BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
BesEmcEndGeometry.cc
Go to the documentation of this file.
1#include "G4ThreeVector.hh"
2
3#include "EmcSim/BesEmcEndGeometry.hh"
4#include "EmcSim/BesEmcParameter.hh"
5#include "G4ios.hh"
6
7#include <assert.h>
8#include <fstream>
9#include <iomanip>
10#include <iostream>
11#include <sstream>
12
13#include "G4SystemOfUnits.hh"
14
15using namespace std;
16using namespace CLHEP;
17
18BesEmcEndGeometry::BesEmcEndGeometry() { ; }
19
20BesEmcEndGeometry::~BesEmcEndGeometry() { ; }
21
22void BesEmcEndGeometry::ReadParameters() {
23 BesEmcParameter& emcPara = BesEmcParameter::GetInstance();
24
25 WorldRmin1 = emcPara.GetWorldRmin1();
26 WorldRmax1 = emcPara.GetWorldRmax1();
27 WorldRmin2 = emcPara.GetWorldRmin2(); //+5.*mm; //add 5mm to avoid warning
28 WorldRmax2 = emcPara.GetWorldRmax2();
29 WorldDz = emcPara.GetWorldDz();
30 WorldZPosition = emcPara.GetWorldZPosition();
31 CrystalLength = emcPara.GetCrystalLength();
32
33 SectorRmin1 = 489.27 * mm;
34 SectorRmax1 = 880. * mm;
35 SectorRmin2 = 621.57 * mm;
36 SectorRmax2 = 1113.53 * mm;
37 SectorDz = WorldDz - 44. * mm;
38 SectorZPosition = -18. * mm;
39
40 for ( G4int i = 0; i < 6; i++ ) cryNumInOneLayer[i] = emcPara.GetCryInOneLayer( i );
41 for ( G4int i = 0; i < 5; i++ ) pentaInOneSector[i] = emcPara.GetPentaInOneSector( i );
42
43 fTyvekThickness = emcPara.GetTyvekThickness();
44 fAlThickness = emcPara.GetAlThickness();
45 fMylarThickness = emcPara.GetMylarThickness();
46 totalThickness = fTyvekThickness + fAlThickness + fMylarThickness;
47
48 G4String ParaPath = getenv( "EMCSIMROOT" );
49 if ( !ParaPath )
50 {
51 G4cout << "BOOST environment not set!" << G4endl;
52 exit( -1 );
53 }
54 ParaPath += "/dat/EmcEndGeometry.dat";
55
56 ifstream fin;
57 fin.open( ParaPath );
58 assert( fin );
59 for ( G4int i = 0; i < 30; i++ )
60 for ( G4int j = 0; j < 24; j++ ) fin >> param[i][j];
61 for ( G4int i = 0; i < 5; i++ )
62 for ( G4int j = 0; j < 6; j++ ) fin >> penta[i][j];
63 fin.close();
64}
65
66void BesEmcEndGeometry::ComputeParameters() {
67
68 ////////////////////////////////////////////////////////////////////////
69 // emc endcap crystal //
70 //////////////////////////////////////////////////////////////////////////
71 // 1 //
72 // 0 __ -- //
73 // -- \ //
74 // | \ \ //
75 // | \ __ - 2 //
76 // | \ -- | //
77 // | | 3 | //
78 // | | | //
79 // | | | //
80 // | | | //
81 // | | 5 | //
82 // 4 \ | | //
83 // \ | __ - 6 //
84 // \| -- //
85 // 7 //
86 /////////////////////////////////////////////////////////////////////////
87
88 ReadParameters();
89
90 G4int pentaNb = 0;
91 for ( G4int i = 0; i < 30; i++ )
92 {
93 for ( G4int j = 0; j < 8; j++ )
94 {
95 // use 24 parameters to construct 8 point of one crystal
96 G4ThreeVector* pPnt = new G4ThreeVector(
97 param[i][j], param[i][j + 8], param[i][j + 16] - WorldZPosition - SectorZPosition );
98 fPnt[i][j] = *pPnt;
99 }
100
101 if ( i == 5 || i == 6 || i == 14 || i == 15 || i == 16 )
102 // if(0) //no pentagonal crystal now
103 {
104 for ( G4int j = 0; j < 8; j++ ) fPnt[30 + pentaNb][j] = fPnt[i][j];
105
106 // compute the 5th point of the pentagonal crystal
107 G4double y0, y1, y4, y5;
108 G4ThreeVector v0, v1, v4, v5;
109 y0 = penta[pentaNb][0];
110 y1 = penta[pentaNb][1];
111 y4 = penta[pentaNb][2];
112 y5 = penta[pentaNb][3];
113 v0 = ( y0 - fPnt[i][3].getY() ) * ( fPnt[i][0] - fPnt[i][3] ) /
114 ( fPnt[i][0].getY() - fPnt[i][3].getY() ) +
115 fPnt[i][3];
116 v1 = ( y1 - fPnt[i][2].getY() ) * ( fPnt[i][1] - fPnt[i][2] ) /
117 ( fPnt[i][1].getY() - fPnt[i][2].getY() ) +
118 fPnt[i][2];
119 v4 = ( y4 - fPnt[i][7].getY() ) * ( fPnt[i][4] - fPnt[i][7] ) /
120 ( fPnt[i][4].getY() - fPnt[i][7].getY() ) +
121 fPnt[i][7];
122 v5 = ( y5 - fPnt[i][6].getY() ) * ( fPnt[i][5] - fPnt[i][6] ) /
123 ( fPnt[i][5].getY() - fPnt[i][6].getY() ) +
124 fPnt[i][6];
125
126 G4double x1, x5;
127 x1 = penta[pentaNb][4];
128 x5 = penta[pentaNb][5];
129 v1 = ( x1 - v0.getX() ) * ( v1 - v0 ) / ( v1.getX() - v0.getX() ) +
130 v0; // v1', the fifth point
131 v5 = ( x5 - v4.getX() ) * ( v5 - v4 ) / ( v5.getX() - v4.getX() ) + v4; // v5'
132
133 fPnt[i][0] = v0;
134 fPnt[i][1] = v1;
135 fPnt[i][4] = v4;
136 fPnt[i][5] = v5;
137
138 fPnt[30 + pentaNb][2] = v1;
139 fPnt[30 + pentaNb][3] = v0;
140 fPnt[30 + pentaNb][6] = v5;
141 fPnt[30 + pentaNb][7] = v4;
142
143 pentaNb++;
144 }
145 }
146
147 // reflect point in one sector according to new design
148 G4ThreeVector temp[35][8];
149 for ( G4int i = 0; i < 35; i++ )
150 {
151 for ( G4int j = 0; j < 8; j++ )
152 {
153 temp[i][j] = fPnt[i][j];
154 fPnt[i][j].rotateZ( 157.5 * deg );
155 fPnt[i][j].setX( -fPnt[i][j].getX() );
156 }
157
158 // point 0<-->3, 1<-->2, 4<-->7, 5<-->6
159 for ( G4int j = 0; j < 8; j++ )
160 {
161 if ( j < 2 )
162 {
163 G4ThreeVector v = fPnt[i][j];
164 fPnt[i][j] = fPnt[i][3 - j];
165 fPnt[i][3 - j] = v;
166 }
167 else if ( j >= 4 && j < 6 )
168 {
169 G4ThreeVector v = fPnt[i][j];
170 fPnt[i][j] = fPnt[i][11 - j];
171 fPnt[i][11 - j] = v;
172 }
173 }
174 }
175
176 // exchange sequence in the same layer
177 // Exchange(0,3); Exchange(1,2); Exchange(4,7); Exchange(5,6);
178 // Exchange(8,12); Exchange(9,11); Exchange(13,17); Exchange(14,16);
179 // Exchange(18,23); Exchange(19,22); Exchange(20,21); Exchange(24,29); Exchange(25,28);
180 // Exchange(26,27);
181
182 Exchange( 0, 3 );
183 Exchange( 1, 2 );
184 Exchange( 4, 7 );
185 Exchange( 5, 31 );
186 Exchange( 6, 30 );
187 Exchange( 8, 12 );
188 Exchange( 9, 11 );
189 Exchange( 13, 17 );
190 Exchange( 14, 34 );
191 Exchange( 15, 33 );
192 Exchange( 16, 32 );
193 Exchange( 18, 23 );
194 Exchange( 19, 22 );
195 Exchange( 20, 21 );
196 Exchange( 24, 29 );
197 Exchange( 25, 28 );
198 Exchange( 26, 27 );
199
200 /*for(G4int i=0;i<35;i++)
201 {
202 G4cout<<"crystal number: "<<i<<G4endl;
203 for(G4int j=0;j<8;j++)
204 G4cout<<fPnt[i][j]<<G4endl;
205 }*/
206
207 // compute the 6 crystal beside the 20mm gap
208 for ( G4int i = 0; i < 35; i++ )
209 {
210 for ( G4int j = 0; j < 8; j++ )
211 {
212 G4ThreeVector pPnt1 = temp[i][j];
213 fPnt1[i][j] = pPnt1.rotateZ( 67.5 * deg );
214 }
215 if ( ( i == 3 ) || ( i == 7 ) || ( i == 12 ) || ( i == 17 ) || ( i == 23 ) || ( i == 29 ) )
216 {
217 fPnt1[i][0].setX( 10 );
218 fPnt1[i][1].setX( 10 );
219 fPnt1[i][4].setX( 10 );
220 fPnt1[i][5].setX( 10 );
221
222 G4double y0 = fPnt1[i][0].getY() +
223 10 * ( fPnt1[i][3].getY() - fPnt1[i][0].getY() ) / fPnt1[i][3].getX();
224 G4double y1 = fPnt1[i][1].getY() +
225 10 * ( fPnt1[i][2].getY() - fPnt1[i][1].getY() ) / fPnt1[i][2].getX();
226 G4double y4 = fPnt1[i][4].getY() +
227 10 * ( fPnt1[i][7].getY() - fPnt1[i][4].getY() ) / fPnt1[i][7].getX();
228 G4double y5 = fPnt1[i][5].getY() +
229 10 * ( fPnt1[i][6].getY() - fPnt1[i][5].getY() ) / fPnt1[i][6].getX();
230
231 G4double z0 = fPnt1[i][0].getZ() +
232 10 * ( fPnt1[i][3].getZ() - fPnt1[i][0].getZ() ) / fPnt1[i][3].getX();
233 G4double z1 = fPnt1[i][1].getZ() +
234 10 * ( fPnt1[i][2].getZ() - fPnt1[i][1].getZ() ) / fPnt1[i][2].getX();
235 G4double z4 = fPnt1[i][4].getZ() +
236 10 * ( fPnt1[i][7].getZ() - fPnt1[i][4].getZ() ) / fPnt1[i][7].getX();
237 G4double z5 = fPnt1[i][5].getZ() +
238 10 * ( fPnt1[i][6].getZ() - fPnt1[i][5].getZ() ) / fPnt1[i][6].getX();
239
240 fPnt1[i][0].setY( y0 );
241 fPnt1[i][1].setY( y1 );
242 fPnt1[i][4].setY( y4 );
243 fPnt1[i][5].setY( y5 );
244
245 fPnt1[i][0].setZ( z0 );
246 fPnt1[i][1].setZ( z1 );
247 fPnt1[i][4].setZ( z4 );
248 fPnt1[i][5].setZ( z5 );
249 }
250 }
251}
252
253void BesEmcEndGeometry::Exchange( G4int cry1, G4int cry2 ) {
254 G4ThreeVector v;
255 for ( G4int i = 0; i < 8; i++ )
256 {
257 v = fPnt[cry1][i];
258 fPnt[cry1][i] = fPnt[cry2][i];
259 fPnt[cry2][i] = v;
260 }
261}
262
263void BesEmcEndGeometry::ExchangeSector7( G4int cry1, G4int cry2 ) {
264 G4ThreeVector v;
265 for ( G4int i = 0; i < 8; i++ )
266 {
267 v = fPnt1[cry1][i];
268 fPnt1[cry1][i] = fPnt1[cry2][i];
269 fPnt1[cry2][i] = v;
270 }
271}
272
273// reflect x axis to construct sectors on the left
274void BesEmcEndGeometry::ReflectX() {
275 for ( G4int i = 0; i < 35; i++ )
276 {
277 for ( G4int j = 0; j < 8; j++ ) { fPnt1[i][j].setX( -fPnt1[i][j].getX() ); }
278
279 // point 0<-->3, 1<-->2, 4<-->7, 5<-->6
280 for ( G4int j = 0; j < 8; j++ )
281 {
282 if ( j < 2 )
283 {
284 G4ThreeVector v = fPnt1[i][j];
285 fPnt1[i][j] = fPnt1[i][3 - j];
286 fPnt1[i][3 - j] = v;
287 }
288 else if ( j >= 4 && j < 6 )
289 {
290 G4ThreeVector v = fPnt1[i][j];
291 fPnt1[i][j] = fPnt1[i][11 - j];
292 fPnt1[i][11 - j] = v;
293 }
294 }
295
296 // change the sequence of eight points according to the requirment of IrregBox
297 // point 0<-->1, 2<-->3, 4<-->5, 6<-->7
298 /*for(G4int j=0;j<8;j++)
299 {
300 if((j%2)==0)
301 {
302 G4ThreeVector v2=fPnt1[i][j];
303 fPnt1[i][j]=fPnt1[i][j+1];
304 fPnt1[i][j+1]=v2;
305 }
306 }*/
307 }
308 ExchangeSector7( 0, 3 );
309 ExchangeSector7( 1, 2 );
310 ExchangeSector7( 4, 7 );
311 ExchangeSector7( 5, 31 );
312 ExchangeSector7( 6, 30 );
313 ExchangeSector7( 8, 12 );
314 ExchangeSector7( 9, 11 );
315 ExchangeSector7( 13, 17 );
316 ExchangeSector7( 14, 34 );
317 ExchangeSector7( 15, 33 );
318 ExchangeSector7( 16, 32 );
319 ExchangeSector7( 18, 23 );
320 ExchangeSector7( 19, 22 );
321 ExchangeSector7( 20, 21 );
322 ExchangeSector7( 24, 29 );
323 ExchangeSector7( 25, 28 );
324 ExchangeSector7( 26, 27 );
325}
326
327void BesEmcEndGeometry::Zoom( const G4ThreeVector pos[8], const G4double factor ) {
328 G4ThreeVector center1( 0, 0, 0 );
329 G4ThreeVector center2( 0, 0, 0 );
330 for ( G4int i = 0; i < 8; i++ ) zoomPoint[i] = G4ThreeVector( 0, 0, 0 );
331
332 for ( G4int i = 0; i < 8; i++ )
333 {
334 if ( i < 4 ) center1 += pos[i];
335 else center2 += pos[i];
336 }
337 center1 /= 4;
338 center2 /= 4;
339
340 for ( G4int i = 0; i < 8; i++ )
341 {
342 if ( i < 4 ) zoomPoint[i] = factor * pos[i] + ( 1 - factor ) * center1;
343 else zoomPoint[i] = factor * pos[i] + ( 1 - factor ) * center2;
344 }
345}
346
347// subtract the casing
348void BesEmcEndGeometry::ModifyForCasing( G4ThreeVector pos[8], G4int CryNb ) {
349 G4ThreeVector center1( 0, 0, 0 ); // the center of large surface
350 G4ThreeVector center2( 0, 0, 0 ); // the center of small surface
351
352 const G4double dt = 1e-5; // avoid overlap between crystal and casing
353
354 if ( CryNb == 5 || CryNb == 6 || CryNb == 14 || CryNb == 15 || CryNb == 16 )
355 {
356 center1 = ( pos[0] + pos[1] ) * ( 1 - dt ) / 2 + ( pos[2] + pos[3] ) * dt / 2;
357 center2 = ( pos[4] + pos[5] ) * ( 1 - dt ) / 2 + ( pos[6] + pos[7] ) * dt / 2;
358 }
359 else if ( CryNb >= 30 && CryNb < 35 )
360 {
361 center1 = ( pos[0] + pos[1] ) * dt / 2 + ( pos[2] + pos[3] ) * ( 1 - dt ) / 2;
362 center2 = ( pos[4] + pos[5] ) * dt / 2 + ( pos[6] + pos[7] ) * ( 1 - dt ) / 2;
363 }
364 else
365 {
366 center1 = ( pos[0] + pos[1] + pos[2] + pos[3] ) / 4;
367 center2 = ( pos[4] + pos[5] + pos[6] + pos[7] ) / 4;
368 }
369
370 G4double r1 = ( pos[1] - center1 ).r();
371 G4double r2 = ( pos[2] - center1 ).r();
372 G4double r12 = ( pos[1] - pos[2] ).r();
373 G4double theta = acos( ( r2 * r2 + r12 * r12 - r1 * r1 ) / ( 2 * r2 * r12 ) );
374 G4double h = r2 * sin( theta ); // distance from the center to the vertical side
375 G4double t1 = totalThickness / h;
376
377 r1 = ( pos[5] - center2 ).r();
378 r2 = ( pos[6] - center2 ).r();
379 r12 = ( pos[5] - pos[6] ).r();
380 theta = acos( ( r2 * r2 + r12 * r12 - r1 * r1 ) / ( 2 * r2 * r12 ) );
381 h = r2 * sin( theta );
382 G4double t2 = totalThickness / h;
383
384 for ( G4int i = 0; i < 8; i++ )
385 {
386 if ( i < 4 ) { cryPoint[i] = ( 1 - t1 ) * pos[i] + t1 * center1; }
387 else
388 {
389 G4ThreeVector temp = ( 1 - t2 ) * pos[i] + t2 * center2;
390 cryPoint[i] = ( 1 - totalThickness / CrystalLength ) * temp +
391 ( totalThickness / CrystalLength ) * pos[i - 4];
392 }
393 // G4cout<<"casing="<<pos[i]<<"\t"<<"crystal="<<cryPoint[i]<<G4endl;
394 }
395}
396
397G4ThreeVector BesEmcEndGeometry::ComputeDimAndPos( const G4int partId, const G4int numTheta,
398 const G4int numPhi ) {
399 // ComputeParameters();
400 G4int sector = -1, cryNb = -1;
401 G4int leftFlag = 0;
402 G4int downFlag = 0;
403 G4int pentaFlag = 0;
404 G4int flag = 0;
405 G4double A1 = 0, a1 = 0, B1 = 0, b1 = 0, C1 = 0, c1 = 0, D1 = 0, d1 = 0, E1 = 0,
406 e1 = 0; // dimension of pentagonal crystal
407 G4int m_numPhi = 0;
408 G4ThreeVector position( 0, 0, 0 );
409 G4int cryInOneSector =
410 cryNumInOneLayer[numTheta] / 16; // number of crystal in one layer in one sector
411 G4ThreeVector pos[8];
412
413 if ( partId == 2 ) // west end
414 {
415 if ( numPhi >= 0 && numPhi < 8 * cryInOneSector )
416 m_numPhi = 8 * cryInOneSector - 1 - numPhi;
417 else if ( numPhi >= 8 * cryInOneSector && numPhi < 16 * cryInOneSector )
418 m_numPhi = 16 * cryInOneSector - 1 - numPhi;
419 }
420 else // east end
421 m_numPhi = numPhi;
422
423 if ( numPhi >= 4 * cryInOneSector && numPhi < 5 * cryInOneSector ) // crystal in 4th sector
424 {
425 leftFlag = 1;
426 m_numPhi = 8 * cryInOneSector - 1 - numPhi;
427 }
428 else if ( numPhi >= 11 * cryInOneSector && numPhi < 12 * cryInOneSector ) // crystal in 11th
429 // sector
430 {
431 leftFlag = 1;
432 downFlag = 1;
433 m_numPhi = numPhi - 8 * cryInOneSector;
434 }
435 if ( numPhi >= 12 * cryInOneSector && numPhi < 13 * cryInOneSector ) // crystal in 12th
436 // sector
437 {
438 downFlag = 1;
439 m_numPhi = 16 * cryInOneSector - 1 - numPhi;
440 }
441
442 // translate numTheta and numPhi to sector and cryNb
443 G4int cryNbOffset = 0;
444 for ( G4int i = 0; i < numTheta; i++ ) cryNbOffset += cryNumInOneLayer[i] / 16;
445 if ( cryInOneSector ) sector = m_numPhi / cryInOneSector;
446 cryNb = m_numPhi - cryInOneSector * sector + cryNbOffset;
447 sector += 3;
448 if ( sector > 15 && sector <= 18 ) sector -= 16;
449
450 // sector beside the gap
451 if ( sector == 6 )
452 for ( G4int i = 0; i < 8; i++ ) pos[i] = fPnt1[cryNb][i];
453 else
454 for ( G4int i = 0; i < 8; i++ )
455 {
456 pos[i] = fPnt[cryNb][i];
457 pos[i].rotateZ( -67.5 * deg + sector * 22.5 * deg );
458 }
459
460 // crystal dimension
461 Zoom( pos, 0.999 );
462 ModifyForCasing( zoomPoint, cryNb );
463 G4double A = ( cryPoint[0] - cryPoint[3] ).r();
464 G4double a = ( cryPoint[4] - cryPoint[7] ).r();
465 G4double B = ( cryPoint[1] - cryPoint[2] ).r();
466 G4double b = ( cryPoint[5] - cryPoint[6] ).r();
467 G4double C = ( cryPoint[0] - cryPoint[1] ).r();
468 G4double c = ( cryPoint[4] - cryPoint[5] ).r();
469 G4double D = ( cryPoint[2] - cryPoint[3] ).r();
470 G4double d = ( cryPoint[6] - cryPoint[7] ).r();
471
472 // reflect the axis according to the flag
473 for ( G4int i = 0; i < 8; i++ )
474 {
475 pos[i].setZ( pos[i].getZ() + WorldZPosition + SectorZPosition ); // give the absolute z
476 // coordinate
477 if ( leftFlag == 1 ) pos[i].setX( -pos[i].getX() );
478 if ( downFlag == 1 ) pos[i].setY( -pos[i].getY() );
479 if ( partId == 2 )
480 {
481 pos[i].setX( -pos[i].getX() );
482 pos[i].setZ( -pos[i].getZ() );
483 }
484 }
485
486 // compute the position
487 for ( G4int j = 4; j < 8; j++ ) position += pos[j];
488 position /= 4;
489
490 // compute pentagonal crystal
491 for ( G4int i = 0; i < 5; i++ )
492 {
493 if ( cryNb == pentaInOneSector[i] )
494 {
495 pentaFlag = 1;
496 G4ThreeVector penta[8];
497
498 // sector beside the gap
499 if ( sector == 6 )
500 for ( G4int j = 0; j < 8; j++ ) penta[j] = fPnt1[30 + i][j];
501 else
502 for ( G4int j = 0; j < 8; j++ )
503 {
504 penta[j] = fPnt[30 + i][j];
505 penta[j].rotateZ( -67.5 * deg + sector * 22.5 * deg );
506 }
507
508 // crystal dimension
509 ModifyForCasing( penta, 30 + i );
510 A1 = ( cryPoint[1] - cryPoint[2] ).r();
511 a1 = ( cryPoint[5] - cryPoint[6] ).r();
512 B1 = ( cryPoint[1] - cryPoint[0] ).r();
513 b1 = ( cryPoint[5] - cryPoint[4] ).r();
514 C1 = ( cryPoint[0] - cryPoint[3] ).r() + A;
515 c1 = ( cryPoint[4] - cryPoint[7] ).r() + a;
516 D1 = D;
517 d1 = d;
518 E1 = B;
519 e1 = b;
520
521 // reflect the axis according to the flag
522 for ( G4int j = 0; j < 8; j++ )
523 {
524 penta[j].setZ( penta[j].getZ() + WorldZPosition +
525 SectorZPosition ); // give the absolute z coordinate
526 if ( leftFlag == 1 ) penta[j].setX( -penta[j].getX() );
527 if ( downFlag == 1 ) penta[j].setY( -penta[j].getY() );
528 if ( partId == 2 )
529 {
530 penta[j].setX( -penta[j].getX() );
531 penta[j].setZ( -penta[j].getZ() );
532 }
533 }
534
535 // compute the position
536 for ( G4int j = 4; j < 8; j++ )
537 {
538 if ( j != 0 && j != 4 ) position += pos[j];
539 if ( j == 0 || j == 1 || j == 4 || j == 5 ) position += penta[j];
540 }
541 position /= 10;
542
543 flag = leftFlag + downFlag;
544 if ( flag == 1 )
545 {
546 G4double temp1 = B1;
547 B1 = D1;
548 D1 = temp1;
549 temp1 = A1;
550 A1 = E1;
551 E1 = temp1;
552 temp1 = b1;
553 b1 = d1;
554 d1 = temp1;
555 temp1 = a1;
556 a1 = e1;
557 e1 = temp1;
558 }
559
560 break;
561 }
562 }
563
564 flag = leftFlag + downFlag + partId / 2;
565 if ( flag == 1 || flag == 3 )
566 {
567 G4double temp = C;
568 C = D;
569 D = temp;
570 temp = c;
571 c = d;
572 d = temp;
573 }
574
575 /*G4cout<<"##########################################################################"<<G4endl;
576 G4cout<<"###sector="<<sector<<",cryNb="<<cryNb<<",left flag="<<leftFlag<<",down
577 flag="<<downFlag<<G4endl; G4cout<<"partId="<<partId<<"\t"<<"theta
578 number="<<numTheta<<"\t"<<"phi number="<<numPhi<<G4endl; G4cout<<"crystal point:"<<G4endl;
579 for(G4int i=0;i<8;i++)
580 G4cout<<pos[i]<<G4endl;
581 G4cout<<"crystal position:"<<"\t"<<position<<"\t"<<"phi="<<position.phi()/deg<<G4endl;
582 G4cout<<"crystal dimension:"<<G4endl;
583 if(pentaFlag==1)
584 G4cout<<"A="<<A1<<",a="<<a1<<",B="<<B1<<",b="<<b1<<",C="<<C1<<",c="<<c1<<",D="<<D1<<",d="<<d1<<",E="<<E1<<",e="<<e1<<G4endl;
585 else
586 G4cout<<"A="<<A<<",a="<<a<<",B="<<B<<",b="<<b<<",C="<<C<<",c="<<c<<",D="<<D<<",d="<<d<<G4endl;
587 G4cout<<"##########################################################################"<<G4endl;*/
588
589 return position;
590}
e1
Double_t e1
Definition DataBase/tau_mode.c:7
sin
double sin(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:185
v
**********Class see also m_nmax DOUBLE PRECISION m_amel DOUBLE PRECISION m_x2 DOUBLE PRECISION m_alfinv DOUBLE PRECISION m_Xenph INTEGER m_KeyWtm INTEGER m_idyfs DOUBLE PRECISION m_zini DOUBLE PRECISION m_q2 DOUBLE PRECISION m_Wt_KF DOUBLE PRECISION m_WtCut INTEGER m_KFfin *COMMON c_KarLud $ !Input CMS energy[GeV] $ !CMS energy after beam spread beam strahlung[GeV] $ !Beam energy spread[GeV] $ !z boost due to beam spread $ !electron beam mass *ff pair spectrum $ !minimum v
Definition KarLud.h:35
dt
TGraph2DErrors * dt
Definition McCor.cxx:41
C
***************************************************************************************Pseudo Class RRes *****************************************************************************************Parameters and physical constants **Maarten sept ************************************************************************DOUBLE PRECISION xsmu **************************************************************************PARTICLE DATA all others are from PDG *Only resonances with known widths into electron pairs are sept ************************************************************************C Declarations C
Definition RRes.h:29
BesEmcEndGeometry::Exchange
void Exchange(G4int cry1, G4int cry2)
Definition BesEmcEndGeometry.cc:253
BesEmcEndGeometry::ExchangeSector7
void ExchangeSector7(G4int cry1, G4int cry2)
Definition BesEmcEndGeometry.cc:263
BesEmcEndGeometry::ModifyForCasing
void ModifyForCasing(G4ThreeVector pos[8], G4int CryNb)
Definition BesEmcEndGeometry.cc:348
BesEmcEndGeometry::Zoom
void Zoom(const G4ThreeVector pos[8], const G4double factor)
Definition BesEmcEndGeometry.cc:327
BesEmcEndGeometry::ComputeDimAndPos
G4ThreeVector ComputeDimAndPos(const G4int, const G4int, const G4int)
Definition BesEmcEndGeometry.cc:397
BesEmcParameter::GetInstance
static BesEmcParameter & GetInstance()
Definition BesEmcParameter.cc:28