MucStrip.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucStrip.cxx                            |
//      [Brief ]:       Class MucStrip for MUC calibration                      |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       Apil 6, 2005                                            |
//------------------------------------------------------------------------------|
 
#include<iostream>
#include<fstream>
#include<cmath>
 
using namespace std;
 
#include "MucGeoCreateAlg/MucGeoConst.h"
#include "MucGeoCreateAlg/MucStrip.h"
 
// Constructor
MucStrip::MucStrip( int part, int segment, int layer, int id ) : MucEntity( part, segment, layer, id )
{
  MucStrip::Init();
  // m_MucPadChain = NULL;
}
 
// Copy constructor
MucStrip::MucStrip( const MucStrip& other ) : MucEntity( other )
{
  m_Type        = other.m_Type;
  m_CenterLine  = other.m_CenterLine;
  m_Head        = other.m_Head;
  m_Tail        = other.m_Tail;
  m_Phi         = other.m_Phi;
 
  // m_MucPadChain  = other.m_MucPadChain;
}
 
// Operator =
MucStrip& MucStrip::operator =( const MucStrip &other )
{
  if( this == &other) return *this;
 
  MucEntity::operator =(other);
  
  m_Type        = other.m_Type;
  m_CenterLine  = other.m_CenterLine;
  m_Head        = other.m_Head;
  m_Tail        = other.m_Tail;
  m_Phi         = other.m_Phi;
  
  // m_MucPadChain  = other.m_MucPadChain;
  
  return *this;
}
 
// Destructor
MucStrip::~MucStrip()
{
  // delete m_MucPadChain;
}
 
// Initialize
void MucStrip::Init()
{
  SetType();
  SetW();
  SetWu();
  SetWd();
  SetCenterLine(); // use strip width
  SetHead();
  SetTail();
  SetPhi();
  
  SetThin();
  SetH();
  SetL();
  SetPadNumber();
  
  SetLocOrgInBes();
  SetObjRotToMot();
  
  SetEndcapStripInBes();
  SetBarrelStripInLoc();
  
  SetObjOrgInBes();
  SetObjOrgInLoc(); 
}
 
// ---------------------------------Get methods ------------------------
int    MucStrip::GetType()        { return m_Type;        }
double MucStrip::GetCenterLine()  { return m_CenterLine;  }
double MucStrip::GetHead()        { return m_Head;        }
double MucStrip::GetTail()        { return m_Tail;        }
double MucStrip::GetPhi()         { return m_Phi;         }
int    MucStrip::GetPadNumber()   { return m_PadNumber;   }
 
/*
MucPadChain* MucStrip::GetPadChain( )
{
  if( m_MucPadChain != NULL )
    return m_MucPadChain;
  else
    return ( m_MucPadChain = new MucPadChain( m_Part, m_Segment, m_Layer, m_PadNumber ) );
}
 
*/
 
//-----------------------------------Set methods-------------------------
// Set strip type(readout direction) 
void MucStrip::SetType()
{
  if( m_Part == BRID )  {
    if( (m_Layer+1)%2 == 1 )  m_Type = ZSTR;
    else                      m_Type = PHISTR;
  }
  else {
    if( (m_Layer+1)%2 == 1 )  m_Type = XSTR;
    else                      m_Type = YSTR;
  }
}
 
// Set x or y of endcap strip certerline in BES coordinate system
void MucStrip::SetCenterLine()
{
  // Base on strips width and structure correlations
  // Endcap only 
  
  int segFlag = 0;
  
  if( (m_Layer+1)%2 == 1 )  // 1,3,5,7
  {
    if( m_Segment < 2 ) segFlag = 1;
    else                segFlag = -1;
    
    if( m_ID == 0 ) m_CenterLine = segFlag * (E_GP_DY+E_STRPLN_DA+m_W/2.0); // NO.0
    else if( m_ID != E_STR_NUM-1 )                                          // NO.1~62
      m_CenterLine = segFlag * ( E_XSTR_OFFSET + m_ID*E_STR_DST );
    else                                                                    // NO.63 end strip
      m_CenterLine = segFlag * ( E_XSTR_OFFSET + (E_STR_NUM-2)*E_STR_DST + (E_STR_DST + m_W + STR_GAP)/2);
  }
  else                      // 2,4,6,8
  {
    if( m_Segment%3 == 0 )  segFlag = 1;
    else                    segFlag = -1;
    
    if( m_ID == 0 ) m_CenterLine = segFlag * (E_GP_DX+E_STRPLN_DA+m_W/2.0); // NO.0
    else if(m_ID != E_STR_NUM-1)                                            // NO.1~62
      m_CenterLine = segFlag * ( E_YSTR_OFFSET + m_ID*E_STR_DST );
    else                                                                    // NO.63 end strip
      m_CenterLine = segFlag * ( E_YSTR_OFFSET + (E_STR_NUM-2)*E_STR_DST + (E_STR_DST + m_W + STR_GAP)/2);
  }
}
 
// Set x and y of the head of endcap strip in BES coordinate system
void MucStrip::SetHead()
{
  int segFlag = 0;
  
  // base on strips width and correlations
  if( m_ID+1 < HEAD_TURN_STR_NUM[m_Layer][0] )
    m_Head = FIRST_TURN_HEAD[m_Layer][0];
  else if( m_ID+1 == HEAD_TURN_STR_NUM[m_Layer][0] )
    m_Head = FIRST_TURN_HEAD[m_Layer][1];
  else if( (m_ID+1 > HEAD_TURN_STR_NUM[m_Layer][0]) && (m_ID+1 < HEAD_TURN_STR_NUM[m_Layer][1]) )
    m_Head = FIRST_TURN_HEAD[m_Layer][1] - ( m_ID + 1 - HEAD_TURN_STR_NUM[m_Layer][0] )*E_STR_DST;
  else if( m_ID+1 >= HEAD_TURN_STR_NUM[m_Layer][1] )
    m_Head = SECOND_TURN_HEAD[m_Layer%2];
  
  
  if( (m_Layer+1)%2 == 1 )  // 1,3,5,7
  {
    if( m_Segment%3 ==0 ) segFlag = 1;
    else segFlag = -1;
  }
  else                      // 2,4,6,8
  {
    if( m_Segment < 2 ) segFlag = 1;
    else segFlag = -1;
  }
  
  m_Head *= segFlag;
}
 
// Set x and y of the tail of endcap strip in BES coordinate system
void MucStrip::SetTail()
{
  int segFlag = 0;
  
  if( (m_Layer+1)%2 == 1 )  // 1,3,5,7
  {
    if( m_Segment%3 ==0 ) segFlag = 1;
    else                  segFlag = -1;
    
    if( m_ID+1 < TAIL_TURN_STR_NUM[0] )
      m_Tail = ODD_TURN_POINT_TAIL[(m_Layer==0)?0:1][0];
    else if( m_ID+1 == TAIL_TURN_STR_NUM[0] )
      m_Tail = ODD_TURN_POINT_TAIL[(m_Layer==0)?0:1][1];
    else if( m_ID+1 > TAIL_TURN_STR_NUM[0] )
      m_Tail = ODD_TURN_POINT_TAIL[(m_Layer==0)?0:1][1]-( m_ID + 1 - TAIL_TURN_STR_NUM[0] )* E_STR_DST;
    if( m_ID == E_STR_NUM - 1 )
      m_Tail = ODD_TURN_POINT_TAIL[(m_Layer==0)?0:1][1]-( m_ID -TAIL_TURN_STR_NUM[0] ) * E_STR_DST - ( E_STR_DST + m_W + STR_GAP )/2;
  }
  else                       // 2,4,6,8
  {
    if( m_Segment < 2 ) segFlag = 1;
    else                segFlag = -1;
    
    if( m_ID+1 < TAIL_TURN_STR_NUM[1] )
      m_Tail = EVEN_TURN_POINT_TAIL[0];
    if( m_ID+1 == TAIL_TURN_STR_NUM[1] )
      m_Tail = EVEN_TURN_POINT_TAIL[1];
    if( m_ID+1 > TAIL_TURN_STR_NUM[1] )
      m_Tail = EVEN_TURN_POINT_TAIL[1] - ( m_ID + 1 - TAIL_TURN_STR_NUM[1] ) * E_STR_DST;
    if( m_ID == E_STR_NUM - 1 )
      m_Tail = EVEN_TURN_POINT_TAIL[1]-(m_ID - TAIL_TURN_STR_NUM[1]) * E_STR_DST - ( E_STR_DST + m_W + STR_GAP )/2;
  }
  
  m_Tail *= segFlag;
}
 
// Set inclination angle of local coordinate x axis and global coordinate x axis
void MucStrip::SetPhi()
{
  if ( m_Part == BRID ) // barrel 
    m_Phi = B_PHI[m_Segment] * (MUC_PI/4.0);      
  else                 // endcap , all phi is zer
    m_Phi = 0.;   
}
 
// set strip thickness
void MucStrip::SetThin()
{
  m_Thin = STR_TH;
}
 
// Set strip width
void MucStrip::SetW()
{
  if( m_Part == BRID )
  {
    // Set maximum strip 
    int maxStrip;
    if( (m_Layer+1)%2 == 1 )
      maxStrip = B_ZSTR_NUM;      // odd layer
    else if( m_Segment != B_TOP )
      maxStrip = B_PHISTR_NUM;    // even layer not top segment
    else
      maxStrip = B_TOPSTR_NUM;    // even layer top segment
    
    if( (m_Layer+1)%2 == 1 )  // odd layer, z
    {
      if( m_ID > 0 && m_ID < (maxStrip-1))  // not marginal strip
        m_W = B_STR_DST[m_Layer] - STR_GAP;
      else                                  // marginal strip
        m_W = (B_BOX_WT[m_Layer] - 2*B_BOX_DT[SL_DOWN] - (maxStrip-2)*B_STR_DST[m_Layer] - STR_GAP)/2;
    }
    else                      // even layer, phi
    {
      if( m_ID >0 && m_ID < (maxStrip-1) )                    // not marginal strip
        m_W = B_STR_DST[m_Layer] - STR_GAP;
      else                                                    // marginal strip
        m_W = B_BOX_LT/2 - B_BOX_DZ[SL_DOWN] - B_STR_DST[m_Layer]*(B_PHISTR_NUM-2)/2;
      
      if( (maxStrip == B_TOPSTR_NUM) && (m_ID == (B_PHISTR_NUM - 1)) )  // special marginal strip
        m_W = B_BOX_LT/2 - B_BOX_DZ[SL_DOWN] - B_STR_DST[m_Layer]*(B_PHISTR_NUM-2)/2;
    }
  } // End barrel
  else
  {
    // Strip0:48;
    // Strip1~62: 33;
    // Strip63:   L0: 34; L2/4/6: 43; L1/3/5/7: 53 
    if(m_ID ==0 ) m_W = E_FIRST_STR_WT;
    else if(m_ID != E_STR_NUM-1) m_W = E_STR_WT; // NO.1~62
    else // NO.63, end strip
    {
      if((m_Layer+1)%2!=0)  // 0,2,4,6
      {
        if(m_Layer==0) m_W = 31;
        else m_W = 43;
      }
      else m_W = 53;        // 1,3,5,7
    }
  }
}
 
// Set strip Wu, no use
void MucStrip::SetWu()
{
  m_Wu = m_W;
}
 
// Set strip Wd, no use
void MucStrip::SetWd()
{
  m_Wd = m_W;
}
 
// Set strip height
void MucStrip::SetH()
{
  m_H = STR_TH;
}
 
// Set strip length 
void MucStrip::SetL()
{
  if( m_Part==BRID )    // barrel
  {
    int ZCUT_HEAD_NUM = B_ZSTR_NUM/2 - B_ZSTR_CUT_NUM[m_Layer] - 1;
    int ZCUT_TAIL_NUM = B_ZSTR_NUM/2 + B_ZSTR_CUT_NUM[m_Layer];
    
    if( m_Segment != B_TOP ) // not top segment
    {
      if( (m_Layer+1)%2 == 1) // odd layer, Z 
        m_L = B_BOX_LT - 2*B_BOX_DZ[SL_DOWN];
      else                    // even layer, phi
        m_L = B_BOX_WT[m_Layer] - 2*B_BOX_DZ[SL_DOWN];
    }
    else            // top segment
    {
      if((m_Layer+1)%2 == 1)  // odd layer, z
      {
        if( m_ID > ZCUT_HEAD_NUM && m_ID < ZCUT_TAIL_NUM )  // be cut
        {
          if( m_Layer == 0 )
            m_L = B_BOX_LT - 2*B_BOX_DZ[SL_DOWN] - B_ZSTR_CUT[1];
          else
            m_L = B_BOX_LT - 2*B_BOX_DZ[SL_DOWN] - B_ZSTR_CUT[0];
        }
        else  // no cut
          m_L = B_BOX_LT - 2*B_BOX_DZ[SL_DOWN];
      }
      else                    // even layer, phi
      {
        if( m_ID < B_PHISTR_CUT_NUM ) // no cut
          m_L = B_BOX_WT[m_Layer] - 2*B_BOX_DZ[SL_DOWN];
        else                          // be cut
          m_L = (B_BOX_WT[m_Layer] - 2*B_BOX_DZ[SL_DOWN] - B_PHISTR_CUT)/2;
      }
    } // End top segment
  }
  else  // endcap
    m_L = fabs( m_Head - m_Tail );
}
 
// Set area cm^2
void MucStrip::SetArea()
{
  m_Area = m_W*m_L/100;
}
 
// Set Pad number of strip
void MucStrip::SetPadNumber()
{
  int    n        = 0;
  double fn       = 0;
  
  if(m_W == 0) {
    cout<<"Error, strip width = 0!"<<endl;
    m_PadNumber = 0;
  }
  else
  {
    fn = (m_L/m_W);
    n  = (int)fn;
    
    if( (fn - n) > 0.3 )  m_PadNumber = n + 1;
    else                  m_PadNumber = n;
  }
}
 
 
// Set local or temporary local(MucStripPlane) origin coordinates in BES
void MucStrip::SetLocOrgInBes()
{
  double x, y, z = 0 ;
  
  if( m_Part == BRID )
  {
    x = ( B_AS_RMIN[m_Layer] - AS_GAP/2.0 ) * cos( m_Segment * ( MUC_PI/4.0 ) );
    y = ( B_AS_RMIN[m_Layer] - AS_GAP/2.0 ) * sin( m_Segment * ( MUC_PI/4.0 ) );
    z = 0.;
  } // barrel
  else
  {
    //------------- set x and y --------------------
    // segment 0 as reference 
    x = (E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + E_GP_DX + E_STRPLN_DA) / 2.0;
    y = (E_AS_RMAX - E_BOX_DR - E_STRPLN_DB[(m_Layer==0)?0:1] + E_GP_DY + E_STRPLN_DA) / 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 );
  } // else, 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 MucStrip::SetObjRotToMot()
{
  // The x, y and z of strip coordinate system is always parallele with those of strip plane  
  for( int i=0; i<3; i++ )
    m_ObjRotToMot[i] = 0.0;
}
*/
 
// Set endcap strip origin coordinates in global
void MucStrip::SetEndcapStripInBes()
{   
  double x, y, z;
  
  // Set x 
  if( (m_Layer+1)%2 == 0 )  // even layer
    x = m_CenterLine;
  else                      // odd layer
    x = ( m_Head + m_Tail )/2;
  
  // Set y
  if( (m_Layer+1)%2 == 0 )  // even layer
    y = ( m_Head + m_Tail )/2;
  else                      // odd layer
    y = m_CenterLine;
  
  // Set z
  z = 0.;
  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 + z) + AS_GAP/2.0 ) * 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.; 
}
 
// Set x, y and z of barrel strip origin in local or temparory local(MucStripPlane) coordinate
void MucStrip::SetBarrelStripInLoc()
{
  int j = m_Layer;
  int n = m_ID;
  
  int maxStrip = 0;
  double x, y, z = 0;
   
  if( m_Type == ZSTR )          maxStrip = B_ZSTR_NUM;    // odd layer
  else if( m_Segment != B_TOP ) maxStrip = B_PHISTR_NUM;  // even layer not top segment
  else                          maxStrip = B_TOPSTR_NUM;  // even layer top segment
  
  if( m_Segment != B_TOP )  // not top segment
  {
    if( m_Type == ZSTR )  // odd layer, ZSTR
    {
    // Set x
    if( n == 0 )
    x = ( B_BOX_WT[j] - 2*B_BOX_DT[SL_DOWN] +  (maxStrip-2)*B_STR_DST[j] + STR_GAP )/4.0;
    else if( n == (maxStrip-1) )
    x = ( 2*B_BOX_DT[SL_DOWN] - B_BOX_WT[j] - (maxStrip-2)*B_STR_DST[j] - STR_GAP )/4.0;
    else
    x =( ((maxStrip-1) - 2*n) * B_STR_DST[j] )/2.0;
    
    // Set y
    y = 0.;
    
    // Set z
    z = 0.;
    }
    else                  // even layer, phi
    {
      // Set x
      x = 0.;
      
      // Set y
      y = 0.;
      
      // Set Z
      if( n == 0 )
        z = -B_BOX_LT/4.0 + B_BOX_DZ[SL_DOWN]/2.0 - B_STR_DST[j]*(B_PHISTR_NUM-2)/4.0;
      else if( n == (B_PHISTR_NUM - 1) )
        z = B_BOX_LT/4.0 - B_BOX_DZ[SL_DOWN]/2.0 + B_STR_DST[j]*(B_PHISTR_NUM-2)/4.0;
      else
        z = ( 2*n - B_PHISTR_NUM + 1 ) * B_STR_DST[j] / 2.0;
    }
  }     // end not top segment
  else  // top segment
  {
    if( m_Type == ZSTR )  // odd layer, z
    {
      // Set x
      if( n == 0 )
        x = B_BOX_WT[j]/4.0 - B_BOX_DT[SL_DOWN]/2.0 +  (maxStrip-2)*B_STR_DST[j]/4.0 + STR_GAP/4.0;
      else if( n == (maxStrip-1) )
        x = -B_BOX_WT[j]/4.0 + B_BOX_DT[SL_DOWN]/2.0 -  (maxStrip-2)*B_STR_DST[j]/4.0 - STR_GAP/4.0;
      else
        x = ( (maxStrip-1) - 2*n ) * B_STR_DST[j] / 2.0;
      
      // Set y
      y = 0.;
      
      // Set z
      if( (n > (B_ZSTR_NUM/2 - 1 - B_ZSTR_CUT_NUM[j])) && (n < (B_ZSTR_NUM/2 + B_ZSTR_CUT_NUM[j])) )    // be cut
        z = -( (j==0) ? B_ZSTR_CUT[1] : B_ZSTR_CUT[0] )/2;
      else  // no cut
        z = 0.;
    } 
    else                  // even layer, phi
    {
      // Set x
      if( n < B_PHISTR_CUT_NUM )  // no cut
        x = 0.; 
      else                        // be cut
      {
        if( n < B_PHISTR_NUM )
          x = -B_BOX_WT[j]/4.0 - B_PHISTR_CUT/4.0 + B_BOX_DZ[SL_DOWN]/2.0;
        else
          x = B_BOX_WT[j]/4.0 + B_PHISTR_CUT/4.0 - B_BOX_DZ[SL_DOWN]/2.0;
      }
      
      // Set y 
      y = 0.;
      
      // Set z
      if( n < B_PHISTR_NUM )
      {
        if( n == 0 )
          z = -B_BOX_LT/4.0 + B_BOX_DZ[SL_DOWN]/2.0 - B_STR_DST[j]*(B_PHISTR_NUM-2)/4.0;
        else if( n == (B_PHISTR_NUM - 1) )
          z = B_BOX_LT/4.0 - B_BOX_DZ[SL_DOWN]/2.0 + B_STR_DST[j]*(B_PHISTR_NUM-2)/4.0;
        else
          z = ( 2*n - B_PHISTR_NUM + 1 ) * B_STR_DST[j] / 2.0;
      }
      else
      {
        if( n == (B_TOPSTR_NUM-1) )
          z = B_BOX_LT/4.0 - B_BOX_DZ[SL_DOWN]/2.0 + B_STR_DST[j]*(B_PHISTR_NUM-2)/4.0;
        else
          z = ( 2*n - 3*B_PHISTR_NUM + 2*B_PHISTR_CUT_NUM + 1 ) * B_STR_DST[j]/2.0;
      }
    } // end even       
  } // end 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.;
  } 
}
 
// Set strip origin in global coordinates
void MucStrip::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.0;
  }
}
 
// Set strip local and global coordinates
void MucStrip::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.;
  }
}
 
// END