MdcCalibFunSvc.h

Go to the documentation of this file.

#ifndef MDCCALIBFUNSVC_H_
#define MDCCALIBFUNSVC_H_

#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IIncidentListener.h"

#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/DataSvc.h"
#include "CalibData/CalibModel.h"
#include "CalibData/Mdc/MdcCalibData.h"
#include "CalibDataSvc/ICalibRootSvc.h"

#include "MdcCalibFunSvc/IMdcCalibFunSvc.h"

#include <map>
#include <vector>

class MdcCalibFunSvc: public Service, virtual public IMdcCalibFunSvc, 
                      virtual public IIncidentListener{
                      public:
     MdcCalibFunSvc( const std::string& name, ISvcLocator* svcloc );
     ~MdcCalibFunSvc();

     virtual StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown);
     virtual StatusCode initialize();
     virtual StatusCode finalize();

     // Incident handler
     void handle(const Incident&);

     int m_run;

     /* Access by users */

     /* propagation velocity of the signal in the wire. unit: mm/ns */
     double getVprop(int lay) const;

     /* get propagation time. the unit of z is mm */
     double getTprop(int lay, double z) const;

     /* DriftTime is real drift time, that is 
        DriftTime = Tdc - TOF - T0 - TimeWalk */
     /* the unit of distance is mm */
     double driftTimeToDist(double drifttime, 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 ;

     /* here tawtimeNoTOF = Tdc - TOF */
     double rawTimeNoTOFToDist(double rawtimeNoTOF, 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 ;

     /* convert rawTime to DriftTime, here TOF is excluded from rawTime */
     double rawTimeToDriftT(double rawtime, int layid, 
                            int cellid, double Q) const;

     /* Sigma1 and Sigma2 are the smaller and the bigger sigma of
        the two gaussian distribution, respectively.
        Sigma = sqrt( F*Sigma1^2 + (1-F)*Sigma2^2 ) */
     /* the unit of distance is mm */
     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 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 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 getF(int layid, int lr, double dist,
                 double entrance = 0.0, double tanlam = 0.0,
                 double z = 0.0, double Q = 1000.0) const ;

     void   setXtBegin() { m_xtiter = m_xtmap.begin(); }
     int    getNextXtpar(int& key, double& par);
     void   getXtpar(int layid, int entr, int lr, double par[]) const;

     double getT0(int layid, int cellid) const ;
     double getT0(int wireid) const { return m_t0[wireid]; }
     double getDelT0(int wireid) const { return m_delt0[wireid]; }

     double getTimeWalk(int layid, double Q) const ;
     double getQtpar(int layid, int ord) const;

     void setSdBegin() { m_sditer = m_sdmap.begin(); }
     int  getNextSdpar(int& key, double& par);
     void getSdpar(int layid, int entr, int lr, double par[]) const;
     
     int getXtEntrIndex(double entrance) const;
     int getSdEntrIndex(double entrance) const;

/*      std::string getCalibDataFile() { return m_pRootSvc->getrootfile(); } */

                      private:
     /* initial calib const */
     bool initCalibConst();

     int  getXtKey(int layid, int entr, int lr, int ord) const;

     int getSdKey(int layid, int entr, int lr, int bin) const;

     int getXtparId(int layid, int entr, int lr, int ord) const;
     int getSdparId(int layid, int entr, int lr, int bin) const;

     int m_layInfSig;           /* the layer with infinite sigma for reconstruction */

     IMdcGeomSvc*       m_pMdcGeomSvc;
     IDataProviderSvc*  m_pCalDataSvc;
     ICalibRootSvc*     m_pRootSvc;

     /* for calculation Tprop */
     double m_zst[43];

     /* calibration constants */
     std::map<int, double> m_xtmap;
     std::vector<double>   m_xtpar;

     std::vector<double>   m_t0;
     std::vector<double>   m_delt0;

     std::vector<double>   m_qtpar0;
     std::vector<double>   m_qtpar1;

     std::map<int, double> m_sdmap;
     std::vector<double>   m_sdpar;

     std::map<int, double>::iterator m_xtiter;
     std::map<int, double>::iterator m_sditer;


     static const int NWIRE = 6796;
     static const int NLAYER = 43;
     static const int NXTPAR = 8;
     static const int NXTORD = 6;
     static const int NSDBIN = 24;

     static const int XTLAYER_INDEX    = 11;
     static const int XTLAYER_MASK     = 0x1F800;
     static const int XTLAYER_DECO     = 0x3F;

     static const int XTENTRA_INDEX    = 6;
     static const int XTENTRA_MASK     = 0x7C0;
     static const int XTENTRA_DECO     = 0x1F;

     static const int XTLR_INDEX       = 4;
     static const int XTLR_MASK        = 0x30;
     static const int XTLR_DECO        = 0x3;

     static const int XTORDER_INDEX    = 0;
     static const int XTORDER_MASK     = 0xF;
     static const int XTORDER_DECO     = 0xF;


     static const int SDLAYER_INDEX    = 10;
     static const int SDLAYER_MASK     = 0xFC00;
     static const int SDLAYER_DECO     = 0x3F;

     static const int SDENTRA_INDEX    = 7;
     static const int SDENTRA_MASK     = 0x380;
     static const int SDENTRA_DECO     = 0x7;

     static const int SDLR_INDEX       = 5;
     static const int SDLR_MASK        = 0x60;
     static const int SDLR_DECO        = 0x3;

     static const int SDBIN_INDEX      = 0;
     static const int SDBIN_MASK       = 0x1F;
     static const int SDBIN_DECO       = 0x1F;
};

inline double MdcCalibFunSvc::getVprop(int lay) const{
     if(lay<8) return 220.0;
     else return 240.0;
}

inline int MdcCalibFunSvc::getXtparId(int layid, int entr, int lr,
                                      int ord) const{
     int parId = (layid * 432) + (entr * 24) + (lr * 8) + ord;
     return parId;
}

inline int MdcCalibFunSvc::getSdparId(int layid, int entr, int lr,
                                      int bin) const{
     int parId = (layid * 288) + (entr * 48) + (lr * 24) + bin;
     return parId;
}

#endif /* MDCCALIBFUNSVC_H_ */

---