Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
LXeMainVolume Class Reference

#include <LXeMainVolume.hh>

Inheritance diagram for LXeMainVolume:
Collaboration diagram for LXeMainVolume:

Public Member Functions

 LXeMainVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, LXeDetectorConstruction *c)
 
G4LogicalVolumeGetLogPhotoCath ()
 
G4LogicalVolumeGetLogScint ()
 
std::vector< G4ThreeVectorGetPmtPositions ()
 
- 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
 
G4VPVParameterisationGetParameterisation () 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
 
G4RotationMatrixGetObjectRotation () const
 
G4RotationMatrix GetObjectRotationValue () const
 
G4ThreeVector GetObjectTranslation () const
 
const G4RotationMatrixGetFrameRotation () const
 
G4ThreeVector GetFrameTranslation () const
 
const G4ThreeVectorGetTranslation () const
 
const G4RotationMatrixGetRotation () const
 
void SetTranslation (const G4ThreeVector &v)
 
G4RotationMatrixGetRotation ()
 
void SetRotation (G4RotationMatrix *)
 
G4LogicalVolumeGetLogicalVolume () const
 
void SetLogicalVolume (G4LogicalVolume *pLogical)
 
G4LogicalVolumeGetMotherLogical () const
 
void SetMotherLogical (G4LogicalVolume *pMother)
 
const G4StringGetName () 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 G4PVManagerGetSubInstanceManager ()
 
- 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,
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,
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 }
static constexpr double mm
Definition: G4SIunits.hh:115
CLHEP::Hep3Vector G4ThreeVector
HepRotation & rotateX(double delta)
Definition: Rotation.cc:66
CLHEP::HepRotation G4RotationMatrix
static G4Material * GetMaterial(const G4String &name, G4bool warning=true)
Definition: G4Material.cc:602
Definition: G4Box.hh:64
Definition: G4Tubs.hh:85
tuple x
Definition: test.py:50
HepRotation & rotateY(double delta)
Definition: Rotation.cc:79
int G4int
Definition: G4Types.hh:78
G4PVPlacement(G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
static constexpr double cm
Definition: G4SIunits.hh:119
tuple z
Definition: test.py:28
double G4double
Definition: G4Types.hh:76
static constexpr double deg
Definition: G4SIunits.hh:152
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: