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

00001 //------------------------------------------------------------------------------|
00002 //      [File  ]:                       MucGas.cxx                              |
00003 //      [Brief ]:       MUC geometry mixture gas 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/MucGas.h"
00013 
00014 using namespace std;
00015 
00016 // Constructor
00017 MucGas::MucGas( int part, int segment, int layer, int upDown, int rpcId, int id ) 
00018         : MucEntity( part, segment, layer, upDown, rpcId, id )
00019 {
00020         MucGas::Init();
00021 }
00022 
00023 // Copy constructor             
00024 MucGas::MucGas( const MucGas &other ) : MucEntity( other )
00025 {
00026         m_Phi           = other.m_Phi;
00027 }
00028 
00029 // Operator =
00030 MucGas& MucGas::operator =( const MucGas &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 }
00041 
00042 // Destructor
00043 MucGas::~MucGas()
00044 {       
00045         ;
00046 }
00047 
00048 // Initialize
00049 void MucGas::Init()
00050 {
00051         SetPhi();
00052         SetTheta();
00053         SetRin();
00054         SetRout();
00055         SetRc();
00056 
00057         SetThin();
00058         SetW();
00059         SetWu();
00060         SetWd();
00061         SetH();
00062         SetL();
00063 
00064         SetEndcapRpcInBes();
00065         SetBarrelRpcInBes();
00066 
00067         SetLocOrgInBes();
00068         SetObjOrgInBes();
00069         SetObjOrgInLoc();
00070 }
00071                 
00072 // -------------------------- Get methods ----------------------------
00073 
00074 double MucGas::GetPhi()         {        return m_Phi;          }
00075 
00076 // ---------------------------Set motheds -----------------------------
00077 
00078 // Set inclination angle of local coordinate x axis and global coordinate x axis
00079 void MucGas::SetPhi()
00080 {
00081         if( m_Part == BRID )
00082                 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
00083         else
00084                 m_Phi = 0.;
00085 }
00086 
00087 void MucGas::SetTheta()
00088 {
00089         if( m_Part == BRID )
00090                 m_Theta = m_Segment * (MUC_PI/4.0);
00091         else
00092         {
00093                 if( m_UpDown == SL_UP )
00094                         m_Theta = ( MUC_PI/4.0 ) + (1 - m_RpcId) * MUC_PI / 8.0 ;
00095                 else
00096                 {
00097                         if( m_RpcId < 2 ) // RPC NO.1 and NO.2 
00098                                 m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
00099                         else if ( m_RpcId == 2 ) // center RPC, NO.3
00100                                 m_Theta = ( MUC_PI/4.0 ) ;
00101                         else
00102                                 m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
00103                 }
00104         }
00105 }
00106 
00107 
00108 void MucGas::SetRin()
00109 {
00110 
00111         if( m_Part == BRID ) // Rin of gas( same as which of RPC )
00112                 m_Rin = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0 - GAS_TH/2.0;
00113         else  // Rin of RPC
00114                 m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
00115 }
00116 
00117 void MucGas::SetRout()
00118 {
00119         if( m_Part == BRID )
00120                 m_Rout = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0 + GAS_TH/2.0;
00121         else
00122                 m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
00123 }
00124 
00125 void MucGas::SetRc()
00126 {
00127         m_Rc = (m_Rin + m_Rout)/2.0;
00128 }
00129 
00130 
00131 void MucGas::SetThin()
00132 {
00133         m_Thin = GAS_TH;
00134 }
00135 
00136 void MucGas::SetW()
00137 {
00138         if( m_Part == BRID)
00139         {
00140                 if( m_Segment == B_TOP && m_RpcId < 2 )         // the first 2 gases in top segment
00141                 {
00142                         if( (m_Layer+1)%2 == 1 ) // odd layer
00143                                 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;
00144                         else                     // even layer
00145                                 m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
00146                 }       
00147                 else                                    // other gases
00148                 {
00149                         if( (m_Layer+1)%2 ==1 )  // odd layer
00150                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
00151                         else                     // even layer
00152                                 m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
00153 
00154                 }       
00155         } // end barrel
00156         else
00157         {
00158                 if( m_UpDown == SL_UP ) // up layer
00159                 {       if( m_RpcId == 0 )
00160                                 m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00161                         else if ( m_RpcId == 1 )
00162                                 m_W = 2 * VALUE * m_Rc;
00163                         else 
00164                                 m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00165                 }
00166                 else // down layer
00167                 {       
00168                         switch( m_RpcId )
00169                         {
00170                                 case 0:
00171                                         m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
00172                                         break;
00173                                 case 1:
00174                                 case 3:
00175                                         m_W = VALUE * ( m_Rc - m_Rin );
00176                                         break;
00177                                 case 2:
00178                                         m_W = 2 * VALUE * m_Rin;
00179                                         break;
00180                                 case 4:
00181                                         m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA;     
00182                                         break;
00183                                 default: ;
00184                         }
00185                 }
00186                 
00187         } // else, endcap
00188 
00189         // cut rpc chamber death edge
00190         if( m_Part == BRID )
00191                 m_W -= RPC_DEATH_EDGE * 2.0;
00192         else
00193         {
00194                 if( m_UpDown == SL_UP )
00195                 {
00196                         if( m_RpcId == 1 ) m_W -= RPC_DEATH_EDGE * 2.0; // center rpc
00197                         else            m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00198                 }
00199                 else
00200                 {
00201                         if( m_RpcId == 2 ) // center rpc
00202                                 m_W -= RPC_DEATH_EDGE * 2.0;
00203                         else // DOWN 0,1,3,4 RPC
00204                                 m_W -= RPC_DEATH_EDGE;
00205                 }
00206         }
00207 }
00208 
00209 void MucGas::SetH()
00210 {
00211         if( m_Part == BRID )
00212                 m_H = GAS_TH;
00213         else
00214         {
00215                 m_H = m_Rout - m_Rin;
00216 
00217                 // cut rpc chamber death edge
00218                 if( m_UpDown == SL_DOWN && (m_ID == 1 || m_ID == 3) )
00219                         m_H -= RPC_DEATH_EDGE * (1 + 1.0/VALUE);
00220                 else
00221                         m_H -= RPC_DEATH_EDGE * 2.0;
00222         }
00223 }
00224 
00225 void MucGas::SetL()
00226 {
00227         if( m_Part == BRID ) // barrel
00228         {
00229                 if( m_Segment != B_TOP ) // not top segment
00230                 {
00231                         // the first rpc of SL_DOWN is constructed as the same as the last rpc of SL_UP
00232                         if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
00233                         {
00234                                 if( m_Layer != 1 ) // not layer NO.2
00235                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
00236                                 else               // layer NO.2 is special
00237                                         m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
00238                         }
00239                         else
00240                         {
00241                                 if( m_Layer != 1 ) // not layer NO.2
00242                                         m_L = B_RPC_LTN;
00243                                 else               // layer NO.2 is special
00244                                         m_L = B_RPC_LTS;
00245                         }
00246                 }
00247                 else // top segment
00248                 {
00249                         if( m_RpcId < 2 ) // RPC NO.1 and NO.2
00250                         {
00251                                 m_L = B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ];
00252                         }                       
00253                         else if( (m_UpDown == SL_UP && m_RpcId == 4) || (m_UpDown == SL_DOWN && m_RpcId == 2) )
00254                         {
00255                                 m_L = B_BOX_LT - B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ] - 2*(B_BOX_DZ[m_UpDown]+B_RPC_LTN);
00256                         }
00257                         else
00258                                 m_L = B_RPC_LTN;
00259 
00260                 } // else, top segment  
00261 
00262                 m_L -= RPC_DEATH_EDGE * 2.0;    // cut rpc chamber death edge
00263 
00264         } // if, barrel 
00265         else // endcap
00266         {
00267                 m_L = GAS_TH;
00268         }
00269 
00270 }
00271 
00272 void MucGas::SetWu()
00273 {
00274         if( m_Part == BRID )
00275                 m_Wu = m_W;
00276         else
00277         {       
00278                 if( m_UpDown == SL_UP )
00279                 {
00280                         if( m_RpcId == 0 )
00281                                 m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00282                         else if( m_RpcId == 1 )
00283                                 m_Wu = 2.0* VALUE * m_Rin;
00284                         else 
00285                                 m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00286                 }
00287                 else
00288                 {
00289                         switch( m_RpcId )
00290                         {
00291                                 case 0:
00292                                         m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
00293                                         break;
00294                                 case 1:
00295                                 case 3:
00296                                         m_Wu = 0.;              
00297                                         break;
00298                                 case 2:
00299                                         m_Wu = 2.0* VALUE * m_Rin;
00300                                         break;
00301                                 case 4:
00302                                         m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;
00303                                         break;
00304                                 default: ;
00305                         }
00306                 }
00307 
00308                 // cut rpc chamber death edge
00309                 if( m_Wu > 0.0 )
00310                 {
00311                         if( m_UpDown == SL_UP )
00312                         {
00313                                 if( m_RpcId == 1 ) m_Wu -= RPC_DEATH_EDGE * 2.0; // center rpc
00314                                 else            m_Wu -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00315                         }
00316                         else
00317                         {
00318                                 if( m_RpcId == 2 ) // center rpc
00319                                         m_Wu -= RPC_DEATH_EDGE * 2.0;
00320                                 else // DOWN 0,4 RPC
00321                                         m_W -= RPC_DEATH_EDGE;
00322                         }
00323                 }
00324         } // else, endcap
00325 }
00326 
00327 void MucGas::SetWd()
00328 {
00329          if( m_Part == BRID )
00330                 m_Wd = m_W;
00331         else
00332         {
00333                 if( m_UpDown == SL_UP )
00334                 {
00335                         if( m_RpcId == 0 )
00336                                 m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
00337                         else if( m_RpcId == 1 )
00338                                 m_Wd = 2.0* VALUE * m_Rout;
00339                         else
00340                                 m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
00341                 }
00342                 else
00343                 {
00344                         switch( m_RpcId )
00345                         {
00346                                 case 0:
00347                                         m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
00348                                         break;
00349                                 case 1:
00350                                 case 3:
00351                                         m_Wd = VALUE * (m_Rout - m_Rin);
00352                                         break;
00353                                 case 2:
00354                                         m_Wd = 2.0 * VALUE * m_Rin;
00355                                         break;
00356                                 case 4:
00357                                         m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
00358                                         break;
00359                                 default: ;
00360                         }
00361                 }
00362 
00363                 // cut rpc chamber death edge
00364                 if( m_UpDown == SL_UP )
00365                 {
00366                         if( m_RpcId == 1 ) m_Wd -= RPC_DEATH_EDGE * 2.0; // center rpc
00367                         else            m_Wd -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
00368                 }
00369                 else
00370                 {
00371                         if( m_RpcId == 2 ) // center rpc
00372                                m_Wd -= RPC_DEATH_EDGE * 2.0;
00373                         else // DOWN 0,4 RPC
00374                                m_Wd -= RPC_DEATH_EDGE;
00375                 }
00376 
00377         } // else, endcap
00378 }
00379 
00380 
00381 // Set barrel rpc in BES CS
00382 int MucGas::SetBarrelRpcInBes()
00383 {
00384         if( m_Part != BRID ) return 0;
00385 
00386         double x, y, z;
00387         x = y = z = 0.;
00388 
00389         if( m_Segment != B_TOP )
00390         {
00391                 // set x and y
00392                 double r;
00393                 r = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
00394                 x = r * cos( m_Theta );
00395                 y = r * sin( m_Theta );
00396 
00397                 // set z
00398                 if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
00399                 {
00400                         if( m_Layer != 1 ) // not layer NO.2
00401                                 z = (2*m_UpDown - 1) * 3 * B_RPC_LTN/2.0;
00402                         else
00403                                 z = (2*m_UpDown - 1) * 3 * B_RPC_LTS/2.0;
00404                 }
00405                 else if( m_UpDown == SL_UP )
00406                         z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_RpcId)*B_RPC_LTN/2.0;
00407                 else
00408                         z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_RpcId))*B_RPC_LTN/2.0;
00409 
00410         } // end not top segment
00411         else // top segment
00412         {
00413                 //---------- set x--------
00414                 if( m_RpcId > 1 )  // NO.3, 4, 5
00415                         x = 0.;
00416                 else  // NO.1 and NO.2
00417                         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 );
00418                 
00419                 //---------- set y--------
00420                 y = (B_AS_RMIN[m_Layer] - AS_GAP / 2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
00421 
00422                 //---------- set z--------
00423                 if( m_RpcId < 2 ) // rpc NO.1 and NO.2
00424                         z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00425                 else if( m_UpDown == SL_UP && m_RpcId == 4 ) // up NO.5
00426                         z = -B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00427                 else if( m_UpDown == SL_DOWN && m_RpcId == 2 ) // down NO.3
00428                         z = B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
00429                 else if( m_UpDown == SL_UP ) // up NO.3 and NO.4
00430                         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;
00431                 else    // down NO.4 and NO.5
00432                         z = -B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] + (1+2*(4-m_RpcId))*B_RPC_LTN/2.0;
00433 
00434         } // end top segment
00435 
00436         m_LocOrgInBes[0] = x;
00437         m_LocOrgInBes[1] = y;
00438         m_LocOrgInBes[2] = z;
00439 
00440         // limit cut
00441         for( int i=0; i<2; i++ ) {
00442                 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.0;
00443         }
00444         
00445         return 0;
00446 }
00447 
00448 int MucGas::SetEndcapRpcInBes()
00449 {
00450         if( m_Part == BRID ) return 0;
00451         
00452         double x, y, z;
00453         x = y = z = 0.;
00454 
00455         //------------ set x and y ---------------
00456         if( m_UpDown == SL_UP )
00457         {
00458                 if( m_RpcId == 0 )
00459                 {
00460                         x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
00461                         y = m_Rc;
00462                 }       
00463                 else if( m_RpcId == 1 )
00464                 {
00465                         x = m_Rc * cos( MUC_PI/4.0 );
00466                         y = m_Rc * sin( MUC_PI/4.0 );
00467                 }
00468                 else
00469                 {
00470                         x = m_Rc;
00471                         y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
00472                 }               
00473         }
00474         else
00475         {
00476                 switch( m_RpcId )
00477                 {
00478                         case 0:
00479                                 x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
00480                                 y = m_Rc;
00481                                 break;
00482                         case 1:
00483                                 x = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00484                                 x += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
00485 
00486                                 y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00487                                 y += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
00488 
00489                                 break;
00490                         case 2:
00491                                 x = m_Rc * cos( MUC_PI/4.0 ); 
00492                                 y = m_Rc * sin( MUC_PI/4.0 );
00493                                 break;
00494                         case 3:
00495                                 x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
00496                                 x += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
00497 
00498                                 y = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
00499                                 y += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
00500 
00501                                 break;
00502                         case 4:
00503                                 x = m_Rc;
00504                                 y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
00505                 }
00506                 
00507         }
00508         
00509         // sign different by segment
00510         if     ( m_Segment == 0 ) {     ;               }
00511         else if( m_Segment == 1 ) {     x = -x;         }
00512         else if( m_Segment == 2 ) {     x = -x; y = -y; }                                               
00513         else                      {     y = -y;         }
00514 
00515         
00516         //------------ set z ---------------------
00517         for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i]; 
00518         z += m_Layer * AS_GAP;
00519         z += ( (E_AS_ZMAX - E_AS_TOTAL_TH) + AS_GAP/2.0 );  
00520         z += (1-2*m_UpDown) * ( STR_TH + RPC_TH ) / 2.0;        
00521         z *= cos( m_Part*MUC_PI/2.0 );
00522 
00523         m_LocOrgInBes[0] = x;
00524         m_LocOrgInBes[1] = y;
00525         m_LocOrgInBes[2] = z;
00526 
00527         // limit cut
00528         for( int i=0; i<2; i++ ) {
00529                 if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
00530         }
00531                 
00532         return 0;
00533 }
00534 
00535 // Set local origin(RPC) in BES CS
00536 void MucGas::SetLocOrgInBes() 
00537 {
00538         if( m_Part == BRID )
00539                 SetBarrelRpcInBes();
00540         else
00541                 SetEndcapRpcInBes();
00542 }
00543 
00544 // Set gas origin in RPC CS, all is 0
00545 void MucGas::SetObjOrgInLoc()
00546 {
00547         for( int i=0; i<3; i++ )  m_ObjOrgInLoc[i] = 0.;
00548 }
00549 
00550 void MucGas::SetObjOrgInBes()
00551 {
00552         MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
00553 
00554         // limit cut
00555         for( int i=0; i<3; i++ ) {
00556                 if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.0;
00557         }
00558 }
00559 
00560 /*
00561 void MucGas::SetAlignment( double dx, double dy, double dz )
00562 {
00563         
00564         m_ObjOrgInLoc[0] += dx;
00565         m_ObjOrgInLoc[1] += dy;
00566         m_ObjOrgInLoc[2] += d;
00567 }
00568 */
00569 
00570 // END