Ignore:
Timestamp:
12/04/03 12:17:22 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/manalysis
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/manalysis/MCalibrationBlindPix.h

    r2525 r2599  
    5151  Float_t GetErrT()      const    { return fErrT;      }
    5252 
    53   Bool_t FillQ(Int_t q)            { return fHist->FillBPQ(q); }
    54   Bool_t FillT(Int_t t)            { return fHist->FillBPT(t); } 
    55   Bool_t FillRQvsT(Float_t rq, Int_t t) { return fHist->FillBPQvsN(rq,t); }   
     53  Bool_t FillQ(Int_t q)            { return fHist->FillBlindPixelQ(q); }
     54  Bool_t FillT(Int_t t)            { return fHist->FillBlindPixelT(t); } 
     55  Bool_t FillRQvsT(Float_t rq, Int_t t) { return fHist->FillBlindPixelQvsN(rq,t); }   
    5656 
    5757  Bool_t IsValid()                 { return fLambda > 0. || fErrLambda > 0.; }

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

    r2581 r2599  
    163163      }
    164164
    165     //
    166     // fRawEvt->GetNumPixels() does not work !!!!!!!!!!
    167     //
    168     fCalibrations->InitSize(577);
    169165
    170166    switch (fColor)
    … …  
    189185      }
    190186   
    191 
    192     // MTime does not work!!!!
    193 
    194     //    fEvtTime = (MTime*)pList->FindObject("MRawEvtTime");
    195     //    if (!fEvtTime)
    196     //      {
    197     //        *fLog << dbginf << "MTime could not be created ... ¡!¡!¡!¡!" << endl;       
    198     //      }
    199    
    200     // fEvtTime->SetTime(0.);
    201 
    202187   
    203188    return kTRUE;
    … …  
    222207    fNumHiGainSamples =  fRunHeader->GetNumSamplesHiGain();
    223208    fNumLoGainSamples =  fRunHeader->GetNumSamplesLoGain();
    224  
     209
     210    //
     211    // FIXME: The next statement simply does not work:
     212    //        fRawEvt->GetNumPixels() returns always 0
     213    // fCalibrations->InitSize(fRawEvt->GetNumPixels());
     214    //
     215
     216    fCalibrations->InitSize(577);   
     217
     218    for (Int_t i=0;i<577;i++)
     219      {
     220        MCalibrationPix &pix = (*fCalibrations)[i];
     221        pix.ChangePixId(i);
     222      }
     223   
    225224    return kTRUE;
    226225 
    … …  
    238237    fEvents++;
    239238
    240     Bool_t cosmic = kFALSE;
     239    Int_t cosmicpix = 0;
    241240
    242241    MCalibrationBlindPix &blindpixel = *(fCalibrations->GetBlindPixel());
    … …  
    251250        const Int_t pixid = pixel.GetPixelId();
    252251
    253         if (!fCalibrations->IsPixelUsed(pixid))
    254           if (!fCalibrations->AddPixel(pixid))
    255             *fLog << err << dbginf << "MCalibrationPix(" << pixid << ") could not be created !!" << endl;
    256        
    257252        Byte_t *ptr = pixel.GetHiGainSamples();
    258253        Byte_t mid  = pixel.GetIdxMaxHiGainSample();
    … …  
    270265            mid = pixel.GetIdxMaxLoGainSample();
    271266
    272             sum = (max == gkSaturationLimit              // overflow of LoGain ??? -> GimmeABreak!!!
    273                    ? fHistOverFlow++, gkLoGainOverFlow   // OUCH (Florian was maybe right)
    274                    : sum*gkConversionHiLo    );          // OUFF (Florian was wrong) !!
    275 
    276             //            *fLog << warn << "Warning: Saturation of HiGain reached in slice " << (int)mid << " !!! " << endl;
    277             //            *fLog << warn << "Max = " << max << endl;
     267            //
     268            //  FIXME: It seems the conversion HiGain LoGain is already
     269            //         performed in the data?!?
     270            //
     271            sum = (max > gkSaturationLimit              // overflow of LoGain ??? -> GimmeABreak!!!
     272                   ? fHistOverFlow++, gkLoGainOverFlow  // OUCH (Florian was maybe right)
     273                   : sum  );                            // OUFF (Florian was wrong) !!
     274            //                   : sum*gkConversionHiLo    );          // OUFF (Florian was wrong) !!
    278275
    279276            if (fHistOverFlow)
    … …  
    282279
    283280          }
    284        
    285281
    286282        MPedestalPix    &ped = (*fPedestals)[pixid];
    … …  
    298294
    299295        //
    300         // This is a very primitive check for the number of cosmics
     296        // This is a very primitive check for the number of cosmicpixs
    301297        // The cut will be applied in the fit, but for the blind pixel,
    302298        // we need to remove this event
    … …  
    305301        //
    306302
    307         if ((float)sum < pedes+5.*pedrms)
    308            cosmic = kTRUE;
     303        if ((float)sum < pedes+4.*pedrms)
     304           cosmicpix++;
    309305
    310306        Float_t rsum      = (float)sum - pedes;
    … …  
    314310           
    315311          case gkCalibrationBlindPixelId:
     312
    316313            //
    317314            // FIXME: This works only when the blind pixel ID is much larger than
    318315            //        the rest of the pixels (which is the case right now)
    319316            //
    320 //          if (!cosmic)
    321                if (!blindpixel.FillQ(sum))
     317            if (cosmicpix < 100.)
     318              {
     319                if (!blindpixel.FillQ(sum))
    322320                  *fLog << warn <<
    323                   "Overflow or Underflow occurred filling Blind Pixel sum = " << sum << endl;
    324 
    325             if (!blindpixel.FillT((int)mid))
    326               *fLog << warn <<
    327                 "Overflow or Underflow occurred filling Blind Pixel time = " << (int)mid << endl;
    328 
    329             if (!blindpixel.FillRQvsT(rsum,fEvents))
    330               *fLog << warn <<
    331                 "Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
    332 
     321                    "Overflow or Underflow occurred filling Blind Pixel sum = " << sum << endl;
     322
     323                if (!blindpixel.FillT((int)mid))
     324                  *fLog << warn <<
     325                    "Overflow or Underflow occurred filling Blind Pixel time = " << (int)mid << endl;
     326
     327                if (!blindpixel.FillRQvsT(rsum,fEvents))
     328                  *fLog << warn <<
     329                    "Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
     330              }
     331           
    333332          case gkCalibrationPINDiodeId:
    334333            if (!pindiode.FillQ(sum))
    … …  
    364363      } /* while (pixel.Next()) */
    365364
    366     if (cosmic)
     365    if (cosmicpix > 300.)
    367366        fCosmics++;
    368367
    369     fCalibrations->SetReadyToSave();
    370    
    371368    return kTRUE;
    372369}
    … …  
    405402
    406403  *fLog << GetDescriptor() << " Fitting the Normal Pixels" << endl;
     404
    407405  //
    408406  // loop over the pedestal events and check if we have calibration
    … …  
    411409    {
    412410
    413       if (fCalibrations->IsPixelUsed(pixid))
    414         {
    415 
    416           MCalibrationPix &pix = (*fCalibrations)[pixid];
    417 
    418           const Float_t ped    = (*fPedestals)[pixid].GetPedestal() * fNumHiGainSamples;
    419           const Float_t prms   = (*fPedestals)[pixid].GetPedestalRms() * fNumHiGainSamples;
    420 
    421           pix.SetPedestal(ped,prms);
    422 
    423           if (TESTBIT(fFlags,kUseTFits))
    424             pix.FitT();
    425 
    426           if (!pix.FitQ())
    427              continue;
    428 
    429         }
     411      MCalibrationPix &pix = (*fCalibrations)[pixid];
     412
     413      const Float_t ped    = (*fPedestals)[pixid].GetPedestal() * fNumHiGainSamples;
     414      const Float_t prms   = (*fPedestals)[pixid].GetPedestalRms() * fNumHiGainSamples;
     415
     416      pix.SetPedestal(ped,prms);
     417
     418      if (TESTBIT(fFlags,kUseTFits))
     419        pix.FitT();
     420     
     421      pix.FitQ();
    430422    }
    431423

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

    r2582 r2599  
    6161    fTitle = title ? title : "Storage container for the Calibration Information in the camera";
    6262
    63     fPixels     = new TClonesArray("MCalibrationPix",0);
     63    fPixels     = new TClonesArray("MCalibrationPix",1);
    6464    fBlindPixel = new MCalibrationBlindPix();
    6565    fPINDiode   = new MCalibrationPINDiode();
    … …  
    9292
    9393  //
    94   // Here it is important to use GetEntriesFast,
    95   // We get the array index of the last "filled" fPixel entry
    96   // (Not the number of "filled" fPixels!!)
     94  // Here we get the number of "filled" fPixels!!
    9795  //
    9896  return fPixels->GetEntriesFast();
    … …  
    116114    return *static_cast<MCalibrationPix*>(fPixels->UncheckedAt(i));
    117115}
    118 
    119 Bool_t MCalibrationCam::AddPixel(Int_t idx)
    120 {
    121 
    122   //
    123   // Check bounds first
    124   //
    125   if (!CheckBounds(idx))
    126     InitSize(idx);
    127 
    128   //
    129   // in case, new cannot allocate memory,
    130   // return FALSE
    131   //
    132   return (new ((*fPixels)[idx]) MCalibrationPix(idx));
    133 
    134 }
    135 
    136116
    137117// --------------------------------------------------------------------------
    … …  
    173153Bool_t MCalibrationCam::IsPixelFitted(Int_t idx) const
    174154{
    175   if (!IsPixelUsed(idx))
    176     return kFALSE;
    177 
    178155  return ((*this)[idx].GetRQ() > 0. && (*this)[idx].GetErrRQ() > 0.);
    179156}
    … …  
    208185    {
    209186
    210       Int_t id = 0;
    211      
    212187      TIter Next(fPixels);
    213188      MCalibrationPix *pix;
    214189      while ((pix=(MCalibrationPix*)Next()))
    215190        {
    216           if (!IsPixelUsed(id++))
    217             continue;
    218191          if (pix->FitQ())
    219192            nsuccess++;
    … …  
    222195  else                  // fit only the pixel with index i
    223196    {
    224       if (!IsPixelUsed(i))
    225         return 0;
    226197      if((*this)[i].FitQ())
    227198        nsuccess++;
    … …  
    247218  UShort_t nsuccess = 0;
    248219
    249   Int_t id = 0;
    250 
    251220  TIter Next(fPixels);
    252221  MCalibrationPix *pix;
    253222  while ((pix=(MCalibrationPix*)Next()))
    254223    {
    255       if (!IsPixelUsed(id++))
    256         continue;
    257224      if (pix->FitQ())
    258225        nsuccess++;
    … …  
    293260    {
    294261
    295       Int_t id = 0;
    296      
    297262      TIter Next(fPixels);
    298263      MCalibrationPix *pix;
    299264      while ((pix=(MCalibrationPix*)Next()))
    300265        {
    301           if (!IsPixelUsed(id++))
    302             continue;
    303           if (pix->FitT())
     266         if (pix->FitT())
    304267            nsuccess++;
    305268        }
    … …  
    331294  UShort_t nsuccess = 0;
    332295
    333   Int_t id = 0;
    334 
    335296  TIter Next(fPixels);
    336297  MCalibrationPix *pix;
    337298  while ((pix=(MCalibrationPix*)Next()))
    338299    {
    339       if (!IsPixelUsed(id++))
    340         continue;
    341300      if (pix->FitT())
    342301        nsuccess++;
    … …  
    391350  // we want to keep all pixel not used with a NULL pointer.
    392351  //
    393   fPixels->Expand(size);
    394   //
    395   // Set all entries to the null pointer. 
    396   // Later we fill the array per pixId with the contruction: new (fPixels[i]) MCalibrationPix(pixid)
    397   // To check, if pixels is already filled, we test the NULL pointer (see IsPixelUsed)
    398   //
    399   for (Int_t i=0; i< size; i++)
    400     {
    401       MCalibrationPix *pix = &(*this)[i];
    402       pix = NULL;
    403     }
     352  fPixels->ExpandCreate(size);
     353
    404354}
    405355 
    … …  
    413363    while ((pix=(MCalibrationPix*)Next()))
    414364    {
    415         if (!IsPixelUsed(id))
    416           continue;
    417 
    418         *fLog << id << ": ";
     365
     366        *fLog << id << ": " << pix->GetPed() << " " << pix->GetPedRms() << " Charges: " ;
    419367        *fLog << pix->GetQ() << " " << pix->GetRQ() << endl;
    420368
    … …  
    426374Bool_t MCalibrationCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const
    427375{
    428 
    429   if (!IsPixelFitted(idx))
    430     return kFALSE;
    431376
    432377  switch (type)
    … …  
    468413      val = (*this)[idx].GetErrRQ();
    469414      break;
     415    case 12:
     416      val = (*this)[idx].GetPheFFactorMethod();
     417      break;
     418    case 13:
     419      val = (*this)[idx].GetConversionFFactorMethod();
     420      break;
    470421    default:
    471422      return kFALSE;
    … …  
    474425}
    475426
    476 void MCalibrationCam::DrawPixelContent(Int_t num) const
    477 {
    478     *fLog << warn << "MCalibrationCam::DrawPixelContent - not available." << endl;
     427void MCalibrationCam::DrawPixelContent(Int_t idx) const
     428{
     429
     430  (*this)[idx].Draw();
     431
    479432}
    480433

  • trunk/MagicSoft/Mars/manalysis/MCalibrationCam.h

    r2525 r2599  
    7777  Bool_t CheckBounds(Int_t i) const;
    7878
    79   Bool_t AddPixel(Int_t idx);
    80 
    8179  void Print(Option_t *o="") const;
    8280 

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

    r2581 r2599  
    4040using namespace std;
    4141
    42 static const TString gsDefHTitle = "Calibration Histograms Pixel ";
    4342// --------------------------------------------------------------------------
    4443//
    4544// Default Constructor.
    4645//
    47 MCalibrationPix::MCalibrationPix(Int_t pix, const char *name, const char *title)
    48     : fPixId(pix)
     46MCalibrationPix::MCalibrationPix(const char *name, const char *title)
     47    : fPixId(-1),
     48      fQ(-1.),
     49      fErrQ(-1.),
     50      fSigmaQ(-1.),
     51      fErrSigmaQ(-1.),
     52      fQProb(-1.),
     53      fPed(-1.),
     54      fPedRms(-1.),
     55      fT(-1.),
     56      fSigmaT(-1.),
     57      fTProb(-1.),
     58      fRQ(-1.),
     59      fErrRQ(-1.),
     60      fFactor(1.3),
     61      fPheFFactorMethod(-1.),
     62      fConversionFFactorMethod(-1.)
    4963{
    5064
    … …  
    5266  fTitle = title ? title : "Container of the MHCalibrationPixels and the fit results";
    5367
    54   fHist = new MHCalibrationPixel(fPixId,"MHCalibrationPixel",gsDefHTitle.Data()+fPixId);
    55 
    56   fQ   = fErrQ     = 0.;
    57   fPed = fPedRms   = 0.;
    58   fT   = fSigmaT  = 0.;
    59   fRQ  = fErrRQ = 0.;
    60   fSigmaQ = fErrSigmaQ = 0.;
    61   fQProb  = 0.;
    62 
     68  fHist = new MHCalibrationPixel("MHCalibrationPixel","Calibration Histograms Pixel");
    6369}
    6470
    … …  
    6773  delete fHist;
    6874}
     75
     76
     77void MCalibrationPix::ChangePixId(Int_t i)
     78{
     79 
     80  fPixId = i;
     81  fHist->ChangeHistId(i);
     82 
     83}
     84
    6985
    7086// ------------------------------------------------------------------------
    … …  
    84100
    85101  if (fPed && fPedRms)
    86     fHist->SetLowerFitRange(fPed + 3.5*fPedRms);
     102    fHist->SetLowerFitRange(fPed + 2.0*fPedRms);
    87103  else
    88104    *fLog << warn << "Cannot set lower fit range to suppress cosmics: Pedestals not available" << endl;
    … …  
    101117  fQProb     = fHist->GetQProb();
    102118
    103   if (fPed)
     119  if ((fPed > 0.)  && (fPedRms > 0.))
     120    {
     121     
    104122    fRQ      = fQ - fPed;
    105   if (fPedRms)
    106123    fErrRQ   = TMath::Sqrt(fErrQ*fErrQ + fPedRms*fPedRms);
    107  
     124
     125    fPheFFactorMethod =
     126      fFactor
     127      * fRQ * fRQ
     128      / (fSigmaQ * fSigmaQ - fPedRms*fPedRms) ;
     129
     130    fConversionFFactorMethod = fPheFFactorMethod / fRQ ;
     131   
     132    }
    108133
    109134  return kTRUE;
    … …  
    142167}
    143168
    144 void MCalibrationPix::Test()
    145 {
    146   *fLog << "TEST: pixid: " << fPixId << endl; 
    147 }

  • trunk/MagicSoft/Mars/manalysis/MCalibrationPix.h

    r2544 r2599  
    1212private:
    1313
    14   //
    15   // FIXME: Derive class from MCerphotPix ??
    16   //
    1714  Int_t   fPixId;           // the pixel Id
    1815 
    … …  
    3229  Float_t fRQ;               // The reduced mean charge after the fit
    3330  Float_t fErrRQ;            // The error of the reduced mean charge after the fit 
    34  
     31
     32  Float_t fFactor;            // The F-factor
     33  Float_t fPheFFactorMethod;  // The number of Phe's calculated after the F-factor method
     34  Float_t fConversionFFactorMethod; // The conversion factor to Phe's calculated after the F-factor method
     35   
    3536  MHCalibrationPixel *fHist; // Pointer to the histograms performing the fits, etc. 
    3637 
    3738public:
    3839
    39   MCalibrationPix(Int_t pix=-1, const char *name=NULL, const char *title=NULL);
     40  MCalibrationPix(const char *name=NULL, const char *title=NULL);
    4041  ~MCalibrationPix();
    4142 
    … …  
    6667  Bool_t IsValid()      const           { return fRQ >=0 || fErrRQ >= 0; }
    6768  Int_t  GetPixId()     const           { return fPixId;   }
    68 
     69  void ChangePixId(Int_t i);
     70 
    6971  Bool_t FitQ();
    7072  Bool_t FitT();
    … …  
    7375  virtual void Draw(Option_t *opt="")     { fHist->Draw(opt); }
    7476 
    75   void Test();
    76    
     77  Float_t GetPheFFactorMethod() const        { return fPheFFactorMethod;  } 
     78  Float_t GetConversionFFactorMethod() const { return fConversionFFactorMethod;  }
     79 
    7780  ClassDef(MCalibrationPix, 1)  // Storage Container for Calibration information of one pixel
    7881};

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

    r2536 r2599  
    6060
    6161    AddToBranchList("fHiGainPixId");
    62     //AddToBranchList("fLoGainPixId");
    6362    AddToBranchList("fHiGainFadcSamples");
    64     //AddToBranchList("fLoGainFadcSamples");
    6563}
    6664
    … …  
    9896    fNumHiGainSamples =  fRunheader->GetNumSamplesHiGain();
    9997
     98    fPedestals->InitSize(fRunheader->GetNumPixel());
     99
    100100    return kTRUE;
    101101
    … …  
    105105Int_t MPedCalcPedRun::Process()
    106106{
     107
    107108    MRawEvtPixelIter pixel(fRawEvt);
    108109
    109110    while (pixel.Next())
    110111    {
    111               Byte_t *ptr = pixel.GetHiGainSamples();
     112             Byte_t *ptr = pixel.GetHiGainSamples();
    112113        const Byte_t *end = ptr + fRawEvt->GetNumHiGainSamples();
    113114
    … …  
    115116        const Float_t higainrms = CalcHiGainRms(ptr, end, higainped);
    116117
    117         //const Float_t higainpederr = CalcHiGainMeanErr(higainrms);
    118         //const Float_t higainrmserr = CalcHiGainRmsErr(higainrms);
    119 
    120118        const UInt_t pixid = pixel.GetPixelId();
    121119        MPedestalPix &pix = (*fPedestals)[pixid];
    122120
    123121        pix.Set(higainped, higainrms);
    124        //pix.SetPedestalRms(higainpederr, higainrmserr);
     122
    125123    }
    126124
Note: See TracChangeset for help on using the changeset viewer.