[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));
  if (i < 0 || i >= fCounts.fN) { 
    std::cerr << "Graph index " << i << " out of bounds [0," 
	      << fCounts.fN << ") - " 
	      << fCounts.fN << " * " << s << " / " << max << std::endl;
    return;
  }
  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:   "), 
    fFMD1Area(0),
    fFMD2Area(0),
    fFMD3Area(0)
{
  // 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();
  
  fFMD1Area = 0;
  fFMD2Area = 0;
  fFMD3Area = 0;

  Double_t innerArea = 0;
  Double_t outerArea = 0;

  Char_t rs[] = { 'I' , 'O', '\0' };
  Char_t *r   = rs;
  do {
    AliFMDRing* ring = geom->GetRing(*r);
    if (!ring) continue;

    Double_t rl   = ring->GetMinR();
    Double_t rh   = ring->GetMaxR();
    Double_t area = rh * rh * TMath::Pi() - rl * rl * TMath::Pi();
    if (*r == 'I') innerArea = area;
    else           outerArea = area;
      

    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 = 6; // 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 = 1; c < 4; c++) {
	TVector2* v = static_cast<TVector2*>(vs.At(c));
	mr          = TMath::Max(mr, Float_t(v->Mod()));
	TVector2  w(v->Rotate(a));
	if (c == 1) { x0 = w.X(); y0 = w.Y(); }
	g->SetPoint(c-1, w.X(), w.Y());
      }
      for (Int_t c = 3; c > 0; c--) {
	TVector2* v = static_cast<TVector2*>(vs.At(c));
	TVector2  u(-v->X(), v->Y());
	mr          = TMath::Max(mr, Float_t(u.Mod()));
	TVector2  w(u.Rotate(a));
	g->SetPoint(3+(3-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));

  fFMD1Area = innerArea;
  fFMD2Area = innerArea + outerArea;
  fFMD3Area = innerArea + outerArea;
  
  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   (%4.2f /cm^{2})", 
			 fFMD1.Total(), fFMD1.Total()/fFMD1Area));
  total += fFMD1.Total();

  fFMD2.End();
  fFMD2Pad->Modified();
  fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d   (%4.2f /cm^{2})", 
			 fFMD2.Total(), fFMD2.Total()/fFMD2Area));
  total += fFMD2.Total();

  fFMD3.End();
  fFMD3Pad->Modified();
  fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d   (%4.2f /cm^{2})", 
			 fFMD3.Total(), fFMD3.Total()/fFMD3Area));
  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
e064ab4a	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));
e064ab4a	255	if (i < 0 \|\| i >= fCounts.fN) {
	256	std::cerr << "Graph index " << i << " out of bounds [0,"
	257	<< fCounts.fN << ") - "
	258	<< fCounts.fN << " * " << s << " / " << max << std::endl;
	259	return;
	260	}
a9579262	261	TGraph* g = static_cast<TGraph*>(fGraphs.At(i));
	262	if (!g) return;
	263	g->SetPoint(fCounts[i]++, x, y);
	264	}
	265
	266
	267	//____________________________________________________________________
	268	AliFMDPattern::AliFMDPattern(const char* gAliceFile)
	269	: AliFMDDisplay(kTRUE, gAliceFile),
17e542eb	270	fInners(0),
17e542eb	271	fOuters(0),
a9579262	272	fInnerMax(0),
	273	fOuterMax(0),
	274	fFMD1Pad(0),
	275	fFMD1(1),
	276	fFMD2Pad(0),
	277	fFMD2(2),
	278	fFMD3Pad(0),
	279	fFMD3(3),
17e542eb	280	fSummary(0),
a9579262	281	fEvent(.1, .8, "Event #"),
	282	fFMD1Sum(.2, .7, "# in FMD1: "),
	283	fFMD2Sum(.2, .6, "# in FMD2: "),
	284	fFMD3Sum(.2, .5, "# in FMD3: "),
	285	fLine(.15, .47, .85, .47),
e064ab4a	286	fTotal(.2, .35, "Total: "),
	287	fFMD1Area(0),
	288	fFMD2Area(0),
	289	fFMD3Area(0)
