// previous calibration procedure.
// The function SetDebug enables the user to see:
// _fDebug = 0: nothing, only the values are written in the tree if wanted
-// _fDebug = 1: a comparaison of the coefficients found and the default values
+// _fDebug = 1: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
+// _fDebug = 2: a comparaison of the coefficients found and the default values
// in the choosen database.
// fCoef , histogram of the coefs as function of the calibration group number
// fDelta , histogram of the relative difference of the coef with the default
// value in the database as function of the calibration group number
// fError , dirstribution of this relative difference
-// _fDebug = 2: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
// _fDebug = 3: The coefficients in the choosen detector fDet (SetDet) as function of the
// pad row and col number
// _fDebug = 4; The coeffcicients in the choosen detector fDet (SetDet) like in the 3 but with
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDgeometry.h"
+#include "AliTRDCommonParam.h"
#include "./Cal/AliTRDCalROC.h"
#include "./Cal/AliTRDCalPad.h"
#include "./Cal/AliTRDCalDet.h"
return fgInstance;
}
-
//______________________________________________________________________________________
void AliTRDCalibraFit::Terminate()
{
}
}
-
//______________________________________________________________________________________
AliTRDCalibraFit::AliTRDCalibraFit()
:TObject()
,fMethod(0)
,fBeginFitCharge(3.5)
,fFitPHPeriode(1)
- ,fTakeTheMaxPH(kFALSE)
- ,fT0Shift(0.124797)
+ ,fTakeTheMaxPH(kTRUE)
+ ,fT0Shift0(0.124797)
+ ,fT0Shift1(0.267451)
,fRangeFitPRF(1.0)
,fAccCDB(kFALSE)
,fMinEntries(800)
,fEntriesCurrent(0)
,fCountDet(0)
,fCount(0)
+ ,fNbDet(0)
,fCalDet(0x0)
,fCalROC(0x0)
,fCalDet2(0x0)
,fBeginFitCharge(c.fBeginFitCharge)
,fFitPHPeriode(c.fFitPHPeriode)
,fTakeTheMaxPH(c.fTakeTheMaxPH)
-,fT0Shift(c.fT0Shift)
+,fT0Shift0(c.fT0Shift0)
+,fT0Shift1(c.fT0Shift1)
,fRangeFitPRF(c.fRangeFitPRF)
,fAccCDB(c.fAccCDB)
,fMinEntries(c.fMinEntries)
,fEntriesCurrent(c.fEntriesCurrent)
,fCountDet(c.fCountDet)
,fCount(c.fCount)
+,fNbDet(c.fNbDet)
,fCalDet(0x0)
,fCalROC(0x0)
,fCalDet2(0x0)
}
if(c.fCalDet) fCalDet = new AliTRDCalDet(*c.fCalDet);
if(c.fCalDet2) fCalDet2 = new AliTRDCalDet(*c.fCalDet2);
-
+
if(c.fCalROC) fCalROC = new AliTRDCalROC(*c.fCalROC);
if(c.fCalROC2) fCalROC = new AliTRDCalROC(*c.fCalROC2);
AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
Int_t detector = ((AliTRDFitInfo *)c.fVectorFit.UncheckedAt(k))->GetDetector();
Int_t ntotal = 1;
- if (GetChamber(detector) == 2) {
+ if (GetStack(detector) == 2) {
ntotal = 1728;
}
else {
AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
Int_t detector = ((AliTRDFitInfo *)c.fVectorFit2.UncheckedAt(k))->GetDetector();
Int_t ntotal = 1;
- if (GetChamber(detector) == 2) {
+ if (GetStack(detector) == 2) {
ntotal = 1728;
}
else {
if ( fCalDet ) delete fCalDet;
if ( fCalDet2 ) delete fCalDet2;
if ( fCalROC ) delete fCalROC;
- if ( fCalROC2 ) delete fCalROC2;
+ if ( fCalROC2 ) delete fCalROC2;
+ if( fCurrentCoefDetector ) delete [] fCurrentCoefDetector;
+ if( fCurrentCoefDetector2 ) delete [] fCurrentCoefDetector2;
fVectorFit.Delete();
fVectorFit2.Delete();
if (fGeo) {
fgInstance = 0x0;
}
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFit::DestroyDebugStreamer()
+{
+ //
+ // Delete DebugStreamer
+ //
+
+ if ( fDebugStreamer ) delete fDebugStreamer;
+ fDebugStreamer = 0x0;
+
+}
+//__________________________________________________________________________________
+void AliTRDCalibraFit::RangeChargeIntegration(Float_t vdrift, Float_t t0, Int_t &begin, Int_t &peak, Int_t &end) const
+{
+ //
+ // From the drift velocity and t0
+ // return the position of the peak and maximum negative slope
+ //
+
+ const Float_t kDrWidth = AliTRDgeometry::DrThick(); // drift region
+ Double_t widbins = 0.1; // 0.1 mus
+
+ //peak and maxnegslope in mus
+ Double_t begind = t0*widbins + fT0Shift0;
+ Double_t peakd = t0*widbins + fT0Shift1;
+ Double_t maxnegslope = (kDrWidth + vdrift*peakd)/vdrift;
+
+ // peak and maxnegslope in timebin
+ begin = TMath::Nint(begind*widbins);
+ peak = TMath::Nint(peakd*widbins);
+ end = TMath::Nint(maxnegslope*widbins);
+
}
//____________Functions fit Online CH2d________________________________________
-Bool_t AliTRDCalibraFit::AnalyseCH(TH2I *ch)
+Bool_t AliTRDCalibraFit::AnalyseCH(const TH2I *ch)
{
//
// Fit the 1D histos, projections of the 2D ch on the Xaxis, for each
// Set the calibration mode
const char *name = ch->GetTitle();
- SetModeCalibration(name,0);
+ if(!SetModeCalibration(name,0)) return kFALSE;
// Number of Ybins (detectors or groups of pads)
Int_t nbins = ch->GetNbinsX();// charge
// Set the calibraMode
const char *name = calvect->GetNameCH();
- SetModeCalibration(name,0);
+ if(!SetModeCalibration(name,0)) return kFALSE;
// Number of Xbins (detectors or groups of pads)
if (!InitFit((432*calvect->GetDetCha0(0)+108*calvect->GetDetCha2(0)),0)) {
Bool_t something = kTRUE;
if(!calvect->GetCHEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("CH");
- name += idect;
- projch = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) name);
+ TString tname("CH");
+ tname += idect;
+ projch = calvect->ConvertVectorCHHisto(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0)))),(const char *) tname);
projch->SetDirectory(0);
for (Int_t k = 0; k < calvect->GetNumberBinCharge(); k++) {
nentries += projch->GetBinContent(k+1);
return kTRUE;
}
//________________functions fit Online PH2d____________________________________
-Bool_t AliTRDCalibraFit::AnalysePH(TProfile2D *ph)
+Bool_t AliTRDCalibraFit::AnalysePH(const TProfile2D *ph)
{
//
// Take the 1D profiles (average pulse height), projections of the 2D PH
// Set the calibration mode
const char *name = ph->GetTitle();
- SetModeCalibration(name,1);
+ if(!SetModeCalibration(name,1)) return kFALSE;
// Number of Xbins (detectors or groups of pads)
Int_t nbins = ph->GetNbinsX();// time
// This detector has not enough statistics or was off
if (nentries <= fMinEntries) {
//printf("Not enough statistic!\n");
- NotEnoughStatisticPH(idect);
+ NotEnoughStatisticPH(idect,nentries);
if (fDebugLevel != 1) {
delete projph;
}
default: return kFALSE;
}
// Fill the tree if end of a detector or only the pointer to the branch!!!
- FillInfosFitPH(idect);
+ FillInfosFitPH(idect,nentries);
// Memory!!!
if (fDebugLevel != 1) {
delete projph;
// Set the calibration mode
const char *name = calvect->GetNamePH();
- SetModeCalibration(name,1);
+ if(!SetModeCalibration(name,1)) return kFALSE;
// Number of Xbins (detectors or groups of pads)
if (!InitFit((432*calvect->GetDetCha0(1)+108*calvect->GetDetCha2(1)),1)) {
Bool_t something = kTRUE;
if(!calvect->GetPHEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PH");
- name += idect;
- projph = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name)));
+ TString tname("PH");
+ tname += idect;
+ projph = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPHTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)));
projph->SetDirectory(0);
}
//printf("The number of entries for the group %d is %d\n",idect,fEntriesCurrent);
// This detector has not enough statistics or was off
if (fEntriesCurrent <= fMinEntries) {
//printf("Not enough stat!\n");
- NotEnoughStatisticPH(idect);
+ NotEnoughStatisticPH(idect,fEntriesCurrent);
if (fDebugLevel != 1) {
if(projph) delete projph;
}
default: return kFALSE;
}
// Fill the tree if end of a detector or only the pointer to the branch!!!
- FillInfosFitPH(idect);
+ FillInfosFitPH(idect,fEntriesCurrent);
// Memory!!!
if (fDebugLevel != 1) {
delete projph;
return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
-Bool_t AliTRDCalibraFit::AnalysePRF(TProfile2D *prf)
+Bool_t AliTRDCalibraFit::AnalysePRF(const TProfile2D *prf)
{
//
// Take the 1D profiles (pad response function), projections of the 2D PRF
// Set the calibration mode
const char *name = prf->GetTitle();
- SetModeCalibration(name,2);
+ if(!SetModeCalibration(name,2)) return kFALSE;
// Number of Ybins (detectors or groups of pads)
Int_t nybins = prf->GetNbinsY();// calibration groups
return kTRUE;
}
//____________Functions fit Online PRF2d_______________________________________
-Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(TProfile2D *prf)
+Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(const TProfile2D *prf)
{
//
// Take the 1D profiles (pad response function), projections of the 2D PRF
// Set the calibration mode
const char *name = prf->GetTitle();
- SetModeCalibration(name,2);
+ if(!SetModeCalibration(name,2)) return kFALSE;
// Number of Ybins (detectors or groups of pads)
TAxis *xprf = prf->GetXaxis();
// Set the calibra mode
const char *name = calvect->GetNamePRF();
- SetModeCalibration(name,2);
+ if(!SetModeCalibration(name,2)) return kFALSE;
//printf("test0 %s\n",name);
// Number of Xbins (detectors or groups of pads)
Bool_t something = kTRUE;
if(!calvect->GetPRFEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PRF");
- name += idect;
- projprf = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name)));
+ TString tname("PRF");
+ tname += idect;
+ projprf = CorrectTheError((TGraphErrors *) (calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname)));
projprf->SetDirectory(0);
}
// This detector has not enough statistics or was off
// Set the calibra mode
const char *name = calvect->GetNamePRF();
- SetModeCalibration(name,2);
+ if(!SetModeCalibration(name,2)) return kFALSE;
//printf("test0 %s\n",name);
Int_t nbg = GetNumberOfGroupsPRF((const char *)name);
- printf("test1 %d\n",nbg);
+ //printf("test1 %d\n",nbg);
if(nbg == -1) return kFALSE;
if(nbg > 0) fMethod = 1;
else fMethod = 0;
Bool_t something = kTRUE;
if(!calvect->GetPRFEntries(fCountDet)) something = kFALSE;
if(something){
- TString name("PRF");
- name += idect;
- projprftree = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) name);
+ TString tname("PRF");
+ tname += idect;
+ projprftree = calvect->ConvertVectorPRFTGraphErrors(fCountDet,(idect-(fCount-(fCalibraMode->GetNfragZ(1)*fCalibraMode->GetNfragRphi(1)))),(const char *) tname);
nbins = projprftree->GetN();
arrayx = (Double_t *)projprftree->GetX();
arraye = (Double_t *)projprftree->GetEX();
const Char_t *patternrphi5 = "Nrphi5";
const Char_t *patternrphi6 = "Nrphi6";
+
+ const Char_t *patternrphi10 = "Nrphi10";
+ const Char_t *patternrphi100 = "Nrphi100";
+ const Char_t *patternz10 = "Nz10";
+ const Char_t *patternz100 = "Nz100";
+
// Nrphi mode
+ if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+ fCalibraMode->SetAllTogether(i);
+ fNbDet = 540;
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 100",fNbDet));
+ }
+ return kTRUE;
+ }
+ if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+ fCalibraMode->SetPerSuperModule(i);
+ fNbDet = 30;
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNDet %d and 100",fNbDet));
+ }
+ return kTRUE;
+ }
+
if (strstr(name,patternrphi0)) {
fCalibraMode->SetNrphi(i ,0);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 0",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi1)) {
fCalibraMode->SetNrphi(i, 1);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 1",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi2)) {
fCalibraMode->SetNrphi(i, 2);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 2",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi3)) {
fCalibraMode->SetNrphi(i, 3);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 3",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi4)) {
fCalibraMode->SetNrphi(i, 4);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 4",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi5)) {
fCalibraMode->SetNrphi(i, 5);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 5",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternrphi6)) {
fCalibraMode->SetNrphi(i, 6);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 6",fNbDet));
+ }
return kTRUE;
}
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and rest",fNbDet));
+ }
fCalibraMode->SetNrphi(i ,0);
return kFALSE;
-
+
}
//_____________________________________________________________________________
Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
const Char_t *patternz2 = "Nz2";
const Char_t *patternz3 = "Nz3";
const Char_t *patternz4 = "Nz4";
-
+
+ const Char_t *patternrphi10 = "Nrphi10";
+ const Char_t *patternrphi100 = "Nrphi100";
+ const Char_t *patternz10 = "Nz10";
+ const Char_t *patternz100 = "Nz100";
+
+ if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+ fCalibraMode->SetAllTogether(i);
+ fNbDet = 540;
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 100",fNbDet));
+ }
+ return kTRUE;
+ }
+ if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+ fCalibraMode->SetPerSuperModule(i);
+ fNbDet = 30;
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 10",fNbDet));
+ }
+ return kTRUE;
+ }
if (strstr(name,patternz0)) {
fCalibraMode->SetNz(i, 0);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 0",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternz1)) {
fCalibraMode->SetNz(i ,1);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 1",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternz2)) {
fCalibraMode->SetNz(i ,2);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 2",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternz3)) {
fCalibraMode->SetNz(i ,3);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 3",fNbDet));
+ }
return kTRUE;
}
if (strstr(name,patternz4)) {
fCalibraMode->SetNz(i ,4);
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and 4",fNbDet));
+ }
return kTRUE;
}
-
+
+ if (fDebugLevel > 1) {
+ AliInfo(Form("fNbDet %d and rest",fNbDet));
+ }
fCalibraMode->SetNz(i ,0);
return kFALSE;
}
+//______________________________________________________________________
+void AliTRDCalibraFit::PutMeanValueOtherVectorFit(Int_t ofwhat, Bool_t perdetector){
+ //
+ // ofwhat is equaled to 0: mean value of all passing detectors
+ // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
+ //
+
+ Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
+ if(loop != 540) {
+ AliInfo("The Vector Fit is not complete!");
+ return;
+ }
+ Int_t detector = -1;
+ Int_t sector = -1;
+ Float_t value = 0.0;
+
+ /////////////////////////////////
+ // Calculate the mean values
+ ////////////////////////////////
+ // Initialisation
+ ////////////////////////
+ Double_t meanAll = 0.0;
+ Double_t meanSupermodule[18];
+ Double_t meanDetector[540];
+ Int_t countAll = 0;
+ Int_t countSupermodule[18];
+ Int_t countDetector[540];
+ for(Int_t sm = 0; sm < 18; sm++){
+ meanSupermodule[sm] = 0.0;
+ countSupermodule[sm] = 0;
+ }
+ for(Int_t det = 0; det < 540; det++){
+ meanDetector[det] = 0.0;
+ countDetector[det] = 0;
+ }
+ // compute
+ ////////////
+ for (Int_t k = 0; k < loop; k++) {
+ detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
+ sector = GetSector(detector);
+ if(perdetector){
+ value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
+ if(value > 0.0) {
+ meanDetector[detector] += value;
+ countDetector[detector]++;
+ meanSupermodule[sector] += value;
+ countSupermodule[sector]++;
+ meanAll += value;
+ countAll++;
+ }
+ }
+ else {
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
+ for (Int_t row = 0; row < rowMax; row++) {
+ for (Int_t col = 0; col < colMax; col++) {
+ value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+ if(value > 0.0) {
+ meanDetector[detector] += value;
+ countDetector[detector]++;
+ meanSupermodule[sector] += value;
+ countSupermodule[sector]++;
+ meanAll += value;
+ countAll++;
+ }
+
+ } // Col
+ } // Row
+ }
+ }
+ if(countAll > 0) meanAll = meanAll/countAll;
+ for(Int_t sm = 0; sm < 18; sm++){
+ if(countSupermodule[sm] > 0) meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
+ }
+ for(Int_t det = 0; det < 540; det++){
+ if(countDetector[det] > 0) meanDetector[det] = meanDetector[det]/countDetector[det];
+ }
+ // Put the mean value for the no-fitted
+ /////////////////////////////////////////////
+ for (Int_t k = 0; k < loop; k++) {
+ detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
+ sector = GetSector(detector);
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
+ Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
+
+ for (Int_t row = 0; row < rowMax; row++) {
+ for (Int_t col = 0; col < colMax; col++) {
+ value = coef[(Int_t)(col*rowMax+row)];
+ if(value < 0.0) {
+ if((ofwhat == 0) && (meanAll > 0.0)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
+ if(ofwhat == 1){
+ if(meanDetector[detector] > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanDetector[detector]);
+ else if(meanSupermodule[sector] > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanSupermodule[sector]);
+ else if(meanAll > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
+ }
+ }
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Float_t coefnow = coef[(Int_t)(col*rowMax+row)];
+
+ (* fDebugStreamer) << "PutMeanValueOtherVectorFit"<<
+ "detector="<<detector<<
+ "sector="<<sector<<
+ "row="<<row<<
+ "col="<<col<<
+ "before="<<value<<
+ "after="<<coefnow<<
+ "\n";
+ }
+ } // Col
+ } // Row
+ }
+
+}
+//______________________________________________________________________
+void AliTRDCalibraFit::PutMeanValueOtherVectorFit2(Int_t ofwhat, Bool_t perdetector){
+ //
+ // ofwhat is equaled to 0: mean value of all passing detectors
+ // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
+ //
+
+ Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
+ if(loop != 540) {
+ AliInfo("The Vector Fit is not complete!");
+ return;
+ }
+ Int_t detector = -1;
+ Int_t sector = -1;
+ Float_t value = 0.0;
+
+ /////////////////////////////////
+ // Calculate the mean values
+ ////////////////////////////////
+ // Initialisation
+ ////////////////////////
+ Double_t meanAll = 0.0;
+ Double_t meanSupermodule[18];
+ Double_t meanDetector[540];
+ Int_t countAll = 0;
+ Int_t countSupermodule[18];
+ Int_t countDetector[540];
+ for(Int_t sm = 0; sm < 18; sm++){
+ meanSupermodule[sm] = 0.0;
+ countSupermodule[sm] = 0;
+ }
+ for(Int_t det = 0; det < 540; det++){
+ meanDetector[det] = 0.0;
+ countDetector[det] = 0;
+ }
+ // compute
+ ////////////
+ for (Int_t k = 0; k < loop; k++) {
+ detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
+ sector = GetSector(detector);
+ if(perdetector){
+ value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
+ if(value < 70.0) {
+ meanDetector[detector] += value;
+ countDetector[detector]++;
+ meanSupermodule[sector] += value;
+ countSupermodule[sector]++;
+ meanAll += value;
+ countAll++;
+ }
+ }
+ else {
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
+ for (Int_t row = 0; row < rowMax; row++) {
+ for (Int_t col = 0; col < colMax; col++) {
+ value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+ if(value < 70.0) {
+ meanDetector[detector] += value;
+ countDetector[detector]++;
+ meanSupermodule[sector] += value;
+ countSupermodule[sector]++;
+ meanAll += value;
+ countAll++;
+ }
+
+ } // Col
+ } // Row
+ }
+ }
+ if(countAll > 0) meanAll = meanAll/countAll;
+ for(Int_t sm = 0; sm < 18; sm++){
+ if(countSupermodule[sm] > 0) meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
+ }
+ for(Int_t det = 0; det < 540; det++){
+ if(countDetector[det] > 0) meanDetector[det] = meanDetector[det]/countDetector[det];
+ }
+ // Put the mean value for the no-fitted
+ /////////////////////////////////////////////
+ for (Int_t k = 0; k < loop; k++) {
+ detector = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
+ sector = GetSector(detector);
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
+ Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
+
+ for (Int_t row = 0; row < rowMax; row++) {
+ for (Int_t col = 0; col < colMax; col++) {
+ value = coef[(Int_t)(col*rowMax+row)];
+ if(value > 70.0) {
+ if((ofwhat == 0) && (meanAll > 0.0)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
+ if(ofwhat == 1){
+ if(meanDetector[detector] > 0.0) coef[(Int_t)(col*rowMax+row)] = meanDetector[detector]+100.0;
+ else if(meanSupermodule[sector] > 0.0) coef[(Int_t)(col*rowMax+row)] = meanSupermodule[sector]+100.0;
+ else if(meanAll > 0.0) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
+ }
+ }
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Float_t coefnow = coef[(Int_t)(col*rowMax+row)];
+
+ (* fDebugStreamer) << "PutMeanValueOtherVectorFit2"<<
+ "detector="<<detector<<
+ "sector="<<sector<<
+ "row="<<row<<
+ "col="<<col<<
+ "before="<<value<<
+ "after="<<coefnow<<
+ "\n";
+ }
+ } // Col
+ } // Row
+ }
+
+}
//_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(TObjArray *vectorFit, Bool_t perdetector)
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(const TObjArray *vectorFit, Bool_t perdetector)
{
//
// It creates the AliTRDCalDet object from the AliTRDFitInfo
if(loop != 540) AliInfo("The Vector Fit is not complete!");
Int_t detector = -1;
Float_t value = 0.0;
-
+
+ //
for (Int_t k = 0; k < loop; k++) {
detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
Float_t mean = 0.0;
}
else {
Int_t count = 0;
- Int_t rowMax = fGeo->GetRowMax(GetPlane(detector),GetChamber(detector),GetSector(detector));
- Int_t colMax = fGeo->GetColMax(GetPlane(detector));
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
for (Int_t row = 0; row < rowMax; row++) {
for (Int_t col = 0; col < colMax; col++) {
value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
return object;
}
//_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(TObjArray *vectorFit, Double_t scaleFitFactor, Bool_t perdetector)
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(const TObjArray *vectorFit, Bool_t meanOtherBefore, Double_t scaleFitFactor, Bool_t perdetector)
{
//
// It creates the AliTRDCalDet object from the AliTRDFitInfo
Float_t mean = 0.0;
if(perdetector){
value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
- if(value > 0) value = value*scaleFitFactor;
+ if(!meanOtherBefore){
+ if(value > 0) value = value*scaleFitFactor;
+ }
+ else value = value*scaleFitFactor;
mean = TMath::Abs(value);
}
else{
Int_t count = 0;
- Int_t rowMax = fGeo->GetRowMax(GetPlane(detector),GetChamber(detector),GetSector(detector));
- Int_t colMax = fGeo->GetColMax(GetPlane(detector));
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
for (Int_t row = 0; row < rowMax; row++) {
for (Int_t col = 0; col < colMax; col++) {
value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
- if(value > 0) value = value*scaleFitFactor;
+ if(!meanOtherBefore) {
+ if(value > 0) value = value*scaleFitFactor;
+ }
+ else value = value*scaleFitFactor;
mean += TMath::Abs(value);
count++;
} // Col
return object;
}
//_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(TObjArray *vectorFit, Bool_t perdetector)
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector)
{
//
// It creates the AliTRDCalDet object from the AliTRDFitInfo2
detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
Float_t min = 100.0;
if(perdetector){
- min = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
+ value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
+ // check successful
+ if(value > 70.0) value = value-100.0;
+ //
+ min = value;
}
else{
- Int_t rowMax = fGeo->GetRowMax(GetPlane(detector),GetChamber(detector),GetSector(detector));
- Int_t colMax = fGeo->GetColMax(GetPlane(detector));
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
for (Int_t row = 0; row < rowMax; row++) {
for (Int_t col = 0; col < colMax; col++) {
value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+ // check successful
+ if(value > 70.0) value = value-100.0;
+ //
if(min > value) min = value;
} // Col
} // Row
}
//_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(TObjArray *vectorFit)
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vectorFit)
{
//
// It creates the AliTRDCalDet object from the AliTRDFitInfo2
for (Int_t k = 0; k < loop; k++) {
detector = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
/*
- Int_t rowMax = fGeo->GetRowMax(GetPlane(detector),GetChamber(detector),GetSector(detector));
- Int_t colMax = fGeo->GetColMax(GetPlane(detector));
+ Int_t rowMax = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+ Int_t colMax = fGeo->GetColMax(GetLayer(detector));
Float_t min = 100.0;
for (Int_t row = 0; row < rowMax; row++) {
for (Int_t col = 0; col < colMax; col++) {
}
//_____________________________________________________________________________
-TObject *AliTRDCalibraFit::CreatePadObjectGain(TObjArray *vectorFit, Double_t scaleFitFactor, AliTRDCalDet *detobject)
+TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
{
//
// It Creates the AliTRDCalPad object from AliTRDFitInfo
return object;
}
//_____________________________________________________________________________
-TObject *AliTRDCalibraFit::CreatePadObjectVdrift(TObjArray *vectorFit, AliTRDCalDet *detobject)
+TObject *AliTRDCalibraFit::CreatePadObjectVdrift(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
{
//
// It Creates the AliTRDCalPad object from AliTRDFitInfo
}
//_____________________________________________________________________________
-TObject *AliTRDCalibraFit::CreatePadObjectT0(TObjArray *vectorFit, AliTRDCalDet *detobject)
+TObject *AliTRDCalibraFit::CreatePadObjectT0(const TObjArray *vectorFit, const AliTRDCalDet *detobject)
{
//
// It Creates the AliTRDCalPad object from AliTRDFitInfo2
for (Int_t row = 0; row < rowMax; row++) {
for (Int_t col = 0; col < colMax; col++) {
value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+ // check successful
+ if(value > 70.0) value = value - 100.0;
+ //
calROC->SetValue(col,row,value-min);
} // Col
} // Row
}
//_____________________________________________________________________________
-TObject *AliTRDCalibraFit::CreatePadObjectPRF(TObjArray *vectorFit)
+TObject *AliTRDCalibraFit::CreatePadObjectPRF(const TObjArray *vectorFit)
{
//
// It Creates the AliTRDCalPad object from AliTRDFitInfo
}
//_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(TObjArray *vectorFit, const char *name, Double_t &mean)
+AliTRDCalDet *AliTRDCalibraFit::MakeOutliersStatDet(const TObjArray *vectorFit, const char *name, Double_t &mean)
{
//
// It Creates the AliTRDCalDet object from AliTRDFitInfo
return object;
}
//_____________________________________________________________________________
-TObject *AliTRDCalibraFit::MakeOutliersStatPad(TObjArray *vectorFit, const char *name, Double_t &mean)
+TObject *AliTRDCalibraFit::MakeOutliersStatPad(const TObjArray *vectorFit, const char *name, Double_t &mean)
{
//
// It Creates the AliTRDCalPad object from AliTRDFitInfo
}
//_____________________________________________________________________________
-void AliTRDCalibraFit::SetT0Shift(Float_t t0Shift)
+void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift)
{
//
- // The t0 calculated with the maximum positif slope is shift from t0Shift
- // You can here set t0Shift
+ // The t0 calculated with the maximum positif slope is shift from t0Shift0
+ // You can here set t0Shift0
//
if (t0Shift > 0) {
- fT0Shift = t0Shift;
+ fT0Shift0 = t0Shift;
+ }
+ else {
+ AliInfo("t0Shift0 must be strict positif!");
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFit::SetT0Shift1(Float_t t0Shift)
+{
+ //
+ // The t0 calculated with the maximum of the amplification region is shift from t0Shift1
+ // You can here set t0Shift1
+ //
+
+ if (t0Shift > 0) {
+ fT0Shift1 = t0Shift;
}
else {
AliInfo("t0Shift must be strict positif!");
AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
Int_t ntotal = 1;
- if (GetChamber(fCountDet) == 2) {
+ if (GetStack(fCountDet) == 2) {
ntotal = 1728;
}
else {
AliTRDFitInfo *fitInfo = new AliTRDFitInfo();
Int_t ntotal = 1;
- if (GetChamber(fCountDet) == 2) {
+ if (GetStack(fCountDet) == 2) {
ntotal = 1728;
}
else {
// Quick verification that we have the good pad calibration mode!
if (fNumberOfBinsExpected != nbins) {
- AliInfo("It doesn't correspond to the mode of pad group calibration!");
+ AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
return kFALSE;
}
fCalDet2 = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
//printf("test2\n");
for(Int_t k = 0; k < 540; k++){
- fCalDet2->SetValue(k,cal->GetOmegaTau(fCalDet->GetValue(k),-fMagneticField));
+ fCalDet2->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDet->GetValue(k)));
}
//printf("test3\n");
}
else{
Float_t devalue = 1.5;
- Float_t devalue2 = cal->GetOmegaTau(1.5,-fMagneticField);
+ Float_t devalue2 = AliTRDCommonParam::Instance()->GetOmegaTau(1.5);
if(fCalDet) delete fCalDet;
if(fCalDet2) delete fCalDet2;
//printf("test1\n");
fCount = fCalibraMode->GetXbins(i);
fCountDet--;
// Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
- fCalibraMode->ModePadCalibration((Int_t) GetChamber(fCountDet),i);
- fCalibraMode->ModePadFragmentation((Int_t) GetPlane(fCountDet)
- ,(Int_t) GetChamber(fCountDet)
- ,(Int_t) GetSector(fCountDet),i);
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),i);
}
}
//_______________________________________________________________________________
//
fNumberOfBinsExpected = 0;
+ // All
+ if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
+ fNumberOfBinsExpected = 1;
+ return;
+ }
+ // Per supermodule
+ if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
+ fNumberOfBinsExpected = 18;
+ return;
+ }
+ // More
fCalibraMode->ModePadCalibration(2,i);
fCalibraMode->ModePadFragmentation(0,2,0,i);
fCalibraMode->SetDetChamb2(i);
fCalibraMode->CalculXBins(fCountDet,i);
fDect1 = fCalibraMode->GetXbins(i);
// Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
- fCalibraMode->ModePadCalibration((Int_t) GetChamber(fCountDet),i);
- fCalibraMode->ModePadFragmentation((Int_t) GetPlane(fCountDet)
- ,(Int_t) GetChamber(fCountDet)
- ,(Int_t) GetSector(fCountDet),i);
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),i);
// Set for the next detector
fDect2 = fDect1 + fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
}
// Doesn't matter for 2
//
if (fCount == idect) {
- // On en est au detector
- fCountDet += 1;
- // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
- fCalibraMode->ModePadCalibration((Int_t) GetChamber(fCountDet),i);
- fCalibraMode->ModePadFragmentation((Int_t) GetPlane(fCountDet)
- ,(Int_t) GetChamber(fCountDet)
- ,(Int_t) GetSector(fCountDet),i);
- // Set for the next detector
- fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
- // calib objects
- SetCalROC(i);
- }
+ // On en est au detector (or first detector in the group)
+ fCountDet += 1;
+ AliDebug(2,Form("We are at the detector %d\n",fCountDet));
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),i);
+ // Set for the next detector
+ fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
+ // calib objects
+ SetCalROC(i);
+ }
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
//
// Reconstruct the min pad row, max pad row, min pad col and
// max pad col of the calibration group for the Fit functions
+ // idect is the calibration group inside the detector
//
if (fDebugLevel != 1) {
fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
}
+ AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
+ AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
if (fDebugLevel == 1) {
AliInfo("The element has not enough statistic to be fitted");
}
-
+ else if (fNbDet > 0){
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+ ,idect,firstdetector,lastdetector));
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(0);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),0);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,0);
+
+ // Calcul the coef from the database choosen for the detector
+ CalculChargeCoefMean(kFALSE);
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+ }
+ }
+
+ //Put default value negative
+ fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+ fCurrentCoefE = 0.0;
+
+ // Fill the stuff
+ FillVectorFit();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Int_t detector = fCountDet;
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(0);
+ Short_t rowmax = fCalibraMode->GetRowMax(0);
+ Short_t colmin = fCalibraMode->GetColMin(0);
+ Short_t colmax = fCalibraMode->GetColMax(0);
+ Float_t gf = fCurrentCoef[0];
+ Float_t gfs = fCurrentCoef[1];
+ Float_t gfE = fCurrentCoefE;
+
+ (*fDebugStreamer) << "FillFillCH" <<
+ "detector=" << detector <<
+ "caligroup=" << caligroup <<
+ "rowmin=" << rowmin <<
+ "rowmax=" << rowmax <<
+ "colmin=" << colmin <<
+ "colmax=" << colmax <<
+ "gf=" << gf <<
+ "gfs=" << gfs <<
+ "gfE=" << gfE <<
+ "\n";
+
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ }
+
+ }// loop detector
+ AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+ }
else {
AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
// Calcul the coef from the database choosen
CalculChargeCoefMean(kFALSE);
- //chamber 2, not chamber 2
+ //stack 2, not stack 2
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
+ if(GetStack(fCountDet) == 2) factor = 12;
else factor = 16;
// Fill the fCurrentCoefDetector with negative value to say: not fitted
//____________Functions for initialising the AliTRDCalibraFit in the code_________
-Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect)
+Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
{
//
// For the case where there are not enough entries in the histograms
if (fDebugLevel == 1) {
AliInfo("The element has not enough statistic to be fitted");
}
+ else if (fNbDet > 0) {
+
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+ ,idect,firstdetector,lastdetector));
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(1);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),1);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,1);
+
+ // Calcul the coef from the database choosen for the detector
+ CalculVdriftCoefMean();
+ CalculT0CoefMean();
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+ fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
+ }
+ }
+
+ //Put default value negative
+ fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+ fCurrentCoefE = 0.0;
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+ fCurrentCoefE2 = 0.0;
+
+ // Fill the stuff
+ FillVectorFit();
+ FillVectorFit2();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+
+ Int_t detector = fCountDet;
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(1);
+ Short_t rowmax = fCalibraMode->GetRowMax(1);
+ Short_t colmin = fCalibraMode->GetColMin(1);
+ Short_t colmax = fCalibraMode->GetColMax(1);
+ Float_t vf = fCurrentCoef[0];
+ Float_t vs = fCurrentCoef[1];
+ Float_t vfE = fCurrentCoefE;
+ Float_t t0f = fCurrentCoef2[0];
+ Float_t t0s = fCurrentCoef2[1];
+ Float_t t0E = fCurrentCoefE2;
+
+
+
+ (* fDebugStreamer) << "FillFillPH"<<
+ "detector="<<detector<<
+ "nentries="<<nentries<<
+ "caligroup="<<caligroup<<
+ "rowmin="<<rowmin<<
+ "rowmax="<<rowmax<<
+ "colmin="<<colmin<<
+ "colmax="<<colmax<<
+ "vf="<<vf<<
+ "vs="<<vs<<
+ "vfE="<<vfE<<
+ "t0f="<<t0f<<
+ "t0s="<<t0s<<
+ "t0E="<<t0E<<
+ "\n";
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ fCurrentCoefDetector2[k] = 0.0;
+ }
+
+ }// loop detector
+ AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+ }
else {
AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
CalculVdriftCoefMean();
CalculT0CoefMean();
- //chamber 2 and not chamber 2
+ //stack 2 and not stack 2
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
+ if(GetStack(fCountDet) == 2) factor = 12;
else factor = 16;
for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
- fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1];
+ fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
}
}
// Put the default value
fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
fCurrentCoefE = 0.0;
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
fCurrentCoefE2 = 0.0;
- FillFillPH(idect);
+ FillFillPH(idect,nentries);
}
return kTRUE;
-
+
}
if (fDebugLevel == 1) {
AliInfo("The element has not enough statistic to be fitted");
}
+ else if (fNbDet > 0){
+
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+ ,idect,firstdetector,lastdetector));
+
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(2);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),2);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,2);
+
+ // Calcul the coef from the database choosen for the detector
+ CalculPRFCoefMean();
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+ }
+ }
+
+ //Put default value negative
+ fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+ fCurrentCoefE = 0.0;
+
+ // Fill the stuff
+ FillVectorFit();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Int_t detector = fCountDet;
+ Int_t layer = GetLayer(fCountDet);
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(2);
+ Short_t rowmax = fCalibraMode->GetRowMax(2);
+ Short_t colmin = fCalibraMode->GetColMin(2);
+ Short_t colmax = fCalibraMode->GetColMax(2);
+ Float_t widf = fCurrentCoef[0];
+ Float_t wids = fCurrentCoef[1];
+ Float_t widfE = fCurrentCoefE;
+
+ (* fDebugStreamer) << "FillFillPRF"<<
+ "detector="<<detector<<
+ "layer="<<layer<<
+ "caligroup="<<caligroup<<
+ "rowmin="<<rowmin<<
+ "rowmax="<<rowmax<<
+ "colmin="<<colmin<<
+ "colmax="<<colmax<<
+ "widf="<<widf<<
+ "wids="<<wids<<
+ "widfE="<<widfE<<
+ "\n";
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ }
+
+ }// loop detector
+ AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+ }
else {
AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
CalculPRFCoefMean();
- // chamber 2 and not chamber 2
+ // stack 2 and not stack 2
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
+ if(GetStack(fCountDet) == 2) factor = 12;
else factor = 16;
// Fill the fCurrentCoefDetector
for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
- fCurrentCoefDetector[(Int_t)(j*factor+k)] = -fCurrentCoef[1];
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
}
}
// Put the default value
- fCurrentCoef[0] = -fCurrentCoef[1];
+ fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
fCurrentCoefE = 0.0;
FillFillPRF(idect);
CalculVdriftLorentzCoef();
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 1728;
+ if(GetStack(fCountDet) == 2) factor = 1728;
else factor = 2304;
//
if (fDebugLevel != 1) {
-
- Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
- else factor = 16;
-
- for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
- for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
- fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+ if (fNbDet > 0){
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+ ,idect,firstdetector,lastdetector));
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(0);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),0);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,0);
+
+ // Calcul the coef from the database choosen for the detector
+ if(fCurrentCoef[0] < 0.0) CalculChargeCoefMean(kFALSE);
+ else CalculChargeCoefMean(kTRUE);
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ Double_t coeftoput = 1.0;
+ if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+ else coeftoput = fCurrentCoef[0];
+ for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
+ }
+ }
+
+ // Fill the stuff
+ FillVectorFit();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Int_t detector = fCountDet;
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(0);
+ Short_t rowmax = fCalibraMode->GetRowMax(0);
+ Short_t colmin = fCalibraMode->GetColMin(0);
+ Short_t colmax = fCalibraMode->GetColMax(0);
+ Float_t gf = fCurrentCoef[0];
+ Float_t gfs = fCurrentCoef[1];
+ Float_t gfE = fCurrentCoefE;
+
+ (*fDebugStreamer) << "FillFillCH" <<
+ "detector=" << detector <<
+ "caligroup=" << caligroup <<
+ "rowmin=" << rowmin <<
+ "rowmax=" << rowmax <<
+ "colmin=" << colmin <<
+ "colmax=" << colmax <<
+ "gf=" << gf <<
+ "gfs=" << gfs <<
+ "gfE=" << gfE <<
+ "\n";
+
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ }
+
+ }// loop detector
+ //printf("Check the count now: fCountDet %d\n",fCountDet);
+ }
+ else{
+
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+ }
}
+
+ FillFillCH(idect);
}
-
- FillFillCH(idect);
-
}
return kTRUE;
}
//____________Functions for initialising the AliTRDCalibraFit in the code_________
-Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect)
+Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect,Double_t nentries)
{
//
// Fill the coefficients found with the fits or other
//
if (fDebugLevel != 1) {
-
- Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
- else factor = 16;
-
- for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
- for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
- fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
- fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
- }
- }
- FillFillPH(idect);
+ if (fNbDet > 0){
+
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+ ,idect,firstdetector,lastdetector));
+
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(1);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),1);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,1);
+
+ // Calcul the coef from the database choosen for the detector
+ CalculVdriftCoefMean();
+ CalculT0CoefMean();
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ Double_t coeftoput = 1.5;
+ Double_t coeftoput2 = 0.0;
+
+ if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+ else coeftoput = fCurrentCoef[0];
+
+ if(fCurrentCoef2[0] > 70.0) coeftoput2 = fCurrentCoef2[1] + 100.0;
+ else coeftoput2 = fCurrentCoef2[0];
+
+ for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
+ fCurrentCoefDetector2[(Int_t)(j*factor+k)] = coeftoput2;
+ }
+ }
+
+ // Fill the stuff
+ FillVectorFit();
+ FillVectorFit2();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+
+ Int_t detector = fCountDet;
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(1);
+ Short_t rowmax = fCalibraMode->GetRowMax(1);
+ Short_t colmin = fCalibraMode->GetColMin(1);
+ Short_t colmax = fCalibraMode->GetColMax(1);
+ Float_t vf = fCurrentCoef[0];
+ Float_t vs = fCurrentCoef[1];
+ Float_t vfE = fCurrentCoefE;
+ Float_t t0f = fCurrentCoef2[0];
+ Float_t t0s = fCurrentCoef2[1];
+ Float_t t0E = fCurrentCoefE2;
+
+
+
+ (* fDebugStreamer) << "FillFillPH"<<
+ "detector="<<detector<<
+ "nentries="<<nentries<<
+ "caligroup="<<caligroup<<
+ "rowmin="<<rowmin<<
+ "rowmax="<<rowmax<<
+ "colmin="<<colmin<<
+ "colmax="<<colmax<<
+ "vf="<<vf<<
+ "vs="<<vs<<
+ "vfE="<<vfE<<
+ "t0f="<<t0f<<
+ "t0s="<<t0s<<
+ "t0E="<<t0E<<
+ "\n";
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ fCurrentCoefDetector2[k] = 0.0;
+ }
+
+ }// loop detector
+ //printf("Check the count now: fCountDet %d\n",fCountDet);
+ }
+ else {
+
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+ fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
+ }
+ }
+
+ FillFillPH(idect,nentries);
+ }
}
return kTRUE;
}
//
if (fDebugLevel != 1) {
-
- Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
- else factor = 16;
+ if (fNbDet > 0){
- // Pointer to the branch
- for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
- for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
- fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+ Int_t firstdetector = fCountDet;
+ Int_t lastdetector = fCountDet+fNbDet;
+ AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+ ,idect,firstdetector,lastdetector));
+
+ // loop over detectors
+ for(Int_t det = firstdetector; det < lastdetector; det++){
+
+ //Set the calibration object again
+ fCountDet = det;
+ SetCalROC(2);
+
+ // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+ // Put them at 1
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+ ,(Int_t) GetStack(fCountDet)
+ ,(Int_t) GetSector(fCountDet),2);
+ // Reconstruct row min row max
+ ReconstructFitRowMinRowMax(idect,2);
+
+ // Calcul the coef from the database choosen for the detector
+ CalculPRFCoefMean();
+
+ //stack 2, not stack 2
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Fill the fCurrentCoefDetector with negative value to say: not fitted
+ Double_t coeftoput = 1.0;
+ if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+ else coeftoput = fCurrentCoef[0];
+ for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
+ }
+ }
+
+ // Fill the stuff
+ FillVectorFit();
+ // Debug
+ if(fDebugLevel > 1){
+
+ if ( !fDebugStreamer ) {
+ //debug stream
+ TDirectory *backup = gDirectory;
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
+ if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
+ }
+
+ Int_t detector = fCountDet;
+ Int_t layer = GetLayer(fCountDet);
+ Int_t caligroup = idect;
+ Short_t rowmin = fCalibraMode->GetRowMin(2);
+ Short_t rowmax = fCalibraMode->GetRowMax(2);
+ Short_t colmin = fCalibraMode->GetColMin(2);
+ Short_t colmax = fCalibraMode->GetColMax(2);
+ Float_t widf = fCurrentCoef[0];
+ Float_t wids = fCurrentCoef[1];
+ Float_t widfE = fCurrentCoefE;
+
+ (* fDebugStreamer) << "FillFillPRF"<<
+ "detector="<<detector<<
+ "layer="<<layer<<
+ "caligroup="<<caligroup<<
+ "rowmin="<<rowmin<<
+ "rowmax="<<rowmax<<
+ "colmin="<<colmin<<
+ "colmax="<<colmax<<
+ "widf="<<widf<<
+ "wids="<<wids<<
+ "widfE="<<widfE<<
+ "\n";
+ }
+ // Reset
+ for (Int_t k = 0; k < 2304; k++) {
+ fCurrentCoefDetector[k] = 0.0;
+ }
+
+ }// loop detector
+ //printf("Check the count now: fCountDet %d\n",fCountDet);
+ }
+ else {
+
+ Int_t factor = 0;
+ if(GetStack(fCountDet) == 2) factor = 12;
+ else factor = 16;
+
+ // Pointer to the branch
+ for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+ for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+ fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+ }
}
+ FillFillPRF(idect);
}
- FillFillPRF(idect);
}
-
+
return kTRUE;
}
//
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 1728;
+ if(GetStack(fCountDet) == 2) factor = 1728;
else factor = 2304;
// Pointer to the branch
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Float_t gfs = fCurrentCoef[1];
Float_t gfE = fCurrentCoefE;
- (*fDebugStreamer) << "GAIN" <<
+ (*fDebugStreamer) << "FillFillCH" <<
"detector=" << detector <<
"caligroup=" << caligroup <<
"rowmin=" << rowmin <<
}
}
//________________________________________________________________________________
-void AliTRDCalibraFit::FillFillPH(Int_t idect)
+void AliTRDCalibraFit::FillFillPH(Int_t idect,Double_t nentries)
{
//
// DebugStream and fVectorFit and fVectorFit2
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
- (* fDebugStreamer) << "PH"<<
+ (* fDebugStreamer) << "FillFillPH"<<
"detector="<<detector<<
+ "nentries="<<nentries<<
"caligroup="<<caligroup<<
"rowmin="<<rowmin<<
"rowmax="<<rowmax<<
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Int_t detector = fCountDet;
- Int_t plane = GetPlane(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
Int_t caligroup = idect;
Short_t rowmin = fCalibraMode->GetRowMin(2);
Short_t rowmax = fCalibraMode->GetRowMax(2);
Float_t wids = fCurrentCoef[1];
Float_t widfE = fCurrentCoefE;
- (* fDebugStreamer) << "PRF"<<
+ (* fDebugStreamer) << "FillFillPRF"<<
"detector="<<detector<<
- "plane="<<plane<<
+ "layer="<<layer<<
"caligroup="<<caligroup<<
"rowmin="<<rowmin<<
"rowmax="<<rowmax<<
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitLinearFitter.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
//Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
- AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetPlane(fCountDet),GetChamber(fCountDet));
+ AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
Float_t rowmd = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
- Float_t r = AliTRDgeometry::GetTime0(GetPlane(fCountDet));
+ Float_t r = AliTRDgeometry::GetTime0(GetLayer(fCountDet));
Float_t tiltangle = padplane->GetTiltingAngle();
Int_t detector = fCountDet;
- Int_t chamber = GetChamber(fCountDet);
- Int_t plane = GetChamber(fCountDet);
+ Int_t stack = GetStack(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
Float_t vf = fCurrentCoef[0];
Float_t vs = fCurrentCoef[1];
Float_t vfE = fCurrentCoefE;
Float_t elorentzangler = fCurrentCoefE2;
Float_t lorentzangles = fCurrentCoef2[1];
- (* fDebugStreamer) << "LinearFitter"<<
+ (* fDebugStreamer) << "FillFillLinearFitter"<<
"detector="<<detector<<
- "chamber="<<chamber<<
- "plane="<<plane<<
+ "stack="<<stack<<
+ "layer="<<layer<<
"rowmd="<<rowmd<<
"r="<<r<<
"tiltangle="<<tiltangle<<
fCurrentCoef2[1] = 0.0;
if(fDebugLevel != 1){
- if((fCalibraMode->GetNz(1) > 0) ||
- (fCalibraMode->GetNrphi(1) > 0)) {
+ if(((fCalibraMode->GetNz(1) > 0) ||
+ (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1) != 10) && (fCalibraMode->GetNz(1) != 100))) {
+
for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
}
}
+
fCurrentCoef2[1] = fCurrentCoef2[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
+
}
else {
+
if(!fAccCDB){
fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet);
}
else{
- for(Int_t row = 0; row < fGeo->GetRowMax(GetPlane(fCountDet),GetChamber(fCountDet),GetSector(fCountDet)); row++){
- for(Int_t col = 0; col < fGeo->GetColMax(GetPlane(fCountDet)); col++){
+
+ for(Int_t row = 0; row < fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)); row++){
+ for(Int_t col = 0; col < fGeo->GetColMax(GetLayer(fCountDet)); col++){
fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
}
}
- fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetPlane(fCountDet),GetChamber(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetPlane(fCountDet))));
+ fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetLayer(fCountDet))));
+
}
}
}
fCurrentCoef[1] = 0.0;
if(fDebugLevel != 1){
- if ((fCalibraMode->GetNz(0) > 0) ||
- (fCalibraMode->GetNrphi(0) > 0)) {
+ if (((fCalibraMode->GetNz(0) > 0) ||
+ (fCalibraMode->GetNrphi(0) > 0)) && ((fCalibraMode->GetNz(0) != 10) && (fCalibraMode->GetNz(0) != 100))) {
for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
fCurrentCoef[1] = 0.0;
if(fDebugLevel != 1){
- if ((fCalibraMode->GetNz(1) > 0) ||
- (fCalibraMode->GetNrphi(1) > 0)) {
+ if (((fCalibraMode->GetNz(1) > 0) ||
+ (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1) != 10) && (fCalibraMode->GetNz(1) != 100))) {
+
for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
}
}
+
fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
+
}
else {
//per detectors
return kTRUE;
}
//_____________________________________________________________________________
-Float_t AliTRDCalibraFit::GetPRFDefault(Int_t plane) const
+Float_t AliTRDCalibraFit::GetPRFDefault(Int_t layer) const
{
//
// Default width of the PRF if there is no database as reference
//
- switch(plane)
+ switch(layer)
{
// default database
//case 0: return 0.515;
switch (i)
{
case 0:
- if(fCalROC) delete fCalROC;
- fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
+ if( fCalROC ){
+ fCalROC->~AliTRDCalROC();
+ new(fCalROC) AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
+ }else fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
break;
case 1:
- if(fCalROC) delete fCalROC;
- if(fCalROC2) delete fCalROC2;
- fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
- fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
+ if( fCalROC ){
+ fCalROC->~AliTRDCalROC();
+ new(fCalROC) AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
+ }else fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
+ if( fCalROC2 ){
+ fCalROC2->~AliTRDCalROC();
+ new(fCalROC2) AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
+ }else fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
break;
case 2:
- if(fCalROC) delete fCalROC;
- fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet))); break;
+ if( fCalROC ){
+ fCalROC->~AliTRDCalROC();
+ new(fCalROC) AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
+ }else fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
+ break;
default: return;
}
}
{
case 0:
if(fCalROC) delete fCalROC;
- fCalROC = new AliTRDCalROC(GetPlane(fCountDet),GetChamber(fCountDet));
+ fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
fCalROC->SetValue(k,1.0);
}
case 1:
if(fCalROC) delete fCalROC;
if(fCalROC2) delete fCalROC2;
- fCalROC = new AliTRDCalROC(GetPlane(fCountDet),GetChamber(fCountDet));
- fCalROC2 = new AliTRDCalROC(GetPlane(fCountDet),GetChamber(fCountDet));
+ fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
+ fCalROC2 = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
fCalROC->SetValue(k,1.0);
fCalROC2->SetValue(k,0.0);
break;
case 2:
if(fCalROC) delete fCalROC;
- value = GetPRFDefault(GetPlane(fCountDet));
- fCalROC = new AliTRDCalROC(GetPlane(fCountDet),GetChamber(fCountDet));
+ value = GetPRFDefault(GetLayer(fCountDet));
+ fCalROC = new AliTRDCalROC(GetLayer(fCountDet),GetStack(fCountDet));
for(Int_t k = 0; k < fCalROC->GetNchannels(); k++){
fCalROC->SetValue(k,value);
}
if((l3P1dr != 0.0) && (l3P2dr != 0.0)){
fCurrentCoefE += (l3P1drE/l3P1dr + l3P2drE/l3P2dr)*fPhd[2];
}
- Float_t fPhdt0 = 0.0;
- if(fTakeTheMaxPH) fPhdt0 = fPhd[1];
- else fPhdt0 = fPhd[0];
+ Float_t fPhdt0 = 0.0;
+ Float_t t0Shift = 0.0;
+ if(fTakeTheMaxPH) {
+ fPhdt0 = fPhd[1];
+ t0Shift = fT0Shift1;
+ }
+ else {
+ fPhdt0 = fPhd[0];
+ t0Shift = fT0Shift0;
+ }
if ((fPhd[2] > fPhd[0]) &&
(fPhd[2] > fPhd[1]) &&
fNumberFitSuccess++;
if (fPhdt0 >= 0.0) {
- fCurrentCoef2[0] = (fPhdt0 - fT0Shift) / widbins;
+ fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
if (fCurrentCoef2[0] < -1.0) {
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
}
else {
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
}
else {
fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
if (fDebugLevel == 1) {
}
//check
- if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) put = kFALSE;
- if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) put = kFALSE;
+ if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) {
+ AliInfo("Too many fluctuations at the end!");
+ put = kFALSE;
+ }
+ if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) {
+ AliInfo("Too many fluctuations at the end!");
+ put = kFALSE;
+ }
+ if(pente->GetBinContent(binmin+1)==0){
+ AliInfo("No entries for the next bin!");
+ pente->SetBinContent(binmin,0);
+ if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
+ }
+
x[0] = 0.0;
x[1] = 0.0;
c = CalculPolynomeLagrange4(x,y);
//richtung +/-
if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
- (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
+ (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+ //AliInfo("polynome 4 false 1");
+ put = kFALSE;
+ }
if(((binmin+3) <= (nbins-1)) &&
(pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
- (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) put = kFALSE;
+ (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) {
+ AliInfo("polynome 4 false 2");
+ put = kFALSE;
+ }
+ // poly 3
if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
- (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) case1 = kTRUE;
+ (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) {
+ //AliInfo("polynome 4 case 1");
+ case1 = kTRUE;
+ }
if((pente->GetBinContent(binmin+2) > pente->GetBinContent(binmin+1)) &&
- (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case4 = kTRUE;
+ (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+ //AliInfo("polynome 4 case 4");
+ case4 = kTRUE;
+ }
+
}
//case binmin = nbins-2
//pol3 case 1
c = CalculPolynomeLagrange3(x,y);
//richtung +: nothing
//richtung -
- if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case2 = kTRUE;
+ if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+ //AliInfo("polynome 3- case 2");
+ case2 = kTRUE;
+ }
}
//pol3 case 4
if(((binmin <= (nbins-3)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
//Calcul the polynome de Lagrange
c = CalculPolynomeLagrange3(x,y);
//richtung +
- if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) case2 = kTRUE;
+ if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
+ //AliInfo("polynome 3+ case 2");
+ case2 = kTRUE;
+ }
}
//pol2 case 5
if((binmin <= (nbins-3)) && (binmin == TMath::Min(binmax+4, projPH->GetNbinsX()))){
//Calcul the polynome de Lagrange
c = CalculPolynomeLagrange2(x,y);
//richtung +
- if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) put = kFALSE;
+ if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
+ //AliInfo("polynome 2+ false");
+ put = kFALSE;
+ }
}
//pol2 case 2
if(((binmin == (nbins-2)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
//fluctuation too big!
//richtung +: nothing
//richtung -
- if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
+ if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+ //AliInfo("polynome 2- false ");
+ put = kFALSE;
+ }
}
if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
put = kFALSE;
AliInfo("For the drift...problem!");
}
//pass but should not happen
- if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+4, projPH->GetNbinsX()))){
+ if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+6, projPH->GetNbinsX()))){
put = kFALSE;
AliInfo("For the drift...problem!");
}
}
fPhd[2] = placeminimum;
}
+ //printf("La fin %d\n",((Int_t)(fPhd[2]*10.0))+2);
+ if((((Int_t)(fPhd[2]*10.0))+2) >= projPH->GetNbinsX()) fPhd[2] = 0.0;
+ if(((((Int_t)(fPhd[2]*10.0))+2) < projPH->GetNbinsX()) && (projPH->GetBinContent(((Int_t)(fPhd[2]*10.0))+2)==0)) fPhd[2] = 0.0;
- Float_t fPhdt0 = 0.0;
- if(fTakeTheMaxPH) fPhdt0 = fPhd[1];
- else fPhdt0 = fPhd[0];
+ Float_t fPhdt0 = 0.0;
+ Float_t t0Shift = 0.0;
+ if(fTakeTheMaxPH) {
+ fPhdt0 = fPhd[1];
+ t0Shift = fT0Shift1;
+ }
+ else {
+ fPhdt0 = fPhd[0];
+ t0Shift = fT0Shift0;
+ }
if ((fPhd[2] > fPhd[0]) &&
(fPhd[2] > fPhd[1]) &&
fCurrentCoef[0] = (kDrWidth) / (fPhd[2]-fPhd[1]);
fNumberFitSuccess++;
if (fPhdt0 >= 0.0) {
- fCurrentCoef2[0] = (fPhdt0 - fT0Shift) / widbins;
+ fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
if (fCurrentCoef2[0] < -1.0) {
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
}
else {
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
}
else {
- fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
- fCurrentCoef2[0] = fCurrentCoef2[1];
- //printf("Fit failed!\n");
+ if((fPhd[1] > fPhd[0]) &&
+ (put)) {
+ if (fPhdt0 >= 0.0) {
+ fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
+ if (fCurrentCoef2[0] < -1.0) {
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+ }
+ }
+ else {
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+ }
+ }
+ else{
+ fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+ //printf("Fit failed!\n");
+ }
}
if (fDebugLevel == 1) {
pente->Draw();
}
else {
- delete pentea;
- delete pente;
- delete polynome;
- delete polynomea;
- delete polynomeb;
+ if(pentea) delete pentea;
+ if(pente) delete pente;
+ if(polynome) delete polynome;
+ if(polynomea) delete polynomea;
+ if(polynomeb) delete polynomeb;
+ if(x) delete [] x;
+ if(y) delete [] y;
+ if(c) delete [] c;
+ if(line) delete line;
+
}
+
+ //Provisoire
+ //if(fCurrentCoef[0] > 1.7) fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+ //if((fCurrentCoef2[0] > 2.6) || (fCurrentCoef2[0] < 2.1)) fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
projPH->SetDirectory(0);
}
else {
fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
}
// Put the default value
fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
- fCurrentCoef2[0] = fCurrentCoef2[1];
+ fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
}
if (fDebugLevel != 1) {
}
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t kError)
+Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_t *arrayme, Int_t nBins, Float_t xMin, Float_t xMax, TVectorD *param, Bool_t bError)
{
//
// Fit methode for the sigma of the pad response function
errorm = 0.0;
errorn = 0.0;
error = 0.0;
- if(!kError){
+ if(!bError){
if((valueI + 0.01) > 0.0) errorm = TMath::Log((valueI + 0.01)/valueI);
if((valueI - 0.01) > 0.0) errorn = TMath::Log((valueI - 0.01)/valueI);
error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Int_t detector = fCountDet;
- Int_t plane = GetPlane(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
Int_t group = ibin;
(* fDebugStreamer) << "FitGausMIFill"<<
"detector="<<detector<<
- "plane="<<plane<<
+ "layer="<<layer<<
"nbins="<<nBins<<
"group="<<group<<
"entriesI="<<entriesI<<
"errorm="<<errorm<<
"errorn="<<errorn<<
"error="<<error<<
- "kError="<<kError<<
+ "bError="<<bError<<
"\n";
}
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Int_t detector = fCountDet;
- Int_t plane = GetPlane(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
(* fDebugStreamer) << "FitGausMIFit"<<
"detector="<<detector<<
- "plane="<<plane<<
+ "layer="<<layer<<
"nbins="<<nBins<<
"errorsigma="<<chi2<<
"mean="<<(*param)[1]<<
}
if((chi2/(*param)[2]) > 0.1){
- if(kError){
+ if(bError){
chi2 = FitGausMI(arraye,arraym,arrayme,nBins,xMin,xMax,param,kFALSE);
}
else return -4.0;
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Int_t detector = fCountDet;
- Int_t plane = GetPlane(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
Int_t nbtotal = total;
Int_t group = k;
Float_t low = lowedge;
Float_t wid = fCurrentCoef[0];
Float_t widfE = fCurrentCoefE;
- (* fDebugStreamer) << "FitTnpRangeFill"<<
+ (* fDebugStreamer) << "FitTnpRange0"<<
"detector="<<detector<<
- "plane="<<plane<<
+ "layer="<<layer<<
"nbtotal="<<nbtotal<<
"group="<<group<<
"low="<<low<<
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
Int_t detector = fCountDet;
- Int_t plane = GetPlane(fCountDet);
+ Int_t layer = GetLayer(fCountDet);
Int_t nbtotal = total;
Double_t colsize[6] = {0.635,0.665,0.695,0.725,0.755,0.785};
- Double_t sigmax = TMath::Sqrt(TMath::Abs(pars0[2]))*10000*colsize[plane];
+ Double_t sigmax = TMath::Sqrt(TMath::Abs(pars0[2]))*10000*colsize[layer];
- (* fDebugStreamer) << "FitTnpRangeFit"<<
+ (* fDebugStreamer) << "FitTnpRange1"<<
"detector="<<detector<<
- "plane="<<plane<<
+ "layer="<<layer<<
"nbtotal="<<nbtotal<<
"par0="<<pars0[0]<<
"par1="<<pars0[1]<<
}
}
//_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange2(Double_t *x, Double_t *y) const
+Double_t *AliTRDCalibraFit::CalculPolynomeLagrange2(const Double_t *x, const Double_t *y) const
{
//
// Calcul the coefficients of the polynome passant par ces trois points de degre 2
}
//_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange3(Double_t *x, Double_t *y) const
+Double_t *AliTRDCalibraFit::CalculPolynomeLagrange3(const Double_t *x, const Double_t *y) const
{
//
// Calcul the coefficients of the polynome passant par ces quatre points de degre 3
}
//_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange4(Double_t *x, Double_t *y) const
+Double_t *AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Double_t *y) const
{
//
// Calcul the coefficients of the polynome passant par ces cinqs points de degre 4
Int_t detector = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
//printf("detector %d coef[0] %f\n",detector,coef[0]);
- if (GetChamber(detector) == 2) {
+ if (GetStack(detector) == 2) {
total = 1728;
}
- if (GetChamber(detector) != 2) {
+ if (GetStack(detector) != 2) {
total = 2304;
}
for (Int_t j = 0; j < total; j++) {
if ( !fDebugStreamer ) {
//debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+ fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
- (* fDebugStreamer) << "ScaleFactor"<<
+ (* fDebugStreamer) << "NormierungCharge"<<
"scalefactor="<<scalefactor<<
"\n";
}
}
//_____________________________________________________________________________
-TH1I *AliTRDCalibraFit::ReBin(TH1I *hist) const
+TH1I *AliTRDCalibraFit::ReBin(const TH1I *hist) const
{
//
// Rebin of the 1D histo for the gain calibration if needed.
}
//_____________________________________________________________________________
-TH1F *AliTRDCalibraFit::ReBin(TH1F *hist) const
+TH1F *AliTRDCalibraFit::ReBin(const TH1F *hist) const
{
//
// Rebin of the 1D histo for the gain calibration if needed
}
//_____________________________________________________________________________
-TH1F *AliTRDCalibraFit::CorrectTheError(TGraphErrors *hist)
+TH1F *AliTRDCalibraFit::CorrectTheError(const TGraphErrors *hist)
{
//
// In the case of the vectors method the trees contains TGraphErrors for PH and PRF
//
//_____________________________________________________________________________
-Int_t AliTRDCalibraFit::GetPlane(Int_t d) const
+Int_t AliTRDCalibraFit::GetLayer(Int_t d) const
{
//
// Reconstruct the plane number from the detector number
}
//_____________________________________________________________________________
-Int_t AliTRDCalibraFit::GetChamber(Int_t d) const
+Int_t AliTRDCalibraFit::GetStack(Int_t d) const
{
//
- // Reconstruct the chamber number from the detector number
+ // Reconstruct the stack number from the detector number
//
- Int_t fgkNplan = 6;
+ const Int_t kNlayer = 6;
- return ((Int_t) (d % 30) / fgkNplan);
+ return ((Int_t) (d % 30) / kNlayer);
}
//
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::PH(Double_t *x, Double_t *par)
+Double_t AliTRDCalibraFit::PH(const Double_t *x, const Double_t *par)
{
//
// Function for the fit
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::AsymmGauss(Double_t *x, Double_t *par)
+Double_t AliTRDCalibraFit::AsymmGauss(const Double_t *x, const Double_t *par)
{
//
// Function for the fit
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::FuncLandauGaus(Double_t *x, Double_t *par)
+Double_t AliTRDCalibraFit::FuncLandauGaus(const Double_t *x, const Double_t *par)
{
//
// Sum Landau + Gaus with identical mean
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::LanGauFun(Double_t *x, Double_t *par)
+Double_t AliTRDCalibraFit::LanGauFun(const Double_t *x, const Double_t *par)
{
//
// Function for the fit
}
//_____________________________________________________________________________
-TF1 *AliTRDCalibraFit::LanGauFit(TH1 *his, Double_t *fitrange, Double_t *startvalues
- , Double_t *parlimitslo, Double_t *parlimitshi
+TF1 *AliTRDCalibraFit::LanGauFit(TH1 *his, const Double_t *fitrange, const Double_t *startvalues
+ , const Double_t *parlimitslo, const Double_t *parlimitshi
, Double_t *fitparams, Double_t *fiterrors
, Double_t *chiSqr, Int_t *ndf) const
{
}
//_____________________________________________________________________________
-Int_t AliTRDCalibraFit::LanGauPro(Double_t *params, Double_t &maxx, Double_t &fwhm)
+Int_t AliTRDCalibraFit::LanGauPro(const Double_t *params, Double_t &maxx, Double_t &fwhm)
{
//
// Function for the fit
return (0);
}
//_____________________________________________________________________________
-Double_t AliTRDCalibraFit::GausConstant(Double_t *x, Double_t *par)
+Double_t AliTRDCalibraFit::GausConstant(const Double_t *x, const Double_t *par)
{
//
// Gaus with identical mean
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff