#include "TTreeStream.h"
#include "TFile.h"
#include "TKey.h"
+#include <TFormula.h>
+#include <TString.h>
+#include <TObjString.h>
+#include <iostream>
+#include <AliLog.h>
ClassImp(AliTPCCalPad)
// else sector specified in 'roc' is ignored and specified sector is filled
//
if (sector == -1) sector = roc->GetSector();
+ if (!fROC[sector]) fROC[sector] = new AliTPCCalROC(sector);
for (UInt_t ichannel = 0; ichannel < roc->GetNchannels(); ichannel++)
fROC[sector]->SetValue(ichannel, roc->GetValue(ichannel));
}
// - pad by pad -
//
for (Int_t isec = 0; isec < kNsec; isec++) {
- if (fROC[isec]){
+ if (fROC[isec] && pad->GetCalROC(isec)){
fROC[isec]->Add(pad->GetCalROC(isec),c1);
}
}
}
-AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* PadOutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction){
+AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* PadOutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction, Bool_t printCurrentSector) const {
//
// Loops over all AliTPCCalROCs and performs a localFit in each ROC
// AliTPCCalPad with fit-data is returned
//
AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
for (Int_t isec = 0; isec < 72; isec++){
+ if (printCurrentSector) std::cout << "LocalFit in sector " << isec << "\r" << std::flush;
if (PadOutliers)
- SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, PadOutliers->GetCalROC(isec), robust, chi2Threshold, robustFraction));
+ pad->SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, PadOutliers->GetCalROC(isec), robust, chi2Threshold, robustFraction));
else
- SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, 0, robust, chi2Threshold, robustFraction));
+ pad->SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, 0, robust, chi2Threshold, robustFraction));
}
return pad;
}
-AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutliers, Bool_t robust, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction){
+AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutliers, Bool_t robust, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction, Double_t err, TObjArray *fitParArr, TObjArray *fitCovArr){
//
// Loops over all AliTPCCalROCs and performs a globalFit in each ROC
// AliTPCCalPad with fit-data is returned
// robustFraction: Fraction of data that will be used in EvalRobust
// chi2Threshold: Threshold for chi2 when EvalRobust is called
// robustFraction: Fraction of data that will be used in EvalRobust
+ // err: error of the data points
+ // if fitParArr and/or fitCovArr is given, write fitParameters and/or covariance Matrices into the array
//
AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
TVectorD fitParam(0);
Float_t chi2 = 0;
for (Int_t isec = 0; isec < 72; isec++){
if (PadOutliers)
- GetCalROC(isec)->GlobalFit(PadOutliers->GetCalROC(isec), robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction);
+ GetCalROC(isec)->GlobalFit(PadOutliers->GetCalROC(isec), robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction, err);
else
- GetCalROC(isec)->GlobalFit(0, robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction);
- pad->SetCalROC(AliTPCCalROC::CreateGlobalFitCalROC(fitParam, isec));
+ GetCalROC(isec)->GlobalFit(0, robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction, err);
+
+ AliTPCCalROC *roc=AliTPCCalROC::CreateGlobalFitCalROC(fitParam, isec);
+ pad->SetCalROC(roc);
+ delete roc;
+ if ( fitParArr ) fitParArr->AddAtAndExpand(new TVectorD(fitParam), isec);
+ if ( fitCovArr ) fitCovArr->AddAtAndExpand(new TMatrixD(covMatrix), isec);
}
return pad;
}
+//_____________________________________________________________________________
+TObjArray* AliTPCCalPad::CreateFormulaArray(const char *fitFormula)
+{
+ //
+ // create an array of TFormulas for the each parameter of the fit function
+ //
+ // split fit string in single parameters
+ // find dimension of the fit:
+ TString fitString(fitFormula);
+ fitString.ReplaceAll("++","#");
+ fitString.ReplaceAll(" ","");
+ TObjArray *arrFitParams = fitString.Tokenize("#");
+ Int_t ndim = arrFitParams->GetEntries();
+ //create array of TFormulas to evaluate the parameters
+ TObjArray *arrFitFormulas = new TObjArray(ndim);
+ arrFitFormulas->SetOwner(kTRUE);
+ for (Int_t idim=0;idim<ndim;++idim){
+ TString s=((TObjString*)arrFitParams->At(idim))->GetString();
+ s.ReplaceAll("gx","[0]");
+ s.ReplaceAll("gy","[1]");
+ s.ReplaceAll("lx","[2]");
+ s.ReplaceAll("ly","[3]");
+ s.ReplaceAll("sector","[4]");
+ arrFitFormulas->AddAt(new TFormula(Form("param%02d",idim),s.Data()),idim);
+ }
+ 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 parameter values
+ EvalFormulaArray(*arrFitFormulas,parValues,isec,irow,ipad);
+ //get value
+ Float_t value=rocData->GetValue(irow,ipad);
+ //point error
+ Int_t err=1;
+ if (rocErr) {
+ err=TMath::Nint(rocErr->GetValue(irow,ipad));
+ if (err==0) err=1;
+ }
+ //add points to the fitters
+ if (isec/18%2==0){
+ fitterGA->AddPoint(parValues.GetMatrixArray(),value,err);
+ }else{
+ fitterGC->AddPoint(parValues.GetMatrixArray(),value,err);
+ }
+ }
+ }
+ }
+ if (robust){
+ fitterGA->EvalRobust(robustFraction);
+ fitterGC->EvalRobust(robustFraction);
+ } else {
+ fitterGA->Eval();
+ fitterGC->Eval();
+ }
+ chi2SideA=fitterGA->GetChisquare()/(fitterGA->GetNpoints()-(ndim+1));
+ chi2SideC=fitterGC->GetChisquare()/(fitterGC->GetNpoints()-(ndim+1));
+ fitterGA->GetParameters(fitParamSideA);
+ fitterGC->GetParameters(fitParamSideC);
+ fitterGA->GetCovarianceMatrix(covMatrixSideA);
+ fitterGC->GetCovarianceMatrix(covMatrixSideC);
+
+ 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){
//
// Makes a GlobalFit over each side and return fit-parameters, covariance and chi2 for each side
delete fitterGA;
delete fitterGC;
}
-
-
-void AliTPCCalPad::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
- //
- // Write a tree with all available information
- // im mapFileName is speciefied, the Map information are also written to the tree
- // pads specified in outlierPad are not used for calculating statistics
- // - this function will be moved to AliTPCCalibViewer -
- // - DO NOT USE THIS FUNCTION ANY MORE -
- //
- AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
-
- TObjArray* mapIROCs = 0;
- TObjArray* mapOROCs = 0;
- TVectorF *mapIROCArray = 0;
- TVectorF *mapOROCArray = 0;
- Int_t mapEntries = 0;
- TString* mapNames = 0;
-
- if (mapFileName) {
- TFile mapFile(mapFileName, "read");
-
- TList* listOfROCs = mapFile.GetListOfKeys();
- mapEntries = listOfROCs->GetEntries()/2;
- mapIROCs = new TObjArray(mapEntries*2);
- mapOROCs = new TObjArray(mapEntries*2);
- mapIROCArray = new TVectorF[mapEntries];
- mapOROCArray = new TVectorF[mapEntries];
-
- mapNames = new TString[mapEntries];
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
- TString ROCname(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
- ROCname.Remove(ROCname.Length()-4, 4);
- mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "IROC").Data()), ivalue);
- mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((ROCname + "OROC").Data()), ivalue);
- mapNames[ivalue].Append(ROCname);
- }
-
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
- mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
- mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
-
- for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
- (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
- for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
- (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
- }
-
- } // if (mapFileName)
-
- TTreeSRedirector cstream(fileName);
- Int_t arrayEntries = array->GetEntries();
-
- TString* names = new TString[arrayEntries];
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
- names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
-
- for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
- //
- // get statistic for given sector
- //
- TVectorF median(arrayEntries);
- TVectorF mean(arrayEntries);
- TVectorF rms(arrayEntries);
- TVectorF ltm(arrayEntries);
- TVectorF ltmrms(arrayEntries);
- TVectorF medianWithOut(arrayEntries);
- TVectorF meanWithOut(arrayEntries);
- TVectorF rmsWithOut(arrayEntries);
- TVectorF ltmWithOut(arrayEntries);
- TVectorF ltmrmsWithOut(arrayEntries);
-
- TVectorF *vectorArray = new TVectorF[arrayEntries];
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
- vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
- AliTPCCalROC* calROC = calPad->GetCalROC(isector);
- AliTPCCalROC* outlierROC = 0;
- if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
- if (calROC) {
- median[ivalue] = calROC->GetMedian();
- mean[ivalue] = calROC->GetMean();
- rms[ivalue] = calROC->GetRMS();
- Double_t ltmrmsValue = 0;
- ltm[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction);
- ltmrms[ivalue] = ltmrmsValue;
- if (outlierROC) {
- medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
- meanWithOut[ivalue] = calROC->GetMean(outlierROC);
- rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
- ltmrmsValue = 0;
- ltmWithOut[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction, outlierROC);
- ltmrmsWithOut[ivalue] = ltmrmsValue;
- }
- }
- else {
- median[ivalue] = 0.;
- mean[ivalue] = 0.;
- rms[ivalue] = 0.;
- ltm[ivalue] = 0.;
- ltmrms[ivalue] = 0.;
- medianWithOut[ivalue] = 0.;
- meanWithOut[ivalue] = 0.;
- rmsWithOut[ivalue] = 0.;
- ltmWithOut[ivalue] = 0.;
- ltmrmsWithOut[ivalue] = 0.;
- }
- }
-
- //
- // fill vectors of variable per pad
- //
- TVectorF *posArray = new TVectorF[8];
- for (Int_t ivalue = 0; ivalue < 8; ivalue++)
- posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
- Float_t posG[3] = {0};
- Float_t posL[3] = {0};
- Int_t ichannel = 0;
- for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
- for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
- tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
- tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
- posArray[0][ichannel] = irow;
- posArray[1][ichannel] = ipad;
- posArray[2][ichannel] = posL[0];
- posArray[3][ichannel] = posL[1];
- posArray[4][ichannel] = posG[0];
- posArray[5][ichannel] = posG[1];
- posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
- posArray[7][ichannel] = ichannel;
-
- // loop over array containing AliTPCCalPads
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
- AliTPCCalROC* calROC = calPad->GetCalROC(isector);
- if (calROC)
- (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
- else
- (vectorArray[ivalue])[ichannel] = 0;
- }
- ichannel++;
- }
- }
-
- cstream << "calPads" <<
- "sector=" << isector;
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
- (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
- (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
- if (outlierPad) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
- }
- }
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
- }
-
- if (mapFileName) {
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
- if (isector < 36)
- cstream << "calPads" <<
- (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
- else
- cstream << "calPads" <<
- (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
- }
- }
-
- cstream << "calPads" <<
- "row.=" << &posArray[0] <<
- "pad.=" << &posArray[1] <<
- "lx.=" << &posArray[2] <<
- "ly.=" << &posArray[3] <<
- "gx.=" << &posArray[4] <<
- "gy.=" << &posArray[5] <<
- "rpad.=" << &posArray[6] <<
- "channel.=" << &posArray[7];
-
- cstream << "calPads" <<
- "\n";
-
- delete[] posArray;
- delete[] vectorArray;
- }
- delete[] names;
- if (mapFileName) {
- delete mapIROCs;
- delete mapOROCs;
- delete[] mapIROCArray;
- delete[] mapOROCArray;
- delete[] mapNames;
- }
-}
-
+*/
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff