[u/mrichter/AliRoot.git] / FMD / AliFMDPattern.cxx

/**************************************************************************
 * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */
/** @file    AliFMDPattern.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:39:09 2006
    @brief   FMD 2D Event display 
*/
//___________________________________________________________________
//
// The classes defined here, are utility classes for reading in data
// for the FMD.  They are  put in a seperate library to not polute the
// normal libraries.  The classes are intended to be used as base
// classes for customized class that do some sort of analysis on the
// various types of data produced by the FMD. 
//
// Latest changes by Christian Holm Christensen
//

// #include <iostream>

// #include <TApplication.h>
// #include <TButton.h>
#include <TCanvas.h>
#include <TH2F.h>
#include <TMath.h>
#include <TPad.h>
#include <TRandom.h>
// #include <TSlider.h>
#include <TStyle.h>
// #include <TSystem.h>
#include <TVector2.h>
// #include <TView.h>
#include <TGraph.h>
#include "AliFMDPattern.h"	// ALIFMDDISPLAY_H
#include "AliFMDGeometry.h"	// ALIFMDGEOMETRY_H
//#include "AliFMDParameters.h"	// ALIFMDPARAMETERS_H
#include "AliFMDRing.h"
// #include "AliFMDDetector.h"
#include "AliFMDHit.h"
// #include <AliLog.h>
#include "AliFMDDebug.h" // Better debug macros
class AliFMDDetector;

//____________________________________________________________________
ClassImp(AliFMDPattern)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDPattern::AliFMDPatternDetector::AliFMDPatternDetector(UShort_t id) 
  : fId(id),
    fCounts(0), 
    fGraphs(0), 
    fFrame(0), 
    fInners(10), 
    fOuters(id == 1 ? 0 : 20)
{
  // CTOR 
  // 
  // Parameters: 
  // 
  //   ID 	Identifier 
}

//____________________________________________________________________
AliFMDPattern::AliFMDPatternDetector::~AliFMDPatternDetector()
{
  // DTOR 
  // Destructor - 
  // deletes mother frame 
  if (fFrame) delete fFrame;
}

//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::DrawShape(TObjArray& a) 
{
  // Draw all shapes. 
  // 
  // Paramters 
  // 
  //	a	Array of shapes 
  //
  TIter next(&a);
  TGraph* g = 0;
  while ((g = static_cast<TGraph*>(next()))) {
    g->DrawClone("f same");
    g->DrawClone("l same");
  }
}

//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::CopyShapes(TObjArray& src, 
						 TObjArray& dest, 
						 Double_t ang, 
						 Double_t fx, 
						 Double_t fy)
{
  TIter     next(&src);
  TGraph*   g = 0;
  while ((g = static_cast<TGraph*>(next()))) { 
    TGraph* gg = new TGraph(*g);
    Double_t* x  = gg->GetX();
    Double_t* y  = gg->GetY();
    for (Int_t i = 0; i < gg->GetN(); i++) { 
      Float_t xx = x[i] * TMath::Cos(ang) - y[i] * TMath::Sin(ang);
      Float_t yy = x[i] * TMath::Sin(ang) + y[i] * TMath::Cos(ang);
      gg->SetPoint(i, fx * xx, fy * yy);
    }
    gg->SetFillStyle(g->GetFillStyle());
    gg->SetFillColor(g->GetFillColor());
    gg->SetLineStyle(g->GetLineStyle());
    gg->SetLineColor(g->GetLineColor());
    gg->SetLineWidth(g->GetLineWidth());
    gg->SetMarkerStyle(g->GetMarkerStyle());
    gg->SetMarkerColor(g->GetMarkerColor());
    gg->SetMarkerSize(g->GetMarkerSize());
    TString name(g->GetName());
    name.ReplaceAll("X", Form("%d",fId));
    gg->SetName(name.Data());
    TString title(g->GetTitle());
    title.ReplaceAll("X", Form("%d",fId));
    gg->SetTitle(title.Data());
    dest.Add(gg);
  }
  dest.SetOwner();
}

//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::Begin(Int_t      nlevel, 
					    Double_t   r, 
					    TObjArray& inners, 
					    TObjArray& outers)
{
  // Start of a run. 
  // 
  // Parameters 
  // 
  //	nlevel		Number of levels 
  //    r		Radius 
  //	inners		Array of inner shapes 
  //	outers		Array of outer shapes 
  //

  // To make code-checker shut up
  TStyle* style = gStyle;  
  if (nlevel < 1) nlevel = style->GetNumberOfColors();
  fCounts.Set(nlevel);
  Double_t rr = 1.05 * r;
  if (!fFrame) {
    // The code-checker thinks this is not using the declaration of
    // TH2F - what a morron!   
    fFrame = new TH2F(Form("fmd%dFrame", fId), Form("FMD%d", fId), 
		      100, -rr, rr, 100, -rr, rr);
    fFrame->SetStats(kFALSE);
    fFrame->Draw();
  }
  Double_t ang = (fId == 1 ? -TMath::Pi() / 2 : 0);
  Double_t fx  = (fId == 3 ? -1               : 1); // Flip around Y
  Double_t fy  = (fId == 1 ?  1               : 1); // Flip around X
  
  CopyShapes(inners, fInners, ang, fx, fy);
  DrawShape(fInners);
  if (fId != 1) { 
    CopyShapes(outers, fOuters, ang, fx, fy);
    DrawShape(fOuters);
  }

  for (Int_t i = 0; i < nlevel; i++) { 
    TGraph* g = new TGraph;
    Int_t idx = Int_t(Float_t(i) / nlevel * style->GetNumberOfColors());
    Int_t col = style->GetColorPalette(idx);
    g->SetName(Form("FMD%d_L%02d", fId, i));
    g->SetMarkerColor(col);
    g->SetLineColor(col);
    g->SetFillColor(col);
    g->SetMarkerSize(i * .2 + .2);
    g->SetMarkerStyle(2);
    g->SetEditable(kFALSE);
    g->Draw("same p");
    fGraphs.AddAtAndExpand(g, i);
  }
  // TIter   next(&fGraphs);
}

//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::Clear() 
{
  // Clear this display.  
  // Simply reset counters to zero. 
  // Avoid deleting memory. 
  fCounts.Reset(0);
}

//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::End()
{
  // Called when displaying the data.  
  // Simply resets number of points at each level to 
  // the seen number of hits at that level. 
  // Avoid deleting memory. 
  TIter   next(&fGraphs);
  TGraph* g = 0;
  Int_t   i = 0;
  while ((g = static_cast<TGraph*>(next()))) { 
    Int_t cnt = fCounts[i++];
    if (cnt > 0) { 
      g->Set(cnt);
      g->SetMarkerSize(i * .2 + .2);
    }
    else {
      g->SetPoint(0,0,0);
      g->SetMarkerSize(0);
    }
  }
  
}
//____________________________________________________________________
void
AliFMDPattern::AliFMDPatternDetector::AddMarker(Double_t x, 
						Double_t y, 
						Float_t  s, 
						Float_t  max)
{
  // Add a marker at (X,Y,Z).  The marker color and size is chosen
  // relative to the MAX argument. 
  // 
  // Parameters 
  // 
  //	X,Y,Z		Coordiantes 
  //	MAX		Maximum value. 
  // 
  /** Sigh, for some odd reason, the code-checker does not recognise
      this a usage of the TMath namespace declaration! Idiot */
  Int_t i = TMath::Min(Int_t(fCounts.fN * s / max),  
		       Int_t(fGraphs.GetEntries()-1));
  TGraph* g = static_cast<TGraph*>(fGraphs.At(i));
  if (!g) return;
  g->SetPoint(fCounts[i]++, x, y);
}


//____________________________________________________________________
AliFMDPattern::AliFMDPattern(const char* gAliceFile)
  : AliFMDDisplay(kTRUE, gAliceFile),
    fInners(0), 
    fOuters(0),
    fInnerMax(0), 
    fOuterMax(0),
    fFMD1Pad(0),
    fFMD1(1),
    fFMD2Pad(0),
    fFMD2(2),
    fFMD3Pad(0),
    fFMD3(3),
    fSummary(0),
    fEvent(.1, .8, "Event #"),
    fFMD1Sum(.2, .7, "# in FMD1: "),
    fFMD2Sum(.2, .6, "# in FMD2: "),
    fFMD3Sum(.2, .5, "# in FMD3: "),
    fLine(.15, .47, .85, .47),
    fTotal(.2, .35, "Total:   ")
{
  // Constructor. 
  // 
  // Parameters 
  // 
  //   gAliceFile	The galice.root file to use - if any. 
  // 

  SetName("AliFMDPattern");
  SetName("2D display of FMD data");
  
  // RemoveLoad(kGeometry);
  fEvent.SetBit(TLatex::kTextNDC);
  fFMD1Sum.SetBit(TLatex::kTextNDC);
  fFMD2Sum.SetBit(TLatex::kTextNDC);
  fFMD3Sum.SetBit(TLatex::kTextNDC);
  fLine.SetBit(TLine::kLineNDC);
  fTotal.SetBit(TLatex::kTextNDC);
}

//____________________________________________________________________
AliFMDPattern::~AliFMDPattern()
{
  // DTOR 
  // Free all allocated shapes. 
  // note, that most members are real objects, so we do not need to
  // deal with them here. 
  fInners.Delete();
  fOuters.Delete();
}

    
//____________________________________________________________________
Bool_t 
AliFMDPattern::Init()
{
  // Initialize.  Get transforms and such, 
  if (!AliFMDInput::Init()) return kFALSE;
  AliFMDGeometry* geom = AliFMDGeometry::Instance();
  if (!geom) return kFALSE;
  geom->Init();
  geom->InitTransformations();
  
  Char_t rs[] = { 'I' , 'O', '\0' };
  Char_t *r   = rs;
  do {
    AliFMDRing* ring = geom->GetRing(*r);
    if (!ring) continue;
    const TObjArray& vs = ring->GetVerticies();
    TObjArray&       gs = (*r == 'I' ? fInners   : fOuters);
    Float_t&         mr = (*r == 'I' ? fInnerMax : fOuterMax);
    Int_t            nm = ring->GetNModules();
    AliFMDDebug(1, ("Making %d modules for %c", nm, *r));
    for (Int_t m = 0; m < nm; m++) {
      Int_t          nv = vs.GetEntries();
      Double_t       a  = TMath::Pi() / 180 * (m * 2 + 1) * ring->GetTheta();
      TGraph*        g  = new TGraph(nv+1);
      Double_t       x0 = 0, y0 = 0;
      gs.AddAtAndExpand(g, m);
      for (Int_t c = 0; c < nv; c++) {
	TVector2* v = static_cast<TVector2*>(vs.At(c));
	mr          = TMath::Max(mr, Float_t(v->Mod()));
	TVector2  w(v->Rotate(a));
	if (c == 0) { x0 = w.X(); y0 = w.Y(); }
	g->SetPoint(c, w.X(), w.Y());
      }
      g->SetName(Form("FMDX%c_%02d%02d", *r, 2*m,2*m+1));
      g->SetTitle(Form("FMDX%c, sectors %d and %d", *r, 2*m,2*m+1));
      g->SetPoint(nv, x0, y0);
      g->SetFillColor((*rs == 'I' ? 
		       (m % 2 == 0 ? 18 : 17) :
		       (m % 2 == 0 ? 20 : 23)));
      g->SetFillStyle(3001);
      g->SetLineColor(1);
      g->SetLineWidth(1);
      g->SetLineStyle(2);
    }
  } while (*(++r));
    
  return kTRUE;
}

//____________________________________________________________________
Bool_t 
AliFMDPattern::Begin(Int_t event) 
{
  // Called at the begining of an event. 
  // 
  // Parameters 
  //
  //	EVENT		The event number 
  // 
  MakeAux();
  if (!fCanvas) {
    const char* which[] = { "Continue", "Start", "Pause", "Redisplay", 0 };
    MakeCanvas(which);
    
    AliFMDGeometry* geom = AliFMDGeometry::Instance();
    // AliFMDDetector* det;
    if ((/* det = */ geom->GetDetector(1))) {
      fPad->cd();
      fFMD1Pad = new TPad("FMD1", "FMD1", 0.0, 0.50, 0.5, 1.0, 0, 0);
      fFMD1Pad->Draw();
      fFMD1Pad->cd();
      fFMD1.Begin(-1, fInnerMax, fInners, fOuters);
    }
    if ((/* det = */ geom->GetDetector(2))) {
      fPad->cd();
      fFMD2Pad = new TPad("FMD2", "FMD2", 0.5, 0.50, 1.0, 1.0, 0, 0);
      fFMD2Pad->Draw();
      fFMD2Pad->cd();
      fFMD2.Begin(-1, fOuterMax, fInners, fOuters);
    }
    if ((/* det = */ geom->GetDetector(3))) {
      fPad->cd();
      fFMD3Pad = new TPad("FMD3", "FMD3", 0.0, 0.0, .5, .5, 0, 0);
      fFMD3Pad->Draw();
      fFMD3Pad->cd();
      fFMD3.Begin(-1, fOuterMax, fInners, fOuters);
    }
    fPad->cd();
    fSummary = new TPad("display", "Display", 0.5, 0.0, 1.0, 0.5, 0, 0);
    fSummary->Draw();
    fSummary->cd();
    fEvent.Draw();
    fFMD1Sum.Draw();
    fFMD2Sum.Draw();
    fFMD3Sum.Draw();
    fLine.Draw();
    fTotal.Draw();
  }
  fEvent.SetTitle(Form("Event # %6d", event));

  fCanvas->Modified();
  fCanvas->Update();
  fCanvas->cd();
  fFMD1.Clear();
  fFMD2.Clear();
  fFMD3.Clear();
  return AliFMDInput::Begin(event);
}

//____________________________________________________________________
void
AliFMDPattern::Redisplay()
{
  // Redraw the displayu 
  fFMD1.Clear();
  fFMD2.Clear();
  fFMD3.Clear();
  AliFMDDisplay::Redisplay();
}

//____________________________________________________________________
void
AliFMDPattern::AtEnd()
{
  // Called at the end of an event. 
  DrawAux();
  
  Int_t total = 0;
  
  fFMD1.End();
  fFMD1Pad->Modified();
  fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d", fFMD1.Total()));
  total += fFMD1.Total();

  fFMD2.End();
  fFMD2Pad->Modified();
  fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d", fFMD2.Total()));
  total += fFMD2.Total();

  fFMD3.End();
  fFMD3Pad->Modified();
  fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d", fFMD3.Total()));
  total += fFMD3.Total();

  fTotal.SetTitle(Form("Total:    %5d/51200 (%3d%%)", 
		      total, Int_t(100. / 51200 * total)));
  fSummary->Modified();
  fCanvas->Modified();
  fCanvas->Update();
  fCanvas->cd();
}

//____________________________________________________________________
Bool_t 
AliFMDPattern::ProcessHit(AliFMDHit* hit, TParticle*) 
{
  // Process a hit. 
  // 
  // Parameters 
  // 
  //	HIT		The hit to process. 
  // 
  // The TParticle argument is never used. 
  static const Float_t rMin  = fgkEdepRange.fLow;
  static const Float_t rMax  = fgkEdepRange.fHigh;

  if (!hit) { AliError("No hit");   return kFALSE; }
  // if (!p)   { AliError("No track"); return kFALSE; }
  Float_t  edep  = hit->Edep();

  if (fHits)                        fHits->Add(hit);
  if (fSpec)                        fSpec->Fill(edep);
  if (InsideCut(edep, rMin, rMax) && fSpecCut) fSpecCut->Fill(edep);

  switch (hit->Detector()) {
  case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
  case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
  case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
  }
  return kTRUE;
}


//____________________________________________________________________
void
AliFMDPattern::AddMarker(UShort_t det, Char_t rng, 
			 UShort_t sec, UShort_t str,
			 TObject*, Float_t s, Float_t /*min*/, Float_t max)
{
  // Add a marker to the display
  //
  //    det 	Detector
  //    rng 	Ring
  //    sec 	Sector 
  //    str 	Strip
  //    o   	Object to refer to
  //    s   	Signal 
  //    max 	Maximum of signal 
  //
  AliFMDPatternDetector* d = 0;
  switch (det) {
  case 1: d = &fFMD1; break;
  case 2: d = &fFMD2; break;
  case 3: d = &fFMD3; break;
  }
  if (!d) return;
  AliFMDGeometry*   geom = AliFMDGeometry::Instance();
  Double_t x, y, z;
  geom->Detector2XYZ(det, rng, sec, str, x, y, z);
  // Make code-checker shut the f**k up 
  TRandom* rand = gRandom;
  if (false) {
    AliFMDRing* r  = geom->GetRing(rng);
    Double_t    t  = .9 * r->GetTheta() / 2;
    Double_t    a  = rand->Uniform(-t,t) * TMath::Pi() / 180;
    Double_t    x1 = x * TMath::Cos(a) - y * TMath::Sin(a);
    Double_t    y1 = x * TMath::Sin(a) + y * TMath::Cos(a);
    x = x1;
    y = y1;
  }
  d->AddMarker(x, y, s, max);
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
a9579262	1	/**************************************************************************
	2	* Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	/* $Id$ */
	16	/** @file AliFMDPattern.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:39:09 2006
	19	@brief FMD 2D Event display
	20	*/
	21	//___________________________________________________________________
	22	//
	23	// The classes defined here, are utility classes for reading in data
	24	// for the FMD. They are put in a seperate library to not polute the
	25	// normal libraries. The classes are intended to be used as base
	26	// classes for customized class that do some sort of analysis on the
	27	// various types of data produced by the FMD.
	28	//
	29	// Latest changes by Christian Holm Christensen
	30	//
9edefa04	31
f95a63c4	32	// #include <iostream>
9edefa04	33
f95a63c4	34	// #include <TApplication.h>
f95a63c4	35	// #include <TButton.h>
9edefa04	36	#include <TCanvas.h>
	37	#include <TH2F.h>
	38	#include <TMath.h>
	39	#include <TPad.h>
	40	#include <TRandom.h>
f95a63c4	41	// #include <TSlider.h>
9edefa04	42	#include <TStyle.h>
f95a63c4	43	// #include <TSystem.h>
9edefa04	44	#include <TVector2.h>
f95a63c4	45	// #include <TView.h>
f95a63c4	46	#include <TGraph.h>
a9579262	47	#include "AliFMDPattern.h" // ALIFMDDISPLAY_H
a9579262	48	#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
f95a63c4	49	//#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
a9579262	50	#include "AliFMDRing.h"
f95a63c4	51	// #include "AliFMDDetector.h"
a9579262	52	#include "AliFMDHit.h"
f95a63c4	53	// #include <AliLog.h>
	54	#include "AliFMDDebug.h" // Better debug macros
	55	class AliFMDDetector;
a9579262	56
	57	//____________________________________________________________________
	58	ClassImp(AliFMDPattern)
	59	#if 0
	60	; // This is here to keep Emacs for indenting the next line
	61	#endif
	62
	63	//____________________________________________________________________
f95a63c4	64	AliFMDPattern::AliFMDPatternDetector::AliFMDPatternDetector(UShort_t id)
a9579262	65	: fId(id),
	66	fCounts(0),
	67	fGraphs(0),
f38b1653	68	fFrame(0),
7af3df7f	69	fInners(10),
7af3df7f	70	fOuters(id == 1 ? 0 : 20)
f95a63c4	71	{
	72	// CTOR
	73	//
	74	// Parameters:
	75	//
	76	// ID Identifier
	77	}
a9579262	78
a9579262	79	//____________________________________________________________________
f95a63c4	80	AliFMDPattern::AliFMDPatternDetector::~AliFMDPatternDetector()
a9579262	81	{
f95a63c4	82	// DTOR
	83	// Destructor -
	84	// deletes mother frame
a9579262	85	if (fFrame) delete fFrame;
	86	}
	87
	88	//____________________________________________________________________
	89	void
f95a63c4	90	AliFMDPattern::AliFMDPatternDetector::DrawShape(TObjArray& a)
a9579262	91	{
f95a63c4	92	// Draw all shapes.
	93	//
	94	// Paramters
	95	//
	96	// a Array of shapes
	97	//
a9579262	98	TIter next(&a);
	99	TGraph* g = 0;
	100	while ((g = static_cast<TGraph*>(next()))) {
	101	g->DrawClone("f same");
	102	g->DrawClone("l same");
	103	}
	104	}
	105
f38b1653	106	//____________________________________________________________________
	107	void
	108	AliFMDPattern::AliFMDPatternDetector::CopyShapes(TObjArray& src,
	109	TObjArray& dest,
	110	Double_t ang,
	111	Double_t fx,
	112	Double_t fy)
	113	{
	114	TIter next(&src);
	115	TGraph* g = 0;
	116	while ((g = static_cast<TGraph*>(next()))) {
	117	TGraph* gg = new TGraph(*g);
	118	Double_t* x = gg->GetX();
	119	Double_t* y = gg->GetY();
	120	for (Int_t i = 0; i < gg->GetN(); i++) {
	121	Float_t xx = x[i] * TMath::Cos(ang) - y[i] * TMath::Sin(ang);
	122	Float_t yy = x[i] * TMath::Sin(ang) + y[i] * TMath::Cos(ang);
	123	gg->SetPoint(i, fx * xx, fy * yy);
	124	}
	125	gg->SetFillStyle(g->GetFillStyle());
	126	gg->SetFillColor(g->GetFillColor());
	127	gg->SetLineStyle(g->GetLineStyle());
	128	gg->SetLineColor(g->GetLineColor());
	129	gg->SetLineWidth(g->GetLineWidth());
	130	gg->SetMarkerStyle(g->GetMarkerStyle());
	131	gg->SetMarkerColor(g->GetMarkerColor());
	132	gg->SetMarkerSize(g->GetMarkerSize());
	133	TString name(g->GetName());
	134	name.ReplaceAll("X", Form("%d",fId));
	135	gg->SetName(name.Data());
	136	TString title(g->GetTitle());
	137	title.ReplaceAll("X", Form("%d",fId));
	138	gg->SetTitle(title.Data());
	139	dest.Add(gg);
	140	}
	141	dest.SetOwner();
	142	}
	143
a9579262	144	//____________________________________________________________________
a9579262	145	void
cf291b42	146	AliFMDPattern::AliFMDPatternDetector::Begin(Int_t nlevel,
	147	Double_t r,
	148	TObjArray& inners,
	149	TObjArray& outers)
a9579262	150	{
f95a63c4	151	// Start of a run.
	152	//
	153	// Parameters
	154	//
	155	// nlevel Number of levels
	156	// r Radius
	157	// inners Array of inner shapes
	158	// outers Array of outer shapes
	159	//
	160
	161	// To make code-checker shut up
	162	TStyle* style = gStyle;
	163	if (nlevel < 1) nlevel = style->GetNumberOfColors();
a9579262	164	fCounts.Set(nlevel);
5cf05dbb	165	Double_t rr = 1.05 * r;
a9579262	166	if (!fFrame) {
f95a63c4	167	// The code-checker thinks this is not using the declaration of
f95a63c4	168	// TH2F - what a morron!
a9579262	169	fFrame = new TH2F(Form("fmd%dFrame", fId), Form("FMD%d", fId),
5cf05dbb	170	100, -rr, rr, 100, -rr, rr);
a9579262	171	fFrame->SetStats(kFALSE);
	172	fFrame->Draw();
	173	}
f38b1653	174	Double_t ang = (fId == 1 ? -TMath::Pi() / 2 : 0);
	175	Double_t fx = (fId == 3 ? -1 : 1); // Flip around Y
	176	Double_t fy = (fId == 1 ? 1 : 1); // Flip around X
	177
	178	CopyShapes(inners, fInners, ang, fx, fy);
	179	DrawShape(fInners);
	180	if (fId != 1) {
	181	CopyShapes(outers, fOuters, ang, fx, fy);
	182	DrawShape(fOuters);
	183	}
	184
a9579262	185	for (Int_t i = 0; i < nlevel; i++) {
a9579262	186	TGraph* g = new TGraph;
f95a63c4	187	Int_t idx = Int_t(Float_t(i) / nlevel * style->GetNumberOfColors());
f95a63c4	188	Int_t col = style->GetColorPalette(idx);
a9579262	189	g->SetName(Form("FMD%d_L%02d", fId, i));
	190	g->SetMarkerColor(col);
	191	g->SetLineColor(col);
	192	g->SetFillColor(col);
	193	g->SetMarkerSize(i * .2 + .2);
	194	g->SetMarkerStyle(2);
5cf05dbb	195	g->SetEditable(kFALSE);
a9579262	196	g->Draw("same p");
	197	fGraphs.AddAtAndExpand(g, i);
	198	}
cf291b42	199	// TIter next(&fGraphs);
a9579262	200	}
	201
	202	//____________________________________________________________________
	203	void
f95a63c4	204	AliFMDPattern::AliFMDPatternDetector::Clear()
a9579262	205	{
f95a63c4	206	// Clear this display.
	207	// Simply reset counters to zero.
	208	// Avoid deleting memory.
a9579262	209	fCounts.Reset(0);
	210	}
	211
	212	//____________________________________________________________________
	213	void
f95a63c4	214	AliFMDPattern::AliFMDPatternDetector::End()
a9579262	215	{
f95a63c4	216	// Called when displaying the data.
	217	// Simply resets number of points at each level to
	218	// the seen number of hits at that level.
	219	// Avoid deleting memory.
a9579262	220	TIter next(&fGraphs);
	221	TGraph* g = 0;
	222	Int_t i = 0;
5cf05dbb	223	while ((g = static_cast<TGraph*>(next()))) {
	224	Int_t cnt = fCounts[i++];
	225	if (cnt > 0) {
	226	g->Set(cnt);
	227	g->SetMarkerSize(i * .2 + .2);
	228	}
	229	else {
	230	g->SetPoint(0,0,0);
	231	g->SetMarkerSize(0);
	232	}
	233	}
	234
a9579262	235	}
	236	//____________________________________________________________________
	237	void
cf291b42	238	AliFMDPattern::AliFMDPatternDetector::AddMarker(Double_t x,
	239	Double_t y,
	240	Float_t s,
	241	Float_t max)
a9579262	242	{
f95a63c4	243	// Add a marker at (X,Y,Z). The marker color and size is chosen
	244	// relative to the MAX argument.
	245	//
	246	// Parameters
	247	//
	248	// X,Y,Z Coordiantes
	249	// MAX Maximum value.
	250	//
	251	/** Sigh, for some odd reason, the code-checker does not recognise
	252	this a usage of the TMath namespace declaration! Idiot */
	253	Int_t i = TMath::Min(Int_t(fCounts.fN * s / max),
a9579262	254	Int_t(fGraphs.GetEntries()-1));
	255	TGraph* g = static_cast<TGraph*>(fGraphs.At(i));
	256	if (!g) return;
	257	g->SetPoint(fCounts[i]++, x, y);
	258	}
	259
	260
	261	//____________________________________________________________________
	262	AliFMDPattern::AliFMDPattern(const char* gAliceFile)
	263	: AliFMDDisplay(kTRUE, gAliceFile),
17e542eb	264	fInners(0),
17e542eb	265	fOuters(0),
a9579262	266	fInnerMax(0),
	267	fOuterMax(0),
	268	fFMD1Pad(0),
	269	fFMD1(1),
	270	fFMD2Pad(0),
	271	fFMD2(2),
	272	fFMD3Pad(0),
	273	fFMD3(3),
17e542eb	274	fSummary(0),
a9579262	275	fEvent(.1, .8, "Event #"),
	276	fFMD1Sum(.2, .7, "# in FMD1: "),
	277	fFMD2Sum(.2, .6, "# in FMD2: "),
	278	fFMD3Sum(.2, .5, "# in FMD3: "),
	279	fLine(.15, .47, .85, .47),
	280	fTotal(.2, .35, "Total: ")
	281	{
f95a63c4	282	// Constructor.
	283	//
	284	// Parameters
	285	//
	286	// gAliceFile The galice.root file to use - if any.
	287	//
	288
42f1b2f5	289	SetName("AliFMDPattern");
	290	SetName("2D display of FMD data");
	291
a9579262	292	// RemoveLoad(kGeometry);
	293	fEvent.SetBit(TLatex::kTextNDC);
	294	fFMD1Sum.SetBit(TLatex::kTextNDC);
	295	fFMD2Sum.SetBit(TLatex::kTextNDC);
	296	fFMD3Sum.SetBit(TLatex::kTextNDC);
	297	fLine.SetBit(TLine::kLineNDC);
	298	fTotal.SetBit(TLatex::kTextNDC);
	299	}
	300
	301	//____________________________________________________________________
	302	AliFMDPattern::~AliFMDPattern()
	303	{
f95a63c4	304	// DTOR
	305	// Free all allocated shapes.
	306	// note, that most members are real objects, so we do not need to
	307	// deal with them here.
a9579262	308	fInners.Delete();
	309	fOuters.Delete();
	310	}
	311
	312
	313	//____________________________________________________________________
	314	Bool_t
	315	AliFMDPattern::Init()
	316	{
f95a63c4	317	// Initialize. Get transforms and such,
a9579262	318	if (!AliFMDInput::Init()) return kFALSE;
a9579262	319	AliFMDGeometry* geom = AliFMDGeometry::Instance();
69893a66	320	if (!geom) return kFALSE;
a9579262	321	geom->Init();
	322	geom->InitTransformations();
	323
	324	Char_t rs[] = { 'I' , 'O', '\0' };
	325	Char_t *r = rs;
	326	do {
	327	AliFMDRing* ring = geom->GetRing(*r);
	328	if (!ring) continue;
	329	const TObjArray& vs = ring->GetVerticies();
	330	TObjArray& gs = (*r == 'I' ? fInners : fOuters);
	331	Float_t& mr = (*r == 'I' ? fInnerMax : fOuterMax);
	332	Int_t nm = ring->GetNModules();
f38b1653	333	AliFMDDebug(1, ("Making %d modules for %c", nm, *r));
a9579262	334	for (Int_t m = 0; m < nm; m++) {
	335	Int_t nv = vs.GetEntries();
	336	Double_t a = TMath::Pi() / 180 * (m * 2 + 1) * ring->GetTheta();
	337	TGraph* g = new TGraph(nv+1);
	338	Double_t x0 = 0, y0 = 0;
	339	gs.AddAtAndExpand(g, m);
	340	for (Int_t c = 0; c < nv; c++) {
	341	TVector2* v = static_cast<TVector2*>(vs.At(c));
	342	mr = TMath::Max(mr, Float_t(v->Mod()));
	343	TVector2 w(v->Rotate(a));
	344	if (c == 0) { x0 = w.X(); y0 = w.Y(); }
	345	g->SetPoint(c, w.X(), w.Y());
	346	}
f38b1653	347	g->SetName(Form("FMDX%c_%02d%02d", r, 2m,2*m+1));
f38b1653	348	g->SetTitle(Form("FMDX%c, sectors %d and %d", r, 2m,2*m+1));
a9579262	349	g->SetPoint(nv, x0, y0);
	350	g->SetFillColor((*rs == 'I' ?
	351	(m % 2 == 0 ? 18 : 17) :
	352	(m % 2 == 0 ? 20 : 23)));
	353	g->SetFillStyle(3001);
	354	g->SetLineColor(1);
	355	g->SetLineWidth(1);
	356	g->SetLineStyle(2);
	357	}
	358	} while (*(++r));
	359
	360	return kTRUE;
	361	}
	362
	363	//____________________________________________________________________
	364	Bool_t
	365	AliFMDPattern::Begin(Int_t event)
	366	{
f95a63c4	367	// Called at the begining of an event.
	368	//
	369	// Parameters
	370	//
	371	// EVENT The event number
	372	//
97b4001e	373	MakeAux();
a9579262	374	if (!fCanvas) {
2eddac03	375	const char* which[] = { "Continue", "Start", "Pause", "Redisplay", 0 };
a9579262	376	MakeCanvas(which);
a9579262	377
a9579262	378	AliFMDGeometry* geom = AliFMDGeometry::Instance();
f95a63c4	379	// AliFMDDetector* det;
f95a63c4	380	if ((/* det = */ geom->GetDetector(1))) {
a9579262	381	fPad->cd();
	382	fFMD1Pad = new TPad("FMD1", "FMD1", 0.0, 0.50, 0.5, 1.0, 0, 0);
	383	fFMD1Pad->Draw();
	384	fFMD1Pad->cd();
97b4001e	385	fFMD1.Begin(-1, fInnerMax, fInners, fOuters);
a9579262	386	}
f95a63c4	387	if ((/* det = */ geom->GetDetector(2))) {
a9579262	388	fPad->cd();
	389	fFMD2Pad = new TPad("FMD2", "FMD2", 0.5, 0.50, 1.0, 1.0, 0, 0);
	390	fFMD2Pad->Draw();
	391	fFMD2Pad->cd();
97b4001e	392	fFMD2.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	393	}
f95a63c4	394	if ((/* det = */ geom->GetDetector(3))) {
a9579262	395	fPad->cd();
	396	fFMD3Pad = new TPad("FMD3", "FMD3", 0.0, 0.0, .5, .5, 0, 0);
	397	fFMD3Pad->Draw();
	398	fFMD3Pad->cd();
97b4001e	399	fFMD3.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	400	}
	401	fPad->cd();
	402	fSummary = new TPad("display", "Display", 0.5, 0.0, 1.0, 0.5, 0, 0);
	403	fSummary->Draw();
	404	fSummary->cd();
	405	fEvent.Draw();
	406	fFMD1Sum.Draw();
	407	fFMD2Sum.Draw();
	408	fFMD3Sum.Draw();
	409	fLine.Draw();
	410	fTotal.Draw();
	411	}
	412	fEvent.SetTitle(Form("Event # %6d", event));
	413
	414	fCanvas->Modified();
	415	fCanvas->Update();
	416	fCanvas->cd();
	417	fFMD1.Clear();
	418	fFMD2.Clear();
	419	fFMD3.Clear();
	420	return AliFMDInput::Begin(event);
	421	}
	422
	423	//____________________________________________________________________
	424	void
	425	AliFMDPattern::Redisplay()
	426	{
f95a63c4	427	// Redraw the displayu
a9579262	428	fFMD1.Clear();
	429	fFMD2.Clear();
	430	fFMD3.Clear();
	431	AliFMDDisplay::Redisplay();
	432	}
	433
	434	//____________________________________________________________________
	435	void
	436	AliFMDPattern::AtEnd()
	437	{
f95a63c4	438	// Called at the end of an event.
a9579262	439	DrawAux();
	440
	441	Int_t total = 0;
	442
	443	fFMD1.End();
	444	fFMD1Pad->Modified();
	445	fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d", fFMD1.Total()));
	446	total += fFMD1.Total();
	447
	448	fFMD2.End();
	449	fFMD2Pad->Modified();
	450	fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d", fFMD2.Total()));
	451	total += fFMD2.Total();
	452
	453	fFMD3.End();
	454	fFMD3Pad->Modified();
	455	fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d", fFMD3.Total()));
	456	total += fFMD3.Total();
	457
	458	fTotal.SetTitle(Form("Total: %5d/51200 (%3d%%)",
	459	total, Int_t(100. / 51200 * total)));
	460	fSummary->Modified();
	461	fCanvas->Modified();
	462	fCanvas->Update();
	463	fCanvas->cd();
	464	}
	465
	466	//____________________________________________________________________
	467	Bool_t
	468	AliFMDPattern::ProcessHit(AliFMDHit* hit, TParticle*)
	469	{
f95a63c4	470	// Process a hit.
	471	//
	472	// Parameters
	473	//
	474	// HIT The hit to process.
	475	//
	476	// The TParticle argument is never used.
ef8e8623	477	static const Float_t rMin = fgkEdepRange.fLow;
	478	static const Float_t rMax = fgkEdepRange.fHigh;
	479
	480	if (!hit) { AliError("No hit"); return kFALSE; }
	481	// if (!p) { AliError("No track"); return kFALSE; }
	482	Float_t edep = hit->Edep();
	483
	484	if (fHits) fHits->Add(hit);
	485	if (fSpec) fSpec->Fill(edep);
	486	if (InsideCut(edep, rMin, rMax) && fSpecCut) fSpecCut->Fill(edep);
	487
a9579262	488	switch (hit->Detector()) {
ef8e8623	489	case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
	490	case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
	491	case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
a9579262	492	}
	493	return kTRUE;
	494	}
	495
	496
	497	//____________________________________________________________________
	498	void
f95a63c4	499	AliFMDPattern::AddMarker(UShort_t det, Char_t rng,
f95a63c4	500	UShort_t sec, UShort_t str,
cf291b42	501	TObject, Float_t s, Float_t /min*/, Float_t max)
a9579262	502	{
	503	// Add a marker to the display
	504	//
	505	// det Detector
	506	// rng Ring
	507	// sec Sector
	508	// str Strip
	509	// o Object to refer to
	510	// s Signal
	511	// max Maximum of signal
	512	//
f95a63c4	513	AliFMDPatternDetector* d = 0;
a9579262	514	switch (det) {
	515	case 1: d = &fFMD1; break;
	516	case 2: d = &fFMD2; break;
	517	case 3: d = &fFMD3; break;
	518	}
	519	if (!d) return;
	520	AliFMDGeometry* geom = AliFMDGeometry::Instance();
	521	Double_t x, y, z;
	522	geom->Detector2XYZ(det, rng, sec, str, x, y, z);
f95a63c4	523	// Make code-checker shut the f**k up
f95a63c4	524	TRandom* rand = gRandom;
f38b1653	525	if (false) {
a9579262	526	AliFMDRing* r = geom->GetRing(rng);
a9579262	527	Double_t t = .9 * r->GetTheta() / 2;
f95a63c4	528	Double_t a = rand->Uniform(-t,t) * TMath::Pi() / 180;
a9579262	529	Double_t x1 = x * TMath::Cos(a) - y * TMath::Sin(a);
	530	Double_t y1 = x * TMath::Sin(a) + y * TMath::Cos(a);
	531	x = x1;
	532	y = y1;
	533	}
	534	d->AddMarker(x, y, s, max);
	535	}
	536
	537	//____________________________________________________________________
	538	//
	539	// EOF
	540	//