[u/mrichter/AliRoot.git] / MUON / AliMUONGeometryTransformer.h

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

// $Id$

/// \ingroup geometry
/// \class AliMUONGeometryTransformer
/// \brief Top container class for geometry transformations
///
/// Geometry transformations can be filled in these ways:
/// - by geometry builder when geometry is built via builders
///   (this way is used when running simulation and building geometry
///    via VirtualMC)
/// - from Root geometry file (*.root) or ASCII file (*.dat) using
///   the method LoadGeometryData(const TString& fileName)
/// - from geometry loaded in AliGeomManager using
///   the method LoadGeometryData() without arguments
/// 
/// \author Ivana Hrivnacova, IPN Orsay

#ifndef ALI_MUON_GEOMETRY_TRANSFORMER_H
#define ALI_MUON_GEOMETRY_TRANSFORMER_H

#include <TObject.h>
#include <TObjArray.h>
#include <TGeoMatrix.h>

class AliMUONGeometryModuleTransformer;
class AliMUONGeometryDetElement;

class TGeoManager;
class TClonesArray;
class AliMpExMap;
class AliMpArea;

using std::ifstream;
using std::ofstream;

class AliMUONGeometryTransformer : public TObject
{
  public:
    AliMUONGeometryTransformer();
    AliMUONGeometryTransformer(TRootIOCtor* /*ioCtor*/);
    virtual  ~AliMUONGeometryTransformer();
    
    // methods
    void  AddModuleTransformer(AliMUONGeometryModuleTransformer* transformer);
    void  AddMisAlignModule(Int_t moduleId, const TGeoHMatrix& matrix, Bool_t bGlobal = kTRUE);
    void  AddMisAlignDetElement(Int_t detElemId, const TGeoHMatrix& matrix, Bool_t bGlobal = kTRUE);
    void  CreateModules();

    void  AddAlignableVolumes() const; 
    TClonesArray* CreateZeroAlignmentData() const;
    void  ClearMisAlignmentData();	

    // IO
    //
    Bool_t  LoadTransformations(); 
    Bool_t  LoadGeometryData(const TString& fileName);
    Bool_t  LoadGeometryData();

    Bool_t  WriteTransformations(const TString& fileName) const;
    Bool_t  WriteMisAlignmentData(const TString& fileName) const;

    // Transformation methods 
    //
    void Global2Local(Int_t detElemId,
                 Float_t xg, Float_t yg, Float_t zg, 
                 Float_t& xl, Float_t& yl, Float_t& zl) const;
    void Global2Local(Int_t detElemId,
                 Double_t xg, Double_t yg, Double_t zg, 
                 Double_t& xl, Double_t& yl, Double_t& zl) const;

    void Local2Global(Int_t detElemId,
                 Float_t xl, Float_t yl, Float_t zl, 
                 Float_t& xg, Float_t& yg, Float_t& zg) const;
    void Local2Global(Int_t detElemId,
                 Double_t xl, Double_t yl, Double_t zl, 
                 Double_t& xg, Double_t& yg, Double_t& zg) const;
                 
    // Set methods
    void SetDetName(const TString& detName);                 
    void SetOwner(Bool_t isOwner);                 

    // Get methods
    //
    Int_t GetNofModuleTransformers() const;
    const AliMUONGeometryModuleTransformer* GetModuleTransformer(
                               Int_t index, Bool_t warn = true) const;

    const AliMUONGeometryModuleTransformer* GetModuleTransformerByDEId(
                               Int_t detElemId, Bool_t warn = true) const;

    const AliMUONGeometryDetElement* GetDetElement(
                               Int_t detElemId, Bool_t warn = true) const;

    const TClonesArray* GetMisAlignmentData() const;
    
    Bool_t  HasDE(Int_t detElemId) const;

    AliMpArea* GetDEArea(Int_t detElemId) const;
    
  protected:
    /// Not implemented
    AliMUONGeometryTransformer(const AliMUONGeometryTransformer& right);
    /// Not implemented
    AliMUONGeometryTransformer&  operator = (const AliMUONGeometryTransformer& right);
 
  private:
    // static methods
    static const TString&  GetDefaultDetectorName(); 

    // methods
      
    void CreateDEAreas() const;
    
    Bool_t LoadMapping() const;
    AliMUONGeometryModuleTransformer* GetModuleTransformerNonConst(
                                    Int_t index, Bool_t warn = true) const;

    TGeoHMatrix GetTransform(
                  Double_t x, Double_t y, Double_t z,
		  Double_t a1, Double_t a2, Double_t a3, 
 		  Double_t a4, Double_t a5, Double_t a6) const;

    void FillModuleTransform(Int_t moduleId,
                  Double_t x, Double_t y, Double_t z,
		  Double_t a1, Double_t a2, Double_t a3, 
 		  Double_t a4, Double_t a5, Double_t a6); 
    void FillDetElemTransform(Int_t id, 
                  Double_t x, Double_t y, Double_t z,
		  Double_t a1, Double_t a2, Double_t a3, 
 		  Double_t a4, Double_t a5, Double_t a6);

    TString ReadModuleTransforms(ifstream& in);
    TString ReadDetElemTransforms(ifstream& in);
    Bool_t  ReadTransformations(const TString& fileName);

    void    WriteTransform(ofstream& out, const TGeoMatrix* transform) const;
    void    WriteModuleTransforms(ofstream& out) const;
    void    WriteDetElemTransforms(ofstream& out) const;
    
    TString GetModuleSymName(Int_t moduleId) const;
    TString GetDESymName(Int_t detElemId) const;

    // data members
    TString        fDetectorName;       ///< Detector name
    TObjArray*     fModuleTransformers; ///< array of module transformers
    TClonesArray*  fMisAlignArray;      ///< array of misalignment data
    mutable AliMpExMap*    fDEAreas; ///< areas of detection elements in global coordinates
    
  ClassDef(AliMUONGeometryTransformer,4)  // Geometry parametrisation
};

// inline methods

/// Return the number of contained module transformers
inline Int_t AliMUONGeometryTransformer::GetNofModuleTransformers() const
{ return fModuleTransformers->GetEntriesFast(); }

/// Return the array of misalignment data
inline const TClonesArray* AliMUONGeometryTransformer::GetMisAlignmentData() const	
{ return fMisAlignArray; }		       
			       
/// Set detector name
inline void AliMUONGeometryTransformer::SetDetName(const TString& detName)
{  fDetectorName = detName; }               

/// Set ownership of array module transformers
inline void AliMUONGeometryTransformer::SetOwner(Bool_t isOwner)
{  fModuleTransformers->SetOwner(isOwner); }               

#endif //ALI_MUON_GEOMETRY_TRANSFORMER_H
Commit	Line	Data
	1	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	2	* See cxx source for full Copyright notice */
	3
	4	// $Id$
	5
	6	/// \ingroup geometry
	7	/// \class AliMUONGeometryTransformer
	8	/// \brief Top container class for geometry transformations
	9	///
	10	/// Geometry transformations can be filled in these ways:
	11	/// - by geometry builder when geometry is built via builders
	12	/// (this way is used when running simulation and building geometry
	13	/// via VirtualMC)
	14	/// - from Root geometry file (.root) or ASCII file (.dat) using
	15	/// the method LoadGeometryData(const TString& fileName)
	16	/// - from geometry loaded in AliGeomManager using
	17	/// the method LoadGeometryData() without arguments
	18	///
	19	/// \author Ivana Hrivnacova, IPN Orsay
	20
	21	#ifndef ALI_MUON_GEOMETRY_TRANSFORMER_H
	22	#define ALI_MUON_GEOMETRY_TRANSFORMER_H
	23
	24	#include <TObject.h>
	25	#include <TObjArray.h>
	26	#include <TGeoMatrix.h>
	27
	28	class AliMUONGeometryModuleTransformer;
	29	class AliMUONGeometryDetElement;
	30
	31	class TGeoManager;
	32	class TClonesArray;
	33	class AliMpExMap;
	34	class AliMpArea;
	35
	36	using std::ifstream;
	37	using std::ofstream;
	38
	39	class AliMUONGeometryTransformer : public TObject
	40	{
	41	public:
	42	AliMUONGeometryTransformer();
	43	AliMUONGeometryTransformer(TRootIOCtor* /ioCtor/);
	44	virtual ~AliMUONGeometryTransformer();
	45
	46	// methods
	47	void AddModuleTransformer(AliMUONGeometryModuleTransformer* transformer);
	48	void AddMisAlignModule(Int_t moduleId, const TGeoHMatrix& matrix, Bool_t bGlobal = kTRUE);
	49	void AddMisAlignDetElement(Int_t detElemId, const TGeoHMatrix& matrix, Bool_t bGlobal = kTRUE);
	50	void CreateModules();
	51
	52	void AddAlignableVolumes() const;
	53	TClonesArray* CreateZeroAlignmentData() const;
	54	void ClearMisAlignmentData();
	55
	56	// IO
	57	//
	58	Bool_t LoadTransformations();
	59	Bool_t LoadGeometryData(const TString& fileName);
	60	Bool_t LoadGeometryData();
	61
	62	Bool_t WriteTransformations(const TString& fileName) const;
	63	Bool_t WriteMisAlignmentData(const TString& fileName) const;
	64
	65	// Transformation methods
	66	//
	67	void Global2Local(Int_t detElemId,
	68	Float_t xg, Float_t yg, Float_t zg,
	69	Float_t& xl, Float_t& yl, Float_t& zl) const;
	70	void Global2Local(Int_t detElemId,
	71	Double_t xg, Double_t yg, Double_t zg,
	72	Double_t& xl, Double_t& yl, Double_t& zl) const;
	73
	74	void Local2Global(Int_t detElemId,
	75	Float_t xl, Float_t yl, Float_t zl,
	76	Float_t& xg, Float_t& yg, Float_t& zg) const;
	77	void Local2Global(Int_t detElemId,
	78	Double_t xl, Double_t yl, Double_t zl,
	79	Double_t& xg, Double_t& yg, Double_t& zg) const;
	80
	81	// Set methods
	82	void SetDetName(const TString& detName);
	83	void SetOwner(Bool_t isOwner);
	84
	85	// Get methods
	86	//
	87	Int_t GetNofModuleTransformers() const;
	88	const AliMUONGeometryModuleTransformer* GetModuleTransformer(
	89	Int_t index, Bool_t warn = true) const;
	90
	91	const AliMUONGeometryModuleTransformer* GetModuleTransformerByDEId(
	92	Int_t detElemId, Bool_t warn = true) const;
	93
	94	const AliMUONGeometryDetElement* GetDetElement(
	95	Int_t detElemId, Bool_t warn = true) const;
	96
	97	const TClonesArray* GetMisAlignmentData() const;
	98
	99	Bool_t HasDE(Int_t detElemId) const;
	100
	101	AliMpArea* GetDEArea(Int_t detElemId) const;
	102
	103	protected:
	104	/// Not implemented
	105	AliMUONGeometryTransformer(const AliMUONGeometryTransformer& right);
	106	/// Not implemented
	107	AliMUONGeometryTransformer& operator = (const AliMUONGeometryTransformer& right);
	108
	109	private:
	110	// static methods
	111	static const TString& GetDefaultDetectorName();
	112
	113	// methods
	114
	115	void CreateDEAreas() const;
	116
	117	Bool_t LoadMapping() const;
	118	AliMUONGeometryModuleTransformer* GetModuleTransformerNonConst(
	119	Int_t index, Bool_t warn = true) const;
	120
	121	TGeoHMatrix GetTransform(
	122	Double_t x, Double_t y, Double_t z,
	123	Double_t a1, Double_t a2, Double_t a3,
	124	Double_t a4, Double_t a5, Double_t a6) const;
	125
	126	void FillModuleTransform(Int_t moduleId,
	127	Double_t x, Double_t y, Double_t z,
	128	Double_t a1, Double_t a2, Double_t a3,
	129	Double_t a4, Double_t a5, Double_t a6);
	130	void FillDetElemTransform(Int_t id,
	131	Double_t x, Double_t y, Double_t z,
	132	Double_t a1, Double_t a2, Double_t a3,
	133	Double_t a4, Double_t a5, Double_t a6);
	134
	135	TString ReadModuleTransforms(ifstream& in);
	136	TString ReadDetElemTransforms(ifstream& in);
	137	Bool_t ReadTransformations(const TString& fileName);
	138
	139	void WriteTransform(ofstream& out, const TGeoMatrix* transform) const;
	140	void WriteModuleTransforms(ofstream& out) const;
	141	void WriteDetElemTransforms(ofstream& out) const;
	142
	143	TString GetModuleSymName(Int_t moduleId) const;
	144	TString GetDESymName(Int_t detElemId) const;
	145
	146	// data members
	147	TString fDetectorName; ///< Detector name
	148	TObjArray* fModuleTransformers; ///< array of module transformers
	149	TClonesArray* fMisAlignArray; ///< array of misalignment data
	150	mutable AliMpExMap* fDEAreas; ///< areas of detection elements in global coordinates
	151
	152	ClassDef(AliMUONGeometryTransformer,4) // Geometry parametrisation
	153	};
	154
	155	// inline methods
	156
	157	/// Return the number of contained module transformers
	158	inline Int_t AliMUONGeometryTransformer::GetNofModuleTransformers() const
	159	{ return fModuleTransformers->GetEntriesFast(); }
	160
	161	/// Return the array of misalignment data
	162	inline const TClonesArray* AliMUONGeometryTransformer::GetMisAlignmentData() const
	163	{ return fMisAlignArray; }
	164
	165	/// Set detector name
	166	inline void AliMUONGeometryTransformer::SetDetName(const TString& detName)
	167	{ fDetectorName = detName; }
	168
	169	/// Set ownership of array module transformers
	170	inline void AliMUONGeometryTransformer::SetOwner(Bool_t isOwner)
	171	{ fModuleTransformers->SetOwner(isOwner); }
	172
	173	#endif //ALI_MUON_GEOMETRY_TRANSFORMER_H
	174
	175
	176
	177
	178
	179
	180