a9579262	290	{
f95a63c4	291	// Constructor.
	292	//
	293	// Parameters
	294	//
	295	// gAliceFile The galice.root file to use - if any.
	296	//
	297
42f1b2f5	298	SetName("AliFMDPattern");
	299	SetName("2D display of FMD data");
	300
a9579262	301	// RemoveLoad(kGeometry);
	302	fEvent.SetBit(TLatex::kTextNDC);
	303	fFMD1Sum.SetBit(TLatex::kTextNDC);
	304	fFMD2Sum.SetBit(TLatex::kTextNDC);
	305	fFMD3Sum.SetBit(TLatex::kTextNDC);
	306	fLine.SetBit(TLine::kLineNDC);
	307	fTotal.SetBit(TLatex::kTextNDC);
	308	}
	309
	310	//____________________________________________________________________
	311	AliFMDPattern::~AliFMDPattern()
	312	{
f95a63c4	313	// DTOR
	314	// Free all allocated shapes.
	315	// note, that most members are real objects, so we do not need to
	316	// deal with them here.
a9579262	317	fInners.Delete();
	318	fOuters.Delete();
	319	}
	320
	321
	322	//____________________________________________________________________
	323	Bool_t
	324	AliFMDPattern::Init()
	325	{
f95a63c4	326	// Initialize. Get transforms and such,
a9579262	327	if (!AliFMDInput::Init()) return kFALSE;
a9579262	328	AliFMDGeometry* geom = AliFMDGeometry::Instance();
69893a66	329	if (!geom) return kFALSE;
a9579262	330	geom->Init();
	331	geom->InitTransformations();
	332
e064ab4a	333	fFMD1Area = 0;
	334	fFMD2Area = 0;
	335	fFMD3Area = 0;
	336
	337	Double_t innerArea = 0;
	338	Double_t outerArea = 0;
	339
a9579262	340	Char_t rs[] = { 'I' , 'O', '\0' };
	341	Char_t *r = rs;
	342	do {
	343	AliFMDRing* ring = geom->GetRing(*r);
	344	if (!ring) continue;
e064ab4a	345
	346	Double_t rl = ring->GetMinR();
	347	Double_t rh = ring->GetMaxR();
	348	Double_t area = rh * rh * TMath::Pi() - rl * rl * TMath::Pi();
	349	if (*r == 'I') innerArea = area;
	350	else outerArea = area;
	351
	352
a9579262	353	const TObjArray& vs = ring->GetVerticies();
	354	TObjArray& gs = (*r == 'I' ? fInners : fOuters);
	355	Float_t& mr = (*r == 'I' ? fInnerMax : fOuterMax);
	356	Int_t nm = ring->GetNModules();
f38b1653	357	AliFMDDebug(1, ("Making %d modules for %c", nm, *r));
a9579262	358	for (Int_t m = 0; m < nm; m++) {
c6b36280	359	Int_t nv = 6; // vs.GetEntries();
a9579262	360	Double_t a = TMath::Pi() / 180 * (m * 2 + 1) * ring->GetTheta();
	361	TGraph* g = new TGraph(nv+1);
	362	Double_t x0 = 0, y0 = 0;
	363	gs.AddAtAndExpand(g, m);
c6b36280	364	for (Int_t c = 1; c < 4; c++) {
a9579262	365	TVector2* v = static_cast<TVector2*>(vs.At(c));
	366	mr = TMath::Max(mr, Float_t(v->Mod()));
	367	TVector2 w(v->Rotate(a));
c6b36280	368	if (c == 1) { x0 = w.X(); y0 = w.Y(); }
	369	g->SetPoint(c-1, w.X(), w.Y());
	370	}
	371	for (Int_t c = 3; c > 0; c--) {
	372	TVector2* v = static_cast<TVector2*>(vs.At(c));
	373	TVector2 u(-v->X(), v->Y());
	374	mr = TMath::Max(mr, Float_t(u.Mod()));
	375	TVector2 w(u.Rotate(a));
	376	g->SetPoint(3+(3-c), w.X(), w.Y());
a9579262	377	}
f38b1653	378	g->SetName(Form("FMDX%c_%02d%02d", r, 2m,2*m+1));
f38b1653	379	g->SetTitle(Form("FMDX%c, sectors %d and %d", r, 2m,2*m+1));
a9579262	380	g->SetPoint(nv, x0, y0);
	381	g->SetFillColor((*rs == 'I' ?
	382	(m % 2 == 0 ? 18 : 17) :
	383	(m % 2 == 0 ? 20 : 23)));
	384	g->SetFillStyle(3001);
	385	g->SetLineColor(1);
	386	g->SetLineWidth(1);
	387	g->SetLineStyle(2);
	388	}
	389	} while (*(++r));
e064ab4a	390
	391	fFMD1Area = innerArea;
	392	fFMD2Area = innerArea + outerArea;
	393	fFMD3Area = innerArea + outerArea;
	394
a9579262	395	return kTRUE;
	396	}
	397
	398	//____________________________________________________________________
	399	Bool_t
	400	AliFMDPattern::Begin(Int_t event)
	401	{
f95a63c4	402	// Called at the begining of an event.
	403	//
	404	// Parameters
	405	//
	406	// EVENT The event number
	407	//
97b4001e	408	MakeAux();
a9579262	409	if (!fCanvas) {
2eddac03	410	const char* which[] = { "Continue", "Start", "Pause", "Redisplay", 0 };
a9579262	411	MakeCanvas(which);
a9579262	412
a9579262	413	AliFMDGeometry* geom = AliFMDGeometry::Instance();
f95a63c4	414	// AliFMDDetector* det;
f95a63c4	415	if ((/* det = */ geom->GetDetector(1))) {
a9579262	416	fPad->cd();
	417	fFMD1Pad = new TPad("FMD1", "FMD1", 0.0, 0.50, 0.5, 1.0, 0, 0);
	418	fFMD1Pad->Draw();
	419	fFMD1Pad->cd();
97b4001e	420	fFMD1.Begin(-1, fInnerMax, fInners, fOuters);
a9579262	421	}
f95a63c4	422	if ((/* det = */ geom->GetDetector(2))) {
a9579262	423	fPad->cd();
	424	fFMD2Pad = new TPad("FMD2", "FMD2", 0.5, 0.50, 1.0, 1.0, 0, 0);
	425	fFMD2Pad->Draw();
	426	fFMD2Pad->cd();
97b4001e	427	fFMD2.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	428	}
f95a63c4	429	if ((/* det = */ geom->GetDetector(3))) {
a9579262	430	fPad->cd();
	431	fFMD3Pad = new TPad("FMD3", "FMD3", 0.0, 0.0, .5, .5, 0, 0);
	432	fFMD3Pad->Draw();
	433	fFMD3Pad->cd();
97b4001e	434	fFMD3.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	435	}
	436	fPad->cd();
	437	fSummary = new TPad("display", "Display", 0.5, 0.0, 1.0, 0.5, 0, 0);
	438	fSummary->Draw();
	439	fSummary->cd();
	440	fEvent.Draw();
	441	fFMD1Sum.Draw();
	442	fFMD2Sum.Draw();
	443	fFMD3Sum.Draw();
	444	fLine.Draw();
	445	fTotal.Draw();
	446	}
	447	fEvent.SetTitle(Form("Event # %6d", event));
	448
	449	fCanvas->Modified();
	450	fCanvas->Update();
	451	fCanvas->cd();
	452	fFMD1.Clear();
	453	fFMD2.Clear();
	454	fFMD3.Clear();
	455	return AliFMDInput::Begin(event);
	456	}
	457
	458	//____________________________________________________________________
	459	void
	460	AliFMDPattern::Redisplay()
	461	{
f95a63c4	462	// Redraw the displayu
a9579262	463	fFMD1.Clear();
	464	fFMD2.Clear();
	465	fFMD3.Clear();
	466	AliFMDDisplay::Redisplay();
	467	}
	468
	469	//____________________________________________________________________
	470	void
	471	AliFMDPattern::AtEnd()
	472	{
f95a63c4	473	// Called at the end of an event.
a9579262	474	DrawAux();
	475
	476	Int_t total = 0;
	477
	478	fFMD1.End();
	479	fFMD1Pad->Modified();
e1a9aea4	480	fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d (%4.2f /cm^{2})",
e064ab4a	481	fFMD1.Total(), fFMD1.Total()/fFMD1Area));
a9579262	482	total += fFMD1.Total();
	483
	484	fFMD2.End();
	485	fFMD2Pad->Modified();
e1a9aea4	486	fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d (%4.2f /cm^{2})",
e064ab4a	487	fFMD2.Total(), fFMD2.Total()/fFMD2Area));
a9579262	488	total += fFMD2.Total();
	489
	490	fFMD3.End();
	491	fFMD3Pad->Modified();
e1a9aea4	492	fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d (%4.2f /cm^{2})",
e064ab4a	493	fFMD3.Total(), fFMD3.Total()/fFMD3Area));
a9579262	494	total += fFMD3.Total();
	495
	496	fTotal.SetTitle(Form("Total: %5d/51200 (%3d%%)",
	497	total, Int_t(100. / 51200 * total)));
	498	fSummary->Modified();
	499	fCanvas->Modified();
	500	fCanvas->Update();
	501	fCanvas->cd();
	502	}
	503
	504	//____________________________________________________________________
	505	Bool_t
	506	AliFMDPattern::ProcessHit(AliFMDHit* hit, TParticle*)
	507	{
f95a63c4	508	// Process a hit.
	509	//
	510	// Parameters
	511	//
	512	// HIT The hit to process.
	513	//
	514	// The TParticle argument is never used.
ef8e8623	515	static const Float_t rMin = fgkEdepRange.fLow;
	516	static const Float_t rMax = fgkEdepRange.fHigh;
	517
	518	if (!hit) { AliError("No hit"); return kFALSE; }
	519	// if (!p) { AliError("No track"); return kFALSE; }
	520	Float_t edep = hit->Edep();
	521
	522	if (fHits) fHits->Add(hit);
	523	if (fSpec) fSpec->Fill(edep);
	524	if (InsideCut(edep, rMin, rMax) && fSpecCut) fSpecCut->Fill(edep);
	525
a9579262	526	switch (hit->Detector()) {
ef8e8623	527	case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
	528	case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
	529	case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
a9579262	530	}
	531	return kTRUE;
	532	}
	533
	534
	535	//____________________________________________________________________
	536	void
f95a63c4	537	AliFMDPattern::AddMarker(UShort_t det, Char_t rng,
f95a63c4	538	UShort_t sec, UShort_t str,
cf291b42	539	TObject, Float_t s, Float_t /min*/, Float_t max)
a9579262	540	{
	541	// Add a marker to the display
	542	//
	543	// det Detector
	544	// rng Ring
	545	// sec Sector
	546	// str Strip
	547	// o Object to refer to
	548	// s Signal
	549	// max Maximum of signal
	550	//
f95a63c4	551	AliFMDPatternDetector* d = 0;
a9579262	552	switch (det) {
	553	case 1: d = &fFMD1; break;
	554	case 2: d = &fFMD2; break;
	555	case 3: d = &fFMD3; break;
	556	}
	557	if (!d) return;
	558	AliFMDGeometry* geom = AliFMDGeometry::Instance();
	559	Double_t x, y, z;
	560	geom->Detector2XYZ(det, rng, sec, str, x, y, z);
f95a63c4	561	// Make code-checker shut the f**k up
f95a63c4	562	TRandom* rand = gRandom;
f38b1653	563	if (false) {
a9579262	564	AliFMDRing* r = geom->GetRing(rng);
a9579262	565	Double_t t = .9 * r->GetTheta() / 2;
f95a63c4	566	Double_t a = rand->Uniform(-t,t) * TMath::Pi() / 180;
a9579262	567	Double_t x1 = x * TMath::Cos(a) - y * TMath::Sin(a);
	568	Double_t y1 = x * TMath::Sin(a) + y * TMath::Cos(a);
	569	x = x1;
	570	y = y1;
	571	}
	572	d->AddMarker(x, y, s, max);
	573	}
	574
	575	//____________________________________________________________________
	576	//
	577	// EOF
	578	//