BOSS 7.0.6
BESIII Offline Software System
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
MucRpc Class Reference

#include <MucRpc.h>

+ Inheritance diagram for MucRpc:

Public Member Functions

 MucRpc (int part, int segment, int layer, int upDown, int id)
 
 MucRpc (const MucRpc &other)
 
MucRpc & operator= (const MucRpc &other)
 
virtual ~MucRpc ()
 
double GetPhi ()
 
MucGas * GetGas ()
 
MucBakelite * GetBakelite (int id)
 
- Public Member Functions inherited from MucEntity
 MucEntity (int part, int segment, int layer)
 
 MucEntity (int part, int segment, int layer, int id)
 
 MucEntity (int part, int segment, int layer, int upDown, int id)
 
 MucEntity (int part, int segment, int layer, int upDown, int rpcId, int id)
 
 MucEntity (const MucEntity &other)
 
MucEntity & operator= (const MucEntity &other)
 
virtual ~MucEntity ()
 
int GetPart ()
 
int GetSegment ()
 
int GetLayer ()
 
int GetUpDown ()
 
int GetRpcId ()
 
int GetID ()
 
double GetTheta ()
 
double GetRin ()
 
double GetRout ()
 
double GetRc ()
 
double GetThin ()
 
double GetW ()
 
double GetH ()
 
double GetL ()
 
double GetWu ()
 
double GetWd ()
 
double GetArea ()
 
double GetLocOrgInBes (int i)
 
double GetObjRotToMot (int i)
 
double GetObjOrgInBes (int i)
 
double GetObjOrgInLoc (int i)
 
double * GetLocOrgInBes ()
 
double * GetObjRotToMot ()
 
double * GetObjOrgInLoc ()
 
double * GetObjOrgInBes ()
 
void TransBesToLoc (double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
 
void TransLocToBes (double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
 

Protected Member Functions

virtual void Init ()
 
void SetPhi ()
 
virtual void SetTheta ()
 
virtual void SetRc ()
 
virtual void SetRin ()
 
virtual void SetRout ()
 
virtual void SetThin ()
 
virtual void SetW ()
 
virtual void SetH ()
 
virtual void SetL ()
 
virtual void SetWu ()
 
virtual void SetWd ()
 
int SetEndcapRpcInBes ()
 
int SetBarrelRpcInLoc ()
 
virtual void SetLocOrgInBes ()
 
virtual void SetObjOrgInBes ()
 
virtual void SetObjOrgInLoc ()
 
- Protected Member Functions inherited from MucEntity
virtual void Init ()
 
virtual void SetTheta ()
 
virtual void SetRin ()
 
virtual void SetRout ()
 
virtual void SetRc ()
 
virtual void SetThin ()
 
virtual void SetW ()
 
virtual void SetH ()
 
virtual void SetL ()
 
virtual void SetWu ()
 
virtual void SetWd ()
 
virtual void SetArea ()
 
virtual void SetLocOrgInBes ()
 
virtual void SetObjRotToMot ()
 
virtual void SetObjOrgInBes ()
 
virtual void SetObjOrgInLoc ()
 
virtual void SetAlignment (double dx, double dy, double dz)
 

Additional Inherited Members

- Protected Attributes inherited from MucEntity
int m_Part
 
int m_Segment
 
int m_Layer
 
int m_UpDown
 
int m_RpcId
 
int m_ID
 
double m_Theta
 
double m_Rin
 
double m_Rout
 
double m_Rc
 
double m_Thin
 
double m_W
 
double m_H
 
double m_L
 
double m_Wu
 
double m_Wd
 
double m_Area
 
double m_LocOrgInBes [3]
 
double m_ObjRotToMot [3]
 
double m_ObjOrgInBes [3]
 
double m_ObjOrgInLoc [3]
 

Detailed Description

Definition at line 20 of file MucRpc.h.

Constructor & Destructor Documentation

◆ MucRpc() [1/2]

MucRpc::MucRpc ( int  part,
int  segment,
int  layer,
int  upDown,
int  id 
)

Definition at line 17 of file MucRpc.cxx.

17 : MucEntity( part, segment, layer, upDown, id )
18{
19 MucRpc::Init();
20
21 m_MucGas = NULL;
22 m_MucBakelite = NULL;
23}
MucRpc::Init
virtual void Init()
Definition: MucRpc.cxx:56

◆ MucRpc() [2/2]

MucRpc::MucRpc ( const MucRpc &  other)

Definition at line 26 of file MucRpc.cxx.

26 : MucEntity( other )
27{
28 m_Phi = other.m_Phi;
29 m_MucGas = other.m_MucGas;
30 m_MucBakelite = other.m_MucBakelite;
31}
EvtCyclic3::other
Index other(Index i, Index j)
Definition: EvtCyclic3.cc:118

◆ ~MucRpc()

MucRpc::~MucRpc ( )
virtual

Definition at line 49 of file MucRpc.cxx.

50{
51 delete m_MucGas;
52 delete m_MucBakelite;
53}

Member Function Documentation

◆ GetBakelite()

MucBakelite * MucRpc::GetBakelite ( int  id)

Definition at line 89 of file MucRpc.cxx.

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}
MucEntity::m_RpcId
int m_RpcId
Definition: MucEntity.h:92
MucEntity::m_Layer
int m_Layer
Definition: MucEntity.h:90
MucEntity::m_Segment
int m_Segment
Definition: MucEntity.h:89
MucEntity::m_Part
int m_Part
Definition: MucEntity.h:88
MucEntity::m_UpDown
int m_UpDown
Definition: MucEntity.h:91

◆ GetGas()

MucGas * MucRpc::GetGas ( )

Definition at line 82 of file MucRpc.cxx.

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}
MucEntity::m_ID
int m_ID
Definition: MucEntity.h:93
MucGas
Definition: MucGas.h:19

◆ GetPhi()

double MucRpc::GetPhi ( )

Definition at line 80 of file MucRpc.cxx.

80{ return m_Phi; }

◆ Init()

void MucRpc::Init ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 56 of file MucRpc.cxx.

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}
MucRpc::SetWu
virtual void SetWu()
Definition: MucRpc.cxx:283
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::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::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

Referenced by MucRpc().

◆ operator=()

MucRpc & MucRpc::operator= ( const MucRpc &  other)

Definition at line 34 of file MucRpc.cxx.

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}
MucEntity::operator=
MucEntity & operator=(const MucEntity &other)
Definition: MucEntity.cxx:92

◆ SetBarrelRpcInLoc()

int MucRpc::SetBarrelRpcInLoc ( )
protected

Definition at line 468 of file MucRpc.cxx.

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}
MucEntity::m_ObjOrgInLoc
double m_ObjOrgInLoc[3]
Definition: MucEntity.h:119
y
double y[1000]
Definition: draw_charge_space_coarse_II.cxx:8
x
double x[1000]
Definition: draw_charge_space_coarse_II.cxx:8

Referenced by Init().

◆ SetEndcapRpcInBes()

int MucRpc::SetEndcapRpcInBes ( )
protected

Definition at line 377 of file MucRpc.cxx.

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}
sin
double sin(const BesAngle a)
Definition: BesAngle.h:210
cos
double cos(const BesAngle a)
Definition: BesAngle.h:213
MucEntity::m_Wd
double m_Wd
Definition: MucEntity.h:106
MucEntity::m_Theta
double m_Theta
Definition: MucEntity.h:95
MucEntity::m_Rc
double m_Rc
Definition: MucEntity.h:100
MucEntity::m_ObjOrgInBes
double m_ObjOrgInBes[3]
Definition: MucEntity.h:118

Referenced by Init().

◆ SetH()

void MucRpc::SetH ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 221 of file MucRpc.cxx.

222{
223 if( m_Part == BRID )
224 m_H = RPC_TH;
225 else
226 {
227 m_H = m_Rout - m_Rin;
228 }
229}
MucEntity::m_Rin
double m_Rin
Definition: MucEntity.h:98
MucEntity::m_H
double m_H
Definition: MucEntity.h:103
MucEntity::m_Rout
double m_Rout
Definition: MucEntity.h:99

Referenced by Init().

◆ SetL()

void MucRpc::SetL ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 231 of file MucRpc.cxx.

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}
MucEntity::m_L
double m_L
Definition: MucEntity.h:104

Referenced by Init().

◆ SetLocOrgInBes()

void MucRpc::SetLocOrgInBes ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 590 of file MucRpc.cxx.

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}
MucEntity::m_LocOrgInBes
double m_LocOrgInBes[3]
Definition: MucEntity.h:109

Referenced by Init().

◆ SetObjOrgInBes()

void MucRpc::SetObjOrgInBes ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 634 of file MucRpc.cxx.

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}
MucEntity::TransLocToBes
void TransLocToBes(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:232

Referenced by Init().

◆ SetObjOrgInLoc()

void MucRpc::SetObjOrgInLoc ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 647 of file MucRpc.cxx.

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}
MucEntity::TransBesToLoc
void TransBesToLoc(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:223

Referenced by Init().

◆ SetPhi()

void MucRpc::SetPhi ( )
protected

Definition at line 99 of file MucRpc.cxx.

100{
101 if( m_Part == BRID )
102 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
103 else
104 m_Phi = 0.;
105}

Referenced by Init().

◆ SetRc()

void MucRpc::SetRc ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 146 of file MucRpc.cxx.

147{
148 m_Rc = (m_Rin + m_Rout)/2.0;
149}

Referenced by Init().

◆ SetRin()

void MucRpc::SetRin ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 130 of file MucRpc.cxx.

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}

Referenced by Init().

◆ SetRout()

void MucRpc::SetRout ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 138 of file MucRpc.cxx.

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}

Referenced by Init().

◆ SetTheta()

void MucRpc::SetTheta ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 108 of file MucRpc.cxx.

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}

Referenced by Init().

◆ SetThin()

void MucRpc::SetThin ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 151 of file MucRpc.cxx.

152{
153 m_Thin = RPC_TH;
154}
MucEntity::m_Thin
double m_Thin
Definition: MucEntity.h:101

Referenced by Init().

◆ SetW()

void MucRpc::SetW ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 156 of file MucRpc.cxx.

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}
MucEntity::m_W
double m_W
Definition: MucEntity.h:102

Referenced by Init().

◆ SetWd()

void MucRpc::SetWd ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 326 of file MucRpc.cxx.

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}

Referenced by Init().

◆ SetWu()

void MucRpc::SetWu ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 283 of file MucRpc.cxx.

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}
MucEntity::m_Wu
double m_Wu
Definition: MucEntity.h:105

Referenced by Init().

The documentation for this class was generated from the following files: