BOSS_7.0.2: /home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Muc/MucGeoCreateAlg/MucGeoCreateAlg-00-01-00/src/MucRpc.cxx Source File

00001 //------------------------------------------------------------------------------|
00002 //      [File  ]:                       MucRpc.cxx                              |
00003 //      [Brief ]:       MUC geometry RPC creating class                         |
00004 //      [Author]:       Xie Yuguang, <ygxie@mail.ihep.ac.cn>                    |
00005 //      [Date  ]:       May 22, 2005                                            |
00006 //------------------------------------------------------------------------------|
00007 
00008 #include <iostream>
00009 #include <cmath>
00010 
00011 #include "MucGeoCreateAlg/MucGeoConst.h"
00012 #include "MucGeoCreateAlg/MucRpc.h"
00013 
00014 using namespace std;
00015 
00016 // Constructor
00017 MucRpc::MucRpc( int part, int segment, int layer, int upDown, int id ) : MucEntity( part, segment, layer, upDown, id )
00018 {
00019         MucRpc::Init();
00020 
00021         m_MucGas        = NULL;
00022         m_MucBakelite   = NULL;
00023 }
00024 
00025 // Copy constructor             
00026 MucRpc::MucRpc( const MucRpc &other ) : MucEntity( other )
00027 {
00028         m_Phi           = other.m_Phi;
00029         m_MucGas        = other.m_MucGas;
00030         m_MucBakelite   = other.m_MucBakelite;
00031 }
00032 
00033 // Operator =
00034 MucRpc& MucRpc::operator =( const MucRpc &other )
00035 {
00036         if( this == &other)
00037                 return *this;
00038 
00039         MucEntity::operator =(other);
00040 
00041         m_Phi           = other.m_Phi;  
00042         m_MucGas        = other.m_MucGas;
00043         m_MucBakelite   = other.m_MucBakelite;
00044 
00045         return *this;   
00046 }
00047 
00048 // Destructor
00049 MucRpc::~MucRpc()
00050 {       
00051         delete m_MucGas;
00052         delete m_MucBakelite;
00053 }
00054 
00055 // Initialize
00056 void MucRpc::Init()
00057 {
00058         SetPhi();
00059         SetTheta();
00060         SetRin();
00061         SetRout();
00062         SetRc();
00063 
00064         SetThin();
00065         SetW();
00066         SetWu();
00067         SetWd();
00068         SetH();
00069         SetL();
00070         
00071         SetEndcapRpcInBes();
00072         SetBarrelRpcInLoc();
00073 
00074         SetLocOrgInBes();
00075         SetObjOrgInBes();
00076         SetObjOrgInLoc();
00077 }
00078                 
00079 // -------------------------- Get methods ----------------------------
00080 double MucRpc::GetPhi() {       return m_Phi;   }
00081 
00082 MucGas* MucRpc::GetGas()
00083 {
00084         if( m_MucGas != NULL )  delete m_MucGas;
00085 
00086         return ( m_MucGas = new MucGas( m_Part, m_Segment, m_Layer, m_UpDown, m_ID, 0 ) );
00087 }
00088 
00089 MucBakelite* MucRpc::GetBakelite( int id )
00090 {
00091         if( m_MucBakelite != NULL )  delete m_MucBakelite;
00092 
00093         return ( m_MucBakelite = new MucBakelite( m_Part, m_Segment, m_Layer, m_UpDown, m_RpcId, id ) );
00094 }
00095 
00096 
00097 // ---------------------------Set motheds -----------------------------
00098 
00099 void MucRpc::SetPhi()
00100 {
00101         if( m_Part == BRID )
00102                 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
00103         else
00104                 m_Phi = 0.;
00105 }
00106 
00107 
00108 void MucRpc::SetTheta()
00109 {
00110         if( m_Part == BRID )
00111                 m_Theta = m_Segment * ( MUC_PI/4.0 );
00112         else
00113         {
00114                 if( m_UpDown == SL_UP )
00115                 {
00116                         m_Theta = ( MUC_PI/4.0 ) + ( 1 - m_ID ) * MUC_PI / 8.0 ;
00117                 }
00118                 else
00119                 {       
00120                         if( m_ID < 2 ) // RPC NO.1 and NO.2
00121                                 m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
00122                         else if ( m_ID == 2 ) // center RPC, NO.3
00123                                 m_Theta = ( MUC_PI/4.0 ) ;
00124                         else    
00125                                 m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
00126                 }
00127         }
00128 }
00129 
00130 void MucRpc::SetRin()
00131 {
00132         if( m_Part == BRID )
00133                 m_Rin = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown ) * (STR_TH / 2.0 + m_UpDown*RPC_TH);
00134         else
00135                 m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
00136 }
00137 
00138 void MucRpc::SetRout()
00139 {
00140         if( m_Part == BRID )
00141                 m_Rout = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown )*( STR_TH / 2.0 + (1-m_UpDown)*RPC_TH );
00142         else
00143                 m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
00144 }
00145 
00146 void MucRpc::SetRc()
00147 {
00148         m_Rc = (m_Rin + m_Rout)/2.0;
00149 }
00150 
00151 void MucRpc::SetThin()
00152 {
00153         m_Thin = RPC_TH;
00154 }
00155 
00156 void MucRpc::SetW()
00157 {
00158         if( m_Part == BRID)
00159         {
00160                 if( m_Segment == B_TOP && m_ID < 2 )    // the first 2 RPCs in top segment
00161                 {
00162                         if( (m_Layer+1)%2 == 1 ) // odd layer
00163                                 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;
00164                         else                     // even layer
00165                                 m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
00166                 }       
00167                 else                                    // other RPCs
00168                 {
00169                         if( (m_Layer+1)%2 ==1 )  // odd layer
00170                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
00171                         else                     // even layer
00172                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
00173 
00174                 }       
00175         } // end barrel
00176         else
00177         {
00178                 if( m_UpDown == SL_UP ) // up super layer RPCs
00179                 {
00180                         if( m_ID == 0 )
00181                                 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00182                         else if( m_ID == 1 )
00183                                 m_W = VALUE * m_Rc * 2.0;
00184                         else
00185                                 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00186                 }
00187                 else // down super layer RPCs
00188                 {
00189                         if( m_ID == 0 )
00190                                 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
00191                         else if( m_ID == 1 || m_ID == 3 )       
00192                                 m_W = VALUE * (m_Rc - m_Rin);
00193                         else if( m_ID == 2 )
00194                                 m_W = VALUE * m_Rin * 2.0;
00195                         else 
00196                                 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA; 
00197                 }
00198                 
00199         } // else, endcap
00200         
00201         // cut rpc chamber death edge
00202         if( m_Part == BRID )
00203                 m_W -= OVERLAP_WIDTH * 2.0;
00204         else
00205         {
00206                 if( m_UpDown == SL_UP )
00207                 {
00208                         if( m_ID == 1 ) m_W -= OVERLAP_WIDTH * 2.0; // center rpc
00209                         else            m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * OVERLAP_WIDTH;
00210                 }
00211                 else
00212                 {
00213                         if( m_ID == 2 ) // center rpc
00214                                 m_W -= OVERLAP_WIDTH * 2.0;     
00215                         else // DOWN 0,1,3,4 RPC
00216                                 m_W -= OVERLAP_WIDTH;
00217                 }
00218         }
00219 }
00220 
00221 void MucRpc::SetH()
00222 {
00223         if( m_Part == BRID )
00224                 m_H = RPC_TH;
00225         else
00226         {
00227                 m_H = m_Rout - m_Rin;
00228         }
00229 }
00230 
00231 void MucRpc::SetL()
00232 {
00233         if( m_Part == BRID ) // barrel
00234         {
00235                 if( m_Segment != B_TOP ) // not top segment
00236                 {
00237                         if( (m_UpDown == SL_UP && m_ID == 3 ) || (m_UpDown == SL_DOWN && m_ID == 0 ) )
00238                         {
00239                                 if( m_Layer != 1 ) // not layer NO. 2
00240                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
00241                                 else
00242                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
00243                         }
00244                         else
00245                         {
00246                                 if( m_Layer != 1 ) // not layer NO. 2
00247                                         m_L = B_RPC_LTN;
00248                                 else
00249                                         m_L = B_RPC_LTS;                        
00250                         }
00251                 }
00252                 else // top segment
00253                 {
00254                         if( m_ID < 2 ) // first two RPCs
00255                         {
00256                                 if( m_Layer == 0 ) // the first layer
00257                                         m_L = B_TOPRPC_LTS[1];
00258                                 else
00259                                         m_L = B_TOPRPC_LTS[m_Layer%2];
00260                         }
00261                         else if( (m_UpDown == SL_UP && m_ID == 4 ) || (m_UpDown == SL_DOWN && m_ID == 2 ) )
00262                         {
00263                                 if( m_Layer == 0 ) // the first layer
00264                                         m_L = B_BOX_LT - B_TOPRPC_LTS[1] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
00265                                 else
00266                                         m_L = B_BOX_LT - B_TOPRPC_LTS[m_Layer%2] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);               
00267                         }
00268                         else
00269                         {
00270                                 m_L = B_TOPRPC_LTN;
00271                         }
00272                 } // end top segment
00273 
00274                 m_L -= OVERLAP_WIDTH * 2.0; // cut rpc chamber death edge
00275 
00276         } // end barrel
00277         else
00278         {
00279                 m_L = RPC_TH;
00280         }
00281 }
00282 
00283 void MucRpc::SetWu()
00284 {
00285         if( m_Part == BRID )
00286                 m_Wu = m_W;
00287         else
00288         {
00289                 if( m_UpDown == SL_UP )
00290                 {
00291                         if( m_ID == 0 )
00292                                 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00293                         else if( m_ID == 1 )
00294                                 m_Wu = VALUE * m_Rin * 2.0;
00295                         else 
00296                                 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00297                 }
00298                 else
00299                 {
00300                         if( m_ID == 0 )
00301                                 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
00302                         else if( m_ID == 1 || m_ID == 3 )
00303                                 m_Wu = 0.;
00304                         else if( m_ID == 2 )
00305                                 m_Wu = VALUE * m_Rin * 2.0;
00306                         else
00307                                 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;                   
00308                 }
00309 
00310                 // cut rpc chamber death edge
00311                 if( m_Wu > 0.0 ) // except for DOWN 1, 3 RPC 
00312                 {
00313                         if( m_UpDown == SL_UP )
00314                         {
00315                                 if( m_ID == 1 ) m_Wu += 2.0*OVERLAP_WIDTH *(sin(BETA)-1)/cos(BETA); // center rpc
00316                                 else            m_Wu -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
00317                         }
00318                         else
00319                         {
00320                                 m_Wu -= 1.5*OVERLAP_WIDTH;
00321                         }
00322                 }
00323         }
00324 }
00325  
00326 void MucRpc::SetWd()
00327 {
00328          if( m_Part == BRID )
00329                 m_Wd = m_W;
00330         else
00331         {       
00332                 if( m_UpDown == SL_UP )
00333                 {
00334                         if( m_ID == 0 )
00335                                 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00336                         else if( m_ID == 1 )
00337                                 m_Wd = VALUE * m_Rout * 2.0;
00338                         else
00339                                 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00340                 }
00341                 else
00342                 {
00343                         switch( m_ID )
00344                         {
00345                                 case 0:
00346                                         m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
00347                                         break;
00348                                 case 1:
00349                                 case 3:
00350                                         m_Wd = VALUE * ( m_Rout - m_Rin );
00351                                         break;
00352                                 case 2:
00353                                         m_Wd = 2 * VALUE * m_Rin;
00354                                         break;
00355                                 case 4:
00356                                         m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
00357                                         break;
00358                                 default: ;
00359                         }
00360                 }
00361         
00362                 // cut rpc chamber death edge
00363                 if( m_UpDown == SL_UP )
00364                 {
00365                         if( m_ID == 1 ) m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)+1)/cos(BETA); // center rpc
00366                         else            m_Wd -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
00367                 }
00368                 else
00369                 {
00370                         if( m_ID ==0 || m_ID == 4 )
00371                               // m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)-1)/cos(BETA);
00372                          m_Wd -= 1.5*OVERLAP_WIDTH;
00373                 }
00374         }
00375 }
00376 
00377 int MucRpc::SetEndcapRpcInBes()
00378 {
00379         if( m_Part == BRID )
00380                 return 0;
00381         else
00382         {
00383                 double x, y, z;
00384                 x = y = z = 0.;
00385 
00386                 // -----------------set x and y -----------------
00387                 if( m_UpDown == SL_UP ) // up super layer
00388                 {
00389                         if( m_ID == 0 )
00390                         {
00391                                 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
00392                                 y = m_Rc;  
00393                         }
00394                         else if( m_ID == 1 )
00395                         {
00396                                 x = m_Rc * cos( m_Theta );
00397                                 y = m_Rc * sin( m_Theta );
00398                         }
00399                         else
00400                         {
00401                                 x = m_Rc;
00402                                 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0; 
00403                         }
00404                 }
00405                 else    // down super layer
00406                 {
00407                         if( m_ID == 0 )
00408                         {
00409                                 x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
00410                                 y = m_Rc; 
00411                         }
00412                         else if( m_ID == 1 )
00413                         {
00414                                 x = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00415                 //              x += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
00416 
00417                                 y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00418                 //              y += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
00419                         }
00420                         else if( m_ID == 2 )
00421                         {
00422                                 x = m_Rc * cos( MUC_PI/4.0 );
00423                                 y = m_Rc * sin( MUC_PI/4.0 );
00424                         }
00425                         else if( m_ID == 3 )
00426                         {
00427                                 x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00428                 //              x += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
00429 
00430                                 y = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00431                 //              y += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
00432                         }
00433                         else
00434                         {
00435                                 x = m_Rc;
00436                                 y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
00437                         }
00438                 }
00439 
00440                 // x, y signs of coordinate different by segment 
00441                 if( m_Segment == 0 )       {    ;               }
00442                 else if ( m_Segment == 1 ) {    x = -x;         }
00443                 else if ( m_Segment == 2 ) {    x = -x; y = -y; }
00444                 else                       {    y = -y;         }
00445 
00446                 //-------------- set z -----------------------------
00447                 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
00448 
00449                 z += m_Layer * AS_GAP;
00450                 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
00451                 z += (1-2*m_UpDown) * (RPC_TH + STR_TH)/2.0 ;
00452                 z *= cos( m_Part*MUC_PI/2.0 );
00453                 
00454                 m_ObjOrgInBes[0] = x;
00455                 m_ObjOrgInBes[1] = y;
00456                 m_ObjOrgInBes[2] = z;
00457 
00458                 // limit cut
00459                 for(int i=0;i<3;i++) {
00460                         if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
00461                 }
00462 
00463         } // else, endcap
00464 
00465         return 0;
00466 }
00467 
00468 int MucRpc::SetBarrelRpcInLoc()
00469 {
00470         if( m_Part != BRID )
00471                 return 0;
00472         else
00473         {
00474                 double x, y, z;
00475                 x = y = z = 0.;
00476 
00477                 if( m_Segment != B_TOP ) // not top segment
00478                 {
00479                         //---------- set x--------
00480                         x = 0.;
00481 
00482                         //---------- set y--------
00483                         y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
00484 
00485                         //---------- set z--------
00486                         if( (m_UpDown == SL_UP && m_ID == 3) || (m_UpDown == SL_DOWN && m_ID == 0) )
00487                         {
00488                                 if( m_Layer != 1 ) // not layer NO.2
00489                                         z = (2*m_UpDown - 1) * 3 * B_RPC_LTN / 2.0;
00490                                 else
00491                                         z = (2*m_UpDown - 1) * 3 * B_RPC_LTS / 2.0; 
00492                         }
00493                         else 
00494                         {       
00495                                 if( m_Layer != 1) // not layer NO.2
00496                                 {
00497                                         if( m_UpDown == SL_UP )
00498                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTN/2.0;
00499                                         else
00500                                                 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTN/2.0;
00501                                 }
00502                                 else
00503                                 {
00504                                         if( m_UpDown == SL_UP )
00505                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTS/2.0;
00506                                         else
00507                                                 z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTS/2.0;  
00508                                 }
00509                         }
00510                 }
00511                 else // top segment
00512                 {
00513                         //---------- set x--------
00514                         if( m_ID > 1 )
00515                                 x = 0.;
00516                         else
00517                                 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 ); 
00518 
00519                         //---------- set y--------
00520                         y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
00521 
00522                         //---------- set z--------
00523                         if( m_UpDown == SL_UP )
00524                         {
00525                                 switch( m_ID )
00526                                 {
00527                                  case 0:
00528                                  case 1:
00529                                         if( m_Layer == 0 )
00530                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
00531                                         else
00532                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
00533                                         break;
00534                                  case 2:
00535                                  case 3:
00536                                         if( m_Layer == 0 )
00537                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1] +  (3-2*m_ID)*B_RPC_LTN/2.0;
00538                                         else
00539                                                 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;                     
00540                                         break;
00541                                  case 4:
00542                                         if( m_Layer == 0 )
00543                                                 z = -B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
00544                                         else
00545                                                 z = -B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
00546                                         break;
00547                                  default: ;
00548                                 }
00549                         }else // down super layer
00550                         {
00551                                 switch( m_ID )
00552                                 {
00553                                  case 0: ;
00554                                  case 1:
00555                                         if( m_Layer == 0 )
00556                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
00557                                         else
00558                                                 z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
00559                                         break;
00560                                  case 2:
00561                                         if( m_Layer == 0 )
00562                                                 z = B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
00563                                         else
00564                                                 z = B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
00565                                         break;
00566                                  case 3:
00567                                  case 4:
00568                                         z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(4-m_ID))*B_RPC_LTN/2.0;
00569                                         break;
00570                                  default: ;
00571                                 }
00572                         } // else, down super layer
00573                 } // else, top segment
00574 
00575                 m_ObjOrgInLoc[0] = x;
00576                 m_ObjOrgInLoc[1] = y;
00577                 m_ObjOrgInLoc[2] = z;
00578 
00579                 // limit cut
00580                 for(int i=0;i<3;i++) {
00581                         if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
00582                 }
00583 
00584         } // else, barrel
00585         
00586         return 0;
00587 }
00588 
00589 // Set local( box ) in BES CS
00590 void MucRpc::SetLocOrgInBes()
00591 {
00592         double x, y, z;
00593         x = y = z = 0.;
00594 
00595         if( m_Part == BRID )
00596         {
00597                 x = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * cos( m_Theta );
00598                 y = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * sin( m_Theta );
00599                 z = 0.;
00600 
00601         } // barrel
00602         else
00603         {
00604                 //-------------- set x and y ----------------------
00605                 // segment 0 as reference
00606                 x = (E_AS_RMAX - E_BOX_DR + E_GP_DX) / 2.0;
00607                 y = (E_AS_RMAX - E_BOX_DR + E_GP_DY) / 2.0;                     
00608                 
00609                 // x, y signs of coordinate different by segment 
00610                 if( m_Segment == 0 )       {    ;               }
00611                 else if ( m_Segment == 1 ) {    x = -x;         }
00612                 else if ( m_Segment == 2 ) {    x = -x; y = -y; }
00613                 else                       {    y = -y;         }
00614 
00615                 //-------------- set z -----------------------------
00616                 for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i];
00617 
00618                 z += m_Layer * AS_GAP;
00619                 z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );
00620                 z *= cos( m_Part*MUC_PI/2.0 );
00621 
00622         }// endcap
00623 
00624         m_LocOrgInBes[0] = x;
00625         m_LocOrgInBes[1] = y;
00626         m_LocOrgInBes[2] = z;
00627 
00628         // limit cut
00629         for(int i=0;i<3;i++) {
00630                 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
00631         }
00632 }
00633 
00634 void MucRpc::SetObjOrgInBes()
00635 {
00636         if( m_Part == BRID )
00637         {
00638                 MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
00639 
00640                 // limit cut
00641                 for(int i=0;i<3;i++) {
00642                         if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
00643                 }
00644         }
00645 }
00646 
00647 void MucRpc::SetObjOrgInLoc()
00648 {
00649         if( m_Part != BRID )
00650         {
00651                 MucEntity::TransBesToLoc( m_ObjOrgInLoc, m_ObjOrgInBes, m_LocOrgInBes, m_Phi );
00652                 // limit cut
00653                 for(int i=0;i<3;i++) {
00654                         if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
00655                 }
00656         }
00657 }
00658 
00659 /*
00660 void MucRpc::SetAlignment( double dx, double dy, double dz )
00661 {
00662         
00663         if( m_Part == BRID || m_ID == -1 )
00664         {
00665                 m_ObjOrgInLoc[0] += dx;
00666                 m_ObjOrgInLoc[1] += dy;
00667                 m_ObjOrgInLoc[2] += dz;
00668         }
00669 }
00670 */
00671 
00672 // END