[u/mrichter/AliRoot.git] / TGeant4 / TG4GeometryManager.h

// $Id$
// Category: geometry
//
// Geant4 implementation of the MonteCarlo interface methods                    
// for building Geant4 geometry and access to it.

#ifndef TG4_GEOMETRY_MANAGER_H
#define TG4_GEOMETRY_MANAGER_H

#include "TG4NameMap.h"
#include "TG4Globals.h"

#include <globals.hh>
#include <G3SensVolVector.hh>

#include <Rtypes.h>

#include <g4std/fstream>
#include <g4std/vector>

class TG4CutVector;
class TG4FlagVector;
class TG4GeometryOutputManager;
class TG4GeometryServices;

class G4Material;
class G4VPhysicalVolume;
class G4LogicalVolume;

class TG4GeometryManager
{
  public:
    TG4GeometryManager();
    // --> protected
    // TG4GeometryManager(const TG4GeometryManager& right);
    virtual ~TG4GeometryManager();

    // static access method
    static TG4GeometryManager* Instance();

    //
    // methods (from the base class)
    
    // detector composition
    void  Material(Int_t& kmat, const char* name, Float_t a, 
                     Float_t z, Float_t dens, Float_t radl, Float_t absl,
                     Float_t* buf, Int_t nwbuf);
    void  Mixture(Int_t& kmat, const char *name, Float_t *a, 
                     Float_t *z, Float_t dens, Int_t nlmat, Float_t *wmat);
    void  Medium(Int_t& kmed, const char *name, Int_t nmat, 
                     Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd, 
                     Float_t stemax, Float_t deemax, Float_t epsil, 
		     Float_t stmin, Float_t* ubuf, Int_t nbuf);
    void  Matrix(Int_t& krot, Double_t thetaX, Double_t phiX, 
                     Double_t thetaY, Double_t phiY, Double_t thetaZ, 
		     Double_t phiZ);
    void  Matrix(Int_t& krot, Float_t thetaX, Float_t phiX, 
                     Float_t thetaY, Float_t phiY, Float_t thetaZ, 
		     Float_t phiZ);

    // functions from GBASE 
    void  Ggclos(); 

    // functions from GCONS 
    void  Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,  
  		         Float_t &dens, Float_t &radl, Float_t &absl,
		         Float_t* ubuf, Int_t& nbuf); 
    void  Gstpar(Int_t itmed, const char *param, Float_t parval); 
    void  SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
			 Float_t *absco, Float_t *effic, Float_t *rindex); 

    // functions from GGEOM 
    Int_t Gsvolu(const char *name, const char *shape, Int_t nmed,  
                         Double_t *upar, Int_t np); 
    Int_t Gsvolu(const char *name, const char *shape, Int_t nmed,  
                         Float_t *upar, Int_t np); 
    void  Gsdvn(const char *name, const char *mother, Int_t ndiv, 
                        Int_t iaxis);
    void  Gsdvn2(const char *name, const char *mother, Int_t ndiv, 
                         Int_t iaxis, Double_t c0i, Int_t numed); 
    void  Gsdvn2(const char *name, const char *mother, Int_t ndiv, 
                         Int_t iaxis, Float_t c0i, Int_t numed); 
    void  Gsdvt(const char *name, const char *mother, Double_t step,
                         Int_t iaxis, Int_t numed, Int_t ndvmx); 
    void  Gsdvt(const char *name, const char *mother, Float_t step,
                         Int_t iaxis, Int_t numed, Int_t ndvmx); 
    void  Gsdvt2(const char *name, const char *mother, Double_t step, 
                         Int_t iaxis, Double_t c0, Int_t numed, Int_t ndvmx); 
    void  Gsdvt2(const char *name, const char *mother, Float_t step, 
                         Int_t iaxis, Float_t c0, Int_t numed, Int_t ndvmx); 

    void  Gsord(const char *name, Int_t iax); 
    void  Gspos(const char *name, Int_t nr, const char *mother,  
                        Double_t x, Double_t y, Double_t z, Int_t irot, 
                        const char *konly); 
    void  Gspos(const char *name, Int_t nr, const char *mother,  
                        Float_t x, Float_t y, Float_t z, Int_t irot, 
                        const char *konly); 
    void  Gsposp(const char *name, Int_t nr, const char *mother,  
                         Double_t x, Double_t y, Double_t z, Int_t irot,
                         const char *konly, Double_t *upar, Int_t np); 
    void  Gsposp(const char *name, Int_t nr, const char *mother,  
                         Float_t x, Float_t y, Float_t z, Int_t irot,
                         const char *konly, Float_t *upar, Int_t np); 
        
    // Euclid		       
    void WriteEuclid(const char* fileName, const char* topVolName, 
                         Int_t number, Int_t nlevel); //new
		               
    // end of methods
    // 

    //
    // methods for Geant4 only 
 
    G4VPhysicalVolume* CreateG4Geometry();
    void ReadG3Geometry(G4String filePath);
    void UseG3TrackingMediaLimits();
    void FillMediumIdVector();
    void ClearG3Tables();       
    void ClearG3TablesFinal();
    void OpenOutFile(G4String filePath);
    void CloseOutFile();
    void PrintNameMap();
    
    // set methods
    void SetWriteGeometry(G4bool writeGeometry);
    void SetMapSecond(const G4String& name);
     
  protected:
    TG4GeometryManager(const TG4GeometryManager& right);

    // operators
    TG4GeometryManager& operator=(const TG4GeometryManager& right);

  private:
    // methods
    void SetUserLimits();
        
    // static data members
    static TG4GeometryManager*  fgInstance;     //this instance

    // data members
    TG4GeometryOutputManager*   fOutputManager;   //output manager 
    TG4GeometryServices*        fGeometryServices;//geometry services
    TG4intVector  fMediumIdVector;  //vector of second indexes for materials
    TG4NameMap    fNameMap;         //map of volumes names to modules names
    G4int         fMediumCounter;   //global medium counter
    G4int         fMaterialCounter; //global material counter
    G4int         fMatrixCounter;   //global matrix counter
    G4bool        fUseG3TMLimits;   //if true: G3 limits are passed to G4 
                                    //(in development)
    G4bool        fWriteGeometry;   //if true: geometry parameters are written
                                    //in a file (ASCII)  
};

// inline methods
inline TG4GeometryManager* TG4GeometryManager::Instance()
{ return fgInstance; }

#endif //TG4_GEOMETRY_MANAGER_H
Commit	Line	Data
2817d3e2	1	// $Id$
	2	// Category: geometry
	3	//
	4	// Geant4 implementation of the MonteCarlo interface methods
9a226a21	5	// for building Geant4 geometry and access to it.
2817d3e2	6
	7	#ifndef TG4_GEOMETRY_MANAGER_H
	8	#define TG4_GEOMETRY_MANAGER_H
	9
	10	#include "TG4NameMap.h"
	11	#include "TG4Globals.h"
2817d3e2	12
	13	#include <globals.hh>
	14	#include <G3SensVolVector.hh>
	15
	16	#include <Rtypes.h>
	17
63c8351a	18	#include <g4std/fstream>
63c8351a	19	#include <g4std/vector>
2817d3e2	20
	21	class TG4CutVector;
	22	class TG4FlagVector;
	23	class TG4GeometryOutputManager;
154fc5a5	24	class TG4GeometryServices;
2817d3e2	25
	26	class G4Material;
	27	class G4VPhysicalVolume;
154fc5a5	28	class G4LogicalVolume;
2817d3e2	29
	30	class TG4GeometryManager
	31	{
	32	public:
	33	TG4GeometryManager();
	34	// --> protected
	35	// TG4GeometryManager(const TG4GeometryManager& right);
	36	virtual ~TG4GeometryManager();
	37
	38	// static access method
	39	static TG4GeometryManager* Instance();
	40
	41	//
	42	// methods (from the base class)
	43
	44	// detector composition
	45	void Material(Int_t& kmat, const char* name, Float_t a,
	46	Float_t z, Float_t dens, Float_t radl, Float_t absl,
	47	Float_t* buf, Int_t nwbuf);
	48	void Mixture(Int_t& kmat, const char name, Float_t a,
	49	Float_t z, Float_t dens, Int_t nlmat, Float_t wmat);
	50	void Medium(Int_t& kmed, const char *name, Int_t nmat,
	51	Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd,
	52	Float_t stemax, Float_t deemax, Float_t epsil,
	53	Float_t stmin, Float_t* ubuf, Int_t nbuf);
2ce4a261	54	void Matrix(Int_t& krot, Double_t thetaX, Double_t phiX,
	55	Double_t thetaY, Double_t phiY, Double_t thetaZ,
	56	Double_t phiZ);
2817d3e2	57	void Matrix(Int_t& krot, Float_t thetaX, Float_t phiX,
	58	Float_t thetaY, Float_t phiY, Float_t thetaZ,
	59	Float_t phiZ);
	60
2817d3e2	61	// functions from GBASE
	62	void Ggclos();
	63
	64	// functions from GCONS
	65	void Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,
	66	Float_t &dens, Float_t &radl, Float_t &absl,
	67	Float_t* ubuf, Int_t& nbuf);
	68	void Gstpar(Int_t itmed, const char *param, Float_t parval);
ad390979	69	void SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
2817d3e2	70	Float_t absco, Float_t effic, Float_t *rindex);
	71
	72	// functions from GGEOM
