FairRoot/PandaRoot
Functions | Variables
createRootGeometry_RICH.C File Reference
#include <vector>

Go to the source code of this file.

Functions

void createRootGeometry_RICH (UInt_t ver=0, bool useBeamPipeHole=true)
 

Variables

const Double_t pi = 3.1415926535
 

Function Documentation

void createRootGeometry_RICH ( UInt_t  ver = 0,
bool  useBeamPipeHole = true 
)

Definition at line 14 of file createRootGeometry_RICH.C.

References acos(), PndRichGeo::aerogelLayers(), PndRichGeo::aerogelOffset(), PndRichGeo::aerogelSize(), PndRichGeo::alBoxSize(), PndRichGeo::alBoxWallThickness(), alpha, PndRichGeo::angleExtansionInner(), PndRichGeo::angleExtansionOuter(), PndRichGeo::angleOfMirrorPosition(), atan2(), PndRichGeo::beamPipeHoleX(), PndRichGeo::beamPipeHoleY(), combi, cos(), Double_t, fGeoFile, fi, PndRichGeo::flatMirrorY(), PndRichGeo::flatMirrorZ(), geobuild, geoFace, geoLoad, gGeoMan, gGeoManager, i, PndRichGeo::init(), is, Media, PndRichGeo::mirrorAxis(), PndRichGeo::mirrorCurvature(), PndRichGeo::mirrorLength(), PndRichGeo::mirrorRadius(), PndRichGeo::mirrorThetaMax(), PndRichGeo::mirrorThetaMin(), PndRichGeo::mirrorThickness(), nmed, PndRichGeo::nOpt(), PndRichGeo::phDetLength(), PndRichGeo::phDetThickness(), PndRichGeo::phDetY(), PndRichGeo::phDetZ(), pi, PndRichGeo::richOffset(), sin(), sqrt(), theta, thickness, top, trans, and TString.

