def __init__(self, parent, shift_z):
material = G4.G4NistManager.Instance().FindOrBuildMaterial(
"G4_Fe") # выбираем материал - железо
position = G4.G4ThreeVector(0.0 * cm, 0.0 * cm, 0.0 * cm + shift_z)
dimensions = G4.G4Box("Plate", 4.0 * cm, 4.0 * cm,
5.0 * mm) # размеры пластины (±x, ±y, ±z)
self.logical = G4.G4LogicalVolume(dimensions, material,
"Plate") # заполнение его материалом
self.physical = G4.G4PVPlacement(None, position, self.logical, "Plate",
parent, False, 0)
def __init__(self):
material = G4.G4NistManager.Instance().FindOrBuildMaterial(
"G4_AIR") # выбираем материал - воздух
position = G4.G4ThreeVector(0.0 * cm, 0.0 * cm, 0.0 * cm)
dimensions = G4.G4Box("WorldBox", 6.0 * cm, 6.0 * cm, 20.0 *
cm) # известное нам пространство (±x, ±y, ±z)
self.logical = G4.G4LogicalVolume(dimensions, material,
"piece") # заполнение его материалом
self.physical = G4.G4PVPlacement(None, position, self.logical, "World",
None, False, 0)
def Construct(self):
check_overlap = False
many = False
geometry_keys = list(self.conf['Geometry'].keys())
if len(geometry_keys) != 1:
raise ValueError('Must define exactly one top-level Geometry')
world_name = geometry_keys[0]
global geom_s, geom_l, geom_p
geom_s = {}
geom_l = {}
geom_p = {}
for geom in depth_first_tree_traversal(self.conf['Geometry']):
geom_type = geom['Type']
geom_name = geom['Name']
parent_name = geom_name.rsplit('.', 1)[0]
if parent_name in geom_p:
parent_p = geom_p[parent_name]
else:
parent_p = None
if geom_type == 'G4Box':
solid = g4.G4Box(geom_name, geom['pX'] * mm, geom['pY'] * mm,
geom['pZ'] * mm)
elif geom_type == 'G4Tubs':
solid = g4.G4Tubs(geom_name, geom['pRMin'] * mm,
geom['pRMax'] * mm, geom['pDz'] * mm,
geom['pSPhi'] * deg, geom['pDPhi'] * deg)
elif geom_type == 'CadMesh':
mesh = compton.cadmesh.TessellatedMesh(geom['File'])
if 'SolidName' in geom:
solid = mesh.GetSolid(geom['SolidName'])
else:
solid = mesh.GetSolid(0)
else:
raise ValueError(
"unimplemented geometry type '{}'".format(geom_type))
logical = g4.G4LogicalVolume(
solid, g4.gNistManager.FindOrBuildMaterial(geom['Material']),
geom_name)
transform = g4.G4Transform3D()
if 'Transformation' in geom:
for operation, value in zip(*geom['Transformation']):
translation = g4.G4ThreeVector()
rotation = g4.G4RotationMatrix()
if operation == 'TranslateX':
translation += g4.G4ThreeVector(value * mm, 0, 0)
elif operation == 'TranslateY':
translation += g4.G4ThreeVector(0, value * mm, 0)
elif operation == 'TranslateZ':
translation += g4.G4ThreeVector(0, 0, value * mm)
elif operation == 'RotateX':
rotation.rotateX(value * deg)
elif operation == 'RotateY':
rotation.rotateY(value * deg)
elif operation == 'RotateZ':
rotation.rotateZ(value * deg)
else:
assert (False)
transform = (g4.G4Transform3D(rotation, translation) *
transform)
if 'Rotation' in geom:
euler = np.array(geom['Rotation']) * deg
rotation = g4.G4RotationMatrix()
rotation.rotateZ(euler[0])
rotation.rotateY(euler[1])
rotation.rotateZ(euler[2])
else:
rotation = g4.G4RotationMatrix()
if 'Translation' in geom:
translation = g4.G4ThreeVector(*np.array(geom['Translation']) *
mm)
else:
translation = g4.G4ThreeVector()
physical = g4.G4PVPlacement(
g4.G4Transform3D(rotation, translation) * transform, geom_name,
logical, parent_p, many, 0, check_overlap)
if 'Visible' in geom:
logical.SetVisAttributes(g4.G4VisAttributes(geom['Visible']))
if 'Color' in geom:
logical.SetVisAttributes(
g4.G4VisAttributes(g4.G4Color(*geom['Color'])))
geom_s[geom_name] = solid
geom_l[geom_name] = logical
geom_p[geom_name] = physical
return geom_p[world_name]
def ConstructDevice(self):
"""
"""
# make colours
white = g4.G4Color(1.0, 1.0, 1.0)
orange = g4.G4Color(.75, .55, 0.0)
world_visatt = g4.G4VisAttributes(True, white)
process_space_visatt = g4.G4VisAttributes(False, orange)
# ========
# World
# ========
world_length_x = settings.world_length_x * g4.micrometer
world_length_y = settings.world_length_y * g4.micrometer
world_length_z = settings.world_length_z * g4.micrometer
world_solid = g4.G4Box("world_solid", world_length_x, world_length_y,
world_length_z)
world_logical = g4.G4LogicalVolume(world_solid, self.world_material,
"world_logical")
world_logical.SetVisAttributes(world_visatt)
self.world_physical = g4.G4PVPlacement(g4.G4Transform3D(),
world_logical, "world_physical",
None, False, 0)
# ===============
# process space
# ===============
process_space_length_x = settings.process_space_length_x * g4.micrometer
process_space_length_y = settings.process_space_length_y * g4.micrometer
process_space_length_z = settings.process_space_length_z * g4.micrometer
process_space_solid = g4.G4Box("process_space_solid",
process_space_length_x,
process_space_length_y,
process_space_length_z)
process_space_logical = g4.G4LogicalVolume(process_space_solid,
self.process_space_material,
"process_space_logical")
process_space_logical.SetVisAttributes(process_space_visatt)
process_space_pos = g4.G4ThreeVector(0, 0, -process_space_length_z)
process_space_physical = g4.G4PVPlacement(None, process_space_pos,
"process_space_physical",
process_space_logical,
self.world_physical, False,
0, True)
# ========================
# process wafer phantom
# ========================
voxel_length_x = process_space_length_x / self.n_voxel_x
voxel_length_y = process_space_length_y / self.n_voxel_y
voxel_length_z = process_space_length_z / self.n_voxel_z
voxel_solid = g4.G4Box("voxel_solid", voxel_length_x, voxel_length_y,
voxel_length_z)
self.voxel_logical = g4.G4LogicalVolume(voxel_solid,
self.process_space_material,
"voxel_logical")
# voxel_logical.SetVisAttributes(g4.G4VisAttributes(G4VisAttributes::GetInvisible()))
wafer = PhantomParameterisationColour()
# set color
for mat_name, color in settings.COLOR_MAP.items():
cred = color[0]
cgreen = color[1]
cblue = color[2]
copacity = color[3]
g4_color = g4.G4Color(cred, cgreen, cblue, copacity)
visAtt = g4.G4VisAttributes(g4_color)
# visAtt.SetForceSolid(True)
visAtt.SetVisibility(True)
wafer.AddColor(mat_name, visAtt)
wafer.SetVoxelDimensions(voxel_length_x, voxel_length_y,
voxel_length_z)
wafer.SetNoVoxel(self.n_voxel_x, self.n_voxel_y, self.n_voxel_z)
wafer.SetMaterials(self.materials)
wafer.SetMaterialIndices(self.material_IDs)
wafer.BuildContainerSolid(process_space_physical)
wafer.CheckVoxelsFillContainer(process_space_solid.GetXHalfLength(),
process_space_solid.GetYHalfLength(),
process_space_solid.GetZHalfLength())
n_voxel = self.n_voxel_x * self.n_voxel_y * self.n_voxel_z
wafer_physical = G4PVParameterised("wafer_physical",
self.voxel_logical,
process_space_logical,
g4.G4global.EAxis.kXAxis, n_voxel,
wafer, False)
wafer_physical.SetRegularStructureId(1)
return self.world_physical
def __init__(self, parent, shift_z):
nist = G4.G4NistManager.Instance()
Vc = nist.FindOrBuildMaterial("G4_Galactic")
Al = nist.FindOrBuildMaterial("G4_Al")
Ge = nist.FindOrBuildMaterial("G4_Ge")
Pg = nist.FindOrBuildMaterial("G4_PLEXIGLASS")
Ml = nist.FindOrBuildMaterial("G4_MYLAR")
Ai = nist.FindOrBuildMaterial("G4_AIR")
A = 0.5 * 51.1 * mm # Crystal Radius
B = 72.9 * mm # Crystal Length
C = 0.5 * 8.8 * mm # Hole Radius
D = 64.0 * mm # Hole Depth
E = 0.5 * 8.8 * mm # Nominal Hole End Radius
F = 94. * mm # CUP Length
G = 3.0 * mm # Top Gap between CUP and the Shell
H1 = 0.03 * mm # CUP Top Al Thickness
H2 = 0.03 * mm # CUP Top Maylar Thickness
I = 1.0 * mm # Shell Top Thickness
J = 8.0 * mm # Nominal Crystal End Radius
K = 0.8 * mm # CUP Walls Thickness
L = 1.0 * mm # Shell Walls Thickness
M = 0.0003 * mm # Outer Dead Layer Thickness
N = 0.7 * mm # Inner Dead Layer Thikness
O = 3.0 * mm # CUP Bottom Thickness
P = 0.5 * 76.0 * mm # Shell Radius
Q = 120. * mm # Shell Length
Z = 0.0 * mm # zero
s, t = 0.0, 360.0 * deg # start, turn
# Detector Base
base = G4.G4Tubs("base", Z, P, 0.5 * O, s, t)
logBase = G4.G4LogicalVolume(base, Pg, "logBase")
# Detector
HPGe = G4.G4Tubs("HPGe", Z, P, 0.5 * Q, s, t)
logHPGe = G4.G4LogicalVolume(HPGe, Vc, "logHPGe")
# Making the Crystal shape
crystal1 = G4.G4Tubs("cyl1", Z, A - J, 0.5 * B, s, t)
crystal2 = G4.G4Tubs("cyl2", Z, A, 0.5 * (B - J), s, t)
torroid1 = G4.G4Torus("tor1", Z, J, A - J, s, t)
xyz = G4.G4ThreeVector(Z, Z, -0.5 * J)
crystal3 = G4.G4UnionSolid("cry3", crystal1, crystal2, None, xyz)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * B - J)
crystal4 = G4.G4UnionSolid("cry4", crystal3, torroid1, None, xyz)
# Making the Active Crystal shape
activeCrystal1 = G4.G4Tubs("acyl1", Z, A - J, 0.5 * (B - M), s, t)
activeCrystal2 = G4.G4Tubs("acyl2", Z, A - M, 0.5 * (B - J), s, t)
activeTor1 = G4.G4Torus("activeTor1", Z, J - M, A - J, s, t)
xyz = G4.G4ThreeVector(Z, Z, -0.5 * (J - M))
activeCrystal3 = G4.G4UnionSolid("cry3", activeCrystal1,
activeCrystal2, None, xyz)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (B - M) - J)
activeCrystal4 = G4.G4UnionSolid("cry4", activeCrystal3, activeTor1,
None, xyz)
# Making the hole
hole1 = G4.G4Tubs("hole1", Z, C, 0.5 * (D - C), s, t)
hole2 = G4.G4Orb("hole2", C)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (D - C))
hole = G4.G4UnionSolid("hole", hole1, hole2, None, xyz)
# Making outer dead layer
xyz = G4.G4ThreeVector(Z, Z, Z)
outerDeadLayer = G4.G4SubtractionSolid("outerDeadLayer", crystal4,
activeCrystal4, None, xyz)
# Making the inner dead layer
innerDead1 = G4.G4Tubs("innerDead1", Z, C + N, 0.5 * (D - C), s, t)
innerDead2 = G4.G4Orb("innerDead2", C + N)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (D - C))
innerDead3 = G4.G4UnionSolid("innerDead3", innerDead1, innerDead2,
None, xyz)
xyz = G4.G4ThreeVector(Z, Z, Z)
innerDeadLayer = G4.G4SubtractionSolid("innerDeadLayer", innerDead3,
hole, None, xyz)
# Making final detector shape
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (D - C) - 0.5 * (B - M))
activeCrystal = G4.G4SubtractionSolid("activeCrystal", activeCrystal4,
innerDead3, None, xyz)
logOuterDead = G4.G4LogicalVolume(outerDeadLayer, Ge, "logOuterDead")
logInnerDead = G4.G4LogicalVolume(innerDeadLayer, Ge, "logInnerDead")
logActive = G4.G4LogicalVolume(activeCrystal, Ge, "logActive")
# Mylar layer
mylarLayer = G4.G4Tubs("mylarLayer", Z, K + A, 0.5 * H2, s, t)
logMylar = G4.G4LogicalVolume(mylarLayer, Ml, "logMylar")
# CUP
CUP1 = G4.G4Tubs("CUP1", Z, K + A, 0.5 * F, s, t)
CUP2 = G4.G4Tubs("CUP2", Z, A, 0.5 * (F - H1 - O), s, t)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (O - H1))
CUP = G4.G4SubtractionSolid("CUP", CUP1, CUP2, None, xyz)
logCUP = G4.G4LogicalVolume(CUP, Al, "logCUP")
#detector shell
shell1 = G4.G4Tubs("shell1", Z, P, 0.5 * Q, s, t)
shell2 = G4.G4Tubs("shell2", Z, P - L, 0.5 * Q - L, s, t)
xyz = G4.G4ThreeVector(Z, Z, Z)
shell = G4.G4SubtractionSolid("shell", shell1, shell2, None, xyz)
logShell = G4.G4LogicalVolume(shell, Al, "logShell")
# Placement of all Elements
xyz = G4.G4ThreeVector(Z, Z, -(I + G + F) - 0.5 * O + shift_z)
G4.G4PVPlacement(None, xyz, logBase, "physBase", parent, False, 0)
xyz = G4.G4ThreeVector(Z, Z, -0.5 * Q + shift_z)
G4.G4PVPlacement(None, xyz, logHPGe, "physHPGe", parent, False, 0)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (Q - B) - I - G - H1)
G4.G4PVPlacement(None, xyz, logOuterDead, "physOuterDead", logHPGe,
False, 0)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (Q + D - C) - I - G - H1 - B)
G4.G4PVPlacement(None, xyz, logInnerDead, "physInnerDead", logHPGe,
False, 0)
xyz = G4.G4ThreeVector(Z, Z, Z)
G4.G4PVPlacement(None, xyz, logShell, "physShell", logHPGe, False, 0)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (Q + H2) - L - G)
G4.G4PVPlacement(None, xyz, logMylar, "physMylar", logHPGe, False, 0)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (Q - F) - L - G)
G4.G4PVPlacement(None, xyz, logCUP, "physCUP", logHPGe, False, 0)
xyz = G4.G4ThreeVector(Z, Z, 0.5 * (Q - M - B) - L - G - H1)
G4.G4PVPlacement(None, xyz, logActive, "physActive", logHPGe, False, 0)
self.logical = logActive
# Detector Visualization Attributes
BaseVA = G4.G4VisAttributes(G4.G4Color(1.0, 1.0, 1.0, 1.0))
BaseVA.SetForceSolid(True)
logBase.SetVisAttributes(BaseVA)
HPGeVA = G4.G4VisAttributes(G4.G4Color(1.0, 1.0, 0.0, 0.0))
HPGeVA.SetForceSolid(True)
logHPGe.SetVisAttributes(HPGeVA)
ShellVA = G4.G4VisAttributes(G4.G4Color(1.0, 0.5, 0.9, 0.1))
ShellVA.SetForceSolid(True)
logShell.SetVisAttributes(ShellVA)
CupVA = G4.G4VisAttributes(G4.G4Color(0.2, 1.0, 0.0, 0.1))
CupVA.SetForceSolid(True)
logCUP.SetVisAttributes(CupVA)
MylarVA = G4.G4VisAttributes(G4.G4Color(0.2, 1.0, 0.0, 0.6))
MylarVA.SetForceSolid(True)
logMylar.SetVisAttributes(MylarVA)
OutdlVA = G4.G4VisAttributes(G4.G4Color(0.9, 1.0, 0.0, 0.1))
OutdlVA.SetForceSolid(True)
logOuterDead.SetVisAttributes(OutdlVA)
InndlVA = G4.G4VisAttributes(G4.G4Color(0.9, 1.0, 0.0, 0.1))
InndlVA.SetForceSolid(True)
logInnerDead.SetVisAttributes(InndlVA)
CrystVA = G4.G4VisAttributes(G4.G4Color(0.8, 0.2, 0.8, 0.5))
CrystVA.SetForceSolid(True)
logActive.SetVisAttributes(CrystVA)
