/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Mdc/MdcAlignAlg/MdcAlignAlg-00-01-04/share/distAlign/src/MdcCosGeom.cpp

Go to the documentation of this file.

#include "include/MdcCosGeom.h"

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <cstdlib>

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;
     }
}

---