,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)
,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)
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 {
fgInstance = 0x0;
}
+}
+//__________________________________________________________________________________
+void AliTRDCalibraFit::RangeChargeIntegration(Float_t vdrift, Float_t t0, Int_t &begin, Int_t &peak, Int_t &end)
+{
+ //
+ // 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 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);
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);
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
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();
}
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)];
}
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)];
min = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
}
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)];
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++) {
}
//_____________________________________________________________________________
-void AliTRDCalibraFit::SetT0Shift(Float_t t0Shift)
+void AliTRDCalibraFit::SetT0Shift0(Float_t t0Shift)
+{
+ //
+ // The t0 calculated with the maximum positif slope is shift from t0Shift0
+ // You can here set t0Shift0
+ //
+
+ if (t0Shift > 0) {
+ fT0Shift0 = t0Shift;
+ }
+ else {
+ AliInfo("t0Shift0 must be strict positif!");
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFit::SetT0Shift1(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 of the amplification region is shift from t0Shift1
+ // You can here set t0Shift1
//
if (t0Shift > 0) {
- fT0Shift = t0Shift;
+ 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 {
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);
}
}
//_______________________________________________________________________________
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);
}
// 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);
+ 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
// 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
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;
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;
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;
+ if(GetStack(fCountDet) == 2) factor = 12;
else factor = 16;
for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
if (fDebugLevel != 1) {
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++) {
if (fDebugLevel != 1) {
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 12;
+ if(GetStack(fCountDet) == 2) factor = 12;
else factor = 16;
// Pointer to the branch
//
Int_t factor = 0;
- if(GetChamber(fCountDet) == 2) factor = 1728;
+ if(GetStack(fCountDet) == 2) factor = 1728;
else factor = 2304;
// Pointer to the branch
Float_t gfs = fCurrentCoef[1];
Float_t gfE = fCurrentCoefE;
- (*fDebugStreamer) << "GAIN" <<
+ (*fDebugStreamer) << "FillFillCH" <<
"detector=" << detector <<
"caligroup=" << caligroup <<
"rowmin=" << rowmin <<
- (* fDebugStreamer) << "PH"<<
+ (* fDebugStreamer) << "FillFillPH"<<
"detector="<<detector<<
"caligroup="<<caligroup<<
"rowmin="<<rowmin<<
}
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<<
}
//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] = 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))));
}
}
}
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;
{
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];
}
fPhd[2] = placeminimum;
}
- 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];
}
}
}
//_____________________________________________________________________________
-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));
}
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";
}
}
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;
}
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<<
}
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]<<
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++) {
fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
}
- (* fDebugStreamer) << "ScaleFactor"<<
+ (* fDebugStreamer) << "NormierungCharge"<<
"scalefactor="<<scalefactor<<
"\n";
}
//
//_____________________________________________________________________________
-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);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff