source: trunk/examples/advanced/Rich/src/RichTbComponent.cc @ 1309

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

update
File size: 14.2 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// Rich advanced example for Geant4
27// RichTbComponent.cc for Rich of LHCb
28// History:
29// Created: Sajan Easo (Sajan.Easo@cern.ch)
30// Revision and changes: Patricia Mendez (Patricia.Mendez@cern.ch)
31/////////////////////////////////////////////////////////////////////////////
32#include <iostream>
33#include "globals.hh"
34#include "RichTbDetectorConstruction.hh"
35#include "RichTbGeometryParameters.hh"
36#include "RichTbMaterialParameters.hh"
37#include "FilterTypeSpec.hh"
38#include "RichTbComponent.hh"
39#include "G4Box.hh"
40#include "G4Tubs.hh"
41#include "G4Sphere.hh"
42#include "G4LogicalVolume.hh"
43#include "G4VPhysicalVolume.hh"
44#include "G4PVPlacement.hh"
45#include "G4RotationMatrix.hh"
46#include "G4ThreeVector.hh"
47#include "G4Transform3D.hh"
48#include "G4LogicalBorderSurface.hh"
49#include "G4Material.hh"
50#include "G4SubtractionSolid.hh"
51
52RichTbComponent::RichTbComponent(){ ; }
53RichTbComponent::RichTbComponent(RichTbMaterial* RMaterial, 
54  RichTbHall* RTbHall , RichTbRunConfig* RConfig, 
55  G4bool ConstructTrackingSwitch):
56  RichTbAgelLVol(std::vector<G4LogicalVolume*>(MaxNumberOfAerogelTiles)),
57  RichTbAgelPVol(std::vector<G4VPhysicalVolume*>(MaxNumberOfAerogelTiles)),
58  RichTbAgelWrapTopLVol(std::vector<G4LogicalVolume*>(MaxNumberOfAerogelTiles)),
59  RichTbAgelWrapTopPVol(std::vector<G4VPhysicalVolume*>(MaxNumberOfAerogelTiles)),
60  RichTbAgelWrapBotLVol(std::vector<G4LogicalVolume*>(MaxNumberOfAerogelTiles)),
61 RichTbAgelWrapBotPVol(std::vector<G4VPhysicalVolume*>(MaxNumberOfAerogelTiles))
62 { 
63
64    ConstructTrackingGeometrySwitch=ConstructTrackingSwitch;
65
66  //First define the shapes.
67  //Components of the Vessel.
68  G4Tubs * VesselEnclosure
69    = new G4Tubs("VesselEnclosure",VesselInnerRad,VesselOuterRad,
70                 VesselHalfZ,VesselStartPhi,VesselDelPhi);
71  G4RotationMatrix VesselBRot; 
72  G4ThreeVector VesselBTrsl(VesselPosX,VesselPosY,VesselPosZ);
73
74  G4Transform3D VesselBTransform(VesselBRot,VesselBTrsl);
75
76  G4LogicalVolume* VesselEnclosureLog=
77    new G4LogicalVolume(VesselEnclosure, RMaterial->getNitrogenGas(),
78                        "VesselEnclosure",0,0,0);
79 
80  G4VPhysicalVolume* VesselEnclosurePhys=
81    new G4PVPlacement(VesselBTransform,"VesselEnclosure",
82                      VesselEnclosureLog,
83                      RTbHall->getRichTbHallPhysicalVolume(),
84                      false,0);
85  //
86  //
87  if(ConstructTrackingSwitch){
88
89  G4int NAgelTiles=RConfig-> GetNumberOfAerogelTiles();
90
91
92  G4Box * RadFrame
93    = new G4Box("RadFrame",RadFrameHalfX,RadFrameHalfY,RadFrameHalfZ);
94
95  G4Box * RadHoldUps
96    = new G4Box("RadHoldUps",RadHoldUpHalfX,RadHoldUpHalfY,RadHoldUpHalfZ);
97  G4Tubs * RadHoldUpWin
98    = new G4Tubs("RadHoldUpWin", RadWinUpInnerRad, RadWinUpOuterRad,
99                  RadWinUpHalfZ,RadWinUpStartPhi,RadWinUpDelPhi);
100
101
102  G4Box * RadHoldDns
103    = new G4Box("RadHoldDns",RadHoldDnHalfX,RadHoldDnHalfY,RadHoldDnHalfZ);
104  G4Tubs * RadHoldDnWin
105    = new G4Tubs("RadHoldDnWin", RadWinDnInnerRad, RadWinDnOuterRad,
106                  RadWinDnHalfZ,RadWinDnStartPhi,RadWinDnDelPhi);
107
108
109  G4int FilterNum = RConfig->GetFilterTNumber();
110  G4Box * FilterBox=0;
111  if(FilterNum >= 0 ) {
112  G4double FilterHalfZ= FilterHalfZArray[FilterNum];
113  FilterBox
114    = new G4Box("FilterBox", FilterHalfX,FilterHalfY,FilterHalfZ);
115
116  }
117  //Mirror
118  G4double MirrThetaSize=2.0*std::asin(MirrorHorizontalChord/(MirrorRInner*2.0));
119  G4double MirrThetaStart=halfpi*rad-MirrThetaSize/2.0;
120  G4double MirrPhiSize=2.0*std::asin(MirrorVerticalChord/(MirrorRInner*2.0));
121  G4double MirrPhiStart=-MirrPhiSize/2.0;
122
123  G4Sphere* MirrorSphe= new G4Sphere("MirrorSphe",MirrorRInner,
124                                      MirrorROuter,MirrPhiStart,
125                                      MirrPhiSize,MirrThetaStart,
126                                      MirrThetaSize);
127
128  //Now for the rotations and translations..
129
130  G4RotationMatrix RadFrameRot;
131  G4RotationMatrix RadWinUpRot,RadWinDnRot,RadHoldUpRot,RadHoldDnRot;
132
133  G4ThreeVector RadFrameTrsl(RadFramePosX,RadFramePosY,RadFramePosZ);
134  G4Transform3D RadFrameTransform(RadFrameRot,RadFrameTrsl);
135  //
136  //
137  G4ThreeVector RadWinUpTrsl(RadWinUpShiftX,RadWinUpShiftY,RadWinUpShiftZ);
138  G4Transform3D RadWinUpTransform(RadWinUpRot,RadWinUpTrsl);
139  G4ThreeVector RadHoldUpTrsl(RadHoldUpPosX,RadHoldUpPosY,RadHoldUpPosZ);
140  G4Transform3D RadHoldUpTransform(RadHoldUpRot,RadHoldUpTrsl);
141  //
142  G4ThreeVector RadWinDnTrsl(RadWinDnShiftX,RadWinDnShiftY,RadWinDnShiftZ);
143  G4Transform3D RadWinDnTransform(RadWinDnRot,RadWinDnTrsl);
144  G4ThreeVector RadHoldDnTrsl(RadHoldDnPosX,RadHoldDnPosY,RadHoldDnPosZ);
145  G4Transform3D RadHoldDnTransform(RadHoldDnRot,RadHoldDnTrsl);
146  //
147  //
148  //
149  G4RotationMatrix MirrorRotationX, MirrorRotationY;
150  G4double MirrorExtraTiltX = RConfig->getMirrorAddTiltX();
151  G4double MirrorExtraTiltY = RConfig->getMirrorAddTiltY();
152  G4double MirrorTotRotX= MirrorNominalRotX+MirrorExtraTiltX;
153  G4double MirrorTotRotY= MirrorNominalRotY+MirrorExtraTiltY;
154  G4double  MirrorPosX,  MirrorPosY,  MirrorPosZ;
155
156  if( MirrorTotRotX !=0.0 ||  MirrorTotRotY != 0.0 ) {
157     MirrorPosX =-VesselPosX-MirrorRInner*std::sin(MirrorTotRotY);
158     MirrorPosY =-VesselPosY+MirrorRInner*std::sin(MirrorTotRotX);
159     MirrorPosZ =MirrorShiftFromEnd-VesselHalfZ
160      -MirrorRInner*(std::cos(MirrorTotRotY)+std::cos(MirrorTotRotX)-1.0);
161  }else {
162    MirrorPosX =-VesselPosX;
163    MirrorPosY =-VesselPosY;
164    MirrorPosZ =MirrorNominalPosZ;
165  }
166  G4ThreeVector MirrorPos(MirrorPosX,MirrorPosY,MirrorPosZ);
167  if (MirrorTotRotX != 0.0 ) {
168  MirrorRotationX.rotateX(MirrorTotRotX);
169  }
170  MirrorRotationY.rotateY(-halfpi*rad+MirrorTotRotY);
171  G4Transform3D MirrorTransform(MirrorRotationX*MirrorRotationY,MirrorPos);
172
173  //
174       
175  G4LogicalBorderSurface* VesselOuterSurface =
176    new G4LogicalBorderSurface("VesselOuterSurface", 
177                         RTbHall->getRichTbHallPhysicalVolume(),
178                         VesselEnclosurePhys,
179                         RMaterial->getOpticalEnclosureSurface());
180  G4LogicalBorderSurface* VesselInnerSurface =
181    new G4LogicalBorderSurface("VesselInnerSurface",
182                         VesselEnclosurePhys, 
183                         RTbHall->getRichTbHallPhysicalVolume(),
184                         RMaterial->getOpticalEnclosureSurface());
185
186  RichTbEnclosureOuterBSurf=VesselOuterSurface;
187  RichTbEnclosureInnerBSurf=VesselInnerSurface;
188
189  G4LogicalVolume* RadFrameLog=
190    new G4LogicalVolume(RadFrame,RMaterial->getNitrogenGas(),
191                        "RadFrame",0,0,0);
192
193  G4VPhysicalVolume* RadFramePhys=
194    new G4PVPlacement(RadFrameTransform,"RadFrame",RadFrameLog,
195                     VesselEnclosurePhys,false,0);
196
197  //Now for the holder upstream and downstream of the Aerogel Tiles.
198  G4SubtractionSolid* RadUpW = 
199    new G4SubtractionSolid("RadUpW",RadHoldUps,RadHoldUpWin,
200                           RadWinUpTransform); 
201
202  G4LogicalVolume* RadUpWLog=
203    new G4LogicalVolume(RadUpW,RMaterial->getPlasticAg(),
204                        "RadUpW",0,0,0);
205
206  G4VPhysicalVolume* RadUpWPhys=
207    new G4PVPlacement( RadHoldUpTransform,"RadUpW",RadUpWLog,
208                     RadFramePhys ,false,0);
209  //
210  G4SubtractionSolid* RadDnW = 
211    new G4SubtractionSolid("RadDnW",RadHoldDns,RadHoldDnWin,
212                           RadWinDnTransform); 
213
214  G4LogicalVolume* RadDnWLog=
215    new G4LogicalVolume(RadDnW,RMaterial->getAluminium(),
216                        "RadDnW",0,0,0);
217
218  G4VPhysicalVolume* RadDnWPhys=
219    new G4PVPlacement( RadHoldDnTransform,"RadDnW",RadDnWLog,
220                     RadFramePhys ,false,0);
221   
222
223  //Now for the various aerogel tiles and the wraps above and
224  //below them
225
226  NumAerogelTiles= NAgelTiles; 
227  G4RotationMatrix AgelRot,AgelWrapTopRot,AgelWrapBotRot;
228  G4double AgelPosSZ[MaxNumberOfAerogelTiles];
229  G4double AgelPosCurZ[MaxNumberOfAerogelTiles];
230  for(G4int agNum=0; agNum<NAgelTiles; agNum++ ){
231     G4int agTnumber= RConfig->GetCurAerogelTNumber(agNum);
232
233     G4Box* Agel = new G4Box("Agel", AgelHalfX[agTnumber],
234                           AgelHalfY[agTnumber],AgelHalfZ[agTnumber]);
235
236     AgelPosSZ[agNum]=AgelHalfZ[agTnumber];
237
238     AgelPosCurZ[agNum]=AgelEndZ-AgelHalfZ[agTnumber];
239     for(G4int agt=0; agt<agNum; agt++ ) {
240
241       AgelPosCurZ[agNum] -= (2*AgelPosSZ[agt]+ AgelTileGapZ);
242     } 
243     G4ThreeVector AgelTrsl(AgelPosX[agNum],
244            AgelPosY[agNum],AgelPosCurZ[agNum]);
245     G4Transform3D AgelTransform(AgelRot,AgelTrsl);
246
247     G4Material* CurAgelMaterial= RMaterial->getAerogelMaterial(agTnumber);
248
249     G4LogicalVolume* AgelLog=
250       new G4LogicalVolume(Agel,CurAgelMaterial,"Agel",0,0,0);
251       G4VPhysicalVolume* AgelPhys=
252        new G4PVPlacement(AgelTransform,"Agel",AgelLog,
253                     RadFramePhys,false,agNum);
254
255     RichTbAgelLVol[agNum] =  AgelLog;
256     RichTbAgelPVol[agNum] =  AgelPhys;
257
258     G4Box* AgelWrapTop = new G4Box("AgelWrapTop", AgelWrapTopHalfX[agTnumber],
259                           AgelWrapTopHalfY[agTnumber],
260                           AgelWrapTopHalfZ[agTnumber]);
261     G4Box* AgelWrapBot = new G4Box("AgelWrapBot", AgelWrapBotHalfX[agTnumber],
262                       AgelWrapBotHalfY[agTnumber],
263                       AgelWrapBotHalfZ[agTnumber]);
264
265     G4double AgelWrapTopPosCurZ=AgelPosCurZ[agNum];
266     G4double AgelWrapBotPosCurZ=AgelPosCurZ[agNum];
267     G4double AgelWrapTopPosCurY=AgelHalfY[agTnumber]+ 
268       AgelWrapTopHalfY[agTnumber];
269     G4double AgelWrapBotPosCurY=-AgelHalfY[agTnumber]+ 
270       -AgelWrapBotHalfY[agTnumber];
271     G4ThreeVector AgelWrapTopTrsl(AgelWrapTopPosX[agNum],
272                   AgelWrapTopPosCurY,AgelWrapTopPosCurZ);
273     G4Transform3D AgelWrapTopTransform(AgelWrapTopRot,AgelWrapTopTrsl);
274     G4ThreeVector AgelWrapBotTrsl(AgelWrapBotPosX[agNum],
275                   AgelWrapBotPosCurY,AgelWrapBotPosCurZ);
276     G4Transform3D AgelWrapBotTransform(AgelWrapBotRot,AgelWrapBotTrsl);
277
278     G4LogicalVolume* AgelWrapTopLog=
279        new G4LogicalVolume(AgelWrapTop, RMaterial->getPlasticAg(),
280                        "AgelWrapTop",0,0,0);
281      G4LogicalVolume* AgelWrapBotLog=
282       new G4LogicalVolume(AgelWrapBot, RMaterial->getPlasticAg(),
283                        "AgelWrapBot",0,0,0);
284
285   G4VPhysicalVolume* AgelWrapTopPhys=
286      new G4PVPlacement(AgelWrapTopTransform,"AgelWrapTop",
287                    AgelWrapTopLog,RadFramePhys,false,agNum);
288
289   G4VPhysicalVolume* AgelWrapBotPhys=
290     new G4PVPlacement(AgelWrapBotTransform,"AgelWrapBot",
291                  AgelWrapBotLog,RadFramePhys,false,agNum);
292
293   RichTbAgelWrapTopLVol[agNum] =  AgelWrapTopLog;
294   RichTbAgelWrapTopPVol[agNum] =  AgelWrapTopPhys;
295   RichTbAgelWrapBotLVol[agNum] =  AgelWrapBotLog;
296   RichTbAgelWrapBotPVol[agNum] =  AgelWrapBotPhys;
297
298  }
299
300  //  FilterType CurFil= RConfig->GetFilterType();
301  G4int Filnum=  RConfig->GetFilterTNumber() ;
302  G4LogicalVolume* FilterLog=0;
303  G4VPhysicalVolume* FilterPhys=0;
304  if(Filnum >= 0 ) {
305
306  G4double FilterHalfZCur= FilterHalfZArray[Filnum];
307
308  G4double FilterPosZ= FilterPosZNominal-FilterHalfZNominal+FilterHalfZCur;
309 
310
311  G4RotationMatrix FilterRot;
312
313  G4ThreeVector FilterTrsl(FilterPosX,FilterPosY,FilterPosZ);
314  G4Transform3D FilterTransform(FilterRot,FilterTrsl);
315
316  G4Material*  CurFilterMaterial
317    = RMaterial-> getRichTbFilterMaterial( Filnum);
318
319     FilterLog=
320      new G4LogicalVolume(FilterBox, CurFilterMaterial,
321                        "FilterBox",0,0,0);
322
323    FilterPhys=
324    new G4PVPlacement(FilterTransform,"FilterBox",FilterLog,
325                     RadFramePhys,false,0);
326
327//  G4LogicalBorderSurface* FilterInnerSurface =
328    new G4LogicalBorderSurface("RichTbFilterInnerSurface",
329                               FilterPhys,VesselEnclosurePhys,
330                               RMaterial->getOpticalFilterSurface());
331
332//  G4LogicalBorderSurface* FilterOuterSurface =
333    new G4LogicalBorderSurface("RichTbFilterOuterSurface",
334                               VesselEnclosurePhys,FilterPhys,
335                               RMaterial->getOpticalFilterSurface());
336
337  }
338  G4LogicalVolume* MirrorLog=
339    new G4LogicalVolume(MirrorSphe,RMaterial->getMirrorQuartz(),
340                        "MirrorSphe",0,0,0);
341
342
343  G4VPhysicalVolume* MirrorPhys=
344    new G4PVPlacement(MirrorTransform,"MirrorSphe",MirrorLog,
345                     VesselEnclosurePhys,false,0);
346  G4LogicalBorderSurface* MirrorSurface =
347    new G4LogicalBorderSurface("RichTbMirrorSurface",
348                               VesselEnclosurePhys,MirrorPhys,
349                               RMaterial->getOpticalMirrorSurface());
350
351
352  RichTbRadFrameLVol= RadFrameLog;
353  RichTbRadFramePVol= RadFramePhys;
354
355  RichTbRadUpWLVol= RadUpWLog;
356  RichTbRadUpWPVol= RadUpWPhys;
357
358  RichTbRadDnWLVol= RadDnWLog;
359  RichTbRadDnWPVol= RadDnWPhys;
360
361  if(Filnum >= 0 ) {
362  RichTbFilterLVol =  FilterLog;
363  RichTbFilterPVol =  FilterPhys;
364  }
365  RichTbMirrorLVol=MirrorLog;
366  RichTbMirrorPVol=MirrorPhys;
367  RichTbMirrorBSurf=MirrorSurface;
368  }
369
370  RichTbEnclosureLVol=VesselEnclosureLog;
371  RichTbEnclosurePVol=VesselEnclosurePhys;
372
373
374 }
375
376RichTbComponent::~RichTbComponent() {; }
377
378
379
380
381
382
383
384
385
Note: See TracBrowser for help on using the repository browser.