Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

MucBakelite Class Reference

#include <MucBakelite.h>

Inheritance diagram for MucBakelite:

MucEntity MucEntity List of all members.

Public Member Functions

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

Protected Member Functions

virtual void Init ()
virtual void Init ()
virtual void SetAlignment (double dx, double dy, double dz)
virtual void SetAlignment (double dx, double dy, double dz)
virtual void SetArea ()
virtual void SetArea ()
int SetBarrelRpcInBes ()
int SetBarrelRpcInBes ()
int SetEndcapRpcInBes ()
int SetEndcapRpcInBes ()
virtual void SetH ()
virtual void SetH ()
virtual void SetL ()
virtual void SetL ()
virtual void SetLocOrgInBes ()
virtual void SetLocOrgInBes ()
virtual void SetObjOrgInBes ()
virtual void SetObjOrgInBes ()
virtual void SetObjOrgInLoc ()
virtual void SetObjOrgInLoc ()
virtual void SetObjRotToMot ()
virtual void SetObjRotToMot ()
virtual void SetPhi ()
virtual void SetPhi ()
virtual void SetRc ()
virtual void SetRc ()
virtual void SetRin ()
virtual void SetRin ()
virtual void SetRout ()
virtual void SetRout ()
virtual void SetTheta ()
virtual void SetTheta ()
virtual void SetThin ()
virtual void SetThin ()
virtual void SetW ()
virtual void SetW ()
virtual void SetWd ()
virtual void SetWd ()
virtual void SetWu ()
virtual void SetWu ()

Protected Attributes

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

Private Attributes

double m_Phi

Constructor & Destructor Documentation

MucBakelite::MucBakelite (  int  part,
int  segment,
int  layer,
int  upDown,
int  rpcId,
int  id
) 
  

00018         : MucEntity( part, segment, layer, upDown, rpcId, id )
00019 {
00020         MucBakelite::Init();
00021 }

MucBakelite::MucBakelite (  const MucBakelite &  other  ) 
  

00024                                                    : MucEntity( other )
00025 {
00026         m_Phi           = other.m_Phi;
00027 }

MucBakelite::~MucBakelite (   ) 
  

00043 { ; }

MucBakelite::MucBakelite (  int  part,
int  segment,
int  layer,
int  upDown,
int  rpcId,
int  id
) 
 

MucBakelite::MucBakelite (  const MucBakelite &  other  ) 
 

MucBakelite::~MucBakelite (   ) 
 

Member Function Documentation

double MucEntity::GetArea (   )  [inherited]
 

double MucEntity::GetArea (   )  [inherited]
  

00150 { return m_Area;        }

double MucEntity::GetH (   )  [inherited]
 

double MucEntity::GetH (   )  [inherited]
  

00146 { return m_H;           }

int MucEntity::GetID (   )  [inherited]
 

int MucEntity::GetID (   )  [inherited]
  

00139 { return m_ID;          }

double MucEntity::GetL (   )  [inherited]
 

double MucEntity::GetL (   )  [inherited]
  

00147 { return m_L;           }

int MucEntity::GetLayer (   )  [inherited]
 

int MucEntity::GetLayer (   )  [inherited]
  

00136 { return m_Layer;       }

double* MucEntity::GetLocOrgInBes (   )  [inherited]
 

double MucEntity::GetLocOrgInBes (  int  i  )  [inherited]
 

double * MucEntity::GetLocOrgInBes (   )  [inherited]
  

00176 { return &m_LocOrgInBes[0]; }

double MucEntity::GetLocOrgInBes (  int  i  )  [inherited]
  

00153 {
00154         if( i<1 || i>3 ) i=1;
00155         return m_LocOrgInBes[i-1];
00156 }

double* MucEntity::GetObjOrgInBes (   )  [inherited]
 

double MucEntity::GetObjOrgInBes (  int  i  )  [inherited]
 

double * MucEntity::GetObjOrgInBes (   )  [inherited]
  

00178 { return &m_ObjOrgInBes[0]; }

double MucEntity::GetObjOrgInBes (  int  i  )  [inherited]
  

00165 {
00166         if( i<1 || i>3 ) i=1;
00167         return m_ObjOrgInBes[i-1];
00168 }

double* MucEntity::GetObjOrgInLoc (   )  [inherited]
 

double MucEntity::GetObjOrgInLoc (  int  i  )  [inherited]
 

double * MucEntity::GetObjOrgInLoc (   )  [inherited]
  

00179 { return &m_ObjOrgInLoc[0]; }

double MucEntity::GetObjOrgInLoc (  int  i  )  [inherited]
  

00171 {
00172         if( i<1 || i>3 ) i=1;
00173         return m_ObjOrgInLoc[i-1];
00174 }

double* MucEntity::GetObjRotToMot (   )  [inherited]
 

double MucEntity::GetObjRotToMot (  int  i  )  [inherited]
 

double * MucEntity::GetObjRotToMot (   )  [inherited]
  

00177 { return &m_ObjRotToMot[0]; }

double MucEntity::GetObjRotToMot (  int  i  )  [inherited]
  

00159 {
00160         if( i<1 || i>3 ) i=1;
00161         return m_ObjRotToMot[i-1];
00162 }

int MucEntity::GetPart (   )  [inherited]
 

int MucEntity::GetPart (   )  [inherited]
  

00134 { return m_Part;        }

double MucBakelite::GetPhi (   ) 
 

double MucBakelite::GetPhi (   ) 
  

00071 {        return m_Phi;          }

double MucEntity::GetRc (   )  [inherited]
 

double MucEntity::GetRc (   )  [inherited]
  

00143 { return m_Rc;          }

double MucEntity::GetRin (   )  [inherited]
 

double MucEntity::GetRin (   )  [inherited]
  

00141 { return m_Rin;         }

double MucEntity::GetRout (   )  [inherited]
 

double MucEntity::GetRout (   )  [inherited]
  

00142 { return m_Rout;        }

int MucEntity::GetRpcId (   )  [inherited]
 

int MucEntity::GetRpcId (   )  [inherited]
  

00138 { return m_RpcId;       }

int MucEntity::GetSegment (   )  [inherited]
 

int MucEntity::GetSegment (   )  [inherited]
  

00135 { return m_Segment;     }

double MucEntity::GetTheta (   )  [inherited]
 

double MucEntity::GetTheta (   )  [inherited]
  

00140 { return m_Theta;       }

double MucEntity::GetThin (   )  [inherited]
 

double MucEntity::GetThin (   )  [inherited]
  

00144 { return m_Thin;        }

int MucEntity::GetUpDown (   )  [inherited]
 

int MucEntity::GetUpDown (   )  [inherited]
  

00137 { return m_UpDown;      }

double MucEntity::GetW (   )  [inherited]
 

double MucEntity::GetW (   )  [inherited]
  

00145 { return m_W;           }

double MucEntity::GetWd (   )  [inherited]
 

double MucEntity::GetWd (   )  [inherited]
  

00149 { return m_Wd;          }

double MucEntity::GetWu (   )  [inherited]
 

double MucEntity::GetWu (   )  [inherited]
  

00148 { return m_Wu;          }

virtual void MucBakelite::Init (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::Init (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00047 {
00048         SetPhi();
00049         SetTheta();
00050         SetRin();
00051         SetRout();
00052         SetRc();
00053 
00054         SetThin();
00055         SetW();
00056         SetWu();
00057         SetWd();
00058         SetH();
00059         SetL();
00060 
00061         SetEndcapRpcInBes();
00062         SetBarrelRpcInBes();
00063 
00064         SetLocOrgInBes();
00065         SetObjOrgInLoc();
00066         SetObjOrgInBes();
00067 }

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

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

00031 {
00032         if( this == &other)
00033                 return *this;
00034 
00035         MucEntity::operator =(other);
00036 
00037         m_Phi           = other.m_Phi;
00038 
00039         return *this;   
00040 }

virtual void MucEntity::SetAlignment (  double  dx,
double  dy,
double  dz
)  [protected, virtual, inherited]
 

Reimplemented in MucBox, MucStripPlane, MucBox, and MucStripPlane.

void MucEntity::SetAlignment (  double  dx,
double  dy,
double  dz
)  [protected, virtual, inherited]
 

Reimplemented in MucBox, MucStripPlane, MucBox, and MucStripPlane.

00219 { ; }

virtual void MucEntity::SetArea (   )  [protected, virtual, inherited]
 

Reimplemented in MucBox, MucStrip, MucBox, and MucStrip.

void MucEntity::SetArea (   )  [protected, virtual, inherited]
 

Reimplemented in MucBox, MucStrip, MucBox, and MucStrip.

00212 { m_Area        = 0.;   }

int MucBakelite::SetBarrelRpcInBes (   )  [protected]
 

int MucBakelite::SetBarrelRpcInBes (   )  [protected]
  

00380 {
00381         if( m_Part != BRID ) return 0;
00382 
00383         double x, y, z;
00384         x = y = z = 0.0;
00385 
00386         if( m_Segment != B_TOP )
00387         {
00388                 // set x and y
00389                 double r;
00390                 r = (B_AS_RMIN[m_Layer] - AS_GAP / 2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
00391                 x = r * cos( m_Theta );
00392                 y = r * sin( m_Theta );
00393 
00394                 // set z
00395                 if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
00396                 {
00397                         if( m_Layer != 1 ) // not layer NO.2
00398                                 z = (2*m_UpDown - 1) * 3 * B_RPC_LTN/2.0;
00399                         else
00400                                 z = (2*m_UpDown - 1) * 3 * B_RPC_LTS/2.0;
00401                 }
00402                 else if( m_UpDown == SL_UP )
00403                         z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_RpcId)*B_RPC_LTN/2.0;
00404                 else
00405                         z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_RpcId))*B_RPC_LTN/2.0;
00406 
00407         } // end not top segment
00408         else
00409         {
00410                 //---------- set x--------
00411                 if( m_RpcId > 1 )  // NO.3, 4, 5
00412                         x = 0.;
00413                 else // NO.1 and NO.2
00414                         x = (1-2*m_RpcId) * ( (B_BOX_WT[m_Layer] + B_BOX_SLOT_WT)/4.0 + (B_BOX_DZ[m_UpDown] - B_BOX_DT[m_UpDown])/2.0 );
00415                 
00416                 //---------- set y--------
00417                 y = (B_AS_RMIN[m_Layer] - AS_GAP / 2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
00418 
00419                 //---------- set z--------
00420                 if( m_RpcId < 2 ) // rpc NO.1 and NO.2
00421                         z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00422                 else if( m_UpDown == SL_UP && m_RpcId == 4 )
00423                         z = -B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00424                 else if( m_UpDown == SL_DOWN && m_RpcId == 2 )
00425                         z = B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00426                 else if( m_UpDown == SL_UP )
00427                         z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ] + (3-2*m_RpcId)*B_RPC_LTN/2.0;
00428                 else
00429                         z = -B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] + (1+2*(4-m_RpcId))*B_RPC_LTN/2.0;
00430 
00431         } // end top segment
00432 
00433         m_LocOrgInBes[0] = x;
00434         m_LocOrgInBes[1] = y;
00435         m_LocOrgInBes[2] = z;
00436 
00437         // limit cut
00438         for( int i=0; i<2; i++ ) {
00439                 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.0;
00440         }
00441         
00442         return 0;
00443 }

int MucBakelite::SetEndcapRpcInBes (   )  [protected]
 

int MucBakelite::SetEndcapRpcInBes (   )  [protected]
  

00446 {
00447         if( m_Part == BRID ) return 0;
00448         
00449         double x, y, z;
00450         x = y = z = 0.;
00451 
00452         //------------ set x and y ---------------
00453         if( m_UpDown == SL_UP )
00454         {
00455                 if( m_RpcId == 0 )
00456                 {
00457                         x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
00458                         y = m_Rc;
00459                 }       
00460                 else if( m_RpcId == 1 )
00461                 {
00462                         x = m_Rc * cos( MUC_PI/4.0 );
00463                         y = m_Rc * sin( MUC_PI/4.0 );
00464                 }
00465                 else
00466                 {
00467                         x = m_Rc;
00468                         y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
00469                 }               
00470         }
00471         else
00472         {
00473                 switch( m_RpcId )
00474                 {
00475                         case 0:
00476                                 x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
00477                                 y = m_Rc;
00478                                 break;
00479                         case 1:
00480                                 x = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00481                                 x += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
00482 
00483                                 y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00484                                 y += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
00485 
00486                                 break;
00487                         case 2:
00488                                 x = m_Rc * cos( MUC_PI/4.0 );
00489                                 y = m_Rc * sin( MUC_PI/4.0 );
00490                                 break;
00491                         case 3:
00492                                 x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00493                                 x += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
00494 
00495                                 y = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00496                                 y += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
00497 
00498                                 break;
00499                         case 4:
00500                                 x = m_Rc;
00501                                 y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
00502                 }
00503                 
00504         }
00505         
00506         // sign different by segment
00507         if     ( m_Segment == 0 ) {     ;               }
00508         else if( m_Segment == 1 ) {     x = -x;         }
00509         else if( m_Segment == 2 ) {     x = -x; y = -y; }                                               
00510         else                      {     y = -y;         }
00511 
00512         
00513         //------------ set z ---------------------
00514         for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i]; 
00515 
00516         z += m_Layer * AS_GAP;
00517         z +=  ( (E_AS_ZMAX - E_AS_TOTAL_TH ) + AS_GAP/2.0 );  
00518         z += (1-2*m_UpDown) * ( STR_TH + RPC_TH ) / 2.0;        
00519         z *= cos( m_Part*MUC_PI/2.0 );
00520 
00521         m_LocOrgInBes[0] = x;
00522         m_LocOrgInBes[1] = y;
00523         m_LocOrgInBes[2] = z;
00524 
00525         // limit cut
00526         for( int i=0; i<2; i++ ) {
00527                 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
00528         }
00529                 
00530         return 0;
00531 }

virtual void MucBakelite::SetH (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetH (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00208 {
00209         if( m_Part == BRID )
00210                 m_H = BKLT_TH;
00211         else
00212         {
00213                 m_H = m_Rout - m_Rin;   
00214 
00215                 // cut rpc chamber death edge
00216                 if( m_UpDown == SL_DOWN && (m_ID == 1 || m_ID == 3) )
00217                         m_H -= RPC_DEATH_EDGE * (1 + 1.0/VALUE);
00218                 else
00219                         m_H -= RPC_DEATH_EDGE * 2.0;
00220         }
00221 }

virtual void MucBakelite::SetL (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetL (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00224 {
00225         if( m_Part == BRID ) // barrel
00226         {
00227                 if( m_Segment != B_TOP ) // not top segment
00228                 {
00229                         // the first rpc of SL_DOWN is constructed as the same as the last rpc of SL_UP
00230                         if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
00231                         {
00232                                 if( m_Layer != 1 ) // not layer NO.2
00233                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
00234                                 else               // layer NO.2 is special
00235                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
00236                         }
00237                         else
00238                         {
00239                                 if( m_Layer != 1 ) // not layer NO.2
00240                                         m_L = B_RPC_LTN;
00241                                 else               // layer NO.2 is special
00242                                         m_L = B_RPC_LTS;
00243                         }
00244                 }
00245                 else // top segment
00246                 {
00247                         if( m_RpcId < 2 ) // RPC NO.1 and NO.2
00248                         {
00249                                 m_L = B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ];
00250                         }                       
00251                         else if( (m_UpDown == SL_UP && m_RpcId == 4) || (m_UpDown == SL_DOWN && m_RpcId == 2) )
00252                         {
00253                                 m_L = B_BOX_LT - B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ] - 2*(B_BOX_DZ[m_UpDown]+B_RPC_LTN);
00254                         }
00255                         else
00256                                 m_L = B_RPC_LTN;
00257 
00258                 } // else, top segment  
00259 
00260                 m_L -= RPC_DEATH_EDGE * 2.0;    // cut rpc chamber death edge
00261 
00262         } // if, barrel 
00263         else // endcap
00264         {
00265                 m_L = BKLT_TH;
00266         }
00267 
00268 }

virtual void MucBakelite::SetLocOrgInBes (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetLocOrgInBes (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00535 {
00536         if( m_Part == BRID )
00537                 SetBarrelRpcInBes();
00538         else
00539                 SetEndcapRpcInBes();
00540 }

virtual void MucBakelite::SetObjOrgInBes (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetObjOrgInBes (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00562 {
00563         MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
00564 
00565         // limit cut
00566         for( int i=0; i<3; i++ ) {
00567                 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
00568         }
00569 }

virtual void MucBakelite::SetObjOrgInLoc (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetObjOrgInLoc (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00544 {
00545         if( m_Part == BRID )
00546         {
00547                 m_ObjOrgInLoc[0] = 0.;
00548 
00549                 m_ObjOrgInLoc[1] = (1-2*m_ID) * (BKLT_TH + GAS_TH)/2.0;
00550 
00551                 m_ObjOrgInLoc[2] = 0.;
00552         }
00553         else
00554         {
00555                 m_ObjOrgInLoc[0] = 0.;
00556                 m_ObjOrgInLoc[1] = 0.;
00557                 m_ObjOrgInLoc[2] = (1-2*m_ID) * (BKLT_TH + GAS_TH)/2.0;
00558         }
00559 }

virtual void MucEntity::SetObjRotToMot (   )  [protected, virtual, inherited]
 

Reimplemented in MucAbsorber, MucBox, MucGap, MucAbsorber, MucBox, and MucGap.

void MucEntity::SetObjRotToMot (   )  [protected, virtual, inherited]
 

Reimplemented in MucAbsorber, MucBox, MucGap, MucAbsorber, MucBox, and MucGap.

00215 { for( int i=0; i<3; i++) m_ObjRotToMot[i] = 0.; }

virtual void MucBakelite::SetPhi (   )  [protected, virtual]
 

void MucBakelite::SetPhi (   )  [protected, virtual]
  

00077 {
00078         if( m_Part == BRID )
00079                 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
00080         else
00081                 m_Phi = 0.;
00082 }

virtual void MucBakelite::SetRc (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetRc (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00125 {
00126         m_Rc = (m_Rin + m_Rout)/2.0;
00127 }

virtual void MucBakelite::SetRin (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetRin (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00105 {
00106         if( m_Part == BRID ) // Rin of bakelite
00107                 m_Rin = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0 
00108                         + (1-2*m_ID)*(GAS_TH + BKLT_TH)/2.0 - BKLT_TH/2.0;
00109         else    // Rin of RPC
00110                 m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
00111 }

virtual void MucBakelite::SetRout (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetRout (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00114 {
00115         if( m_Part == BRID ) // Rout of bakelite
00116                 m_Rout = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0
00117                          + (1-2*m_ID)*(GAS_TH + BKLT_TH)/2.0 + BKLT_TH/2.0;
00118         else
00119         {
00120                 m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
00121         }
00122 }

virtual void MucBakelite::SetTheta (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetTheta (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00085 {
00086         if( m_Part == BRID )
00087                 m_Theta = m_Segment * (MUC_PI/4.0);
00088         else
00089         {
00090                 if( m_UpDown == SL_UP )
00091                         m_Theta = ( MUC_PI/4.0 ) + (1 - m_RpcId) * MUC_PI / 8.0 ;
00092                 else
00093                 {
00094                         if( m_RpcId < 2 ) // RPC NO.1 and NO.2 
00095                                 m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
00096                         else if ( m_RpcId == 2 ) // center RPC, NO.3
00097                                 m_Theta = ( MUC_PI/4.0 ) ;
00098                         else
00099                                 m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
00100                 }
00101         }
00102 }

virtual void MucBakelite::SetThin (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetThin (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00130 {
00131         m_Thin = BKLT_TH;
00132 }

virtual void MucBakelite::SetW (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetW (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00135 {
00136         if( m_Part == BRID)
00137         {
00138                 if( m_Segment == B_TOP && m_RpcId < 2 )         // the first 2 RPCs in top segment
00139                 {
00140                         if( (m_Layer+1)%2 == 1 ) // odd layer
00141                                 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;
00142                         else                     // even layer
00143                                 m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
00144                 }       
00145                 else                                    // other RPCs
00146                 {
00147                         if( (m_Layer+1)%2 ==1 )  // odd layer
00148                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
00149                         else                     // even layer
00150                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
00151 
00152                 }       
00153         } // end barrel
00154         else
00155         {
00156                 if( m_UpDown == SL_UP ) // up layer
00157                 {       if( m_RpcId == 0 )
00158                                 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00159                         else if ( m_RpcId == 1 )
00160                                 m_W = 2 * VALUE * m_Rc;
00161                         else 
00162                                 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00163                 }
00164                 else // down layer
00165                 {       
00166                         switch( m_RpcId )
00167                         {
00168                                 case 0:
00169                                         m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
00170                                         break;
00171                                 case 1:
00172                                 case 3:
00173                                         m_W = VALUE * ( m_Rc - m_Rin );
00174                                         break;
00175                                 case 2:
00176                                         m_W = 2 * VALUE * m_Rin;
00177                                         break;
00178                                 case 4:
00179                                         m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA;     
00180                                         break;
00181                                 default: ;
00182                         }
00183                 }
00184                 
00185         } // else, endcap
00186 
00187         // cut rpc chamber death edge
00188         if( m_Part == BRID )
00189                 m_W -= RPC_DEATH_EDGE * 2.0;
00190         else
00191         {
00192                 if( m_UpDown == SL_UP )
00193                 {
00194                         if( m_RpcId == 1 ) m_W -= RPC_DEATH_EDGE * 2.0; // center rpc
00195                         else               m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00196                 }
00197                 else
00198                 {
00199                         if( m_RpcId == 2 ) // center rpc
00200                                 m_W -= RPC_DEATH_EDGE * 2.0;
00201                         else // DOWN 0,1,3,4 RPC
00202                                 m_W -= RPC_DEATH_EDGE;
00203                 }
00204         }
00205 }

virtual void MucBakelite::SetWd (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetWd (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00326 {
00327          if( m_Part == BRID )
00328                 m_Wd = m_W;
00329         else
00330         {
00331                 if( m_UpDown == SL_UP )
00332                 {
00333                         if( m_RpcId == 0 )
00334                                 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00335                         else if( m_RpcId == 1 )
00336                                 m_Wd = 2.0* VALUE * m_Rout;
00337                         else
00338                                 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00339                 }
00340                 else
00341                 {
00342                         switch( m_RpcId )
00343                         {
00344                                 case 0:
00345                                         m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
00346                                         break;
00347                                 case 1:
00348                                 case 3:
00349                                         m_Wd = VALUE * (m_Rout - m_Rin);
00350                                         break;
00351                                 case 2:
00352                                         m_Wd = 2.0 * VALUE * m_Rin;
00353                                         break;
00354                                 case 4:
00355                                         m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
00356                                         break;
00357                                 default: ;
00358                         }
00359                 }
00360 
00361                 // cut rpc chamber death edge
00362                 if( m_UpDown == SL_UP )
00363                 {
00364                         if( m_RpcId == 1 ) m_Wd -= RPC_DEATH_EDGE * 2.0; // center rpc
00365                         else            m_Wd -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00366                 }
00367                 else
00368                 {
00369                         if( m_RpcId == 2 ) // center rpc
00370                                m_Wd -= RPC_DEATH_EDGE * 2.0;
00371                         else // DOWN 0,4 RPC
00372                                m_Wd -= RPC_DEATH_EDGE;
00373                 }
00374 
00375         } // else, endcap       
00376 }

virtual void MucBakelite::SetWu (   )  [protected, virtual]
 

Reimplemented from MucEntity.

void MucBakelite::SetWu (   )  [protected, virtual]
 

Reimplemented from MucEntity.

00271 {
00272         if( m_Part == BRID )
00273                 m_Wu = m_W;
00274         else
00275         {       
00276                 if( m_UpDown == SL_UP )
00277                 {
00278                         if( m_RpcId == 0 )
00279                                 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00280                         else if( m_RpcId == 1 )
00281                                 m_Wu = 2.0* VALUE * m_Rin;
00282                         else 
00283                                 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00284                 }
00285                 else
00286                 {
00287                         switch( m_RpcId )
00288                         {
00289                                 case 0:
00290                                         m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
00291                                         break;
00292                                 case 1:
00293                                 case 3:
00294                                         m_Wu = 0.0;             
00295                                         break;
00296                                 case 2:
00297                                         m_Wu = 2.0* VALUE * m_Rin;
00298                                         break;
00299                                 case 4:
00300                                         m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;
00301                                         break;
00302                                 default: ;
00303                         }
00304                 }
00305 
00306                 // cut rpc chamber death edge
00307                 if( m_Wu > 0.0 )
00308                 {
00309                         if( m_UpDown == SL_UP )
00310                         {
00311                                 if( m_RpcId == 1 ) m_Wu -= RPC_DEATH_EDGE * 2.0; // center rpc
00312                                 else            m_Wu -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00313                         }
00314                         else
00315                         {
00316                                 if( m_RpcId == 2 ) // center rpc
00317                                         m_Wu -= RPC_DEATH_EDGE * 2.0;
00318                                 else // DOWN 0,4 RPC
00319                                         m_W -= RPC_DEATH_EDGE;
00320                         }
00321                 }
00322         } // else, endcap
00323 }

void MucEntity::TransBesToLoc (  double  LocCoord[],
double  BesCoord[],
double  LocOrgInBes[],
double  Rot_z
)  [inherited]
 

void MucEntity::TransBesToLoc (  double  LocCoord[],
double  BesCoord[],
double  LocOrgInBes[],
double  Rot_z
)  [inherited]
  

00224 {
00225        LocCoord[0] = (BesCoord[0] - LocOrgInBes[0])*cos(Rot_z) + (BesCoord[1] - LocOrgInBes[1])*sin(Rot_z);
00226        LocCoord[1] = -(BesCoord[0] - LocOrgInBes[0])*sin(Rot_z) + (BesCoord[1] - LocOrgInBes[1])*cos(Rot_z);
00227        LocCoord[2] = BesCoord[2] - LocOrgInBes[2];
00228 }

void MucEntity::TransLocToBes (  double  LocCoord[],
double  BesCoord[],
double  LocOrgInBes[],
double  Rot_z
)  [inherited]
 

void MucEntity::TransLocToBes (  double  LocCoord[],
double  BesCoord[],
double  LocOrgInBes[],
double  Rot_z
)  [inherited]
  

00233 {
00234         BesCoord[0] = LocCoord[0]*cos(Rot_z) - LocCoord[1]*sin(Rot_z) + LocOrgInBes[0];
00235         BesCoord[1] = LocCoord[0]*sin(Rot_z) + LocCoord[1]*cos(Rot_z) + LocOrgInBes[1];
00236         BesCoord[2] = LocCoord[2] + LocOrgInBes[2];
00237 }

Member Data Documentation

double MucEntity::m_Area [protected, inherited]
 

double MucEntity::m_H [protected, inherited]
 

int MucEntity::m_ID [protected, inherited]
 

double MucEntity::m_L [protected, inherited]
 

int MucEntity::m_Layer [protected, inherited]
 

double MucEntity::m_LocOrgInBes [protected, inherited]
 

double MucEntity::m_ObjOrgInBes [protected, inherited]
 

double MucEntity::m_ObjOrgInLoc [protected, inherited]
 

double MucEntity::m_ObjRotToMot [protected, inherited]
 

int MucEntity::m_Part [protected, inherited]
 

double MucBakelite::m_Phi [private]
 

double MucEntity::m_Rc [protected, inherited]
 

double MucEntity::m_Rin [protected, inherited]
 

double MucEntity::m_Rout [protected, inherited]
 

int MucEntity::m_RpcId [protected, inherited]
 

int MucEntity::m_Segment [protected, inherited]
 

double MucEntity::m_Theta [protected, inherited]
 

double MucEntity::m_Thin [protected, inherited]
 

int MucEntity::m_UpDown [protected, inherited]
 

double MucEntity::m_W [protected, inherited]
 

double MucEntity::m_Wd [protected, inherited]
 

double MucEntity::m_Wu [protected, inherited]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:32:43 2011 for BOSS6.5.5 by  doxygen 1.3.9.1