BOSS 7.1.0
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.

18 : MucEntity( part, segment, layer, upDown, id )
19{
20 MucRpc::Init();
21 m_MucGas = NULL;
22 m_MucBakelite = NULL;
23}
NULL
#define NULL
Definition: VertexExtrapolate.h:14
MucRpc::Init
virtual void Init()
Definition: MucRpc.cxx:53

◆ 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 46 of file MucRpc.cxx.

47{
48 delete m_MucGas;
49 delete m_MucBakelite;
50}

Member Function Documentation

◆ GetBakelite()

MucBakelite * MucRpc::GetBakelite ( int  id)

Definition at line 85 of file MucRpc.cxx.

86{
87 if( m_MucBakelite != NULL ) delete m_MucBakelite;
88 return ( m_MucBakelite = new MucBakelite( m_Part, m_Segment, m_Layer, m_UpDown, m_RpcId, id ) );
89}
MucEntity::m_RpcId
int m_RpcId
Definition: MucEntity.h:91
MucEntity::m_Layer
int m_Layer
Definition: MucEntity.h:89
MucEntity::m_Segment
int m_Segment
Definition: MucEntity.h:88
MucEntity::m_Part
int m_Part
Definition: MucEntity.h:87
MucEntity::m_UpDown
int m_UpDown
Definition: MucEntity.h:90

◆ GetGas()

MucGas * MucRpc::GetGas ( )

Definition at line 79 of file MucRpc.cxx.

80{
81 if( m_MucGas != NULL ) delete m_MucGas;
82 return ( m_MucGas = new MucGas( m_Part, m_Segment, m_Layer, m_UpDown, m_ID, 0 ) );
83}
MucEntity::m_ID
int m_ID
Definition: MucEntity.h:92
MucGas
Definition: MucGas.h:19

◆ GetPhi()

double MucRpc::GetPhi ( )

Definition at line 77 of file MucRpc.cxx.

77{ return m_Phi; }

◆ Init()

void MucRpc::Init ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 53 of file MucRpc.cxx.

54{
55 SetPhi();
56 SetTheta();
57 SetRin();
58 SetRout();
59 SetRc();
60
61 SetThin();
62 SetW();
63 SetWu();
64 SetWd();
65 SetH();
66 SetL();
67
68 SetEndcapRpcInBes();
69 SetBarrelRpcInLoc();
70
71 SetLocOrgInBes();
72 SetObjOrgInBes();
73 SetObjOrgInLoc();
74}
MucRpc::SetWu
virtual void SetWu()
Definition: MucRpc.cxx:258
MucRpc::SetRout
virtual void SetRout()
Definition: MucRpc.cxx:125
MucRpc::SetThin
virtual void SetThin()
Definition: MucRpc.cxx:138
MucRpc::SetLocOrgInBes
virtual void SetLocOrgInBes()
Definition: MucRpc.cxx:544
MucRpc::SetW
virtual void SetW()
Definition: MucRpc.cxx:143
MucRpc::SetPhi
void SetPhi()
Definition: MucRpc.cxx:92
MucRpc::SetBarrelRpcInLoc
int SetBarrelRpcInLoc()
Definition: MucRpc.cxx:424
MucRpc::SetEndcapRpcInBes
int SetEndcapRpcInBes()
Definition: MucRpc.cxx:345
MucRpc::SetTheta
virtual void SetTheta()
Definition: MucRpc.cxx:98
MucRpc::SetRin
virtual void SetRin()
Definition: MucRpc.cxx:117
MucRpc::SetObjOrgInBes
virtual void SetObjOrgInBes()
Definition: MucRpc.cxx:585
MucRpc::SetRc
virtual void SetRc()
Definition: MucRpc.cxx:133
MucRpc::SetWd
virtual void SetWd()
Definition: MucRpc.cxx:297
MucRpc::SetObjOrgInLoc
virtual void SetObjOrgInLoc()
Definition: MucRpc.cxx:596
MucRpc::SetH
virtual void SetH()
Definition: MucRpc.cxx:205
MucRpc::SetL
virtual void SetL()
Definition: MucRpc.cxx:211

Referenced by MucRpc().

◆ operator=()

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

Definition at line 34 of file MucRpc.cxx.

35{
36 if( this == &other) return *this;
37 MucEntity::operator =(other);
38 m_Phi = other.m_Phi;
39 m_MucGas = other.m_MucGas;
40 m_MucBakelite = other.m_MucBakelite;
41
42 return *this;
43}
MucEntity::operator=
MucEntity & operator=(const MucEntity &other)
Definition: MucEntity.cxx:92

◆ SetBarrelRpcInLoc()

int MucRpc::SetBarrelRpcInLoc ( )
protected

Definition at line 424 of file MucRpc.cxx.

425{
426 if( m_Part != BRID ) return 0;
427 else
428 {
429 double x, y, z;
430 x = y = z = 0.;
431
432 if( m_Segment != B_TOP ) // not top segment
433 {
434 //---------- set x--------
435 x = 0.;
436
437 //---------- set y--------
438 y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
439
440 //---------- set z--------
441 if( (m_UpDown == SL_UP && m_ID == 3) || (m_UpDown == SL_DOWN && m_ID == 0) )
442 {
443 if( m_Layer != 1 ) // not layer NO.2
444 z = (2*m_UpDown - 1) * 3 * B_RPC_LTN / 2.0;
445 else
446 z = (2*m_UpDown - 1) * 3 * B_RPC_LTS / 2.0;
447 }
448 else
449 {
450 if( m_Layer != 1) // not layer NO.2
451 {
452 if( m_UpDown == SL_UP )
453 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTN/2.0;
454 else
455 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTN/2.0;
456 }
457 else
458 {
459 if( m_UpDown == SL_UP )
460 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTS/2.0;
461 else
462 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTS/2.0;
463 }
464 }
465 }
466 else // top segment
467 {
468 //---------- set x--------
469 if( m_ID > 1 )
470 x = 0.;
471 else
472 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 );
473
474 //---------- set y--------
475 y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
476
477 //---------- set z--------
478 if( m_UpDown == SL_UP )
479 {
480 switch( m_ID )
481 {
482 case 0:
483 case 1:
484 if( m_Layer == 0 )
485 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
486 else
487 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
488 break;
489 case 2:
490 case 3:
491 if( m_Layer == 0 )
492 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1] + (3-2*m_ID)*B_RPC_LTN/2.0;
493 else
494 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;
495 break;
496 case 4:
497 if( m_Layer == 0 )
498 z = -B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
499 else
500 z = -B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
501 break;
502 default: ;
503 }
504 }else // down super layer
505 {
506 switch( m_ID )
507 {
508 case 0: ;
509 case 1:
510 if( m_Layer == 0 )
511 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
512 else
513 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
514 break;
515 case 2:
516 if( m_Layer == 0 )
517 z = B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
518 else
519 z = B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
520 break;
521 case 3:
522 case 4:
523 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(4-m_ID))*B_RPC_LTN/2.0;
524 break;
525 default:;
526 }
527 } // else, down super layer
528 } // else, top segment
529
530 m_ObjOrgInLoc[0] = x;
531 m_ObjOrgInLoc[1] = y;
532 m_ObjOrgInLoc[2] = z;
533
534 // limit cut
535 for(int i=0;i<3;i++)
536 if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
537
538 } // else, barrel
539
540 return 0;
541}
x
Double_t x[10]
Definition: DataBase/tau_mode.c:57
MucEntity::m_ObjOrgInLoc
double m_ObjOrgInLoc[3]
Definition: MucEntity.h:118
y
double y[1000]
Definition: draw_charge_space_coarse_II.cxx:8

Referenced by Init().

◆ SetEndcapRpcInBes()

int MucRpc::SetEndcapRpcInBes ( )
protected

Definition at line 345 of file MucRpc.cxx.

346{
347 if( m_Part == BRID ) return 0;
348 else
349 {
350 double x, y, z;
351 x = y = z = 0.;
352
353 // -----------------set x and y -----------------
354 if( m_UpDown == SL_UP ) // up super layer
355 {
356 if( m_ID == 0 ) {
357 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
358 y = m_Rc;
359 }
360 else if( m_ID == 1 ) {
361 x = m_Rc * cos( m_Theta );
362 y = m_Rc * sin( m_Theta );
363 }
364 else {
365 x = m_Rc;
366 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
367 }
368 }
369 else // down super layer
370 {
371 if( m_ID == 0 ) {
372 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
373 y = m_Rc;
374 }
375 else if( m_ID == 1 ) {
376 x = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
377 // x += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
378 y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
379 // y += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
380 }
381 else if( m_ID == 2 ) {
382 x = m_Rc * cos( MUC_PI/4.0 );
383 y = m_Rc * sin( MUC_PI/4.0 );
384 }
385 else if( m_ID == 3 ) {
386 x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
387 // x += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
388 y = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
389 // y += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
390 }
391 else {
392 x = m_Rc;
393 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
394 }
395 } // End down super layer
396
397 // x, y signs of coordinate different by segment
398 if ( m_Segment == 0 ) { ; }
399 else if ( m_Segment == 1 ) { x = -x; }
400 else if ( m_Segment == 2 ) { x = -x; y = -y; }
401 else { y = -y; }
402
403 //-------------- set z -----------------------------
404 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
405
406 z += m_Layer * AS_GAP;
407 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
408 z += (1-2*m_UpDown) * (RPC_TH + STR_TH)/2.0 ;
409 z *= cos( m_Part*MUC_PI/2.0 );
410
411 m_ObjOrgInBes[0] = x;
412 m_ObjOrgInBes[1] = y;
413 m_ObjOrgInBes[2] = z;
414
415 // limit cut
416 for(int i=0;i<3;i++)
417 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
418
419 } // else, endcap
420
421 return 0;
422}
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:105
MucEntity::m_Theta
double m_Theta
Definition: MucEntity.h:94
MucEntity::m_Rc
double m_Rc
Definition: MucEntity.h:99
MucEntity::m_ObjOrgInBes
double m_ObjOrgInBes[3]
Definition: MucEntity.h:117

Referenced by Init().

◆ SetH()

void MucRpc::SetH ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 205 of file MucRpc.cxx.

206{
207 if( m_Part == BRID ) m_H = RPC_TH;
208 else m_H = m_Rout - m_Rin;
209}
MucEntity::m_Rin
double m_Rin
Definition: MucEntity.h:97
MucEntity::m_H
double m_H
Definition: MucEntity.h:102
MucEntity::m_Rout
double m_Rout
Definition: MucEntity.h:98

Referenced by Init().

◆ SetL()

void MucRpc::SetL ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 211 of file MucRpc.cxx.

212{
213 if( m_Part == BRID ) // barrel
214 {
215 if( m_Segment != B_TOP ) // not top segment
216 {
217 if( (m_UpDown == SL_UP && m_ID == 3 ) || (m_UpDown == SL_DOWN && m_ID == 0 ) )
218 {
219 if( m_Layer != 1 ) // not layer NO. 2
220 m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
221 else
222 m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
223 }
224 else
225 {
226 if( m_Layer != 1 ) // not layer NO. 2
227 m_L = B_RPC_LTN;
228 else
229 m_L = B_RPC_LTS;
230 }
231 }
232 else // top segment
233 {
234 if( m_ID < 2 ) // first two RPCs
235 {
236 if( m_Layer == 0 ) // the first layer
237 m_L = B_TOPRPC_LTS[1];
238 else
239 m_L = B_TOPRPC_LTS[m_Layer%2];
240 }
241 else if( (m_UpDown == SL_UP && m_ID == 4 ) || (m_UpDown == SL_DOWN && m_ID == 2 ) )
242 {
243 if( m_Layer == 0 ) // the first layer
244 m_L = B_BOX_LT - B_TOPRPC_LTS[1] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
245 else
246 m_L = B_BOX_LT - B_TOPRPC_LTS[m_Layer%2] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
247 }
248 else
249 m_L = B_TOPRPC_LTN;
250 } // end top segment
251
252 m_L -= OVERLAP_WIDTH * 2.0; // cut rpc chamber death edge
253
254 } // end barrel
255 else m_L = RPC_TH;
256}
MucEntity::m_L
double m_L
Definition: MucEntity.h:103

Referenced by Init().

◆ SetLocOrgInBes()

void MucRpc::SetLocOrgInBes ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 544 of file MucRpc.cxx.

545{
546 double x, y, z;
547 x = y = z = 0.;
548
549 if( m_Part == BRID )
550 {
551 x = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * cos( m_Theta );
552 y = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * sin( m_Theta );
553 z = 0.;
554 } // barrel
555 else
556 {
557 //-------------- set x and y ----------------------
558 // segment 0 as reference
559 x = (E_AS_RMAX - E_BOX_DR + E_GP_DX) / 2.0;
560 y = (E_AS_RMAX - E_BOX_DR + E_GP_DY) / 2.0;
561
562 // x, y signs of coordinate different by segment
563 if ( m_Segment == 0 ) { ; }
564 else if ( m_Segment == 1 ) { x = -x; }
565 else if ( m_Segment == 2 ) { x = -x; y = -y; }
566 else { y = -y; }
567
568 //-------------- set z -----------------------------
569 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
570
571 z += m_Layer * AS_GAP;
572 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
573 z *= cos( m_Part*MUC_PI/2.0 );
574 }// endcap
575
576 m_LocOrgInBes[0] = x;
577 m_LocOrgInBes[1] = y;
578 m_LocOrgInBes[2] = z;
579
580 // limit cut
581 for(int i=0;i<3;i++)
582 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
583}
MucEntity::m_LocOrgInBes
double m_LocOrgInBes[3]
Definition: MucEntity.h:108

Referenced by Init().

◆ SetObjOrgInBes()

void MucRpc::SetObjOrgInBes ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 585 of file MucRpc.cxx.

586{
587 if( m_Part == BRID )
588 {
589 MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
590 // limit cut
591 for(int i=0;i<3;i++)
592 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
593 }
594}
MucEntity::TransLocToBes
void TransLocToBes(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:231

Referenced by Init().

◆ SetObjOrgInLoc()

void MucRpc::SetObjOrgInLoc ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 596 of file MucRpc.cxx.

597{
598 if( m_Part != BRID )
599 {
600 MucEntity::TransBesToLoc( m_ObjOrgInLoc, m_ObjOrgInBes, m_LocOrgInBes, m_Phi );
601 // limit cut
602 for(int i=0;i<3;i++)
603 if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
604 }
605}
MucEntity::TransBesToLoc
void TransBesToLoc(double LocCoord[], double BesCoord[], double LocOrgInBes[], double Rot_z)
Definition: MucEntity.cxx:222

Referenced by Init().

◆ SetPhi()

void MucRpc::SetPhi ( )
protected

Definition at line 92 of file MucRpc.cxx.

93{
94 if( m_Part == BRID ) m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
95 else m_Phi = 0.;
96}

Referenced by Init().

◆ SetRc()

void MucRpc::SetRc ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 133 of file MucRpc.cxx.

134{
135 m_Rc = (m_Rin + m_Rout)/2.0;
136}

Referenced by Init().

◆ SetRin()

void MucRpc::SetRin ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 117 of file MucRpc.cxx.

118{
119 if( m_Part == BRID )
120 m_Rin = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown ) * (STR_TH / 2.0 + m_UpDown*RPC_TH);
121 else
122 m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
123}

Referenced by Init().

◆ SetRout()

void MucRpc::SetRout ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 125 of file MucRpc.cxx.

126{
127 if( m_Part == BRID )
128 m_Rout = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown )*( STR_TH / 2.0 + (1-m_UpDown)*RPC_TH );
129 else
130 m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
131}

Referenced by Init().

◆ SetTheta()

void MucRpc::SetTheta ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 98 of file MucRpc.cxx.

99{
100 if( m_Part == BRID ) m_Theta = m_Segment * ( MUC_PI/4.0 );
101 else
102 {
103 if( m_UpDown == SL_UP )
104 m_Theta = ( MUC_PI/4.0 ) + ( 1 - m_ID ) * MUC_PI / 8.0 ;
105 else
106 {
107 if( m_ID < 2 ) // RPC NO.1 and NO.2
108 m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
109 else if ( m_ID == 2 ) // center RPC, NO.3
110 m_Theta = ( MUC_PI/4.0 ) ;
111 else
112 m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
113 }
114 }
115}

Referenced by Init().

◆ SetThin()

void MucRpc::SetThin ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 138 of file MucRpc.cxx.

139{
140 m_Thin = RPC_TH;
141}
MucEntity::m_Thin
double m_Thin
Definition: MucEntity.h:100

Referenced by Init().

◆ SetW()

void MucRpc::SetW ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 143 of file MucRpc.cxx.

144{
145 if( m_Part == BRID)
146 {
147 if( m_Segment == B_TOP && m_ID < 2 ) // the first 2 RPCs in top segment
148 {
149 if( (m_Layer+1)%2 == 1 ) // odd layer
150 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;
151 else // even layer
152 m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
153 }
154 else // other RPCs
155 {
156 if( (m_Layer+1)%2 ==1 ) // odd layer
157 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
158 else // even layer
159 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
160 }
161 } // end barrel
162 else
163 {
164 if( m_UpDown == SL_UP ) // up super layer RPCs
165 {
166 if( m_ID == 0 )
167 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
168 else if( m_ID == 1 )
169 m_W = VALUE * m_Rc * 2.0;
170 else
171 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
172 }
173 else // down super layer RPCs
174 {
175 if( m_ID == 0 )
176 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
177 else if( m_ID == 1 || m_ID == 3 )
178 m_W = VALUE * (m_Rc - m_Rin);
179 else if( m_ID == 2 )
180 m_W = VALUE * m_Rin * 2.0;
181 else
182 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA;
183 }
184 } // else, endcap
185
186 // cut rpc chamber death edge
187 if( m_Part == BRID )
188 m_W -= OVERLAP_WIDTH * 2.0;
189 else
190 {
191 if( m_UpDown == SL_UP ) {
192 if( m_ID == 1 ) m_W -= OVERLAP_WIDTH * 2.0; // center rpc
193 else m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * OVERLAP_WIDTH;
194 }
195 else
196 {
197 if( m_ID == 2 ) // center rpc
198 m_W -= OVERLAP_WIDTH * 2.0;
199 else // DOWN 0,1,3,4 RPC
200 m_W -= OVERLAP_WIDTH;
201 }
202 }
203}
MucEntity::m_W
double m_W
Definition: MucEntity.h:101

Referenced by Init().

◆ SetWd()

void MucRpc::SetWd ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 297 of file MucRpc.cxx.

298{
299 if( m_Part == BRID ) m_Wd = m_W;
300 else
301 {
302 if( m_UpDown == SL_UP )
303 {
304 if( m_ID == 0 )
305 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
306 else if( m_ID == 1 )
307 m_Wd = VALUE * m_Rout * 2.0;
308 else
309 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
310 }
311 else
312 {
313 switch( m_ID )
314 {
315 case 0:
316 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
317 break;
318 case 1:
319 case 3:
320 m_Wd = VALUE * ( m_Rout - m_Rin );
321 break;
322 case 2:
323 m_Wd = 2 * VALUE * m_Rin;
324 break;
325 case 4:
326 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
327 break;
328 default: ;
329 }
330 }
331
332 // cut rpc chamber death edge
333 if( m_UpDown == SL_UP ) {
334 if( m_ID == 1 ) m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)+1)/cos(BETA); // center rpc
335 else m_Wd -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
336 }
337 else {
338 if( m_ID ==0 || m_ID == 4 )
339 // m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)-1)/cos(BETA);
340 m_Wd -= 1.5*OVERLAP_WIDTH;
341 }
342 }
343}

Referenced by Init().

◆ SetWu()

void MucRpc::SetWu ( )
protectedvirtual

Reimplemented from MucEntity.

Definition at line 258 of file MucRpc.cxx.

259{
260 if( m_Part == BRID ) m_Wu = m_W;
261 else
262 {
263 if( m_UpDown == SL_UP )
264 {
265 if( m_ID == 0 )
266 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
267 else if( m_ID == 1 )
268 m_Wu = VALUE * m_Rin * 2.0;
269 else
270 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
271 }
272 else
273 {
274 if( m_ID == 0 )
275 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
276 else if( m_ID == 1 || m_ID == 3 )
277 m_Wu = 0.;
278 else if( m_ID == 2 )
279 m_Wu = VALUE * m_Rin * 2.0;
280 else
281 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;
282 }
283
284 // cut rpc chamber death edge
285 if( m_Wu > 0.0 ) // except for DOWN 1, 3 RPC
286 {
287 if( m_UpDown == SL_UP ) {
288 if( m_ID == 1 ) m_Wu += 2.0*OVERLAP_WIDTH *(sin(BETA)-1)/cos(BETA); // center rpc
289 else m_Wu -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
290 }
291 else
292 m_Wu -= 1.5*OVERLAP_WIDTH;
293 }
294 }
295}
MucEntity::m_Wu
double m_Wu
Definition: MucEntity.h:104

Referenced by Init().

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