Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | List of all members
LXeMainVolume Class Reference

#include <LXeMainVolume.hh>

Inheritance diagram for LXeMainVolume:
Inheritance graph
[legend]
Collaboration diagram for LXeMainVolume:
Collaboration graph
[legend]

Public Member Functions

 LXeMainVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, LXeDetectorConstruction *c)
 
G4LogicalVolume * GetLogPhotoCath ()
 
G4LogicalVolume * GetLogScint ()
 
std::vector< G4ThreeVector > GetPmtPositions ()
 
- Public Member Functions inherited from G4PVPlacement
 G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (const G4Transform3D &Transform3D, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (const G4Transform3D &Transform3D, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
virtual ~G4PVPlacement ()
 
G4int GetCopyNo () const
 
void SetCopyNo (G4int CopyNo)
 
G4bool CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1)
 
 G4PVPlacement (__void__ &)
 
G4bool IsMany () const
 
G4bool IsReplicated () const
 
G4bool IsParameterised () const
 
G4VPVParameterisation * GetParameterisation () const
 
void GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
 
G4bool IsRegularStructure () const
 
G4int GetRegularStructureId () const
 
- Public Member Functions inherited from G4VPhysicalVolume
 G4VPhysicalVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother)
 
virtual ~G4VPhysicalVolume ()
 
G4bool operator== (const G4VPhysicalVolume &p) const
 
G4RotationMatrix * GetObjectRotation () const
 
G4RotationMatrix GetObjectRotationValue () const
 
G4ThreeVector GetObjectTranslation () const
 
const G4RotationMatrix * GetFrameRotation () const
 
G4ThreeVector GetFrameTranslation () const
 
const G4ThreeVector & GetTranslation () const
 
const G4RotationMatrix * GetRotation () const
 
void SetTranslation (const G4ThreeVector &v)
 
G4RotationMatrix * GetRotation ()
 
void SetRotation (G4RotationMatrix *)
 
G4LogicalVolume * GetLogicalVolume () const
 
void SetLogicalVolume (G4LogicalVolume *pLogical)
 
G4LogicalVolume * GetMotherLogical () const
 
void SetMotherLogical (G4LogicalVolume *pMother)
 
const G4String & GetName () const
 
void SetName (const G4String &pName)
 
EVolume VolumeType () const
 
virtual G4int GetMultiplicity () const
 
 G4VPhysicalVolume (__void__ &)
 
G4int GetInstanceID () const
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicalVolume
static const G4PVManager & GetSubInstanceManager ()
 
- Protected Member Functions inherited from G4VPhysicalVolume
void InitialiseWorker (G4VPhysicalVolume *pMasterObject, G4RotationMatrix *pRot, const G4ThreeVector &tlate)
 
void TerminateWorker (G4VPhysicalVolume *pMasterObject)
 
- Protected Attributes inherited from G4VPhysicalVolume
G4int instanceID
 
- Static Protected Attributes inherited from G4VPhysicalVolume
static G4GEOM_DLL G4PVManager subInstanceManager
 

Detailed Description

Definition at line 44 of file LXeMainVolume.hh.

Constructor & Destructor Documentation

LXeMainVolume::LXeMainVolume ( G4RotationMatrix *  pRot,
const G4ThreeVector &  tlate,
G4LogicalVolume *  pMotherLogical,
G4bool  pMany,
G4int  pCopyNo,
LXeDetectorConstruction *  c 
)

Definition at line 43 of file LXeMainVolume.cc.

