Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

MdcCalibFunSvc Class Reference

#include <MdcCalibFunSvc.h>

Inheritance diagram for MdcCalibFunSvc:

IMdcCalibFunSvc IMdcCalibFunSvc List of all members.

Public Member Functions

double distToDriftTime (double dist, int layid, int cellid, int lr, double entrance=0.0) const
double distToDriftTime (double dist, int layid, int cellid, int lr, double entrance=0.0) const
double distToRawTimeNoTOF (double dist, int layid, int cellid, int lr, double entrance=0.0, double Q=1000.0) const
double distToRawTimeNoTOF (double dist, int layid, int cellid, int lr, double entrance=0.0, double Q=1000.0) const
double driftTimeToDist (double drifttime, int layid, int cellid, int lr, double entrance=0.0) const
double driftTimeToDist (double drifttime, int layid, int cellid, int lr, double entrance=0.0) const
virtual StatusCode finalize ()
virtual StatusCode finalize ()
double getDelT0 (int wireid) const
double getDelT0 (int wireid) const
double getF (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getF (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
int getNextSdpar (int &key, double &par)
int getNextSdpar (int &key, double &par)
int getNextXtpar (int &key, double &par)
int getNextXtpar (int &key, double &par)
double getQtpar (int layid, int ord) const
double getQtpar (int layid, int ord) const
int getSdEntrIndex (double entrance) const
int getSdEntrIndex (double entrance) const
void getSdpar (int layid, int entr, int lr, double par[]) const
void getSdpar (int layid, int entr, int lr, double par[]) const
double getSigma (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigma (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigma1 (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigma1 (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigma2 (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigma2 (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigmaLR (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getSigmaLR (int layid, int lr, double dist, double entrance=0.0, double tanlam=0.0, double z=0.0, double Q=1000.0) const
double getT0 (int wireid) const
double getT0 (int layid, int cellid) const
double getT0 (int wireid) const
double getT0 (int layid, int cellid) const
double getTimeWalk (int layid, double Q) const
double getTimeWalk (int layid, double Q) const
double getTprop (int lay, double z) const
double getTprop (int lay, double z) const
double getVprop (int lay) const
double getVprop (int lay) const
int getXtEntrIndex (double entrance) const
int getXtEntrIndex (double entrance) const
void getXtpar (int layid, int entr, int lr, double par[]) const
void getXtpar (int layid, int entr, int lr, double par[]) const
void handle (const Incident &)
void handle (const Incident &)
virtual StatusCode initialize ()
virtual StatusCode initialize ()
 MdcCalibFunSvc (const std::string &name, ISvcLocator *svcloc)
 MdcCalibFunSvc (const std::string &name, ISvcLocator *svcloc)
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvUnknown)
double rawTimeNoTOFToDist (double rawtimeNoTOF, int layid, int cellid, int lr, double entrance=0.0, double Q=1000.0) const
double rawTimeNoTOFToDist (double rawtimeNoTOF, int layid, int cellid, int lr, double entrance=0.0, double Q=1000.0) const
double rawTimeToDriftT (double rawtime, int layid, int cellid, double Q) const
double rawTimeToDriftT (double rawtime, int layid, int cellid, double Q) const
void setSdBegin ()
void setSdBegin ()
void setXtBegin ()
void setXtBegin ()
 ~MdcCalibFunSvc ()
 ~MdcCalibFunSvc ()

Static Public Member Functions

const InterfaceID & interfaceID ()
const InterfaceID & interfaceID ()

Public Attributes

int m_run

Private Member Functions

int getSdKey (int layid, int entr, int lr, int bin) const
int getSdKey (int layid, int entr, int lr, int bin) const
int getSdparId (int layid, int entr, int lr, int bin) const
int getSdparId (int layid, int entr, int lr, int bin) const
int getXtKey (int layid, int entr, int lr, int ord) const
int getXtKey (int layid, int entr, int lr, int ord) const
int getXtparId (int layid, int entr, int lr, int ord) const
int getXtparId (int layid, int entr, int lr, int ord) const
bool initCalibConst ()
bool initCalibConst ()

Private Attributes

std::vector< double > m_delt0
std::vector< double > m_delt0
int m_layInfSig
IDataProviderSvc * m_pCalDataSvc
IDataProviderSvc * m_pCalDataSvc
IMdcGeomSvc * m_pMdcGeomSvc
IMdcGeomSvc * m_pMdcGeomSvc
ICalibRootSvc * m_pRootSvc
ICalibRootSvc * m_pRootSvc
std::vector< double > m_qtpar0
std::vector< double > m_qtpar0
std::vector< double > m_qtpar1
std::vector< double > m_qtpar1
std::map< int, double >::iterator m_sditer
std::map< int, double >::iterator m_sditer
std::map< int, double > m_sdmap
std::map< int, double > m_sdmap
std::vector< double > m_sdpar
std::vector< double > m_sdpar
std::vector< double > m_t0
std::vector< double > m_t0
std::map< int, double >::iterator m_xtiter
std::map< int, double >::iterator m_xtiter
std::map< int, double > m_xtmap
std::map< int, double > m_xtmap
std::vector< double > m_xtpar
std::vector< double > m_xtpar
double m_zst [43]

Static Private Attributes

const int NLAYER = 43
const int NSDBIN = 24
const int NWIRE = 6796
const int NXTORD = 6
const int NXTPAR = 8
const int SDBIN_DECO = 0x1F
const int SDBIN_INDEX = 0
const int SDBIN_MASK = 0x1F
const int SDENTRA_DECO = 0x7
const int SDENTRA_INDEX = 7
const int SDENTRA_MASK = 0x380
const int SDLAYER_DECO = 0x3F
const int SDLAYER_INDEX = 10
const int SDLAYER_MASK = 0xFC00
const int SDLR_DECO = 0x3
const int SDLR_INDEX = 5
const int SDLR_MASK = 0x60
const int XTENTRA_DECO = 0x1F
const int XTENTRA_INDEX = 6
const int XTENTRA_MASK = 0x7C0
const int XTLAYER_DECO = 0x3F
const int XTLAYER_INDEX = 11
const int XTLAYER_MASK = 0x1F800
const int XTLR_DECO = 0x3
const int XTLR_INDEX = 4
const int XTLR_MASK = 0x30
const int XTORDER_DECO = 0xF
const int XTORDER_INDEX = 0
const int XTORDER_MASK = 0xF

Constructor & Destructor Documentation

MdcCalibFunSvc::MdcCalibFunSvc (  const std::string &  name,
ISvcLocator *  svcloc
) 
  

00032                                                                        :
00033      Service (name, svcloc), m_layInfSig(-1) {
00034 
00035      // declare properties
00036      declareProperty("LayerInfSig", m_layInfSig);
00037 }

MdcCalibFunSvc::~MdcCalibFunSvc (   ) 
  

00039                                {
00040 }

MdcCalibFunSvc::MdcCalibFunSvc (  const std::string &  name,
ISvcLocator *  svcloc
) 
 

MdcCalibFunSvc::~MdcCalibFunSvc (   ) 
 

Member Function Documentation

double MdcCalibFunSvc::distToDriftTime (  double  dist,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::distToDriftTime (  double  dist,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00148                                                                       {
00149      int i = 0;
00150      double time;
00151      int ord;
00152      double xtpar[8];
00153      double dxdtpar[5];
00154      double x;
00155      double dxdt;
00156      double deltax;
00157 
00158      int entr = getXtEntrIndex(entrance);
00159      getXtpar(layid, entr, lr, xtpar);
00160 
00161      double tm1 = xtpar[6];
00162      double tm2 = 2000.0;
00163      double dm1 = driftTimeToDist(tm1, layid, cellid, lr, entrance);
00164      double dm2 = driftTimeToDist(tm2, layid, cellid, lr, entrance);
00165 
00166      if(dist < 0){
00167           cout << "Warning in MdcCalibFunSvc: driftDist < 0" << endl;
00168           time = 0.0;
00169      } else if(dist < xtpar[0]){
00170           time = 0.0;
00171      } else if(dist < dm1){
00172           for(ord=0; ord<5; ord++){
00173                dxdtpar[ord] = (double)(ord+1) * xtpar[ord+1];
00174           }
00175           time = dist / 0.03;
00176           while(1){
00177                if( i > 50 ){
00178                     cout << "Warning in MdcCalibFunSvc: "
00179                          << "can not get the exact value in the dist-to-time conversion." 
00180                          << endl;
00181                     time = dist / 0.03;
00182                     break;
00183                }
00184 
00185                x = 0.0;
00186                for(ord=0; ord<6; ord++)
00187                     x += xtpar[ord] * pow(time, ord);
00188 
00189                deltax = x - dist;
00190                if( fabs(deltax) < 0.001 ){
00191                     break;
00192                }
00193 
00194                dxdt = 0.0;
00195                for(ord=0; ord<5; ord++)
00196                     dxdt += dxdtpar[ord] * pow(time, ord);
00197 
00198                time = time - (deltax / dxdt);
00199                i++;
00200           }
00201      } else if(dist < dm2){
00202           time = (dist - dm1) * (tm2 - tm1) / (dm2 - dm1) + tm1;
00203      } else{
00204           time = tm2;
00205      }
00206 
00207      return time;
00208 }

double MdcCalibFunSvc::distToRawTimeNoTOF (  double  dist,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::distToRawTimeNoTOF (  double  dist,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00223                                                                            {
00224      double time = 0.0;
00225      double drifttime;
00226      double t0;
00227      double tw;
00228 
00229      drifttime = distToDriftTime(dist, layid, cellid, lr, entrance);
00230      t0 = getT0(layid, cellid);
00231      tw = getTimeWalk(layid, Q);
00232      time = drifttime + t0 + tw;
00233 
00234      return time;
00235 }

double MdcCalibFunSvc::driftTimeToDist (  double  drifttime,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::driftTimeToDist (  double  drifttime,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00125                                                                       {
00126      int ord;
00127      double xtpar[8];
00128      double dist = 0.0;
00129 
00130      int entr = getXtEntrIndex(entrance);
00131      getXtpar(layid, entr, lr, xtpar);
00132 
00133      if(drifttime < xtpar[6]){
00134           for(ord=0; ord<6; ord++){
00135                dist += xtpar[ord] * pow(drifttime, ord);
00136           }
00137      } else{
00138           for(ord=0; ord<6; ord++){
00139                dist += xtpar[ord] * pow(xtpar[6], ord);
00140           }
00141           dist += xtpar[7] * (drifttime - xtpar[6]);
00142      }
00143 
00144      return dist;
00145 }

virtual StatusCode MdcCalibFunSvc::finalize (   )  [virtual]
 

StatusCode MdcCalibFunSvc::finalize (   )  [virtual]
  

00081                                    {
00082      MsgStream log(messageService(), name());
00083      log << MSG::INFO << "MdcCalibFunSvc::finalize()" << endreq;
00084 
00085      m_xtmap.clear();
00086      m_t0.clear();
00087      m_delt0.clear();
00088      m_qtpar0.clear();
00089      m_qtpar1.clear();
00090      m_sdmap.clear();
00091 
00092      return StatusCode::SUCCESS;
00093 }

double MdcCalibFunSvc::getDelT0 (  int  wireid  )  const [inline, virtual]
 

Implements IMdcCalibFunSvc.

00088 { return m_delt0[wireid]; }

double MdcCalibFunSvc::getDelT0 (  int  wireid  )  const [inline, virtual]
 

Implements IMdcCalibFunSvc.

00088 { return m_delt0[wireid]; }

double MdcCalibFunSvc::getF (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getF (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00317                                                       {
00318 
00319      return 1.0;
00320 }

int MdcCalibFunSvc::getNextSdpar (  int &  key,
double &  par
)  [virtual]
 

Implements IMdcCalibFunSvc.

int MdcCalibFunSvc::getNextSdpar (  int &  key,
double &  par
)  [virtual]
 

Implements IMdcCalibFunSvc.

00384                                                      {
00385      if( m_sditer != m_sdmap.end() ){
00386           key = (*m_sditer).first;
00387           par = (*m_sditer).second;
00388           m_sditer++;
00389           return 1;
00390      }
00391      else return 0;
00392 }

int MdcCalibFunSvc::getNextXtpar (  int &  key,
double &  par
)  [virtual]
 

Implements IMdcCalibFunSvc.

int MdcCalibFunSvc::getNextXtpar (  int &  key,
double &  par
)  [virtual]
 

Implements IMdcCalibFunSvc.

00322                                                      {
00323      if( m_xtiter != m_xtmap.end() ){
00324           key = (*m_xtiter).first;
00325           par = (*m_xtiter).second;
00326           m_xtiter++;
00327           return 1;
00328      }
00329      else return 0;
00330 }

double MdcCalibFunSvc::getQtpar (  int  layid,
int  ord
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getQtpar (  int  layid,
int  ord
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00364                                                         {
00365      if(0 == ord)       return m_qtpar0[layid];
00366      else if(1 == ord)  return m_qtpar1[layid];
00367      else {
00368           cout << "wrong order number" << endl;
00369           return 0.0;
00370      }
00371 }

int MdcCalibFunSvc::getSdEntrIndex (  double  entrance  )  const [virtual]
 

Implements IMdcCalibFunSvc.

int MdcCalibFunSvc::getSdEntrIndex (  double  entrance  )  const [virtual]
 

Implements IMdcCalibFunSvc.

00425                                                         {
00426      int i;
00427      int index;
00428      int idmax = 5;
00429      double aglpi = 3.141592653;
00430      double aglmin = -1.570796327; // -90 degree
00431      double aglmax = 1.570796327; // 90 degree
00432      double delAngle = 0.523598776; // 30 degree
00433 
00434      MsgStream log(messageService(), name());
00435      if(entrance < aglmin){
00436           log << MSG::WARNING << "entrance angle < -pi/2" << endreq;
00437           while(1){
00438                entrance += aglpi;
00439                if(entrance >= aglmin) break;
00440           }
00441      } else if(entrance > aglmax){
00442           log << MSG::WARNING << "entrance angle > pi/2" << endreq;
00443           while(1){
00444                entrance -= aglpi;
00445                if(entrance <= aglmax) break;
00446           }
00447      }
00448 
00449      index = (int)((entrance-aglmin) / delAngle);
00450      if(index < 0) index = 0;
00451      else if(index > idmax) index = idmax;
00452 
00453      return index;
00454 }

int MdcCalibFunSvc::getSdKey (  int  layid,
int  entr,
int  lr,
int  bin
)  const [private]
 

int MdcCalibFunSvc::getSdKey (  int  layid,
int  entr,
int  lr,
int  bin
)  const [private]
  

00582                                                                        {
00583      int key = ( (layid << SDLAYER_INDEX) & SDLAYER_MASK ) |
00584           ( (entr << SDENTRA_INDEX) & SDENTRA_MASK ) |
00585           ( (lr << SDLR_INDEX) & SDLR_MASK ) |
00586           ( (ord << SDBIN_INDEX) & SDBIN_MASK );
00587 
00588      return key;
00589 }

void MdcCalibFunSvc::getSdpar (  int  layid,
int  entr,
int  lr,
double  par[]
)  const [virtual]
 

Implements IMdcCalibFunSvc.

void MdcCalibFunSvc::getSdpar (  int  layid,
int  entr,
int  lr,
double  par[]
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00373                                                                             {
00374      int parId;
00375      if( (entr < 0) || (entr >= 18) ){
00376           entr = 17;
00377      }
00378      for(int bin=0; bin<NSDBIN; bin++){
00379           parId = getSdparId(layid, entr, lr, bin);
00380           par[bin] = m_sdpar[parId];
00381      }
00382 }

int MdcCalibFunSvc::getSdparId (  int  layid,
int  entr,
int  lr,
int  bin
)  const [private]
 

int MdcCalibFunSvc::getSdparId (  int  layid,
int  entr,
int  lr,
int  bin
)  const [inline, private]
  

00191                                                     {
00192      int parId = (layid * 288) + (entr * 48) + (lr * 24) + bin;
00193      return parId;
00194 }

double MdcCalibFunSvc::getSigma (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getSigma (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00249                                                           {
00250      double sigma;
00251      if( (0 == lr) || (1 == lr) ){
00252           sigma = getSigmaLR(layid, lr, dist, entrance, tanlam, z, Q);
00253      } else{
00254           double sl = getSigmaLR(layid, 0, dist, entrance, tanlam, z, Q);
00255           double sr = getSigmaLR(layid, 1, dist, entrance, tanlam, z, Q);
00256           sigma = (sl + sr) * 0.5;
00257      }
00258 
00259      if(layid == m_layInfSig) sigma = 9999.0;
00260      return sigma;
00261 }

double MdcCalibFunSvc::getSigma1 (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getSigma1 (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00303                                                            {
00304      double sigma1 = getSigma(layid, lr, dist, entrance, tanlam, z, Q);
00305      return sigma1;
00306 }

double MdcCalibFunSvc::getSigma2 (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getSigma2 (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00310                                                            {
00311 
00312      return 0.0;
00313 }

double MdcCalibFunSvc::getSigmaLR (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getSigmaLR (  int  layid,
int  lr,
double  dist,
double  entrance = 0.0,
double  tanlam = 0.0,
double  z = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00265                                                             {
00266 
00267      double sigma = 0.0;
00268      double par[NSDBIN];
00269 
00270      int entr = getSdEntrIndex(entrance);
00271      getSdpar(layid, entr, lr, par);
00272 
00273      int nmaxBin;
00274      double dw = 0.5;           // width of each distance bin
00275      double dmin = 0.25;        // mm
00276      if(layid < 8){
00277           nmaxBin = 11; // 6mm
00278      } else{
00279           nmaxBin = 15; // 8mm
00280      }
00281 
00282      double dref[2];
00283      double distAbs = fabs(dist);
00284      if(distAbs < dmin){
00285           sigma = par[0];
00286      } else{
00287           int bin = (int)((distAbs - dmin) / dw);
00288           if(bin >= nmaxBin){
00289                sigma = par[nmaxBin];
00290           } else{
00291 
00292                dref[0] = (double)bin * dw + 0.25;
00293                dref[1] = (double)(bin+1) * dw + 0.25;
00294                sigma = (par[bin+1] - par[bin]) * (distAbs - dref[0]) /
00295                     (dref[1] - dref[0]) + par[bin];
00296           }
00297      }
00298      return sigma;
00299 }

double MdcCalibFunSvc::getT0 (  int  wireid  )  const [inline, virtual]
 

Implements IMdcCalibFunSvc.

00087 { return m_t0[wireid]; }

double MdcCalibFunSvc::getT0 (  int  layid,
int  cellid
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getT0 (  int  wireid  )  const [inline, virtual]
 

Implements IMdcCalibFunSvc.

00087 { return m_t0[wireid]; }

double MdcCalibFunSvc::getT0 (  int  layid,
int  cellid
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00340                                                         {
00341      int wireid = m_pMdcGeomSvc->Wire(layid, cellid)->Id();
00342      double t0 = getT0(wireid);
00343 
00344      return t0;
00345 }

double MdcCalibFunSvc::getTimeWalk (  int  layid,
double  Q
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getTimeWalk (  int  layid,
double  Q
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00347                                                             {
00348      double tw = 0.0;
00349      double qtpar[2];
00350      int ord;
00351 
00352      if(Q < 0.0001) Q = 0.0001;
00353 
00354      for(ord=0; ord<2; ord++){
00355           qtpar[ord] = getQtpar(layid, ord);
00356      }
00357 
00358      tw = qtpar[0] + qtpar[1] / sqrt( Q );
00359      if(m_run < 0) tw = 0.0;    // for MC
00360 
00361      return tw;
00362 }

double MdcCalibFunSvc::getTprop (  int  lay,
double  z
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getTprop (  int  lay,
double  z
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00118                                                       {
00119      double vp = getVprop(lay);
00120      double tp = fabs(z - m_zst[lay]) / vp;
00121      return tp;
00122 }

double MdcCalibFunSvc::getVprop (  int  lay  )  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::getVprop (  int  lay  )  const [inline, virtual]
 

Implements IMdcCalibFunSvc.

00179                                                    {
00180      if(lay<8) return 220.0;
00181      else return 240.0;
00182 }

int MdcCalibFunSvc::getXtEntrIndex (  double  entrance  )  const [virtual]
 

Implements IMdcCalibFunSvc.

int MdcCalibFunSvc::getXtEntrIndex (  double  entrance  )  const [virtual]
 

Implements IMdcCalibFunSvc.

00394                                                         {
00395      int i;
00396      int index;
00397      int idmax = 17;
00398      double aglpi = 3.141592653;
00399      double aglmin = -1.570796327; // -90 degree
00400      double aglmax = 1.570796327; // 90 degree
00401      double delAngle = 0.174532925; // 10 degree
00402 
00403      MsgStream log(messageService(), name());
00404      if(entrance < aglmin){
00405           log << MSG::WARNING << "entrance angle < -pi/2" << endreq;
00406           while(1){
00407                entrance += aglpi;
00408                if(entrance >= aglmin) break;
00409           }
00410      } else if(entrance > aglmax){
00411           log << MSG::WARNING << "entrance angle > pi/2" << endreq;
00412           while(1){
00413                entrance -= aglpi;
00414                if(entrance <= aglmax) break;
00415           }
00416      }
00417 
00418      index = (int)((entrance-aglmin) / delAngle);
00419      if(index < 0) index = 0;
00420      else if(index > idmax) index = idmax;
00421 
00422      return index;
00423 }

int MdcCalibFunSvc::getXtKey (  int  layid,
int  entr,
int  lr,
int  ord
)  const [private]
 

int MdcCalibFunSvc::getXtKey (  int  layid,
int  entr,
int  lr,
int  ord
)  const [private]
  

00572                                                                       {
00573 
00574      int key = ( (layid << XTLAYER_INDEX) & XTLAYER_MASK ) |
00575           ( (entr << XTENTRA_INDEX) & XTENTRA_MASK ) |
00576           ( (lr << XTLR_INDEX) & XTLR_MASK ) |
00577           ( (ord << XTORDER_INDEX) & XTORDER_MASK );
00578 
00579      return key;
00580 }

void MdcCalibFunSvc::getXtpar (  int  layid,
int  entr,
int  lr,
double  par[]
)  const [virtual]
 

Implements IMdcCalibFunSvc.

void MdcCalibFunSvc::getXtpar (  int  layid,
int  entr,
int  lr,
double  par[]
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00332                                                                             {
00333      int parId;
00334      for(int ord=0; ord<8; ord++){
00335           parId = getXtparId(layid, entr, lr, ord);
00336           par[ord] = m_xtpar[parId];
00337      }
00338 }

int MdcCalibFunSvc::getXtparId (  int  layid,
int  entr,
int  lr,
int  ord
)  const [private]
 

int MdcCalibFunSvc::getXtparId (  int  layid,
int  entr,
int  lr,
int  ord
)  const [inline, private]
  

00185                                                     {
00186      int parId = (layid * 432) + (entr * 24) + (lr * 8) + ord;
00187      return parId;
00188 }

void MdcCalibFunSvc::handle (  const Incident &   ) 
 

void MdcCalibFunSvc::handle (  const Incident &   ) 
  

00095                                               {
00096      MsgStream log( messageService(), name() );
00097      log << MSG::DEBUG << "handle: " << inc.type() << endreq;
00098 
00099      if ( inc.type() == "NewRun" ){
00100           log << MSG::DEBUG << "NewRun" << endreq;
00101 
00102           if( ! initCalibConst() ){
00103                log << MSG::ERROR 
00104                    << "can not initilize Mdc Calib Constants" << endl
00105                    << "  Please insert the following statement "
00106                    << "in your \"jobOption.txt\" "
00107                    << "before the include file of Mdc Reconstruction: "
00108                    << endl << "        "
00109                    << "#include \"$CALIBSVCROOT/share/job-CalibData.txt\""
00110                    << endl
00111                    << "  If still error, please contact with Wu Linghui "
00112                    << "(wulh@mail.ihep.ac.cn)."
00113                    << endreq;
00114           }
00115      } 
00116 }

bool MdcCalibFunSvc::initCalibConst (   )  [private, virtual]
 

Implements IMdcCalibFunSvc.

bool MdcCalibFunSvc::initCalibConst (   )  [private, virtual]
 

Implements IMdcCalibFunSvc.

00456                                    {
00457      MsgStream log(messageService(), name());
00458      log << MSG::INFO << "read calib const from TCDS" << endreq;
00459 
00460      IDataProviderSvc* eventSvc = NULL;
00461      Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00462      SmartDataPtr<Event::EventHeader> eventHeader(eventSvc,"/Event/EventHeader");
00463      if (!eventHeader) {
00464           log << MSG::FATAL << "Could not find Event Header" << endreq;
00465           return( StatusCode::FAILURE);
00466      }
00467      m_run = eventHeader->runNumber();
00468 
00469      // clear calibration constants vectors
00470      m_xtmap.clear();
00471      m_xtpar.clear();
00472      m_t0.clear();
00473      m_delt0.clear();
00474      m_qtpar0.clear();
00475      m_qtpar1.clear();
00476      m_sdmap.clear();
00477      m_sdpar.clear();
00478 
00479      string fullPath = "/Calib/MdcCal";
00480      SmartDataPtr<CalibData::MdcCalibData> calConst(m_pCalDataSvc, fullPath);
00481      if( ! calConst ){
00482           log << MSG::ERROR << "can not get MdcCalibConst via SmartPtr" 
00483               << endreq;
00484           return false;
00485      }
00486 
00487      // initialize XT parameter
00488      int layid;
00489      int entr;
00490      int lr;
00491      int ord;
00492      int key;
00493      double par;
00494      calConst -> setXtBegin();
00495      while( calConst->getNextXtpar(key, par) ){
00496           m_xtmap.insert( valType(key, par) );
00497      }
00498 
00499      int parId;
00500      unsigned mapsize = m_xtmap.size();
00501      m_xtpar.resize(mapsize);
00502      log << MSG::INFO << "size of xtmap: " << mapsize << endreq;
00503 
00504      calConst -> setXtBegin();
00505      while( calConst->getNextXtpar(key, par) ){
00506           layid = (key >> XTLAYER_INDEX) & XTLAYER_DECO;
00507           entr = (key >> XTENTRA_INDEX) & XTENTRA_DECO;
00508           lr = (key >> XTLR_INDEX) & XTLR_DECO;
00509           ord = (key >> XTORDER_INDEX) & XTORDER_DECO;
00510 
00511           parId = getXtparId(layid, entr, lr, ord);
00512           m_xtpar[parId] = par;
00513      }
00514 
00515      // initialize T0 parameter
00516      int wid;
00517      double t0;
00518      double delt0;
00519      for(wid=0; wid<NWIRE; wid++){
00520           t0 = calConst->getT0(wid);
00521           delt0 = calConst->getDelT0(wid);
00522           
00523           m_t0.push_back(t0);
00524           m_delt0.push_back(delt0);
00525      }
00526 
00527      // initialize QT parameter
00528      double qtpar0;
00529      double qtpar1;
00530      for(layid=0; layid<NLAYER; layid++){
00531           qtpar0 = calConst -> getQtpar0(layid);
00532           qtpar1 = calConst -> getQtpar1(layid);
00533 
00534           m_qtpar0.push_back(qtpar0);
00535           m_qtpar1.push_back(qtpar1);
00536      }
00537 
00538      // initialize resolution parameter
00539      calConst -> setSdBegin();
00540      while( calConst -> getNextSdpar(key, par) ){
00541           m_sdmap.insert( valType(key, par) );
00542      }
00543 
00544      mapsize = m_sdmap.size();
00545      m_sdpar.resize(mapsize);
00546      log << MSG::INFO << "size of sdmap: " << mapsize << endreq;
00547 
00548      calConst -> setSdBegin();
00549      while( calConst -> getNextSdpar(key, par) ){
00550           layid = (key >> SDLAYER_INDEX) & SDLAYER_DECO;
00551           entr = (key >> SDENTRA_INDEX) & SDENTRA_DECO;
00552           lr = (key >> SDLR_INDEX) & SDLR_DECO;
00553           ord = (key >> SDBIN_INDEX) & SDBIN_DECO;
00554 
00555           parId = getSdparId(layid, entr, lr, ord);
00556           m_sdpar[parId] = par;
00557      }
00558 
00559      double zeast;
00560      double zwest;
00561      for(layid=0; layid<NLAYER; layid++){
00562           zwest = m_pMdcGeomSvc->Wire(layid, 0)->Forward().z();
00563           zeast = m_pMdcGeomSvc->Wire(layid, 0)->Backward().z();
00564 
00565           if(0 == (layid % 2)) m_zst[layid] = zwest;    // west end
00566           else m_zst[layid] = zeast; // east end
00567      }
00568 
00569      return true;
00570 }

virtual StatusCode MdcCalibFunSvc::initialize (   )  [virtual]
 

StatusCode MdcCalibFunSvc::initialize (   )  [virtual]
  

00051                                      {
00052      MsgStream log(messageService(), name());
00053      log << MSG::INFO << "MdcCalibFunSvc::initialize()" << endreq;
00054 
00055      StatusCode sc = Service::initialize();
00056      if( sc.isFailure() ) return sc;
00057 
00058      IIncidentSvc* incsvc;
00059      sc = service("IncidentSvc", incsvc);
00060      int priority = 100;
00061      if( sc.isSuccess() ){
00062           incsvc -> addListener(this, "NewRun", priority);
00063      }
00064 
00065      sc = service("CalibDataSvc", m_pCalDataSvc, true);
00066      if( sc == StatusCode::SUCCESS ){
00067           log << MSG::INFO << "Retrieve IDataProviderSvc" << endreq;
00068      }else{
00069           log << MSG::FATAL << "can not get IDataProviderSvc" << endreq;
00070      }
00071 
00072      sc = service("MdcGeomSvc", m_pMdcGeomSvc);
00073      if( sc != StatusCode::SUCCESS ){
00074           log << MSG::ERROR << "can not use MdcGeomSvc" << endreq;
00075           return StatusCode::FAILURE;
00076      }
00077 
00078      return StatusCode::SUCCESS;
00079 }

const InterfaceID& IMdcCalibFunSvc::interfaceID (   )  [inline, static, inherited]
  

00017 { return IID_IMdcCalibFunSvc; }

const InterfaceID& IMdcCalibFunSvc::interfaceID (   )  [inline, static, inherited]
  

00017 { return IID_IMdcCalibFunSvc; }

virtual StatusCode MdcCalibFunSvc::queryInterface (  const InterfaceID &  riid,
void **  ppvUnknown
)  [virtual]
 

StatusCode MdcCalibFunSvc::queryInterface (  const InterfaceID &  riid,
void **  ppvUnknown
)  [virtual]
  

00042                                                                                      {
00043      if( IID_IMdcCalibFunSvc.versionMatch(riid) ){
00044           *ppvInterface = static_cast<IMdcCalibFunSvc*> (this);
00045      } else{
00046           return Service::queryInterface(riid, ppvInterface);
00047      }
00048      return StatusCode::SUCCESS;
00049 }

double MdcCalibFunSvc::rawTimeNoTOFToDist (  double  rawtimeNoTOF,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::rawTimeNoTOFToDist (  double  rawtimeNoTOF,
int  layid,
int  cellid,
int  lr,
double  entrance = 0.0,
double  Q = 1000.0
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00212                                                                            {
00213 
00214      double tdr = rawTimeToDriftT(rawtimeNoTOF, layid, cellid, Q);
00215 //      if( tdr < 0.000001 )  tdr = 0.000001;
00216 
00217      double dist = driftTimeToDist(tdr, layid, cellid, lr, entrance);
00218 
00219      return dist;
00220 }

double MdcCalibFunSvc::rawTimeToDriftT (  double  rawtime,
int  layid,
int  cellid,
double  Q
)  const [virtual]
 

Implements IMdcCalibFunSvc.

double MdcCalibFunSvc::rawTimeToDriftT (  double  rawtime,
int  layid,
int  cellid,
double  Q
)  const [virtual]
 

Implements IMdcCalibFunSvc.

00238                                                                    {
00239 
00240      double t0 = getT0(layid, cellid);
00241      double tw = getTimeWalk(layid, Q);
00242      double tdr = rawtime - t0 - tw;
00243 
00244      return tdr;
00245 }

void MdcCalibFunSvc::setSdBegin (   )  [inline, virtual]
 

Implements IMdcCalibFunSvc.

00093 { m_sditer = m_sdmap.begin(); }

void MdcCalibFunSvc::setSdBegin (   )  [inline, virtual]
 

Implements IMdcCalibFunSvc.

00093 { m_sditer = m_sdmap.begin(); }

void MdcCalibFunSvc::setXtBegin (   )  [inline, virtual]
 

Implements IMdcCalibFunSvc.

00082 { m_xtiter = m_xtmap.begin(); }

void MdcCalibFunSvc::setXtBegin (   )  [inline, virtual]
 

Implements IMdcCalibFunSvc.

00082 { m_xtiter = m_xtmap.begin(); }

Member Data Documentation

std::vector<double> MdcCalibFunSvc::m_delt0 [private]
 

std::vector<double> MdcCalibFunSvc::m_delt0 [private]
 

int MdcCalibFunSvc::m_layInfSig [private]
 

IDataProviderSvc* MdcCalibFunSvc::m_pCalDataSvc [private]
 

IDataProviderSvc* MdcCalibFunSvc::m_pCalDataSvc [private]
 

IMdcGeomSvc* MdcCalibFunSvc::m_pMdcGeomSvc [private]
 

IMdcGeomSvc* MdcCalibFunSvc::m_pMdcGeomSvc [private]
 

ICalibRootSvc* MdcCalibFunSvc::m_pRootSvc [private]
 

ICalibRootSvc* MdcCalibFunSvc::m_pRootSvc [private]
 

std::vector<double> MdcCalibFunSvc::m_qtpar0 [private]
 

std::vector<double> MdcCalibFunSvc::m_qtpar0 [private]
 

std::vector<double> MdcCalibFunSvc::m_qtpar1 [private]
 

std::vector<double> MdcCalibFunSvc::m_qtpar1 [private]
 

int MdcCalibFunSvc::m_run
 

std::map<int, double>::iterator MdcCalibFunSvc::m_sditer [private]
 

std::map<int, double>::iterator MdcCalibFunSvc::m_sditer [private]
 

std::map<int, double> MdcCalibFunSvc::m_sdmap [private]
 

std::map<int, double> MdcCalibFunSvc::m_sdmap [private]
 

std::vector<double> MdcCalibFunSvc::m_sdpar [private]
 

std::vector<double> MdcCalibFunSvc::m_sdpar [private]
 

std::vector<double> MdcCalibFunSvc::m_t0 [private]
 

std::vector<double> MdcCalibFunSvc::m_t0 [private]
 

std::map<int, double>::iterator MdcCalibFunSvc::m_xtiter [private]
 

std::map<int, double>::iterator MdcCalibFunSvc::m_xtiter [private]
 

std::map<int, double> MdcCalibFunSvc::m_xtmap [private]
 

std::map<int, double> MdcCalibFunSvc::m_xtmap [private]
 

std::vector<double> MdcCalibFunSvc::m_xtpar [private]
 

std::vector<double> MdcCalibFunSvc::m_xtpar [private]
 

double MdcCalibFunSvc::m_zst [private]
 

const int MdcCalibFunSvc::NLAYER = 43 [static, private]
 

const int MdcCalibFunSvc::NSDBIN = 24 [static, private]
 

const int MdcCalibFunSvc::NWIRE = 6796 [static, private]
 

const int MdcCalibFunSvc::NXTORD = 6 [static, private]
 

const int MdcCalibFunSvc::NXTPAR = 8 [static, private]
 

const int MdcCalibFunSvc::SDBIN_DECO = 0x1F [static, private]
 

const int MdcCalibFunSvc::SDBIN_INDEX = 0 [static, private]
 

const int MdcCalibFunSvc::SDBIN_MASK = 0x1F [static, private]
 

const int MdcCalibFunSvc::SDENTRA_DECO = 0x7 [static, private]
 

const int MdcCalibFunSvc::SDENTRA_INDEX = 7 [static, private]
 

const int MdcCalibFunSvc::SDENTRA_MASK = 0x380 [static, private]
 

const int MdcCalibFunSvc::SDLAYER_DECO = 0x3F [static, private]
 

const int MdcCalibFunSvc::SDLAYER_INDEX = 10 [static, private]
 

const int MdcCalibFunSvc::SDLAYER_MASK = 0xFC00 [static, private]
 

const int MdcCalibFunSvc::SDLR_DECO = 0x3 [static, private]
 

const int MdcCalibFunSvc::SDLR_INDEX = 5 [static, private]
 

const int MdcCalibFunSvc::SDLR_MASK = 0x60 [static, private]
 

const int MdcCalibFunSvc::XTENTRA_DECO = 0x1F [static, private]
 

const int MdcCalibFunSvc::XTENTRA_INDEX = 6 [static, private]
 

const int MdcCalibFunSvc::XTENTRA_MASK = 0x7C0 [static, private]
 

const int MdcCalibFunSvc::XTLAYER_DECO = 0x3F [static, private]
 

const int MdcCalibFunSvc::XTLAYER_INDEX = 11 [static, private]
 

const int MdcCalibFunSvc::XTLAYER_MASK = 0x1F800 [static, private]
 

const int MdcCalibFunSvc::XTLR_DECO = 0x3 [static, private]
 

const int MdcCalibFunSvc::XTLR_INDEX = 4 [static, private]
 

const int MdcCalibFunSvc::XTLR_MASK = 0x30 [static, private]
 

const int MdcCalibFunSvc::XTORDER_DECO = 0xF [static, private]
 

const int MdcCalibFunSvc::XTORDER_INDEX = 0 [static, private]
 

const int MdcCalibFunSvc::XTORDER_MASK = 0xF [static, private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:24:00 2011 for BOSS6.5.5 by  doxygen 1.3.9.1