#include "AliTPCExB.h"
#include "TMath.h"
-#include "TTreeStream.h"
+//#include "TTreeStream.h"
#include "AliMagF.h"
#include "TLinearFitter.h"
#include "AliTPCcalibDB.h"
}
-Double_t AliTPCExB::EvalMat(TVectorD &vec, Double_t r, Double_t phi, Double_t z){
+Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z){
//
// Evaluate taylor expansion in r,phi,z
//
-#ifndef ALITPC_EXB
-#define ALITPC_EXB
+#ifndef ALITPCEXB_H
+#define ALITPCEXB_H
class AliMagF;
#include "TObject.h"
-#include "TVectorD.h"
+#include "TVectorDfwd.h"
class AliTPCExB:public TObject {
public:
static Double_t GetDphi(Double_t r, Double_t phi, Double_t z, Double_t bz=5);
static Double_t GetDz(Double_t r, Double_t phi, Double_t z, Double_t bz=5);
static AliTPCExB* Instance(){return fgInstance;}
- static void SetInstance(AliTPCExB*param){fgInstance = param;}
+ static void SetInstance(AliTPCExB *const param){fgInstance = param;}
//
// Mag field scans
//
//
Double_t Eval(Int_t type, Double_t r, Double_t phi, Double_t z);
Double_t SEval(Int_t type, Double_t r, Double_t phi, Double_t z){return Instance()->Eval(type,r,phi,z);}
- static Double_t EvalMat(TVectorD &vec, Double_t r, Double_t phi, Double_t z); // evalute parameterization
+ static Double_t EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z); // evalute parameterization
- public:
+ private:
TVectorD * fMatBrBz; //param matrix Br/Bz
TVectorD * fMatBrfiBz; //param matrix Br/Bz
TVectorD * fMatBrBzI0; //param matrix Br/Bz integral z>0
TVectorD * fMatBrfiBzI0; //param matrix Br/Bz integral z>0
TVectorD * fMatBrfiBzI1; //param matrix Br/Bz integral z<0
- private:
static AliTPCExB* fgInstance; //! Instance of this class (singleton implementation)
static TObjArray fgArray; //! array of magnetic fields
//
delete fBitMask;
delete fFixedParam;
}
-void AliTPCTransformation::SetParams(Double_t param, Double_t sigma, Double_t sigma2Time, TVectorD* fixedParams){
+void AliTPCTransformation::SetParams(Double_t param, Double_t sigma, Double_t sigma2Time, const TVectorD *const fixedParams){
//
// Set parameters of transformation
//
return deltaAlpha*xyz[3];
}
-Double_t AliTPCTransformation::TPClocalRPhiEdge(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPClocalRPhiEdge(Double_t *xyz, const Double_t *const param){
//
//
// Scaling if the local y -phi
}
-Double_t AliTPCTransformation::TPCdeltaFCROC(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPCdeltaFCROC(Double_t *xyz, const Double_t *const param){
//
// delta R(Z) ROC induced
// param[0] - switch 0 - use distance to IFC - 1 - distance to IFC
}
-Double_t AliTPCTransformation::TPCdeltaFCCE(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPCdeltaFCCE(Double_t *xyz, const Double_t *const param){
//
// delta R(Z) CE (central electrode) induced
// param[0] - switch 0 - use distance to IFC - 1 - distance to IFC
//
//
//
-Double_t AliTPCTransformation:: TPClocaldLxdGX(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation:: TPClocaldLxdGX(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter
return ca*factor;
}
-Double_t AliTPCTransformation::TPClocaldLxdGY(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPClocaldLxdGY(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter
return sa*factor;
}
-Double_t AliTPCTransformation:: TPClocaldLydGX(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation:: TPClocaldLydGX(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter
return -sa*factor;
}
-Double_t AliTPCTransformation::TPClocaldLydGY(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPClocaldLydGY(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter
}
-Double_t AliTPCTransformation::TPClocaldRzdGX(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPClocaldRzdGX(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter - rotation angle in mrad
return dgxR;
}
-Double_t AliTPCTransformation::TPClocaldRzdGY(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPClocaldRzdGY(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter - rotation angle in mrad
return xyz[3]*sign*signZ;
}
-Double_t AliTPCTransformation::TPCDeltaZ(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPCDeltaZ(Double_t *xyz, const Double_t *const param){
//
// xyz - [0..2] - position
// [3] - scale parameter
}
-Double_t AliTPCTransformation::TPCTiltingZ(Double_t *xyz, Double_t * param){
+Double_t AliTPCTransformation::TPCTiltingZ(Double_t *xyz, const Double_t *const param){
// xyz - [0..2] - position
// [3] - scale parameter
// [4] - volID
~AliTPCTransformation();
//
virtual Double_t GetDeltaXYZ(Int_t coord, Int_t volID, Double_t param, Double_t x, Double_t y, Double_t z);
- void SetParams(Double_t param, Double_t sigma, Double_t sigma2Time, TVectorD* fixedParams);
+ void SetParams(Double_t param, Double_t sigma, Double_t sigma2Time, const TVectorD *const fixedParams);
Bool_t Init();
void SetActive(Bool_t flag){ fIsActive = flag;}
- Bool_t IsActive(){return fIsActive;}
+ Bool_t IsActive() const {return fIsActive;}
//
+ Double_t GetParam() const {return fParam;}
+ void SetParam(Double_t param) {fParam=param;}
+ Double_t GetSigma() const {return fSigma;}
+ Double_t GetSigmaMax() const {return fSigmaMax;}
+ Double_t GetSigma2Time() const {return fSigma2Time;}
//
static TBits * BitsSide(Bool_t aside);
static TBits * BitsAll();
static void RegisterFormula(const char * name, GenFuncG formula);
static AliTPCTransformation::GenFuncG FindFormula(const char * name);
static Double_t Eval(const char * name, const Double_t*x,const Double_t*par);
-public:
+
+ private:
//
TString * fNameX; // x formula
TString * fNameY; // y formula
static Double_t TPCscalingZDriftGy(Double_t *xyz, Double_t * param);
static Double_t TPCscalingZDriftT0(Double_t *xyz, Double_t * param);
static Double_t TPCscalingPhiLocal(Double_t *xyz, Double_t * param);
- static Double_t TPClocalRPhiEdge(Double_t *xyz, Double_t * param);
+ static Double_t TPClocalRPhiEdge(Double_t *xyz, const Double_t *const param);
//
// TPC Field cage + ROC misalingment induced distortion
//
//
// TPC field cage + ROC misalignemnt induced distortion
//
- static Double_t TPCdeltaFCROC(Double_t *xyz, Double_t * param);
- static Double_t TPCdeltaFCCE(Double_t *xyz, Double_t * param);
+ static Double_t TPCdeltaFCROC(Double_t *xyz, const Double_t *const param);
+ static Double_t TPCdeltaFCCE(Double_t *xyz, const Double_t *const param);
//
// TPC local misalignment
//
- static Double_t TPClocaldLxdGX(Double_t *xyz, Double_t * param);
- static Double_t TPClocaldLxdGY(Double_t *xyz, Double_t * param);
- static Double_t TPClocaldLydGX(Double_t *xyz, Double_t * param);
- static Double_t TPClocaldLydGY(Double_t *xyz, Double_t * param);
- static Double_t TPClocaldRzdGX(Double_t *xyz, Double_t * param);
- static Double_t TPClocaldRzdGY(Double_t *xyz, Double_t * param);
+ static Double_t TPClocaldLxdGX(Double_t *xyz, const Double_t *const param);
+ static Double_t TPClocaldLxdGY(Double_t *xyz, const Double_t *const param);
+ static Double_t TPClocaldLydGX(Double_t *xyz, const Double_t *const param);
+ static Double_t TPClocaldLydGY(Double_t *xyz, const Double_t *const param);
+ static Double_t TPClocaldRzdGX(Double_t *xyz, const Double_t *const param);
+ static Double_t TPClocaldRzdGY(Double_t *xyz, const Double_t *const param);
//
// TPC quadrant misalignment
//
// Z shift -
//
- static Double_t TPCDeltaZ(Double_t *xyz, Double_t * param);
+ static Double_t TPCDeltaZ(Double_t *xyz, const Double_t *const param);
static Double_t TPCDeltaZMediumLong(Double_t *xyz, Double_t * param);
- static Double_t TPCTiltingZ(Double_t *xyz, Double_t * param);
+ static Double_t TPCTiltingZ(Double_t *xyz, const Double_t *const param);
//
Bool_t fInit; // initialization flag
GenFuncG fFormulaX; //! x formula
GenFuncG fFormulaZ; //! z formula
static GenFuncG fgFormulas[10000]; //! array of pointers to formula
static TObjArray* fgFormulasName; //! array of formalas name
-private:
+
AliTPCTransformation &operator=(const AliTPCTransformation&); // not implemented
ClassDef(AliTPCTransformation,2);
return padTime0;
}
//_____________________________________________________________________________________
-Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *rocOut)
+Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *const rocOut)
{
//
// GetMeanAlto information
///////////////////////////////////////////////////////////////////////////////
#include <TObject.h>
-#include <TArrayI.h>
-#include <TVectorD.h>
-#include <TVectorF.h>
+class TArrayI;
+#include <TVectorDfwd.h>
+#include <TVectorFfwd.h>
class TGraph;
class TMap;
//setters for pad by pad information
void SetPulserData(AliTPCCalPad * const tmean, AliTPCCalPad * const trms=0x0, AliTPCCalPad * const qmean=0x0)
{fPulserTmean=tmean; fPulserTrms=trms; fPulserQmean=qmean;}
- void SetCEData(AliTPCCalPad *tmean, AliTPCCalPad *trms=0x0, AliTPCCalPad *qmean=0x0)
+ void SetCEData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
{fCETmean=tmean; fCETrms=trms; fCEQmean=qmean;}
- void SetNoisePedestal(AliTPCCalPad *noise, AliTPCCalPad *pedestal=0x0)
+ void SetNoisePedestal(AliTPCCalPad *const noise, AliTPCCalPad *const pedestal=0x0)
{fPadNoise=noise; fPedestals=pedestal;}
- void SetALTROData(AliTPCCalPad *masked)
+ void SetALTROData(AliTPCCalPad *const masked)
{fALTROMasked=masked;}
- void SetGoofieArray(AliDCSSensorArray *arr) {fGoofieArray=arr;}
+ void SetGoofieArray(AliDCSSensorArray *const arr) {fGoofieArray=arr;}
//setters for pad by pad information
void SetRefFile(const char* filename);
void SetReferenceRun(Int_t run=-1);
void UpdateRefDataFromOCDB();
- void SetRefPulserData(AliTPCCalPad *tmean, AliTPCCalPad *trms=0x0, AliTPCCalPad *qmean=0x0)
+ void SetRefPulserData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
{fRefPulserTmean=tmean; fRefPulserTrms=trms; fRefPulserQmean=qmean;}
- void SetRefCEData(AliTPCCalPad *tmean, AliTPCCalPad *trms=0x0, AliTPCCalPad *qmean=0x0)
+ void SetRefCEData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
{fRefCETmean=tmean; fRefCETrms=trms; fRefCEQmean=qmean;}
- void SetRefNoisePedestal(AliTPCCalPad *noise, AliTPCCalPad *pedestal=0x0)
+ void SetRefNoisePedestal(AliTPCCalPad *const noise, AliTPCCalPad *const pedestal=0x0)
{fRefPadNoise=noise; fRefPedestals=pedestal;}
- void SetRefALTROData(AliTPCCalPad *masked)
+ void SetRefALTROData(AliTPCCalPad *const masked)
{fRefALTROMasked=masked;}
//creation of derived pad by pad calibration data
fCalibCovar = new TMatrixD(ncalibs,ncalibs);
for (Int_t icalib=0;icalib<ncalibs; icalib++){
AliTPCTransformation * transform = (AliTPCTransformation *)fCalibration->At(icalib);
- (*fCalibParam)(icalib,0) = transform->fParam;
+ (*fCalibParam)(icalib,0) = transform->GetParam();
for (Int_t jcalib=0;jcalib<ncalibs; jcalib++){
if (icalib!=jcalib) (*fCalibCovar)(icalib,jcalib)= 0;
- if (icalib==jcalib) (*fCalibCovar)(icalib,jcalib) = transform->fSigma*transform->fSigma;
+ if (icalib==jcalib) (*fCalibCovar)(icalib,jcalib) = transform->GetSigma()*transform->GetSigma();
}
}
//
// save current param and covariance
for (Int_t i=0; i<ncalibs;i++){
AliTPCTransformation * transform = (AliTPCTransformation *)fCalibration->At(i);
- transform->fParam= (*fLinearParam)(i,0);
+ transform->SetParam( (*fLinearParam)(i,0));
(*fCalibParam)(i,0) = (*fLinearParam)(i,0);
for (Int_t j=0; j<ncalibs;j++){
(*fCalibCovar)(i,j) = (*fLinearCovar)(i,j);
fLastTimeStamp = time;
for (Int_t icalib=0;icalib<ncalibs; icalib++){
AliTPCTransformation * transform = (AliTPCTransformation *)fCalibration->At(icalib);
- if ((*fCalibCovar)(icalib,icalib)<transform->fSigmaMax*transform->fSigmaMax)
- (*fCalibCovar)(icalib,icalib)+= transform->fSigma2Time*TMath::Abs(deltaT);
+ if ((*fCalibCovar)(icalib,icalib)<transform->GetSigmaMax()*transform->GetSigmaMax())
+ (*fCalibCovar)(icalib,icalib)+= transform->GetSigma2Time()*TMath::Abs(deltaT);
}
}
Double_t dxdydz[3]={0,0,0};
for (Int_t icalib=0; icalib<ncalibs; icalib++){
AliTPCTransformation * transform = (AliTPCTransformation *)fCalibration->At(icalib);
- dxdydz[0] += transform->GetDeltaXYZ(0,volId, transform->fParam, xyz[0], xyz[1], xyz[2]);
- dxdydz[1] += transform->GetDeltaXYZ(1,volId, transform->fParam, xyz[0], xyz[1], xyz[2]);
- dxdydz[2] += transform->GetDeltaXYZ(2,volId, transform->fParam, xyz[0], xyz[1], xyz[2]);
+ dxdydz[0] += transform->GetDeltaXYZ(0,volId, transform->GetParam(), xyz[0], xyz[1], xyz[2]);
+ dxdydz[1] += transform->GetDeltaXYZ(1,volId, transform->GetParam(), xyz[0], xyz[1], xyz[2]);
+ dxdydz[2] += transform->GetDeltaXYZ(2,volId, transform->GetParam(), xyz[0], xyz[1], xyz[2]);
}
((Float_t*)array->GetX())[ipoint]+=csign*dxdydz[0];
((Float_t*)array->GetY())[ipoint]+=csign*dxdydz[1];