PamG4/include/DetectorConstruction.hh


#ifndef DetectorConstruction_h
#define DetectorConstruction_h 1

#include "G4VUserDetectorConstruction.hh"
#include "globals.hh"

class G4VPhysicalVolume;
class G4Box;
class G4Tubs;
class G4Trd;
class G4LogicalVolume;

class DetectorConstruction : public G4VUserDetectorConstruction
{
  public:
    DetectorConstruction();
    ~DetectorConstruction();

  public:
  
     G4VPhysicalVolume* Construct();
public:
  
  G4double GetWorld_Z()        {return World_Z;};
  G4double GetWorld_XY()       {return World_XY;};
  G4double GetCalor_XY()       {return Calor_XY;};
  G4double GetCalorThickness() {return CalorTh;};

private: 
  G4Box* solidWorld; 

  G4Box* solidAbsorber;
  G4Box* solidPcb;
  G4Box* solidSiLayerY;
  G4Box* solidSiLayerX;
  G4Box* solidStrPlateY;
  G4Box* solidStrPlateX;
  G4Box* solidStrX_L;
  G4Box* solidStrY_L;

  G4Box* solidS1;
  G4Box* solidS2;
  G4Box* solidS3;
  G4Box* solidS4;
  G4Box* solidCAT;
  G4Box* solidCAT1;
  G4Box* solidCASX;
  G4Box* solidCASY;
  G4Box* solidAl;
  G4Trd* solidCARD;
  G4Trd* solidCARD1;

  G4Box* solidMag;
  G4Box* solidMagAir;
  G4Box* solidMagSiLayer;
  G4Box* solidMagSiPlate;

    G4Box*  solidPol; 
    G4Tubs * He3Ar_tubs;
    G4Tubs * Fe_tubs;
  //---------------------------------------------------------------
  G4LogicalVolume* logicWorld;

  G4LogicalVolume* logicAbsorber;
  G4LogicalVolume* logicPcb;
  G4LogicalVolume* logicSiLayerY;
  G4LogicalVolume* logicSiLayerX;
  G4LogicalVolume* logicStrPlateY;
  G4LogicalVolume* logicStrPlateX;
  G4LogicalVolume* logicStrX_L;
  G4LogicalVolume* logicStrY_L;

  G4LogicalVolume* logicS1;
  G4LogicalVolume* logicS2;
  G4LogicalVolume* logicS3;
  G4LogicalVolume* logicS4;
  G4LogicalVolume* logicCAT;
  G4LogicalVolume* logicCAT1;
  G4LogicalVolume* logicCASX;
  G4LogicalVolume* logicCASY;
  G4LogicalVolume* logicCARD;
  G4LogicalVolume* logicCARD1;

  G4LogicalVolume* logicAl;

  G4LogicalVolume* logicMag;
  G4LogicalVolume* logicMagAir;
  G4LogicalVolume* logicMagSiLayer;
  G4LogicalVolume* logicMagSiPlate;

  G4LogicalVolume* logicPol;
  G4LogicalVolume*  He3Ar_log;
  G4LogicalVolume*  Fe_log;
  //--------------------------------------------------------------------
  G4VPhysicalVolume* physiWorld;

  G4VPhysicalVolume* physiStrPlateY;
  G4VPhysicalVolume* physiStrPlateX;
  G4VPhysicalVolume* physiStrY_L;
  G4VPhysicalVolume* physiStrX_L;
  G4VPhysicalVolume* physiAbsorber;
  G4VPhysicalVolume* physiPcb;
  G4VPhysicalVolume* physiSiLayerY;
  G4VPhysicalVolume* physiSiLayerX;

  G4VPhysicalVolume* physiS1;
  G4VPhysicalVolume* physiS2;
  G4VPhysicalVolume* physiS3;
  G4VPhysicalVolume* physiS4;
  G4VPhysicalVolume* physiCAT;
  G4VPhysicalVolume* physiCAT1;
  G4VPhysicalVolume* physiCARD;
  G4VPhysicalVolume* physiCARD1;
  G4VPhysicalVolume* physiCASX;
  G4VPhysicalVolume* physiCASY;

  G4VPhysicalVolume* physiAl;
  G4VPhysicalVolume* physiPol;

  G4VPhysicalVolume* physiMag;
  G4VPhysicalVolume* physiMagAir;
  G4VPhysicalVolume* physiMagSiLayer;
  G4VPhysicalVolume* physiMagSiPlate;

  G4VPhysicalVolume* physiHe3Ar;
  G4VPhysicalVolume* physiFe;

G4double CalorSTh;
G4double CalorTh;
G4double Calor_XY;
G4double World_Z;
G4double World_XY;
G4double PcbTh;
G4double AbsorberTh;  
G4double  SiLayerTh;

};

#endif


// 2005 by G.I.Vasilyev
1	cafagna	1.1
2			#ifndef DetectorConstruction_h
3			#define DetectorConstruction_h 1
4
5			#include "G4VUserDetectorConstruction.hh"
6			#include "globals.hh"
7
8			class G4VPhysicalVolume;
9			class G4Box;
10			class G4Tubs;
11			class G4Trd;
12			class G4LogicalVolume;
13
14			class DetectorConstruction : public G4VUserDetectorConstruction
15			{
16			public:
17			DetectorConstruction();
18			~DetectorConstruction();
19
20			public:
21
22			G4VPhysicalVolume* Construct();
23			public:
24
25			G4double GetWorld_Z() {return World_Z;};
26			G4double GetWorld_XY() {return World_XY;};
27			G4double GetCalor_XY() {return Calor_XY;};
28			G4double GetCalorThickness() {return CalorTh;};
29
30			private:
31			G4Box* solidWorld;
32
33			G4Box* solidAbsorber;
34			G4Box* solidPcb;
35			G4Box* solidSiLayerY;
36			G4Box* solidSiLayerX;
37			G4Box* solidStrPlateY;
38			G4Box* solidStrPlateX;
39			G4Box* solidStrX_L;
40			G4Box* solidStrY_L;
41
42			G4Box* solidS1;
43			G4Box* solidS2;
44			G4Box* solidS3;
45			G4Box* solidS4;
46			G4Box* solidCAT;
47			G4Box* solidCAT1;
48			G4Box* solidCASX;
49			G4Box* solidCASY;
50			G4Box* solidAl;
51			G4Trd* solidCARD;
52			G4Trd* solidCARD1;
53
54			G4Box* solidMag;
55			G4Box* solidMagAir;
56			G4Box* solidMagSiLayer;
57			G4Box* solidMagSiPlate;
58
59			G4Box* solidPol;
60			G4Tubs * He3Ar_tubs;
61			G4Tubs * Fe_tubs;
62			//---------------------------------------------------------------
63			G4LogicalVolume* logicWorld;
64
65			G4LogicalVolume* logicAbsorber;
66			G4LogicalVolume* logicPcb;
67			G4LogicalVolume* logicSiLayerY;
68			G4LogicalVolume* logicSiLayerX;
69			G4LogicalVolume* logicStrPlateY;
70			G4LogicalVolume* logicStrPlateX;
71			G4LogicalVolume* logicStrX_L;
72			G4LogicalVolume* logicStrY_L;
73
74			G4LogicalVolume* logicS1;
75			G4LogicalVolume* logicS2;
76			G4LogicalVolume* logicS3;
77			G4LogicalVolume* logicS4;
78			G4LogicalVolume* logicCAT;
79			G4LogicalVolume* logicCAT1;
80			G4LogicalVolume* logicCASX;
81			G4LogicalVolume* logicCASY;
82			G4LogicalVolume* logicCARD;
83			G4LogicalVolume* logicCARD1;
84
85			G4LogicalVolume* logicAl;
86
87			G4LogicalVolume* logicMag;
88			G4LogicalVolume* logicMagAir;
89			G4LogicalVolume* logicMagSiLayer;
90			G4LogicalVolume* logicMagSiPlate;
91
92			G4LogicalVolume* logicPol;
93			G4LogicalVolume* He3Ar_log;
94			G4LogicalVolume* Fe_log;
95			//--------------------------------------------------------------------
96			G4VPhysicalVolume* physiWorld;
97
98			G4VPhysicalVolume* physiStrPlateY;
99			G4VPhysicalVolume* physiStrPlateX;
100			G4VPhysicalVolume* physiStrY_L;
101			G4VPhysicalVolume* physiStrX_L;
102			G4VPhysicalVolume* physiAbsorber;
103			G4VPhysicalVolume* physiPcb;
104			G4VPhysicalVolume* physiSiLayerY;
105			G4VPhysicalVolume* physiSiLayerX;
106
107			G4VPhysicalVolume* physiS1;
108			G4VPhysicalVolume* physiS2;
109			G4VPhysicalVolume* physiS3;
110			G4VPhysicalVolume* physiS4;
111			G4VPhysicalVolume* physiCAT;
112			G4VPhysicalVolume* physiCAT1;
113			G4VPhysicalVolume* physiCARD;
114			G4VPhysicalVolume* physiCARD1;
115			G4VPhysicalVolume* physiCASX;
116			G4VPhysicalVolume* physiCASY;
117
118			G4VPhysicalVolume* physiAl;
119			G4VPhysicalVolume* physiPol;
120
121			G4VPhysicalVolume* physiMag;
122			G4VPhysicalVolume* physiMagAir;
123			G4VPhysicalVolume* physiMagSiLayer;
124			G4VPhysicalVolume* physiMagSiPlate;
125
126			G4VPhysicalVolume* physiHe3Ar;
127			G4VPhysicalVolume* physiFe;
128
129			G4double CalorSTh;
130			G4double CalorTh;
131			G4double Calor_XY;
132			G4double World_Z;
133			G4double World_XY;
134			G4double PcbTh;
135			G4double AbsorberTh;
136			G4double SiLayerTh;
137
138			};
139
140			#endif
141
142
143			// 2005 by G.I.Vasilyev