[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveITSDigitsInfo.h

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

#ifndef AliEveITSDigitsInfo_H
#define AliEveITSDigitsInfo_H

#include <TEveUtil.h>
#include <TObject.h>

#include <map>
#include <vector>

class TClonesArray;
class TTree;

class AliITSsegmentationSPD;
class AliITSsegmentationSDD;
class AliITSsegmentationSSD;
class AliITSDDLModuleMapSDD;

class AliRawReader;

/******************************************************************************/
// AliEveITSModuleSelection
/******************************************************************************/

class AliEveITSModuleSelection
{
public:
  AliEveITSModuleSelection();
  virtual ~AliEveITSModuleSelection() {}

  Int_t   GetType() const        { return fType;     }
  void    SetType(Int_t x)       { fType = x;        }
  Int_t   GetLayer() const       { return fLayer;    }
  void    SetLayer(Int_t x)      { fLayer = x;       }
  Float_t GetMinPhi() const      { return fMinPhi;   }
  void    SetMinPhi(Float_t x)   { fMinPhi = x;      }
  Float_t GetMaxPhi() const      { return fMaxPhi;   }
  void    SetMaxPhi(Float_t x)   { fMaxPhi = x;      }
  Float_t GetMinTheta() const    { return fMinTheta; }
  void    SetMinTheta(Float_t x) { fMinTheta = x;    }
  Float_t GetMaxTheta() const    { return fMaxTheta; }
  void    SetMaxTheta(Float_t x) { fMaxTheta = x;    }

  void    SetPhiRange  (Float_t x, Float_t y) { fMinPhi   = x; fMaxPhi   = y; }
  void    SetThetaRange(Float_t x, Float_t y) { fMinTheta = x; fMaxTheta = y; }

protected:
  Int_t    fType;      // Type of modules: 0 - SPD, 1 - SDD, 2 - SSD.
  Int_t    fLayer;     // Layer, 0 - inner SPD, 5 - outer SSD.
  Float_t  fMinPhi;    // Min phi.
  Float_t  fMaxPhi;    // Max phi.
  Float_t  fMinTheta;  // Min theta.
  Float_t  fMaxTheta;  // Max theta.

  ClassDef(AliEveITSModuleSelection, 0); // Helper for selecting a range of ITS modules by type, layer, phi and theta.
};


/******************************************************************************/
// AliEveITSDigitsInfo
/******************************************************************************/

class AliEveITSDigitsInfo : public TObject, public TEveRefCnt
{
public:
  TTree*                   fTree;         // Tree from which the digits are read.

  AliITSsegmentationSPD*   fSegSPD;       // Segmentation of SPD.
  AliITSsegmentationSDD*   fSegSDD;       // Segmentation of SDD.
  AliITSsegmentationSSD*   fSegSSD;       // Segmentation of SSD.

  Int_t                    fSPDMinVal;    // Default low  limit for display of SPD digits.
  Int_t                    fSSDMinVal;    // Default low  limit for display of SSD digits.
  Int_t                    fSDDMinVal;    // Default low  limit for display of SDD digits.
  Int_t                    fSPDMaxVal;    // Default high limit for display of SPD digits.
  Int_t                    fSSDMaxVal;    // Default high limit for display of SSD digits.
  Int_t                    fSDDMaxVal;    // Default high limit for display of SDD digits.

  Int_t                    fSPDHighLim;   // Maximum value of SPD digits.
  Int_t                    fSDDHighLim;   // Maximum value of SDD digits.
  Int_t                    fSSDHighLim;   // Maximum value of SSD digits.

  Int_t                    fSPDScaleX[5]; // SPD cell-sizes along X for display of scaled-digits.
  Int_t                    fSPDScaleZ[5]; // SPD cell-sizes along Z for display of scaled-digits.
  Int_t                    fSDDScaleX[5]; // SDD cell-sizes along X for display of scaled-digits.
  Int_t                    fSDDScaleZ[5]; // SDD cell-sizes along Z for display of scaled-digits.
  Int_t                    fSSDScale [5]; // SSD cell-sizes for display of scaled-digits.

  static AliITSDDLModuleMapSDD* fgDDLMapSDD;  // Mapping DDL/module to SDD-module number.

  AliEveITSDigitsInfo();
  virtual ~AliEveITSDigitsInfo();

  void SetTree(TTree* tree);
  void ReadRaw(AliRawReader* raw, Int_t mode);

  TClonesArray* GetDigits(Int_t moduleID, Int_t detector);

  void GetSPDLocalZ(Int_t j, Float_t& z) const;

  void GetModuleIDs(AliEveITSModuleSelection* sel, std::vector<UInt_t>& ids);

  virtual void Print(Option_t* opt="") const;

protected:
  std::map<Int_t,  TClonesArray*> fSPDmap; // Map from module-id to SPD data.
  std::map<Int_t,  TClonesArray*> fSDDmap; // Map from module-id to SDD data.
  std::map<Int_t,  TClonesArray*> fSSDmap; // Map from module-id to SSD data.

  void SetITSSegmentation();

private:
  Float_t fSPDZCoord[192]; // Precalculated z-coordinates for positions of digits.

  void InitInternals();

  AliEveITSDigitsInfo(const AliEveITSDigitsInfo&);            // Not implemented
  AliEveITSDigitsInfo& operator=(const AliEveITSDigitsInfo&); // Not implemented

  ClassDef(AliEveITSDigitsInfo, 0); // Stores ITS geometry information and event-data in format suitable for visualization.
};


inline void AliEveITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z) const
{
  z = fSPDZCoord[j];
}

#endif
Commit	Line	Data
	1	// $Id$
	2	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
	7	* full copyright notice. *
	8	**************************************************************************/
	9
	10	#ifndef AliEveITSDigitsInfo_H
	11	#define AliEveITSDigitsInfo_H
	12
	13	#include <TEveUtil.h>
	14	#include <TObject.h>
	15
	16	#include <map>
	17	#include <vector>
	18
	19	class TClonesArray;
	20	class TTree;
	21
	22	class AliITSsegmentationSPD;
	23	class AliITSsegmentationSDD;
	24	class AliITSsegmentationSSD;
	25	class AliITSDDLModuleMapSDD;
	26
	27	class AliRawReader;
	28
	29	/******************************************************************************/
	30	// AliEveITSModuleSelection
	31	/******************************************************************************/
	32
	33	class AliEveITSModuleSelection
	34	{
	35	public:
	36	AliEveITSModuleSelection();
	37	virtual ~AliEveITSModuleSelection() {}
	38
	39	Int_t GetType() const { return fType; }
	40	void SetType(Int_t x) { fType = x; }
	41	Int_t GetLayer() const { return fLayer; }
	42	void SetLayer(Int_t x) { fLayer = x; }
	43	Float_t GetMinPhi() const { return fMinPhi; }
	44	void SetMinPhi(Float_t x) { fMinPhi = x; }
	45	Float_t GetMaxPhi() const { return fMaxPhi; }
	46	void SetMaxPhi(Float_t x) { fMaxPhi = x; }
	47	Float_t GetMinTheta() const { return fMinTheta; }
	48	void SetMinTheta(Float_t x) { fMinTheta = x; }
	49	Float_t GetMaxTheta() const { return fMaxTheta; }
	50	void SetMaxTheta(Float_t x) { fMaxTheta = x; }
	51
	52	void SetPhiRange (Float_t x, Float_t y) { fMinPhi = x; fMaxPhi = y; }
	53	void SetThetaRange(Float_t x, Float_t y) { fMinTheta = x; fMaxTheta = y; }
	54
	55	protected:
	56	Int_t fType; // Type of modules: 0 - SPD, 1 - SDD, 2 - SSD.
	57	Int_t fLayer; // Layer, 0 - inner SPD, 5 - outer SSD.
	58	Float_t fMinPhi; // Min phi.
	59	Float_t fMaxPhi; // Max phi.
	60	Float_t fMinTheta; // Min theta.
	61	Float_t fMaxTheta; // Max theta.
	62
	63	ClassDef(AliEveITSModuleSelection, 0); // Helper for selecting a range of ITS modules by type, layer, phi and theta.
	64	};
	65
	66
	67	/******************************************************************************/
	68	// AliEveITSDigitsInfo
	69	/******************************************************************************/
	70
	71	class AliEveITSDigitsInfo : public TObject, public TEveRefCnt
	72	{
	73	public:
	74	TTree* fTree; // Tree from which the digits are read.
	75
	76	AliITSsegmentationSPD* fSegSPD; // Segmentation of SPD.
	77	AliITSsegmentationSDD* fSegSDD; // Segmentation of SDD.
	78	AliITSsegmentationSSD* fSegSSD; // Segmentation of SSD.
	79
	80	Int_t fSPDMinVal; // Default low limit for display of SPD digits.
	81	Int_t fSSDMinVal; // Default low limit for display of SSD digits.
	82	Int_t fSDDMinVal; // Default low limit for display of SDD digits.
	83	Int_t fSPDMaxVal; // Default high limit for display of SPD digits.
	84	Int_t fSSDMaxVal; // Default high limit for display of SSD digits.
	85	Int_t fSDDMaxVal; // Default high limit for display of SDD digits.
	86
	87	Int_t fSPDHighLim; // Maximum value of SPD digits.
	88	Int_t fSDDHighLim; // Maximum value of SDD digits.
	89	Int_t fSSDHighLim; // Maximum value of SSD digits.
	90
	91	Int_t fSPDScaleX[5]; // SPD cell-sizes along X for display of scaled-digits.
	92	Int_t fSPDScaleZ[5]; // SPD cell-sizes along Z for display of scaled-digits.
	93	Int_t fSDDScaleX[5]; // SDD cell-sizes along X for display of scaled-digits.
	94	Int_t fSDDScaleZ[5]; // SDD cell-sizes along Z for display of scaled-digits.
	95	Int_t fSSDScale [5]; // SSD cell-sizes for display of scaled-digits.
	96
	97	static AliITSDDLModuleMapSDD* fgDDLMapSDD; // Mapping DDL/module to SDD-module number.
	98
	99	AliEveITSDigitsInfo();
	100	virtual ~AliEveITSDigitsInfo();
	101
	102	void SetTree(TTree* tree);
	103	void ReadRaw(AliRawReader* raw, Int_t mode);
	104
	105	TClonesArray* GetDigits(Int_t moduleID, Int_t detector);
	106
	107	void GetSPDLocalZ(Int_t j, Float_t& z) const;
	108
	109	void GetModuleIDs(AliEveITSModuleSelection* sel, std::vector<UInt_t>& ids);
	110
	111	virtual void Print(Option_t* opt="") const;
	112
	113	protected:
	114	std::map<Int_t, TClonesArray*> fSPDmap; // Map from module-id to SPD data.
	115	std::map<Int_t, TClonesArray*> fSDDmap; // Map from module-id to SDD data.
	116	std::map<Int_t, TClonesArray*> fSSDmap; // Map from module-id to SSD data.
	117
	118	void SetITSSegmentation();
	119
	120	private:
	121	Float_t fSPDZCoord[192]; // Precalculated z-coordinates for positions of digits.
	122
	123	void InitInternals();
	124
	125	AliEveITSDigitsInfo(const AliEveITSDigitsInfo&); // Not implemented
	126	AliEveITSDigitsInfo& operator=(const AliEveITSDigitsInfo&); // Not implemented
	127
	128	ClassDef(AliEveITSDigitsInfo, 0); // Stores ITS geometry information and event-data in format suitable for visualization.
	129	};
	130
	131
	132	inline void AliEveITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z) const
	133	{
	134	z = fSPDZCoord[j];
	135	}
	136
	137	#endif