MdcCalibAlg/share/distcalib/src/MdcCosGeom.cpp

Go to the documentation of this file.

#include "include/MdcCosGeom.h"
 
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
 
using namespace std;
 
MdcCosGeom::MdcCosGeom( std::string fwireconf, std::string falign )
    : m_fwconf( fwireconf ), m_falign( falign ) {
  // constructor
  int ilay;
  int icell;
  for ( ilay = 0; ilay < LAYERNMAX; ilay++ )
  {
    for ( icell = 0; icell < CELLNMAX; icell++ ) { m_wiretable[ilay][icell] = -1; }
  }
 
  for ( int i = 0; i < 12; i++ )
  {
    m_iTXf = 0;
    m_iTXb = 8;
    m_iTYf = 16;
    m_iTYb = 24;
    m_iTZf = 32;
    m_iTZb = 40;
 
    m_iRXf = 48;
    m_iRXb = 56;
    m_iRYf = 64;
    m_iRYb = 72;
    m_iRZf = 80;
    m_iRZb = 88;
  }
 
  m_rot = 0.0;
 
  int ipream;
  for ( ilay = 0; ilay < LAYERNMAX; ilay++ )
  {
    for ( ipream = 0; ipream < 100; ipream++ ) { m_fan[ilay][ipream] = -999; }
  }
 
  cout << "INFO:    MdcCosGeom created." << endl;
}
 
MdcCosGeom::~MdcCosGeom() {
  // destructor
  int i;
  for ( i = 0; i < WIRENMAX; i++ ) { delete m_pwire[i]; }
  for ( i = 0; i < LAYERNMAX; i++ ) { delete m_player[i]; }
 
  cout << "INFO:    MdcCosGeom has been destructed." << endl;
}
 
bool MdcCosGeom::initialize( double rot ) {
  m_rot = rot * PI / 180.0;
  if ( !initWire() )
  {
    cout << "ERROR:  Intialize wire failed !!!" << endl;
    return false;
  }
  return true;
}
 
