MucBakelite.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucBakelite.cxx                         |
//      [Brief ]:       MUC geometry bakelite class                             |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       May 22, 2005                                            |
//------------------------------------------------------------------------------|
 
#include <iostream>
#include <cmath>
 
#include "MucGeoCreateAlg/MucGeoConst.h"
#include "MucGeoCreateAlg/MucBakelite.h"
 
using namespace std;
 
// Constructor
MucBakelite::MucBakelite( int part, int segment, int layer, int upDown, int rpcId, int id ) 
  : MucEntity( part, segment, layer, upDown, rpcId, id )
{
  MucBakelite::Init();
}
 
// Copy constructor     
MucBakelite::MucBakelite( const MucBakelite &other ) : MucEntity( other )
{
  m_Phi = other.m_Phi;
}
 
// Operator =
MucBakelite& MucBakelite::operator =( const MucBakelite &other )
{
  if( this == &other) return *this;
  MucEntity::operator =(other);
  m_Phi = other.m_Phi;
 
  return *this; 
}
 
// Destructor
MucBakelite::~MucBakelite() { ; }
 
// Initialize
void MucBakelite::Init()
{
  SetPhi();
  SetTheta();
  SetRin();
  SetRout();
  SetRc();
  
  SetThin();
  SetW();
  SetWu();
  SetWd();
  SetH();
  SetL();
  
  SetEndcapRpcInBes();
  SetBarrelRpcInBes();
  
  SetLocOrgInBes();
  SetObjOrgInLoc();
  SetObjOrgInBes();
}
        
// -------------------------- Get methods ----------------------------
 
double MucBakelite::GetPhi()  { return m_Phi; }
 
// ---------------------------Set motheds -----------------------------
 
// Set inclination angle of local coordinate x axis and global coordinate x axis
void MucBakelite::SetPhi()
{
  if( m_Part == BRID )  m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
  else                  m_Phi = 0.;
}
 
void MucBakelite::SetTheta()
{
  if( m_Part == BRID )
    m_Theta = m_Segment * (MUC_PI/4.0);
  else
  {
    if( m_UpDown == SL_UP )
      m_Theta = ( MUC_PI/4.0 ) + (1 - m_RpcId) * MUC_PI / 8.0 ;
    else
    {
      if( m_RpcId < 2 ) // RPC NO.1 and NO.2 
        m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
      else if ( m_RpcId == 2 ) // center RPC, NO.3
        m_Theta = ( MUC_PI/4.0 ) ;
      else
        m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
    }
  }
}
 
void MucBakelite::SetRin()
{
  if( m_Part == BRID )  // Rin of bakelite
    m_Rin = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0 
            + (1-2*m_ID)*(GAS_TH + BKLT_TH)/2.0 - BKLT_TH/2.0;
  else                  // Rin of RPC
    m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
}
 
void MucBakelite::SetRout()
{
  if( m_Part == BRID )  // Rout of bakelite
    m_Rout = B_AS_RMIN[m_Layer] - AS_GAP/2.0 + (1-2*m_UpDown) * (STR_TH + RPC_TH)/2.0
              + (1-2*m_ID)*(GAS_TH + BKLT_TH)/2.0 + BKLT_TH/2.0;
  else
    m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
}
 
void MucBakelite::SetRc()
{
  m_Rc = (m_Rin + m_Rout)/2.0;
}
 
void MucBakelite::SetThin()
{
  m_Thin = BKLT_TH;
}
 
void MucBakelite::SetW()
{
  if( m_Part == BRID)
  {
    if( m_Segment == B_TOP && m_RpcId < 2 )   // the first 2 RPCs in top segment
    {
      if( (m_Layer+1)%2 == 1 )  // odd layer
        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;
      else                      // even layer
        m_W = (B_BOX_WT[m_Layer] - 4*B_BOX_DZ[m_UpDown] - B_BOX_SLOT_WT)/2.0;
    }   
    else                                      // other RPCs
    {
      if( (m_Layer+1)%2 ==1 ) // odd layer
        m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DT[m_UpDown];
      else                    // even layer
        m_W = B_BOX_WT[m_Layer] - 2 * B_BOX_DZ[m_UpDown];
    }   
  } // end barrel
  else
  {
    if( m_UpDown == SL_UP ) // up layer
    {   
      if( m_RpcId == 0 )
        m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
      else if ( m_RpcId == 1 )
        m_W = 2 * VALUE * m_Rc;
      else 
        m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
    }
    else                    // down layer
    {   
      switch( m_RpcId )
      {
        case 0:
                m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
                break;
        case 1:
        case 3:
                m_W = VALUE * ( m_Rc - m_Rin );
                break;
        case 2:
                m_W = 2 * VALUE * m_Rin;
                break;
        case 4:
                m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA; 
                break;
        default: ;
      }
    }
  } // else, endcap
 
  // cut rpc chamber death edge
  if( m_Part == BRID )
    m_W -= RPC_DEATH_EDGE * 2.0;
  else
  {
    if( m_UpDown == SL_UP ) {
      if( m_RpcId == 1 ) m_W -= RPC_DEATH_EDGE * 2.0; // center rpc
      else               m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
    }
    else
    {
      if( m_RpcId == 2 )  // center rpc
        m_W -= RPC_DEATH_EDGE * 2.0;
      else                // DOWN 0,1,3,4 RPC
        m_W -= RPC_DEATH_EDGE;
    }
  }
}
 
void MucBakelite::SetH()
{
  if( m_Part == BRID )
    m_H = BKLT_TH;
  else
  {
    m_H = m_Rout - m_Rin;   
    
    // cut rpc chamber death edge
    if( m_UpDown == SL_DOWN && (m_ID == 1 || m_ID == 3) )
      m_H -= RPC_DEATH_EDGE * (1 + 1.0/VALUE);
    else
      m_H -= RPC_DEATH_EDGE * 2.0;
  }
}
 
void MucBakelite::SetL()
{
  if( m_Part == BRID ) // barrel
  {
    if( m_Segment != B_TOP ) // not top segment
    {
      // the first rpc of SL_DOWN is constructed as the same as the last rpc of SL_UP
      if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
      {
        if( m_Layer != 1 )  // not layer NO.2
          m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTN;
        else                // layer NO.2 is special
          m_L = B_BOX_LT - 2*B_BOX_DZ[m_UpDown] - 3*B_RPC_LTS;
      }
      else
      {
        if( m_Layer != 1 )  // not layer NO.2
          m_L = B_RPC_LTN;
        else                // layer NO.2 is special
          m_L = B_RPC_LTS;
      }
    }
    else // top segment
    {
      if( m_RpcId < 2 ) {  // RPC NO.1 and NO.2
        m_L = B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ];
      }         
      else if( (m_UpDown == SL_UP && m_RpcId == 4) || (m_UpDown == SL_DOWN && m_RpcId == 2) ) {
        m_L = B_BOX_LT - B_TOPRPC_LTS[ ((m_Layer == 0)?1:(m_Layer%2)) ] - 2*(B_BOX_DZ[m_UpDown]+B_RPC_LTN);
      }
      else
        m_L = B_RPC_LTN;
    
    } // else, top segment  
    
    m_L -= RPC_DEATH_EDGE * 2.0;    // cut rpc chamber death edge
  
  } // if, barrel 
  else { // endcap
    m_L = BKLT_TH;
  }
}
 
void MucBakelite::SetWu()
{
  if( m_Part == BRID )  m_Wu = m_W;
  else
  { 
    if( m_UpDown == SL_UP )
    {
      if( m_RpcId == 0 )
        m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
      else if( m_RpcId == 1 )
        m_Wu = 2.0* VALUE * m_Rin;
      else 
        m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
    }
    else
    {
      switch( m_RpcId )
      {
        case 0:
                m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
                break;
        case 1:
        case 3:
                m_Wu = 0.0;     
                break;
        case 2:
                m_Wu = 2.0* VALUE * m_Rin;
                break;
        case 4:
                m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;
                break;
        default: ;
      }
    }
 
    // cut rpc chamber death edge
    if( m_Wu > 0.0 )
    {
      if( m_UpDown == SL_UP ) {
        if( m_RpcId == 1 )  m_Wu -= RPC_DEATH_EDGE * 2.0; // center rpc
        else                m_Wu -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
      }
      else
      {
        if( m_RpcId == 2 )  // center rpc
          m_Wu -= RPC_DEATH_EDGE * 2.0;
        else                // DOWN 0,4 RPC
          m_W -= RPC_DEATH_EDGE;
      }
    }
  } // else, endcap
}
 
void MucBakelite::SetWd()
{
  if( m_Part == BRID )  m_Wd = m_W;
  else
  {
    if( m_UpDown == SL_UP )
    {
      if( m_RpcId == 0 )
        m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
      else if( m_RpcId == 1 )
        m_Wd = 2.0* VALUE * m_Rout;
      else
        m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
    }
    else
    {
      switch( m_RpcId )
      {
        case 0:
                m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA;
                break;
        case 1:
        case 3:
                m_Wd = VALUE * (m_Rout - m_Rin);
                break;
        case 2:
                m_Wd = 2.0 * VALUE * m_Rin;
                break;
        case 4:
                m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA;
                break;
        default: ;
      }
    }
    
    // cut rpc chamber death edge
    if( m_UpDown == SL_UP ) {
      if( m_RpcId == 1 )  m_Wd -= RPC_DEATH_EDGE * 2.0; // center rpc
      else                m_Wd -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * RPC_DEATH_EDGE;
    }
    else
    {
      if( m_RpcId == 2 )  // center rpc
        m_Wd -= RPC_DEATH_EDGE * 2.0;
      else                // DOWN 0,4 RPC
        m_Wd -= RPC_DEATH_EDGE;
    }
  } // else, endcap 
}
 
// Set barrel rpc in BES CS
int MucBakelite::SetBarrelRpcInBes()
{
  if( m_Part != BRID ) return 0;
 
  double x, y, z;
  x = y = z = 0.0;
 
  if( m_Segment != B_TOP )
  {
    // set x and y
    double r;
    r = (B_AS_RMIN[m_Layer] - AS_GAP / 2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
    x = r * cos( m_Theta );
    y = r * sin( m_Theta );
    
    // set z
    if( (m_UpDown == SL_UP && m_RpcId == 3) || (m_UpDown == SL_DOWN && m_RpcId == 0) )
    {
      if( m_Layer != 1 ) // not layer NO.2
        z = (2*m_UpDown - 1) * 3 * B_RPC_LTN/2.0;
      else
        z = (2*m_UpDown - 1) * 3 * B_RPC_LTS/2.0;
    }
    else if( m_UpDown == SL_UP )
      z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_RpcId)*B_RPC_LTN/2.0;
    else
      z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_RpcId))*B_RPC_LTN/2.0;
  } // end not top segment
  else
  {
    //---------- set x--------
    if( m_RpcId > 1 ) // NO.3, 4, 5
      x = 0.;
    else              // NO.1 and NO.2
      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 );
    
    //---------- set y--------
    y = (B_AS_RMIN[m_Layer] - AS_GAP / 2.0) + (1-2*m_UpDown)*(STR_TH + RPC_TH)/2.0;
    
    //---------- set z--------
    if( m_RpcId < 2 ) // rpc NO.1 and NO.2
      z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
    else if( m_UpDown == SL_UP && m_RpcId == 4 )
      z = -B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
    else if( m_UpDown == SL_DOWN && m_RpcId == 2 )
      z = B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
    else if( m_UpDown == SL_UP )
      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;
    else
      z = -B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] + (1+2*(4-m_RpcId))*B_RPC_LTN/2.0;
  } // end top segment
  
  m_LocOrgInBes[0] = x;
  m_LocOrgInBes[1] = y;
  m_LocOrgInBes[2] = z;
  
  // limit cut
  for( int i=0; i<2; i++ ) {
    if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.0;
  }
  
  return 0;
}
 
int MucBakelite::SetEndcapRpcInBes()
{
  if( m_Part == BRID ) return 0;
  
  double x, y, z;
  x = y = z = 0.;
 
  //------------ set x and y ---------------
  if( m_UpDown == SL_UP )
  {
    if( m_RpcId == 0 ) {
      x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
      y = m_Rc;
    }   
    else if( m_RpcId == 1 ) {
      x = m_Rc * cos( MUC_PI/4.0 );
      y = m_Rc * sin( MUC_PI/4.0 );
    }
    else {
      x = m_Rc;
      y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
    }       
  }
  else
  {
    switch( m_RpcId )
    {
      case 0:
              x = ( VALUE*m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
              y = m_Rc;
              break;
      case 1:
              x = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
              x += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
              y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
              y += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
              break;
      case 2:
              x = m_Rc * cos( MUC_PI/4.0 );
              y = m_Rc * sin( MUC_PI/4.0 );
              break;
      case 3:
              x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
              x += RPC_DEATH_EDGE * ( 1 + 4.0/sqrt(2.0) )/4.0;
              y = VALUE*m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
              y += RPC_DEATH_EDGE * ( 3 - 2*sqrt(2.0) )/4.0;
              break;
      case 4:
              x = m_Rc;
              y = ( VALUE*m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + RPC_DEATH_EDGE/2.0;
    }
  }
 
  // sign different by segment
  if     ( m_Segment == 0 ) { ;               }
  else if( m_Segment == 1 ) { x = -x;         }
  else if( m_Segment == 2 ) { x = -x; y = -y; }                         
  else                      { y = -y;         }
  
  //------------ set z ---------------------
  for( int i=0; i<m_Layer+1; i++ ) z += E_AS_TH[i]; 
  
  z += m_Layer * AS_GAP;
  z +=  ( (E_AS_ZMAX - E_AS_TOTAL_TH ) + AS_GAP/2.0 );  
  z += (1-2*m_UpDown) * ( STR_TH + RPC_TH ) / 2.0;  
  z *= cos( m_Part*MUC_PI/2.0 );
  
  m_LocOrgInBes[0] = x;
  m_LocOrgInBes[1] = y;
  m_LocOrgInBes[2] = z;
  
  // limit cut
  for( int i=0; i<2; i++ ) {
    if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
  }
    
  return 0;
}
 
// Set local origin(RPC) in BES CS
void MucBakelite::SetLocOrgInBes() 
{
  if( m_Part == BRID )  SetBarrelRpcInBes();
  else                  SetEndcapRpcInBes();
}
 
// Set bakelite origin in RPC CS
void MucBakelite::SetObjOrgInLoc()
{
  if( m_Part == BRID )
  {
    m_ObjOrgInLoc[0] = 0.;
    m_ObjOrgInLoc[1] = (1-2*m_ID) * (BKLT_TH + GAS_TH)/2.0;
    m_ObjOrgInLoc[2] = 0.;
  }
  else
  {
    m_ObjOrgInLoc[0] = 0.;
    m_ObjOrgInLoc[1] = 0.;
    m_ObjOrgInLoc[2] = (1-2*m_ID) * (BKLT_TH + GAS_TH)/2.0;
  }
}
 
void MucBakelite::SetObjOrgInBes()
{
  MucEntity::TransLocToBes( m_ObjOrgInBes, m_ObjOrgInLoc, m_LocOrgInBes, m_Phi );
  
  // limit cut
  for( int i=0; i<3; i++ ) {
    if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
  }
}
 
/*
void MucBakelite::SetAlignment( double dx, double dy, double dz )
{   
  m_ObjOrgInLoc[0] += dx;
  m_ObjOrgInLoc[1] += dy;
  m_ObjOrgInLoc[2] += dz;
}
*/
 
// END