[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliFMDCorrAcceptance.cxx

//
// This class contains the acceptance correction due to dead channels 
// 
//
#include "AliFMDCorrAcceptance.h"
#include <TBrowser.h>
#include <TH2D.h>
#include <AliLog.h>
#include <AliForwardUtil.h>
#include <TPad.h>
#include <TCanvas.h>
#include <TLatex.h>
#include <TMath.h>
#include <THStack.h>
#include <TROOT.h>
#include <iostream>

//____________________________________________________________________
AliFMDCorrAcceptance::AliFMDCorrAcceptance()
  : fRingArray(), 
    fCache(0),
    fVertexAxis(0,0,0),
    fHasOverflow(false)
{
  // 
  // Default constructor 
  //
  fRingArray.SetOwner(kTRUE);
  fRingArray.SetName("rings");
  fVertexAxis.SetName("vtxAxis");
  fVertexAxis.SetTitle("v_{z} [cm]");
  
}
//____________________________________________________________________
AliFMDCorrAcceptance::AliFMDCorrAcceptance(const 
					       AliFMDCorrAcceptance& o)
  : TObject(o), 
    fRingArray(o.fRingArray), 
    fCache(o.fCache),
    fVertexAxis(o.fVertexAxis.GetNbins(), o.fVertexAxis.GetXmin(), 
		o.fVertexAxis.GetXmax()),
    fHasOverflow(o.fHasOverflow)
{
  // 
  // Copy constructor 
  // 
  // Parameters:
  //    o Object to copy from 
  //
  fVertexAxis.SetName("vtxAxis");
  fVertexAxis.SetTitle("v_{z} [cm]");
}
//____________________________________________________________________
AliFMDCorrAcceptance::~AliFMDCorrAcceptance()
{
  //
  // Destructor 
  // 
  //
  fRingArray.Clear();
  if (fCache) fCache->Clear();
}
//____________________________________________________________________
AliFMDCorrAcceptance&
AliFMDCorrAcceptance::operator=(const AliFMDCorrAcceptance& o)
{
  // 
  // Assignment operator 
  // 
  // Parameters:
  //    o Object to assign from 
  // 
  // Return:
  //    Reference to this object 
  //
  if (&o == this) return *this;

  fRingArray        = o.fRingArray;
  fCache            = o.fCache;
  fHasOverflow      = o.fHasOverflow;
  SetVertexAxis(o.fVertexAxis);

  return *this;
}
//____________________________________________________________________
TH2D*
AliFMDCorrAcceptance::GetCorrection(UShort_t d, Char_t r, Double_t v) const
{
  // 
  // Get the acceptance correction @f$ a_{r,v}@f$ 
  // 
  // Parameters:
  //    d  Detector number (1-3)
  //    r  Ring identifier (I or O)
  //    v  Primary interaction point @f$z@f$ coordinate
  // 
  // Return:
  //    The correction @f$ a_{r,v}@f$ 
  //
  Int_t b = FindVertexBin(v);
  if (b <= 0) return 0;
  return GetCorrection(d, r, UShort_t(b));
}
//____________________________________________________________________
TH2D*
AliFMDCorrAcceptance::GetCorrection(UShort_t d, Char_t r, UShort_t b) const
{
  // 
  // Get the acceptance correction @f$ a_{r,v}@f$ 
  // 
  // Parameters:
  //    d  Detector number (1-3)
  //    r  Ring identifier (I or O)
  //    b  Bin corresponding to the primary interaction point 
  //           @f$z@f$ coordinate (1 based)
  // 
  // Return:
  //    The correction @f$ a_{r,v}@f$ 
  //
  return static_cast<TH2D*>(GetObject(fRingArray, d, r, b));
}
//____________________________________________________________________
TH1D*
AliFMDCorrAcceptance::GetPhiAcceptance(UShort_t d, Char_t r, Double_t v) const
{
  // 
  // Get the acceptance correction @f$ a_{r,v}@f$ 
  // 
  // Parameters:
  //    d  Detector number (1-3)
  //    r  Ring identifier (I or O)
  //    v  Primary interaction point @f$z@f$ coordinate
  // 
  // Return:
  //    The correction @f$ a_{r,v}@f$ 
  //
  Int_t b = FindVertexBin(v);
  if (b <= 0) return 0;
  return GetPhiAcceptance(d, r, UShort_t(b));
}
//____________________________________________________________________
TH1D*
AliFMDCorrAcceptance::GetPhiAcceptance(UShort_t d, Char_t r, UShort_t b) const
{
  // 
  // Get the acceptance correction @f$ a_{r,v}@f$ 
  // 
  // Parameters:
  //    d  Detector number (1-3)
  //    r  Ring identifier (I or O)
  //    b  Bin corresponding to the primary interaction point 
  //           @f$z@f$ coordinate (1 based)
  // 
  // Return:
  //    The correction @f$ a_{r,v}@f$ 
  //
  if (!fHasOverflow) return 0;
  if (!fCache) FillCache();
  return static_cast<TH1D*>(GetObject(*fCache, d, r, b));
}
  
//____________________________________________________________________
Int_t
AliFMDCorrAcceptance::FindVertexBin(Double_t v) const
{
  // 
  // Find the vertex bin that corresponds to the passed vertex 
  // 
  // Parameters:
  //    vertex The interaction points @f$z@f$-coordinate 
  // 
  // Return:
  //    Vertex bin in @f$[1,N_{\mbox{vertex}}]@f$ or negative if 
  // out of range 
  //
  if (fVertexAxis.GetNbins() <= 0) { 
    AliWarning("No vertex array defined");
    return 0;
  }
  Int_t bin = const_cast<TAxis&>(fVertexAxis).FindBin(v);
  if (bin <= 0 || bin > fVertexAxis.GetNbins()) { 
    AliWarning(Form("vertex %+8.4f out of range [%+8.4f,%+8.4f]",
		    v, fVertexAxis.GetXmin(), fVertexAxis.GetXmax()));
    return 0;
  }
  return bin;
}
//____________________________________________________________________
Int_t
AliFMDCorrAcceptance::GetRingIndex(UShort_t d, Char_t r) const
{
  // Get the index corresponding to the given ring 
  // 
  // Parameters:
  //    d Detector
  //    r Ring 
  // 
  // Return:
  //    Index (0 based) or negative in case of errors
  //
  switch (d) {
  case 1:  return 0;
  case 2:  return (r == 'I' || r == 'i' ? 1 : 2); break;  
  case 3:  return (r == 'I' || r == 'i' ? 3 : 4); break;  

  }
  AliWarning(Form("Index for FMD%d%c not found", d, r));
  return -1;
}
//____________________________________________________________________
TObject*
AliFMDCorrAcceptance::GetObject(const TObjArray& m, UShort_t d, 
				Char_t r, UShort_t b) const
{
  // 
  // Get the object @f$ a_{r,v}@f$ 
  // 
  // Parameters:
  //    m  Mother list
  //    d  Detector number (1-3)
  //    r  Ring identifier (I or O)
  //    b  Bin corresponding to the primary interaction point 
  //           @f$z@f$ coordinate (1 based)
  // 
  // Return:
  //    The correction @f$ a_{r,v}@f$ 
  //
  TObjArray* ringArray = GetRingArray(m, d, r);
  if (!ringArray) return 0;

  if (b <= 0 || b > ringArray->GetEntriesFast()) {
    AliWarning(Form("vertex bin %d out of range [1,%d]", 
		    b, ringArray->GetEntriesFast()));
    return 0;
  }

  TObject* o = ringArray->At(b-1);
  if (o) return o;

  AliWarning(Form("No dead channels map found for FMD%d%c in vertex bin %d",
		    d,r,b));
  return 0;
}
//____________________________________________________________________
TObjArray*
AliFMDCorrAcceptance::GetRingArray(const TObjArray& m, 
				   UShort_t d, Char_t r) const
{
  // 
  // Get the ring array corresponding to the specified ring
  // 
  // Parameters:
  //    d Detector 
  //    r Ring 
  // 
  // Return:
  //    Pointer to ring array, or null in case of problems
  //
  Int_t idx = GetRingIndex(d,r);
  if (idx < 0) return 0;
  
  TObject* o = m.At(idx);
  if (!o) { 
    AliWarning(Form("No array found for FMD%d%c", d, r));
    return 0;
  }

  return static_cast<TObjArray*>(o);
}
//____________________________________________________________________
TObjArray*
AliFMDCorrAcceptance::GetOrMakeRingArray(TObjArray& m, 
					 UShort_t d, Char_t r) const
{
  // 
  // Get the ring array corresponding to the specified ring
  // 
  // Parameters:
  //    d Detector 
  //    r Ring 
  // 
  // Return:
  //    Pointer to ring array, or newly created container 
  //
  Int_t idx = GetRingIndex(d,r);
  if (idx < 0) return 0;
  
  TObject* o = m.At(idx);
  if (!o) { 
    TObjArray* a = new TObjArray(fVertexAxis.GetNbins());
    a->SetName(Form("FMD%d%c", d, r));
    a->SetOwner(kTRUE);
    m.AddAtAndExpand(a, idx);
    return a;
  }

  return static_cast<TObjArray*>(m.At(idx));
}

//____________________________________________________________________
Bool_t
AliFMDCorrAcceptance::SetCorrection(UShort_t d, Char_t r, 
				    UShort_t b, TH2D*  h) 
{
  // 
  // Set the acceptance correction @f$ a_{r,v}(\eta)@f$ 
  // Note, that the object takes ownership of the passed pointer.
  // 
  // Parameters:
  //    d    Detector number (1-3)
  //    r    Ring identifier (I or O)
  //    b    Bin corresponding to the primary interaction point 
  //             @f$z@f$ coordinate  (1 based)
  //    h    @f$ a_{r,v}(\eta)@f$ 
  // 
  // Return:
  //    true if operation succeeded 
  //
  TObjArray* ringArray = GetOrMakeRingArray(fRingArray, d, r);
  if (!ringArray) return false;
  
  if (b <= 0 || b > fVertexAxis.GetNbins()) { 
    AliWarning(Form("Vertex bin %3d out of range [1,%3d]", 
		    b, fVertexAxis.GetNbins()));
    return false;
  }
  h->SetName(Form("FMD%d%c_vtxbin%03d", d, r, b));
  h->SetTitle(Form("Acceptance correction for FMD%d%c "
		   "in vertex bin %d [%+8.4f,%+8.4f]", 
		   d, r, b, fVertexAxis.GetBinLowEdge(b), 
		   fVertexAxis.GetBinUpEdge(b)));
  h->SetXTitle("#eta");
  h->SetYTitle("N_{strips,OK}/N_{strips}");
  h->SetFillStyle(3001);
  h->SetDirectory(0);
  h->SetStats(0);
  ringArray->AddAtAndExpand(h, b-1);
  return kTRUE;
}
//____________________________________________________________________
Bool_t
AliFMDCorrAcceptance::SetCorrection(UShort_t d, Char_t r, 
				    Double_t v, TH2D*  h) 
{
  // 
  // Set the acceptance correction @f$ a_{r,v}(\eta)@f$.
  // Note, that the object takes ownership of the passed pointer.
  // 
  // Parameters:
  //    d    Detector number (1-3)
  //    r    Ring identifier (I or O)
  //    v    Primary interaction point @f$z@f$ coordinate  
  //    h    @f$ a_{r,v}(\eta)@f$ 
  // 
  // Return:
  //    true if operation succeeded 
  //
  Int_t b = FindVertexBin(v);
  if (b <= 0 || b > fVertexAxis.GetNbins()) { 
    AliWarning(Form("Vertex %+8.4f out of range [%+8.4f,%+8.4f]", 
		    v, fVertexAxis.GetXmin(), fVertexAxis.GetXmax()));
    return false;
  }
  return SetCorrection(d, r, UShort_t(b), h);
}

//____________________________________________________________________
void
AliFMDCorrAcceptance::FillCache() const
{
  if (fCache) return;

  fCache = new TObjArray;
  fCache->SetOwner(kTRUE);
  fCache->SetName("cache");

  Int_t nV = fVertexAxis.GetNbins();
  for (UShort_t v = 1; v <= nV; v++) {
    for(UShort_t d = 1; d <= 3;d++) { 
      UShort_t nR = (d == 1 ? 1 : 2);
      for (UShort_t q = 0; q < nR; q++) { 
	Char_t   r  = (q == 0 ? 'I' : 'O');

	TObjArray* a = GetOrMakeRingArray(*fCache, d, r);

	TH2D* corr = GetCorrection(d, r, v);
	if (!corr) continue;

	Int_t nY = corr->GetNbinsY();
	TH1D* h  = corr->ProjectionX("tmp", nY+1, nY+1, "");
	h->SetName(Form("FMD%d%c_vtxbin%03d", d, r, v));
	h->SetTitle(Form("#phi acceptance correction for FMD%d%c "
			   "in vertex bin %d [%+8.4f,%+8.4f]", 
			   d, r, v, fVertexAxis.GetBinLowEdge(v), 
			   fVertexAxis.GetBinUpEdge(v)));
	h->SetXTitle("#eta");
	h->SetYTitle("N_{strips}/N_{strips,OK}");
	h->SetFillStyle(3001);
	h->SetDirectory(0);
	h->SetStats(0);
	a->AddAtAndExpand(h,v-1);

	if (fHasOverflow) continue;

	// Construct the overflow bin from 
	Int_t nX = corr->GetNbinsX();
	for (Int_t eta = 1; eta <= nX; eta++) { 
	  Double_t sum = 0;
	  for (Int_t phi = 1; phi <= nY; phi++) 
	    sum += corr->GetBinContent(eta, phi);
	  if (nY <= 0) continue;
	  h->SetBinContent(eta, nY/sum);
	} // for eta 
      } // for q 
    } // for d 
  } // for v 
}
//____________________________________________________________________
void
AliFMDCorrAcceptance::Browse(TBrowser* b)
{
  // 
  // Browse this object in the browser
  // 
  // Parameters:
  //    b 
  //
  b->Add(&fRingArray);
  if (fCache) b->Add(fCache);
  b->Add(&fVertexAxis);
}
//____________________________________________________________________
void
AliFMDCorrAcceptance::Print(Option_t* option) const
{
  // 
  // Print this object 
  // 
  // Parameters:
  //    option 
  //  
  std::cout << "Acceptance correction due to dead channels" << std::endl;
  fRingArray.Print(option);
  fVertexAxis.Print(option);
}
//____________________________________________________________________
void
AliFMDCorrAcceptance::ls(Option_t* option) const
{
  // 
  // Print this object 
  // 
  // Parameters:
  //    option 
  //  
  TObject::ls(option);
  gROOT->IncreaseDirLevel();
  fVertexAxis.ls(option);
  fRingArray.ls(option);
  gROOT->DecreaseDirLevel();
}

#if 0
namespace {
  void ClearCanvas(TVirtualPad* c)
  {
    c->SetLeftMargin(.1);
    c->SetRightMargin(.05);
    c->SetBottomMargin(.1);
    c->SetTopMargin(.05);
    c->Clear();
  }
}

//____________________________________________________________________
void
AliFMDCorrAcceptance::SaveAs(const Char_t* filename, Option_t* option) const
{
  // 
  // Override to allow saving to a PDF 
  // 
  TString fileName(filename);
  if (!fileName.EndsWith(".pdf")) {
    TObject::SaveAs(fileName, option);
    return;
  }
  
  TVirtualPad* c = new TCanvas(filename, GetTitle(), 800/TMath::Sqrt(2), 800);
  c->SetFillColor(0);
  c->SetBorderSize(0);
  c->SetBorderMode(0);
  c->Print(Form("%s[", filename));

  //__________________________________________________________________
  // Create a title page 
  TLatex* ll = new TLatex(.5,.8, filename);
  ll->SetTextAlign(22);
  ll->SetTextSize(0.03);
  ll->SetNDC();
  ll->Draw();

  TLatex* l = new TLatex(.5,.8, filename);
  l->SetNDC();
  l->SetTextSize(0.03);
  l->SetTextFont(132);
  l->SetTextAlign(12);
  l->DrawLatex(0.2, 0.70, "Acceptance due to dead channels");
  l->SetTextAlign(22);
  l->DrawLatex(0.5, 0.60, "c_{v,r}(#eta,#phi)=#frac{"
	       "#sum active strips#in(#eta,#phi)}{"
	       "#sum strips#in(#eta,#phi)}");
  
  c->Print(filename, "Title:Title page");
  
  //__________________________________________________________________
  // Draw all corrections
  const TAxis& vtxAxis = GetVertexAxis();
  Int_t        nVtx    = vtxAxis.GetNbins();

  // --- Loop over detectors -----------------------------------------
  for (UShort_t d = 1; d <= 3; d++) {
    UShort_t     nQ = (d == 1 ? 1 : 2);
    for (UShort_t q = 0; q < nQ; q++) { 
      Char_t r = (q == 0 ? 'I' : 'O');

      ClearCanvas(c);
      c->Divide(2, (nVtx+1)/2);
      for (UShort_t v=1; v <= nVtx; v++) { 
	TVirtualPad* p = c->cd(v);
	p->SetFillColor(kWhite);
      
	TH2* h2 = GetCorrection(d, r, v);
	if (!h2) { 
	  Warning("DrawCorrAcc", "No correction for r=%c, v=%d", r, v);
	  continue;
	}
	h2->Draw(option);
      }
      c->Print(filename, Form("Title:FMD%d%c", d, r));
    }
  }
  if (HasOverflow()){
    const_cast<AliFMDCorrAcceptance*>(this)->Draw(Form("%s phi", option));
    c->Print(filename, "Title:Phi Acceptance");
  }
  const_cast<AliFMDCorrAcceptance*>(this)->Draw(option);
  c->Print(filename, "Title:Summary");
  c->Print(Form("%s]", filename));
}
//____________________________________________________________________
void
AliFMDCorrAcceptance::Draw(Option_t* option)
{
  //
  // Draw this object 
  // 
  // Parameters: 
  //   option 
  // 
  TString opt(option);
  opt.ToLower();
  Bool_t over = opt.Contains("phi");
  opt.ReplaceAll("phi", "");

  TVirtualPad* c = gPad;
  if (!c) c = new TCanvas(GetName(), GetTitle());
  
  const TAxis& vtxAxis = fVertexAxis;
  Int_t        nVtx    = vtxAxis.GetNbins();
  Int_t        ipad    = 0;
  c->SetLeftMargin(.1);
  c->SetRightMargin(.05);
  c->SetBottomMargin(.1);
  c->SetTopMargin(.05);
  c->Clear();
  c->Divide((nVtx+2)/3, 3, 0, 0);

  // Draw all corrections
  for (UShort_t v = 1; v <= nVtx; v++) { 
    ipad++;
    if (ipad == 1 || ipad == 12) ipad++;

    TVirtualPad* p = c->cd(ipad);
    p->SetFillColor(kWhite);
        
    THStack* stack = new THStack(Form("vtx%02d", v),
				 Form("%+5.1f<v_{z}<%+5.1f",
				      vtxAxis.GetBinLowEdge(v),
				      vtxAxis.GetBinUpEdge(v)));
    for (UShort_t d = 1; d <= 3; d++) {
      UShort_t     nQ = (d == 1 ? 1 : 2);
      for (UShort_t q = 0; q < nQ; q++) { 
	Char_t r = (q == 0 ? 'I' : 'O');
	
	if (over) { 
	  TH1* hp = GetPhiAcceptance(d, r, v);
	  if (!hp) { 
	    Error("", "No phi acceptance at v=%d", v-1);
	    continue;
	  }
	  hp->SetDirectory(0);
	  hp->SetMarkerColor(AliForwardUtil::RingColor(d, r));
	  hp->SetLineColor(AliForwardUtil::RingColor(d, r));
	  hp->SetFillColor(AliForwardUtil::RingColor(d, r));
	  hp->SetFillStyle(3001);
	  // Info("", "Adding phi acceptance plot %d", int(hp->GetEntries()));
	  stack->Add(hp);
	  continue;
	}
	  
	TH2* h1 = GetCorrection(d, r, v);
	if (!h1) { 
	  Warning("Draw", "No correction for r=%c, v=%d", r, v);
	  continue;
	}
	Int_t nY = h1->GetNbinsY();
	TH1* hh = h1->ProjectionX(Form("FMD%d%c", d, r), 1, nY);
	hh->Scale(1. / nY);
	hh->SetDirectory(0);
	hh->SetMarkerColor(AliForwardUtil::RingColor(d, r));
	hh->SetLineColor(AliForwardUtil::RingColor(d, r));
	hh->SetFillColor(AliForwardUtil::RingColor(d, r));
	hh->SetFillStyle(3004);

	stack->Add(hh);
      }
    }
    stack->SetMaximum(1.2);
    stack->Draw(Form("nostack %s", opt.Data()));
  }
}
#endif

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
1298ee54	1	//
8973b4ed	2	// This class contains the acceptance correction due to dead channels
1298ee54	3	//
1298ee54	4	//
8973b4ed	5	#include "AliFMDCorrAcceptance.h"
1298ee54	6	#include <TBrowser.h>
	7	#include <TH2D.h>
	8	#include <AliLog.h>
8449e3e0	9	#include <AliForwardUtil.h>
	10	#include <TPad.h>
	11	#include <TCanvas.h>
	12	#include <TLatex.h>
	13	#include <TMath.h>
	14	#include <THStack.h>
	15	#include <TROOT.h>
1298ee54	16	#include <iostream>
	17
	18	//____________________________________________________________________
8973b4ed	19	AliFMDCorrAcceptance::AliFMDCorrAcceptance()
1298ee54	20	: fRingArray(),
9b5cc785	21	fCache(0),
	22	fVertexAxis(0,0,0),
	23	fHasOverflow(false)
1298ee54	24	{
	25	//
	26	// Default constructor
	27	//
	28	fRingArray.SetOwner(kTRUE);
	29	fRingArray.SetName("rings");
	30	fVertexAxis.SetName("vtxAxis");
	31	fVertexAxis.SetTitle("v_{z} [cm]");
	32
	33	}
	34	//____________________________________________________________________
8973b4ed	35	AliFMDCorrAcceptance::AliFMDCorrAcceptance(const
8973b4ed	36	AliFMDCorrAcceptance& o)
1298ee54	37	: TObject(o),
1298ee54	38	fRingArray(o.fRingArray),
9b5cc785	39	fCache(o.fCache),
1298ee54	40	fVertexAxis(o.fVertexAxis.GetNbins(), o.fVertexAxis.GetXmin(),
9b5cc785	41	o.fVertexAxis.GetXmax()),
9b5cc785	42	fHasOverflow(o.fHasOverflow)
1298ee54	43	{
	44	//
	45	// Copy constructor
	46	//
	47	// Parameters:
	48	// o Object to copy from
	49	//
	50	fVertexAxis.SetName("vtxAxis");
	51	fVertexAxis.SetTitle("v_{z} [cm]");
	52	}
	53	//____________________________________________________________________
8973b4ed	54	AliFMDCorrAcceptance::~AliFMDCorrAcceptance()
1298ee54	55	{
	56	//
	57	// Destructor
	58	//
	59	//
	60	fRingArray.Clear();
9b5cc785	61	if (fCache) fCache->Clear();
1298ee54	62	}
1298ee54	63	//____________________________________________________________________
8973b4ed	64	AliFMDCorrAcceptance&
8973b4ed	65	AliFMDCorrAcceptance::operator=(const AliFMDCorrAcceptance& o)
1298ee54	66	{
	67	//
	68	// Assignment operator
	69	//
	70	// Parameters:
	71	// o Object to assign from
	72	//
	73	// Return:
	74	// Reference to this object
	75	//
73b32206	76	if (&o == this) return *this;
73b32206	77
1298ee54	78	fRingArray = o.fRingArray;
9b5cc785	79	fCache = o.fCache;
9b5cc785	80	fHasOverflow = o.fHasOverflow;
1298ee54	81	SetVertexAxis(o.fVertexAxis);
	82
	83	return *this;
	84	}
	85	//____________________________________________________________________
	86	TH2D*
8973b4ed	87	AliFMDCorrAcceptance::GetCorrection(UShort_t d, Char_t r, Double_t v) const
1298ee54	88	{
1298ee54	89	//
8973b4ed	90	// Get the acceptance correction @f$ a_{r,v}@f$
1298ee54	91	//
	92	// Parameters:
	93	// d Detector number (1-3)
	94	// r Ring identifier (I or O)
	95	// v Primary interaction point @f$z@f$ coordinate
	96	//
	97	// Return:
8973b4ed	98	// The correction @f$ a_{r,v}@f$
1298ee54	99	//
	100	Int_t b = FindVertexBin(v);
	101	if (b <= 0) return 0;
	102	return GetCorrection(d, r, UShort_t(b));
	103	}
	104	//____________________________________________________________________
	105	TH2D*
8973b4ed	106	AliFMDCorrAcceptance::GetCorrection(UShort_t d, Char_t r, UShort_t b) const
1298ee54	107	{
1298ee54	108	//
8973b4ed	109	// Get the acceptance correction @f$ a_{r,v}@f$
1298ee54	110	//
	111	// Parameters:
	112	// d Detector number (1-3)
	113	// r Ring identifier (I or O)
	114	// b Bin corresponding to the primary interaction point
	115	// @f$z@f$ coordinate (1 based)
	116	//
	117	// Return:
8973b4ed	118	// The correction @f$ a_{r,v}@f$
1298ee54	119	//
9b5cc785	120	return static_cast<TH2D*>(GetObject(fRingArray, d, r, b));
	121	}
	122	//____________________________________________________________________
	123	TH1D*
	124	AliFMDCorrAcceptance::GetPhiAcceptance(UShort_t d, Char_t r, Double_t v) const
	125	{
	126	//
	127	// Get the acceptance correction @f$ a_{r,v}@f$
	128	//
	129	// Parameters:
	130	// d Detector number (1-3)
	131	// r Ring identifier (I or O)
	132	// v Primary interaction point @f$z@f$ coordinate
	133	//
	134	// Return:
	135	// The correction @f$ a_{r,v}@f$
	136	//
	137	Int_t b = FindVertexBin(v);
	138	if (b <= 0) return 0;
	139	return GetPhiAcceptance(d, r, UShort_t(b));
	140	}
	141	//____________________________________________________________________
	142	TH1D*
	143	AliFMDCorrAcceptance::GetPhiAcceptance(UShort_t d, Char_t r, UShort_t b) const
	144	{
	145	//
	146	// Get the acceptance correction @f$ a_{r,v}@f$
	147	//
	148	// Parameters:
	149	// d Detector number (1-3)
	150	// r Ring identifier (I or O)
	151	// b Bin corresponding to the primary interaction point
	152	// @f$z@f$ coordinate (1 based)
	153	//
	154	// Return:
	155	// The correction @f$ a_{r,v}@f$
	156	//
	157	if (!fHasOverflow) return 0;
	158	if (!fCache) FillCache();
	159	return static_cast<TH1D>(GetObject(fCache, d, r, b));
1298ee54	160	}
	161
	162	//____________________________________________________________________
	163	Int_t
8973b4ed	164	AliFMDCorrAcceptance::FindVertexBin(Double_t v) const
1298ee54	165	{
	166	//
	167	// Find the vertex bin that corresponds to the passed vertex
	168	//
	169	// Parameters:
	170	// vertex The interaction points @f$z@f$-coordinate
	171	//
	172	// Return:
	173	// Vertex bin in @f$[1,N_{\mbox{vertex}}]@f$ or negative if
	174	// out of range
	175	//
	176	if (fVertexAxis.GetNbins() <= 0) {
	177	AliWarning("No vertex array defined");
	178	return 0;
	179	}
	180	Int_t bin = const_cast<TAxis&>(fVertexAxis).FindBin(v);
	181	if (bin <= 0 \|\| bin > fVertexAxis.GetNbins()) {
	182	AliWarning(Form("vertex %+8.4f out of range [%+8.4f,%+8.4f]",
	183	v, fVertexAxis.GetXmin(), fVertexAxis.GetXmax()));
	184	return 0;
	185	}
	186	return bin;
	187	}
	188	//____________________________________________________________________
	189	Int_t
8973b4ed	190	AliFMDCorrAcceptance::GetRingIndex(UShort_t d, Char_t r) const
1298ee54	191	{
1298ee54	192	// Get the index corresponding to the given ring
	193	//
	194	// Parameters:
	195	// d Detector
	196	// r Ring
	197	//
	198	// Return:
	199	// Index (0 based) or negative in case of errors
	200	//
	201	switch (d) {
	202	case 1: return 0;
	203	case 2: return (r == 'I' \|\| r == 'i' ? 1 : 2); break;
	204	case 3: return (r == 'I' \|\| r == 'i' ? 3 : 4); break;
9b5cc785	205
1298ee54	206	}
	207	AliWarning(Form("Index for FMD%d%c not found", d, r));
	208	return -1;
	209	}
	210	//____________________________________________________________________
9b5cc785	211	TObject*
	212	AliFMDCorrAcceptance::GetObject(const TObjArray& m, UShort_t d,
	213	Char_t r, UShort_t b) const
	214	{
	215	//
	216	// Get the object @f$ a_{r,v}@f$
	217	//
	218	// Parameters:
	219	// m Mother list
	220	// d Detector number (1-3)
	221	// r Ring identifier (I or O)
	222	// b Bin corresponding to the primary interaction point
	223	// @f$z@f$ coordinate (1 based)
	224	//
	225	// Return:
	226	// The correction @f$ a_{r,v}@f$
	227	//
	228	TObjArray* ringArray = GetRingArray(m, d, r);
	229	if (!ringArray) return 0;
	230
	231	if (b <= 0 \|\| b > ringArray->GetEntriesFast()) {
	232	AliWarning(Form("vertex bin %d out of range [1,%d]",
	233	b, ringArray->GetEntriesFast()));
	234	return 0;
	235	}
	236
	237	TObject* o = ringArray->At(b-1);
	238	if (o) return o;
	239
	240	AliWarning(Form("No dead channels map found for FMD%d%c in vertex bin %d",
	241	d,r,b));
	242	return 0;
	243	}
	244	//____________________________________________________________________
1298ee54	245	TObjArray*
9b5cc785	246	AliFMDCorrAcceptance::GetRingArray(const TObjArray& m,
9b5cc785	247	UShort_t d, Char_t r) const
1298ee54	248	{
	249	//
	250	// Get the ring array corresponding to the specified ring
	251	//
	252	// Parameters:
	253	// d Detector
	254	// r Ring
	255	//
	256	// Return:
	257	// Pointer to ring array, or null in case of problems
	258	//
	259	Int_t idx = GetRingIndex(d,r);
	260	if (idx < 0) return 0;
	261
9b5cc785	262	TObject* o = m.At(idx);
1298ee54	263	if (!o) {
	264	AliWarning(Form("No array found for FMD%d%c", d, r));
	265	return 0;
	266	}
	267
	268	return static_cast<TObjArray*>(o);
	269	}
	270	//____________________________________________________________________
	271	TObjArray*
9b5cc785	272	AliFMDCorrAcceptance::GetOrMakeRingArray(TObjArray& m,
9b5cc785	273	UShort_t d, Char_t r) const
1298ee54	274	{
	275	//
	276	// Get the ring array corresponding to the specified ring
	277	//
	278	// Parameters:
	279	// d Detector
	280	// r Ring
	281	//
	282	// Return:
	283	// Pointer to ring array, or newly created container
	284	//
	285	Int_t idx = GetRingIndex(d,r);
	286	if (idx < 0) return 0;
	287
9b5cc785	288	TObject* o = m.At(idx);
1298ee54	289	if (!o) {
	290	TObjArray* a = new TObjArray(fVertexAxis.GetNbins());
	291	a->SetName(Form("FMD%d%c", d, r));
	292	a->SetOwner(kTRUE);
9b5cc785	293	m.AddAtAndExpand(a, idx);
1298ee54	294	return a;
	295	}
	296
9b5cc785	297	return static_cast<TObjArray*>(m.At(idx));
1298ee54	298	}
	299
	300	//____________________________________________________________________
	301	Bool_t
8973b4ed	302	AliFMDCorrAcceptance::SetCorrection(UShort_t d, Char_t r,
8973b4ed	303	UShort_t b, TH2D* h)
1298ee54	304	{
1298ee54	305	//
8973b4ed	306	// Set the acceptance correction @f$ a_{r,v}(\eta)@f$
1298ee54	307	// Note, that the object takes ownership of the passed pointer.
	308	//
	309	// Parameters:
	310	// d Detector number (1-3)
	311	// r Ring identifier (I or O)
	312	// b Bin corresponding to the primary interaction point
	313	// @f$z@f$ coordinate (1 based)
8973b4ed	314	// h @f$ a_{r,v}(\eta)@f$
1298ee54	315	//
	316	// Return:
	317	// true if operation succeeded
	318	//
9b5cc785	319	TObjArray* ringArray = GetOrMakeRingArray(fRingArray, d, r);
1298ee54	320	if (!ringArray) return false;
	321
	322	if (b <= 0 \|\| b > fVertexAxis.GetNbins()) {
	323	AliWarning(Form("Vertex bin %3d out of range [1,%3d]",
	324	b, fVertexAxis.GetNbins()));
	325	return false;
	326	}
	327	h->SetName(Form("FMD%d%c_vtxbin%03d", d, r, b));
8973b4ed	328	h->SetTitle(Form("Acceptance correction for FMD%d%c "
1298ee54	329	"in vertex bin %d [%+8.4f,%+8.4f]",
	330	d, r, b, fVertexAxis.GetBinLowEdge(b),
	331	fVertexAxis.GetBinUpEdge(b)));
	332	h->SetXTitle("#eta");
9b5cc785	333	h->SetYTitle("N_{strips,OK}/N_{strips}");
1298ee54	334	h->SetFillStyle(3001);
	335	h->SetDirectory(0);
	336	h->SetStats(0);
	337	ringArray->AddAtAndExpand(h, b-1);
	338	return kTRUE;
	339	}
	340	//____________________________________________________________________
	341	Bool_t
8973b4ed	342	AliFMDCorrAcceptance::SetCorrection(UShort_t d, Char_t r,
8973b4ed	343	Double_t v, TH2D* h)
1298ee54	344	{
1298ee54	345	//
8973b4ed	346	// Set the acceptance correction @f$ a_{r,v}(\eta)@f$.
1298ee54	347	// Note, that the object takes ownership of the passed pointer.
	348	//
	349	// Parameters:
	350	// d Detector number (1-3)
	351	// r Ring identifier (I or O)
	352	// v Primary interaction point @f$z@f$ coordinate
8973b4ed	353	// h @f$ a_{r,v}(\eta)@f$
1298ee54	354	//
	355	// Return:
	356	// true if operation succeeded
	357	//
	358	Int_t b = FindVertexBin(v);
	359	if (b <= 0 \|\| b > fVertexAxis.GetNbins()) {
	360	AliWarning(Form("Vertex %+8.4f out of range [%+8.4f,%+8.4f]",
	361	v, fVertexAxis.GetXmin(), fVertexAxis.GetXmax()));
	362	return false;
	363	}
	364	return SetCorrection(d, r, UShort_t(b), h);
	365	}
9b5cc785	366
	367	//____________________________________________________________________
	368	void
	369	AliFMDCorrAcceptance::FillCache() const
	370	{
	371	if (fCache) return;
	372
	373	fCache = new TObjArray;
	374	fCache->SetOwner(kTRUE);
	375	fCache->SetName("cache");
	376
	377	Int_t nV = fVertexAxis.GetNbins();
	378	for (UShort_t v = 1; v <= nV; v++) {
	379	for(UShort_t d = 1; d <= 3;d++) {
	380	UShort_t nR = (d == 1 ? 1 : 2);
	381	for (UShort_t q = 0; q < nR; q++) {
	382	Char_t r = (q == 0 ? 'I' : 'O');
	383
	384	TObjArray* a = GetOrMakeRingArray(*fCache, d, r);
	385
	386	TH2D* corr = GetCorrection(d, r, v);
	387	if (!corr) continue;
	388
	389	Int_t nY = corr->GetNbinsY();
	390	TH1D* h = corr->ProjectionX("tmp", nY+1, nY+1, "");
	391	h->SetName(Form("FMD%d%c_vtxbin%03d", d, r, v));
	392	h->SetTitle(Form("#phi acceptance correction for FMD%d%c "
	393	"in vertex bin %d [%+8.4f,%+8.4f]",
	394	d, r, v, fVertexAxis.GetBinLowEdge(v),
	395	fVertexAxis.GetBinUpEdge(v)));
	396	h->SetXTitle("#eta");
	397	h->SetYTitle("N_{strips}/N_{strips,OK}");
	398	h->SetFillStyle(3001);
	399	h->SetDirectory(0);
	400	h->SetStats(0);
	401	a->AddAtAndExpand(h,v-1);
	402
	403	if (fHasOverflow) continue;
	404
	405	// Construct the overflow bin from
	406	Int_t nX = corr->GetNbinsX();
	407	for (Int_t eta = 1; eta <= nX; eta++) {
	408	Double_t sum = 0;
	409	for (Int_t phi = 1; phi <= nY; phi++)
	410	sum += corr->GetBinContent(eta, phi);
	411	if (nY <= 0) continue;
	412	h->SetBinContent(eta, nY/sum);
	413	} // for eta
	414	} // for q
	415	} // for d
	416	} // for v
	417	}
1298ee54	418	//____________________________________________________________________
1298ee54	419	void
8973b4ed	420	AliFMDCorrAcceptance::Browse(TBrowser* b)
1298ee54	421	{
	422	//
	423	// Browse this object in the browser
	424	//
	425	// Parameters:
	426	// b
	427	//
	428	b->Add(&fRingArray);
9b5cc785	429	if (fCache) b->Add(fCache);
1298ee54	430	b->Add(&fVertexAxis);
	431	}
	432	//____________________________________________________________________
	433	void
8973b4ed	434	AliFMDCorrAcceptance::Print(Option_t* option) const
1298ee54	435	{
	436	//
	437	// Print this object
	438	//
	439	// Parameters:
	440	// option
	441	//
8973b4ed	442	std::cout << "Acceptance correction due to dead channels" << std::endl;
1298ee54	443	fRingArray.Print(option);
	444	fVertexAxis.Print(option);
	445	}
8449e3e0	446	//____________________________________________________________________
	447	void
	448	AliFMDCorrAcceptance::ls(Option_t* option) const
	449	{
	450	//
	451	// Print this object
	452	//
	453	// Parameters:
	454	// option
	455	//
	456	TObject::ls(option);
	457	gROOT->IncreaseDirLevel();
	458	fVertexAxis.ls(option);
	459	fRingArray.ls(option);
	460	gROOT->DecreaseDirLevel();
	461	}
	462
	463	#if 0
	464	namespace {
	465	void ClearCanvas(TVirtualPad* c)
	466	{
	467	c->SetLeftMargin(.1);
	468	c->SetRightMargin(.05);
	469	c->SetBottomMargin(.1);
	470	c->SetTopMargin(.05);
	471	c->Clear();
	472	}
	473	}
	474
	475	//____________________________________________________________________
	476	void
	477	AliFMDCorrAcceptance::SaveAs(const Char_t* filename, Option_t* option) const
	478	{
	479	//
	480	// Override to allow saving to a PDF
	481	//
	482	TString fileName(filename);
	483	if (!fileName.EndsWith(".pdf")) {
	484	TObject::SaveAs(fileName, option);
	485	return;
	486	}
	487
	488	TVirtualPad* c = new TCanvas(filename, GetTitle(), 800/TMath::Sqrt(2), 800);
	489	c->SetFillColor(0);
	490	c->SetBorderSize(0);
	491	c->SetBorderMode(0);
	492	c->Print(Form("%s[", filename));
	493
	494	//__________________________________________________________________
	495	// Create a title page
	496	TLatex* ll = new TLatex(.5,.8, filename);
	497	ll->SetTextAlign(22);
	498	ll->SetTextSize(0.03);
	499	ll->SetNDC();
	500	ll->Draw();
	501
	502	TLatex* l = new TLatex(.5,.8, filename);
	503	l->SetNDC();
	504	l->SetTextSize(0.03);
	505	l->SetTextFont(132);
	506	l->SetTextAlign(12);
	507	l->DrawLatex(0.2, 0.70, "Acceptance due to dead channels");
	508	l->SetTextAlign(22);
	509	l->DrawLatex(0.5, 0.60, "c_{v,r}(#eta,#phi)=#frac{"
510	"#sum active strips#in(#eta,#phi)}{"
511	"#sum strips#in(#eta,#phi)}");
512
513	c->Print(filename, "Title:Title page");
514
515	//__________________________________________________________________
516	// Draw all corrections
517	const TAxis& vtxAxis = GetVertexAxis();
518	Int_t nVtx = vtxAxis.GetNbins();
519
520	// --- Loop over detectors -----------------------------------------
521	for (UShort_t d = 1; d <= 3; d++) {
522	UShort_t nQ = (d == 1 ? 1 : 2);
523	for (UShort_t q = 0; q < nQ; q++) {
524	Char_t r = (q == 0 ? 'I' : 'O');
525
526	ClearCanvas(c);
527	c->Divide(2, (nVtx+1)/2);
528	for (UShort_t v=1; v <= nVtx; v++) {
529	TVirtualPad* p = c->cd(v);
530	p->SetFillColor(kWhite);
531
532	TH2* h2 = GetCorrection(d, r, v);
533	if (!h2) {
534	Warning("DrawCorrAcc", "No correction for r=%c, v=%d", r, v);
535	continue;
536	}
537	h2->Draw(option);
538	}
539	c->Print(filename, Form("Title:FMD%d%c", d, r));
540	}
541	}
542	if (HasOverflow()){
543	const_cast<AliFMDCorrAcceptance*>(this)->Draw(Form("%s phi", option));
544	c->Print(filename, "Title:Phi Acceptance");
545	}
546	const_cast<AliFMDCorrAcceptance*>(this)->Draw(option);
547	c->Print(filename, "Title:Summary");
548	c->Print(Form("%s]", filename));
549	}
550	//____________________________________________________________________
551	void
552	AliFMDCorrAcceptance::Draw(Option_t* option)
553	{
554	//
555	// Draw this object
556	//
557	// Parameters:
558	// option
559	//
560	TString opt(option);
561	opt.ToLower();
562	Bool_t over = opt.Contains("phi");
563	opt.ReplaceAll("phi", "");
564
565	TVirtualPad* c = gPad;
566	if (!c) c = new TCanvas(GetName(), GetTitle());
567
568	const TAxis& vtxAxis = fVertexAxis;
569	Int_t nVtx = vtxAxis.GetNbins();
570	Int_t ipad = 0;
571	c->SetLeftMargin(.1);
572	c->SetRightMargin(.05);
573	c->SetBottomMargin(.1);
574	c->SetTopMargin(.05);
575	c->Clear();
576	c->Divide((nVtx+2)/3, 3, 0, 0);
577
578	// Draw all corrections
579	for (UShort_t v = 1; v <= nVtx; v++) {
580	ipad++;
581	if (ipad == 1 \|\| ipad == 12) ipad++;
582
583	TVirtualPad* p = c->cd(ipad);
584	p->SetFillColor(kWhite);
585
586	THStack* stack = new THStack(Form("vtx%02d", v),
587	Form("%+5.1f<v_{z}<%+5.1f",
588	vtxAxis.GetBinLowEdge(v),
589	vtxAxis.GetBinUpEdge(v)));
590	for (UShort_t d = 1; d <= 3; d++) {
591	UShort_t nQ = (d == 1 ? 1 : 2);
592	for (UShort_t q = 0; q < nQ; q++) {
593	Char_t r = (q == 0 ? 'I' : 'O');
594
595	if (over) {
596	TH1* hp = GetPhiAcceptance(d, r, v);
597	if (!hp) {
598	Error("", "No phi acceptance at v=%d", v-1);
599	continue;
600	}
601	hp->SetDirectory(0);
602	hp->SetMarkerColor(AliForwardUtil::RingColor(d, r));
603	hp->SetLineColor(AliForwardUtil::RingColor(d, r));
604	hp->SetFillColor(AliForwardUtil::RingColor(d, r));
605	hp->SetFillStyle(3001);
606	// Info("", "Adding phi acceptance plot %d", int(hp->GetEntries()));
607	stack->Add(hp);
608	continue;
609	}
610
611	TH2* h1 = GetCorrection(d, r, v);
612	if (!h1) {
613	Warning("Draw", "No correction for r=%c, v=%d", r, v);
614	continue;
615	}
616	Int_t nY = h1->GetNbinsY();
617	TH1* hh = h1->ProjectionX(Form("FMD%d%c", d, r), 1, nY);
618	hh->Scale(1. / nY);
619	hh->SetDirectory(0);
620	hh->SetMarkerColor(AliForwardUtil::RingColor(d, r));
621	hh->SetLineColor(AliForwardUtil::RingColor(d, r));
622	hh->SetFillColor(AliForwardUtil::RingColor(d, r));
623	hh->SetFillStyle(3004);
624
625	stack->Add(hh);
626	}
627	}
628	stack->SetMaximum(1.2);
629	stack->Draw(Form("nostack %s", opt.Data()));
630	}
631	}
632	#endif
633
1298ee54	634	//____________________________________________________________________
	635	//
	636	// EOF
	637	//