Changeset 3564 for trunk/MagicSoft/Mars


Ignore:
Timestamp:
03/20/04 00:12:47 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3563 r3564  
    3737     - fixed GetPixelContent flags
    3838     - introduced RadialProfile for some displays
     39     - removed some not so important displays
    3940
    4041   * manalysis/MGeomApply.cc

  • trunk/MagicSoft/Mars/mjobs/MJCalibration.cc

    r3524 r3564  
    3636#include <TCanvas.h>
    3737#include <TSystem.h>
     38#include <TProfile.h>
    3839
    3940#include "MLog.h"
    … …  
    7980}
    8081
    81 void MJCalibration::DrawProjection(MHCamera *obj1, Int_t fit) const
    82 {
    83     TH1D *obj2 = (TH1D*)obj1->Projection(obj1->GetName());
    84     obj2->SetDirectory(0);
    85     obj2->Draw();
    86     obj2->SetBit(kCanDelete);
    87 
    88     if (obj1->GetGeomCam().InheritsFrom("MGeomCamMagic"))
    89     {
    90         TArrayI s0(3);
    91         s0[0] = 6;
    92         s0[1] = 1;
    93         s0[2] = 2;
    94 
    95         TArrayI s1(3);
    96         s1[0] = 3;
    97         s1[1] = 4;
    98         s1[2] = 5;
    99 
    100         TArrayI inner(1);
    101         inner[0] = 0;
    102 
    103         TArrayI outer(1);
    104         outer[0] = 1;
    105 
    106         // Just to get the right (maximum) binning
    107         TH1D *half[4];
    108         half[0] = obj1->ProjectionS(s0, inner, "Sector 6-1-2 Inner");
    109         half[1] = obj1->ProjectionS(s1, inner, "Sector 3-4-5 Inner");
    110         half[2] = obj1->ProjectionS(s0, outer, "Sector 6-1-2 Outer");
    111         half[3] = obj1->ProjectionS(s1, outer, "Sector 3-4-5 Outer");
    112 
    113         for (int i=0; i<4; i++)
     82void MJCalibration::DrawProjection(MHCamera *obj, Int_t fit) const
     83{
     84 
     85  TH1D *obj2 = (TH1D*)obj->Projection(obj->GetName());
     86  obj2->SetDirectory(0);
     87  obj2->Draw();
     88  obj2->SetBit(kCanDelete);
     89 
     90  if (obj->GetGeomCam().InheritsFrom("MGeomCamMagic"))
     91    {
     92      TArrayI s0(3);
     93      s0[0] = 6;
     94      s0[1] = 1;
     95      s0[2] = 2;
     96     
     97      TArrayI s1(3);
     98      s1[0] = 3;
     99      s1[1] = 4;
     100      s1[2] = 5;
     101     
     102      TArrayI inner(1);
     103      inner[0] = 0;
     104     
     105      TArrayI outer(1);
     106      outer[0] = 1;
     107     
     108      // Just to get the right (maximum) binning
     109      TH1D *half[4];
     110      half[0] = obj->ProjectionS(s0, inner, "Sector 6-1-2 Inner");
     111      half[1] = obj->ProjectionS(s1, inner, "Sector 3-4-5 Inner");
     112      half[2] = obj->ProjectionS(s0, outer, "Sector 6-1-2 Outer");
     113      half[3] = obj->ProjectionS(s1, outer, "Sector 3-4-5 Outer");
     114     
     115      for (int i=0; i<4; i++)
    114116        {
    115             half[i]->SetLineColor(kRed+i);
    116             half[i]->SetDirectory(0);
    117             half[i]->SetBit(kCanDelete);
    118             half[i]->Draw("same");
     117          half[i]->SetLineColor(kRed+i);
     118          half[i]->SetDirectory(0);
     119          half[i]->SetBit(kCanDelete);
     120          half[i]->Draw("same");
    119121        }
    120122    }
    121 
    122     const Double_t min   = obj2->GetBinCenter(obj2->GetXaxis()->GetFirst());
    123     const Double_t max   = obj2->GetBinCenter(obj2->GetXaxis()->GetLast());
    124     const Double_t integ = obj2->Integral("width")/2.5;
    125     const Double_t mean  = obj2->GetMean();
    126     const Double_t rms   = obj2->GetRMS();
    127     const Double_t width = max-min;
    128 
    129     const TString dgausformula = "([0]-[3])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])"
    130         "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])";
    131 
    132     const TString tgausformula = "([0]-[3]-[6])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])"
    133         "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])"
    134         "+[6]/[8]*exp(-0.5*(x-[7])*(x-[7])/[8]/[8])";
    135     TF1 *f=0;
    136     switch (fit)
     123 
     124  const Double_t min   = obj2->GetBinCenter(obj2->GetXaxis()->GetFirst());
     125  const Double_t max   = obj2->GetBinCenter(obj2->GetXaxis()->GetLast());
     126  const Double_t integ = obj2->Integral("width")/2.5;
     127  const Double_t mean  = obj2->GetMean();
     128  const Double_t rms   = obj2->GetRMS();
     129  const Double_t width = max-min;
     130 
     131  const TString dgausformula = "([0]-[3])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])"
     132    "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])";
     133 
     134  const TString tgausformula = "([0]-[3]-[6])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])"
     135    "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])"
     136    "+[6]/[8]*exp(-0.5*(x-[7])*(x-[7])/[8]/[8])";
     137  TF1 *f=0;
     138  switch (fit)
    137139    {
    138140    case 1:
    139         f = new TF1("sgaus", "gaus(0)", min, max);
    140         f->SetLineColor(kYellow);
    141         f->SetBit(kCanDelete);
    142         f->SetParNames("Area", "#mu", "#sigma");
    143         f->SetParameters(integ/rms, mean, rms);
    144         f->SetParLimits(0, 0,   integ);
    145         f->SetParLimits(1, min, max);
    146         f->SetParLimits(2, 0,   width/1.5);
    147 
    148         obj2->Fit(f, "QLR");
    149         break;
    150 
     141      f = new TF1("sgaus", "gaus(0)", min, max);
     142      f->SetLineColor(kYellow);
     143      f->SetBit(kCanDelete);
     144      f->SetParNames("Area", "#mu", "#sigma");
     145      f->SetParameters(integ/rms, mean, rms);
     146      f->SetParLimits(0, 0,   integ);
     147      f->SetParLimits(1, min, max);
     148      f->SetParLimits(2, 0,   width/1.5);
     149     
     150      obj2->Fit(f, "QLR");
     151      break;
     152     
    151153    case 2:
    152         f = new TF1("dgaus",dgausformula.Data(),min,max);
    153         f->SetLineColor(kYellow);
    154         f->SetBit(kCanDelete);
    155         f->SetParNames("A_{tot}", "#mu1", "#sigma1", "A2", "#mu2", "#sigma2");
    156         f->SetParameters(integ,(min+mean)/2.,width/4.,
    157                          integ/width/2.,(max+mean)/2.,width/4.);
    158         // The left-sided Gauss
    159         f->SetParLimits(0,integ-1.5      , integ+1.5);
    160         f->SetParLimits(1,min+(width/10.), mean);
    161         f->SetParLimits(2,0              , width/2.);
    162         // The right-sided Gauss
    163         f->SetParLimits(3,0   , integ);
    164         f->SetParLimits(4,mean, max-(width/10.));
    165         f->SetParLimits(5,0   , width/2.);
    166         obj2->Fit(f,"QLRM");
    167         break;
    168 
     154      f = new TF1("dgaus",dgausformula.Data(),min,max);
     155      f->SetLineColor(kYellow);
     156      f->SetBit(kCanDelete);
     157      f->SetParNames("A_{tot}", "#mu1", "#sigma1", "A2", "#mu2", "#sigma2");
     158      f->SetParameters(integ,(min+mean)/2.,width/4.,
     159                       integ/width/2.,(max+mean)/2.,width/4.);
     160      // The left-sided Gauss
     161      f->SetParLimits(0,integ-1.5      , integ+1.5);
     162      f->SetParLimits(1,min+(width/10.), mean);
     163      f->SetParLimits(2,0              , width/2.);
     164      // The right-sided Gauss
     165      f->SetParLimits(3,0   , integ);
     166      f->SetParLimits(4,mean, max-(width/10.));
     167      f->SetParLimits(5,0   , width/2.);
     168      obj2->Fit(f,"QLRM");
     169      break;
     170     
    169171    case 3:
    170         f = new TF1("tgaus",tgausformula.Data(),min,max);
    171         f->SetLineColor(kYellow);
    172         f->SetBit(kCanDelete);
    173         f->SetParNames("A_{tot}","#mu_{1}","#sigma_{1}",
    174                        "A_{2}","#mu_{2}","#sigma_{2}",
    175                        "A_{3}","#mu_{3}","#sigma_{3}");
    176         f->SetParameters(integ,(min+mean)/2,width/4.,
    177                          integ/width/3.,(max+mean)/2.,width/4.,
    178                          integ/width/3.,mean,width/2.);
    179         // The left-sided Gauss
    180         f->SetParLimits(0,integ-1.5,integ+1.5);
    181         f->SetParLimits(1,min+(width/10.),mean);
    182         f->SetParLimits(2,width/15.,width/2.);
    183         // The right-sided Gauss
    184         f->SetParLimits(3,0.,integ);
    185         f->SetParLimits(4,mean,max-(width/10.));
    186         f->SetParLimits(5,width/15.,width/2.);
    187         // The Gauss describing the outliers
    188         f->SetParLimits(6,0.,integ);
    189         f->SetParLimits(7,min,max);
    190         f->SetParLimits(8,width/4.,width/1.5);
    191         obj2->Fit(f,"QLRM");
    192         break;
    193 
     172      f = new TF1("tgaus",tgausformula.Data(),min,max);
     173      f->SetLineColor(kYellow);
     174      f->SetBit(kCanDelete);
     175      f->SetParNames("A_{tot}","#mu_{1}","#sigma_{1}",
     176                     "A_{2}","#mu_{2}","#sigma_{2}",
     177                     "A_{3}","#mu_{3}","#sigma_{3}");
     178      f->SetParameters(integ,(min+mean)/2,width/4.,
     179                       integ/width/3.,(max+mean)/2.,width/4.,
     180                       integ/width/3.,mean,width/2.);
     181      // The left-sided Gauss
     182      f->SetParLimits(0,integ-1.5,integ+1.5);
     183      f->SetParLimits(1,min+(width/10.),mean);
     184      f->SetParLimits(2,width/15.,width/2.);
     185      // The right-sided Gauss
     186      f->SetParLimits(3,0.,integ);
     187      f->SetParLimits(4,mean,max-(width/10.));
     188      f->SetParLimits(5,width/15.,width/2.);
     189      // The Gauss describing the outliers
     190      f->SetParLimits(6,0.,integ);
     191      f->SetParLimits(7,min,max);
     192      f->SetParLimits(8,width/4.,width/1.5);
     193      obj2->Fit(f,"QLRM");
     194      break;
     195     
    194196    case 4:
    195         obj2->Fit("pol0", "Q");
    196         obj2->GetFunction("pol0")->SetLineColor(kYellow);
    197         break;
    198 
     197      obj2->Fit("pol0", "Q");
     198      obj2->GetFunction("pol0")->SetLineColor(kYellow);
     199      break;
     200     
    199201    case 9:
    200         break;
    201 
     202      break;
     203     
    202204    default:
    203         obj2->Fit("gaus", "Q");
    204         obj2->GetFunction("gaus")->SetLineColor(kYellow);
    205         break;
    206     }
    207 }
    208 
    209 void MJCalibration::CamDraw(TCanvas &c, const Int_t x, const Int_t y, const MHCamera &cam1, const Int_t fit)
     205      obj2->Fit("gaus", "Q");
     206      obj2->GetFunction("gaus")->SetLineColor(kYellow);
     207      break;
     208    }
     209}
     210
     211void MJCalibration::DrawRadialProfile(MHCamera *obj) const
     212{
     213 
     214  TProfile *obj2 = (TProfile*)obj->RadialProfile(obj->GetName());
     215  obj2->SetDirectory(0);
     216  obj2->Draw();
     217  obj2->SetBit(kCanDelete);
     218 
     219  if (obj->GetGeomCam().InheritsFrom("MGeomCamMagic"))
     220    {
     221
     222      TArrayI s0(6);
     223      s0[0] = 1;
     224      s0[1] = 2;
     225      s0[2] = 3;
     226      s0[3] = 4;
     227      s0[4] = 5;
     228      s0[5] = 6;
     229
     230      TArrayI inner(1);
     231      inner[0] = 0;
     232     
     233      TArrayI outer(1);
     234      outer[0] = 1;
     235     
     236      // Just to get the right (maximum) binning
     237      TProfile *half[2];
     238      half[0] = obj->RadialProfileS(s0, inner,Form("%s%s",obj->GetName(),"Inner"));
     239      half[1] = obj->RadialProfileS(s0, outer,Form("%s%s",obj->GetName(),"Outer"));
     240     
     241      for (Int_t i=0; i<2; i++)
     242        {
     243          Double_t min = obj->GetGeomCam().GetMinRadius(i);
     244          Double_t max = obj->GetGeomCam().GetMaxRadius(i);
     245
     246          half[i]->SetLineColor(kRed+i);
     247          half[i]->SetDirectory(0);
     248          half[i]->SetBit(kCanDelete);
     249          half[i]->Draw("same");
     250          half[i]->Fit("pol1","Q","",min,max);
     251          half[i]->GetFunction("pol1")->SetLineColor(kRed+i);
     252          half[i]->GetFunction("pol1")->SetLineWidth(1);
     253        }
     254    }
     255}
     256
     257
     258void MJCalibration::CamDraw(TCanvas &c, const Int_t x, const Int_t y, const MHCamera &cam1,
     259                            const Int_t fit, const Int_t rad)
    210260{
    211261    c.cd(x);
    212262    gPad->SetBorderMode(0);
     263    gPad->SetTicks();
    213264    MHCamera *obj1=(MHCamera*)cam1.DrawCopy("hist");
    214     obj1->AddNotify(&fCalibrationCam);
     265    obj1->SetDirectory(NULL);
    215266
    216267    c.cd(x+y);
    217268    gPad->SetBorderMode(0);
     269    obj1->SetPrettyPalette();
     270    obj1->AddNotify(&fCalibrationCam);
    218271    obj1->Draw();
     272
     273    if (rad)
     274      {
     275        c.cd(x+2*y);
     276        gPad->SetBorderMode(0);
     277        gPad->SetTicks();
     278        DrawRadialProfile(obj1);
     279      }
     280   
    219281
    220282    if (!fit)
    221283        return;
    222284
    223     c.cd(x+2*y);
     285    c.cd(rad ? x+3*y : x+2*y);
    224286    gPad->SetBorderMode(0);
     287    gPad->SetTicks();
    225288    DrawProjection(obj1, fit);
    226289}
    … …  
    249312    MHCamera disp1 (geomcam, "Cal;Charge",         "Fitted Mean Charges");
    250313    MHCamera disp2 (geomcam, "Cal;SigmaCharge",    "Sigma of Fitted Charges");
    251     MHCamera disp3 (geomcam, "Cal;FitProb",        "Probability of Fit");
    252     MHCamera disp4 (geomcam, "Cal;RSigma",         "Reduced Sigmas");
    253     MHCamera disp5 (geomcam, "Cal;RSigma/Charge",  "Reduced Sigma per Charge");
    254     MHCamera disp6 (geomcam, "Cal;FFactorPhe",     "Nr. of Phe's (F-Factor Method)");
    255     MHCamera disp7 (geomcam, "Cal;FFactorConv",    "Conversion Factor (F-Factor Method)");
    256     MHCamera disp8 (geomcam, "Cal;FFactorFFactor", "Total F-Factor (F-Factor Method)");
    257     MHCamera disp9 (geomcam, "Cal;BlindPixPh",     "Photon flux inside plexiglass (Blind Pixel Method)");
    258     MHCamera disp10(geomcam, "Cal;BlindPixConv",   "Conversion Factor (Blind Pixel Method)");
    259     MHCamera disp11(geomcam, "Cal;BlindPixFFactor","Total F-Factor (Blind Pixel Method)");
    260     MHCamera disp12(geomcam, "Cal;PINDiodePh",     "Photons flux outside plexiglass (PIN Diode Method)");
    261     MHCamera disp13(geomcam, "Cal;PINDiodeConv",   "Conversion Factor (PIN Diode Method)");
    262     MHCamera disp14(geomcam, "Cal;PINDiodeFFactor","Total F-Factor (PIN Diode Method)");
    263     MHCamera disp15(geomcam, "Cal;Excluded",       "Pixels previously excluded");
    264     MHCamera disp16(geomcam, "Cal;NotFitted",      "Pixels that could not be fitted");
    265     MHCamera disp17(geomcam, "Cal;NotFitValid",    "Pixels with not valid fit results");
    266     MHCamera disp18(geomcam, "Cal;Oscillation",    "Oscillating Pixels");
    267     MHCamera disp19(geomcam, "Cal;Saturation",     "Pixels with saturated Hi Gain");
     314    MHCamera disp3 (geomcam, "Cal;RSigma",         "Reduced Sigmas");
     315    MHCamera disp4 (geomcam, "Cal;RSigma/Charge",  "Reduced Sigma per Charge");
     316    MHCamera disp5 (geomcam, "Cal;FFactorPhe",     "Nr. of Phe's (F-Factor Method)");
     317    MHCamera disp6 (geomcam, "Cal;FFactorConv",    "Conversion Factor (F-Factor Method)");
     318    MHCamera disp7 (geomcam, "Cal;BlindPixConv",   "Conversion Factor (Blind Pixel Method)");
     319    MHCamera disp8 (geomcam, "Cal;PINDiodeConv",   "Conversion Factor (PIN Diode Method)");
     320    MHCamera disp9 (geomcam, "Cal;FFactorValid",   "Pixels with valid F-Factor calibration");
     321    MHCamera disp10(geomcam, "Cal;BlindPixelValid","Pixels with valid BlindPixel calibration");
     322    MHCamera disp11(geomcam, "Cal;PINdiodeValid",  "Pixels with valid PINDiode calibration");
     323    MHCamera disp12(geomcam, "Cal;Excluded",       "Pixels previously excluded");
     324    MHCamera disp13(geomcam, "Cal;Saturation",     "Pixels with saturated Hi Gain");
     325    MHCamera disp14(geomcam, "Cal;HiGainPickup",   "Number Pickup events Hi Gain");
     326    MHCamera disp15(geomcam, "Cal;LoGainPickup",   "Number Pickup events Lo Gain");
     327    MHCamera disp16(geomcam, "Bad;UnSuitable",     "Pixels not suited for further analysis");
     328    MHCamera disp17(geomcam, "Bad;UnReliable",     "Pixels not reliable for further analysis");
     329    MHCamera disp18(geomcam, "Bad;Oscillation",    "Oscillating Pixels");
    268330
    269331    // Fitted charge means and sigmas
    … …  
    272334    disp2.SetCamContent(fCalibrationCam,  2);
    273335    disp2.SetCamError(  fCalibrationCam,  3);
    274     // Fit probabilities
    275     disp3.SetCamContent(fCalibrationCam,  4);
    276336
    277337    // Reduced Sigmas and reduced sigmas per charge
    278     disp4.SetCamContent(fCalibrationCam,  5);
    279     disp4.SetCamError(  fCalibrationCam,  6);
    280     disp5.SetCamContent(fCalibrationCam,  7);
    281     disp5.SetCamError(  fCalibrationCam,  8);
    282 
    283     // F-Factor Method
    284     disp6.SetCamContent(fCalibrationCam,  9);
    285     disp6.SetCamError(  fCalibrationCam, 10);
    286     disp7.SetCamContent(fCalibrationCam, 11);
    287     disp7.SetCamError(  fCalibrationCam, 12);
    288     disp8.SetCamContent(fCalibrationCam, 13);
    289     disp8.SetCamError(  fCalibrationCam, 14);
    290 
    291     /// Blind Pixel Method
    292     disp9.SetCamContent(fCalibrationCam, 15);
    293     disp9.SetCamError(  fCalibrationCam, 16);
    294     disp10.SetCamContent(fCalibrationCam,17);
    295     disp10.SetCamError(  fCalibrationCam,18);
    296     disp11.SetCamContent(fCalibrationCam,19);
    297     disp11.SetCamError(  fCalibrationCam,20);
    298 
    299     // PIN Diode Method
    300     disp12.SetCamContent(fCalibrationCam,21);
    301     disp12.SetCamError(  fCalibrationCam,22);
    302     disp13.SetCamContent(fCalibrationCam,23);
    303     disp13.SetCamError(  fCalibrationCam,24);
    304     disp14.SetCamContent(fCalibrationCam,25);
    305     disp14.SetCamError(  fCalibrationCam,26);
     338    disp3.SetCamContent(fCalibrationCam,  5);
     339    disp3.SetCamError(  fCalibrationCam,  6);
     340    disp4.SetCamContent(fCalibrationCam,  7);
     341    disp4.SetCamError(  fCalibrationCam,  8);
     342
     343    // Conversion Factors, Methods
     344    disp5.SetCamContent(fCalibrationCam,  9);
     345    disp5.SetCamError(  fCalibrationCam, 10);
     346    disp6.SetCamContent(fCalibrationCam, 11);
     347    disp6.SetCamError(  fCalibrationCam, 12);
     348    disp7.SetCamContent(fCalibrationCam, 13);
     349    disp7.SetCamError(  fCalibrationCam, 14);
     350    disp8.SetCamContent(fCalibrationCam, 16);
     351    disp8.SetCamError(  fCalibrationCam, 17);
     352
     353    // Valid flags
     354    disp9.SetCamContent (fCalibrationCam, 15);
     355    disp10.SetCamContent(fCalibrationCam, 20);
     356    disp11.SetCamContent(fCalibrationCam, 25);
     357
     358    // Pixels behavior
     359    disp12.SetCamContent(fCalibrationCam, 26);
     360    disp13.SetCamContent(fCalibrationCam, 29);
     361    disp14.SetCamContent(fCalibrationCam, 27);
     362    disp15.SetCamContent(fCalibrationCam, 28);
    306363
    307364    // Pixels with defects
    308     disp15.SetCamContent(fCalibrationCam,27);
    309     disp16.SetCamContent(fCalibrationCam,28);
    310     disp17.SetCamContent(fBadPixels     , 9);
    311     disp18.SetCamContent(fBadPixels     , 8);
    312 
    313     // Lo Gain calibration
    314     disp19.SetCamContent(fCalibrationCam,31);
     365    disp16.SetCamContent(fBadPixels, 1);
     366    disp17.SetCamContent(fBadPixels, 3);
     367    disp18.SetCamContent(fBadPixels, 8);
    315368
    316369    disp1.SetYTitle("Q [FADC units]");
    317370    disp2.SetYTitle("\\sigma_{Q} [FADC units]");
    318     disp3.SetYTitle("P_{Q} [1]");
    319 
    320     disp4.SetYTitle("\\sqrt{\\sigma^{2}_{Q} - RMS^{2}_{Ped}} [FADC Counts]");
    321     disp5.SetYTitle("Red.Sigma/<Q> [1]");
    322 
    323     disp6.SetYTitle("PhE [#]");
    324     disp7.SetYTitle("Conv.Factor [PhE/FADC units]");
    325     disp8.SetYTitle("\\sqrt{N_{PhE}}*\\sigma_{Q}/\\mu_{Q} [1]");
    326 
    327     disp9.SetYTitle("Phot.flux [ph/mm^{2}]");
    328     disp10.SetYTitle("Conv.Factor [Phot/FADC Count]");
    329     disp11.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Q}/\\mu_{Q} [1]");
    330 
    331     disp12.SetYTitle("Phot.flux [ph/mm^{2}]");
    332     disp13.SetYTitle("Conv.Factor [Phot/FADC Count]");
    333     disp14.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Q}/\\mu_{Q} [1]");
    334 
     371
     372    disp3.SetYTitle("\\sqrt{\\sigma^{2}_{Q} - RMS^{2}_{Ped}} [FADC Counts]");
     373    disp4.SetYTitle("Red.Sigma/<Q> [1]");
     374
     375    disp5.SetYTitle("PhE [#]");
     376    disp6.SetYTitle("Conv.Factor [PhE/FADC units]");
     377
     378    disp7.SetYTitle("Conv.Factor [Phot/FADC Count]");
     379    disp8.SetYTitle("Conv.Factor [Phot/FADC Count]");
     380
     381    disp9.SetYTitle("[1]");
     382    disp10.SetYTitle("[1]");
     383    disp11.SetYTitle("[1]");
     384    disp12.SetYTitle("[1]");
     385    disp13.SetYTitle("[1]");
     386    disp14.SetYTitle("[1]");
    335387    disp15.SetYTitle("[1]");
    336388    disp16.SetYTitle("[1]");
    … …  
    343395    // Charges
    344396    TCanvas &c1 = fDisplay->AddTab("Fit.Charge");
    345     c1.Divide(2, 3);
    346 
    347     CamDraw(c1, 1, 2, disp1, 2);
    348     CamDraw(c1, 2, 2, disp2, 2);
    349 
    350     // Fit Probability
    351     TCanvas &c2 = fDisplay->AddTab("Fit.Prob");
    352     c2.Divide(1,3);
    353 
    354     CamDraw(c2, 1, 1, disp3, 4);
     397    c1.Divide(2, 4);
     398
     399    CamDraw(c1, 1, 2, disp1, 2, 1);
     400    CamDraw(c1, 2, 2, disp2, 2, 1);
    355401
    356402    // Reduced Sigmas
    357403    TCanvas &c3 = fDisplay->AddTab("Red.Sigma");
    358     c3.Divide(2,3);
    359 
    360     CamDraw(c3, 1, 2, disp4, 2);
    361     CamDraw(c3, 2, 2, disp5, 2);
    362 
    363     // F-Factor Method
    364     TCanvas &c4 = fDisplay->AddTab("F-Factor");
    365     c4.Divide(3,3);
    366 
    367     CamDraw(c4, 1, 3, disp6, 2);
    368     CamDraw(c4, 2, 3, disp7, 2);
    369     CamDraw(c4, 3, 3, disp8, 2);
    370 
    371     // Blind Pixel Method
    372     TCanvas &c5 = fDisplay->AddTab("BlindPix");
    373     c5.Divide(3, 3);
    374 
    375     CamDraw(c5, 1, 3, disp9,  9);
    376     CamDraw(c5, 2, 3, disp10, 2);
    377     CamDraw(c5, 3, 3, disp11, 2);
    378 
    379     // PIN Diode Method
    380     TCanvas &c6 = fDisplay->AddTab("PINDiode");
    381     c6.Divide(3,3);
    382 
    383     CamDraw(c6, 1, 3, disp12, 9);
    384     CamDraw(c6, 2, 3, disp13, 2);
    385     CamDraw(c6, 3, 3, disp14, 2);
     404    c3.Divide(2,4);
     405
     406    CamDraw(c3, 1, 2, disp3, 2, 1);
     407    CamDraw(c3, 2, 2, disp4, 2, 1);
     408
     409    //  Methods
     410    TCanvas &c4 = fDisplay->AddTab("Methods");
     411    c4.Divide(4,4);
     412
     413    CamDraw(c4, 1, 4, disp5, 2, 1);
     414    CamDraw(c4, 2, 4, disp6, 2, 1);
     415    CamDraw(c4, 3, 4, disp7, 2, 1);
     416    CamDraw(c4, 4, 4, disp8, 2, 1);
     417
     418    // Validity
     419    TCanvas &c5 = fDisplay->AddTab("Validity");
     420    c5.Divide(3,2);
     421
     422    CamDraw(c5, 1, 3, disp9 , 0);
     423    CamDraw(c5, 2, 3, disp10, 0);
     424    CamDraw(c5, 3, 3, disp11, 0);
     425
     426    // Other info
     427    TCanvas &c6 = fDisplay->AddTab("Behavior");
     428    c6.Divide(4,2);
     429
     430    CamDraw(c6, 1, 4, disp12, 0);
     431    CamDraw(c6, 2, 4, disp13, 0);
     432    CamDraw(c6, 3, 4, disp14, 0);
     433    CamDraw(c6, 4, 4, disp15, 0);
    386434
    387435    // Defects
    388436    TCanvas &c7 = fDisplay->AddTab("Defects");
    389     c7.Divide(4,2);
    390 
    391     CamDraw(c7, 1, 4, disp15, 0);
    392     CamDraw(c7, 2, 4, disp16, 0);
    393     CamDraw(c7, 3, 4, disp17, 0);
    394     CamDraw(c7, 4, 4, disp18, 0);
    395 
    396     // Lo Gain Calibration
    397     TCanvas &c8 = fDisplay->AddTab("LowGain");
    398     c8.Divide(1,3);
    399 
    400     CamDraw(c8, 1, 1, disp19, 0);
     437    c7.Divide(3,2);
     438
     439    CamDraw(c7, 1, 3, disp16, 0);
     440    CamDraw(c7, 2, 3, disp17, 0);
     441    CamDraw(c7, 3, 3, disp18, 0);
     442
    401443}
    402444
    … …  
    530572    plist.AddToList(&pedcam);
    531573    plist.AddToList(&fCalibrationCam);
     574    plist.AddToList(&fBadPixels);
    532575    plist.AddToList(&pindiode);
    533576    plist.AddToList(&blindpix);

  • trunk/MagicSoft/Mars/mjobs/MJCalibration.h

    r3445 r3564  
    2626    MBadPixelsCam         fBadPixels;
    2727
    28     void DrawProjection(MHCamera *obj1, Int_t fit) const;
    29     void CamDraw(TCanvas &c, const Int_t x, const Int_t y, const MHCamera &cam1, const Int_t fit);
     28    void DrawProjection  ( MHCamera *obj, Int_t fit) const;
     29    void DrawRadialProfile( MHCamera *obj)            const;   
     30    void CamDraw(TCanvas &c, const Int_t x, const Int_t y, const MHCamera &cam1,
     31                 const Int_t fit, const Int_t rad=0);
    3032
    3133    void   DisplayResult(MParList &plist);
Note: See TracChangeset for help on using the changeset viewer.