#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)

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

Private Member Functions
void	VisAttributes ()

void	SurfaceProperties ()

void	PlacePMTs (G4LogicalVolume pmt_Log, G4RotationMatrix rot, G4double &a, G4double &b, G4double da, G4double db, G4double amin, G4double bmin, G4int na, G4int nb, G4double &x, G4double &y, G4double &z, G4int &k)

void	CopyValues ()

Private Attributes
LXeDetectorConstruction *	fConstructor

G4double	fScint_x

G4double	fScint_y

G4double	fScint_z

G4double	fD_mtl

G4int	fNx

G4int	fNy

G4int	fNz

G4double	fOuterRadius_pmt

G4bool	fSphereOn

G4double	fRefl

G4Box *	fScint_box

G4Box *	fHousing_box

G4Tubs *	fPmt

G4Tubs *	fPhotocath

G4Sphere *	fSphere

G4LogicalVolume *	fScint_log

G4LogicalVolume *	fHousing_log

G4LogicalVolume *	fPmt_log

G4LogicalVolume *	fPhotocath_log

G4LogicalVolume *	fSphere_log

std::vector< G4ThreeVector >	fPmtPositions

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::LXeMainVolume	(	G4RotationMatrix *	pRot,
		const G4ThreeVector &	tlate,
		G4LogicalVolume *	pMotherLogical,
		G4bool	pMany,
		G4int	pCopyNo,
		LXeDetectorConstruction *	c
	)

Definition at line 43 of file LXeMainVolume.cc.

   :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);
 }

Here is the call graph for this function:

Member Function Documentation

◆ CopyValues()

void LXeMainVolume::CopyValues ( )

private

Definition at line 158 of file LXeMainVolume.cc.

                               {
   fScint_x=fConstructor->GetScintX();
   fScint_y=fConstructor->GetScintY();
   fScint_z=fConstructor->GetScintZ();
   fD_mtl=fConstructor->GetHousingThickness();
   fNx=fConstructor->GetNX();
   fNy=fConstructor->GetNY();
   fNz=fConstructor->GetNZ();
   fOuterRadius_pmt=fConstructor->GetPMTRadius();
   fSphereOn=fConstructor->GetSphereOn();
   fRefl=fConstructor->GetHousingReflectivity();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLogPhotoCath()

G4LogicalVolume* LXeMainVolume::GetLogPhotoCath ( )

inline

Definition at line 55 of file LXeMainVolume.hh.

55 {return fPhotocath_log;}

LXeMainVolume::fPhotocath_log

G4LogicalVolume * fPhotocath_log

Definition: LXeMainVolume.hh:100

Here is the caller graph for this function:

◆ GetLogScint()

G4LogicalVolume* LXeMainVolume::GetLogScint ( )

inline

Definition at line 56 of file LXeMainVolume.hh.

56 {return fScint_log;}

LXeMainVolume::fScint_log

G4LogicalVolume * fScint_log

Definition: LXeMainVolume.hh:97

Here is the caller graph for this function:

◆ GetPmtPositions()

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

inline

Definition at line 58 of file LXeMainVolume.hh.

58 {return fPmtPositions;}

LXeMainVolume::fPmtPositions

std::vector< G4ThreeVector > fPmtPositions

Definition: LXeMainVolume.hh:104

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlacePMTs()

void LXeMainVolume::PlacePMTs	(	G4LogicalVolume *	pmt_Log,
		G4RotationMatrix *	rot,
		G4double &	a,
		G4double &	b,
		G4double	da,
		G4double	db,
		G4double	amin,
		G4double	bmin,
		G4int	na,
		G4int	nb,
		G4double &	x,
		G4double &	y,
		G4double &	z,
		G4int &	k
	)

private

Definition at line 173 of file LXeMainVolume.cc.

                                        {
 /*PlacePMTs : a different way to parameterize placement that does not depend on
   calculating the position from the copy number
 
   pmt_log = logical volume for pmts to be placed
   rot = rotation matrix to apply
   a,b = coordinates to vary(ie. if varying in the xy plane then pass x,y)
   da,db = value to increment a,b by
   amin,bmin = start values for a,b
   na,nb = number of repitions in a and b
   x,y,z = just pass x,y, and z by reference (the same ones passed for a,b)
   k = copy number to start with
   sd = sensitive detector for pmts
 */
   a=amin;
   for(G4int j=1;j<=na;j++){
     a+=da;
     b=bmin;
     for(G4int i=1;i<=nb;i++){
       b+=db;
       new G4PVPlacement(rot,G4ThreeVector(x,y,z),pmt_log,"pmt",
                         fHousing_log,false,k);
       fPmtPositions.push_back(G4ThreeVector(x,y,z));
       k++;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SurfaceProperties()

void LXeMainVolume::SurfaceProperties ( )

private

Definition at line 220 of file LXeMainVolume.cc.

                                      {
   G4double ephoton[] = {7.0*eV, 7.14*eV};
   const G4int num = sizeof(ephoton)/sizeof(G4double);
 
   //**Scintillator housing properties
   G4double reflectivity[] = {fRefl, fRefl};
   assert(sizeof(reflectivity) == sizeof(ephoton));
   G4double efficiency[] = {0.0, 0.0};
   assert(sizeof(efficiency) == sizeof(ephoton));
   G4MaterialPropertiesTable* scintHsngPT = new G4MaterialPropertiesTable();
   scintHsngPT->AddProperty("REFLECTIVITY", ephoton, reflectivity, num);
   scintHsngPT->AddProperty("EFFICIENCY", ephoton, efficiency, num);
   G4OpticalSurface* OpScintHousingSurface =
     new G4OpticalSurface("HousingSurface",unified,polished,dielectric_metal);
   OpScintHousingSurface->SetMaterialPropertiesTable(scintHsngPT);
  
   //**Sphere surface properties
   G4double sphereReflectivity[] = {1.0, 1.0};
   assert(sizeof(sphereReflectivity) == sizeof(ephoton));
   G4double sphereEfficiency[] = {0.0, 0.0};
   assert(sizeof(sphereEfficiency) == sizeof(ephoton));
   G4MaterialPropertiesTable* spherePT = new G4MaterialPropertiesTable();
   spherePT->AddProperty("REFLECTIVITY", ephoton, sphereReflectivity, num);
   spherePT->AddProperty("EFFICIENCY", ephoton, sphereEfficiency, num);
   G4OpticalSurface* OpSphereSurface =
     new G4OpticalSurface("SphereSurface",unified,polished,dielectric_metal);
   OpSphereSurface->SetMaterialPropertiesTable(spherePT);
  
   //**Photocathode surface properties
   G4double photocath_EFF[]={1.,1.}; //Enables 'detection' of photons
   assert(sizeof(photocath_EFF) == sizeof(ephoton));
   G4double photocath_ReR[]={1.92,1.92};
   assert(sizeof(photocath_ReR) == sizeof(ephoton));
   G4double photocath_ImR[]={1.69,1.69};
   assert(sizeof(photocath_ImR) == sizeof(ephoton));
   G4MaterialPropertiesTable* photocath_mt = new G4MaterialPropertiesTable();
   photocath_mt->AddProperty("EFFICIENCY",ephoton,photocath_EFF,num);
   photocath_mt->AddProperty("REALRINDEX",ephoton,photocath_ReR,num);
   photocath_mt->AddProperty("IMAGINARYRINDEX",ephoton,photocath_ImR,num);
   G4OpticalSurface* photocath_opsurf=
     new G4OpticalSurface("photocath_opsurf",glisur,polished,
                          dielectric_metal);
   photocath_opsurf->SetMaterialPropertiesTable(photocath_mt);
 
   //**Create logical skin surfaces
   new G4LogicalSkinSurface("photocath_surf",fHousing_log,
                            OpScintHousingSurface);
   new G4LogicalSkinSurface("sphere_surface",fSphere_log,OpSphereSurface);
   new G4LogicalSkinSurface("photocath_surf",fPhotocath_log,photocath_opsurf);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VisAttributes()

void LXeMainVolume::VisAttributes ( )

private

Definition at line 209 of file LXeMainVolume.cc.

                                  {
   G4VisAttributes* housing_va = new G4VisAttributes(G4Colour(0.8,0.8,0.8));
   fHousing_log->SetVisAttributes(housing_va);
 
   G4VisAttributes* sphere_va = new G4VisAttributes();
   sphere_va->SetForceSolid(true);
   fSphere_log->SetVisAttributes(sphere_va);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fConstructor

LXeDetectorConstruction* LXeMainVolume::fConstructor

private

Definition at line 74 of file LXeMainVolume.hh.

◆ fD_mtl

G4double LXeMainVolume::fD_mtl

private

Definition at line 79 of file LXeMainVolume.hh.

◆ fHousing_box

G4Box* LXeMainVolume::fHousing_box

private

Definition at line 90 of file LXeMainVolume.hh.

◆ fHousing_log

G4LogicalVolume* LXeMainVolume::fHousing_log

private

Definition at line 98 of file LXeMainVolume.hh.

◆ fNx

G4int LXeMainVolume::fNx

private

Definition at line 80 of file LXeMainVolume.hh.

◆ fNy

G4int LXeMainVolume::fNy

private

Definition at line 81 of file LXeMainVolume.hh.

◆ fNz

G4int LXeMainVolume::fNz

private

Definition at line 82 of file LXeMainVolume.hh.

◆ fOuterRadius_pmt

G4double LXeMainVolume::fOuterRadius_pmt

private

Definition at line 83 of file LXeMainVolume.hh.

◆ fPhotocath

G4Tubs* LXeMainVolume::fPhotocath

private

Definition at line 92 of file LXeMainVolume.hh.

◆ fPhotocath_log

G4LogicalVolume* LXeMainVolume::fPhotocath_log

private

Definition at line 100 of file LXeMainVolume.hh.

◆ fPmt

G4Tubs* LXeMainVolume::fPmt

private

Definition at line 91 of file LXeMainVolume.hh.

◆ fPmt_log

G4LogicalVolume* LXeMainVolume::fPmt_log

private

Definition at line 99 of file LXeMainVolume.hh.

◆ fPmtPositions

std::vector<G4ThreeVector> LXeMainVolume::fPmtPositions

private

Definition at line 104 of file LXeMainVolume.hh.

◆ fRefl

G4double LXeMainVolume::fRefl

private

Definition at line 85 of file LXeMainVolume.hh.

◆ fScint_box

G4Box* LXeMainVolume::fScint_box

private

Definition at line 89 of file LXeMainVolume.hh.

◆ fScint_log

G4LogicalVolume* LXeMainVolume::fScint_log

private

Definition at line 97 of file LXeMainVolume.hh.

◆ fScint_x

G4double LXeMainVolume::fScint_x

private

Definition at line 76 of file LXeMainVolume.hh.

◆ fScint_y

G4double LXeMainVolume::fScint_y

private

Definition at line 77 of file LXeMainVolume.hh.

◆ fScint_z

G4double LXeMainVolume::fScint_z

private

Definition at line 78 of file LXeMainVolume.hh.

◆ fSphere

G4Sphere* LXeMainVolume::fSphere

private

Definition at line 93 of file LXeMainVolume.hh.

◆ fSphere_log

G4LogicalVolume* LXeMainVolume::fSphere_log

private

Definition at line 101 of file LXeMainVolume.hh.

◆ fSphereOn

G4bool LXeMainVolume::fSphereOn

private

Definition at line 84 of file LXeMainVolume.hh.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LXeMainVolume()

Member Function Documentation

◆ CopyValues()

◆ GetLogPhotoCath()

◆ GetLogScint()

◆ GetPmtPositions()

◆ PlacePMTs()

◆ SurfaceProperties()

◆ VisAttributes()

Member Data Documentation

◆ fConstructor

◆ fD_mtl

◆ fHousing_box

◆ fHousing_log

◆ fNx

◆ fNy

◆ fNz

◆ fOuterRadius_pmt

◆ fPhotocath

◆ fPhotocath_log

◆ fPmt

◆ fPmt_log

◆ fPmtPositions

◆ fRefl

◆ fScint_box

◆ fScint_log

◆ fScint_x

◆ fScint_y

◆ fScint_z

◆ fSphere

◆ fSphere_log

◆ fSphereOn