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

00001 //------------------------------------------------------------------------------|
00002 //      [File  ]:                       MucBakelite.cxx                         |
00003 //      [Brief ]:       MUC geometry bakelite 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/MucBakelite.h"
00013 
00014 using namespace std;
00015 
00016 // Constructor
00017 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 }
00022 
00023 // Copy constructor             
00024 MucBakelite::MucBakelite( const MucBakelite &other ) : MucEntity( other )
00025 {
00026         m_Phi           = other.m_Phi;
00027 }
00028 
00029 // Operator =
00030 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 }
00041 
00042 // Destructor
00043 MucBakelite::~MucBakelite() { ; }
00044 
00045 // Initialize
00046 void MucBakelite::Init()
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 }
00068                 
00069 // -------------------------- Get methods ----------------------------
00070 
00071 double MucBakelite::GetPhi()            {        return m_Phi;          }
00072 
00073 // ---------------------------Set motheds -----------------------------
00074 
00075 // Set inclination angle of local coordinate x axis and global coordinate x axis
00076 void MucBakelite::SetPhi()
00077 {
00078         if( m_Part == BRID )
00079                 m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
00080         else
00081                 m_Phi = 0.;
00082 }
00083 
00084 void MucBakelite::SetTheta()
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 }
00103 
00104 void MucBakelite::SetRin()
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 }
00112 
00113 void MucBakelite::SetRout()
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 }
00123 
00124 void MucBakelite::SetRc()
00125 {
00126         m_Rc = (m_Rin + m_Rout)/2.0;
00127 }
00128 
00129 void MucBakelite::SetThin()
00130 {
00131         m_Thin = BKLT_TH;
00132 }
00133 
00134 void MucBakelite::SetW()
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 }
00206 
00207 void MucBakelite::SetH()
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 }
00222 
00223 void MucBakelite::SetL()
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 }
00269 
00270 void MucBakelite::SetWu()
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 }
00324 
00325 void MucBakelite::SetWd()
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 }
00377 
00378 // Set barrel rpc in BES CS
00379 int MucBakelite::SetBarrelRpcInBes()
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 }
00444 
00445 int MucBakelite::SetEndcapRpcInBes()
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 }
00532 
00533 // Set local origin(RPC) in BES CS
00534 void MucBakelite::SetLocOrgInBes() 
00535 {
00536         if( m_Part == BRID )
00537                 SetBarrelRpcInBes();
00538         else
00539                 SetEndcapRpcInBes();
00540 }
00541 
00542 // Set bakelite origin in RPC CS
00543 void MucBakelite::SetObjOrgInLoc()
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 }
00560 
00561 void MucBakelite::SetObjOrgInBes()
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 }
00570 
00571 /*
00572 void MucBakelite::SetAlignment( double dx, double dy, double dz )
00573 {
00574         
00575         m_ObjOrgInLoc[0] += dx;
00576         m_ObjOrgInLoc[1] += dy;
00577         m_ObjOrgInLoc[2] += dz;
00578 }
00579 */
00580 
00581 // END