50  :G4PVPlacement(pRot,tlate,
51  //Temp logical volume must be created here
52  new G4LogicalVolume(new G4Box("temp",1,1,1),
53  G4Material::GetMaterial("Vacuum"),
54  "temp",0,0,0),
55  "housing",pMotherLogical,pMany,pCopyNo),fConstructor(c)
56 {
57  CopyValues();
58 
59  G4double housing_x=fScint_x+2.*fD_mtl;
60  G4double housing_y=fScint_y+2.*fD_mtl;
61  G4double housing_z=fScint_z+2.*fD_mtl;
62 
63  //*************************** housing and scintillator
64  fScint_box = new G4Box("scint_box",fScint_x/2.,fScint_y/2.,fScint_z/2.);
65  fHousing_box = new G4Box("housing_box",housing_x/2.,housing_y/2.,
66  housing_z/2.);
67 
68  fScint_log = new G4LogicalVolume(fScint_box,G4Material::GetMaterial("LXe"),
69  "scint_log",0,0,0);
70  fHousing_log = new G4LogicalVolume(fHousing_box,
71  G4Material::GetMaterial("Al"),
72  "housing_log",0,0,0);
73 
74  new G4PVPlacement(0,G4ThreeVector(),fScint_log,"scintillator",
75  fHousing_log,false,0);
76 
77  //*************** Miscellaneous sphere to demonstrate skin surfaces
78  fSphere = new G4Sphere("sphere",0.*mm,2.*cm,0.*deg,360.*deg,0.*deg,360.*deg);
79  fSphere_log = new G4LogicalVolume(fSphere,G4Material::GetMaterial("Al"),
80  "sphere_log");
81  if(fSphereOn)
82  new G4PVPlacement(0,G4ThreeVector(5.*cm,5.*cm,5.*cm),
83  fSphere_log,"sphere",fScint_log,false,0);
84 
85  //****************** Build PMTs
86  G4double innerRadius_pmt = 0.*cm;
87  G4double height_pmt = fD_mtl/2.;
88  G4double startAngle_pmt = 0.*deg;
89  G4double spanningAngle_pmt = 360.*deg;
90 
91  fPmt = new G4Tubs("pmt_tube",innerRadius_pmt,fOuterRadius_pmt,
92  height_pmt,startAngle_pmt,spanningAngle_pmt);
93 
94  //the "photocathode" is a metal slab at the back of the glass that
95  //is only a very rough approximation of the real thing since it only
96  //absorbs or detects the photons based on the efficiency set below
97  fPhotocath = new G4Tubs("photocath_tube",innerRadius_pmt,fOuterRadius_pmt,
98  height_pmt/2,startAngle_pmt,spanningAngle_pmt);
99 
100  fPmt_log = new G4LogicalVolume(fPmt,G4Material::GetMaterial("Glass"),
101  "pmt_log");
102  fPhotocath_log = new G4LogicalVolume(fPhotocath,
103  G4Material::GetMaterial("Al"),
104  "photocath_log");
105 
106  new G4PVPlacement(0,G4ThreeVector(0,0,-height_pmt/2),
107  fPhotocath_log,"photocath",
108  fPmt_log,false,0);
109 
110  //***********Arrange pmts around the outside of housing**********
111 
112  G4double dx = fScint_x/fNx;
113  G4double dy = fScint_y/fNy;
114  G4double dz = fScint_z/fNz;
115 
116  G4double x,y,z;
117  G4double xmin = -fScint_x/2. - dx/2.;
118  G4double ymin = -fScint_y/2. - dy/2.;
119  G4double zmin = -fScint_z/2. - dz/2.;
120  G4int k=0;
121 
122  z = -fScint_z/2. - height_pmt; //front
123  PlacePMTs(fPmt_log,0,x,y,dx,dy,xmin,ymin,fNx,fNy,x,y,z,k);
124 
125  G4RotationMatrix* rm_z = new G4RotationMatrix();
126  rm_z->rotateY(180*deg);
127  z = fScint_z/2. + height_pmt; //back
128  PlacePMTs(fPmt_log,rm_z,x,y,dx,dy,xmin,ymin,fNx,fNy,x,y,z,k);
129 
130  G4RotationMatrix* rm_y1 = new G4RotationMatrix();
131  rm_y1->rotateY(-90*deg);
132  x = -fScint_x/2. - height_pmt; //left
133  PlacePMTs(fPmt_log,rm_y1,y,z,dy,dz,ymin,zmin,fNy,fNz,x,y,z,k);
134 
135  G4RotationMatrix* rm_y2 = new G4RotationMatrix();
136  rm_y2->rotateY(90*deg);
137  x = fScint_x/2. + height_pmt; //right
138  PlacePMTs(fPmt_log,rm_y2,y,z,dy,dz,ymin,zmin,fNy,fNz,x,y,z,k);
139 
140  G4RotationMatrix* rm_x1 = new G4RotationMatrix();
141  rm_x1->rotateX(90*deg);
142  y = -fScint_y/2. - height_pmt; //bottom
143  PlacePMTs(fPmt_log,rm_x1,x,z,dx,dz,xmin,zmin,fNx,fNz,x,y,z,k);
144 
145  G4RotationMatrix* rm_x2 = new G4RotationMatrix();
146  rm_x2->rotateX(-90*deg);
147  y = fScint_y/2. + height_pmt; //top
148  PlacePMTs(fPmt_log,rm_x2,x,z,dx,dz,xmin,zmin,fNx,fNz,x,y,z,k);
149 
150  VisAttributes();
151  SurfaceProperties();
152 
153  SetLogicalVolume(fHousing_log);
154 }
mm
static constexpr double mm
Definition: G4SIunits.hh:115
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
CLHEP::HepRotation::rotateX
HepRotation & rotateX(double delta)
Definition: Rotation.cc:66
G4RotationMatrix
CLHEP::HepRotation G4RotationMatrix
Definition: G4RotationMatrix.hh:43
G4Material::GetMaterial
static G4Material * GetMaterial(const G4String &name, G4bool warning=true)
Definition: G4Material.cc:602
G4Box
Definition: G4Box.hh:64
G4Tubs
Definition: G4Tubs.hh:85
test.x
tuple x
Definition: test.py:50
CLHEP::HepRotation::rotateY
HepRotation & rotateY(double delta)
Definition: Rotation.cc:79
G4int
int G4int
Definition: G4Types.hh:78
G4PVPlacement::G4PVPlacement
G4PVPlacement(G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
Definition: G4PVPlacement.cc:100
cm
static constexpr double cm
Definition: G4SIunits.hh:119
test.z
tuple z
Definition: test.py:28
G4double
double G4double
Definition: G4Types.hh:76
deg
static constexpr double deg
Definition: G4SIunits.hh:152
G4VPhysicalVolume::SetLogicalVolume
void SetLogicalVolume(G4LogicalVolume *pLogical)

Here is the call graph for this function:

Member Function Documentation

G4LogicalVolume* LXeMainVolume::GetLogPhotoCath ( )
inline

Definition at line 55 of file LXeMainVolume.hh.

55 {return fPhotocath_log;}

Here is the caller graph for this function:

G4LogicalVolume* LXeMainVolume::GetLogScint ( )
inline

Definition at line 56 of file LXeMainVolume.hh.

56 {return fScint_log;}

Here is the caller graph for this function:

std::vector<G4ThreeVector> LXeMainVolume::GetPmtPositions ( )
inline

Definition at line 58 of file LXeMainVolume.hh.

58 {return fPmtPositions;}

Here is the caller graph for this function:

The documentation for this class was generated from the following files: