MucStrip.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucStrip.cxx                            |
//      [Brief ]:       Class MucStrip for MUC calibration                      |
//      [Author]:       Xie Yuguang, <ygxie@mail.ihep.ac.cn>                    |
//      [Date  ]:       Apil 6, 2005                                            |
//------------------------------------------------------------------------------|
 
#include <cmath>
#include <fstream>
#include <iostream>
 
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