2ce4a261	73	Int_t Gsvolu(const char name, const char shape, Int_t nmed,
2ce4a261	74	Double_t *upar, Int_t np);
2817d3e2	75	Int_t Gsvolu(const char name, const char shape, Int_t nmed,
	76	Float_t *upar, Int_t np);
	77	void Gsdvn(const char name, const char mother, Int_t ndiv,
	78	Int_t iaxis);
2ce4a261	79	void Gsdvn2(const char name, const char mother, Int_t ndiv,
2ce4a261	80	Int_t iaxis, Double_t c0i, Int_t numed);
2817d3e2	81	void Gsdvn2(const char name, const char mother, Int_t ndiv,
2817d3e2	82	Int_t iaxis, Float_t c0i, Int_t numed);
2ce4a261	83	void Gsdvt(const char name, const char mother, Double_t step,
2ce4a261	84	Int_t iaxis, Int_t numed, Int_t ndvmx);
2817d3e2	85	void Gsdvt(const char name, const char mother, Float_t step,
2817d3e2	86	Int_t iaxis, Int_t numed, Int_t ndvmx);
2ce4a261	87	void Gsdvt2(const char name, const char mother, Double_t step,
2ce4a261	88	Int_t iaxis, Double_t c0, Int_t numed, Int_t ndvmx);
2817d3e2	89	void Gsdvt2(const char name, const char mother, Float_t step,
	90	Int_t iaxis, Float_t c0, Int_t numed, Int_t ndvmx);
	91
	92	void Gsord(const char *name, Int_t iax);
2ce4a261	93	void Gspos(const char name, Int_t nr, const char mother,
	94	Double_t x, Double_t y, Double_t z, Int_t irot,
	95	const char *konly);
2817d3e2	96	void Gspos(const char name, Int_t nr, const char mother,
	97	Float_t x, Float_t y, Float_t z, Int_t irot,
	98	const char *konly);
2ce4a261	99	void Gsposp(const char name, Int_t nr, const char mother,
	100	Double_t x, Double_t y, Double_t z, Int_t irot,
	101	const char konly, Double_t upar, Int_t np);
2817d3e2	102	void Gsposp(const char name, Int_t nr, const char mother,
	103	Float_t x, Float_t y, Float_t z, Int_t irot,
	104	const char konly, Float_t upar, Int_t np);
	105
	106	// Euclid
57f88f6f	107	void WriteEuclid(const char* fileName, const char* topVolName,
57f88f6f	108	Int_t number, Int_t nlevel); //new
2817d3e2	109
2817d3e2	110	// end of methods
	111	//
	112
	113	//
	114	// methods for Geant4 only
	115
	116	G4VPhysicalVolume* CreateG4Geometry();
	117	void ReadG3Geometry(G4String filePath);
	118	void UseG3TrackingMediaLimits();
154fc5a5	119	void FillMediumIdVector();
2817d3e2	120	void ClearG3Tables();
	121	void ClearG3TablesFinal();
	122	void OpenOutFile(G4String filePath);
73b4b945	123	void CloseOutFile();
2817d3e2	124	void PrintNameMap();
	125
	126	// set methods
	127	void SetWriteGeometry(G4bool writeGeometry);
	128	void SetMapSecond(const G4String& name);
154fc5a5	129
2817d3e2	130	protected:
	131	TG4GeometryManager(const TG4GeometryManager& right);
	132
	133	// operators
	134	TG4GeometryManager& operator=(const TG4GeometryManager& right);
	135
	136	private:
	137	// methods
2ce4a261	138	void SetUserLimits();
2817d3e2	139
	140	// static data members
	141	static TG4GeometryManager* fgInstance; //this instance
	142
	143	// data members
154fc5a5	144	TG4GeometryOutputManager* fOutputManager; //output manager
154fc5a5	145	TG4GeometryServices* fGeometryServices;//geometry services
3c7cd15a	146	TG4intVector fMediumIdVector; //vector of second indexes for materials
154fc5a5	147	TG4NameMap fNameMap; //map of volumes names to modules names
3c7cd15a	148	G4int fMediumCounter; //global medium counter
	149	G4int fMaterialCounter; //global material counter
	150	G4int fMatrixCounter; //global matrix counter
	151	G4bool fUseG3TMLimits; //if true: G3 limits are passed to G4
	152	//(in development)
	153	G4bool fWriteGeometry; //if true: geometry parameters are written
	154	//in a file (ASCII)
2817d3e2	155	};
	156
	157	// inline methods
	158	inline TG4GeometryManager* TG4GeometryManager::Instance()
	159	{ return fgInstance; }
	160
2817d3e2	161	#endif //TG4_GEOMETRY_MANAGER_H
2817d3e2	162