BOSS 6.6.4.p01
BESIII Offline Software System
Loading...
Searching...
No Matches
MucRpc.cxx
Go to the documentation of this file.
1//------------------------------------------------------------------------------|
2// [File ]: MucRpc.cxx |
3// [Brief ]: MUC geometry RPC creating class |
4// [Author]: Xie Yuguang, <[email protected]> |
5// [Date ]: May 22, 2005 |
6//------------------------------------------------------------------------------|
7
8#include <iostream>
9#include <cmath>
10
11#include "MucGeoCreateAlg/MucGeoConst.h"
12#include "MucGeoCreateAlg/MucRpc.h"
13
14using namespace std;
15
16// Constructor
17MucRpc::MucRpc( int part, int segment, int layer, int upDown, int id ) : MucEntity( part, segment, layer, upDown, id )
18{
19 MucRpc::Init();
20
21 m_MucGas = NULL;
22 m_MucBakelite = NULL;
23}
24
25// Copy constructor
26MucRpc::MucRpc( const MucRpc &other ) : MucEntity( other )
27{
28 m_Phi = other.m_Phi;
29 m_MucGas = other.m_MucGas;
30 m_MucBakelite = other.m_MucBakelite;
31}
32
33// Operator =
34MucRpc& MucRpc::operator =( const MucRpc &other )
35{
36 if( this == &other)
37 return *this;
38
39 MucEntity::operator =(other);
40
41 m_Phi = other.m_Phi;
42 m_MucGas = other.m_MucGas;
43 m_MucBakelite = other.m_MucBakelite;
44
45 return *this;
46}
47
48// Destructor
49MucRpc::~MucRpc()
50{
51 delete m_MucGas;
52 delete m_MucBakelite;
53}
54
55// Initialize
56void MucRpc::Init()
57{
58 SetPhi();
59 SetTheta();
60 SetRin();
61 SetRout();
62 SetRc();
63
64 SetThin();
65 SetW();
66 SetWu();
67 SetWd();
68 SetH();
69 SetL();
70
71 SetEndcapRpcInBes();
72 SetBarrelRpcInLoc();
73
74 SetLocOrgInBes();
75 SetObjOrgInBes();
76 SetObjOrgInLoc();
77}
78
79// -------------------------- Get methods ----------------------------
80double MucRpc::GetPhi() { return m_Phi; }
81
82MucGas* MucRpc::GetGas()
83{
84 if( m_MucGas != NULL ) delete m_MucGas;
85
86 return ( m_MucGas = new MucGas( m_Part, m_Segment, m_Layer, m_UpDown, m_ID, 0 ) );
87}
88
89MucBakelite* MucRpc::GetBakelite( int id )
90{
91 if( m_MucBakelite != NULL ) delete m_MucBakelite;
92
93 return ( m_MucBakelite = new MucBakelite( m_Part, m_Segment, m_Layer, m_UpDown, m_RpcId, id ) );
94}
95
96
97// ---------------------------Set motheds -----------------------------
98
99void MucRpc::SetPhi()
100{
101 if( m_Part == BRID )
102 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
103 else
104 m_Phi = 0.;
105}
106
107
108void MucRpc::SetTheta()
109{
110 if( m_Part == BRID )
111 m_Theta = m_Segment * ( MUC_PI/4.0 );
112 else
113 {
114 if( m_UpDown == SL_UP )
115 {
116 m_Theta = ( MUC_PI/4.0 ) + ( 1 - m_ID ) * MUC_PI / 8.0 ;
117 }
118 else
119 {
120 if( m_ID < 2 ) // RPC NO.1 and NO.2
121 m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
122 else if ( m_ID == 2 ) // center RPC, NO.3
123 m_Theta = ( MUC_PI/4.0 ) ;
124 else
125 m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
126 }
127 }
128}
129
130void MucRpc::SetRin()
131{
132 if( m_Part == BRID )
133 m_Rin = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown ) * (STR_TH / 2.0 + m_UpDown*RPC_TH);
134 else
135 m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
136}
137
138void MucRpc::SetRout()
139{
140 if( m_Part == BRID )
141 m_Rout = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown )*( STR_TH / 2.0 + (1-m_UpDown)*RPC_TH );
142 else
143 m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
144}
145
146void MucRpc::SetRc()
147{
148 m_Rc = (m_Rin + m_Rout)/2.0;
149}
150
151void MucRpc::SetThin()
152{
153 m_Thin = RPC_TH;
154}
155
156void MucRpc::SetW()
157{
158 if( m_Part == BRID)
159 {
160 if( m_Segment == B_TOP && m_ID < 2 ) // the first 2 RPCs in top segment
161 {
162 if( (m_Layer+1)%2 == 1 ) // odd layer
163 m_W = (B_BOX_WT[m_Layer] - 2*B_BOX_DT[m_UpDown] - 2*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
164 else // even layer
165 m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
166 }
167 else // other RPCs
168 {
169 if( (m_Layer+1)%2 ==1 ) // odd layer
170 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
171 else // even layer
172 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
173
174 }
175 } // end barrel
176 else
177 {
178 if( m_UpDown == SL_UP ) // up super layer RPCs
179 {
180 if( m_ID == 0 )
181 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
182 else if( m_ID == 1 )
183 m_W = VALUE * m_Rc * 2.0;
184 else
185 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
186 }
187 else // down super layer RPCs
188 {
189 if( m_ID == 0 )
190 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
191 else if( m_ID == 1 || m_ID == 3 )
192 m_W = VALUE * (m_Rc - m_Rin);
193 else if( m_ID == 2 )
194 m_W = VALUE * m_Rin * 2.0;
195 else
196 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA;
197 }
198
199 } // else, endcap
200
201 // cut rpc chamber death edge
202 if( m_Part == BRID )
203 m_W -= OVERLAP_WIDTH * 2.0;
204 else
205 {
206 if( m_UpDown == SL_UP )
207 {
208 if( m_ID == 1 ) m_W -= OVERLAP_WIDTH * 2.0; // center rpc
209 else m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * OVERLAP_WIDTH;
210 }
211 else
212 {
213 if( m_ID == 2 ) // center rpc
214 m_W -= OVERLAP_WIDTH * 2.0;
215 else // DOWN 0,1,3,4 RPC
216 m_W -= OVERLAP_WIDTH;
217 }
218 }
219}
220
221void MucRpc::SetH()
222{
223 if( m_Part == BRID )
224 m_H = RPC_TH;
225 else
226 {
227 m_H = m_Rout - m_Rin;
228 }
229}
230
231void MucRpc::SetL()
232{
233 if( m_Part == BRID ) // barrel
234 {
235 if( m_Segment != B_TOP ) // not top segment
236 {
237 if( (m_UpDown == SL_UP && m_ID == 3 ) || (m_UpDown == SL_DOWN && m_ID == 0 ) )
238 {
239 if( m_Layer != 1 ) // not layer NO. 2
240 m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
241 else
242 m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
243 }
244 else
245 {
246 if( m_Layer != 1 ) // not layer NO. 2
247 m_L = B_RPC_LTN;
248 else
249 m_L = B_RPC_LTS;
250 }
251 }
252 else // top segment
253 {
254 if( m_ID < 2 ) // first two RPCs
255 {
256 if( m_Layer == 0 ) // the first layer
257 m_L = B_TOPRPC_LTS[1];
258 else
259 m_L = B_TOPRPC_LTS[m_Layer%2];
260 }
261 else if( (m_UpDown == SL_UP && m_ID == 4 ) || (m_UpDown == SL_DOWN && m_ID == 2 ) )
262 {
263 if( m_Layer == 0 ) // the first layer
264 m_L = B_BOX_LT - B_TOPRPC_LTS[1] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
265 else
266 m_L = B_BOX_LT - B_TOPRPC_LTS[m_Layer%2] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
267 }
268 else
269 {
270 m_L = B_TOPRPC_LTN;
271 }
272 } // end top segment
273
274 m_L -= OVERLAP_WIDTH * 2.0; // cut rpc chamber death edge
275
276 } // end barrel
277 else
278 {
279 m_L = RPC_TH;
280 }
281}
282
283void MucRpc::SetWu()
284{
285 if( m_Part == BRID )
286 m_Wu = m_W;
287 else
288 {
289 if( m_UpDown == SL_UP )
290 {
291 if( m_ID == 0 )
292 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
293 else if( m_ID == 1 )
294 m_Wu = VALUE * m_Rin * 2.0;
295 else
296 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
297 }
298 else
299 {
300 if( m_ID == 0 )
301 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
302 else if( m_ID == 1 || m_ID == 3 )
303 m_Wu = 0.;
304 else if( m_ID == 2 )
305 m_Wu = VALUE * m_Rin * 2.0;
306 else
307 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;
308 }
309
310 // cut rpc chamber death edge
311 if( m_Wu > 0.0 ) // except for DOWN 1, 3 RPC
312 {
313 if( m_UpDown == SL_UP )
314 {
315 if( m_ID == 1 ) m_Wu += 2.0*OVERLAP_WIDTH *(sin(BETA)-1)/cos(BETA); // center rpc
316 else m_Wu -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
317 }
318 else
319 {
320 m_Wu -= 1.5*OVERLAP_WIDTH;
321 }
322 }
323 }
324}
325
326void MucRpc::SetWd()
327{
328 if( m_Part == BRID )
329 m_Wd = m_W;
330 else
331 {
332 if( m_UpDown == SL_UP )
333 {
334 if( m_ID == 0 )
335 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
336 else if( m_ID == 1 )
337 m_Wd = VALUE * m_Rout * 2.0;
338 else
339 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
340 }
341 else
342 {
343 switch( m_ID )
344 {
345 case 0:
346 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
347 break;
348 case 1:
349 case 3:
350 m_Wd = VALUE * ( m_Rout - m_Rin );
351 break;
352 case 2:
353 m_Wd = 2 * VALUE * m_Rin;
354 break;
355 case 4:
356 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
357 break;
358 default: ;
359 }
360 }
361
362 // cut rpc chamber death edge
363 if( m_UpDown == SL_UP )
364 {
365 if( m_ID == 1 ) m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)+1)/cos(BETA); // center rpc
366 else m_Wd -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
367 }
368 else
369 {
370 if( m_ID ==0 || m_ID == 4 )
371 // m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)-1)/cos(BETA);
372 m_Wd -= 1.5*OVERLAP_WIDTH;
373 }
374 }
375}
376
377int MucRpc::SetEndcapRpcInBes()
378{
379 if( m_Part == BRID )
380 return 0;
381 else
382 {
383 double x, y, z;
384 x = y = z = 0.;
385
386 // -----------------set x and y -----------------
387 if( m_UpDown == SL_UP ) // up super layer
388 {
389 if( m_ID == 0 )
390 {
391 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
392 y = m_Rc;
393 }
394 else if( m_ID == 1 )
395 {
396 x = m_Rc * cos( m_Theta );
397 y = m_Rc * sin( m_Theta );
398 }
399 else
400 {
401 x = m_Rc;
402 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
403 }
404 }
405 else // down super layer
406 {
407 if( m_ID == 0 )
408 {
409 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
410 y = m_Rc;
411 }
412 else if( m_ID == 1 )
413 {
414 x = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
415 // x += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
416
417 y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
418 // y += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
419 }
420 else if( m_ID == 2 )
421 {
422 x = m_Rc * cos( MUC_PI/4.0 );
423 y = m_Rc * sin( MUC_PI/4.0 );
424 }
425 else if( m_ID == 3 )
426 {
427 x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
428 // x += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
429
430 y = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
431 // y += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
432 }
433 else
434 {
435 x = m_Rc;
436 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
437 }
438 }
439
440 // x, y signs of coordinate different by segment
441 if( m_Segment == 0 ) { ; }
442 else if ( m_Segment == 1 ) { x = -x; }
443 else if ( m_Segment == 2 ) { x = -x; y = -y; }
444 else { y = -y; }
445
446 //-------------- set z -----------------------------
447 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
448
449 z += m_Layer * AS_GAP;
450 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
451 z += (1-2*m_UpDown) * (RPC_TH + STR_TH)/2.0 ;
452 z *= cos( m_Part*MUC_PI/2.0 );
453
454 m_ObjOrgInBes[0] = x;
455 m_ObjOrgInBes[1] = y;
456 m_ObjOrgInBes[2] = z;
457
458 // limit cut
459 for(int i=0;i<3;i++) {
460 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
461 }
462
463 } // else, endcap
464
465 return 0;
466}
467
468int MucRpc::SetBarrelRpcInLoc()
469{
470 if( m_Part != BRID )
471 return 0;
472 else
473 {
474 double x, y, z;
475 x = y = z = 0.;
476
477 if( m_Segment != B_TOP ) // not top segment
478 {
479 //---------- set x--------
480 x = 0.;
481
482 //---------- set y--------
483 y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
484
485 //---------- set z--------
486 if( (m_UpDown == SL_UP && m_ID == 3) || (m_UpDown == SL_DOWN && m_ID == 0) )
487 {
488 if( m_Layer != 1 ) // not layer NO.2
489 z = (2*m_UpDown - 1) * 3 * B_RPC_LTN / 2.0;
490 else
491 z = (2*m_UpDown - 1) * 3 * B_RPC_LTS / 2.0;
492 }
493 else
494 {
495 if( m_Layer != 1) // not layer NO.2
496 {
497 if( m_UpDown == SL_UP )
498 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTN/2.0;
499 else
500 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTN/2.0;
501 }
502 else
503 {
504 if( m_UpDown == SL_UP )
505 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTS/2.0;
506 else
507 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTS/2.0;
508 }
509 }
510 }
511 else // top segment
512 {
513 //---------- set x--------
514 if( m_ID > 1 )
515 x = 0.;
516 else
517 x = (1-2*m_ID) * ( (B_BOX_WT[m_Layer] + B_BOX_SLOT_WT)/4.0 + (B_BOX_DZ[m_UpDown]-B_BOX_DT[m_UpDown])/2.0 );
518
519 //---------- set y--------
520 y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
521
522 //---------- set z--------
523 if( m_UpDown == SL_UP )
524 {
525 switch( m_ID )
526 {
527 case 0:
528 case 1:
529 if( m_Layer == 0 )
530 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
531 else
532 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
533 break;
534 case 2:
535 case 3:
536 if( m_Layer == 0 )
537 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1] + (3-2*m_ID)*B_RPC_LTN/2.0;
538 else
539 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2] + (3-2*m_ID)*B_RPC_LTN/2.0;
540 break;
541 case 4:
542 if( m_Layer == 0 )
543 z = -B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
544 else
545 z = -B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
546 break;
547 default: ;
548 }
549 }else // down super layer
550 {
551 switch( m_ID )
552 {
553 case 0: ;
554 case 1:
555 if( m_Layer == 0 )
556 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
557 else
558 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
559 break;
560 case 2:
561 if( m_Layer == 0 )
562 z = B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
563 else
564 z = B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
565 break;
566 case 3:
567 case 4:
568 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(4-m_ID))*B_RPC_LTN/2.0;
569 break;
570 default: ;
571 }
572 } // else, down super layer
573 } // else, top segment
574
575 m_ObjOrgInLoc[0] = x;
576 m_ObjOrgInLoc[1] = y;
577 m_ObjOrgInLoc[2] = z;
578
579 // limit cut
580 for(int i=0;i<3;i++) {
581 if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
582 }
583
584 } // else, barrel
585
586 return 0;
587}
588
589// Set local( box ) in BES CS
590void MucRpc::SetLocOrgInBes()
591{
592 double x, y, z;
593 x = y = z = 0.;
594
595 if( m_Part == BRID )
596 {
597 x = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * cos( m_Theta );
598 y = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * sin( m_Theta );
599 z = 0.;
600
601 } // barrel
602 else
603 {
604 //-------------- set x and y ----------------------
605 // segment 0 as reference
606 x = (E_AS_RMAX - E_BOX_DR + E_GP_DX) / 2.0;
607 y = (E_AS_RMAX - E_BOX_DR + E_GP_DY) / 2.0;
608
609 // x, y signs of coordinate different by segment
610 if( m_Segment == 0 ) { ; }
611 else if ( m_Segment == 1 ) { x = -x; }
612 else if ( m_Segment == 2 ) { x = -x; y = -y; }
613 else { y = -y; }
614
615 //-------------- set z -----------------------------
616 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
617
618 z += m_Layer * AS_GAP;
619 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
620 z *= cos( m_Part*MUC_PI/2.0 );
621
622 }// endcap
623
624 m_LocOrgInBes[0] = x;
625 m_LocOrgInBes[1] = y;
626 m_LocOrgInBes[2] = z;
627
628 // limit cut
629 for(int i=0;i<3;i++) {
630 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
631 }
632}
633
634void MucRpc::SetObjOrgInBes()
635{
636 if( m_Part == BRID )
637 {
638 MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
639
640 // limit cut
641 for(int i=0;i<3;i++) {
642 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
643 }
644 }
645}
646
647void MucRpc::SetObjOrgInLoc()
648{
649 if( m_Part != BRID )
650 {
651 MucEntity::TransBesToLoc( m_ObjOrgInLoc, m_ObjOrgInBes, m_LocOrgInBes, m_Phi );
652 // limit cut
653 for(int i=0;i<3;i++) {
654 if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
655 }
656 }
657}
658
659/*
660void MucRpc::SetAlignment( double dx, double dy, double dz )
661{
662
663 if( m_Part == BRID || m_ID == -1 )
664 {
665 m_ObjOrgInLoc[0] += dx;
666 m_ObjOrgInLoc[1] += dy;
667 m_ObjOrgInLoc[2] += dz;
668 }
669}
670*/
671
672// END
sin
double sin(const BesAngle a)
Definition: BesAngle.h:210
cos
double cos(const BesAngle a)
Definition: BesAngle.h:213
x
Double_t x[10]
Definition: DataBase/tau_mode.c:57
MucEntity::m_RpcId
int m_RpcId
Definition: MucEntity.h:92
MucEntity::m_W
double m_W
Definition: MucEntity.h:102
MucEntity::operator=
MucEntity & operator=(const MucEntity &other)
Definition: MucEntity.cxx:92
MucEntity::m_Thin
double m_Thin
Definition: MucEntity.h:101
MucEntity::m_Rin
double m_Rin
Definition: MucEntity.h:98
MucEntity::m_H
double m_H
Definition: MucEntity.h:103
MucEntity::m_Layer
int m_Layer
Definition: MucEntity.h:90
MucEntity::m_ObjOrgInLoc
double m_ObjOrgInLoc[3]
Definition: MucEntity.h:119
MucEntity::m_Rout
double m_Rout
Definition: MucEntity.h:99
MucEntity::m_Wd
double m_Wd
Definition: MucEntity.h:106
MucEntity::TransBesToLoc
void TransBesToLoc(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:223
MucEntity::m_Segment
int m_Segment
Definition: MucEntity.h:89
MucEntity::m_Theta
double m_Theta
Definition: MucEntity.h:95
MucEntity::m_Part
int m_Part
Definition: MucEntity.h:88
MucEntity::m_LocOrgInBes
double m_LocOrgInBes[3]
Definition: MucEntity.h:109
MucEntity::m_Rc
double m_Rc
Definition: MucEntity.h:100
MucEntity::m_ObjOrgInBes
double m_ObjOrgInBes[3]
Definition: MucEntity.h:118
MucEntity::m_UpDown
int m_UpDown
Definition: MucEntity.h:91
MucEntity::TransLocToBes
void TransLocToBes(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:232
MucEntity::m_ID
int m_ID
Definition: MucEntity.h:93
MucEntity::m_Wu
double m_Wu
Definition: MucEntity.h:105
MucEntity::m_L
double m_L
Definition: MucEntity.h:104
MucGas
Definition: MucGas.h:19
MucRpc
Definition: MucRpc.h:21
MucRpc::GetPhi
double GetPhi()
Definition: MucRpc.cxx:80
MucRpc::SetWu
virtual void SetWu()
Definition: MucRpc.cxx:283
MucRpc::GetGas
MucGas * GetGas()
Definition: MucRpc.cxx:82
MucRpc::SetRout
virtual void SetRout()
Definition: MucRpc.cxx:138
MucRpc::SetThin
virtual void SetThin()
Definition: MucRpc.cxx:151
MucRpc::SetLocOrgInBes
virtual void SetLocOrgInBes()
Definition: MucRpc.cxx:590
MucRpc::operator=
MucRpc & operator=(const MucRpc &other)
Definition: MucRpc.cxx:34
MucRpc::~MucRpc
virtual ~MucRpc()
Definition: MucRpc.cxx:49
MucRpc::SetW
virtual void SetW()
Definition: MucRpc.cxx:156
MucRpc::SetPhi
void SetPhi()
Definition: MucRpc.cxx:99
MucRpc::SetBarrelRpcInLoc
int SetBarrelRpcInLoc()
Definition: MucRpc.cxx:468
MucRpc::SetEndcapRpcInBes
int SetEndcapRpcInBes()
Definition: MucRpc.cxx:377
MucRpc::SetTheta
virtual void SetTheta()
Definition: MucRpc.cxx:108
MucRpc::SetRin
virtual void SetRin()
Definition: MucRpc.cxx:130
MucRpc::SetObjOrgInBes
virtual void SetObjOrgInBes()
Definition: MucRpc.cxx:634
MucRpc::SetRc
virtual void SetRc()
Definition: MucRpc.cxx:146
MucRpc::SetWd
virtual void SetWd()
Definition: MucRpc.cxx:326
MucRpc::GetBakelite
MucBakelite * GetBakelite(int id)
Definition: MucRpc.cxx:89
MucRpc::SetObjOrgInLoc
virtual void SetObjOrgInLoc()
Definition: MucRpc.cxx:647
MucRpc::SetH
virtual void SetH()
Definition: MucRpc.cxx:221
MucRpc::SetL
virtual void SetL()
Definition: MucRpc.cxx:231
MucRpc::Init
virtual void Init()
Definition: MucRpc.cxx:56
MucRpc::MucRpc
MucRpc(int part, int segment, int layer, int upDown, int id)
Definition: MucRpc.cxx:17