Changeset 3202 for trunk/MagicSoft


Ignore:
Timestamp:
02/16/04 16:00:57 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r3201 r3202  
    1818     - does not extract signal from Blind Pixel any more, searches
    1919       for MExtractedSignalBlindPixel and fills the hists from there
     20 
     21   * macros/calibration.C
     22     - introduce the blind pixel and PIN diode extraction in the macro
    2023
    2124   * manalysis/MPedestalCam.h

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

    r3187 r3202  
    114114    //
    115115
    116     MCalibrationCam     calcam;
    117     MExtractedSignalCam sigcam;
     116    MCalibrationCam         calcam;
     117    MExtractedSignalCam     sigcam;
    118118   
    119119    plist2.AddToList(&geomcam);
    … …  
    122122    plist2.AddToList(&sigcam);
    123123
    124 
    125124    //tasks
    126125    MReadMarsFile read2("Events", calname);
    127126    read2.DisableAutoScheme();
    128127
    129 
     128    MExtractPINDiode      pincalc;
     129    MExtractBlindPixel    blindcalc;
    130130    MExtractSignal        sigsig;
    131     MCalibrationCalc     calcalc;
    132 
     131    MCalibrationCalc      calcalc;
     132
     133    MFillH fillpin("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode");
    133134    //
    134135    // As long, as we don't have digital modules,
    … …  
    146147    tlist2.AddToList(&read2);
    147148    tlist2.AddToList(&geomapl);
     149    tlist2.AddToList(&blindcalc);
     150    tlist2.AddToList(&pincalc);
    148151    tlist2.AddToList(&sigsig);
    149152    //
    … …  
    154157    //
    155158    tlist2.AddToList(&calcalc);
    156 
     159    tlist2.AddToList(&fillpin);
    157160    //
    158161    // Create and setup the eventloop

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

    r3185 r3202  
    6666    MExtractSignal  sigcalc;
    6767
    68 
    69     MExtractPINDiode pidcalc;
    70     MExtractedSignalPINDiode pindiode;
    71     //    MHCalibrationChargePINDiode pinhist;
    7268    //
    7369    // Set the extraction range higher:
    … …  
    8278    //
    8379    MFillH fill("MHPedestalCam", "MExtractedSignalCam");
    84     //    MFillH fillp("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode");
    8580
    8681    tlist.AddToList(&read);
    8782    tlist.AddToList(&geomapl);
    8883    tlist.AddToList(&sigcalc);
    89     tlist.AddToList(&pidcalc);
    9084    tlist.AddToList(&pedcalc);
    9185    tlist.AddToList(&fill);
    92     //    tlist.AddToList(&fillp);
    9386
    9487    MGeomCamMagic  geomcam;
    … …  
    9891    plist.AddToList(&pedcam);
    9992    plist.AddToList(&hpedcam);
    100     plist.AddToList(&pindiode);
    101     //    plist.AddToList(&pinhist);
    10293
    10394    //
    10495    // Create and setup the eventloop
    105      //
     96    //
    10697    MEvtLoop evtloop;
    10798    evtloop.SetParList(&plist);
    … …  
    253244    // thus take the sliding window
    254245    //         
     246    MExtractPINDiode     pincalc;
     247    MExtractBlindPixel   blindcalc;
    255248    MExtractSignal2      sigcalc2;
    256249    MArrivalTimeCalc2    timecalc;
    … …  
    258251
    259252    MFillH filltime("MHCalibrationRelTimeCam", "MArrivalTime");
     253    MFillH fillpin("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode");
     254
    260255    //
    261256    // Set the range (other than default)
    … …  
    314309
    315310    tlist2.AddToList(&read2);
     311    tlist2.AddToList(&blindcalc);
     312    tlist2.AddToList(&pincalc);
    316313    tlist2.AddToList(&sigcalc2);
    317314    //
    … …  
    326323    tlist2.AddToList(&timecalc);
    327324    tlist2.AddToList(&filltime);
     325    tlist2.AddToList(&fillpin);
    328326    //
    329327    tlist2.AddToList(&calcalc);

  • trunk/MagicSoft/Mars/manalysis/MPedestalCam.cc

    r3160 r3202  
    8686// Get the size of the MPedestalCam
    8787//
    88 Int_t MPedestalCam::GetSize() const
     88UInt_t MPedestalCam::GetSize() const
    8989{
    9090  return fArray->GetEntriesFast();

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

    r3197 r3202  
    3434//   for every pixel. It is filled in the following way:
    3535//
    36 //   ProProcess: Search for MPedestalCam, MExtractedSignalCam
     36//   ProProcess: Search for MPedestalCam, MExtractedSignalCam and MExtractedSignalBlindPixel
    3737//               Initialize MCalibrationCam
    3838//               Initialize pulser light wavelength
    … …  
    6969//   MPedestalCam
    7070//   MExtractedSignalCam
     71//   MExtractedSignalBlindPixel
    7172//
    7273//  Output Containers:
    … …  
    102103#include "MExtractedSignalCam.h"
    103104#include "MExtractedSignalPix.h"
     105#include "MExtractedSignalBlindPixel.h"
    104106
    105107#include "MCalibrationBlindPix.h"
    … …  
    109111using namespace std;
    110112
    111 const UInt_t MCalibrationCalc::fgBlindPixelId    = 559;
    112 const UInt_t MCalibrationCalc::fgPINDiodeId      = 9999;
    113 const Byte_t MCalibrationCalc::fgSaturationLimit = 254;
    114 const Int_t  MCalibrationCalc::fgBlindPixelFirst = 3;
    115 const Int_t  MCalibrationCalc::fgBlindPixelLast  = 14;
    116 const Int_t  MCalibrationCalc::fgBlindPixelSinglePheCut = 400;
     113const UInt_t MCalibrationCalc::fgBlindPixelIdx   = 559;
     114const UInt_t MCalibrationCalc::fgPINDiodeIdx     = 9999;
     115const UInt_t MCalibrationCalc::fgBlindPixelSinglePheCut = 400;
    117116
    118117// --------------------------------------------------------------------------
    … …  
    134133
    135134    Clear();
    136     SetBlindPixelRange();
     135    SetBlindPixelIdx();
     136    SetPINDiodeIdx();
    137137}
    138138
    … …  
    146146    CLRBIT(fFlags, kHiGainOverFlow);
    147147    CLRBIT(fFlags, kLoGainOverFlow);
    148 
    149     fBlindPixelFirst   = 0;
    150     fBlindPixelLast    = 0;
    151148
    152149    fNumBlindPixelSinglePhe = 0;
    … …  
    159156
    160157    fColor = kECT1;
    161 }
    162 
    163 void MCalibrationCalc::SetBlindPixelRange(Int_t first, Int_t last)
    164 {
    165  
    166   fBlindPixelFirst = first;
    167   fBlindPixelLast  = last;
    168 
    169158}
    170159
    … …  
    251240        return kFALSE;
    252241      }
     242
     243    fBlindPixel = (MExtractedSignalBlindPixel*)pList->FindObject("MExtractedSignalBlindPixel");
     244    if (!fBlindPixel)
     245      {
     246        *fLog << err << dbginf << "Cannot find MExtractedSignalBlindPixel ... aborting" << endl;
     247        return kFALSE;
     248      }
    253249   
    254250    return kTRUE;
    … …  
    303299
    304300        // Exclude the blind pixel and the PIN Diode from normal pixel calibration:
    305         if (i == fgBlindPixelId)
     301        if (i == fBlindPixelIdx)
    306302          pix.SetExcluded();
    307303
    308         if (i == fgPINDiodeId)
     304        if (i == fPINDiodeIdx)
    309305          pix.SetExcluded();
    310306
    … …  
    381377{
    382378
    383   //
    384   // Initialize pointers to blind pixel, PIN Diode and individual pixels
    385   //
    386   MCalibrationBlindPix &blindpixel = *(fCalibrations->GetBlindPixel());
    387379 
    388380  MRawEvtPixelIter pixel(fRawEvt);
    … …  
    391383  // Create a loop to fill the calibration histograms
    392384  // Search for: a signal in MExtractedSignalCam
     385  // Search for: a signal in MExtractedSignalBlindPixel
    393386  // Fill histograms with:
    394387  //             charge
    395388  //             charge vs. event nr.
    396389  //
     390  //
     391  // Initialize pointers to blind pixel and individual pixels
     392  //
     393  // FIXME: filling the bind pixel histograms in this class is preliminary
     394  //        and will be replaced soon to fill them with MFillH
     395  //
     396  MCalibrationBlindPix       &blindpixel = *(fCalibrations->GetBlindPixel());
     397  MExtractedSignalBlindPixel &blindsig   = (*fBlindPixel);
     398
     399  const UInt_t signal = blindsig.GetExtractedSignal();
     400 
     401  if (!blindpixel.FillCharge(signal))
     402    *fLog << warn <<
     403      "Overflow or Underflow occurred filling Blind Pixel sum = " << signal << endl;
     404
     405  blindpixel.FillGraphs(signal,0);
     406 
     407  TH1I *hist;
     408 
     409  if (signal > fBlindPixelSinglePheCut)
     410    {
     411      hist = (blindpixel.GetHist())->GetHSinglePheFADCSlices();
     412      fNumBlindPixelSinglePhe++;
     413    }
     414  else
     415    {
     416      hist = (blindpixel.GetHist())->GetHPedestalFADCSlices();
     417      fNumBlindPixelPedestal++;
     418    }
     419
     420  pixel.Jump(fBlindPixelIdx);
     421 
     422  const Byte_t *ptr = pixel.GetHiGainSamples();
     423
     424  for (Int_t i=1;i<16;i++)
     425    hist->Fill(i,*ptr++);
     426 
     427  ptr = pixel.GetLoGainSamples();
     428  for (Int_t i=16;i<31;i++)
     429    hist->Fill(i,*ptr++);
     430
     431  pixel.Reset();
     432 
    397433  while (pixel.Next())
    398434    {
    … …  
    400436      const UInt_t pixid = pixel.GetPixelId();
    401437     
    402       MCalibrationPix &pix = (*fCalibrations)[pixid];
    403      
    404       MExtractedSignalPix &sig =  (*fSignals)[pixid];
     438      MCalibrationPix            &pix   =  (*fCalibrations)[pixid];
     439      MExtractedSignalPix        &sig   =  (*fSignals)     [pixid];
    405440     
    406441      const Float_t sumhi  = sig.GetExtractedSignalHiGain();
    … …  
    408443
    409444      Float_t abstime = 0.;
     445
    410446      if (sig.IsLoGainUsed())
    411447        abstime = (Float_t)pixel.GetIdxMaxLoGainSample();
    … …  
    413449        abstime = (Float_t)pixel.GetIdxMaxHiGainSample();
    414450
    415       switch(pixid)
     451      if (pix.IsExcluded())
     452        continue;
     453     
     454      pix.FillGraphs(sumhi,sumlo);
     455
     456      if (sig.IsLoGainUsed())
    416457        {
    417458         
    418         case fgBlindPixelId:
    419 
    420           if (TESTBIT(fFlags,kUseBlindPixelFit))
    421             {
     459          if (!pix.FillChargeLoGain(sumlo))
     460            *fLog << warn << "Could not fill Lo Gain Charge of pixel: " << pixid
     461                  << " signal = " << sumlo << endl;
    422462         
    423               Byte_t *ptr = pixel.GetHiGainSamples();
    424 
    425               Int_t blindpixelsumhi = 0;
    426               Int_t blindpixelsumlo = 0;
    427               //
    428               // We need a dedicated signal extractor for the blind pixel
    429               //
    430               Int_t diff  = 0;
    431               Int_t last  = fBlindPixelLast;
    432               Int_t first = fBlindPixelFirst;
    433 
    434               if (last > 15)
    435                 {
    436                   diff = last - 15;
    437                   last = 15;
    438                 }
    439 
    440               Byte_t *start   = ptr + first - 1;
    441               Byte_t *end     = ptr + last  - 1;
    442 
    443               ptr = start;
    444 
    445               Int_t sum = 0;
    446              
    447               while (ptr<=end)
    448                 {
    449                   sum += *ptr;
    450                   ptr++;
    451                 }
    452 
    453               if (diff > 0)
    454                 {
    455                   ptr = pixel.GetLoGainSamples();
    456                   end = ptr + diff - 1;
    457                  
    458                   while (ptr<=end)
    459                     {
    460                       sum += *ptr;
    461                       ptr++;
    462                     }
    463                 }
    464              
    465               blindpixelsumhi = sum;
    466 
    467               ptr = pixel.GetLoGainSamples();
    468 
    469               start   = ptr + fBlindPixelFirst - 1;
    470               end     = ptr + fBlindPixelLast;
    471 
    472               ptr = start;
    473 
    474               sum = 0;
    475              
    476               while (++ptr<end)
    477                 sum += *ptr;
    478 
    479               blindpixelsumlo = sum;
    480 
    481               //              if (!CalcSignalBlindPixel(hiptr, blindpixelsumhi))
    482               //                return kFALSE;
    483 
    484               if (!blindpixel.FillCharge(blindpixelsumhi))
    485                 *fLog << warn <<
    486                   "Overflow or Underflow occurred filling Blind Pixel sum = " << blindpixelsumhi << endl;
    487              
    488               //              Byte_t *loptr = pixel.GetLoGainSamples();
    489               //              CalcSignalBlindPixel(loptr, blindpixelsumlo);
    490              
    491               blindpixel.FillGraphs(blindpixelsumhi,blindpixelsumlo);
     463          if (!pix.FillAbsTimeLoGain(abstime))
     464            *fLog << warn << "Could not fill Lo Gain Abs. Time of pixel: "
     465                  << pixid << " time = " << abstime << endl;
     466        }
     467      else
     468        {
     469          if (!pix.FillChargeHiGain(sumhi))
     470            *fLog << warn << "Could not fill Hi Gain Charge of pixel: " << pixid
     471                  << " signal = " << sumhi << endl;
    492472         
    493               TH1I *hist;
    494 
    495               if (blindpixelsumhi > fBlindPixelSinglePheCut)
    496                 {
    497                   hist = (blindpixel.GetHist())->GetHSinglePheFADCSlices();
    498                   fNumBlindPixelSinglePhe++;
    499                 }
    500               else
    501                 {
    502                   hist = (blindpixel.GetHist())->GetHPedestalFADCSlices();
    503                   fNumBlindPixelPedestal++;
    504                 }
    505              
    506               ptr = pixel.GetHiGainSamples();
    507               for (Int_t i=1;i<16;i++)
    508                 hist->Fill(i,*ptr++);
    509 
    510               ptr = pixel.GetLoGainSamples();
    511               for (Int_t i=16;i<31;i++)
    512                 hist->Fill(i,*ptr++);
    513 
    514             } /* if use blind pixel */
    515          
    516           break;
    517         default:
    518              
    519           if (pix.IsExcluded())
    520             continue;
    521 
    522           pix.FillGraphs(sumhi,sumlo);
    523 
    524           if (sig.IsLoGainUsed())
    525             {
    526              
    527               if (!pix.FillChargeLoGain(sumlo))
    528                 *fLog << warn << "Could not fill Lo Gain Charge of pixel: " << pixid
    529                       << " signal = " << sumlo << endl;
    530 
    531               if (!pix.FillAbsTimeLoGain(abstime))
    532                 *fLog << warn << "Could not fill Lo Gain Abs. Time of pixel: "
    533                       << pixid << " time = " << abstime << endl;
    534               /*
    535                 if (!pix.FillRelTimeLoGain(reltime))
    536                 *fLog << warn << "Could not fill Lo Gain Rel. Time of pixel: "
    537                     << pixid << " time = " << reltime << endl;
    538               */
    539             } /* if (sig.IsLoGainUsed()) */
    540           else
    541             {
    542               if (!pix.FillChargeHiGain(sumhi))
    543                 *fLog << warn << "Could not fill Hi Gain Charge of pixel: " << pixid
    544                       << " signal = " << sumhi << endl;
    545              
    546               if (!pix.FillAbsTimeHiGain(abstime))
    547                 *fLog << warn << "Could not fill Hi Gain Abs. Time of pixel: "
    548                       << pixid << " time = " << abstime << endl;
    549               /*
    550               if (!pix.FillRelTimeHiGain(reltime))
    551                     *fLog << warn << "Could not fill Hi Gain Rel. Time of pixel: "
    552                           << pixid << " time = " << reltime << endl;
    553               */
    554             } /* else (sig.IsLoGainUsed()) */
    555           break;
    556          
    557         } /* switch(pixid) */
     473          if (!pix.FillAbsTimeHiGain(abstime))
     474            *fLog << warn << "Could not fill Hi Gain Abs. Time of pixel: "
     475                  << pixid << " time = " << abstime << endl;
     476        }
    558477     
    559478    } /* while (pixel.Next()) */
    … …  
    584503
    585504      //
     505      // retrieve the histogram containers
     506      //
     507      MHCalibrationBlindPixel *hist = blindpixel.GetHist();
     508         
     509      //
    586510      // retrieve mean and sigma of the blind pixel pedestal,
    587511      // so that we can use it for the fit
    588512      //
    589       Float_t pedestal;
    590       Float_t pederr;
    591       Float_t pedsigma;
    592       Float_t pedsigmaerr;
    593      
    594       const ULong_t nentries    = fPedestals->GetTotalEntries();
    595       const Int_t   nslices     = fBlindPixelLast-fBlindPixelFirst+1;
    596       const Float_t sqrslice    = TMath::Sqrt((Float_t)nslices);
    597 
    598       MPedestalPix    &pedpix  = (*fPedestals)[fgBlindPixelId];
    599       pedestal    = pedpix.GetPedestal()*nslices;
    600       pederr      = pedpix.GetPedestalRms()*nslices/nentries;
    601       pedsigma    = pedpix.GetPedestalRms()*sqrslice;
    602       pedsigmaerr = pederr/2.;
    603       //
    604       // retrieve the histogram containers
    605       //
    606       MHCalibrationBlindPixel *hist = blindpixel.GetHist();
    607      
    608       hist->SetMeanPedestal(pedestal);
    609       hist->SetMeanPedestalErr(pederr);
    610       hist->SetSigmaPedestal(pedsigma);
    611       hist->SetSigmaPedestalErr(pedsigmaerr);
    612  
     513      const UInt_t nentries    = fPedestals->GetTotalEntries();
     514      const UInt_t nslices     = 12;
     515      const Float_t sqrslice   = TMath::Sqrt((Float_t)nslices);
     516
     517      MPedestalPix &pedpix  = (*fPedestals)[fBlindPixelIdx];
     518      if (&pedpix)
     519        {
     520          const Float_t pedestal    = pedpix.GetPedestal()*nslices;
     521          const Float_t pederr      = pedpix.GetPedestalRms()*nslices/nentries;
     522          const Float_t pedsigma    = pedpix.GetPedestalRms()*sqrslice;
     523          const Float_t pedsigmaerr = pederr/2.;
     524         
     525          hist->SetMeanPedestal(pedestal);
     526          hist->SetMeanPedestalErr(pederr);
     527          hist->SetSigmaPedestal(pedsigma);
     528          hist->SetSigmaPedestalErr(pedsigmaerr);
     529        }
     530     
    613531      if (!blindpixel.FitCharge())
    614532        {
    … …  
    708626
    709627
    710 Bool_t MCalibrationCalc::CalcSignalBlindPixel(Byte_t *ptr, Float_t &signal) const
    711 {
    712 
    713   Byte_t *newptr  = ptr;
    714   Byte_t *start   = ptr + fBlindPixelFirst-1;
    715   Byte_t *end     = ptr + fBlindPixelLast;
    716 
    717   Byte_t sum = 0;
    718   Int_t  sat = 0;
    719  
    720   newptr = start;
    721 
    722   while (ptr<end)
    723     {
    724       sum += *ptr;
    725       if (*ptr++ >= fgSaturationLimit)
    726         sat++;
    727     }
    728 
    729   if (sat)
    730   {
    731       *fLog << err << "HI Gain Saturation occurred in the blind pixel! "
    732             << " Do not know yet how to treat this ... aborting " << endl;
    733       *fLog << "If you need absolutely any other kind of calibration, "
    734             << " use SkipBlindPixelFit() " << endl;
    735       return kFALSE;
    736   }
    737 
    738   signal = (Float_t)sum;
    739 
    740   return kTRUE;
    741 }
Note: See TracChangeset for help on using the changeset viewer.