Index: trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.cc =================================================================== --- trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.cc (revision 2586) +++ trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.cc (revision 2599) @@ -69,22 +69,22 @@ // Create a large number of bins, later we will rebin - fBPQfirst = 0; - fBPQlast = gkStartBlindPixelBinNr; - fBPQnbins = gkStartBlindPixelBinNr; - - fHBPQ = new TH1I("HBPQ","Distribution of Summed FADC Slices",fBPQnbins,fBPQfirst,fBPQlast); - fHBPQ->SetXTitle("Sum FADC Slices"); - fHBPQ->SetYTitle("Nr. of events"); - fHBPQ->Sumw2(); - - fErrBPQfirst = 0.; - fErrBPQlast = gkStartBlindPixelBinNr; - fErrBPQnbins = gkStartBlindPixelBinNr; - - fHBPErrQ = new TH1F("HBPErrQ","Distribution of Variances of Summed FADC Slices", - fErrBPQnbins,fErrBPQfirst,fErrBPQlast); - fHBPErrQ->SetXTitle("Variance Summed FADC Slices"); - fHBPErrQ->SetYTitle("Nr. of events"); - fHBPErrQ->Sumw2(); + fBlindPixelQfirst = 0; + fBlindPixelQlast = gkStartBlindPixelBinNr; + fBlindPixelQnbins = gkStartBlindPixelBinNr; + + fHBlindPixelQ = new TH1I("HBlindPixelQ","Distribution of Summed FADC Slices",fBlindPixelQnbins,fBlindPixelQfirst,fBlindPixelQlast); + fHBlindPixelQ->SetXTitle("Sum FADC Slices"); + fHBlindPixelQ->SetYTitle("Nr. of events"); + fHBlindPixelQ->Sumw2(); + + fErrBlindPixelQfirst = 0.; + fErrBlindPixelQlast = gkStartBlindPixelBinNr; + fErrBlindPixelQnbins = gkStartBlindPixelBinNr; + + fHBlindPixelErrQ = new TH1F("HBlindPixelErrQ","Distribution of Variances of Summed FADC Slices", + fErrBlindPixelQnbins,fErrBlindPixelQfirst,fErrBlindPixelQlast); + fHBlindPixelErrQ->SetXTitle("Variance Summed FADC Slices"); + fHBlindPixelErrQ->SetYTitle("Nr. of events"); + fHBlindPixelErrQ->Sumw2(); Axis_t tfirst = -0.5; @@ -92,8 +92,8 @@ Int_t nbins = 16; - fHBPT = new TH1I("HBPT","Distribution of Mean Arrival Times",nbins,tfirst,tlast); - fHBPT->SetXTitle("Mean Arrival Times [FADC slice nr]"); - fHBPT->SetYTitle("Nr. of events"); - fHBPT->Sumw2(); + fHBlindPixelT = new TH1I("HBlindPixelT","Distribution of Mean Arrival Times",nbins,tfirst,tlast); + fHBlindPixelT->SetXTitle("Mean Arrival Times [FADC slice nr]"); + fHBlindPixelT->SetYTitle("Nr. of events"); + fHBlindPixelT->Sumw2(); // We define a reasonable number and later enlarge it if necessary @@ -102,7 +102,7 @@ Axis_t nlast = (Axis_t)nbins - 0.5; - fHBPQvsN = new TH1I("HBPQvsN","Sum of Charges vs. Event Number",nbins,nfirst,nlast); - fHBPQvsN->SetXTitle("Event Nr."); - fHBPQvsN->SetYTitle("Sum of FADC slices"); + fHBlindPixelQvsN = new TH1I("HBlindPixelQvsN","Sum of Charges vs. Event Number",nbins,nfirst,nlast); + fHBlindPixelQvsN->SetXTitle("Event Nr."); + fHBlindPixelQvsN->SetYTitle("Sum of FADC slices"); fgSinglePheFitFunc = &gfKto8; @@ -113,7 +113,7 @@ { - delete fHBPQ; - delete fHBPT; - delete fHBPErrQ; + delete fHBlindPixelQ; + delete fHBlindPixelT; + delete fHBlindPixelErrQ; if (fSinglePheFit) @@ -127,7 +127,7 @@ void MHCalibrationBlindPixel::ResetBin(Int_t i) { - fHBPQ->SetBinContent (i, 1.e-20); - fHBPErrQ->SetBinContent (i, 1.e-20); - fHBPT->SetBinContent(i, 1.e-20); + fHBlindPixelQ->SetBinContent (i, 1.e-20); + fHBlindPixelErrQ->SetBinContent (i, 1.e-20); + fHBlindPixelT->SetBinContent(i, 1.e-20); } @@ -209,5 +209,5 @@ gPad->SetTicks(); - fHBPQ->DrawCopy(opt); + fHBlindPixelQ->DrawCopy(opt); if (fSinglePheFit) @@ -231,9 +231,9 @@ gPad->SetLogy(1); gPad->SetBorderMode(0); - fHBPT->DrawCopy(opt); - - if (fHBPT->GetFunction("GausTime")) + fHBlindPixelT->DrawCopy(opt); + + if (fHBlindPixelT->GetFunction("GausTime")) { - TF1 *tfit = fHBPT->GetFunction("GausTime"); + TF1 *tfit = fHBlindPixelT->GetFunction("GausTime"); if (tfit->GetProb() < 0.01) tfit->SetLineColor(kRed); @@ -248,5 +248,5 @@ c->cd(4); - fHBPQvsN->DrawCopy(opt); + fHBlindPixelQvsN->DrawCopy(opt); c->Modified(); @@ -260,7 +260,7 @@ gRandom->SetSeed(); - if (fHBPQ->GetEntries() != 0) + if (fHBlindPixelQ->GetEntries() != 0) { - *fLog << err << "Histogram " << fHBPQ->GetTitle() << " is already filled. " << endl; + *fLog << err << "Histogram " << fHBlindPixelQ->GetTitle() << " is already filled. " << endl; *fLog << err << "Create new class MHCalibrationBlindPixel for simulation! " << endl; return kFALSE; @@ -268,13 +268,13 @@ TF1 *simulateSinglePhe = new TF1("simulateSinglePhe",fgSinglePheFitFunc, - fBPQfirst,fBPQlast,fgSinglePheFitNPar); + fBlindPixelQfirst,fBlindPixelQlast,fgSinglePheFitNPar); simulateSinglePhe->SetParameters(lambda,mu0,mu1,sigma0,sigma1); simulateSinglePhe->SetParNames("#lambda","#mu_0","#mu_1","#sigma_0","#sigma_1"); - simulateSinglePhe->SetNpx(fBPQnbins); + simulateSinglePhe->SetNpx(fBlindPixelQnbins); for (Int_t i=0;i<10000; i++) { - fHBPQ->Fill(simulateSinglePhe->GetRandom()); + fHBlindPixelQ->Fill(simulateSinglePhe->GetRandom()); } @@ -283,5 +283,5 @@ -void MHCalibrationBlindPixel::ChangeFitFunc(BPFitFunc fitfunc, Int_t par) +void MHCalibrationBlindPixel::ChangeFitFunc(BlindPixelFitFunc fitfunc, Int_t par) { @@ -303,6 +303,6 @@ // Get the fitting ranges // - rmin = (rmin != 0.) ? rmin : fBPQfirst; - rmax = (rmax != 0.) ? rmax : fBPQlast; + rmin = (rmin != 0.) ? rmin : fBlindPixelQfirst; + rmax = (rmax != 0.) ? rmax : fBlindPixelQlast; // @@ -310,9 +310,9 @@ // otherwise the fit goes gaga because of high number of dimensions ... // - const Stat_t entries = fHBPQ->GetSumOfWeights(); + const Stat_t entries = fHBlindPixelQ->GetSumOfWeights(); const Double_t lambda_guess = 0.2; - const Double_t mu_0_guess = fHBPQ->GetBinCenter(fHBPQ->GetMaximumBin()); - const Double_t si_0_guess = mu_0_guess/500.; - const Double_t mu_1_guess = mu_0_guess + 2.; + const Double_t mu_0_guess = fHBlindPixelQ->GetBinCenter(fHBlindPixelQ->GetMaximumBin()); + const Double_t si_0_guess = mu_0_guess/10.; + const Double_t mu_1_guess = mu_0_guess + 50.; const Double_t si_1_guess = si_0_guess + si_0_guess; @@ -325,5 +325,5 @@ fSinglePheFit->SetParLimits(3,1.0,rmax-rmin); fSinglePheFit->SetParLimits(4,1.7,rmax-rmin); - fSinglePheFit->SetParLimits(5,0.,2.*entries); + fSinglePheFit->SetParLimits(5,0.,2.5*entries); // // Normalize the histogram to facilitate faster fitting of the area @@ -333,5 +333,5 @@ // ROOT gives us another nice example of user-unfriendly behavior: // Although the normalization of the function fSinglePhe and the - // Histogram fHBPQ agree (!!), the fit does not normalize correctly INTERNALLY + // Histogram fHBlindPixelQ agree (!!), the fit does not normalize correctly INTERNALLY // in the fitting procedure !!! // @@ -342,7 +342,7 @@ // So, WE have to adapt to that internal flaw of ROOT: // - const Int_t npx = fSinglePheFit->GetNpx(); - const Int_t bins = fHBPQ->GetXaxis()->GetLast()-fHBPQ->GetXaxis()->GetFirst(); - // fHBPQ->Scale(gkSq2Pi*(float)bins/npx/entries); + // const Int_t npx = fSinglePheFit->GetNpx(); + // const Int_t bins = fHBlindPixelQ->GetXaxis()->GetLast()-fHBlindPixelQ->GetXaxis()->GetFirst(); + // fHBlindPixelQ->Scale(gkSq2Pi*(float)bins/npx/entries); // @@ -353,5 +353,5 @@ // fSinglePheFit->SetNpx(fQnbins); - fHBPQ->Fit("SinglePheFit",opt); + fHBlindPixelQ->Fit(fSinglePheFit,opt); fLambda = fSinglePheFit->GetParameter(0); @@ -403,18 +403,18 @@ // If you find another solution which WORKS!!, please tell me!! // - Int_t nbins = 100; - - *fLog << "New number of bins in HSinQ: " << CutEdges(fHBPQ,nbins) << endl; - - fBPQfirst = fHBPQ->GetBinLowEdge(fHBPQ->GetXaxis()->GetFirst()); - fBPQlast = fHBPQ->GetBinLowEdge(fHBPQ->GetXaxis()->GetLast())+fHBPQ->GetBinWidth(0); - fBPQnbins = nbins; - - *fLog << "New number of bins in HErrQ: " << CutEdges(fHBPErrQ,30) << endl; - fErrBPQfirst = fHBPErrQ->GetBinLowEdge(fHBPErrQ->GetXaxis()->GetFirst()); - fErrBPQlast = fHBPErrQ->GetBinLowEdge(fHBPErrQ->GetXaxis()->GetLast())+fHBPErrQ->GetBinWidth(0); - fErrBPQnbins = nbins; - - CutEdges(fHBPQvsN,0); + Int_t nbins = 50; + + *fLog << "New number of bins in HSinQ: " << CutEdges(fHBlindPixelQ,nbins) << endl; + + fBlindPixelQfirst = fHBlindPixelQ->GetBinLowEdge(fHBlindPixelQ->GetXaxis()->GetFirst()); + fBlindPixelQlast = fHBlindPixelQ->GetBinLowEdge(fHBlindPixelQ->GetXaxis()->GetLast())+fHBlindPixelQ->GetBinWidth(0); + fBlindPixelQnbins = nbins; + + *fLog << "New number of bins in HErrQ: " << CutEdges(fHBlindPixelErrQ,30) << endl; + fErrBlindPixelQfirst = fHBlindPixelErrQ->GetBinLowEdge(fHBlindPixelErrQ->GetXaxis()->GetFirst()); + fErrBlindPixelQlast = fHBlindPixelErrQ->GetBinLowEdge(fHBlindPixelErrQ->GetXaxis()->GetLast())+fHBlindPixelErrQ->GetBinWidth(0); + fErrBlindPixelQnbins = nbins; + + CutEdges(fHBlindPixelQvsN,0); } @@ -426,9 +426,9 @@ return kFALSE; - rmin = (rmin != 0.) ? rmin : 0.; - rmax = (rmax != 0.) ? rmax : 16.; - - const Stat_t entries = fHBPT->GetEntries(); - const Double_t mu_guess = fHBPT->GetBinCenter(fHBPT->GetMaximumBin()); + rmin = (rmin != 0.) ? rmin : 4.; + rmax = (rmax != 0.) ? rmax : 9.; + + const Stat_t entries = fHBlindPixelT->GetEntries(); + const Double_t mu_guess = fHBlindPixelT->GetBinCenter(fHBlindPixelT->GetMaximumBin()); const Double_t sigma_guess = (rmax - rmin)/2.; const Double_t area_guess = entries/gkSq2Pi; @@ -441,5 +441,12 @@ fTimeGausFit->SetParLimits(2,0.,rmax-rmin); - fHBPT->Fit("GausTime",opt); + fHBlindPixelT->Fit(fTimeGausFit,opt); + + rmin = fTimeGausFit->GetParameter(1) - 2.*fTimeGausFit->GetParameter(2); + rmax = fTimeGausFit->GetParameter(1) + 2.*fTimeGausFit->GetParameter(2); + fTimeGausFit->SetRange(rmin,rmax); + + fHBlindPixelT->Fit(fTimeGausFit,opt); + fMeanT = fTimeGausFit->GetParameter(2); Index: trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.h =================================================================== --- trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.h (revision 2586) +++ trunk/MagicSoft/Mars/mhist/MHCalibrationBlindPixel.h (revision 2599) @@ -32,19 +32,19 @@ private: - TH1I* fHBPQ; //-> Histogram with the single Phe spectrum - TH1F* fHBPErrQ; //-> Variance of summed FADC slices - TH1I* fHBPT; //-> Variance of summed FADC slices - TH1I* fHBPQvsN; //-> Summed Charge vs. Event Nr. + TH1I* fHBlindPixelQ; //-> Histogram with the single Phe spectrum + TH1F* fHBlindPixelErrQ; //-> Variance of summed FADC slices + TH1I* fHBlindPixelT; //-> Variance of summed FADC slices + TH1I* fHBlindPixelQvsN; //-> Summed Charge vs. Event Nr. TF1 *fSinglePheFit; TF1 *fTimeGausFit; - Axis_t fBPQfirst; - Axis_t fBPQlast; - Int_t fBPQnbins; + Axis_t fBlindPixelQfirst; + Axis_t fBlindPixelQlast; + Int_t fBlindPixelQnbins; - Axis_t fErrBPQfirst; - Axis_t fErrBPQlast; - Int_t fErrBPQnbins; + Axis_t fErrBlindPixelQfirst; + Axis_t fErrBlindPixelQlast; + Int_t fErrBlindPixelQnbins; void ResetBin(Int_t i); @@ -54,5 +54,5 @@ Bool_t fFitOK; - BPFitFunc fgSinglePheFitFunc; // In the beginning, + BlindPixelFitFunc fgSinglePheFitFunc; // In the beginning, Int_t fgSinglePheFitNPar; // we want to be flexible using different functions @@ -83,8 +83,8 @@ ~MHCalibrationBlindPixel(); - Bool_t FillBPQ(Int_t q) { return fHBPQ->Fill(q) > -1; } - Bool_t FillErrBPQ(Float_t errq) { return fHBPErrQ->Fill(errq) > -1; } - Bool_t FillBPT(Int_t t) { return fHBPT->Fill(t) > -1; } - Bool_t FillBPQvsN(Stat_t rq, Int_t t) { return fHBPQvsN->Fill(t,rq) > -1; } + Bool_t FillBlindPixelQ(Int_t q) { return fHBlindPixelQ->Fill(q) > -1; } + Bool_t FillErrBlindPixelQ(Float_t errq) { return fHBlindPixelErrQ->Fill(errq) > -1; } + Bool_t FillBlindPixelT(Int_t t) { return fHBlindPixelT->Fill(t) > -1; } + Bool_t FillBlindPixelQvsN(Stat_t rq, Int_t t) { return fHBlindPixelQvsN->Fill(t,rq) > -1; } const Double_t GetLambda() const { return fLambda; } @@ -109,6 +109,6 @@ const Double_t GetSigmaTErr() const { return fSigmaTErr; } - const TH1F *GetHErrQ() { return fHBPErrQ; } - const TH1F *GetHErrQ() const { return fHBPErrQ; } + const TH1F *GetHErrQ() { return fHBlindPixelErrQ; } + const TH1F *GetHErrQ() const { return fHBlindPixelErrQ; } Bool_t SimulateSinglePhe(Double_t lambda, @@ -121,5 +121,5 @@ Bool_t FitT(Axis_t rmin=0., Axis_t rmax=0.,Option_t *opt="R0+"); - void ChangeFitFunc(BPFitFunc fitfunc, Int_t par=5); + void ChangeFitFunc(BlindPixelFitFunc fitfunc, Int_t par=5); Index: trunk/MagicSoft/Mars/mhist/MHCalibrationConfig.h =================================================================== --- trunk/MagicSoft/Mars/mhist/MHCalibrationConfig.h (revision 2586) +++ trunk/MagicSoft/Mars/mhist/MHCalibrationConfig.h (revision 2599) @@ -12,5 +12,5 @@ // Global rejection criteria for the acceptance of a fit: Prob=0.01 == 99% Probability -const Float_t gkProbLimit = 0.01; +const Float_t gkProbLimit = 0.001; // Starting number of bins for the histo: @@ -30,5 +30,5 @@ // typedef to the fitting functions for the blind pixel -typedef Double_t (*BPFitFunc)(Double_t *, Double_t *); +typedef Double_t (*BlindPixelFitFunc)(Double_t *, Double_t *); #endif /* MARS_MHCalibrationBlindPixelConfig */ Index: trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.cc =================================================================== --- trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.cc (revision 2586) +++ trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.cc (revision 2599) @@ -60,11 +60,17 @@ // Default Constructor. // -MHCalibrationPixel::MHCalibrationPixel(Int_t pix, const char *name, const char *title) - : fPixId(pix), +MHCalibrationPixel::MHCalibrationPixel(const char *name, const char *title) + : fPixId(-1), fQGausFit(NULL), fTGausFit(NULL), fFitLegend(NULL), fLowerFitRange(0.), - fFitOK(kFALSE) + fFitOK(kFALSE), + fQChisquare(-1.), + fQProb(-1.), + fQNdf(-1), + fTChisquare(-1.), + fTProb(-1.), + fTNdf(-1) { @@ -72,8 +78,5 @@ fTitle = title ? title : "Fill the accumulated charges and times of all events and perform fits"; - TString qname = "HQ"; TString qtitle = "Distribution of Summed FADC Slices Pixel "; - qname += pix; - qtitle += pix; // Create a large number of bins, later we will rebin @@ -82,5 +85,5 @@ fQnbins = gkStartPixelBinNr; - fHQ = new TH1I( qname.Data(),qtitle.Data(), + fHQ = new TH1I("HQ",qtitle.Data(), fQnbins,fQfirst,fQlast); fHQ->SetXTitle("Sum FADC Slices"); @@ -88,8 +91,7 @@ fHQ->Sumw2(); - TString tname = "HT"; + fHQ->SetDirectory(NULL); + TString ttitle = "Distribution of Mean Arrival Times Pixel "; - tname += pix; - ttitle += pix; Axis_t tfirst = -0.5; @@ -97,5 +99,5 @@ Int_t nbins = 16; - fHT = new TH1I(tname.Data(),ttitle.Data(), + fHT = new TH1I("HT",ttitle.Data(), nbins,tfirst,tlast); fHT->SetXTitle("Mean Arrival Times [FADC slice nr]"); @@ -103,8 +105,7 @@ fHT->Sumw2(); - TString qvsnname = "HQvsN"; + fHT->SetDirectory(NULL); + TString qvsntitle = "Sum of Charges vs. Event Number Pixel "; - qvsnname += pix; - qvsntitle += pix; // We define a reasonable number and later enlarge it if necessary @@ -113,16 +114,10 @@ Axis_t nlast = (Axis_t)nbins - 0.5; - fHQvsN = new TH1I(qvsnname.Data(),qvsntitle.Data(), + fHQvsN = new TH1I("HQvsN",qvsntitle.Data(), nbins,nfirst,nlast); fHQvsN->SetXTitle("Event Nr."); fHQvsN->SetYTitle("Sum of FADC slices"); - fQChisquare = -1.; - fQProb = -1.; - fQNdf = -1; - - fTChisquare = -1.; - fTProb = -1.; - fTNdf = -1; + fHQvsN->SetDirectory(NULL); } @@ -144,4 +139,24 @@ } + +void MHCalibrationPixel::ChangeHistId(Int_t id) +{ + + fPixId = id; + + TString nameQ = TString(fHQ->GetName()); + nameQ += id; + fHQ->SetName(nameQ.Data()); + + TString nameT = TString(fHT->GetName()); + nameT += id; + fHT->SetName(nameT.Data()); + + TString nameQvsN = TString(fHQvsN->GetName()); + nameQvsN += id; + fHQvsN->SetName(nameQvsN.Data()); +} + + void MHCalibrationPixel::Reset() { @@ -206,5 +221,5 @@ char line8[32]; - sprintf(line8,"Probability: %4.2f ",fQProb); + sprintf(line8,"Probability: %4.3f ",fQProb); fFitLegend->AddText(line8); @@ -266,13 +281,12 @@ fHT->DrawCopy(opt); - if (fHT->GetFunction("GausTime")) + if (fTGausFit) { - TF1 *tfit = fHT->GetFunction("GausTime"); - if (tfit->GetProb() < 0.01) - tfit->SetLineColor(kRed); + if (fTChisquare > 1.) + fTGausFit->SetLineColor(kRed); else - tfit->SetLineColor(kGreen); - - tfit->DrawCopy("same"); + fTGausFit->SetLineColor(kGreen); + + fTGausFit->DrawCopy("same"); c->Modified(); c->Update(); @@ -290,10 +304,10 @@ Bool_t MHCalibrationPixel::FitT(Axis_t rmin, Axis_t rmax, Option_t *option) { - + if (fTGausFit) return kFALSE; - rmin = (rmin != 0.) ? rmin : -0.5; - rmax = (rmax != 0.) ? rmax : 15.5; + rmin = (rmin != 0.) ? rmin : 4.; + rmax = (rmax != 0.) ? rmax : 9.; const Stat_t entries = fHT->GetEntries(); @@ -302,5 +316,7 @@ const Double_t area_guess = entries/gkSq2Pi; - fTGausFit = new TF1("GausTime","gaus",rmin,rmax); + TString name = TString("GausTime"); + name += fPixId; + fTGausFit = new TF1(name.Data(),"gaus",rmin,rmax); if (!fTGausFit) @@ -314,7 +330,14 @@ fTGausFit->SetParLimits(0,0.,entries); fTGausFit->SetParLimits(1,rmin,rmax); - fTGausFit->SetParLimits(2,0.,rmax-rmin); - - fHT->Fit("GausTime",option); + fTGausFit->SetParLimits(2,0.,(rmax-rmin)/2.); + fTGausFit->SetRange(rmin,rmax); + + fHT->Fit(fTGausFit,option); + + rmin = fTGausFit->GetParameter(1) - 3.*fTGausFit->GetParameter(2); + rmax = fTGausFit->GetParameter(1) + 3.*fTGausFit->GetParameter(2); + fTGausFit->SetRange(rmin,rmax); + + fHT->Fit(fTGausFit,option); fTChisquare = fTGausFit->GetChisquare(); @@ -324,5 +347,5 @@ fTSigma = fTGausFit->GetParameter(2); - if (fTProb < gkProbLimit) + if (fTChisquare > 1.) { *fLog << warn << "Fit of the Arrival times failed ! " << endl; @@ -344,4 +367,5 @@ // Axis_t rmin = (fLowerFitRange != 0.) ? fLowerFitRange : fQfirst; + Axis_t rmax = 0.; // @@ -352,7 +376,10 @@ const Double_t ar_guess = entries/gkSq2Pi; const Double_t mu_guess = fHQ->GetBinCenter(fHQ->GetMaximumBin()); - const Double_t si_guess = mu_guess/500.; - - fQGausFit = new TF1("QGausFit","gaus",rmin,fQlast); + const Double_t si_guess = mu_guess/50.; + + TString name = TString("QGausFit"); + name += fPixId; + + fQGausFit = new TF1(name.Data(),"gaus",rmin,fQlast); if (!fQGausFit) @@ -367,6 +394,20 @@ fQGausFit->SetParLimits(1,rmin,fQlast); fQGausFit->SetParLimits(2,0.,fQlast-rmin); - - fHQ->Fit("QGausFit",option); + fQGausFit->SetRange(rmin,fQlast); + fQGausFit->Update(); + + fHQ->Fit(fQGausFit,option); + + rmin = fQGausFit->GetParameter(1) - 3.*fQGausFit->GetParameter(2); + rmax = fQGausFit->GetParameter(1) + 3.*fQGausFit->GetParameter(2); + + fQGausFit->SetRange(rmin,rmax); + fHQ->Fit(fQGausFit,option); + + rmin = fQGausFit->GetParameter(1) - 3.5*fQGausFit->GetParameter(2); + rmax = fQGausFit->GetParameter(1) + 3.5*fQGausFit->GetParameter(2); + + fQGausFit->SetRange(rmin,rmax); + fHQ->Fit(fQGausFit,option); fQChisquare = fQGausFit->GetChisquare(); @@ -399,10 +440,5 @@ { - // - // The number 100 is necessary because it is the internal binning - // of ROOT functions. A call to SetNpx() does NOT help - // If you find another solution which WORKS!!, please tell me!! - // - Int_t nbins = 100; + Int_t nbins = 50; CutEdges(fHQ,nbins); Index: trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.h =================================================================== --- trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.h (revision 2586) +++ trunk/MagicSoft/Mars/mhist/MHCalibrationPixel.h (revision 2599) @@ -68,6 +68,8 @@ public: - MHCalibrationPixel(Int_t pix=-1, const char *name=NULL, const char *title=NULL); + MHCalibrationPixel(const char *name=NULL, const char *title=NULL); ~MHCalibrationPixel(); + + void ChangeHistId(Int_t i); Bool_t SetupFill(const MParList *pList); @@ -105,6 +107,6 @@ const TH1I *GetHQvsN() const { return fHQvsN; } - Bool_t FitQ(Option_t *option="RQ0+"); - Bool_t FitT(Axis_t rmin=0, Axis_t rmax=0, Option_t *option="RQ0+"); + Bool_t FitQ(Option_t *option="RQ0"); + Bool_t FitT(Axis_t rmin=0, Axis_t rmax=0, Option_t *option="RQ0"); virtual void Draw(Option_t *option="");