bool MdcCosGeom::initWire() {
  int iwire = 0;
  int ilay;
  int icell;
  int ampid;
  int channel;
  int iFan;
 
  char wirelabel[100];
  char wiretag[100];
 
  int    ncell;
  int    first;
  double radius;
  double twist;
  double length;
  double offset;
  string strtmp;
 
  double aglstart;
  double angleforwini;
  double angleforw;
  double angleback;
 
  int layertype;
 
  double xf;
  double yf;
  double zf;
  double xb;
  double yb;
  double zb;
 
  double slant;
 
  double tension[] = { 15, 15, 15, 16, 16, 17, 17, 18, 14, 14, 19, 19, 24, 24, 31,
                       31, 37, 37, 45, 45, 46, 47, 47, 47, 47, 48, 48, 48, 48, 49,
                       49, 49, 49, 50, 50, 50, 51, 51, 51, 52, 52, 52, 52 };
 
  int iEle;     // index of the element for alignment
  int iPar[12]; // index of alignment paramter
 
  if ( !initAlign() ) { return false; }
 
  if ( !initPream() ) { return false; }
 
  ifstream fin( m_fwconf.c_str() );
  if ( !fin.is_open() )
  {
    cout << "ERROR:   can not open file " << m_fwconf << endl;
    return false;
  }
 
  for ( ilay = 0; ilay < LAYERNMAX; ilay++ )
  {
    fin >> strtmp >> radius >> ncell >> twist >> offset >> length >> first;
 
    length -= 4.0; // wulh test on 2007-05-08
    ncell /= 2;
 
    if ( fabs( twist ) > 0.1 ) { offset = 0.0; }
 
    aglstart = ( PI / ncell ) * first + ( offset * PI / 180.0 );
    if ( aglstart < -0.000001 ) { aglstart += 2.0 * PI / ncell; }
 
    if ( twist < -0.1 ) { layertype = 1; }
    else if ( twist > 0.1 ) { layertype = 2; }
    else { layertype = 0; }
 
    slant = atan( sin( PI * twist / ncell ) * radius * 2.0 / length );
 
    m_player[ilay] = new MdcCosLayer;
    m_player[ilay]->setLayerType( layertype );
    m_player[ilay]->setNcell( ncell );
    m_player[ilay]->setLayerRad( radius );
    m_player[ilay]->setLength( length );
    m_player[ilay]->setTwistCell( twist );
    m_player[ilay]->setSlant( slant );
 
    if ( ilay < INNERNMAX ) m_player[ilay]->setFgInner( true );
    else m_player[ilay]->setFgInner( false );
 
    // set the index of the element for alignment
    if ( ilay < 8 ) { iEle = 0; }
    else if ( ilay < 10 ) { iEle = 1; }
    else if ( ilay < 12 ) { iEle = 2; }
    else if ( ilay < 14 ) { iEle = 3; }
    else if ( ilay < 16 ) { iEle = 4; }
    else if ( ilay < 18 ) { iEle = 5; }
    else if ( ilay < 20 ) { iEle = 6; }
    else { iEle = 7; }
 
    iPar[0]  = iEle + m_iTXf; // TXf
    iPar[1]  = iEle + m_iTXb; // TXb
    iPar[2]  = iEle + m_iTYf; // TYf
    iPar[3]  = iEle + m_iTYb; // TYb
    iPar[4]  = iEle + m_iTZf; // TZf
    iPar[5]  = iEle + m_iTZb; // TZb
    iPar[6]  = iEle + m_iRXf; // RXf
    iPar[7]  = iEle + m_iRXb; // RXb
    iPar[8]  = iEle + m_iRYf; // RYf
    iPar[9]  = iEle + m_iRYb; // RTb
    iPar[10] = iEle + m_iRZf; // RZf
    iPar[11] = iEle + m_iRZb; // RZb
 
    m_player[ilay]->setAlignParId( iPar );
 
    for ( icell = 0; icell < ncell; icell++ )
    {
      m_wiretable[ilay][icell] = iwire;
      angleforwini             = (double)icell * 2.0 * PI / ncell + aglstart;
 
      // forward endpoint
      angleforw = angleforwini + m_alignPar[iEle + m_iRZf];
      angleforw += m_rot;
 
      xf = radius * cos( angleforw );
      yf = radius * sin( angleforw );
      zf = 0.5 * length;
 
      xf += m_alignPar[iEle + m_iTXf];
      yf += m_alignPar[iEle + m_iTYf];
      zf += m_alignPar[iEle + m_iTZf];
 
      // backward endpoint
      angleback = angleforwini + twist * 2.0 * PI / ncell;
      angleback += m_alignPar[iEle + m_iRZb];
      angleback += m_rot;
 
      xb = radius * cos( angleback );
      yb = radius * sin( angleback );
      zb = -0.5 * length;
 
      xb += m_alignPar[iEle + m_iTXb];
      yb += m_alignPar[iEle + m_iTYb];
      zb += m_alignPar[iEle + m_iTZb];
 
      ampid   = icell / 8;
      channel = icell - 8 * ampid;
      sprintf( wirelabel, "%02dS%02d-%d", ilay + 1, ampid + 1, channel + 1 );
      sprintf( wiretag, "%02d_%02d_%04d_%02d", ilay, icell, iwire, ampid + 1 );
 
      m_pwire[iwire] = new MdcCosWire;
 
      m_pwire[iwire]->setLayerPtr( m_player[ilay] );
 
      m_pwire[iwire]->setWireId( iwire );
      m_pwire[iwire]->setLayerId( ilay );
      m_pwire[iwire]->setCellId( icell );
      m_pwire[iwire]->setPreAmpId( ampid + 1 );
      m_pwire[iwire]->setChannel( channel );
 
      // set fanID
      iFan = m_fan[ilay][ampid];
      //           m_pwire[iwire] -> setFanId( abs(iFan) - 1 );
      m_pwire[iwire]->setFanId( abs( iFan ) ); // begin from 1
      if ( iFan > 0 ) m_pwire[iwire]->setEndId( 1 );
      else m_pwire[iwire]->setEndId( -1 );
 
      m_pwire[iwire]->setWireLabel( wirelabel );
      m_pwire[iwire]->setWireTag( wiretag );
 
      m_pwire[iwire]->setXf( xf );
      m_pwire[iwire]->setYf( yf );
      m_pwire[iwire]->setZf( zf );
 
      m_pwire[iwire]->setXb( xb );
      m_pwire[iwire]->setYb( yb );
      m_pwire[iwire]->setZb( zb );
 
      if ( angleforw < 0 ) angleforw += 2.0 * PI;
      m_pwire[iwire]->setPhiForward( angleforw );
 
      m_pwire[iwire]->setTension( tension[ilay] );
 
      iwire++;
    }
  }
  fin.close();
  cout << "INFO:    Number of wires: " << iwire << endl;
  m_nWire  = iwire;
  m_nLayer = LAYERNMAX;
 
  return true;
}
 
bool MdcCosGeom::initAlign() {
  ifstream falign( m_falign.c_str() );
  if ( !falign.is_open() )
  {
    cout << "ERROR:   can not open alignment data file " << m_falign << endl;
    return false;
  }
 
  cout << "INFO:     Alignment data file is " << m_falign << endl;
 
  int    i;
  string str;
  getline( falign, str );
 
  for ( i = 0; i < 8; i++ )
  {
    falign >> str >> m_alignPar[i + m_iTXf] >> m_alignPar[i + m_iTYf] >>
        m_alignPar[i + m_iTZf] >> m_alignPar[i + m_iRXf] >> m_alignPar[i + m_iRYf] >>
        m_alignPar[i + m_iRZf];
 
    // mrad -> rad
    m_alignPar[i + m_iRXf] *= 0.001;
    m_alignPar[i + m_iRYf] *= 0.001;
    m_alignPar[i + m_iRZf] *= 0.001;
  }
 
  for ( i = 0; i < 8; i++ )
  {
    falign >> str >> m_alignPar[i + m_iTXb] >> m_alignPar[i + m_iTYb] >>
        m_alignPar[i + m_iTZb] >> m_alignPar[i + m_iRXb] >> m_alignPar[i + m_iRYb] >>
        m_alignPar[i + m_iRZb];
 
    // mrad -> rad
    m_alignPar[i + m_iRXb] *= 0.001;
    m_alignPar[i + m_iRYb] *= 0.001;
    m_alignPar[i + m_iRZb] *= 0.001;
  }
 
  falign.close();
 
  return true;
}
 
bool MdcCosGeom::initPream() {
  int  i;
  int  k;
  int  iEnd;
  char fname[100];
 
  int lay;
  int ipream;
 
  for ( k = 0; k < 2; k++ )
  {
    for ( i = 0; i < 8; i++ )
    {
      if ( 0 == k )
      {
        sprintf( fname, "pream/east%d.dat", i + 1 );
        iEnd = 1;
      }
      else
      {
        sprintf( fname, "pream/west%d.dat", i + 1 );
        iEnd = -1;
      }
 
      ifstream fin( fname );
      while ( fin >> lay )
      {
        fin >> ipream;
        m_fan[lay - 1][ipream - 1] = ( i + 1 ) * iEnd;
      }
      fin.close();
      fin.clear();
    }
  }
  return true;
}
 
bool MdcCosGeom::setTension() { return true; }
 
void MdcCosGeom::check( string fchk ) const {
  ofstream fout( fchk.c_str() );
  for ( int iwire = 0; iwire < 6796; iwire++ )
  {
    fout << setw( 4 ) << iwire;
    fout << setw( 6 ) << getWire( iwire )->getWireId();
    fout << setw( 4 ) << getWire( iwire )->getLayerId();
    fout << setw( 5 ) << getWire( iwire )->getCellId();
    fout << setw( 15 ) << getWire( iwire )->getXb();
    fout << setw( 15 ) << getWire( iwire )->getYb();
    fout << setw( 7 ) << getWire( iwire )->getZb();
    fout << setw( 15 ) << getWire( iwire )->getXf();
    fout << setw( 15 ) << getWire( iwire )->getYf();
    fout << setw( 7 ) << getWire( iwire )->getZf();
    fout << endl;
  }
  fout.close();
 
  cout << fchk << " has been created for check." << endl;
}
 
const MdcCosWire* MdcCosGeom::getWire( int ilay, int icell ) const {
  assert( ilay < LAYERNMAX );
  assert( icell < getLayer( ilay )->getNcell() );
 
  int iwire = m_wiretable[ilay][icell];
 
  return m_pwire[iwire];
}
 
const void MdcCosGeom::getAlignPar( double alignPar[] ) const {
  for ( int i = 0; i < 96; i++ ) { alignPar[i] = m_alignPar[i]; }
 
  for ( int k = 0; k < 8; k++ )
  {
    alignPar[k + m_iRXf] *= 1000.0;
    alignPar[k + m_iRYf] *= 1000.0;
    alignPar[k + m_iRZf] *= 1000.0;
  }
}