#include <LXeMainVolume.hh>

Inheritance diagram for LXeMainVolume:

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.

References python.hepunit::cm, python.hepunit::deg, G4PVPlacement::G4PVPlacement(), G4Material::GetMaterial(), python.hepunit::mm, CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), G4VPhysicalVolume::SetLogicalVolume(), test::x, and z.

   :G4PVPlacement(pRot,tlate,
                  //Temp logical volume must be created here
                  new G4LogicalVolume(new G4Box("temp",1,1,1),
                                      G4Material::GetMaterial("Vacuum"),
                                      "temp",0,0,0),
                  "housing",pMotherLogical,pMany,pCopyNo),fConstructor(c)
 {
   CopyValues();
 
   G4double housing_x=fScint_x+2.*fD_mtl;
   G4double housing_y=fScint_y+2.*fD_mtl;
   G4double housing_z=fScint_z+2.*fD_mtl;
  
   //*************************** housing and scintillator
   fScint_box = new G4Box("scint_box",fScint_x/2.,fScint_y/2.,fScint_z/2.);
   fHousing_box = new G4Box("housing_box",housing_x/2.,housing_y/2.,
                            housing_z/2.);
  
   fScint_log = new G4LogicalVolume(fScint_box,G4Material::GetMaterial("LXe"),
                                    "scint_log",0,0,0);
   fHousing_log = new G4LogicalVolume(fHousing_box,
                                      G4Material::GetMaterial("Al"),
                                      "housing_log",0,0,0);
  
   new G4PVPlacement(0,G4ThreeVector(),fScint_log,"scintillator",
                                  fHousing_log,false,0);
  
   //*************** Miscellaneous sphere to demonstrate skin surfaces
   fSphere = new G4Sphere("sphere",0.*mm,2.*cm,0.*deg,360.*deg,0.*deg,360.*deg);
   fSphere_log = new G4LogicalVolume(fSphere,G4Material::GetMaterial("Al"),
                                     "sphere_log");
   if(fSphereOn)
     new G4PVPlacement(0,G4ThreeVector(5.*cm,5.*cm,5.*cm),
                                       fSphere_log,"sphere",fScint_log,false,0);
  
   //****************** Build PMTs
   G4double innerRadius_pmt = 0.*cm;
   G4double height_pmt = fD_mtl/2.;
   G4double startAngle_pmt = 0.*deg;
   G4double spanningAngle_pmt = 360.*deg;
  
   fPmt = new G4Tubs("pmt_tube",innerRadius_pmt,fOuterRadius_pmt,
                     height_pmt,startAngle_pmt,spanningAngle_pmt);
  
   //the "photocathode" is a metal slab at the back of the glass that
   //is only a very rough approximation of the real thing since it only
   //absorbs or detects the photons based on the efficiency set below
   fPhotocath = new G4Tubs("photocath_tube",innerRadius_pmt,fOuterRadius_pmt,
                           height_pmt/2,startAngle_pmt,spanningAngle_pmt);
  
   fPmt_log = new G4LogicalVolume(fPmt,G4Material::GetMaterial("Glass"),
                                  "pmt_log");
   fPhotocath_log = new G4LogicalVolume(fPhotocath,
                                        G4Material::GetMaterial("Al"),
                                        "photocath_log");
  
   new G4PVPlacement(0,G4ThreeVector(0,0,-height_pmt/2),
                                     fPhotocath_log,"photocath",
                                     fPmt_log,false,0);
  
   //***********Arrange pmts around the outside of housing**********
 
   G4double dx = fScint_x/fNx;
   G4double dy = fScint_y/fNy;
   G4double dz = fScint_z/fNz;
  
   G4double x,y,z;
   G4double xmin = -fScint_x/2. - dx/2.;
   G4double ymin = -fScint_y/2. - dy/2.;
   G4double zmin = -fScint_z/2. - dz/2.;
   G4int k=0;
  
   z = -fScint_z/2. - height_pmt;      //front
   PlacePMTs(fPmt_log,0,x,y,dx,dy,xmin,ymin,fNx,fNy,x,y,z,k);
 
   G4RotationMatrix* rm_z = new G4RotationMatrix();
   rm_z->rotateY(180*deg);
   z = fScint_z/2. + height_pmt;       //back
   PlacePMTs(fPmt_log,rm_z,x,y,dx,dy,xmin,ymin,fNx,fNy,x,y,z,k);
  
   G4RotationMatrix* rm_y1 = new G4RotationMatrix();
   rm_y1->rotateY(-90*deg);
   x = -fScint_x/2. - height_pmt;      //left
   PlacePMTs(fPmt_log,rm_y1,y,z,dy,dz,ymin,zmin,fNy,fNz,x,y,z,k);
 
   G4RotationMatrix* rm_y2 = new G4RotationMatrix();
   rm_y2->rotateY(90*deg);
   x = fScint_x/2. + height_pmt;      //right
   PlacePMTs(fPmt_log,rm_y2,y,z,dy,dz,ymin,zmin,fNy,fNz,x,y,z,k);
  
   G4RotationMatrix* rm_x1 = new G4RotationMatrix();
   rm_x1->rotateX(90*deg);
   y = -fScint_y/2. - height_pmt;     //bottom
   PlacePMTs(fPmt_log,rm_x1,x,z,dx,dz,xmin,zmin,fNx,fNz,x,y,z,k);
 
   G4RotationMatrix* rm_x2 = new G4RotationMatrix();
   rm_x2->rotateX(-90*deg);
   y = fScint_y/2. + height_pmt;      //top
   PlacePMTs(fPmt_log,rm_x2,x,z,dx,dz,xmin,zmin,fNx,fNz,x,y,z,k);
  
   VisAttributes();
   SurfaceProperties();
 
   SetLogicalVolume(fHousing_log);
 }