source: trunk/examples/advanced/underground_physics/src/DMXDetectorRoom.icc

Last change on this file was 807, checked in by garnier, 16 years ago

update
File size: 24.8 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27  // Window - AIR + glass ************************************************
28
29  G4double glassThick = 3.0*mm;
30  G4double sidepanelWidth = 43.*cm;
31  G4double windowWidth = labWidth - 2.*sidepanelWidth;
32  G4double windowHeight = labHeight - 112.0*cm;
33  G4double glassPosY = 0.5*(worldLength - glassThick);
34  G4double glassPosZ = 0.5*(labHeight - windowHeight);
35
36  G4Box* glass_box = new G4Box
37  ("glass_box",0.5*windowWidth, 0.5*glassThick, 0.5*windowHeight );
38  glass_log = new G4LogicalVolume(glass_box, glass_mat, "glass_log");
39  glass_phys = new G4PVPlacement
40    (0, G4ThreeVector(0., glassPosY, glassPosZ), "glass_phys", glass_log,
41     world_phys, false, 0);
42
43  G4VisAttributes* glass_vat= new G4VisAttributes(blue);
44  glass_vat->SetVisibility(true);
45  glass_vat->SetForceSolid(true);
46  glass_log->SetVisAttributes(glass_vat);
47
48  // hole in wall between glass and "lab": ************************************
49
50  G4double holeThick = wallThick - glassThick;
51  G4double windowPosY = 0.5*(worldLength - holeThick) - glassThick;
52  G4double windowPosZ = glassPosZ;
53
54  G4Box* window_box = new G4Box
55  ("window_box",0.5*windowWidth, 0.5*holeThick, 0.5*windowHeight );
56  window_log = new G4LogicalVolume(window_box, lab_mat, "window_log");
57  window_phys = new G4PVPlacement
58    (0, G4ThreeVector(0., windowPosY, windowPosZ), "window_phys",
59     window_log, world_phys, false, 0);
60
61  G4VisAttributes* window_vat= new G4VisAttributes(yellow);
62  //  window_log->SetVisAttributes(G4VisAttributes::Invisible);
63  window_vat->SetVisibility(true);
64  window_log->SetVisAttributes(window_vat);
65
66
67  // Side panels of Window - AIR + Al ****************************************
68
69  G4double panelThick = 5.0*mm;
70//  G4double sidepanelWidth = 43.*cm; // defined earlier
71  G4double sidepanelPosX = 0.5*(labWidth - sidepanelWidth);
72  G4double sidepanelPosY = 0.5*(worldLength - panelThick);
73  G4double sidepanelPosZ = glassPosZ;
74
75  G4Box* sidepanel_box = new G4Box
76  ("sidepanel_box",0.5*sidepanelWidth, 0.5*panelThick, 0.5*windowHeight );
77  sidepanel_log = new G4LogicalVolume
78                      (sidepanel_box, panel_mat, "sidepanel_log");
79  sidepanel_phys = new G4PVPlacement
80    (0, G4ThreeVector(sidepanelPosX, sidepanelPosY, sidepanelPosZ),
81        "sidepanel_phys", sidepanel_log, world_phys, false, 0);
82
83  sidepanel_phys = new G4PVPlacement
84    (0, G4ThreeVector(-sidepanelPosX, sidepanelPosY, sidepanelPosZ),
85        "sidepanel_phys", sidepanel_log, world_phys, false, 1);
86
87  G4VisAttributes* panel_vat= new G4VisAttributes(grey);
88  panel_vat->SetVisibility(true);
89  panel_vat->SetForceSolid(true);
90  sidepanel_log->SetVisAttributes(panel_vat);
91
92  // panel hole in wall between Al and "lab": ******************************
93
94  G4double panelholePosX  = sidepanelPosX;
95  G4double panelholeThick = wallThick - panelThick;
96  G4double panelholePosY  = 0.5*(worldLength - panelholeThick) - panelThick;
97  G4double panelholePosZ  = sidepanelPosZ;
98
99  G4Box* panelhole_box = new G4Box
100  ("panelhole_box",0.5*sidepanelWidth, 0.5*panelholeThick, 0.5*windowHeight );
101  panelhole_log = new G4LogicalVolume
102                       (panelhole_box, lab_mat, "panelhole_log");
103
104  panelhole_phys = new G4PVPlacement
105    (0, G4ThreeVector(panelholePosX, panelholePosY, panelholePosZ),
106    "panelhole_phys", panelhole_log, world_phys, false, 0);
107  panelhole_phys = new G4PVPlacement
108    (0, G4ThreeVector(-panelholePosX, panelholePosY, panelholePosZ),
109    "panelhole_phys", panelhole_log, world_phys, false, 1);
110
111  panelhole_log->SetVisAttributes(window_vat);
112
113
114  // DOOR Window - AIR + glass ************************************************
115
116  G4double doorwindowWidth = 62.*cm;
117  G4double doorwindowHeight = 84.0*cm;
118  G4double doorglassPosX = 0.5*(labWidth - doorwindowWidth) - sidepanelWidth;
119  G4double doorglassPosY = 0.5*(worldLength - panelThick);
120  G4double doorglassPosZ = glassPosZ - 0.5*(windowHeight+doorwindowHeight);
121
122  G4Box* doorglass_box = new G4Box
123  ("doorglass_box",0.5*doorwindowWidth, 0.5*panelThick, 0.5*doorwindowHeight );
124  doorglass_log = new G4LogicalVolume
125                      (doorglass_box, panel_mat, "doorglass_log");
126  doorglass_phys = new G4PVPlacement
127    (0, G4ThreeVector(doorglassPosX, doorglassPosY, doorglassPosZ),
128        "doorglass_phys", doorglass_log, world_phys, false, 0);
129
130  doorglass_log->SetVisAttributes(panel_vat);
131
132  // door hole in wall between glass and "lab": ******************************
133
134  G4double doorwindowPosX = doorglassPosX;
135  G4double doorwindowPosY = 0.5*(worldLength - panelholeThick) - panelThick;
136  G4double doorwindowPosZ = doorglassPosZ;
137
138  G4Box* doorwindow_box = new G4Box
139  ("doorwindow_box",0.5*doorwindowWidth, 0.5*panelholeThick, 0.5*doorwindowHeight );
140  doorwindow_log = new G4LogicalVolume
141                       (doorwindow_box, lab_mat, "doorwindow_log");
142  doorwindow_phys = new G4PVPlacement
143    (0, G4ThreeVector(doorwindowPosX, doorwindowPosY, doorwindowPosZ),
144    "doorwindow_phys", doorwindow_log, world_phys, false, 0);
145
146  doorwindow_log->SetVisAttributes(window_vat);
147
148
149  // cupboards: ***************************************************************
150
151  // cupboard 1:
152  G4double cupboardDepth  = 38.0*cm; //X
153  G4double cupboard1Width  = 91.0*cm; //Y
154  G4double cupboard2Width  = 153.0*cm; //Y
155  G4double cupboardHeight = 91.0*cm; //Z
156  G4double woodThick      = 2.0*cm;
157  G4double insideDepth  = cupboardDepth - 2.*woodThick;
158  G4double inside1Width  = cupboard1Width - 2.*woodThick;
159  G4double inside2Width  = cupboard2Width - 2.*woodThick;
160  G4double insideHeight = cupboardHeight - 2.*woodThick;
161
162  //nb: cupboard orientation is sideways because they are lined along the wall
163  G4Box* cupboard_box = new G4Box
164   ("cupboard_box", 0.5*cupboardDepth, 0.5*cupboard1Width, 0.5*cupboardHeight);
165  G4Box* inside_box = new G4Box
166    ("inside_box", 0.5*insideDepth, 0.5*inside1Width, 0.5*insideHeight);
167  G4Box* shelf_box  = new G4Box
168    ("shelf_box", 0.5*insideDepth, 0.5*inside1Width, 0.5*woodThick);
169  G4Box* cupdoor_box = new G4Box
170    ("cupdoor_box", 0.5*woodThick+1.0*nanometer, 0.25*inside1Width, 0.5*insideHeight);
171//    ("cupdoor_box", 0.5*woodThick, 0.25*inside1Width, 0.5*insideHeight);
172
173  G4RotationMatrix rotMatrixCupboard;
174  rotMatrixCupboard.rotateY(0.0*deg);
175 
176  G4SubtractionSolid* cupboard_frame = new G4SubtractionSolid
177    ("cupboard_frame", cupboard_box, inside_box, G4Transform3D
178     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
179  G4UnionSolid* cupboard_shelf1 = new G4UnionSolid
180    ("cupboard_shelf1", cupboard_frame, shelf_box, G4Transform3D
181     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.30*(insideHeight))));
182  G4UnionSolid* cupboard_shelf2 = new G4UnionSolid
183    ("cupboard_shelf2", cupboard_shelf1, shelf_box, G4Transform3D
184     (rotMatrixCupboard, G4ThreeVector(0.,0.,-0.05*(insideHeight))));
185  G4SubtractionSolid* cupboard_sol = new G4SubtractionSolid
186    ("cupboard_sol", cupboard_shelf2, cupdoor_box, G4Transform3D
187     (rotMatrixCupboard, G4ThreeVector
188      (-0.5*(insideDepth+woodThick),0.25*inside1Width,0.)));
189
190  cupboard_log = new G4LogicalVolume
191    (cupboard_sol, cupboard_mat, "cupboard_log");
192
193  G4double cupb_X = 0.5*(labWidth - cupboardDepth);
194  //  G4double cupb_Y = 0.5*(labLength - cupboard1Width) - 2.0*cm;
195  G4double cupb_Y = 0.5*labLength;
196  G4double cupb_Z = 0.5*(labHeight - cupboardHeight) - 25.4*cm;
197
198  for (G4int i=0; i<5; i++)
199    {
200      cupb_Y -= cupboard1Width+2.0*cm;
201      cupboard_phys = new G4PVPlacement
202        (0, G4ThreeVector(cupb_X, cupb_Y, cupb_Z), "cupboard_phys",
203         cupboard_log, lab_phys, false, i);
204    }
205
206  cupb_X  = -(0.5*(labWidth - cupboard1Width) - cupboardDepth - 2.0*cm);
207  G4double cupb_Y2 = -0.5*(labLength - cupboardDepth);
208
209  G4RotationMatrix rotMatrixWallcupboard;
210  rotMatrixWallcupboard.rotateZ(-90.0*deg);
211
212  cupboard_phys = new G4PVPlacement
213    (G4Transform3D
214     (rotMatrixWallcupboard,G4ThreeVector(cupb_X, cupb_Y2, cupb_Z)),
215      "cupboard_phys", cupboard_log, lab_phys, false, 5);
216
217
218  G4VisAttributes* cupboard_vat= new G4VisAttributes(yellow);
219  cupboard_vat->SetVisibility(true);
220  cupboard_vat->SetForceSolid(true);
221  cupboard_log->SetVisAttributes(cupboard_vat);
222
223  // cupboard 2 (bigger/wider) ***********************************************
224
225  G4Box* cupboard2_box = new G4Box
226  ("cupboard2_box", 0.5*cupboardDepth, 0.5*cupboard2Width, 0.5*cupboardHeight);
227  G4Box* inside2_box = new G4Box
228    ("inside2_box", 0.5*insideDepth, 0.5*inside2Width, 0.5*insideHeight);
229  G4Box* shelf2_box  = new G4Box
230    ("shelf2_box", 0.5*insideDepth, 0.5*inside2Width, 0.5*woodThick);
231  G4Box* cupdoor_box2 = new G4Box
232    ("cupdoor_box2", 0.5*woodThick+1.0*nanometer, 0.25*inside2Width, 0.5*insideHeight);
233//    ("cupdoor_box2", 0.5*woodThick, 0.25*inside2Width, 0.5*insideHeight);
234
235  G4SubtractionSolid* cupboard2_frame = new G4SubtractionSolid
236    ("cupboard2_frame", cupboard2_box, inside2_box, G4Transform3D
237     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
238  G4UnionSolid* cupboard2_shelf1 = new G4UnionSolid
239    ("cupboard2_shelf1", cupboard2_frame, shelf2_box, G4Transform3D
240     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.30*(insideHeight))));
241  G4UnionSolid* cupboard2_shelf2 = new G4UnionSolid
242    ("cupboard2_shelf2", cupboard2_shelf1, shelf2_box, G4Transform3D
243     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.10*(insideHeight))));
244  G4SubtractionSolid* cupboard2_sol = new G4SubtractionSolid
245    ("cupboard2_sol", cupboard2_shelf2, cupdoor_box2, G4Transform3D
246     (rotMatrixCupboard, G4ThreeVector
247      (-0.5*(insideDepth+woodThick),0.25*inside2Width,0.)));
248
249  cupboard2_log = new G4LogicalVolume
250    (cupboard2_sol, cupboard_mat, "cupboard2_log");
251
252  cupb_X = 0.5*(labWidth - cupboardDepth);
253  //  cupb_Y = -(0.5*(labLength - cupboard2Width) - 2.0*cm);
254  cupb_Y -= 0.5*cupboard1Width + 0.5*cupboard2Width
255                               + 2.0*cm; //using last cupboard posn on right...
256  //  cupb_Z = 0.5*(labHeight - cupboardHeight) - 25.4*cm;
257
258  cupboard2_phys = new G4PVPlacement
259    (0,G4ThreeVector(cupb_X, cupb_Y, cupb_Z),
260      "cupboard2_phys", cupboard2_log, lab_phys, false, 0);
261
262  cupb_X = -0.5*(labWidth - cupboardDepth);
263  cupb_Y = -(0.5*(labLength - cupboard2Width) - cupboardDepth - 2.0*cm);
264
265  G4RotationMatrix rotMatrixWallcupboard2;
266  rotMatrixWallcupboard2.rotateZ(-180.0*deg);
267
268  cupboard2_phys = new G4PVPlacement
269    (G4Transform3D
270     (rotMatrixWallcupboard2,G4ThreeVector(cupb_X, cupb_Y, cupb_Z)),
271      "cupboard2_phys", cupboard2_log, lab_phys, false, 1);
272
273
274  cupboard2_log->SetVisAttributes(cupboard_vat);
275
276
277  // NOW add the (wooden) DOOR:
278
279  G4double doorWidth = 1.67*m;  //X
280  G4double doorThick = 4.0*cm; //Y
281  G4double doorHeight = 2.09*m; //Z
282  G4double doorPosY = -0.5*(worldLength - doorThick);
283  G4double doorPosZ = -0.5*(worldHeight - doorHeight);
284
285  G4Box* door_box = new G4Box
286  ("door_box",0.5*doorWidth, 0.5*doorThick, 0.5*doorHeight );
287  door_log = new G4LogicalVolume(door_box, door_mat, "door_log");
288  door_phys = new G4PVPlacement
289    (0, G4ThreeVector(0., doorPosY, doorPosZ), "door_phys", door_log,
290     world_phys, false, 0);
291
292  G4VisAttributes* door_vat= new G4VisAttributes(brown);
293  door_vat->SetVisibility(true);
294  door_vat->SetForceSolid(true);
295  door_log->SetVisAttributes(door_vat);
296
297
298  // hole in wall between door and "lab": ************************************
299
300  G4double doorholeThick = wallThick - doorThick;
301  G4double doorholePosY = -(0.5*(worldLength - doorholeThick) - doorThick);
302  G4double doorholePosZ = doorPosZ;
303
304  G4Box* doorhole_box = new G4Box
305  ("doorhole_box",0.5*doorWidth, 0.5*doorholeThick, 0.5*doorHeight );
306  doorhole_log = new G4LogicalVolume(doorhole_box, lab_mat, "doorhole_log");
307  doorhole_phys = new G4PVPlacement
308    (0, G4ThreeVector(0., doorholePosY, doorholePosZ), "doorhole_phys",
309     doorhole_log, world_phys, false, 0);
310
311  G4VisAttributes* doorhole_vat= new G4VisAttributes(cyan);
312  //  window_log->SetVisAttributes(G4VisAttributes::Invisible);
313  doorhole_vat->SetVisibility(true);
314  doorhole_log->SetVisAttributes(doorhole_vat);
315
316
317  // desks: *****************************************************************
318  //now add Desks - wood, but have the opportunity for three different woods -
319  // Cupboard, Door and then desks
320
321  // desk1 - no cupboard underneath - should be bigger subtraction?:
322
323  G4double desk1Depth  = 57.0*cm; //X
324  G4double desk1Width  = 160.0*cm; //Y
325  G4double desk1Height = 90.5*cm; //Z
326  G4double deskThick      = 3.0*cm;
327  G4double desk1_insideDepth  = desk1Depth - 2.*deskThick;
328  G4double desk1_insideWidth  = desk1Width - 2.*deskThick;
329  G4double desk1_insideHeight = desk1Height - 2.*deskThick;
330
331  //nb: desk orientation is sideways because they are lined along the wall
332  G4Box* desk1_box = new G4Box
333   ("desk1_box", 0.5*desk1Depth, 0.5*desk1Width, 0.5*desk1Height);
334  G4Box* desk1_inside_box = new G4Box
335    ("desk1_inside_box", 0.5*desk1_insideDepth, 0.5*desk1_insideWidth,
336     0.5*desk1_insideHeight);
337  G4Box* desk1_door_box = new G4Box
338    ("desk1_door_box", 0.5*deskThick+1.0*nanometer, 0.25*desk1_insideWidth,
339     0.5*desk1_insideHeight);
340//    ("desk1_door_box", 0.5*deskThick, 0.25*desk1_insideWidth,
341//     0.5*desk1_insideHeight);
342
343  G4RotationMatrix rotMatrixDesk;
344  rotMatrixDesk.rotateY(0.0*deg);
345 
346  G4SubtractionSolid* desk1_frame = new G4SubtractionSolid
347    ("desk1_frame", desk1_box, desk1_inside_box, G4Transform3D
348     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
349  G4SubtractionSolid* desk1_sol = new G4SubtractionSolid
350    ("desk1_sol", desk1_frame, desk1_door_box, G4Transform3D
351     (rotMatrixCupboard, G4ThreeVector
352      (-0.5*(desk1_insideDepth+deskThick),-0.25*desk1_insideWidth,0.)));
353
354  desk1_log = new G4LogicalVolume(desk1_sol, desk_mat, "desk1_log");
355
356  G4double desk_X = 0.5*(labWidth - desk1Depth);
357  G4double desk_Y = -(0.5*(labLength - desk1Width) - 30.0*cm);
358  G4double desk_Z = 0.5*(desk1Height - labHeight);
359
360  desk1_phys = new G4PVPlacement
361        (0, G4ThreeVector(desk_X, desk_Y, desk_Z), "desk1_phys",
362         desk1_log, lab_phys, false, 0);
363
364  G4VisAttributes* desk_vat= new G4VisAttributes(brown);
365  desk_vat->SetVisibility(true);
366  desk_vat->SetForceSolid(true);
367  desk1_log->SetVisAttributes(desk_vat);
368
369  // *****************
370  // desk2 (drawers):
371
372  G4double desk2Depth  = 57.0*cm; //X
373  G4double desk2Width = 156.0*cm; //Y
374  G4double desk2Height = desk1Height; //Z
375
376  G4double desk2_insideDepth  = desk2Depth - 2.*deskThick;
377  G4double desk2_insideWidth  = desk2Width - 2.*deskThick;
378  G4double desk2_insideHeight = desk2Height - 2.*deskThick;
379
380  //nb: desk orientation is sideways because they are lined along the wall
381  G4Box* desk2_box = new G4Box
382   ("desk2_box", 0.5*desk2Depth, 0.5*desk2Width, 0.5*desk2Height);
383  G4Box* desk2_inside_box = new G4Box
384    ("desk2_inside_box", 0.5*desk2_insideDepth, 0.5*desk2_insideWidth,
385     0.5*desk2_insideHeight);
386  G4Box* desk2_door_box = new G4Box
387    ("desk2_door_box", 0.5*deskThick+1.0*nanometer, 0.2*desk2_insideWidth,
388     0.5*desk2_insideHeight);
389//    ("desk2_door_box", 0.5*deskThick, 0.2*desk2_insideWidth,
390//     0.5*desk2_insideHeight);
391
392  G4SubtractionSolid* desk2_frame = new G4SubtractionSolid
393    ("desk2_frame", desk2_box, desk2_inside_box, G4Transform3D
394     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
395  G4SubtractionSolid* desk2_sol = new G4SubtractionSolid
396    ("desk2_sol", desk2_frame, desk2_door_box, G4Transform3D
397     (rotMatrixCupboard, G4ThreeVector
398      (-0.5*(desk2_insideDepth+deskThick),-0.25*desk2_insideWidth,0.)));
399
400  desk2_log = new G4LogicalVolume(desk2_sol, desk_mat, "desk2_log");
401
402  desk_X = 0.5*(labWidth - desk2Depth);
403  desk_Y += 0.5*(desk2Width + desk1Width) + 2.0*cm;
404  desk_Z = 0.5*(desk2Height - labHeight);
405
406  desk2_phys = new G4PVPlacement
407        (0, G4ThreeVector(desk_X, desk_Y, desk_Z), "desk2_phys",
408         desk2_log, lab_phys, false, 0);
409
410  desk2_log->SetVisAttributes(desk_vat);
411
412  // *****************
413  // desk3 (cupboard underneath):
414
415  G4double desk3Depth  = 79.0*cm; //X
416  G4double desk3Width = 160.0*cm; //Y
417  G4double desk3Height = desk1Height; //Z
418
419  G4double desk3_insideDepth  = desk3Depth - 2.*deskThick;
420  G4double desk3_insideWidth  = desk3Width - 2.*deskThick;
421  G4double desk3_insideHeight = desk3Height - 2.*deskThick;
422
423  //nb: desk orientation is sideways because they are lined along the wall
424  G4Box* desk3_box = new G4Box
425   ("desk3_box", 0.5*desk3Depth, 0.5*desk3Width, 0.5*desk3Height);
426  G4Box* desk3_inside_box = new G4Box
427    ("desk3_inside_box", 0.5*desk3_insideDepth, 0.5*desk3_insideWidth,
428     0.5*desk3_insideHeight);
429  G4Box* desk3_door_box = new G4Box
430    ("desk3_door_box", 0.5*deskThick+1.0*nanometer, 0.15*desk3_insideWidth, 0.5*desk1_insideHeight);
431//    ("desk3_door_box", 0.5*deskThick, 0.15*desk3_insideWidth,
432//     0.5*desk1_insideHeight);
433
434  G4SubtractionSolid* desk3_frame = new G4SubtractionSolid
435    ("desk3_frame", desk3_box, desk3_inside_box, G4Transform3D
436     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
437  G4SubtractionSolid* desk3_sol = new G4SubtractionSolid
438    ("desk3_sol", desk3_frame, desk3_door_box, G4Transform3D
439     (rotMatrixCupboard, G4ThreeVector
440      (-0.5*(desk3_insideDepth+deskThick),-0.35*desk3_insideWidth,0.)));
441
442  desk3_log = new G4LogicalVolume(desk3_sol, desk_mat, "desk3_log");
443
444  desk_X = 0.5*(labWidth - desk3Depth);
445  desk_Y += 0.5*(desk3Width + desk3Width) + 2.0*cm;
446  desk_Z = 0.5*(desk3Height - labHeight);
447
448  desk3_phys = new G4PVPlacement
449        (0, G4ThreeVector(desk_X, desk_Y, desk_Z), "desk3_phys",
450         desk3_log, lab_phys, false, 0);
451
452  desk3_log->SetVisAttributes(desk_vat);
453
454
455  // *****************
456  // wooden radiator trunking - along LHS wall
457
458  G4double trunkDepth  = 20.0*cm; //X
459  G4double trunkWidth  = labLength; //Y
460  G4double trunkHeight = desk1Height; //Z
461  G4double trunkThick  = 3.0*cm;
462
463  // not 2.*trunkThick since only 2 sides of box - top and front
464  G4double trunk_insideDepth  = trunkDepth - trunkThick;
465  G4double trunk_insideWidth  = trunkWidth;
466  G4double trunk_insideHeight = trunkHeight - trunkThick;
467
468  G4Box* trunk_box = new G4Box
469   ("trunk_box", 0.5*trunkDepth, 0.5*trunkWidth, 0.5*trunkHeight);
470  G4Box* trunk_inside_box = new G4Box
471    ("trunk_inside_box", 0.5*trunk_insideDepth, 0.5*trunk_insideWidth,
472     0.5*trunk_insideHeight);
473
474  trunk_log = new G4LogicalVolume(trunk_box, desk_mat, "trunk_log");
475  trunk_inside_log = new G4LogicalVolume
476                    (trunk_inside_box, lab_mat, "trunk_inside_log");
477
478  G4double trunk_X = -0.5*(labWidth - trunkDepth);
479  G4double trunk_Y = 0.0*m;
480  G4double trunk_Z = -0.5*(labHeight - trunkHeight);
481 
482  trunk_phys = new G4PVPlacement
483        (0, G4ThreeVector(trunk_X, trunk_Y, trunk_Z), "trunk_phys",
484         trunk_log, lab_phys, false, 0);
485
486  G4double trunkinside_X = -0.5*(trunkDepth - trunk_insideDepth);
487  G4double trunkinside_Y = 0.0*m;
488  G4double trunkinside_Z = -0.5*(trunkHeight - trunk_insideHeight);
489 
490  trunk_inside_phys = new G4PVPlacement
491        (0, G4ThreeVector(trunkinside_X, trunkinside_Y, trunkinside_Z),
492            "trunk_inside_phys",trunk_inside_log, trunk_phys, false, 0);
493
494  trunk_log->SetVisAttributes(desk_vat);
495  trunk_inside_log->SetVisAttributes(window_vat);
496
497  // *****************
498  // desk4,5,6 (actually 4 with multi-place idx) LHS with cupboards underneath:
499
500  G4double desk4Depth  = 79.0*cm; //X
501  G4double desk4Width  = 79.0*cm; //Y
502  G4double desk4Height = desk1Height; //Z
503
504  G4double desk4_insideDepth  = desk4Depth - 2.*deskThick;
505  G4double desk4_insideWidth  = desk4Width - 2.*deskThick;
506  G4double desk4_insideHeight = desk4Height - 2.*deskThick;
507
508  //nb: desk orientation is sideways because they are lined along the wall
509  G4Box* desk4_box = new G4Box
510   ("desk4_box", 0.5*desk4Depth, 0.5*desk4Width, 0.5*desk4Height);
511  G4Box* desk4_inside_box = new G4Box
512    ("desk4_inside_box", 0.5*desk4_insideDepth, 0.5*desk4_insideWidth,
513     0.5*desk4_insideHeight);
514  G4Box* desk4_door_box = new G4Box
515    ("desk4_door_box", 0.5*deskThick+1.0*nanometer, 0.45*desk4_insideWidth,
516     0.5*desk4_insideHeight);
517//    ("desk4_door_box", 0.5*deskThick, 0.45*desk4_insideWidth,
518//     0.5*desk4_insideHeight);
519
520  G4SubtractionSolid* desk4_frame = new G4SubtractionSolid
521    ("desk4_frame", desk4_box, desk4_inside_box, G4Transform3D
522     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
523  G4SubtractionSolid* desk4_sol = new G4SubtractionSolid
524    ("desk4_sol", desk4_frame, desk4_door_box, G4Transform3D
525     (rotMatrixCupboard, G4ThreeVector
526      (0.5*(desk4_insideDepth+deskThick),0.,0.)));
527
528  desk4_log = new G4LogicalVolume(desk4_sol, desk_mat, "desk4_log");
529
530  desk_X = -0.5*(labWidth - desk4Depth) + trunkDepth;
531  desk_Y = -(0.5*(labLength - desk4Width) - 5.0*cm);
532  desk_Z = 0.5*(desk4Height - labHeight);
533 
534  G4double crateWidth  = 60.0*cm; //Y
535  G4double crate_Y = 0.;
536
537  G4RotationMatrix rotMatrixDesk4;
538  rotMatrixDesk4.rotateZ(0.0*deg);
539
540  for (G4int j=0; j<3; j++)
541    {
542      if( j == 2)
543        {
544          desk_Y += crateWidth;
545          crate_Y = desk_Y - 0.5*(desk4Width + crateWidth);
546        }
547      desk4_phys = new G4PVPlacement
548        (G4Transform3D(rotMatrixDesk4, G4ThreeVector(desk_X, desk_Y, desk_Z)),
549         "desk4_phys", desk4_log, lab_phys, false, j);
550      desk_Y += desk4Width+2.0*cm;
551    }
552
553  desk4_log->SetVisAttributes(desk_vat);
554
555  // *****************
556  // aluminium crate rack:
557
558  G4double crateDepth  = 64.0*cm; //X
559  //  G4double crateWidth  = 60.0*cm; //Y - moved above...........
560  G4double crateHeight = 128.0*cm; //Z
561  G4double crateThick  = 3.0*cm;
562
563  G4double crate_insideDepth  = crateDepth - 2.*crateThick;
564  G4double crate_insideWidth  = crateWidth - 2.*crateThick;
565  G4double crate_insideHeight = crateHeight - 2.*crateThick;
566
567  //nb: crate orientation is sideways because they are lined along the wall
568  G4Box* crate_box = new G4Box
569   ("crate_box", 0.5*crateDepth, 0.5*crateWidth, 0.5*crateHeight);
570  G4Box* crate_inside_box = new G4Box
571    ("crate_inside_box", 0.5*crate_insideDepth, 0.5*crate_insideWidth,
572     0.5*crate_insideHeight);
573  G4Box* crate_front_box = new G4Box
574    ("crate_front_box", 0.5*crateThick+1.0*nanometer, 0.5*crate_insideWidth,
575     0.5*crate_insideHeight);
576
577  G4SubtractionSolid* crate_frame = new G4SubtractionSolid
578    ("crate_frame", crate_box, crate_inside_box, G4Transform3D
579     (rotMatrixCupboard, G4ThreeVector(0.,0.,0.)));
580  G4SubtractionSolid* crate_sol = new G4SubtractionSolid
581    ("crate_sol", crate_frame, crate_front_box, G4Transform3D
582     (rotMatrixCupboard, G4ThreeVector
583      (0.5*(crate_insideDepth+crateThick),0.,0.)));
584
585  crate_log = new G4LogicalVolume(crate_sol, crate_mat, "crate_log");
586
587  G4double crate_X = -0.5*(labWidth - crateDepth) + trunkDepth;
588  // crate_Y defined previously (by desk spacing.......)
589  G4double crate_Z = 0.5*(crateHeight - labHeight);
590 
591  crate_phys = new G4PVPlacement
592        (0, G4ThreeVector(crate_X, crate_Y, crate_Z), "crate_phys",
593         crate_log, lab_phys, false, 0);
594
595  G4VisAttributes* crate_vat= new G4VisAttributes(grey);
596  crate_vat->SetVisibility(true);
597  crate_vat->SetForceSolid(true);
598  crate_log->SetVisAttributes(crate_vat);
599
600// clean room desks: ****************************************************
601
602// first oblong desk (type "3"):
603  desk_X = -0.5*(labWidth - desk3Width) + 50.0*cm;
604  desk_Y = 0.5*(labLength - desk3Width - 30.0*cm);
605  desk_Z = 0.5*(desk4Height - labHeight);
606 
607  G4RotationMatrix rotMatrixCleanDesk;
608  rotMatrixCleanDesk.rotateZ(90.0*deg);
609
610  desk3_phys = new G4PVPlacement
611    (G4Transform3D
612     (rotMatrixCleanDesk,G4ThreeVector(desk_X, desk_Y, desk_Z)),
613      "desk3_phys", desk3_log, lab_phys, false, 1);
614
615// square desk (type "4"):
616
617  desk_X += 0.5*desk3Width + 0.5*desk4Width; // rotated hence Width
618
619  rotMatrixCleanDesk.rotateZ(-180.0*deg);
620  desk4_phys = new G4PVPlacement
621    (G4Transform3D
622        (rotMatrixCleanDesk, G4ThreeVector(desk_X, desk_Y, desk_Z)),
623         "desk4_phys", desk4_log, lab_phys, false, 3);
624
625
Note: See TracBrowser for help on using the repository browser.