Ignore:
Timestamp:
07/13/05 19:06:26 (19 years ago)
Author:
tbretz
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mcalib/MCalibrationIntensityChargeCam.cc

    r6412 r7188  
    594594          varerr[i] = pix.GetRSigmaErr();
    595595        }
    596       if (option.Contains("abstime"))
     596      if (option.Contains("abstimemean"))
    597597        {
    598598          var   [i] = pix.GetAbsTimeMean();
    599599          varerr[i] = pix.GetAbsTimeRms();
    600600        }
     601      if (option.Contains("abstimerms"))
     602        {
     603          var   [i] = pix.GetAbsTimeRms();
     604          varerr[i] = pix.GetAbsTimeRms()/2.;
     605        }
    601606      if (option.Contains("blackout"))
    602607        {
    … …  
    663668          var   [i] = pix.GetRSigmaPerCharge();
    664669          varerr[i] = pix.GetRSigmaPerChargeErr();
     670        }
     671      if (option.Contains("conversionfactor"))
     672        {
     673          const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(0);
     674          const Float_t mean = pix.GetConvertedMean();
     675          const Float_t phe  = apix.GetPheFFactorMethod();
     676
     677          var[i]    = phe/mean;
     678          varerr[i] = TMath::Sqrt(apix.GetPheFFactorMethodErr()*apix.GetPheFFactorMethodErr()/mean/mean
     679                                  + phe*phe/mean/mean/mean/mean*pix.GetConvertedMeanErr()*pix.GetConvertedMeanErr());
    665680        }
    666681  }
    … …  
    735750         
    736751          if (option.Contains("rsigma"))
     752              pvar = pix.GetRSigma();
     753          if (option.Contains("abstimemean"))
     754              pvar = pix.GetAbsTimeMean();
     755          if (option.Contains("abstimerms"))
     756              pvar = pix.GetAbsTimeRms();
     757          if (option.Contains("conversionhilo"))
     758              pvar = pix.GetConversionHiLo();
     759          if (option.Contains("convertedmean"))
     760              pvar = pix.GetConvertedMean();
     761          if (option.Contains("convertedsigma"))
     762              pvar = pix.GetConvertedSigma();
     763          if (option.Contains("convertedrsigma"))
     764              pvar = pix.GetConvertedRSigma();
     765          if (option.Contains("meanconvfadc2phe"))
     766              pvar = pix.GetMeanConvFADC2Phe();
     767          if (option.Contains("meanffactorfadc2phot"))
     768              pvar = pix.GetMeanFFactorFADC2Phot();
     769          if (option.Contains("ped"))
     770              pvar = pix.GetPed();
     771          if (option.Contains("pedrms"))
     772              pvar = pix.GetPedRms();
     773          if (option.Contains("pheffactormethod"))
     774              pvar = pix.GetPheFFactorMethod();
     775          if (option.Contains("rsigmapercharge"))
     776              pvar = pix.GetRSigmaPerCharge();
     777          if (option.Contains("conversionfactor"))
     778          {
     779              const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(aidx);
     780              pvar = apix.GetPheFFactorMethod()/pix.GetConvertedMean();
     781          }
     782
     783
     784          variab  += pvar;
     785          variab2 += pvar*pvar;
     786          num++;
     787         
     788          camcharge.Fill(j,pvar);
     789          camcharge.SetUsed(j);
     790        }
     791     
     792      if (num > 1)
     793        {
     794          variab  /= num;
     795          variance = (variab2 - variab*variab*num) / (num-1);
     796
     797          vararea[i]    = variab;
     798          varareaerr[i] = variance>0 ? TMath::Sqrt(variance/num) : 999999999.;
     799
     800          //
     801          // Make also a Gauss-fit to the distributions. The RMS can be determined by
     802          // outlier, thus we look at the sigma and the RMS and take the smaller one, afterwards.
     803          //
     804          h = camcharge.ProjectionS(TArrayI(),TArrayI(1,&aidx),"_py",750);
     805          h->SetDirectory(NULL);
     806          h->Fit("gaus","QL");
     807          TF1 *fit = h->GetFunction("gaus");
     808
     809          Float_t ci2   = fit->GetChisquare();
     810          Float_t sigma = fit->GetParameter(2);
     811
     812          if (ci2 > 500. || sigma > varareaerr[i])
     813            {
     814              h->Fit("gaus","QLM");
     815              fit = h->GetFunction("gaus");
     816
     817              ci2   = fit->GetChisquare();
     818              sigma = fit->GetParameter(2);
     819            }
     820         
     821          const Float_t mean  = fit->GetParameter(1);
     822          const Float_t ndf   = fit->GetNDF();
     823         
     824          *fLog << inf << "Camera Nr: " << i << endl;
     825          *fLog << inf << option.Data() << " area idx: " << aidx << " Results: " << endl;
     826          *fLog << inf << "Mean: " << Form("%4.3f",mean)
     827                << "+-" << Form("%4.3f",fit->GetParError(1))
     828                << "  Sigma: " << Form("%4.3f",sigma) << "+-" << Form("%4.3f",fit->GetParError(2))
     829                << "  Chisquare: " << Form("%4.3f",ci2) << "  NDF  : " << ndf << endl;
     830          delete h;
     831          gROOT->GetListOfFunctions()->Remove(fit);
     832
     833          if (sigma<varareaerr[i] && ndf>2 && ci2<500.)
     834            {
     835              vararea   [i] = mean;
     836              varareaerr[i] = sigma/TMath::Sqrt((Float_t)num);
     837            }
     838        }
     839      else
     840        {
     841          vararea[i]    = -1.;
     842          varareaerr[i] = 0.;
     843        }
     844
     845      nr[i] = i;
     846      nrerr[i] = 0.;
     847    }
     848 
     849  TGraphErrors *gr = new TGraphErrors(size,
     850                                     nr.GetArray(),vararea.GetArray(),
     851                                     nrerr.GetArray(),varareaerr.GetArray());
     852  gr->SetTitle(Form("%s Area %3i Average",option.Data(),aidx));
     853  gr->GetXaxis()->SetTitle("Camera Nr.");
     854  //  gr->GetYaxis()->SetTitle("<Q> [1]");     
     855  return gr;
     856}
     857
     858
     859// -------------------------------------------------------------------
     860//
     861// Returns a TGraphErrors with the mean effective number of photon
     862// vs. the calibration camera number. With the string 'method', different
     863// calibration methods can be called.
     864//
     865TGraphErrors *MCalibrationIntensityChargeCam::GetPhotVsTime( const Option_t *method )
     866{
     867 
     868  const Int_t size = GetSize();
     869 
     870  if (size == 0)
     871    return NULL;
     872
     873  TString option(method);
     874
     875  TArrayF photarr(size);
     876  TArrayF photarrerr(size);
     877  TArrayF nr(size);
     878  TArrayF nrerr(size);
     879 
     880  for (Int_t i=0;i<GetSize();i++)
     881    {
     882      //
     883      // Get the calibration cam from the intensity cam
     884      //
     885      MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
     886
     887      //
     888      // Get the calibration pix from the calibration cam
     889      //
     890      Float_t phot    = 0.;
     891      Float_t photerr = 0.;
     892
     893      if (option.Contains("BlindPixel"))
     894        {
     895          phot    = cam->GetNumPhotonsBlindPixelMethod();
     896          photerr = cam->GetNumPhotonsBlindPixelMethodErr();
     897        }
     898      if (option.Contains("FFactor"))
     899        {
     900          phot    = cam->GetNumPhotonsFFactorMethod();
     901          photerr = cam->GetNumPhotonsFFactorMethodErr();
     902        }
     903      if (option.Contains("PINDiode"))
     904        {
     905          phot    = cam->GetNumPhotonsPINDiodeMethod();
     906          photerr = cam->GetNumPhotonsPINDiodeMethodErr();
     907        }
     908
     909      photarr[i]       = phot;
     910      photarrerr[i]    = photerr;
     911
     912      nr[i] = i;
     913      nrerr[i] = 0.;
     914    }
     915 
     916  TGraphErrors *gr = new TGraphErrors(size,
     917                                     nr.GetArray(),photarr.GetArray(),
     918                                     nrerr.GetArray(),photarrerr.GetArray());
     919  gr->SetTitle("Photons Average");
     920  gr->GetXaxis()->SetTitle("Camera Nr.");
     921  gr->GetYaxis()->SetTitle("<N_{phot}> [1]");
     922  return gr;
     923}
     924
     925// -------------------------------------------------------------------
     926//
     927// Returns a TGraphErrors with the mean effective number of photo-electrons per
     928// area index 'aidx' vs. the calibration camera number
     929//
     930TGraphErrors *MCalibrationIntensityChargeCam::GetPhePerAreaVsTime( const Int_t aidx, const MGeomCam &geom)
     931{
     932 
     933  const Int_t size = GetSize();
     934 
     935  if (size == 0)
     936    return NULL;
     937 
     938  TArrayF phearea(size);
     939  TArrayF pheareaerr(size);
     940  TArrayF time(size);
     941  TArrayF timeerr(size);
     942 
     943  for (Int_t i=0;i<GetSize();i++)
     944    {
     945      //
     946      // Get the calibration cam from the intensity cam
     947      //
     948      MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
     949
     950      //
     951      // Get the calibration pix from the calibration cam
     952      //
     953      const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(aidx);
     954      const Float_t phe          = apix.GetPheFFactorMethod();
     955      const Float_t pheerr       = apix.GetPheFFactorMethodErr();
     956
     957      phearea[i]       = phe;
     958      pheareaerr[i]    = pheerr;
     959
     960      time[i] = i;
     961      timeerr[i] = 0.;
     962    }
     963 
     964  TGraphErrors *gr = new TGraphErrors(size,
     965                                     time.GetArray(),phearea.GetArray(),
     966                                     timeerr.GetArray(),pheareaerr.GetArray());
     967  gr->SetTitle(Form("Phes Area %d Average",aidx));
     968  gr->GetXaxis()->SetTitle("Camera Nr.");
     969  gr->GetYaxis()->SetTitle("<N_{phe}> [1]");
     970  return gr;
     971}
     972
     973// -------------------------------------------------------------------
     974//
     975// Returns a TGraphErrors with the event-by-event averaged charge per
     976// area index 'aidx' vs. the calibration camera number
     977//
     978TGraphErrors *MCalibrationIntensityChargeCam::GetChargePerAreaVsTime( const Int_t aidx, const MGeomCam &geom)
     979{
     980 
     981  const Int_t size = GetSize();
     982 
     983  if (size == 0)
     984    return NULL;
     985 
     986  TArrayF chargearea(size);
     987  TArrayF chargeareaerr(size);
     988  TArrayF nr(size);
     989  TArrayF nrerr(size);
     990 
     991  for (Int_t i=0;i<GetSize();i++)
     992    {
     993      //
     994      // Get the calibration cam from the intensity cam
     995      //
     996      MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
     997
     998      //
     999      // Get the calibration pix from the calibration cam
     1000      //
     1001      const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(aidx);
     1002      const Float_t charge          = apix.GetConvertedMean();
     1003      const Float_t chargeerr       = apix.GetConvertedSigma();
     1004
     1005      chargearea[i]       = charge;
     1006      chargeareaerr[i]    = chargeerr;
     1007
     1008      nr[i]    = i;
     1009      nrerr[i] = 0.;
     1010    }
     1011 
     1012  TGraphErrors *gr = new TGraphErrors(size,
     1013                                     nr.GetArray(),chargearea.GetArray(),
     1014                                     nrerr.GetArray(),chargeareaerr.GetArray());
     1015  gr->SetTitle(Form("Averaged Charges Area Idx %d",aidx));
     1016  gr->GetXaxis()->SetTitle("Camera Nr.");
     1017  gr->GetYaxis()->SetTitle("<Q> [FADC cnts]");     
     1018  return gr;
     1019}
     1020
     1021TH1F *MCalibrationIntensityChargeCam::GetVarFluctuations( const Int_t aidx, const MGeomCam &geom, const Option_t *varname )
     1022{
     1023 
     1024  const Int_t size = GetSize();
     1025 
     1026  if (size == 0)
     1027    return NULL;
     1028 
     1029  TString option(varname);
     1030  option.ToLower();
     1031 
     1032  TH1F *hist = new TH1F("hist",Form("%s - Rel. Fluctuations %s Pixel",option.Data(),aidx ? "Outer" : "Inner"),
     1033                        200,0.,100.);
     1034  hist->SetXTitle("Relative Fluctuation [%]");
     1035  hist->SetYTitle("Nr. channels [1]"); 
     1036  hist->SetFillColor(kRed+aidx);
     1037
     1038  MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam();
     1039
     1040  //
     1041  // Loop over pixels
     1042  //
     1043  for (Int_t npix=0;npix<cam->GetSize();npix++)
     1044    {
     1045      if (geom[npix].GetAidx() != aidx)
     1046        continue;
     1047
     1048      Double_t variab   = 0.;
     1049      Double_t variab2  = 0.;
     1050      Double_t variance = 0.;
     1051      Int_t    num      = 0;
     1052      Float_t  pvar     = 0.;
     1053      Float_t  relrms   = 99.9;
     1054      //
     1055      // Loop over the Cams for each pixel
     1056      //
     1057      for (Int_t i=0; i<GetSize(); i++)
     1058        {
     1059          MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
     1060          //
     1061          // Get the calibration pix from the calibration cam
     1062          //
     1063          MCalibrationChargePix &pix = (MCalibrationChargePix&)(*cam)[npix];
     1064          //
     1065          // Don't use bad pixels
     1066          //
     1067          if (!pix.IsFFactorMethodValid())
     1068            continue;
     1069
     1070          if (option.Contains("rsigma"))
    7371071            pvar = pix.GetRSigma();
    738           if (option.Contains("abstime"))
     1072          if (option.Contains("abstimemean"))
    7391073            pvar = pix.GetAbsTimeMean();
     1074          if (option.Contains("abstimerms"))
     1075            pvar = pix.GetAbsTimeRms();
    7401076          if (option.Contains("conversionhilo"))
    7411077            pvar = pix.GetConversionHiLo();
    … …  
    7581094          if (option.Contains("rsigmapercharge"))
    7591095            pvar = pix.GetRSigmaPerCharge();
     1096          if (option.Contains("conversionfactor"))
     1097          {
     1098              const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(0);
     1099              pvar = apix.GetPheFFactorMethod()/pix.GetConvertedMean();
     1100          }
     1101
    7601102
    7611103          variab  += pvar;
    7621104          variab2 += pvar*pvar;
    7631105          num++;
    764          
    765           camcharge.Fill(j,pvar);
    766           camcharge.SetUsed(j);
    767         }
    768      
    769       if (num > 1)
    770         {
    771           variab  /= num;
    772           variance = (variab2 - variab*variab*num) / (num-1);
    773 
    774           vararea[i] = variab;
    775           if (variance > 0.)
    776             varareaerr[i] = TMath::Sqrt(variance);
    777           else
    778             varareaerr[i] = 999999999.;
    779 
    780           //
    781           // Make also a Gauss-fit to the distributions. The RMS can be determined by
    782           // outlier, thus we look at the sigma and the RMS and take the smaller one, afterwards.
    783           //
    784           h = camcharge.ProjectionS(TArrayI(),TArrayI(1,&aidx),"_py",750);
    785           h->SetDirectory(NULL);
    786           h->Fit("gaus","QL");
    787           TF1 *fit = h->GetFunction("gaus");
    788 
    789           Float_t ci2   = fit->GetChisquare();
    790           Float_t sigma = fit->GetParameter(2);
    791 
    792           if (ci2 > 500. || sigma > varareaerr[i])
    793             {
    794               h->Fit("gaus","QLM");
    795               fit = h->GetFunction("gaus");
    796 
    797               ci2   = fit->GetChisquare();
    798               sigma = fit->GetParameter(2);
    799             }
    800          
    801           const Float_t mean  = fit->GetParameter(1);
    802           const Float_t ndf   = fit->GetNDF();
    803          
    804           *fLog << inf << "Camera Nr: " << i << endl;
    805           *fLog << inf << option.Data() << " area idx: " << aidx << " Results: " << endl;
    806           *fLog << inf << "Mean: " << Form("%4.3f",mean)
    807                 << "+-" << Form("%4.3f",fit->GetParError(1))
    808                 << "  Sigma: " << Form("%4.3f",sigma) << "+-" << Form("%4.3f",fit->GetParError(2))
    809                 << "  Chisquare: " << Form("%4.3f",fit->GetChisquare()) << "  NDF  : " << ndf << endl;         
    810           delete h;
    811           gROOT->GetListOfFunctions()->Remove(fit);
    812 
    813           if (sigma < varareaerr[i] && ndf > 2)
    814             {
    815               vararea   [i] = mean;
    816               varareaerr[i] = sigma;
    817             }
    818         }
    819       else
    820         {
    821           vararea[i]    = -1.;
    822           varareaerr[i] = 0.;
    823         }
    824 
    825       nr[i] = i;
    826       nrerr[i] = 0.;
    827     }
    828  
    829   TGraphErrors *gr = new TGraphErrors(size,
    830                                      nr.GetArray(),vararea.GetArray(),
    831                                      nrerr.GetArray(),varareaerr.GetArray());
    832   gr->SetTitle(Form("%s Area %3i Average",option.Data(),aidx));
    833   gr->GetXaxis()->SetTitle("Camera Nr.");
    834   //  gr->GetYaxis()->SetTitle("<Q> [1]");     
    835   return gr;
    836 }
    837 
    838 
    839 // -------------------------------------------------------------------
    840 //
    841 // Returns a TGraphErrors with the mean effective number of photon
    842 // vs. the calibration camera number. With the string 'method', different
    843 // calibration methods can be called.
    844 //
    845 TGraphErrors *MCalibrationIntensityChargeCam::GetPhotVsTime( const Option_t *method )
    846 {
    847  
    848   const Int_t size = GetSize();
    849  
    850   if (size == 0)
    851     return NULL;
    852 
    853   TString option(method);
    854 
    855   TArrayF photarr(size);
    856   TArrayF photarrerr(size);
    857   TArrayF nr(size);
    858   TArrayF nrerr(size);
    859  
    860   for (Int_t i=0;i<GetSize();i++)
    861     {
    862       //
    863       // Get the calibration cam from the intensity cam
    864       //
    865       MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
    866 
    867       //
    868       // Get the calibration pix from the calibration cam
    869       //
    870       Float_t phot    = 0.;
    871       Float_t photerr = 0.;
    872 
    873       if (option.Contains("BlindPixel"))
    874         {
    875           phot    = cam->GetNumPhotonsBlindPixelMethod();
    876           photerr = cam->GetNumPhotonsBlindPixelMethodErr();
    877         }
    878       if (option.Contains("FFactor"))
    879         {
    880           phot    = cam->GetNumPhotonsFFactorMethod();
    881           photerr = cam->GetNumPhotonsFFactorMethodErr();
    882         }
    883       if (option.Contains("PINDiode"))
    884         {
    885           phot    = cam->GetNumPhotonsPINDiodeMethod();
    886           photerr = cam->GetNumPhotonsPINDiodeMethodErr();
    887         }
    888 
    889       photarr[i]       = phot;
    890       photarrerr[i]    = photerr;
    891 
    892       nr[i] = i;
    893       nrerr[i] = 0.;
    894     }
    895  
    896   TGraphErrors *gr = new TGraphErrors(size,
    897                                      nr.GetArray(),photarr.GetArray(),
    898                                      nrerr.GetArray(),photarrerr.GetArray());
    899   gr->SetTitle("Photons Average");
    900   gr->GetXaxis()->SetTitle("Camera Nr.");
    901   gr->GetYaxis()->SetTitle("<N_phot> [1]");     
    902   return gr;
    903 }
    904 
    905 // -------------------------------------------------------------------
    906 //
    907 // Returns a TGraphErrors with the mean effective number of photo-electrons per
    908 // area index 'aidx' vs. the calibration camera number
    909 //
    910 TGraphErrors *MCalibrationIntensityChargeCam::GetPhePerAreaVsTime( const Int_t aidx, const MGeomCam &geom)
    911 {
    912  
    913   const Int_t size = GetSize();
    914  
    915   if (size == 0)
    916     return NULL;
    917  
    918   TArrayF phearea(size);
    919   TArrayF pheareaerr(size);
    920   TArrayF time(size);
    921   TArrayF timeerr(size);
    922  
    923   for (Int_t i=0;i<GetSize();i++)
    924     {
    925       //
    926       // Get the calibration cam from the intensity cam
    927       //
    928       MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
    929 
    930       //
    931       // Get the calibration pix from the calibration cam
    932       //
    933       const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(aidx);
    934       const Float_t phe          = apix.GetPheFFactorMethod();
    935       const Float_t pheerr       = apix.GetPheFFactorMethodErr();
    936 
    937       phearea[i]       = phe;
    938       pheareaerr[i]    = pheerr;
    939 
    940       time[i] = i;
    941       timeerr[i] = 0.;
    942     }
    943  
    944   TGraphErrors *gr = new TGraphErrors(size,
    945                                      time.GetArray(),phearea.GetArray(),
    946                                      timeerr.GetArray(),pheareaerr.GetArray());
    947   gr->SetTitle(Form("Phes Area %d Average",aidx));
    948   gr->GetXaxis()->SetTitle("Camera Nr.");
    949   gr->GetYaxis()->SetTitle("<N_phes> [1]");     
    950   return gr;
    951 }
    952 
    953 // -------------------------------------------------------------------
    954 //
    955 // Returns a TGraphErrors with the event-by-event averaged charge per
    956 // area index 'aidx' vs. the calibration camera number
    957 //
    958 TGraphErrors *MCalibrationIntensityChargeCam::GetChargePerAreaVsTime( const Int_t aidx, const MGeomCam &geom)
    959 {
    960  
    961   const Int_t size = GetSize();
    962  
    963   if (size == 0)
    964     return NULL;
    965  
    966   TArrayF chargearea(size);
    967   TArrayF chargeareaerr(size);
    968   TArrayF nr(size);
    969   TArrayF nrerr(size);
    970  
    971   for (Int_t i=0;i<GetSize();i++)
    972     {
    973       //
    974       // Get the calibration cam from the intensity cam
    975       //
    976       MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
    977 
    978       //
    979       // Get the calibration pix from the calibration cam
    980       //
    981       const MCalibrationChargePix &apix = (MCalibrationChargePix&)cam->GetAverageArea(aidx);
    982       const Float_t charge          = apix.GetConvertedMean();
    983       const Float_t chargeerr       = apix.GetConvertedSigma();
    984 
    985       chargearea[i]       = charge;
    986       chargeareaerr[i]    = chargeerr;
    987 
    988       nr[i]    = i;
    989       nrerr[i] = 0.;
    990     }
    991  
    992   TGraphErrors *gr = new TGraphErrors(size,
    993                                      nr.GetArray(),chargearea.GetArray(),
    994                                      nrerr.GetArray(),chargeareaerr.GetArray());
    995   gr->SetTitle(Form("Averaged Charges Area Idx %d",aidx));
    996   gr->GetXaxis()->SetTitle("Camera Nr.");
    997   gr->GetYaxis()->SetTitle("<Q> [FADC cnts]");     
    998   return gr;
    999 }
    1000 
    1001 TH1F *MCalibrationIntensityChargeCam::GetVarFluctuations( const Int_t aidx, const MGeomCam &geom, const Option_t *varname )
    1002 {
    1003  
    1004   const Int_t size = GetSize();
    1005  
    1006   if (size == 0)
    1007     return NULL;
    1008  
    1009   TString option(varname);
    1010  
    1011   TH1F *hist = new TH1F("hist",Form("%s - Rel. Fluctuations %s Pixel",option.Data(),aidx ? "Outer" : "Inner"),
    1012                         200,0.,100.);
    1013   hist->SetXTitle("Relative Fluctuation [%]");
    1014   hist->SetYTitle("Nr. channels [1]"); 
    1015   hist->SetFillColor(kRed+aidx);
    1016 
    1017   MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam();
    1018 
    1019   //
    1020   // Loop over pixels
    1021   //
    1022   for (Int_t npix=0;npix<cam->GetSize();npix++)
    1023     {
    1024       if (geom[npix].GetAidx() != aidx)
    1025         continue;
    1026 
    1027       Double_t variab   = 0.;
    1028       Double_t variab2  = 0.;
    1029       Double_t variance = 0.;
    1030       Int_t    num      = 0;
    1031       Float_t  pvar     = 0.;
    1032       Float_t  relrms   = 99.9;
    1033       //
    1034       // Loop over the Cams for each pixel
    1035       //
    1036       for (Int_t i=0; i<GetSize(); i++)
    1037         {
    1038           MCalibrationChargeCam *cam = (MCalibrationChargeCam*)GetCam(i);
    1039           //
    1040           // Get the calibration pix from the calibration cam
    1041           //
    1042           MCalibrationChargePix &pix = (MCalibrationChargePix&)(*cam)[npix];
    1043           //
    1044           // Don't use bad pixels
    1045           //
    1046           if (!pix.IsFFactorMethodValid())
    1047             continue;
    1048 
    1049           if (option.Contains("RSigma"))
    1050             pvar = pix.GetRSigma();
    1051           if (option.Contains("AbsTime"))
    1052             pvar = pix.GetAbsTimeMean();
    1053           if (option.Contains("ConversionHiLo"))
    1054             pvar = pix.GetConversionHiLo();
    1055           if (option.Contains("ConvertedMean"))
    1056             pvar = pix.GetConvertedMean();
    1057           if (option.Contains("ConvertedSigma"))
    1058             pvar = pix.GetConvertedSigma();
    1059           if (option.Contains("ConvertedRSigma"))
    1060             pvar = pix.GetConvertedRSigma();
    1061           if (option.Contains("MeanConvFADC2Phe"))
    1062             pvar = pix.GetMeanConvFADC2Phe();
    1063           if (option.Contains("MeanFFactorFADC2Phot"))
    1064             pvar = pix.GetMeanFFactorFADC2Phot();
    1065           if (option.Contains("Ped"))
    1066             pvar = pix.GetPed();
    1067           if (option.Contains("PedRms"))
    1068             pvar = pix.GetPedRms();
    1069           if (option.Contains("PheFFactorMethod"))
    1070             pvar = pix.GetPheFFactorMethod();
    1071           if (option.Contains("RSigmaPerCharge"))
    1072             pvar = pix.GetRSigmaPerCharge();
    1073 
    1074           variab  += pvar;
    1075           variab2 += pvar*pvar;
    1076           num++;
    10771106        }
    10781107
Note: See TracChangeset for help on using the changeset viewer.