MucRpc.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucRpc.cxx                          |
//      [Brief ]:       MUC geometry RPC creating class             |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       May 22, 2005                                            |
//------------------------------------------------------------------------------|
 
#include <iostream>
#include <cmath>
 
#include "MucGeoCreateAlg/MucGeoConst.h"
#include "MucGeoCreateAlg/MucRpc.h"
 
using namespace std;
 
// Constructor
MucRpc::MucRpc( int part, int segment, int layer, int upDown, int id ) : MucEntity( part, segment, layer, upDown, id )
{
    MucRpc::Init();
 
    m_MucGas    = NULL;
    m_MucBakelite   = NULL;
}
 
// Copy constructor     
MucRpc::MucRpc( const MucRpc &other ) : MucEntity( other )
{
    m_Phi       = other.m_Phi;
    m_MucGas    = other.m_MucGas;
        m_MucBakelite   = other.m_MucBakelite;
}
 
// Operator =
MucRpc& MucRpc::operator =( const MucRpc &other )
{
    if( this == &other)
                return *this;
 
    MucEntity::operator =(other);
 
        m_Phi           = other.m_Phi;  
        m_MucGas        = other.m_MucGas;
        m_MucBakelite   = other.m_MucBakelite;
 
        return *this;   
}
 
// Destructor
MucRpc::~MucRpc()
{   
    delete m_MucGas;
    delete m_MucBakelite;
}
 
// Initialize
void MucRpc::Init()
{
    SetPhi();
        SetTheta();
        SetRin();
        SetRout();
        SetRc();
 
        SetThin();
        SetW();
        SetWu();
        SetWd();
        SetH();
        SetL();
    
    SetEndcapRpcInBes();
    SetBarrelRpcInLoc();
 
        SetLocOrgInBes();
        SetObjOrgInBes();
        SetObjOrgInLoc();
}
        
// -------------------------- Get methods ----------------------------
double MucRpc::GetPhi() {   return m_Phi;   }
 
MucGas* MucRpc::GetGas()
{
    if( m_MucGas != NULL )  delete m_MucGas;
 
    return ( m_MucGas = new MucGas( m_Part, m_Segment, m_Layer, m_UpDown, m_ID, 0 ) );
}
 
MucBakelite* MucRpc::GetBakelite( int id )
{
        if( m_MucBakelite != NULL )  delete m_MucBakelite;
 
        return ( m_MucBakelite = new MucBakelite( m_Part, m_Segment, m_Layer, m_UpDown, m_RpcId, id ) );
}
 
 
// ---------------------------Set motheds -----------------------------
 
void MucRpc::SetPhi()
{
    if( m_Part == BRID )
        m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);
    else
        m_Phi = 0.;
}
 
 
void MucRpc::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_ID ) * MUC_PI / 8.0 ;
        }
                else
        {   
            if( m_ID < 2 ) // RPC NO.1 and NO.2
                            m_Theta = ( MUC_PI/4.0 ) + MUC_PI / 8.0 ;
            else if ( m_ID == 2 ) // center RPC, NO.3
                m_Theta = ( MUC_PI/4.0 ) ;
            else    
                m_Theta = ( MUC_PI/4.0 ) - MUC_PI / 8.0 ;
        }
        }
}
 
void MucRpc::SetRin()
{
        if( m_Part == BRID )
                m_Rin = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown ) * (STR_TH / 2.0 + m_UpDown*RPC_TH);
        else
        m_Rin = E_GP_RMIN[m_Layer] + E_STRPLN_DR + (1-m_UpDown)*RPC_SL_OFFSET;
}
 
void MucRpc::SetRout()
{
        if( m_Part == BRID )
                m_Rout = B_AS_RMIN[m_Layer] - AS_GAP / 2.0 + ( 1-2*m_UpDown )*( STR_TH / 2.0 + (1-m_UpDown)*RPC_TH );
        else
                m_Rout = E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + (m_UpDown-1)*RPC_SL_OFFSET;
}
 
void MucRpc::SetRc()
{
    m_Rc = (m_Rin + m_Rout)/2.0;
}
 
void MucRpc::SetThin()
{
        m_Thin = RPC_TH;
}
 
void MucRpc::SetW()
{
        if( m_Part == BRID)
        {
        if( m_Segment == B_TOP && m_ID < 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 super layer RPCs
        {
            if( m_ID == 0 )
                m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
            else if( m_ID == 1 )
                m_W = VALUE * m_Rc * 2.0;
            else
                m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
        }
        else // down super layer RPCs
        {
            if( m_ID == 0 )
                m_W = VALUE * m_Rc - E_GP_DX - E_STRPLN_DA;
            else if( m_ID == 1 || m_ID == 3 )   
                m_W = VALUE * (m_Rc - m_Rin);
            else if( m_ID == 2 )
                m_W = VALUE * m_Rin * 2.0;
            else 
                m_W = VALUE * m_Rc - E_GP_DY - E_STRPLN_DA; 
        }
        
        } // else, endcap
    
    // cut rpc chamber death edge
    if( m_Part == BRID )
        m_W -= OVERLAP_WIDTH * 2.0;
    else
    {
        if( m_UpDown == SL_UP )
        {
            if( m_ID == 1 ) m_W -= OVERLAP_WIDTH * 2.0; // center rpc
            else        m_W -= ( 1 + 1.0/cos(MUC_PI/8.0) ) * OVERLAP_WIDTH;
        }
        else
        {
            if( m_ID == 2 ) // center rpc
                m_W -= OVERLAP_WIDTH * 2.0; 
            else // DOWN 0,1,3,4 RPC
                m_W -= OVERLAP_WIDTH;
        }
    }
}
 
void MucRpc::SetH()
{
        if( m_Part == BRID )
                m_H = RPC_TH;
        else
        {
        m_H = m_Rout - m_Rin;
        }
}
 
void MucRpc::SetL()
{
        if( m_Part == BRID ) // barrel
    {
        if( m_Segment != B_TOP ) // not top segment
        {
                if( (m_UpDown == SL_UP && m_ID == 3 ) || (m_UpDown == SL_DOWN && m_ID == 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
                    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
                                    m_L = B_RPC_LTS;            
            }
        }
        else // top segment
        {
            if( m_ID < 2 ) // first two RPCs
            {
                    if( m_Layer == 0 ) // the first layer
                                        m_L = B_TOPRPC_LTS[1];
                                else
                                        m_L = B_TOPRPC_LTS[m_Layer%2];
            }
            else if( (m_UpDown == SL_UP && m_ID == 4 ) || (m_UpDown == SL_DOWN && m_ID == 2 ) )
            {
                                if( m_Layer == 0 ) // the first layer
                                        m_L = B_BOX_LT - B_TOPRPC_LTS[1] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);
                                else
                                        m_L = B_BOX_LT - B_TOPRPC_LTS[m_Layer%2] - 2*(B_BOX_DZ[m_UpDown] + B_TOPRPC_LTN);       
            }
            else
            {
                                m_L = B_TOPRPC_LTN;
            }
        } // end top segment
 
        m_L -= OVERLAP_WIDTH * 2.0; // cut rpc chamber death edge
 
    } // end barrel
        else
    {
                m_L = RPC_TH;
    }
}
 
void MucRpc::SetWu()
{
        if( m_Part == BRID )
                m_Wu = m_W;
        else
        {
        if( m_UpDown == SL_UP )
        {
            if( m_ID == 0 )
                m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
            else if( m_ID == 1 )
                m_Wu = VALUE * m_Rin * 2.0;
            else 
                m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
        }
        else
        {
                        if( m_ID == 0 )
                                m_Wu = VALUE * m_Rin - E_GP_DX - E_STRPLN_DA;
                        else if( m_ID == 1 || m_ID == 3 )
                                m_Wu = 0.;
                        else if( m_ID == 2 )
                                m_Wu = VALUE * m_Rin * 2.0;
                        else
                                m_Wu = VALUE * m_Rin - E_GP_DY - E_STRPLN_DA;           
        }
 
        // cut rpc chamber death edge
        if( m_Wu > 0.0 ) // except for DOWN 1, 3 RPC 
        {
            if( m_UpDown == SL_UP )
                    {
                            if( m_ID == 1 ) m_Wu += 2.0*OVERLAP_WIDTH *(sin(BETA)-1)/cos(BETA); // center rpc
                            else            m_Wu -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
                    }
                    else
                    {
                                m_Wu -= 1.5*OVERLAP_WIDTH;
                    }
        }
        }
}
 
void MucRpc::SetWd()
{
     if( m_Part == BRID )
                m_Wd = m_W;
        else
        {   
                if( m_UpDown == SL_UP )
                {
                        if( m_ID == 0 )
                                m_Wd = VALUE * m_Rout - E_GP_DX - E_STRPLN_DA - RPC_SL_OFFSET;
                        else if( m_ID == 1 )
                                m_Wd = VALUE * m_Rout * 2.0;
                        else
                                m_Wd = VALUE * m_Rout - E_GP_DY - E_STRPLN_DA - RPC_SL_OFFSET;
                }
                else
                {
                        switch( m_ID )
                        {
                                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 * 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_ID == 1 ) m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)+1)/cos(BETA); // center rpc
                        else            m_Wd -= ( 1 + 1.0/cos(BETA) ) * OVERLAP_WIDTH;
                }
                else
                {
            if( m_ID ==0 || m_ID == 4 )
                          // m_Wd -= 2.0*OVERLAP_WIDTH*(sin(BETA)-1)/cos(BETA);
                     m_Wd -= 1.5*OVERLAP_WIDTH;
                }
        }
}
 
int MucRpc::SetEndcapRpcInBes()
{
    if( m_Part == BRID )
        return 0;
    else
    {
        double x, y, z;
        x = y = z = 0.;
 
        // -----------------set x and y -----------------
                if( m_UpDown == SL_UP ) // up super layer
                {
                        if( m_ID == 0 )
            {
                x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0;
                y = m_Rc;  
            }
                        else if( m_ID == 1 )
            {
                                x = m_Rc * cos( m_Theta );
                y = m_Rc * sin( m_Theta );
            }
                        else
            {
                            x = m_Rc;
                y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA + RPC_SL_OFFSET ) / 2.0; 
            }
                }
                else    // down super layer
                {
                        if( m_ID == 0 )
            {
                                x = ( VALUE * m_Rc + E_GP_DX + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
                                y = m_Rc; 
            }
                        else if( m_ID == 1 )
            {
                x = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
        //      x += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
 
                                y = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
        //      y += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
            }
                        else if( m_ID == 2 )
            {
                                x = m_Rc * cos( MUC_PI/4.0 );
                                y = m_Rc * sin( MUC_PI/4.0 );
            }
            else if( m_ID == 3 )
            {
                                x = m_Rc - cos(MUC_PI/4.0)*m_Wd/4.0;
        //      x += OVERLAP_WIDTH * ( 1 + 4.0/sqrt(2.0) )/4.0;
 
                                y = VALUE * m_Rc + sin(MUC_PI/4.0)*m_Wd/4.0;
        //      y += OVERLAP_WIDTH * ( 3 - 2*sqrt(2.0) )/4.0;
            }
                        else
            {
                                x = m_Rc;
                                y = ( VALUE * m_Rc + E_GP_DY + E_STRPLN_DA )/2.0 + OVERLAP_WIDTH/2.0;
            }
                }
 
                // x, y signs of coordinate 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) * (RPC_TH + STR_TH)/2.0 ;
        z *= cos( m_Part*MUC_PI/2.0 );
        
            m_ObjOrgInBes[0] = x;
            m_ObjOrgInBes[1] = y;
            m_ObjOrgInBes[2] = z;
 
            // limit cut
            for(int i=0;i<3;i++) {
                    if( fabs(m_ObjOrgInBes[i]) < ERR_LIMIT ) m_ObjOrgInBes[i] = 0.;
            }
 
    } // else, endcap
 
    return 0;
}
 
int MucRpc::SetBarrelRpcInLoc()
{
    if( m_Part != BRID )
        return 0;
    else
    {
        double x, y, z;
        x = y = z = 0.;
 
        if( m_Segment != B_TOP ) // not top segment
        {
            //---------- set x--------
            x = 0.;
 
                        //---------- set y--------
                        y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
 
                        //---------- set z--------
            if( (m_UpDown == SL_UP && m_ID == 3) || (m_UpDown == SL_DOWN && m_ID == 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_Layer != 1) // not layer NO.2
                {
                    if( m_UpDown == SL_UP )
                        z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTN/2.0;
                    else
                        z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTN/2.0;
                }
                else
                {
                    if( m_UpDown == SL_UP )
                        z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - (1+2*m_ID)*B_RPC_LTS/2.0;
                    else
                        z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(3-m_ID))*B_RPC_LTS/2.0;  
                }
            }
        }
        else // top segment
        {
                        //---------- set x--------
            if( m_ID > 1 )
                            x = 0.;
            else
                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 ); 
 
                        //---------- set y--------
                        y = (1-2*m_UpDown) * ( RPC_TH + STR_TH )/2.0;
 
                        //---------- set z--------
            if( m_UpDown == SL_UP )
            {
                switch( m_ID )
                {
                 case 0:
                 case 1:
                    if( m_Layer == 0 )
                        z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
                    else
                        z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
                    break;
                 case 2:
                 case 3:
                                        if( m_Layer == 0 )
                                                z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1] +  (3-2*m_ID)*B_RPC_LTN/2.0;
                                        else
                                                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;         
                    break;
                 case 4:
                                        if( m_Layer == 0 )
                                                z = -B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
                                        else
                                                z = -B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
                                        break;
                 default: ;
                }
            }else // down super layer
                        {
                switch( m_ID )
                {
                                 case 0: ;
                                 case 1:
                                        if( m_Layer == 0 )
                                                z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[1]/2.0;
                                        else
                                                z = B_BOX_LT/2.0 - B_BOX_DZ[m_UpDown] - B_TOPRPC_LTS[m_Layer%2]/2.0;
                                        break;
                                 case 2:
                                        if( m_Layer == 0 )
                                                z = B_RPC_LTN - B_TOPRPC_LTS[1]/2.0;
                                        else
                                                z = B_RPC_LTN - B_TOPRPC_LTS[m_Layer%2]/2.0;
                                        break;
                                 case 3:
                                 case 4:
                        z = -B_BOX_LT/2.0 + B_BOX_DZ[m_UpDown] + (1+2*(4-m_ID))*B_RPC_LTN/2.0;
                                        break;
                                 default: ;
                                }
                        } // else, down super layer
        } // else, top segment
 
            m_ObjOrgInLoc[0] = x;
            m_ObjOrgInLoc[1] = y;
            m_ObjOrgInLoc[2] = z;
 
            // limit cut
            for(int i=0;i<3;i++) {
                    if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
            }
 
    } // else, barrel
    
    return 0;
}
 
// Set local( box ) in BES CS
void MucRpc::SetLocOrgInBes()
{
        double x, y, z;
    x = y = z = 0.;
 
        if( m_Part == BRID )
        {
                x = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * cos( m_Theta );
                y = (B_AS_RMIN[m_Layer] - AS_GAP/2.0) * sin( m_Theta );
                z = 0.;
 
        } // barrel
        else
        {
                //-------------- set x and y ----------------------
        // segment 0 as reference
                x = (E_AS_RMAX - E_BOX_DR + E_GP_DX) / 2.0;
                y = (E_AS_RMAX - E_BOX_DR + E_GP_DY) / 2.0;         
        
                // x, y signs of coordinate 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 *= cos( m_Part*MUC_PI/2.0 );
 
        }// endcap
 
        m_LocOrgInBes[0] = x;
        m_LocOrgInBes[1] = y;
        m_LocOrgInBes[2] = z;
 
        // limit cut
        for(int i=0;i<3;i++) {
                if( fabs(m_LocOrgInBes[i]) < ERR_LIMIT ) m_LocOrgInBes[i] = 0.;
        }
}
 
void MucRpc::SetObjOrgInBes()
{
        if( m_Part == BRID )
        {
        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 MucRpc::SetObjOrgInLoc()
{
        if( m_Part != BRID )
    {
                MucEntity::TransBesToLoc( m_ObjOrgInLoc, m_ObjOrgInBes, m_LocOrgInBes, m_Phi );
            // limit cut
            for(int i=0;i<3;i++) {
                    if( fabs(m_ObjOrgInLoc[i]) < ERR_LIMIT ) m_ObjOrgInLoc[i] = 0.;
            }
    }
}
 
/*
void MucRpc::SetAlignment( double dx, double dy, double dz )
{
    
        if( m_Part == BRID || m_ID == -1 )
        {
        m_ObjOrgInLoc[0] += dx;
            m_ObjOrgInLoc[1] += dy;
            m_ObjOrgInLoc[2] += dz;
        }
}
*/
 
// END