ResiAlign Class Reference

#include <ResiAlign.h>

Inheritance diagram for ResiAlign:

Public Member Functions
	ResiAlign ()
	~ResiAlign ()
void	clear ()
void	initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc, IMdcUtilitySvc *mdcUtilitySvc)
void	setParam (MdcAliParams &param)
bool	fillHist (MdcAliEvent *event)
void	updateConst (MdcAlignPar *alignPar)
	ResiAlign ()
	~ResiAlign ()
void	init (TObjArray *hlist, MdcCosGeom *pGeom)
void	mergeHist (TFile *fhist)
void	align (MdcAlignPar *alignPar)
Public Member Functions inherited from MdcAlign
	MdcAlign ()
virtual	~MdcAlign ()
Public Member Functions inherited from AlignBase
	AlignBase ()
virtual	~AlignBase ()

Static Public Member Functions
static Double_t	funResi (double *x, double *par)

Additional Inherited Members
Public Attributes inherited from MdcAlign
std::string	fixMomLab

Detailed Description

Definition at line 19 of file include/MdcAlignAlg/ResiAlign.h.

Constructor & Destructor Documentation

ResiAlign() [1/2]

ResiAlign::ResiAlign

(

)

Definition at line 10 of file ResiAlign.cpp.

{ cout << "Alignment type: ResiAlign" << endl; }

~ResiAlign() [1/2]

ResiAlign::~ResiAlign

(

)

Definition at line 12 of file ResiAlign.cpp.

{}

ResiAlign() [2/2]

ResiAlign::ResiAlign

(

)

~ResiAlign() [2/2]

ResiAlign::~ResiAlign

(

)

Member Function Documentation

align()

void ResiAlign::align ( MdcAlignPar * alignPar )

virtual

Implements AlignBase.

Definition at line 135 of file ResiAlign.cpp.

                                             {
  int    iEP;
  double par[3];
  double err[3];
  double dx;
  double dy;
  double rz;
  double rLayer[] = { 120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0,
                      120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0 };
 
  TCanvas c1( "c1", "c1", 10, 10, 700, 500 );
  c1.SetFillColor( 10 );
 
  TF1* fResPhi = new TF1( "fResPhi", funResi, 0, PI2, 3 );
  fResPhi->SetParameter( 0, 0.0 );
  fResPhi->SetParameter( 1, 0.0 );
  fResPhi->SetParameter( 2, 0.0 );
 
  for ( iEP = 0; iEP < NEP; iEP++ )
  {
    if ( ( m_gr[iEP]->GetN() ) > 500 )
    {
      // align dx, dy, rz
      m_gr[iEP]->Fit( "fResPhi", "V" );
      par[0] = fResPhi->GetParameter( 0 );
      par[1] = fResPhi->GetParameter( 1 );
      par[2] = fResPhi->GetParameter( 2 );
      err[0] = fResPhi->GetParError( 0 );
      err[1] = fResPhi->GetParError( 1 );
      err[2] = fResPhi->GetParError( 2 );
 
      // align dx and rz
      //           m_grSinPhi[iEP]->Fit("pol1");
      //           par[0] = m_grSinPhi[iEP]->GetFunction("pol1")->GetParameter(0);
      //           par[1] = m_grSinPhi[iEP]->GetFunction("pol1")->GetParameter(1);
      //           par[2] = 0.0;
      //           err[0] = m_grSinPhi[iEP]->GetFunction("pol1")->GetParError(0);
      //           err[1] = m_grSinPhi[iEP]->GetFunction("pol1")->GetParError(1);
      //           err[2] = 0.0;
 
      // align dy
      //           m_grCosPhi[iEP]->Fit("pol1");
      //           par[0] = 0.0;
      //           par[1] = 0.0;
      //           par[2] = m_grCosPhi[iEP]->GetFunction("pol1")->GetParameter(1);
      //           err[0] = 0.0;
      //           err[1] = 0.0;
      //           err[2] = m_grCosPhi[iEP]->GetFunction("pol1")->GetParError(1);
 
      dx = -1.0 * par[1];
      dy = par[2];
      rz = par[0] / rLayer[iEP];
 
      if ( 7 == iEP || 15 == iEP )
      {
        dx     = 0.0;
        dy     = 0.0;
        rz     = 0.0;
        par[0] = 0.0;
        par[1] = 0.0;
        par[2] = 0.0;
      }
      alignPar->setDelDx( iEP, dx );
      alignPar->setDelDy( iEP, dy );
      alignPar->setDelRz( iEP, rz );
 
      alignPar->setErrDx( iEP, err[1] );
      alignPar->setErrDy( iEP, err[2] );
      alignPar->setErrRz( iEP, err[0] / rLayer[iEP] );
    }
  }
  renameHist();
  delete fResPhi;
}

clear()

void ResiAlign::clear ( )

virtual

Implements MdcAlign.

Definition at line 73 of file ResiAlign.cxx.

                      {
  delete m_hresAll;
  delete m_hresInn;
  delete m_hresStp;
  delete m_hresOut;
  for ( int lay = 0; lay < LAYERNMAX; lay++ )
  {
    delete m_hresLay[lay];
    for ( int i = 0; i < 4; i++ ) delete m_hresLay_LR[lay][i];
  }
  for ( int i = 0; i < NEP; i++ ) delete m_gr[i];
}

fillHist()

bool ResiAlign::fillHist ( MdcAliEvent * event )

virtual

Implements MdcAlign.

Definition at line 198 of file ResiAlign.cxx.

                                             {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "ResiAlign" );
  log << MSG::DEBUG << "ResiAlign::fillHist()" << endmsg;
 
  bool esCutFg = event->getEsCutFlag();
  if ( !esCutFg )
  {
    m_ncut1++;
    return true;
  }
 
  int i = 0;
  int k;
 
  int    trkStat;
  double dr;
  double phi0;
  double kappa;
  double dz;
  double tanl;
  double chisq;
  double p;
  double pt;
 
  int nhits;
  int lay;
  int cel;
  int wir;
  int lr;
  int iEnd;
  int iEP;
 
  double        doca;
  double        resi;
  double        zhit;
  double        wphi;
  double        dphi;
  double        hitPhi;
  double        xx;
  double        yy;
  double        rr;
  int           stat;
  MdcAliRecTrk* rectrk;
  MdcAliRecHit* rechit;
  int           nhitlay;
  bool          fgHitLay[LAYERNMAX];
 
  IDataProviderSvc* eventSvc = NULL;
  Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
  SmartDataPtr<Event::EventHeader> eventHeader( eventSvc, "/Event/EventHeader" );
  if ( !eventHeader )
  {
    log << MSG::FATAL << "Could not find Event Header" << endmsg;
    m_ncut3++;
    return ( StatusCode::FAILURE );
  }
  int iEvt = eventHeader->eventNumber();
  int iRun = eventHeader->runNumber();
 
  int nTrk = event->getNTrk();
  m_hnTrk->Fill( nTrk );
  m_fevt << setw( 10 ) << iRun << setw( 10 ) << iEvt << setw( 10 ) << nTrk << endl;
  if ( ( nTrk < m_param.nTrkCut[0] ) || ( nTrk > m_param.nTrkCut[1] ) )
  {
    m_ncut2++;
    return true;
  }
 
  for ( i = 0; i < nTrk; i++ )
  {
    rectrk  = event->getRecTrk( i );
    nhits   = rectrk->getNHits();
    trkStat = rectrk->getStat();
    //    if (0 != trkStat) continue;
 
    // dr cut
    dr = rectrk->getDr();
    if ( fabs( dr ) > m_param.drCut )
    {
      m_ncut4++;
      continue;
    }
 
    phi0  = rectrk->getPhi0();
    kappa = rectrk->getKappa();
 
    // dz cut
    dz = rectrk->getDz();
    if ( fabs( dz ) > m_param.dzCut )
    {
      m_ncut5++;
      continue;
    }
 
    for ( lay = 0; lay < LAYERNMAX; lay++ ) { fgHitLay[lay] = false; }
 
    m_hnHit->Fill( nhits );
    for ( k = 0; k < nhits; k++ )
    {
      rechit        = rectrk->getRecHit( k );
      lay           = rechit->getLayid();
      fgHitLay[lay] = true;
    }
 
    nhitlay = 0;
    for ( lay = 0; lay < LAYERNMAX; lay++ )
    {
      if ( fgHitLay[lay] ) nhitlay++;
    }
    //    cout << "hitlay " << nhitlay << endl;
    if ( nhitlay < m_param.nHitLayCut )
    {
      m_ncut6++;
      continue;
    }
 
    tanl  = rectrk->getTanLamda();
    chisq = rectrk->getChisq();
    p     = rectrk->getP();
    pt    = rectrk->getPt();
 
    if ( ( fabs( pt ) < m_param.ptCut[0] ) || ( fabs( pt ) > m_param.ptCut[1] ) )
    {
      m_ncut7++;
      continue;
    }
 
    HepVector helix = rectrk->getHelix();
    for ( k = 0; k < nhits; k++ )
    {
      rechit = rectrk->getRecHit( k );
      lay    = rechit->getLayid();
      cel    = rechit->getCellid();
      lr     = rechit->getLR();
      doca   = rechit->getDocaInc();
      zhit   = rechit->getZhit();
 
      stat = rechit->getStat();
      if ( ( 1 == m_param.hitStatCut ) && ( 1 != stat ) )
      {
        m_ncut8++;
        continue;
      }
 
      if ( 1 == m_param.resiType ) { resi = rechit->getResiExcLR(); }
      else { resi = rechit->getResiIncLR(); }
      resi *= -1.0;
      // maqm if( (1==isnan(resi)) || (fabs(resi) > m_resiCut) ||
      if ( ( 1 == std::isnan( resi ) ) || ( fabs( resi ) > m_resiCut ) ||
           ( fabs( doca ) > m_docaMax[lay] ) || ( fabs( doca ) < m_docaMin[lay] ) )
      {
        m_ncut9++;
        continue;
      }
 
      if ( m_param.fgAdjacLayerCut )
      {
        if ( 0 == lay )
        {
          if ( !fgHitLay[1] )
          {
            m_ncut10++;
            continue;
          }
        }
        else if ( 42 == lay )
        {
          if ( !fgHitLay[41] )
          {
            m_ncut11++;
            continue;
          }
        }
        else
        {
          if ( ( !fgHitLay[lay - 1] ) && ( !fgHitLay[lay + 1] ) )
          {
            m_ncut12++;
            continue;
          }
          // for boundary layers
          if ( m_param.fgBoundLayerCut && m_layBound[lay] &&
               ( ( !fgHitLay[lay - 1] ) || ( !fgHitLay[lay + 1] ) ) )
          {
            m_ncut13++;
            continue;
          }
        }
      }
      m_hlayHitmap->Fill( lay );
 
      // fill alignment trees
      if ( ( zhit < m_zrange[lay][0] ) || ( zhit > m_zrange[lay][1] ) )
      {
        wir = m_mdcGeomSvc->Wire( lay, cel )->Id();
        xx  = ( zhit - m_zw[wir] ) * ( m_xe[wir] - m_xw[wir] ) / ( m_ze[wir] - m_zw[wir] ) +
             m_xw[wir];
        yy = ( zhit - m_zw[wir] ) * ( m_ye[wir] - m_yw[wir] ) / ( m_ze[wir] - m_zw[wir] ) +
             m_yw[wir];
        rr   = sqrt( ( xx * xx ) + ( yy * yy ) );
        dphi = fabs( doca ) / m_radii[lay];
 
        if ( yy >= 0 ) wphi = acos( xx / rr );
        else wphi = PI2 - acos( xx / rr );
        if ( 1 == lr ) hitPhi = wphi + dphi;
        else hitPhi = wphi - dphi;
        if ( hitPhi < 0 ) hitPhi += PI2;
        else if ( hitPhi > PI2 ) hitPhi -= PI2;
 
        if ( zhit < m_zrange[lay][0] ) iEnd = 0; // west
        else iEnd = 1;                           // east
        iEP = Alignment::getEpId( lay, iEnd );
 
        m_iRun[iEP] = iRun;
        m_iEvt[iEP] = iEvt;
        m_resi[iEP] = resi;
        m_p[iEP]    = p;
        m_pt[iEP]   = pt;
        m_phi[iEP]  = hitPhi;
        m_lay[iEP]  = lay;
        m_lr[iEP]   = lr;
        m_cel[iEP]  = cel;
        m_tuple[iEP]->write();
 
        m_resi[NEP] = resi;
        m_p[NEP]    = p;
        m_pt[NEP]   = pt;
        m_phi[NEP]  = hitPhi;
        m_lay[NEP]  = lay;
        m_lr[NEP]   = lr;
        m_cel[NEP]  = cel;
        m_tuple[NEP]->write();
 
        m_hresAll->Fill( resi );
        if ( lay < 8 ) m_hresInn->Fill( resi );
        else if ( lay < 20 ) m_hresStp->Fill( resi );
        else m_hresOut->Fill( resi );
        m_hresLay[lay]->Fill( resi );
        if ( 0 == lr )
        {
          if ( hitPhi < 3.14 ) m_hresLay_LR[lay][0]->Fill( resi ); // up L
          else m_hresLay_LR[lay][2]->Fill( resi );                 // down L
        }
        else
        {
          if ( hitPhi < 3.14 ) m_hresLay_LR[lay][1]->Fill( resi ); // up R
          else m_hresLay_LR[lay][3]->Fill( resi );                 // down R
        }
 
        m_gr[iEP]->SetPoint( m_npoint[iEP], hitPhi, resi );
        m_npoint[iEP]++;
      }
    }
  }
 
  return true;
}

funResi()

Double_t ResiAlign::funResi ( double * x, double * par )

static

Referenced by align(), and updateConst().

init()

void ResiAlign::init ( TObjArray * hlist, MdcCosGeom * pGeom )

virtual

Implements AlignBase.

Definition at line 14 of file ResiAlign.cpp.

                                                          {
  m_pGeom = pGeom;
  char hname[200];
  m_hnTrk = new TH1F( "mHNtrack", "", 10, -0.5, 9.5 );
  hlist->Add( m_hnTrk );
 
  m_hnHit = new TH1F( "mHNhit", "", 100, -0.5, 99.5 );
  hlist->Add( m_hnHit );
 
  m_hlayHitmap = new TH1F( "mHitmap", "", 43, -0.5, 42.5 );
  hlist->Add( m_hnHit );
 
  m_hresAll = new TH1F( "mHResAllInc", "", 200, -1.0, 1.0 );
  hlist->Add( m_hresAll );
 
  m_hresInn = new TH1F( "mHResInnInc", "", 200, -1.0, 1.0 );
  hlist->Add( m_hresInn );
 
  m_hresStp = new TH1F( "mHResStpInc", "", 200, -1.0, 1.0 );
  hlist->Add( m_hresStp );
 
  m_hresOut = new TH1F( "mHResOutInc", "", 200, -1.0, 1.0 );
  hlist->Add( m_hresOut );
 
  for ( int lay = 0; lay < LAYERNMAX; lay++ )
  {
    sprintf( hname, "mRes_Layer%02d", lay );
    m_hresLay[lay] = new TH1F( hname, "", 200, -1.0, 1.0 );
    hlist->Add( m_hresLay[lay] );
 
    for ( int i = 0; i < 4; i++ )
    {
      if ( 0 == i ) sprintf( hname, "mResi_Lay%02d_Up_L", lay );
      else if ( 1 == i ) sprintf( hname, "mResi_Lay%02d_Up_R", lay );
      else if ( 2 == i ) sprintf( hname, "mResi_Lay%02d_Dw_L", lay );
      else sprintf( hname, "mResi_Lay%02d_Dw_R", lay );
      m_hresLay_LR[lay][i] = new TH1F( hname, "", 200, -1.0, 1.0 );
      hlist->Add( m_hresLay_LR[lay][i] );
    }
  }
 
  for ( int iEP = 0; iEP < NEP; iEP++ )
  {
    m_gr[iEP] = new TGraph();
    sprintf( hname, "mgrResi%02d", iEP );
    m_gr[iEP]->SetName( hname );
    hlist->Add( m_gr[iEP] );
 
    m_grSinPhi[iEP] = new TGraph();
    sprintf( hname, "mgrResi_sinPhi%02d", iEP );
    m_grSinPhi[iEP]->SetName( hname );
    hlist->Add( m_grSinPhi[iEP] );
 
    m_grCosPhi[iEP] = new TGraph();
    sprintf( hname, "mgrResi_cosPhi%02d", iEP );
    m_grCosPhi[iEP]->SetName( hname );
    hlist->Add( m_grCosPhi[iEP] );
 
    m_npoint[iEP] = 0;
  }
}

initialize()

void ResiAlign::initialize ( TObjArray * hlist, IMdcGeomSvc * mdcGeomSvc, IMdcCalibFunSvc * mdcFunSvc, IMdcUtilitySvc * mdcUtilitySvc )

virtual

Implements MdcAlign.

Definition at line 86 of file ResiAlign.cxx.

                                                                                        {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "ResiAlign" );
  log << MSG::INFO << "ResiAlign::initialize()" << endmsg;
 
  m_hlist         = hlist;
  m_mdcGeomSvc    = mdcGeomSvc;
  m_mdcFunSvc     = mdcFunSvc;
  m_mdcUtilitySvc = mdcUtilitySvc;
 
  double zeast;
  for ( int lay = 0; lay < 43; lay++ )
  {
    zeast            = m_mdcGeomSvc->Wire( lay, 0 )->Backward().z();
    m_zrange[lay][1] = 2.0 * fabs( zeast ) / (double)m_ndiv;
    m_zrange[lay][0] = -1.0 * m_zrange[lay][1];
 
    m_radii[lay] = m_mdcGeomSvc->Layer( lay )->Radius();
  }
 
  for ( int wir = 0; wir < WIRENMAX; wir++ )
  {
    m_xe[wir] = m_mdcGeomSvc->Wire( wir )->Backward().x();
    m_ye[wir] = m_mdcGeomSvc->Wire( wir )->Backward().y();
    m_ze[wir] = m_mdcGeomSvc->Wire( wir )->Backward().z();
    m_xw[wir] = m_mdcGeomSvc->Wire( wir )->Forward().x();
    m_yw[wir] = m_mdcGeomSvc->Wire( wir )->Forward().y();
    m_zw[wir] = m_mdcGeomSvc->Wire( wir )->Forward().z();
  }
 
  char hname[200];
  int  iEP;
 
  INTupleSvc* ntupleSvc;
  Gaudi::svcLocator()->service( "NTupleSvc", ntupleSvc );
  for ( iEP = 0; iEP <= NEP; iEP++ )
  {
    if ( iEP < NEP ) sprintf( hname, "FILE137/align%02d", iEP );
    else sprintf( hname, "FILE137/alignAll" );
 
    NTuplePtr nt( ntupleSvc, hname );
    if ( nt ) m_tuple[iEP] = nt;
    else
    {
      m_tuple[iEP] = ntupleSvc->book( hname, CLID_ColumnWiseTuple, "align" );
      if ( m_tuple[iEP] )
      {
        m_tuple[iEP]->addItem( "run", m_iRun[iEP] );
        m_tuple[iEP]->addItem( "evt", m_iEvt[iEP] );
        m_tuple[iEP]->addItem( "resi", m_resi[iEP] );
        m_tuple[iEP]->addItem( "p", m_p[iEP] );
        m_tuple[iEP]->addItem( "pt", m_pt[iEP] );
        m_tuple[iEP]->addItem( "phi", m_phi[iEP] );
        m_tuple[iEP]->addItem( "lay", m_lay[iEP] );
        m_tuple[iEP]->addItem( "lr", m_lr[iEP] );
        m_tuple[iEP]->addItem( "cel", m_cel[iEP] );
      }
      else { log << MSG::FATAL << "Cannot book N-tuple:" << long( m_tuple[iEP] ) << endmsg; }
    }
  }
 
  m_hnTrk = new TH1F( "HNtrack", "", 10, -0.5, 9.5 );
  m_hlist->Add( m_hnTrk );
 
  m_hnHit = new TH1F( "HNhit", "", 100, -0.5, 99.5 );
  m_hlist->Add( m_hnHit );
 
  m_hlayHitmap = new TH1F( "Hitmap", "", 43, -0.5, 42.5 );
  m_hlist->Add( m_hlayHitmap );
 
  m_hresAll = new TH1F( "HResAllInc", "", 200, -1.0, 1.0 );
  m_hlist->Add( m_hresAll );
 
  m_hresInn = new TH1F( "HResInnInc", "", 200, -1.0, 1.0 );
  m_hlist->Add( m_hresInn );
 
  m_hresStp = new TH1F( "HResStpInc", "", 200, -1.0, 1.0 );
  m_hlist->Add( m_hresStp );
 
  m_hresOut = new TH1F( "HResOutInc", "", 200, -1.0, 1.0 );
  m_hlist->Add( m_hresOut );
 
  int lay;
  for ( lay = 0; lay < LAYERNMAX; lay++ )
  {
    sprintf( hname, "Res_Layer%02d", lay );
    m_hresLay[lay] = new TH1F( hname, "", 200, -1.0, 1.0 );
    m_hlist->Add( m_hresLay[lay] );
 
    for ( int i = 0; i < 4; i++ )
    {
      if ( 0 == i ) sprintf( hname, "Resi_Lay%02d_Up_L", lay );
      else if ( 1 == i ) sprintf( hname, "Resi_Lay%02d_Up_R", lay );
      else if ( 2 == i ) sprintf( hname, "Resi_Lay%02d_Dw_L", lay );
      else sprintf( hname, "Resi_Lay%02d_Dw_R", lay );
      m_hresLay_LR[lay][i] = new TH1F( hname, "", 200, -1.0, 1.0 );
      m_hlist->Add( m_hresLay_LR[lay][i] );
    }
  }
 
  for ( iEP = 0; iEP < NEP; iEP++ )
  {
    m_gr[iEP] = new TGraph();
    sprintf( hname, "grResi%02d", iEP );
    m_gr[iEP]->SetName( hname );
    m_hlist->Add( m_gr[iEP] );
  }
  m_fevt.open( "evt.txt" );
}

mergeHist()

void ResiAlign::mergeHist ( TFile * fhist )

virtual

Implements AlignBase.

Definition at line 76 of file ResiAlign.cpp.

                                        {
  char  hname[200];
  TH1F* hist;
  hist = (TH1F*)fhist->Get( "HNtrack" );
  m_hnTrk->Add( hist );
 
  hist = (TH1F*)fhist->Get( "HNhit" );
  m_hnHit->Add( hist );
 
  hist = (TH1F*)fhist->Get( "Hitmap" );
  m_hlayHitmap->Add( hist );
 
  hist = (TH1F*)fhist->Get( "HResAllInc" );
  m_hresAll->Add( hist );
 
  hist = (TH1F*)fhist->Get( "HResInnInc" );
  m_hresInn->Add( hist );
 
  hist = (TH1F*)fhist->Get( "HResStpInc" );
  m_hresStp->Add( hist );
 
  hist = (TH1F*)fhist->Get( "HResOutInc" );
  m_hresOut->Add( hist );
 
  for ( int lay = 0; lay < LAYERNMAX; lay++ )
  {
    sprintf( hname, "Res_Layer%02d", lay );
    hist = (TH1F*)fhist->Get( hname );
    m_hresLay[lay]->Add( hist );
 
    for ( int i = 0; i < 4; i++ )
    {
      if ( 0 == i ) sprintf( hname, "Resi_Lay%02d_Up_L", lay );
      else if ( 1 == i ) sprintf( hname, "Resi_Lay%02d_Up_R", lay );
      else if ( 2 == i ) sprintf( hname, "Resi_Lay%02d_Dw_L", lay );
      else sprintf( hname, "Resi_Lay%02d_Dw_R", lay );
      hist = (TH1F*)fhist->Get( hname );
      m_hresLay_LR[lay][i]->Add( hist );
    }
  }
 
  for ( int iEP = 0; iEP < NEP; iEP++ )
  {
    sprintf( hname, "grResi%02d", iEP );
    TGraph* gr = (TGraph*)fhist->Get( hname );
    int     np = gr->GetN();
    double  xx;
    double  yy;
    for ( int i = 0; i < np; i++ )
    {
      gr->GetPoint( i, xx, yy );
      m_gr[iEP]->SetPoint( m_npoint[iEP], xx, yy );
      m_grSinPhi[iEP]->SetPoint( m_npoint[iEP], sin( xx ), yy );
      m_grCosPhi[iEP]->SetPoint( m_npoint[iEP], cos( xx ), yy );
      m_npoint[iEP]++;
    }
  }
}

setParam()

void ResiAlign::setParam ( MdcAliParams & param )

inlinevirtual

Implements MdcAlign.

Definition at line 96 of file include/MdcAlignAlg/ResiAlign.h.

                                                     {
  MdcAlign::setParam( param );
  m_param = param;
}

updateConst()

void ResiAlign::updateConst ( MdcAlignPar * alignPar )

virtual

Implements MdcAlign.

Definition at line 458 of file ResiAlign.cxx.

                                                   {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "ResiAlign" );
  log << MSG::INFO << "ResiAlign::updateConst()" << endmsg;
  m_fevt.close();
 
  int    iEP;
  double par[3];
  double err[3];
  double dx;
  double dy;
  double rz;
  double rLayer[] = { 120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0,
                      120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0 };
 
  TCanvas c1( "c1", "c1", 10, 10, 700, 500 );
 
  TF1* fResPhi = new TF1( "fResPhi", funResi, 0, PI2, 3 );
  fResPhi->SetParameter( 0, 0.0 );
  fResPhi->SetParameter( 1, 0.0 );
  fResPhi->SetParameter( 2, 0.0 );
 
  for ( iEP = 0; iEP < NEP; iEP++ )
  {
    if ( ( m_gr[iEP]->GetN() ) > 500 )
    {
      m_gr[iEP]->Fit( "fResPhi", "V" );
      par[0] = fResPhi->GetParameter( 0 );
      par[1] = fResPhi->GetParameter( 1 );
      par[2] = fResPhi->GetParameter( 2 );
 
      err[0] = fResPhi->GetParError( 0 );
      err[1] = fResPhi->GetParError( 1 );
      err[2] = fResPhi->GetParError( 2 );
 
      dx = -1.0 * par[1];
      dy = par[2];
      rz = par[0] / rLayer[iEP];
 
      // assume the shift of the outer section is 0
      if ( 7 == iEP || 15 == iEP )
      {
        dx     = 0.0;
        dy     = 0.0;
        rz     = 0.0;
        par[0] = 0.0;
        par[1] = 0.0;
        par[2] = 0.0;
      }
      alignPar->setDelDx( iEP, dx );
      alignPar->setDelDy( iEP, dy );
      alignPar->setDelRz( iEP, rz );
 
      alignPar->setErrDx( iEP, err[1] );
      alignPar->setErrDy( iEP, err[2] );
      alignPar->setErrRz( iEP, err[0] / rLayer[iEP] );
    }
  }
 
  cout << "TrackCut: cut1: " << m_ncut1 << ",  cut2: " << m_ncut2 << ",  cut3: " << m_ncut3
       << ",  cut4: " << m_ncut4 << ",  cut5: " << m_ncut5 << ",  cut6: " << m_ncut6
       << ",  cut7: " << m_ncut7 << endl;
  cout << "HitCut:   cut8: " << m_ncut8 << ",  cut9: " << m_ncut9 << ",  cut10: " << m_ncut10
       << ",  cut11: " << m_ncut11 << ",  cut12: " << m_ncut12 << ",  cut13: " << m_ncut13
       << endl;
 
  delete fResPhi;
}

---

The documentation for this class was generated from the following files:

• include/MdcAlignAlg/ResiAlign.h
• share/distAlign/src/include/ResiAlign.h
• ResiAlign.cpp
• ResiAlign.cxx