Changeset 3762 for trunk/MagicSoft


Ignore:
Timestamp:
04/15/04 23:31:58 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3761 r3762  
    2727   * macros/bootcampstandardanalysis.C
    2828   * macros/pedphotcalc.C
     29   * macros/calibrate_data.C
    2930     - updated the macro to the cvs-standard used at the Udine bootcamp
    3031

  • trunk/MagicSoft/Mars/macros/calibrate_data.C

    r3567 r3762  
    2323!
    2424\* ======================================================================== */
    25 #include "MAGIC.h"
    2625
    2726const TString defpath = "/mnt/Data/rootdata/CrabNebula/2004_01_27/";
    … …  
    5756  }
    5857
     58  MCalibrationCam::PulserColor_t color;
     59
     60  if (calruns[0] < 20000)
     61    color = MCalibrationCam::kCT1;
     62  else
     63    color = FindColor((MDirIter*)&cruns);
     64
     65  if (color == MCalibrationCam::kNONE)
     66    {
     67      TTimer timer("gSystem->ProcessEvents();", 50, kFALSE);
     68     
     69      while (1)
     70        {
     71          timer.TurnOn();
     72          TString input = Getline("Could not find the correct colour: Type 'q' to exit, "
     73                                  "green, blue, uv or ct1 to go on: ");
     74          timer.TurnOff();
     75         
     76          if (input=="q\n")
     77            return ;
     78         
     79          if (input=="green")
     80            color = MCalibrationCam::kGREEN;
     81          if (input=="blue")
     82            color = MCalibrationCam::kBLUE;
     83          if (input=="uv")
     84            color = MCalibrationCam::kUV;
     85          if (input=="ct1")
     86            color = MCalibrationCam::kCT1;
     87        }
     88    }
     89
    5990  MStatusDisplay *display = new MStatusDisplay;
    6091  display->SetUpdateTime(3000);
    … …  
    75106  MPedestalCam   pedcam;
    76107  MBadPixelsCam  badcam;
    77 
    78108  //
    79109  // for excluding pixels from the beginning:
    … …  
    114144  // Now the short version:
    115145  //
    116 /*
    117     MJCalibration calloop;
    118     calloop.SetInput(&cruns);
    119     calloop.SetDisplay(display);
    120     if (!calloop.Process(pedloop.GetPedestalCam()))
    121         return;
    122 #if 0
    123 */
    124     //
    125     // The longer version:
    126     //
    127 
    128     //
    129     // Create a empty Parameter List and an empty Task List
    130     //
    131     MParList  plist2;
    132     MTaskList tlist2;
    133     plist2.AddToList(&tlist2);
    134     plist2.AddToList(&pedcam);
    135     plist2.AddToList(&badcam);
    136 
    137     gLog << endl;;
    138     gLog << "Calculate MCalibrationCam from Runs " << cruns.GetRunsAsString() << endl;
    139     gLog << endl;
    140 
    141     MReadMarsFile read2("Events");
    142     read2.DisableAutoScheme();
    143     static_cast<MRead&>(read2).AddFiles(cruns);
    144 
    145     MGeomCamMagic              geomcam;
    146     MExtractedSignalCam        sigcam;
    147     MArrivalTimeCam            timecam;
    148     MCalibrationChargeCam      calcam;
    149     //    MCalibrationChargePINDiode pindiode;   
    150     //    MCalibrationChargeBlindPix blindpix;   
    151    
    152     MHCalibrationRelTimeCam     histtime;
    153     MHCalibrationChargeCam      histcharge;
    154     //    MHCalibrationChargePINDiode histpin;
    155     //    MHCalibrationChargeBlindPix histblind;
    156     //
    157     //
    158     // Get the previously created MPedestalCam into the new Parameter List
    159     //
    160     plist2.AddToList(&geomcam);
    161     plist2.AddToList(&sigcam);
    162     plist2.AddToList(&timecam);
    163     plist2.AddToList(&calcam);
    164     plist2.AddToList(&histtime);
    165     plist2.AddToList(&histcharge);
    166 //    plist2.AddToList(&histpin);
    167 //    plist2.AddToList(&histblind);
    168 
    169     //
    170     // We saw that the signal jumps between slices,
    171     // thus take the sliding window
    172     //         
    173     MExtractSignal2        sigcalc;
    174     MExtractPINDiode       pincalc;
    175     MExtractBlindPixel     blindcalc;
    176 
    177     MArrivalTimeCalc2      timecalc;
    178     MCalibrationChargeCalc calcalc;
    179     MGeomApply             geomapl;
    180 
    181     MFillH filltime( "MHCalibrationRelTimeCam"    , "MArrivalTimeCam");
    182 //   MFillH fillpin  ("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode");
    183 //    MFillH fillblind("MHCalibrationChargeBlindPix", "MExtractedSignalBlindPixel");
    184     MFillH fillcam  ("MHCalibrationChargeCam"     , "MExtractedSignalCam");
    185 
    186     //
    187     // Skip the HiGain vs. LoGain calibration
    188     //
    189     calcalc.SkipHiLoGainCalibration();
    190 
    191     //
    192     // Apply a filter against cosmics
    193     // (was directly in MCalibrationCalc in earlier versions)
    194     //
    195     MFCosmics            cosmics;
    196     MContinue            cont(&cosmics);
    197 
    198     tlist2.AddToList(&read2);
    199     tlist2.AddToList(&geomapl);
    200     tlist2.AddToList(&sigcalc);
    201     //    tlist2.AddToList(&blindcalc);
    202     //    tlist2.AddToList(&pincalc);
    203     //
    204     // In case, you want to skip the cosmics rejection,
    205     // uncomment the next line
    206     //
    207     tlist2.AddToList(&cont);
    208     //
    209     // In case, you want to skip the somewhat lengthy calculation
    210     // of the arrival times using a spline, uncomment the next two lines
    211     //
    212     tlist2.AddToList(&timecalc);
    213     tlist2.AddToList(&filltime);
    214 //    tlist2.AddToList(&fillpin);
    215 //    tlist2.AddToList(&fillblind);
    216     tlist2.AddToList(&fillcam);
    217     //
    218     tlist2.AddToList(&calcalc);
    219     //
    220     // Create and setup the eventloop
    221     //
    222     MEvtLoop evtloop;
    223     evtloop.SetParList(&plist2);
    224     evtloop.SetDisplay(display);
    225    
    226     cout << "***************************" << endl;
    227     cout << "** COMPUTING CALIBRATION **" << endl;
    228     cout << "***************************" << endl;
    229 
    230     //
    231     // Execute second analysis
    232     //
    233     if (!evtloop.Eventloop())
    234         return;
    235 
    236     tlist2.PrintStatistics();
    237 
    238     //
    239     // print the most important results of all pixels to a file
    240     //
    241     //    MLog gauglog;
    242     //    gauglog.SetOutputFile(Form("%s%s",calcam.GetName(),".txt"),1);
    243     //    calcam.SetLogStream(&gauglog);
    244     //    calcam.Print();
    245     //  calcam.SetLogStream(&gLog);
    246     //
    247     // just one example how to get the plots of individual pixels
    248     //
    249     //    histblind.DrawClone("all");
    250     //    histcharge[5].DrawClone("all");
    251     //    histcharge(5).DrawClone("all");
    252     //    histtime[5].DrawClone("fourierevents");
    253 
    254     // Create histograms to display
    255     MHCamera disp1  (geomcam, "Cal;Charge",         "Fitted Mean Charges");
    256     MHCamera disp2  (geomcam, "Cal;SigmaCharge",    "Sigma of Fitted Charges");
    257     MHCamera disp3  (geomcam, "Cal;FitProb",        "Probability of Fit");
    258     MHCamera disp4  (geomcam, "Cal;RSigma",         "Reduced Sigmas");
    259     MHCamera disp5  (geomcam, "Cal;RSigma/Charge",  "Reduced Sigma per Charge");
    260     MHCamera disp6  (geomcam, "Cal;FFactorPhe",     "Nr. of Photo-electrons (F-Factor Method)");
    261     MHCamera disp7  (geomcam, "Cal;FFactorConv",    "Conversion Factor to photons (F-Factor Method)");
    262     MHCamera disp8  (geomcam, "Cal;FFactorFFactor", "Total F-Factor (F-Factor Method)");
    263     MHCamera disp9  (geomcam, "Cal;BlindPixConv",   "Conversion Factor to photons (Blind Pixel Method)");
    264     MHCamera disp10 (geomcam, "Cal;BlindPixFFactor","Total F-Factor (Blind Pixel Method)");
    265     MHCamera disp11 (geomcam, "Cal;PINDiodeConv",   "Conversion Factor tp photons (PIN Diode Method)");
    266     MHCamera disp12 (geomcam, "Cal;PINDiodeFFactor","Total F-Factor (PIN Diode Method)");
    267     MHCamera disp13 (geomcam, "Cal;Excluded",       "Pixels previously excluded");
    268     MHCamera disp14 (geomcam, "Cal;NotFitted",      "Pixels that could not be fitted");
    269     MHCamera disp15 (geomcam, "Cal;NotFitValid",    "Pixels with not valid fit results");
    270     MHCamera disp16 (geomcam, "Cal;HiGainOscillating",     "Oscillating Pixels HI Gain");
    271     MHCamera disp17 (geomcam, "Cal;LoGainOscillating",     "Oscillating Pixels LO Gain");
    272     MHCamera disp18 (geomcam, "Cal;HiGainPickup",          "Number Pickup events Hi Gain");
    273     MHCamera disp19 (geomcam, "Cal;LoGainPickup",          "Number Pickup events Lo Gain");
    274     MHCamera disp20 (geomcam, "Cal;Saturation",            "Pixels with saturated Hi Gain");
    275     MHCamera disp21 (geomcam, "Cal;FFactorValid",          "Pixels with valid F-Factor calibration");
    276     MHCamera disp22 (geomcam, "Cal;BlindPixelValid",       "Pixels with valid BlindPixel calibration");
    277     MHCamera disp23 (geomcam, "Cal;PINdiodeFFactorValid",  "Pixels with valid PINDiode calibration");
    278    
    279     MHCamera disp24 (geomcam, "Cal;Ped",         "Pedestals");
    280     MHCamera disp25 (geomcam, "Cal;PedRms",      "Pedestal RMS");
    281    
    282     MHCamera disp26 (geomcam, "time;Time",        "Rel. Arrival Times");
    283     MHCamera disp27 (geomcam, "time;SigmaTime",   "Sigma of Rel. Arrival Times");
    284     MHCamera disp28 (geomcam, "time;TimeProb",    "Probability of Time Fit");
    285     MHCamera disp29 (geomcam, "time;NotFitValid", "Pixels with not valid fit results");
    286     MHCamera disp30 (geomcam, "time;Oscillating", "Oscillating Pixels");
    287    
    288     MHCamera disp31 (geomcam, "Cal;AbsTimeMean",  "Abs. Arrival Times");
    289     MHCamera disp32 (geomcam, "Cal;AbsTimeRms",   "RMS of Arrival Times");
    290    
    291     // Fitted charge means and sigmas
    292     disp1.SetCamContent(calcam,  0);
    293     disp1.SetCamError(  calcam,  1);
    294     disp2.SetCamContent(calcam,  2);
    295     disp2.SetCamError(  calcam,  3);
    296  
    297     // Fit probabilities
    298     disp3.SetCamContent(calcam,  4);
    299    
    300     // Reduced Sigmas and reduced sigmas per charge
    301     disp4.SetCamContent(calcam,  5);
    302     disp4.SetCamError(  calcam,  6);
    303     disp5.SetCamContent(calcam,  7);
    304     disp5.SetCamError(  calcam,  8);
    305    
    306     // F-Factor Method
    307     disp6.SetCamContent(calcam,  9);
    308     disp6.SetCamError(  calcam, 10);
    309     disp7.SetCamContent(calcam, 11);
    310     disp7.SetCamError(  calcam, 12);
    311     disp8.SetCamContent(calcam, 13);
    312     disp8.SetCamError(  calcam, 14);
    313    
    314     // Blind Pixel Method
    315     disp9.SetCamContent(calcam, 16);
    316     disp9.SetCamError(  calcam, 17);
    317     disp10.SetCamContent(calcam,18);
    318     disp10.SetCamError(  calcam,19);
    319    
    320     // PIN Diode Method
    321     disp11.SetCamContent(calcam,21);
    322     disp11.SetCamError(  calcam,22);
    323     disp12.SetCamContent(calcam,23);
    324     disp12.SetCamError(  calcam,24);
    325    
    326     // Pixels with defects
    327     disp13.SetCamContent(calcam,26);
    328     disp14.SetCamContent(badcam,7);
    329     disp15.SetCamContent(badcam,9);
    330     disp16.SetCamContent(badcam,16);
    331     disp17.SetCamContent(badcam,15);
    332     disp18.SetCamContent(calcam,27);
    333     disp19.SetCamContent(calcam,28);
    334    
    335     // Lo Gain calibration
    336     disp20.SetCamContent(calcam,29);
    337    
    338     // Valid flags
    339     disp21.SetCamContent(calcam,15);
    340     disp22.SetCamContent(calcam,20);
    341     disp23.SetCamContent(calcam,25);
    342    
    343     // Pedestals
    344     disp24.SetCamContent(calcam,30);
    345     disp24.SetCamError(  calcam,31);
    346     disp25.SetCamContent(calcam,32);
    347     disp25.SetCamError(  calcam,33);
    348    
    349     // Relative Times
    350     disp26.SetCamContent(histtime,0);
    351     disp26.SetCamError(  histtime,1);
    352     disp27.SetCamContent(histtime,2);
    353     disp27.SetCamError(  histtime,3);
    354     disp28.SetCamContent(histtime,4);
    355     disp29.SetCamContent(histtime,5);
    356     disp30.SetCamContent(histtime,6);
    357    
    358     // Absolute Times
    359     disp31.SetCamContent(calcam,34);
    360     disp31.SetCamError(  calcam,35);
    361     disp32.SetCamContent(calcam,35);
    362    
    363     disp1.SetYTitle("Charge [FADC units]");
    364     disp2.SetYTitle("\\sigma_{Charge} [FADC units]");
    365     disp3.SetYTitle("P_{Charge} [1]");
    366    
    367     disp4.SetYTitle("\\sqrt{\\sigma^{2}_{Charge} - RMS^{2}_{Ped}} [FADC Counts]");
    368     disp5.SetYTitle("Reduced Sigma / Mean Charge [1]");
    369    
    370     disp6.SetYTitle("Nr. Photo-electrons [1]");
    371     disp7.SetYTitle("Conversion Factor [Ph/FADC Count]");
    372     disp8.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1] ");
    373    
    374     disp9.SetYTitle("Conversion Factor [Phot/FADC Count]");
    375     disp10.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1]");
    376    
    377     disp11.SetYTitle("Conversion Factor [Phot/FADC Count]");
    378     disp12.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1]");
    379    
    380     disp13.SetYTitle("[1]");
    381     disp14.SetYTitle("[1]");
    382     disp15.SetYTitle("[1]");
    383     disp16.SetYTitle("[1]");
    384     disp17.SetYTitle("[1]");
    385     disp18.SetYTitle("[1]");
    386     disp19.SetYTitle("[1]");
    387     disp20.SetYTitle("[1]");
    388     disp21.SetYTitle("[1]");
    389     disp22.SetYTitle("[1]");
    390     disp23.SetYTitle("[1]");
    391    
    392     disp24.SetYTitle("Ped [FADC Counts ]");
    393     disp25.SetYTitle("RMS_{Ped} [FADC Counts ]");
    394    
    395     disp26.SetYTitle("Time Offset [ns]");
    396     disp27.SetYTitle("Timing resolution [ns]");
    397     disp28.SetYTitle("P_{Time} [1]");
    398    
    399     disp29.SetYTitle("[1]");
    400     disp30.SetYTitle("[1]");
    401    
    402     disp31.SetYTitle("Mean Abs. Time [FADC slice]");
    403     disp32.SetYTitle("RMS Abs. Time [FADC slices]");
    404    
    405     gStyle->SetOptStat(1111);
    406     gStyle->SetOptFit();
    407    
    408     // Charges
    409     TCanvas &c1 = display->AddTab("Fit.Charge");
    410     c1.Divide(2, 3);
    411 
    412     CamDraw(c1, disp1,calcam,1, 2 , 2);
    413     CamDraw(c1, disp2,calcam,2, 2 , 2);
    414 
    415     // Fit Probability
    416     TCanvas &c2 = display->AddTab("Fit.Prob");
    417     c2.Divide(1,3);
    418 
    419     CamDraw(c2, disp3,calcam,1, 1 , 4);
    420 
    421     // Reduced Sigmas
    422     TCanvas &c3 = display->AddTab("Red.Sigma");
    423     c3.Divide(2,3);
    424 
    425     CamDraw(c3, disp4,calcam,1, 2 , 2);
    426     CamDraw(c3, disp5,calcam,2, 2 , 2);
    427 
    428     // F-Factor Method
    429     TCanvas &c4 = display->AddTab("F-Factor");
    430     c4.Divide(3,3);
    431 
    432     CamDraw(c4, disp6,calcam,1, 3 , 2);
    433     CamDraw(c4, disp7,calcam,2, 3 , 2);
    434     CamDraw(c4, disp8,calcam,3, 3 , 2);
    435 
    436     // Blind Pixel Method
    437     TCanvas &c5 = display->AddTab("BlindPix");
    438     c5.Divide(2,3);
    439 
    440     CamDraw(c5, disp9, calcam,1, 2 , 2);
    441     CamDraw(c5, disp10,calcam,2, 2 , 2);
    442 
    443     // PIN Diode Method
    444     TCanvas &c6 = display->AddTab("PINDiode");
    445     c6.Divide(2,3);
    446 
    447     CamDraw(c6, disp11,calcam,1, 2 , 2);
    448     CamDraw(c6, disp12,calcam,2, 2 , 2);
    449 
    450     // Defects
    451     TCanvas &c7 = display->AddTab("Defects");
    452     c7.Divide(4,2);
    453 
    454     CamDraw(c7, disp13,calcam,1,4, 0);
    455     CamDraw(c7, disp14,calcam,2,4, 0);
    456     CamDraw(c7, disp18,calcam,3,4, 0);
    457     CamDraw(c7, disp19,calcam,4,4, 0);
    458 
    459     // BadCam
    460     TCanvas &c8 = display->AddTab("Defects");
    461     c8.Divide(3,2);
    462 
    463     CamDraw(c8, disp15,badcam,1,3, 0);
    464     CamDraw(c8, disp16,badcam,2,3, 0);
    465     CamDraw(c8, disp17,badcam,3,3, 0);
    466 
    467 
    468     // Valid flags
    469     TCanvas &c9 = display->AddTab("Validity");
    470     c9.Divide(4,2);
    471 
    472     CamDraw(c9, disp20,calcam,1,4,0);
    473     CamDraw(c9, disp21,calcam,2,4,0);
    474     CamDraw(c9, disp22,calcam,3,4,0);
    475     CamDraw(c9, disp23,calcam,4,4,0);
    476 
    477 
    478     // Pedestals
    479     TCanvas &c10 = display->AddTab("Pedestals");
    480     c10.Divide(2,3);
    481 
    482     CamDraw(c10,disp24,calcam,1,2,1);
    483     CamDraw(c10,disp25,calcam,2,2,2);
    484 
    485     // Rel. Times
    486     TCanvas &c11 = display->AddTab("Fitted Rel. Times");
    487     c11.Divide(3,3);
    488 
    489     CamDraw(c11,disp26,calcam,1,3,2);
    490     CamDraw(c11,disp27,calcam,2,3,2);
    491     CamDraw(c11,disp38,calcam,3,3,4);
    492 
    493     // Time Defects
    494     TCanvas &c12 = display->AddTab("Time Def.");
    495     c12.Divide(2,2);
    496 
    497     CamDraw(c12, disp29,calcam,1,2, 0);
    498     CamDraw(c12, disp30,calcam,2,2, 0);
    499 
    500     // Abs. Times
    501     TCanvas &c13 = display->AddTab("Abs. Times");
    502     c13.Divide(2,3);
    503 
    504     CamDraw(c13,disp31,calcam,1,2,2);
    505     CamDraw(c13,disp32,calcam,2,2,2);
     146  //
     147  // Now setup the new tasks for the calibration:
     148  // ---------------------------------------------------
     149  //
     150  MCalibrationQECam qecam;
     151  MJCalibration     calloop;
     152  calloop.SetColor(color);
     153  calloop.SetInput(&cruns);
     154  //  calloop.SetFullDisplay();
     155  //
     156  // Use as signal extractor MExtractSignal2:
     157  //
     158  calloop.SetExtractorLevel(2);
     159  //
     160  // Set the corr. cams:
     161  //
     162  calloop.SetQECam(qecam);
     163  calloop.SetBadPixels(badcam);
     164  //
     165  // The next two commands are for the display:
     166  //
     167  calloop.SetDisplay(display);
     168 
     169  //
     170  // Apply rel. time calibration:
     171  //
     172  calloop.SetRelTimeCalibration();
     173  //
     174  // Use as arrival time extractor MArrivalTimeCalc2:
     175  //
     176  calloop.SetArrivalTimeLevel(2);
     177 
     178  //
     179  // Do the event-loop:
     180  //
     181  cout << "***************************" << endl;
     182  cout << "** COMPUTING CALIBRATION **" << endl;
     183  cout << "***************************" << endl;
     184 
     185  if (!calloop.Process(pedcam))
     186    return;
     187 
     188  MBadPixelsCam          &badbad  = calloop.GetBadPixels();
     189  MCalibrationChargeCam  &calcam  = calloop.GetCalibrationCam();
     190  MCalibrationRelTimeCam &timecam = calloop.GetRelTimeCam();
    506191
    507192  /************************************************************************/
    … …  
    519204  MSrcPosCam          srccam;
    520205  MRawRunHeader       runhead;
     206  MExtractedSignalCam sigcam;
    521207
    522208  plist3.AddToList(&geomcam );
    523209  plist3.AddToList(&pedcam  );
    524210  plist3.AddToList(&calcam  );
    525   plist3.AddToList(&badcam  );
     211  plist3.AddToList(&qecam   );
     212  plist3.AddToList(&badbad  );
    526213  plist3.AddToList(&timecam );
    527214  plist3.AddToList(&sigcam  );
    528   plist3.AddToList(&histtime);
    529215  plist3.AddToList(&photevt);
    530216  plist3.AddToList(&pedphotcam);
    … …  
    537223  static_cast<MRead&>(read3).AddFiles(druns);
    538224
     225  MExtractSignal2     sigcalc;
     226  MArrivalTimeCalc2   timecalc;
    539227  MCalibrateData      photcalc;     
    540228  photcalc.SetCalibrationMode(MCalibrateData::kFfactor);  // !!! was only MCalibrate
    541   //  MPedPhotCalc    pedphotcalc;   // already done by MCalibrate Data
     229  // MPedPhotCalc     pedphotcalc;   // already done by MCalibrate Data
    542230  // MCerPhotCalc     cerphotcalc;  // already done by MCalibrate Data
    543231 
    … …  
    556244  write.AddContainer("MSrcPosCam"            , "RunHeaders");
    557245  write.AddContainer("MCalibrationChargeCam" , "RunHeaders");
     246  write.AddContainer("MCalibrationQECam"     , "RunHeaders");
    558247  //  write.AddContainer("MPedPhotCam","RunHeaders"); // Attention, was in Events - Tree!!
    559248  write.AddContainer("MPedestalCam"          , "RunHeaders");
    560   write.AddContainer("MHCalibrationRelTimeCam","RunHeaders");
     249  write.AddContainer("MCalibrationRelTimeCam", "RunHeaders");
    561250
    562251  write.AddContainer("MCerPhotEvt"   , "Events");
    … …  
    725414
    726415
     416MCalibrationCam::PulserColor_t FindColor(MDirIter* run)
     417{
     418 
     419  MCalibrationCam::PulserColor_t col = MCalibrationCam::kNONE;
     420
     421  TString filenames;
     422
     423  while (!(filenames=run->Next()).IsNull())
     424    {
     425
     426      filenames.ToLower();
     427
     428      if (filenames.Contains("green"))
     429        if (col == MCalibrationCam::kNONE)
     430          {
     431            cout << "Found colour: Green  in " << filenames << endl;
     432            col = MCalibrationCam::kGREEN;
     433          }
     434        else if (col != MCalibrationCam::kGREEN)
     435          {
     436            cout << "Different colour found in " << filenames << "... abort" << endl;
     437            return MCalibrationCam::kNONE;
     438          }
     439
     440      if (filenames.Contains("blue"))
     441        if (col == MCalibrationCam::kNONE)
     442          {
     443            cout << "Found colour: Blue  in " << filenames << endl;
     444            col = MCalibrationCam::kBLUE;
     445          }
     446        else if (col != MCalibrationCam::kBLUE)
     447          {
     448            cout << "Different colour found in " << filenames << "... abort" << endl;
     449            return MCalibrationCam::kNONE;
     450          }
     451
     452      if (filenames.Contains("uv"))
     453        if (col == MCalibrationCam::kNONE)
     454          {
     455            cout << "Found colour: Uv  in " << filenames << endl;
     456            col = MCalibrationCam::kUV;
     457          }
     458        else if (col != MCalibrationCam::kUV)
     459          {
     460            cout << "Different colour found in " << filenames << "... abort" << endl;
     461            return MCalibrationCam::kNONE;
     462          }
     463
     464      if (filenames.Contains("ct1"))
     465        if (col == MCalibrationCam::kNONE)
     466          {
     467            cout << "Found colour: Ct1  in " << filenames << endl;
     468            col = MCalibrationCam::kCT1;
     469          }
     470        else if (col != MCalibrationCam::kCT1)
     471          {
     472            cout << "Different colour found in " << filenames << "... abort" << endl;
     473            return MCalibrationCam::kNONE;
     474          }
     475     
     476    }
     477 
     478
     479     
     480  if (col == MCalibrationCam::kNONE)
     481    cout <<  "No colour found in filenames of runs: " << ((MRunIter*)run)->GetRunsAsString()
     482         << "... abort" << endl;
     483 
     484  return col;     
     485}
Note: See TracChangeset for help on using the changeset viewer.