[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)
{
  // 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::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);
  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), 
		      10, -r, r, 10, -r, r);
    fFrame->SetStats(kFALSE);
    fFrame->Draw();
  }
  DrawShape(inners);
  if (fId != 1) DrawShape(outers);
  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->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()))) g->Set(fCounts[i++]);
}
//____________________________________________________________________
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),
    fInnerMax(0), 
    fOuterMax(0),
    fFMD1Pad(0),
    fFMD1(1),
    fFMD2Pad(0),
    fFMD2(2),
    fFMD3Pad(0),
    fFMD3(3),
    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. 
  // 

  // 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();
  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();
    AliInfo(Form("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", *r, m));
      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", "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. 
  switch (hit->Detector()) {
  case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
  case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
  case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
  }
  return kTRUE;
}


//____________________________________________________________________
void
AliFMDPattern::AddMarker(UShort_t det, Char_t rng, 
			 UShort_t sec, UShort_t str,
			 TObject*, Float_t s, 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 (true) {
    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),
	68	fFrame(0)
f95a63c4	69	{
	70	// CTOR
	71	//
	72	// Parameters:
	73	//
	74	// ID Identifier
	75	}
a9579262	76
a9579262	77	//____________________________________________________________________
f95a63c4	78	AliFMDPattern::AliFMDPatternDetector::~AliFMDPatternDetector()
a9579262	79	{
f95a63c4	80	// DTOR
	81	// Destructor -
	82	// deletes mother frame
a9579262	83	if (fFrame) delete fFrame;
	84	}
	85
	86	//____________________________________________________________________
	87	void
f95a63c4	88	AliFMDPattern::AliFMDPatternDetector::DrawShape(TObjArray& a)
a9579262	89	{
f95a63c4	90	// Draw all shapes.
	91	//
	92	// Paramters
	93	//
	94	// a Array of shapes
	95	//
a9579262	96	TIter next(&a);
	97	TGraph* g = 0;
	98	while ((g = static_cast<TGraph*>(next()))) {
	99	g->DrawClone("f same");
	100	g->DrawClone("l same");
	101	}
	102	}
	103
	104	//____________________________________________________________________
	105	void
f95a63c4	106	AliFMDPattern::AliFMDPatternDetector::Begin(Int_t nlevel, Double_t r,
a9579262	107	TObjArray& inners, TObjArray& outers)
a9579262	108	{
f95a63c4	109	// Start of a run.
	110	//
	111	// Parameters
	112	//
	113	// nlevel Number of levels
	114	// r Radius
	115	// inners Array of inner shapes
	116	// outers Array of outer shapes
	117	//
	118
	119	// To make code-checker shut up
	120	TStyle* style = gStyle;
	121	if (nlevel < 1) nlevel = style->GetNumberOfColors();
a9579262	122	fCounts.Set(nlevel);
a9579262	123	if (!fFrame) {
f95a63c4	124	// The code-checker thinks this is not using the declaration of
f95a63c4	125	// TH2F - what a morron!
a9579262	126	fFrame = new TH2F(Form("fmd%dFrame", fId), Form("FMD%d", fId),
	127	10, -r, r, 10, -r, r);
	128	fFrame->SetStats(kFALSE);
	129	fFrame->Draw();
	130	}
	131	DrawShape(inners);
	132	if (fId != 1) DrawShape(outers);
	133	for (Int_t i = 0; i < nlevel; i++) {
	134	TGraph* g = new TGraph;
f95a63c4	135	Int_t idx = Int_t(Float_t(i) / nlevel * style->GetNumberOfColors());
f95a63c4	136	Int_t col = style->GetColorPalette(idx);
a9579262	137	g->SetName(Form("FMD%d_L%02d", fId, i));
	138	g->SetMarkerColor(col);
	139	g->SetLineColor(col);
	140	g->SetFillColor(col);
	141	g->SetMarkerSize(i * .2 + .2);
	142	g->SetMarkerStyle(2);
	143	g->Draw("same p");
	144	fGraphs.AddAtAndExpand(g, i);
	145	}
	146	TIter next(&fGraphs);
	147	}
	148
	149	//____________________________________________________________________
	150	void
f95a63c4	151	AliFMDPattern::AliFMDPatternDetector::Clear()
a9579262	152	{
f95a63c4	153	// Clear this display.
	154	// Simply reset counters to zero.
	155	// Avoid deleting memory.
a9579262	156	fCounts.Reset(0);
	157	}
	158
	159	//____________________________________________________________________
	160	void
f95a63c4	161	AliFMDPattern::AliFMDPatternDetector::End()
a9579262	162	{
f95a63c4	163	// Called when displaying the data.
	164	// Simply resets number of points at each level to
	165	// the seen number of hits at that level.
	166	// Avoid deleting memory.
a9579262	167	TIter next(&fGraphs);
	168	TGraph* g = 0;
	169	Int_t i = 0;
	170	while ((g = static_cast<TGraph*>(next()))) g->Set(fCounts[i++]);
	171	}
	172	//____________________________________________________________________
	173	void
f95a63c4	174	AliFMDPattern::AliFMDPatternDetector::AddMarker(Double_t x, Double_t y, Float_t s,
a9579262	175	Float_t max)
a9579262	176	{
f95a63c4	177	// Add a marker at (X,Y,Z). The marker color and size is chosen
	178	// relative to the MAX argument.
	179	//
	180	// Parameters
	181	//
	182	// X,Y,Z Coordiantes
	183	// MAX Maximum value.
	184	//
	185	/** Sigh, for some odd reason, the code-checker does not recognise
	186	this a usage of the TMath namespace declaration! Idiot */
	187	Int_t i = TMath::Min(Int_t(fCounts.fN * s / max),
a9579262	188	Int_t(fGraphs.GetEntries()-1));
	189	TGraph* g = static_cast<TGraph*>(fGraphs.At(i));
	190	if (!g) return;
	191	g->SetPoint(fCounts[i]++, x, y);
	192	}
	193
	194
	195	//____________________________________________________________________
	196	AliFMDPattern::AliFMDPattern(const char* gAliceFile)
	197	: AliFMDDisplay(kTRUE, gAliceFile),
	198	fInnerMax(0),
	199	fOuterMax(0),
	200	fFMD1Pad(0),
	201	fFMD1(1),
	202	fFMD2Pad(0),
	203	fFMD2(2),
	204	fFMD3Pad(0),
	205	fFMD3(3),
	206	fEvent(.1, .8, "Event #"),
	207	fFMD1Sum(.2, .7, "# in FMD1: "),
	208	fFMD2Sum(.2, .6, "# in FMD2: "),
	209	fFMD3Sum(.2, .5, "# in FMD3: "),
	210	fLine(.15, .47, .85, .47),
	211	fTotal(.2, .35, "Total: ")
	212	{
f95a63c4	213	// Constructor.
	214	//
	215	// Parameters
	216	//
	217	// gAliceFile The galice.root file to use - if any.
	218	//
	219
a9579262	220	// RemoveLoad(kGeometry);
	221	fEvent.SetBit(TLatex::kTextNDC);
	222	fFMD1Sum.SetBit(TLatex::kTextNDC);
	223	fFMD2Sum.SetBit(TLatex::kTextNDC);
	224	fFMD3Sum.SetBit(TLatex::kTextNDC);
	225	fLine.SetBit(TLine::kLineNDC);
	226	fTotal.SetBit(TLatex::kTextNDC);
	227	}
	228
	229	//____________________________________________________________________
	230	AliFMDPattern::~AliFMDPattern()
	231	{
f95a63c4	232	// DTOR
	233	// Free all allocated shapes.
	234	// note, that most members are real objects, so we do not need to
	235	// deal with them here.
a9579262	236	fInners.Delete();
	237	fOuters.Delete();
	238	}
	239
	240
	241	//____________________________________________________________________
	242	Bool_t
	243	AliFMDPattern::Init()
	244	{
f95a63c4	245	// Initialize. Get transforms and such,
a9579262	246	if (!AliFMDInput::Init()) return kFALSE;
	247	AliFMDGeometry* geom = AliFMDGeometry::Instance();
	248	geom->Init();
	249	geom->InitTransformations();
	250
	251	Char_t rs[] = { 'I' , 'O', '\0' };
	252	Char_t *r = rs;
	253	do {
	254	AliFMDRing* ring = geom->GetRing(*r);
	255	if (!ring) continue;
	256	const TObjArray& vs = ring->GetVerticies();
	257	TObjArray& gs = (*r == 'I' ? fInners : fOuters);
	258	Float_t& mr = (*r == 'I' ? fInnerMax : fOuterMax);
	259	Int_t nm = ring->GetNModules();
	260	AliInfo(Form("Making %d modules for %c", nm, *r));
	261	for (Int_t m = 0; m < nm; m++) {
	262	Int_t nv = vs.GetEntries();
	263	Double_t a = TMath::Pi() / 180 * (m * 2 + 1) * ring->GetTheta();
	264	TGraph* g = new TGraph(nv+1);
	265	Double_t x0 = 0, y0 = 0;
	266	gs.AddAtAndExpand(g, m);
	267	for (Int_t c = 0; c < nv; c++) {
	268	TVector2* v = static_cast<TVector2*>(vs.At(c));
	269	mr = TMath::Max(mr, Float_t(v->Mod()));
	270	TVector2 w(v->Rotate(a));
	271	if (c == 0) { x0 = w.X(); y0 = w.Y(); }
	272	g->SetPoint(c, w.X(), w.Y());
	273	}
	274	g->SetName(Form("FMDX%c_%02d", *r, m));
	275	g->SetPoint(nv, x0, y0);
	276	g->SetFillColor((*rs == 'I' ?
	277	(m % 2 == 0 ? 18 : 17) :
	278	(m % 2 == 0 ? 20 : 23)));
	279	g->SetFillStyle(3001);
	280	g->SetLineColor(1);
	281	g->SetLineWidth(1);
	282	g->SetLineStyle(2);
	283	}
	284	} while (*(++r));
	285
	286	return kTRUE;
	287	}
	288
	289	//____________________________________________________________________
	290	Bool_t
	291	AliFMDPattern::Begin(Int_t event)
	292	{
f95a63c4	293	// Called at the begining of an event.
	294	//
	295	// Parameters
	296	//
	297	// EVENT The event number
	298	//
97b4001e	299	MakeAux();
a9579262	300	if (!fCanvas) {
	301	const char* which[] = { "Continue", "Redisplay", 0 };
	302	MakeCanvas(which);
a9579262	303
a9579262	304	AliFMDGeometry* geom = AliFMDGeometry::Instance();
f95a63c4	305	// AliFMDDetector* det;
f95a63c4	306	if ((/* det = */ geom->GetDetector(1))) {
a9579262	307	fPad->cd();
	308	fFMD1Pad = new TPad("FMD1", "FMD1", 0.0, 0.50, 0.5, 1.0, 0, 0);
	309	fFMD1Pad->Draw();
	310	fFMD1Pad->cd();
97b4001e	311	fFMD1.Begin(-1, fInnerMax, fInners, fOuters);
a9579262	312	}
f95a63c4	313	if ((/* det = */ geom->GetDetector(2))) {
a9579262	314	fPad->cd();
	315	fFMD2Pad = new TPad("FMD2", "FMD2", 0.5, 0.50, 1.0, 1.0, 0, 0);
	316	fFMD2Pad->Draw();
	317	fFMD2Pad->cd();
97b4001e	318	fFMD2.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	319	}
f95a63c4	320	if ((/* det = */ geom->GetDetector(3))) {
a9579262	321	fPad->cd();
	322	fFMD3Pad = new TPad("FMD3", "FMD3", 0.0, 0.0, .5, .5, 0, 0);
	323	fFMD3Pad->Draw();
	324	fFMD3Pad->cd();
97b4001e	325	fFMD3.Begin(-1, fOuterMax, fInners, fOuters);
a9579262	326	}
	327	fPad->cd();
	328	fSummary = new TPad("display", "Display", 0.5, 0.0, 1.0, 0.5, 0, 0);
	329	fSummary->Draw();
	330	fSummary->cd();
	331	fEvent.Draw();
	332	fFMD1Sum.Draw();
	333	fFMD2Sum.Draw();
	334	fFMD3Sum.Draw();
	335	fLine.Draw();
	336	fTotal.Draw();
	337	}
	338	fEvent.SetTitle(Form("Event # %6d", event));
	339
	340	fCanvas->Modified();
	341	fCanvas->Update();
	342	fCanvas->cd();
	343	fFMD1.Clear();
	344	fFMD2.Clear();
	345	fFMD3.Clear();
	346	return AliFMDInput::Begin(event);
	347	}
	348
	349	//____________________________________________________________________
	350	void
	351	AliFMDPattern::Redisplay()
	352	{
f95a63c4	353	// Redraw the displayu
a9579262	354	fFMD1.Clear();
	355	fFMD2.Clear();
	356	fFMD3.Clear();
	357	AliFMDDisplay::Redisplay();
	358	}
	359
	360	//____________________________________________________________________
	361	void
	362	AliFMDPattern::AtEnd()
	363	{
f95a63c4	364	// Called at the end of an event.
a9579262	365	DrawAux();
	366
	367	Int_t total = 0;
	368
	369	fFMD1.End();
	370	fFMD1Pad->Modified();
	371	fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d", fFMD1.Total()));
	372	total += fFMD1.Total();
	373
	374	fFMD2.End();
	375	fFMD2Pad->Modified();
	376	fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d", fFMD2.Total()));
	377	total += fFMD2.Total();
	378
	379	fFMD3.End();
	380	fFMD3Pad->Modified();
	381	fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d", fFMD3.Total()));
	382	total += fFMD3.Total();
	383
	384	fTotal.SetTitle(Form("Total: %5d/51200 (%3d%%)",
	385	total, Int_t(100. / 51200 * total)));
	386	fSummary->Modified();
	387	fCanvas->Modified();
	388	fCanvas->Update();
	389	fCanvas->cd();
	390	}
	391
	392	//____________________________________________________________________
	393	Bool_t
	394	AliFMDPattern::ProcessHit(AliFMDHit* hit, TParticle*)
	395	{
f95a63c4	396	// Process a hit.
	397	//
	398	// Parameters
	399	//
	400	// HIT The hit to process.
	401	//
	402	// The TParticle argument is never used.
a9579262	403	switch (hit->Detector()) {
	404	case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
	405	case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
	406	case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
	407	}
	408	return kTRUE;
	409	}
	410
	411
	412	//____________________________________________________________________
	413	void
f95a63c4	414	AliFMDPattern::AddMarker(UShort_t det, Char_t rng,
f95a63c4	415	UShort_t sec, UShort_t str,
a9579262	416	TObject*, Float_t s, Float_t max)
	417	{
	418	// Add a marker to the display
	419	//
	420	// det Detector
	421	// rng Ring
	422	// sec Sector
	423	// str Strip
	424	// o Object to refer to
	425	// s Signal
	426	// max Maximum of signal
	427	//
f95a63c4	428	AliFMDPatternDetector* d = 0;
a9579262	429	switch (det) {
	430	case 1: d = &fFMD1; break;
	431	case 2: d = &fFMD2; break;
	432	case 3: d = &fFMD3; break;
	433	}
	434	if (!d) return;
	435	AliFMDGeometry* geom = AliFMDGeometry::Instance();
	436	Double_t x, y, z;
	437	geom->Detector2XYZ(det, rng, sec, str, x, y, z);
f95a63c4	438	// Make code-checker shut the f**k up
f95a63c4	439	TRandom* rand = gRandom;
a9579262	440	if (true) {
	441	AliFMDRing* r = geom->GetRing(rng);
	442	Double_t t = .9 * r->GetTheta() / 2;
f95a63c4	443	Double_t a = rand->Uniform(-t,t) * TMath::Pi() / 180;
a9579262	444	Double_t x1 = x * TMath::Cos(a) - y * TMath::Sin(a);
	445	Double_t y1 = x * TMath::Sin(a) + y * TMath::Cos(a);
	446	x = x1;
	447	y = y1;
	448	}
	449	d->AddMarker(x, y, s, max);
	450	}
	451
	452	//____________________________________________________________________
	453	//
	454	// EOF
	455	//