#include <TString.h>
#include <TObjString.h>
#include <iostream>
+#include <AliLog.h>
ClassImp(AliTPCCalPad)
}
return pad;
}
-
-void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, Double_t pointError, Bool_t robust, Double_t robustFraction){
+//_____________________________________________________________________________
+TObjArray* AliTPCCalPad::CreateFormulaArray(const char *fitFormula)
+{
//
- // Performs a fit on both sides.
- // Valid information for the fitFormula are the variables
- // - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
- // - sector: the sector number.
- // eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
- //
- // PadOutliers - pads with value !=0 are not used in fitting procedure
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
+ // create an array of TFormulas for the each parameter of the fit function
//
// split fit string in single parameters
fitString.ReplaceAll(" ","");
TObjArray *arrFitParams = fitString.Tokenize("#");
Int_t ndim = arrFitParams->GetEntries();
- //resize output data arrays
- fitParamSideA.ResizeTo(ndim+1);
- fitParamSideC.ResizeTo(ndim+1);
- covMatrixSideA.ResizeTo(ndim+1,ndim+1);
- covMatrixSideC.ResizeTo(ndim+1,ndim+1);
- // create linear fitter for A- and C- Side
- TLinearFitter* fitterGA = new TLinearFitter(ndim+1,Form("hyp%d",ndim));
- TLinearFitter* fitterGC = new TLinearFitter(ndim+1,Form("hyp%d",ndim));
- fitterGA->StoreData(kTRUE);
- fitterGC->StoreData(kTRUE);
//create array of TFormulas to evaluate the parameters
TObjArray *arrFitFormulas = new TObjArray(ndim);
arrFitFormulas->SetOwner(kTRUE);
s.ReplaceAll("sector","[4]");
arrFitFormulas->AddAt(new TFormula(Form("param%02d",idim),s.Data()),idim);
}
- //loop over data and add points to the fitter
+ delete arrFitParams;
+
+ return arrFitFormulas;
+}
+//_____________________________________________________________________________
+void AliTPCCalPad::EvalFormulaArray(const TObjArray &arrFitFormulas, TVectorD &results,
+ const Int_t sec, const Int_t row, const Int_t pad)
+{
+ //
+ // evaluate the fit formulas
+ //
+ Int_t ndim=arrFitFormulas.GetEntries();
+ results.ResizeTo(ndim);
+
AliTPCROC* tpcROCinstance = AliTPCROC::Instance(); // to calculate the pad's position
Float_t localXYZ[3];
Float_t globalXYZ[3];
+ tpcROCinstance->GetPositionLocal(sec, row, pad, localXYZ);
+ tpcROCinstance->GetPositionGlobal(sec, row, pad, globalXYZ);
+ //calculate parameter values
+ for (Int_t idim=0;idim<ndim;++idim){
+ TFormula *f=(TFormula*)arrFitFormulas.At(idim);
+ f->SetParameters(globalXYZ[0],globalXYZ[1],localXYZ[0],localXYZ[1],sec);
+ results[idim]=f->Eval(0);
+ }
+}
+//_____________________________________________________________________________
+void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, AliTPCCalPad *pointError, Bool_t robust, Double_t robustFraction){
+ //
+ // Performs a fit on both sides.
+ // Valid information for the fitFormula are the variables
+ // - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
+ // - sector: the sector number.
+ // eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
+ //
+ // PadOutliers - pads with value !=0 are not used in fitting procedure
+ // chi2Threshold: Threshold for chi2 when EvalRobust is called
+ // robustFraction: Fraction of data that will be used in EvalRobust
+ //
+
+ TObjArray* arrFitFormulas=CreateFormulaArray(fitFormula);
+ Int_t ndim = arrFitFormulas->GetEntries();
+ //resize output data arrays
+ fitParamSideA.ResizeTo(ndim+1);
+ fitParamSideC.ResizeTo(ndim+1);
+ covMatrixSideA.ResizeTo(ndim+1,ndim+1);
+ covMatrixSideC.ResizeTo(ndim+1,ndim+1);
+ // create linear fitter for A- and C- Side
+ TLinearFitter* fitterGA = new TLinearFitter(ndim+1,Form("hyp%d",ndim));
+ TLinearFitter* fitterGC = new TLinearFitter(ndim+1,Form("hyp%d",ndim));
+ fitterGA->StoreData(kTRUE);
+ fitterGC->StoreData(kTRUE);
+ //parameter values
TVectorD parValues(ndim);
+
+ AliTPCCalROC *rocErr=0x0;
for (UInt_t isec = 0; isec<kNsec; ++isec){
AliTPCCalROC *rocOut=PadOutliers->GetCalROC(isec);
AliTPCCalROC *rocData=GetCalROC(isec);
+ if (pointError) rocErr=pointError->GetCalROC(isec);
if (!rocData) continue;
for (UInt_t irow = 0; irow < GetCalROC(isec)->GetNrows(); irow++) {
for (UInt_t ipad = 0; ipad < GetCalROC(isec)->GetNPads(irow); ipad++) {
//check for outliers
if (rocOut && rocOut->GetValue(irow,ipad)) continue;
- //calculate local and global pad positions
- tpcROCinstance->GetPositionLocal(isec, irow, ipad, localXYZ);
- tpcROCinstance->GetPositionGlobal(isec, irow, ipad, globalXYZ);
//calculate parameter values
- for (Int_t idim=0;idim<ndim;++idim){
- TFormula *f=(TFormula*)arrFitFormulas->At(idim);
- f->SetParameters(globalXYZ[0],globalXYZ[1],localXYZ[0],localXYZ[1],isec);
- parValues[idim]=f->Eval(0);
- }
+ EvalFormulaArray(*arrFitFormulas,parValues,isec,irow,ipad);
//get value
Float_t value=rocData->GetValue(irow,ipad);
+ //point error
+ Int_t err=1;
+ if (rocErr) {
+ err=rocErr->GetValue(irow,ipad);
+ if (err==0) err=1;
+ }
//add points to the fitters
if (isec/18%2==0){
- fitterGA->AddPoint(parValues.GetMatrixArray(),value,pointError);
+ fitterGA->AddPoint(parValues.GetMatrixArray(),value,err);
}else{
- fitterGC->AddPoint(parValues.GetMatrixArray(),value,pointError);
+ fitterGC->AddPoint(parValues.GetMatrixArray(),value,err);
}
}
}
fitterGA->GetCovarianceMatrix(covMatrixSideA);
fitterGC->GetCovarianceMatrix(covMatrixSideC);
- delete arrFitParams;
delete arrFitFormulas;
delete fitterGA;
delete fitterGC;
}
-
+//
+AliTPCCalPad *AliTPCCalPad::CreateCalPadFit(const char* fitFormula, const TVectorD &fitParamSideA, const TVectorD &fitParamSideC)
+{
+ //
+ //
+ //
+ TObjArray *arrFitFormulas=CreateFormulaArray(fitFormula);
+ Int_t ndim = arrFitFormulas->GetEntries();
+ //check if dimension of fit formula and fit parameters agree
+ if (ndim!=fitParamSideA.GetNrows()||ndim!=fitParamSideC.GetNrows()){
+ printf("AliTPCCalPad::CreateCalPadFit: Dimensions of fit formula and fit Parameters does not match!");
+ return 0;
+ }
+ //create cal pad
+ AliTPCCalPad *pad=new AliTPCCalPad("fitResultPad",Form("Fit result: %s",fitFormula));
+ //fill cal pad with fit results if requested
+ for (UInt_t isec = 0; isec<kNsec; ++isec){
+ AliTPCCalROC *roc=pad->GetCalROC(isec);
+ for (UInt_t irow = 0; irow < roc->GetNrows(); irow++) {
+ for (UInt_t ipad = 0; ipad < roc->GetNPads(irow); ipad++) {
+ const TVectorD *fitPar=0;
+ TVectorD fitResArray;
+ if (isec/18%2==0){
+ fitPar=&fitParamSideA;
+ }else{
+ fitPar=&fitParamSideC;
+ }
+ EvalFormulaArray(*arrFitFormulas,fitResArray, isec, irow, ipad);
+ for (Int_t idim=0;idim<ndim;++idim)
+ fitResArray(idim)*=(*fitPar)(idim);
+ roc->SetValue(irow,ipad,fitResArray.Sum());
+ }
+ }
+ }
+ delete arrFitFormulas;
+ return pad;
+}
/*
void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, Int_t fitType, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction){
//
AliTPCCalPad* LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* Padoutliers = 0, Bool_t robust = kFALSE, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7, Bool_t printCurrentSector = kFALSE) const;
AliTPCCalPad* GlobalFit(const char* padName, AliTPCCalPad* Padoutliers = 0, Bool_t robust = kFALSE, Int_t fitType = 1, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7, Double_t err=1, TObjArray *fitParArr=0x0, TObjArray *fitCovArr=0x0);
- void GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC, TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t &chi2SideA, Float_t &chi2SideC, Double_t pointError=1, Bool_t robust = kFALSE, Double_t robustFraction = 0.7);
-
+ void GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC, TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t &chi2SideA, Float_t &chi2SideC, AliTPCCalPad *pointError=0, Bool_t robust = kFALSE, Double_t robustFraction = 0.7);
+
+ static AliTPCCalPad* CreateCalPadFit(const char* fitFormula, const TVectorD &fitParamSideA, const TVectorD &fitParamSideC);
+
+ static TObjArray *CreateFormulaArray(const char *fitFormula);
+ static void EvalFormulaArray(const TObjArray &arrFitFormulas, TVectorD &results,
+ const Int_t sec, const Int_t row, const Int_t pad);
protected:
AliTPCCalROC *fROC[kNsec]; // Array of ROC objects which contain the values per pad
ClassDef(AliTPCCalPad,1) // TPC calibration class for parameters which are saved per pad
rocOut->SetValue(irow,ipad,1);
continue;
}
+ //exclude first two rows in IROC and last two rows in OROC
+ if (iroc<36){
+ if (irow<2) rocOut->SetValue(irow,ipad,1);
+ } else {
+ if (irow>nrows-3) rocOut->SetValue(irow,ipad,1);
+ }
//exclude edge pads
if (ipad==0||ipad==npads-1) rocOut->SetValue(irow,ipad,1);
Float_t valTmean=rocData->GetValue(irow,ipad);
//
UpdateRefPulserOutlierMap();
//loop over all channels
- for (UInt_t isec=0;isec<(UInt_t)AliTPCCalPad::kNsec;++isec){
+ for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
AliTPCCalROC *pqROC=fPulserQmean->GetCalROC(isec);
AliTPCCalROC *pqRefROC=fRefPulserQmean->GetCalROC(isec);
AliTPCCalROC *ptROC=fPulserTmean->GetCalROC(isec);
- //AliTPCCalROC *ptRefROC=fRefPulserTmean->GetCalROC(isec);
+// AliTPCCalROC *ptRefROC=fRefPulserTmean->GetCalROC(isec);
AliTPCCalROC *mROC=fALTROMasked->GetCalROC(isec);
AliTPCCalROC *mRefROC=fRefALTROMasked->GetCalROC(isec);
AliTPCCalROC *oROC=fPulserOutlier->GetCalROC(isec);
// Create pad time0 object from pulser and/or CE data, depending on the selected model
// Model 0: normalise each readout chamber to its mean, outlier cutted, only Pulser
// Model 1: normalise IROCs/OROCs of each readout side to its mean, only Pulser
- //
+ // Model 2: use CE data and a combination CE fit + pulser in the outlier regions.
//
AliTPCCalPad *padTime0=new AliTPCCalPad("PadTime0",Form("PadTime0-Model_%d",model));
}
}
}
+ } else if (model==2){
+ TVectorD vA,vC;
+ AliTPCCalPad outCE("outCE","outCE");
+ Int_t nOut;
+ ProcessCEdata("(sector<36)++gy++gx++(lx-134)++(sector<36)*(lx-134)",vA,vC,nOut,&outCE);
+ AliTPCCalPad *padFit=AliTPCCalPad::CreateCalPadFit("1++0++gy++0++(lx-134)++0",vA,vC);
+// AliTPCCalPad *padFit=AliTPCCalPad::CreateCalPadFit("1++(sector<36)++gy++gx++(lx-134)++(sector<36)*(lx-134)",vA,vC);
+ if (!padFit) return 0;
+ padTime0->Add(fCETmean);
+ padTime0->Add(padFit,-1);
+ TVectorD vFitROC;
+ TMatrixD mFitROC;
+ Float_t chi2;
+ for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
+ AliTPCCalROC *rocPulTmean=fPulserTmean->GetCalROC(isec);
+ AliTPCCalROC *rocTime0=padTime0->GetCalROC(isec);
+ AliTPCCalROC *rocOutPul=fPulserOutlier->GetCalROC(isec);
+ AliTPCCalROC *rocOutCE=outCE.GetCalROC(isec);
+ rocTime0->GlobalFit(rocOutCE,kFALSE,vFitROC,mFitROC,chi2);
+ AliTPCCalROC *rocCEfit=AliTPCCalROC::CreateGlobalFitCalROC(vFitROC, isec);
+ Float_t mean=rocPulTmean->GetMean(rocOutPul);
+ if (mean==0) mean=rocPulTmean->GetMean();
+ UInt_t nrows=rocTime0->GetNrows();
+ for (UInt_t irow=0;irow<nrows;++irow){
+ UInt_t npads=rocTime0->GetNPads(irow);
+ for (UInt_t ipad=0;ipad<npads;++ipad){
+ Float_t timePulser=rocPulTmean->GetValue(irow,ipad)-mean;
+ if (rocOutCE->GetValue(irow,ipad)){
+ Float_t valOut=rocCEfit->GetValue(irow,ipad);
+ if (!rocOutPul->GetValue(irow,ipad)) valOut+=timePulser;
+ rocTime0->SetValue(irow,ipad,valOut);
+ }
+ }
+ }
+ delete rocCEfit;
+ }
+ delete padFit;
}
-
-
return padTime0;
}
//_____________________________________________________________________________________
nMasked 1, Number_of_masked_pads, ALTRO
nOffPulser 1, Pads_without_pulser_signal, Pulser
timePulser. 1, Pulser_Position_[timebins], Pulser, IROC_A-Side, IROC_C-Side, OROC_A-Side, OROC_C-Side
-CEfitA. 1, CE_Fit_A-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_[timebins/cm], dt/dlx^{2}_[timebins/cm^{2}]
-CEfitC. 1, CE_Fit_C-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_[timebins/cm], dt/dlx^{2}_[timebins/cm^{2}]
+#CEfitA. 1, CE_Fit_A-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_[timebins/cm], dt/dlx^{2}_[timebins/cm^{2}]
+#CEfitC. 1, CE_Fit_C-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_[timebins/cm], dt/dlx^{2}_[timebins/cm^{2}]
+CEfitA. 1, CE_Fit_A-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_common_[timebins/cm], dt/dlx_IROCs_[timebins/cm]
+CEfitC. 1, CE_Fit_C-Side, CE, Offset_[timebins], IROC/OROC_Offset_[timebins], dt/dgx_[timebins/cm], dt/dgy_[timebins/cm], dt/dlx_common_[timebins/cm], dt/dlx_IROCs_[timebins/cm]
nmaskedCE 1, CE_Number_of_outliers, CE
Bz 1, Magnetic_Field_[T]
L3polarity 1, L3_polarity, Environment