MucGas.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucGas.cxx                              |
//      [Brief ]:       MUC geometry mixture gas creating class                 |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       May 22, 2005                                            |
//------------------------------------------------------------------------------|
 
#include <iostream>
#include <cmath>
 
#include "MucGeoCreateAlg/MucGeoConst.h"
#include "MucGeoCreateAlg/MucGas.h"
 
using namespace std;
 
// Constructor
MucGas::MucGas( int part, int segment, int layer, int upDown, int rpcId, int id ) 
  : MucEntity( part, segment, layer, upDown, rpcId, id )
{
  MucGas::Init();
}
 
// Copy constructor     
MucGas::MucGas( const MucGas &other ) : MucEntity( other )
{
  m_Phi = other.m_Phi;
}
 
// Operator =
MucGas& MucGas::operator =( const MucGas &other )
{
  if( this == &other) return *this;
  MucEntity::operator =(other);
  m_Phi = other.m_Phi;
  
  return *this; 
}
 
// Destructor
MucGas::~MucGas() { ; }
 
// Initialize
void MucGas::Init()
{
  SetPhi();
  SetTheta();
  SetRin();
  SetRout();
  SetRc();
  
  SetThin();
  SetW();
  SetWu();
  SetWd();
  SetH();
  SetL();
  
  SetEndcapRpcInBes();
  SetBarrelRpcInBes();
  
  SetLocOrgInBes();
  SetObjOrgInBes();
  SetObjOrgInLoc();
}
        
// -------------------------- Get methods ----------------------------
 
double MucGas::GetPhi() { return m_Phi; }
 
// ---------------------------Set motheds -----------------------------
 
// Set inclination angle of local coordinate x axis and global coordinate x axis
void MucGas::SetPhi()
{
  if( m_Part == BRID )  m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
  else                  m_Phi = 0.;
}
 
void MucGas::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 MucGas::SetRin()
{
  if( m_Part == BRID )  // Rin of gas( same as which of RPC )
    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;
  else                  // Rin of RPC
    m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
}
 
void MucGas::SetRout()
{
  if( m_Part == BRID )
    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;
  else
    m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
}
 
void MucGas::SetRc()
{
  m_Rc = (m_Rin + m_Rout)/2.0;
}
 
 
void MucGas::SetThin()
{
  m_Thin = GAS_TH;
}
 
void MucGas::SetW()
{
  if( m_Part == BRID)
  {
    if( m_Segment == B_TOP && m_RpcId < 2 ) // the first 2 gases 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 gases
    {
      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 MucGas::SetH()
{
  if( m_Part == BRID )
    m_H = GAS_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 MucGas::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
  
  } // End barrel 
  else // endcap
    m_L = GAS_TH;
}
 
void MucGas::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.;      
                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 MucGas::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 MucGas::SetBarrelRpcInBes()
{
  if( m_Part != BRID ) return 0;
  
  double x, y, z;
  x = y = z = 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 // top segment
  {
    //---------- 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 )    // up NO.5
      z = -B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
    else if( m_UpDown == SL_DOWN && m_RpcId == 2 )  // down NO.3
      z = B_RPC_LTN - B_TOPRPC_LTS[ ((m_Layer==0)?1:(m_Layer%2)) ];
    else if( m_UpDown == SL_UP )  // up NO.3 and NO.4
      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                          // down NO.4 and NO.5
      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 MucGas::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 MucGas::SetLocOrgInBes() 
{
  if( m_Part == BRID )  SetBarrelRpcInBes();
  else                  SetEndcapRpcInBes();
}
 
// Set gas origin in RPC CS, all is 0
void MucGas::SetObjOrgInLoc()
{
  for( int i=0; i<3; i++ )  m_ObjOrgInLoc[i] = 0.;
}
 
void MucGas::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.0;
}
 
/*
void MucGas::SetAlignment( double dx, double dy, double dz )
{
  m_ObjOrgInLoc[0] += dx;
  m_ObjOrgInLoc[1] += dy;
  m_ObjOrgInLoc[2] += d;
}
*/
 
// END