14  {
15 
16  UInt_t verm = ver%100;
17 
18  const Double_t pi = 3.1415926535;
19 
20 // gROOT->Macro("$VMCWORKDIR/gconfig/rootlogon.C");
21 
22  TString vmcWorkdir = getenv("VMCWORKDIR");
23 
24  // Load this libraries
25  gSystem->Load("libGeoBase");
26  gSystem->Load("libParBase");
27  gSystem->Load("libBase");
28  gSystem->Load("libPndData");
29  gSystem->Load("libPassive");
30  gSystem->Load("libEve");
31 
32  // variable to achieve the RICH basic parameters
33  PndRichGeo* fGeo = new PndRichGeo();
34  fGeo->init(ver);
35 
36  // units = cm
37 
38  //bool useBeamPipeHole = true;
39 
40  TVector3 richOffset = fGeo->richOffset();
41  TVector3 alBoxSize = fGeo->alBoxSize();
42  Double_t alBoxWallThickness = fGeo->alBoxWallThickness();
43  TVector3 aerogelSize = fGeo->aerogelSize();
44  TVector3 aerogelOffset = fGeo->aerogelOffset();
45  std::vector<Double_t> nOpt = fGeo->nOpt();
46  std::vector<Double_t> aerogelLayers = fGeo->aerogelLayers();
47  Double_t ka1 = fGeo->angleExtansionInner();
48  Double_t ka2 = fGeo->angleExtansionOuter();
49  Double_t beta = fGeo->mirrorCurvature();
50  Double_t alpha = fGeo->angleOfMirrorPosition();
51  Double_t mirrorThickness = fGeo->mirrorThickness();
52  Double_t mirrorLength = fGeo->mirrorLength();
53  Double_t phDetLength = fGeo->phDetLength();
54  Double_t phDetThickness = fGeo->phDetThickness();
55  Double_t beamPipeHoleX = fGeo->beamPipeHoleX();
56  Double_t beamPipeHoleY = fGeo->beamPipeHoleY();
57 
58  std::vector<Double_t> phDetY = fGeo->phDetY();
59  std::vector<Double_t> phDetZ = fGeo->phDetZ();
60  std::vector<Double_t> flatMirrorY = fGeo->flatMirrorY();
61  std::vector<Double_t> flatMirrorZ = fGeo->flatMirrorZ();
62  for(size_t i=0;i<flatMirrorY.size();i++)
63  std::cout << i << " " << flatMirrorY[i] << " " << flatMirrorZ[i] << std::endl;
64  for(i=0;i<phDetY.size();i++)
65  std::cout << i << " " << phDetY[i] << " " << phDetZ[i] << std::endl;
66  for(i=0;i<nOpt.size();i++)
67  std::cout << i << " " << nOpt[i] << std::endl;
68 
69  //----------------------------------------------------------
70 
71  if (useBeamPipeHole)
72  TString fGeoFile= Form("../../geometry/rich_v%d.root",ver);
73  else
74  TString fGeoFile= Form("../../geometry/rich_v%d_cal.root",ver);
75  TFile* fi = new TFile(fGeoFile,"RECREATE");
76  cout<<"Output file = "<<fGeoFile<<endl;
77 
78  if (!useBeamPipeHole) {
79  beamPipeHoleX = 0;
80  beamPipeHoleY = 0;
81  useBeamPipeHole = true;
82  }
83  std::cout << beamPipeHoleX << " " << beamPipeHoleY << std::endl;
84 
85  FairGeoLoader* geoLoad = new FairGeoLoader("TGeo","FairGeoLoader");
86  FairGeoInterface *geoFace = geoLoad->getGeoInterface();
87  geoFace->setMediaFile("../../geometry/media_pnd.geo");
88  geoFace->readMedia();
89  geoFace->print();
90 
91  FairGeoMedia *Media = geoFace->getMedia();
92  FairGeoBuilder *geobuild=geoLoad->getGeoBuilder();
93 
94  FairGeoMedium *RichAl = Media->getMedium("aluminium");
95  FairGeoMedium *RichAir = Media->getMedium("RichAir");
96  FairGeoMedium *RichAerogel = Media->getMedium("FusedSil");
97  FairGeoMedium *RichAerogel0 = Media->getMedium("RichAerogel0");
98  FairGeoMedium *RichAerogel1 = Media->getMedium("RichAerogel1");
99  FairGeoMedium *RichAerogel2 = Media->getMedium("RichAerogel2");
100  FairGeoMedium *RichAerogel3 = Media->getMedium("RichAerogel3");
101  FairGeoMedium *RichAerogel4 = Media->getMedium("RichAerogel4");
102  FairGeoMedium *RichPcbmvd = Media->getMedium("pcbmvd");
103  FairGeoMedium *RichPDWindow = Media->getMedium("RichPDWindow");
104  FairGeoMedium *RichSilicon = Media->getMedium("silicon");
105  FairGeoMedium *RichMirror = Media->getMedium("Mirror");
106 
107  Int_t nmed;
108  nmed=geobuild->createMedium(RichAir);
109  nmed=geobuild->createMedium(RichAl);
110  nmed=geobuild->createMedium(RichAerogel);
111  nmed=geobuild->createMedium(RichAerogel0);
112  nmed=geobuild->createMedium(RichAerogel1);
113  nmed=geobuild->createMedium(RichAerogel2);
114  nmed=geobuild->createMedium(RichAerogel3);
115  nmed=geobuild->createMedium(RichAerogel4);
116  nmed=geobuild->createMedium(RichPcbmvd);
117  nmed=geobuild->createMedium(RichPDWindow);
118  nmed=geobuild->createMedium(RichSilicon);
119  nmed=geobuild->createMedium(RichMirror);
120 
121 
122  //-------------------------------------------------------------------------------------------------------------
123  // Rich system
124  // Al box
125  TGeoBBox* lRichBox = new TGeoBBox("richBox", alBoxSize.X()/2, alBoxSize.Y()/2, alBoxSize.Z()/2 );
126  TGeoVolume *alRichBox = new TGeoVolume("RichAlBox",lRichBox, gGeoManager->GetMedium("aluminium"));
127 
128  // Air box
129  TGeoBBox* lRichBoxAir = new TGeoBBox("richBoxAir",
130  alBoxSize.X()/2 - alBoxWallThickness,
131  alBoxSize.Y()/2 - alBoxWallThickness,
132  alBoxSize.Z()/2 - alBoxWallThickness );
133  TGeoVolume *alRichBoxAir = new TGeoVolume("RichAlBoxAir",lRichBoxAir, gGeoManager->GetMedium("RichAir"));
134  alRichBoxAir->SetLineColor(kGreen);
135  alRichBoxAir->SetTransparency(90);
136  alRichBox->AddNode(alRichBoxAir, 0, new TGeoCombiTrans( 0, 0, 0, new TGeoRotation(0) ) );
137 
138  TGeoBBox* lRichBeamPipeHole = new TGeoBBox("richBeamPipeHole",
139  2*beamPipeHoleX/2,
140  2*beamPipeHoleY/2,
141  alBoxSize.Z()/2 );
142 
143  // MultiLayer Aerogel
144  UInt_t numberOfBlocks = nOpt.size();
145  TString aerogelUnity = Form("( ");
146  std::vector<TGeoBBox*> lRichAerogel(numberOfBlocks);
147  std::vector<TGeoTranslation*> trans(numberOfBlocks);
148  std::vector<TGeoCompositeShape*> richAerogelCS(numberOfBlocks);
149  std::vector<TGeoVolume*> richAerogel(numberOfBlocks);
150  Double_t za = aerogelOffset.Z()-alBoxSize.Z()/2;
151  for(UInt_t ia=0; ia<numberOfBlocks; ia++) {
152  Double_t aerogelThickness = aerogelSize.Z()*aerogelLayers[ia];
153  za += aerogelThickness/2;
154 
155  TString richAerogelName = Form("richAerogel%d",ia);
156  TString transName = Form("trans%d",ia);
157  TString richAerogelMedia = Form("RichAerogel%d",ia);
158  TString richAerogelCSName = Form("RichAerogelCS%d",ia);
159  TString richAerogelSensorName = Form("RichAerogelSensor%d",ia);
160 
161  if (useBeamPipeHole)
162  aerogelUnity = "( " + richAerogelName + ":" + transName + " ) - ( richBeamPipeHole ) ";
163  else
164  aerogelUnity = "( " + richAerogelName + ":" + transName + " ) ";
165  std::cout << aerogelUnity << " " << richAerogelMedia << " " <<
166  gGeoManager->GetMedium(richAerogelMedia) << " " <<
167  gGeoManager->GetMedium("FusedSil") << std::endl;
168 
169  lRichAerogel.at(ia) = new TGeoBBox(richAerogelName,
170  aerogelSize.X()/2,
171  aerogelSize.Y()/2,
172  aerogelThickness/2 );
173  trans.at(ia) = new TGeoTranslation(transName,
174  aerogelOffset.X(),
175  aerogelOffset.Y(),
176  za);
177  trans.at(ia)->RegisterYourself();
178  richAerogelCS.at(ia) = new TGeoCompositeShape(richAerogelCSName,aerogelUnity);
179  richAerogel.at(ia) = new TGeoVolume(richAerogelSensorName,
180  richAerogelCS.at(ia),
181  gGeoManager->GetMedium(richAerogelMedia));
182  richAerogel.at(ia)->SetLineColor(kCyan);
183  richAerogel.at(ia)->SetTransparency(40);
184  alRichBoxAir->AddNode(richAerogel.at(ia), 0, new TGeoCombiTrans( 0, 0, 0, new TGeoRotation(0) ) );
185 
186  za += aerogelThickness/2;
187  }
188 
189  // Mirror
190  Double_t za = richOffset.Z() /*+ alBoxWallThickness*/ + aerogelOffset.Z();
191  Double_t ya = aerogelSize.Y()/2;
192  Double_t wa = aerogelSize.Z();
193  Double_t yp1 = ya + wa;
194  Double_t zp1 = wa;
195  alpha = alpha < 45 - beta ? alpha : 45 -beta;
196  alpha *= pi/180;
197  beta *= pi/180;
198  Double_t thetaCh = acos(1/nOpt[0]);
199  Double_t theta = atan(ya/za);
200  Double_t alpha1 = 2*(alpha+beta) - ka1*thetaCh;
201  Double_t alpha2 = 2*(alpha-beta) + ka2*thetaCh + theta;
202  Double_t alpham = (alpha1+alpha2)/2;
203  Double_t zm1 = zp1 + yp1/tan(alpha1);
204  Double_t ym1 = 0;
205  Double_t zm2 = (zm1+ya*tan(alpha))/(1-tan(theta+ka2*thetaCh)*tan(alpha));
206  Double_t ym2 = (zm2-zm1)/tan(alpha);
207  Double_t zp2 = ((ym2-yp1+zm2*tan(alpha2))*tan(alpham)+zp1)/(1+tan(alpha2)*tan(alpham));
208  Double_t yp2 = yp1 + (zp2-zp1)/tan(alpham);
209  if (yp2<ym2) {
210  yp2 = ym2;
211  zp2 = zm2;
212  alpham = atan((zp2-zp1)/(yp2-yp1));
213  }
214  Double_t phDetWidth = sqrt((zp1-zp2)*(zp1-zp2)+(yp1-yp2)*(yp1-yp2));
215  Double_t zmc = (zm1+zm2)/2;
216  Double_t ymc = (ym1+ym2)/2;
217  Double_t wm = sqrt((zm1-zm2)*(zm1-zm2)+(ym1-ym2)*(ym1-ym2));
218  Double_t rm = wm/2/sin(beta);
219  Double_t hm = rm*cos(beta);
220 // Double_t zm0 = zmc-hm*cos(alpha)-(alBoxSize.Z()/2-alBoxWallThickness-aerogelOffset.Z())*2;
221  Double_t zm0 = zmc-hm*cos(alpha)-alBoxSize.Z()/2+aerogelOffset.Z();
222  Double_t ym0 = ymc+hm*sin(alpha);
223  Double_t theta1 = 360-(alpha+beta)*180/pi;
224  Double_t theta2 = 360-(alpha-beta)*180/pi;
225  Double_t theta3 = 360-theta2;
226 
227  if (verm==0) {
228  TGeoPcon* lRichMirrorUpper = new TGeoPcon("richMirrorUpper", theta1, theta2-theta1, 2);
229  lRichMirrorUpper->DefineSection(0, -mirrorLength/2, rm, rm + mirrorThickness );
230  lRichMirrorUpper->DefineSection(1, +mirrorLength/2, rm, rm + mirrorThickness );
231  TGeoTranslation trans1(0,ym0,zm0);
232  TGeoRotation mrot1;
233  mrot1.SetAngles(90,270,270);
234  TGeoCombiTrans *combi1 = new TGeoCombiTrans("combi1",0,ym0,zm0,&mrot1);
235  combi1->RegisterYourself();
236  TGeoPcon* lRichMirrorLower = new TGeoPcon("richMirrorLower", theta3, theta2-theta1, 2);
237  lRichMirrorLower->DefineSection(0, -mirrorLength/2, rm, rm + mirrorThickness );
238  lRichMirrorLower->DefineSection(1, +mirrorLength/2, rm, rm + mirrorThickness );
239  TGeoTranslation trans2(0,-ym0,zm0);
240  TGeoRotation mrot2;
241  mrot2.SetAngles(90,270,270);
242  TGeoCombiTrans *combi2 = new TGeoCombiTrans("combi2",0,-ym0,zm0,&mrot2);
243  combi2->RegisterYourself();
244  if (useBeamPipeHole)
245  TGeoCompositeShape* richMirrorCS = new TGeoCompositeShape("RichMirrorCS",
246  "( richMirrorUpper:combi1 + richMirrorLower:combi2 ) - ( richBeamPipeHole ) ");
247  else
248  TGeoCompositeShape* richMirrorCS = new TGeoCompositeShape("RichMirrorCS",
249  "( richMirrorUpper:combi1 + richMirrorLower:combi2 ) ");
250  TGeoVolume* richMirror = new TGeoVolume("RichMirror",richMirrorCS,
251  gGeoManager->GetMedium("Mirror"));
252  richMirror->SetLineColor(kBlue);
253  richMirror->SetTransparency(40);
254  alRichBoxAir->AddNode(richMirror, 0, new TGeoCombiTrans(0., 0., 0., new TGeoRotation (0)));
255  }
256  if (verm==1) {
257  TVector3 mirrorAxis = fGeo->mirrorAxis();
258  Double_t mirrorRadius = fGeo->mirrorRadius();
259  Double_t mirrorThetaMin = fGeo->mirrorThetaMin()*180/pi;
260  Double_t mirrorThetaMax = fGeo->mirrorThetaMax()*180/pi;
261 
262  TGeoPcon* lRichMirrorUpper = new TGeoPcon("richMirrorUpper", mirrorThetaMin, mirrorThetaMax-mirrorThetaMin, 2);
263  lRichMirrorUpper->DefineSection(0, -mirrorLength/2, mirrorRadius, mirrorRadius + mirrorThickness );
264  lRichMirrorUpper->DefineSection(1, +mirrorLength/2, mirrorRadius, mirrorRadius + mirrorThickness );
265  Double_t zShift = - alBoxSize.Z()/2 + aerogelOffset.Z();
266  std::cout << " " << mirrorAxis.Z() << " " << zShift << std::endl;
267  TGeoTranslation trans1(0,mirrorAxis.Y(),mirrorAxis.Z()+zShift);
268  TGeoRotation mrot1;
269  mrot1.SetAngles(90,270,270);
270  TGeoCombiTrans *combi1 = new TGeoCombiTrans("combi1",0,mirrorAxis.Y(),mirrorAxis.Z()+zShift,&mrot1);
271  combi1->RegisterYourself();
272  TGeoPcon* lRichMirrorLower = new TGeoPcon("richMirrorLower", -mirrorThetaMax, mirrorThetaMax-mirrorThetaMin, 2);
273  lRichMirrorLower->DefineSection(0, -mirrorLength/2, mirrorRadius, mirrorRadius + mirrorThickness );
274  lRichMirrorLower->DefineSection(1, +mirrorLength/2, mirrorRadius, mirrorRadius + mirrorThickness );
275  TGeoTranslation trans2(0,-mirrorAxis.Y(),mirrorAxis.Z()+zShift);
276  TGeoRotation mrot2;
277  mrot2.SetAngles(90,270,270);
278  TGeoCombiTrans *combi2 = new TGeoCombiTrans("combi2",0,-mirrorAxis.Y(),mirrorAxis.Z()+zShift,&mrot2);
279  combi2->RegisterYourself();
280  if (useBeamPipeHole)
281  TGeoCompositeShape* richMirrorCS = new TGeoCompositeShape("RichMirrorCS",
282  "( richMirrorUpper:combi1 + richMirrorLower:combi2 ) - ( richBeamPipeHole ) ");
283  else
284  TGeoCompositeShape* richMirrorCS = new TGeoCompositeShape("RichMirrorCS",
285  "( richMirrorUpper:combi1 + richMirrorLower:combi2 ) ");
286  TGeoVolume* richMirror = new TGeoVolume("RichMirror",richMirrorCS,
287  gGeoManager->GetMedium("Mirror"));
288  richMirror->SetLineColor(kBlue);
289  richMirror->SetTransparency(40);
290  alRichBoxAir->AddNode(richMirror, 0, new TGeoCombiTrans(0., 0., 0., new TGeoRotation (0)));
291 
292  // PhotoDet pars
293  yp1 = phDetY[0];
294  yp2 = phDetY[1];
295  zp1 = phDetZ[0];
296  zp2 = phDetZ[1];
297  alpham = atan((zp2-zp1)/(yp2-yp1));
298  phDetWidth = sqrt((zp1-zp2)*(zp1-zp2)+(yp1-yp2)*(yp1-yp2));
299 
300  }
301  // flat mirror
302  if (((verm>=11)&&(verm<=19))||((verm>=21)&&(verm<=29))) {
303  UInt_t numberOfSegments = flatMirrorY.size()-1;
304  TString richMirrorCSUnity = Form("( ");
305  Double_t sag = 0.0;
306  // upper side of the mirror
307  std::vector<TGeoPcon*> lRichFlatMirrorSag(2*numberOfSegments);
308  std::vector<TGeoBBox*> lRichFlatMirror(2*numberOfSegments);
309  std::vector<TGeoCombiTrans*> combi(2*numberOfSegments);
310  std::vector<TGeoRotation> mrot(2*numberOfSegments);
311  for(UInt_t is=0; is<numberOfSegments; is++) {
312 
313  TString richFlatMirrorName = Form("richFlatMirror%du",is);
314  TString combiName = Form("combi%du",is);
315 
316  richMirrorCSUnity += richFlatMirrorName + ":" + combiName;
317  if (is<numberOfSegments)
318  richMirrorCSUnity += " + ";
319 
320  Double_t y1 = flatMirrorY[is];
321  Double_t y2 = flatMirrorY[is+1];
322  Double_t z1 = flatMirrorZ[is];
323  Double_t z2 = flatMirrorZ[is+1];
324  Double_t alpha = std::atan((z2-z1)/(y2-y1));
325  Double_t mirrorWidth = std::sqrt((y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));
326  if ( sag == 0 ) {
327  Double_t yc = (y1+y2)/2 - mirrorThickness/2*sin(alpha);
328  Double_t zc = (z1+z2)/2 - alBoxSize.Z()/2 + aerogelOffset.Z() + mirrorThickness/2*cos(alpha);
329 
330  lRichFlatMirror.at(is) = new TGeoBBox(richFlatMirrorName,
331  mirrorLength/2,
332  mirrorThickness/2,
333  mirrorWidth/2 );
334  mrot.at(is).SetAngles(0,-90+alpha*180/pi,0);
335  combi.at(is) = new TGeoCombiTrans(combiName,0,yc,zc,&mrot.at(is));
336  combi.at(is)->RegisterYourself();
337  }
338  else {
339  Double_t rm = ( 4*sag*sag + 1 )*mirrorWidth/8/sag;
340  Double_t ym = (y1+y2)/2 + (z2-z1)*(rm/mirrorWidth-sag);
341  Double_t zm = (z1+z2)/2 + (y1-y2)*(rm/mirrorWidth-sag);
342  Double_t theta1 = std::atan2(y1-ym,z1-zm)*180/pi;
343  Double_t theta2 = std::atan2(y2-ym,z2-zm)*180/pi;
344  zm += -alBoxSize.Z()/2 + aerogelOffset.Z();
345 
346  lRichFlatMirrorSag.at(is) = new TGeoPcon(richFlatMirrorName, theta1, theta2-theta1, 2);
347  lRichFlatMirrorSag.at(is)->DefineSection(0, -mirrorLength/2, rm, rm + mirrorThickness );
348  lRichFlatMirrorSag.at(is)->DefineSection(1, +mirrorLength/2, rm, rm + mirrorThickness );
349 
350  mrot.at(is).SetAngles(90,270,270);
351  combi.at(is) = new TGeoCombiTrans(combiName,0,ym,zm,&mrot.at(is));
352  combi.at(is)->RegisterYourself();
353  }
354  }
355  // lower side of the mirror
356  for(UInt_t is=0; is<numberOfSegments; is++) {
357 
358  TString richFlatMirrorName = Form("richFlatMirror%dd",is);
359  TString combiName = Form("combi%dd",is);
360 
361  richMirrorCSUnity += richFlatMirrorName + ":" + combiName;
362  if (is<flatMirrorY.size()-2)
363  richMirrorCSUnity += " + ";
364 
365  UInt_t iss = is + numberOfSegments;
366 
367  Double_t y1 = -flatMirrorY[is];
368  Double_t y2 = -flatMirrorY[is+1];
369  Double_t z1 = flatMirrorZ[is];
370  Double_t z2 = flatMirrorZ[is+1];
371  Double_t alpha = std::atan((z2-z1)/(y2-y1));
372  Double_t mirrorWidth = std::sqrt((y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));
373  if ( sag == 0 ) {
374  Double_t yc = (y1+y2)/2 - mirrorThickness/2*sin(alpha);
375  Double_t zc = (z1+z2)/2 - alBoxSize.Z()/2 + aerogelOffset.Z() + mirrorThickness/2*cos(alpha);
376 
377  lRichFlatMirror.at(iss) = new TGeoBBox(richFlatMirrorName,
378  mirrorLength/2,
379  mirrorThickness/2,
380  mirrorWidth/2 );
381  mrot.at(iss).SetAngles(0,-90+alpha*180/pi,0);
382  combi.at(iss) = new TGeoCombiTrans(combiName,0,yc,zc,&mrot.at(iss));
383  combi.at(iss)->RegisterYourself();
384  }
385  else {
386  Double_t rm = ( 4*sag*sag + 1 )*mirrorWidth/8/sag;
387  Double_t ym = (y1+y2)/2 + (z1-z2)*(rm/mirrorWidth-sag);
388  Double_t zm = (z1+z2)/2 + (y2-y1)*(rm/mirrorWidth-sag);
389  Double_t theta1 = std::atan2(y2-ym,z2-zm)*180/pi;
390  Double_t theta2 = std::atan2(y1-ym,z1-zm)*180/pi;
391  zm += -alBoxSize.Z()/2 + aerogelOffset.Z();
392 
393  lRichFlatMirrorSag.at(iss) = new TGeoPcon(richFlatMirrorName, theta1, theta2-theta1, 2);
394  lRichFlatMirrorSag.at(iss)->DefineSection(0, -mirrorLength/2, rm, rm + mirrorThickness );
395  lRichFlatMirrorSag.at(iss)->DefineSection(1, +mirrorLength/2, rm, rm + mirrorThickness );
396 
397  mrot.at(iss).SetAngles(90,270,270);
398  combi.at(iss) = new TGeoCombiTrans(combiName,0,ym,zm,&mrot.at(iss));
399  combi.at(iss)->RegisterYourself();
400  }
401  }
402  if (useBeamPipeHole)
403  richMirrorCSUnity += " ) - ( richBeamPipeHole ) ";
404  else
405  richMirrorCSUnity += " ) ";
406  std::cout << richMirrorCSUnity << std::endl;
407  TGeoCompositeShape* richMirrorCS = new TGeoCompositeShape("RichMirrorCS",richMirrorCSUnity);
408  TGeoVolume* richMirror = new TGeoVolume("RichMirror",richMirrorCS,
409  gGeoManager->GetMedium("Mirror"));
410  richMirror->SetLineColor(kBlue);
411  richMirror->SetTransparency(40);
412  alRichBoxAir->AddNode(richMirror, 0, new TGeoCombiTrans(0., 0., 0., new TGeoRotation (0)));
413 
414  // PhotoDet pars
415  yp1 = phDetY[0];
416  yp2 = phDetY[1];
417  zp1 = phDetZ[0];
418  zp2 = phDetZ[1];
419  for(UInt_t is=0; is<numberOfSegments; is++)
420  zp2 = zp2>flatMirrorZ[is] ? zp2 : flatMirrorZ[is];
421  alpham = atan((zp2-zp1)/(yp2-yp1));
422  phDetWidth = sqrt((zp1-zp2)*(zp1-zp2)+(yp1-yp2)*(yp1-yp2));
423 
424  // Side parts of mirror
425  if ((verm>=21)&&(verm<=29)) {
426  // left
427  Double_t x_min = mirrorLength/2;
428  Double_t x_max = x_min + mirrorThickness;
429  Double_t y_min = -yp2;
430  Double_t y_max = yp2;
431  Double_t z_min = zp1;
432  Double_t z_max = zp2;
433  Double_t x_size = x_max - x_min;
434  Double_t y_size = y_max - y_min;
435  Double_t z_size = z_max - z_min;
436  Double_t x_mid = (x_max + x_min)/2;
437  Double_t y_mid = (y_max + y_min)/2;
438  Double_t z_mid = (z_max + z_min)/2 - alBoxSize.Z()/2 + aerogelOffset.Z();
439  TGeoBBox* lRichMirrorLeft = new TGeoBBox("richMirrorLeft",
440  x_size/2,
441  y_size/2,
442  z_size/2 );
443  TGeoVolume *richMirrorLeft = new TGeoVolume("RichMirrorLeft",
444  lRichMirrorLeft,
445  gGeoManager->GetMedium("Mirror"));
446  richMirrorLeft->SetLineColor(kBlue);
447  richMirrorLeft->SetTransparency(40);
448  alRichBoxAir->AddNode(richMirrorLeft, 0, new TGeoCombiTrans(x_mid, y_mid, z_mid, new TGeoRotation (0)));
449 
450  // right
451  x_max = -mirrorLength/2;
452  x_min = x_max - mirrorThickness;
453  x_mid = (x_max + x_min)/2;
454  TGeoBBox* lRichMirrorRight = new TGeoBBox("richMirrorRight",
455  x_size/2,
456  y_size/2,
457  z_size/2 );
458  TGeoVolume *richMirrorRight = new TGeoVolume("RichMirrorRight",
459  lRichMirrorRight,
460  gGeoManager->GetMedium("Mirror"));
461  richMirrorRight->SetLineColor(kBlue);
462  richMirrorRight->SetTransparency(40);
463  alRichBoxAir->AddNode(richMirrorRight, 0, new TGeoCombiTrans(x_mid, y_mid, z_mid, new TGeoRotation (0)));
464  }
465 
466  }
467 
468  // Photodetertors
469  Double_t windowThickness = 0.02;
470  Double_t siThickness = 0.025;
471  Double_t stefThickness = 0.1;
472  Double_t gapThickness = 0.5;
473  Double_t stef2Thickness = 0.3;
474  // Upper
475  TGeoBBox* lRichPhDetUpper = new TGeoBBox("richPhDetUpper",
476  phDetLength/2,
477  phDetThickness/2,
478  phDetWidth/2 );
479  TGeoVolume *richPhDetUpper = new TGeoVolume("RichPhDetUpper",
480  lRichPhDetUpper,
481  gGeoManager->GetMedium("RichAir"));
482  richPhDetUpper->SetLineColor(19);
483  richPhDetUpper->SetTransparency(40);
484  TGeoRotation prot1;
485  prot1.SetAngles(0,-90+alpham*180/pi,0);
486  Double_t ypc = (yp1+yp2)/2+phDetThickness/2*sin(alpham);
487  Double_t zpc = (zp1+zp2)/2 - alBoxSize.Z()/2 + aerogelOffset.Z() -phDetThickness/2*cos(alpham);
488  alRichBoxAir->AddNode(richPhDetUpper, 0,
489  new TGeoCombiTrans( 0,
490  ypc,
491  zpc,
492  new TGeoRotation(prot1) ) );
493  // Inner layers
494  Double_t dir = 1;
495  Double_t y_shift = -dir*phDetThickness/2;
496  Double_t thickness = 0;
497  // Window
498  y_shift += dir*thickness/2;
499  thickness = windowThickness;
500  y_shift += dir*thickness/2;
501  TGeoBBox* lRichPhDetWindowUpper = new TGeoBBox("richPhDetWindowUpper",
502  phDetLength/2,
503  thickness/2,
504  phDetWidth/2 );
505  TGeoVolume *richPhDetWindowUpper = new TGeoVolume("RichPhDetWindowUpper",lRichPhDetWindowUpper, gGeoManager->GetMedium("RichPDWindow"));
506  richPhDetWindowUpper->SetLineColor(kGreen);
507  richPhDetWindowUpper->SetTransparency(40);
508  richPhDetUpper->AddNode(richPhDetWindowUpper, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
509  // Si
510  y_shift += dir*thickness/2;
511  thickness = siThickness;
512  y_shift += dir*thickness/2;
513  TGeoBBox* lRichPhDetSiUpper = new TGeoBBox("richPhDetSiUpper",
514  phDetLength/2,
515  thickness/2,
516  phDetWidth/2 );
517  TGeoVolume *richPhDetSiUpper = new TGeoVolume("RichPhDetSiUpperSensor",lRichPhDetSiUpper, gGeoManager->GetMedium("silicon"));
518  richPhDetSiUpper->SetLineColor(kRed);
519  richPhDetSiUpper->SetTransparency(40);
520  richPhDetUpper->AddNode(richPhDetSiUpper, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
521  // STEF
522  y_shift += dir*thickness/2;
523  thickness = stefThickness;
524  y_shift += dir*thickness/2;
525  TGeoBBox* lRichPhDetSTEFUpper = new TGeoBBox("richPhDetSTEFUpper",
526  phDetLength/2,
527  thickness/2,
528  phDetWidth/2 );
529  TGeoVolume *richPhDetSTEFUpper = new TGeoVolume("RichPhDetSTEFUpper",lRichPhDetSTEFUpper, gGeoManager->GetMedium("pcbmvd"));
530  richPhDetSTEFUpper->SetLineColor(kYellow);
531  richPhDetSTEFUpper->SetTransparency(40);
532  richPhDetUpper->AddNode(richPhDetSTEFUpper, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
533  // electronics STEF
534  y_shift += dir*(thickness/2+gapThickness);
535  thickness = stef2Thickness;
536  y_shift += dir*thickness/2;
537  TGeoBBox* lRichPhDetSTEF2Upper = new TGeoBBox("richPhDetSTEF2Upper",
538  phDetLength/2,
539  thickness/2,
540  phDetWidth/2 );
541  TGeoVolume *richPhDetSTEF2Upper = new TGeoVolume("RichPhDetSTEF2Upper",lRichPhDetSTEF2Upper, gGeoManager->GetMedium("pcbmvd"));
542  richPhDetSTEF2Upper->SetLineColor(kYellow);
543  richPhDetSTEF2Upper->SetTransparency(40);
544  richPhDetUpper->AddNode(richPhDetSTEF2Upper, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
545 
546  // Lower
547  TGeoBBox* lRichPhDetLower = new TGeoBBox("richPhDetLower",
548  phDetLength/2,
549  phDetThickness/2,
550  phDetWidth/2 );
551  TGeoVolume *richPhDetLower = new TGeoVolume("RichPhDetLower",
552  lRichPhDetLower,
553  gGeoManager->GetMedium("RichAir"));
554  richPhDetLower->SetLineColor(19);
555  richPhDetLower->SetTransparency(40);
556  TGeoRotation prot2;
557  prot2.SetAngles(0,+90-alpham*180/pi,0);
558  alRichBoxAir->AddNode(richPhDetLower, 0,
559  new TGeoCombiTrans( 0,
560  -ypc,
561  zpc,
562  new TGeoRotation(prot2) ) );
563  // Inner layers
564  dir = -1;
565  y_shift = -dir*phDetThickness/2;
566  thickness = 0;
567  // Window
568  y_shift += dir*thickness/2;
569  thickness = windowThickness;
570  y_shift += dir*thickness/2;
571  TGeoBBox* lRichPhDetWindowLower = new TGeoBBox("richPhDetWindowLower",
572  phDetLength/2,
573  thickness/2,
574  phDetWidth/2 );
575  TGeoVolume *richPhDetWindowLower = new TGeoVolume("RichPhDetWindowLower",lRichPhDetWindowLower, gGeoManager->GetMedium("RichPDWindow"));
576  richPhDetWindowLower->SetLineColor(kGreen);
577  richPhDetWindowLower->SetTransparency(40);
578  richPhDetLower->AddNode(richPhDetWindowLower, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
579  // Si
580  y_shift += dir*thickness/2;
581  thickness = siThickness;
582  y_shift += dir*thickness/2;
583  TGeoBBox* lRichPhDetSiLower = new TGeoBBox("richPhDetSiLower",
584  phDetLength/2,
585  thickness/2,
586  phDetWidth/2 );
587  TGeoVolume *richPhDetSiLower = new TGeoVolume("RichPhDetSiLowerSensor",lRichPhDetSiLower, gGeoManager->GetMedium("silicon"));
588  richPhDetSiLower->SetLineColor(kRed);
589  richPhDetSiLower->SetTransparency(40);
590  richPhDetLower->AddNode(richPhDetSiLower, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
591  // STEF
592  y_shift += dir*thickness/2;
593  thickness = stefThickness;
594  y_shift += dir*thickness/2;
595  TGeoBBox* lRichPhDetSTEFLower = new TGeoBBox("richPhDetSTEFLower",
596  phDetLength/2,
597  thickness/2,
598  phDetWidth/2 );
599  TGeoVolume *richPhDetSTEFLower = new TGeoVolume("RichPhDetSTEFLower",lRichPhDetSTEFLower, gGeoManager->GetMedium("pcbmvd"));
600  richPhDetSTEFLower->SetLineColor(kYellow);
601  richPhDetSTEFLower->SetTransparency(40);
602  richPhDetLower->AddNode(richPhDetSTEFLower, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
603  // electronics STEF
604  y_shift += dir*(thickness/2+gapThickness);
605  thickness = stef2Thickness;
606  y_shift += dir*thickness/2;
607  TGeoBBox* lRichPhDetSTEF2Lower = new TGeoBBox("richPhDetSTEF2Lower",
608  phDetLength/2,
609  thickness/2,
610  phDetWidth/2 );
611  TGeoVolume *richPhDetSTEF2Lower = new TGeoVolume("RichPhDetSTEF2Lower",lRichPhDetSTEF2Lower, gGeoManager->GetMedium("pcbmvd"));
612  richPhDetSTEF2Lower->SetLineColor(kYellow);
613  richPhDetSTEF2Lower->SetTransparency(40);
614  richPhDetLower->AddNode(richPhDetSTEF2Lower, 0, new TGeoCombiTrans( 0, y_shift, 0, new TGeoRotation(0) ) );
615 
616  //---------------------------------------------------------------------------------------------
617 
618 
619  // create top volume:
620  TGeoManager* gGeoMan = (TGeoManager*)gROOT->FindObject("FAIRGeom");
621 
622  TGeoBBox* lTop = new TGeoBBox(500,500,richOffset.Z() + alBoxSize.Z());
623  TGeoVolume* top = new TGeoVolume("RICH", lTop, gGeoManager->GetMedium("RichAir"));
624  gGeoManager->SetTopVolume(top);
625 
626  top->AddNode(alRichBox, 0,
627  new TGeoCombiTrans( richOffset.X(),
628  richOffset.Y(),
629  richOffset.Z() + alBoxSize.Z()/2,
630  new TGeoRotation(0) ) );
631 
632  gGeoManager->CloseGeometry();
633 
634  top->CheckOverlaps(0.0001, "");
635  gGeoManager->CheckOverlaps(0.00001,""); // [cm]
636  gGeoManager->SetVisLevel(4);
637  //gGeoManager->CheckGeometryFull();
638 
639  top->Write();
640  fi->Close();
641  top->Draw("ogl");
642  //pdbase->Draw("ogl");
643 
644  TObjArray *listOfOverlaps = gGeoManager->GetListOfOverlaps();
645  cout<<listOfOverlaps->GetEntries()<<endl;
646  listOfOverlaps->Print();
647 
648 
649 }
PndRichGeo::mirrorCurvature
Double_t mirrorCurvature()
Definition: PndRichGeo.h:144
PndRichGeo::mirrorAxis
TVector3 mirrorAxis()
Definition: PndRichGeo.h:100
acos
friend F32vec4 acos(const F32vec4 &a)
Definition: P4_F32vec4.h:113
theta
double theta
Definition: macro/detectors/emc/dedicated/reco_analys.C:24
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
PndRichGeo::mirrorThetaMin
Double_t mirrorThetaMin()
Definition: PndRichGeo.h:97
PndRichGeo::aerogelOffset
TVector3 aerogelOffset()
Definition: PndRichGeo.h:129
geoLoad
FairGeoLoader * geoLoad
Definition: createRootGeoFile.C:16
i
Int_t i
Definition: run_full.C:25
Media
FairGeoMedia * Media
Definition: createRootFscGeometryFile.C:68
gGeoMan
TGeoManager * gGeoMan
Definition: createRootFscGeometryFile.C:85
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
PndRichGeo::phDetZ
std::vector< Double_t > phDetZ()
Definition: PndRichGeo.h:183
PndRichGeo::aerogelSize
TVector3 aerogelSize()
Definition: PndRichGeo.h:126
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
PndRichGeo::angleOfMirrorPosition
Double_t angleOfMirrorPosition()
Definition: PndRichGeo.h:147
thickness
Double_t thickness
Definition: createRootFscGeometryFile.C:37
gGeoManager
TGeoManager * gGeoManager
Definition: createRootGeoFile.C:97
PndRichGeo::phDetY
std::vector< Double_t > phDetY()
Definition: PndRichGeo.h:180
PndRichGeo::alBoxWallThickness
Double_t alBoxWallThickness()
Definition: PndRichGeo.h:123
top
TGeoVolume * top
Definition: createRootFscGeometryFile.C:89
PndRichGeo::mirrorThickness
Double_t mirrorThickness()
Definition: PndRichGeo.h:150
PndRichGeo::mirrorRadius
Double_t mirrorRadius()
Definition: PndRichGeo.h:99
trans
TGeoTranslation * trans
Definition: createROOTEnDrcGeo.C:65
PndRichGeo::aerogelLayers
std::vector< Double_t > aerogelLayers()
Definition: PndRichGeo.h:135
geobuild
FairGeoBuilder * geobuild
Definition: createRootFscGeometryFile.C:69
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndRichGeo::init
void init(size_t ver=0)
Definition: PndRichGeo.cxx:82
PndRichGeo::angleExtansionOuter
Double_t angleExtansionOuter()
Definition: PndRichGeo.h:141
combi
TGeoCombiTrans * combi
Definition: createROOTEnDrcGeo.C:66
is
static int is
Definition: ranlxd.cxx:374
PndRichGeo::beamPipeHoleY
Double_t beamPipeHoleY()
Definition: PndRichGeo.h:165
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndRichGeo::angleExtansionInner
Double_t angleExtansionInner()
Definition: PndRichGeo.h:138
PndRichGeo::phDetThickness
Double_t phDetThickness()
Definition: PndRichGeo.h:159
PndRichGeo::mirrorLength
Double_t mirrorLength()
Definition: PndRichGeo.h:153
PndRichGeo::richOffset
TVector3 richOffset()
Definition: PndRichGeo.h:117
PndRichGeo::phDetLength
Double_t phDetLength()
Definition: PndRichGeo.h:156
PndRichGeo::flatMirrorY
std::vector< Double_t > flatMirrorY()
Definition: PndRichGeo.h:168
geoFace
FairGeoInterface * geoFace
Definition: createRootGeoFile.C:17
alpha
double alpha
Definition: f_Init.h:9
PndRichGeo::beamPipeHoleX
Double_t beamPipeHoleX()
Definition: PndRichGeo.h:162
pi
const Double_t pi
Definition: createRootGeometry_RICH.C:12
fGeoFile
TString fGeoFile
Definition: createRootGeoFile.C:26
PndRichGeo::nOpt
std::vector< Double_t > nOpt()
Definition: PndRichGeo.h:132
PndRichGeo::mirrorThetaMax
Double_t mirrorThetaMax()
Definition: PndRichGeo.h:98
PndRichGeo::alBoxSize
TVector3 alBoxSize()
Definition: PndRichGeo.h:120
PndRichGeo::flatMirrorZ
std::vector< Double_t > flatMirrorZ()
Definition: PndRichGeo.h:171

Variable Documentation

const Double_t pi = 3.1415926535

Definition at line 12 of file createRootGeometry_RICH.C.

Referenced by createRootGeometry_RICH().

Generated on Sun Aug 18 2019 03:02:27 for FairRoot/PandaRoot by   doxygen 1.8.8