Changeset 2445 for trunk


Ignore:
Timestamp:
10/30/03 17:09:40 (21 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/MagicSoft/Mars/Changelog

    r2442 r2445  
    11                                                 -*-*- END OF LINE -*-*-
     2
     3  2003/10/30: Thomas Bretz
     4
     5   * manalysis/MCerPhotEvt.[h,cc]:
     6     - fixed a bug in the new Lut-stuff. Sometimes pixels where
     7       considered existing, because there where no mark for
     8       empty entries in the Lut.
     9     - all loops ignored pixel with index 0 and used it as reference
     10       pixel - this is wrong, because pixel 0 must not exist at all.
     11       Now all loops are starting with pixel 0.
     12
     13   * mimage/MImgCleanStd.[h,cc]:
     14     - renamed various local variables from 'id' to 'idx'
     15     - in clean step 4 we assumed that a pixel with idx2 is existing
     16       - this is a dangerous assumption. It is checked now.
     17
     18
    219
    320  2003/10/29: Thomas Bretz
  • trunk/MagicSoft/Mars/manalysis/MCerPhotEvt.cc

    r2416 r2445  
    124124Bool_t MCerPhotEvt::IsPixelExisting(Int_t id) const
    125125{
    126     const MCerPhotPix *pix = GetPixById(id);
    127     return pix ? kTRUE : kFALSE;
     126    return GetPixById(id) ? kTRUE : kFALSE;
    128127}
    129128
     
    163162    Float_t minval = FLT_MAX;
    164163
    165     for (UInt_t i=1; i<fNumPixels; i++)
     164    for (UInt_t i=0; i<fNumPixels; i++)
    166165    {
    167166        const MCerPhotPix &pix = (*this)[i];
     
    170169
    171170        const UInt_t id = pix.GetPixId();
    172         if (id>=n)
     171        if (id<0 || id>=n)
    173172            continue;
    174173
     
    200199    Float_t maxval = -FLT_MAX;
    201200
    202     for (UInt_t i=1; i<fNumPixels; i++)
     201    for (UInt_t i=0; i<fNumPixels; i++)
    203202    {
    204203        const MCerPhotPix &pix = (*this)[i];
     
    207206
    208207        const UInt_t id = pix.GetPixId();
    209         if (id>=n)
     208        if (id<0 || id>=n)
    210209            continue;
    211210
     
    229228        return -5.;
    230229
    231     Float_t minval = (*this)[0].GetNumPhotons()/(*this)[0].GetErrorPhot();
    232 
    233     for (UInt_t i=1; i<fNumPixels; i++)
     230    Float_t minval = FLT_MAX;
     231
     232    for (UInt_t i=0; i<fNumPixels; i++)
    234233    {
    235234        const MCerPhotPix &pix = (*this)[i];
     
    259258    Float_t maxval = -FLT_MAX;
    260259
    261     for (UInt_t i=1; i<fNumPixels; i++)
     260    for (UInt_t i=0; i<fNumPixels; i++)
    262261    {
    263262        const MCerPhotPix &pix = (*this)[i];
     
    289288    Float_t minval = FLT_MAX;
    290289
    291     for (UInt_t i=1; i<fNumPixels; i++)
     290    for (UInt_t i=0; i<fNumPixels; i++)
    292291    {
    293292        const MCerPhotPix &pix = (*this)[i];
     
    319318    Float_t maxval = -FLT_MAX;
    320319
    321     for (UInt_t i=1; i<fNumPixels; i++)
     320    for (UInt_t i=0; i<fNumPixels; i++)
    322321    {
    323322        const MCerPhotPix &pix = (*this)[i];
     
    356355// try to search in the array.
    357356//
    358 MCerPhotPix *MCerPhotEvt::GetPixById(int idx) const
    359 {
     357MCerPhotPix *MCerPhotEvt::GetPixById(Int_t idx) const
     358{
     359    if (idx<0)
     360        return 0;
     361
    360362    if (fLut.GetSize()>0)
    361         return idx>=0 && idx<fLut.GetSize() ? (MCerPhotPix*)(fPixels->UncheckedAt(fLut[idx])) : 0;
     363    {
     364        if (idx>=fLut.GetSize())
     365            return 0;
     366
     367        return fLut[idx]<0 ? 0 : (MCerPhotPix*)(fPixels->UncheckedAt(fLut[idx]));
     368    }
    362369
    363370    TIter Next(fPixels);
  • trunk/MagicSoft/Mars/manalysis/MCerPhotEvt.h

    r2416 r2445  
    3939        //
    4040        if (idx>=fLut.GetSize())
     41        {
     42            const Int_t n = fLut.GetSize();
    4143            fLut.Set(idx+1);
     44            for (int i=n; i<idx; i++)
     45                fLut[i] = -1;
     46        }
    4247
    4348        fLut[idx] = fNumPixels;
     
    6671    void RemoveUnusedPixels();
    6772
    68     MCerPhotPix *GetPixById(int idx) const;// { return idx>=0 && idx<fLut.GetSize() ? (MCerPhotPix*)(fPixels->UncheckedAt(fLut[idx])) : 0; } // Return a pointer to the pixel with the requested id. NULL if it doesn't exist.
     73    MCerPhotPix *GetPixById(Int_t idx) const;
    6974
    7075    void Reset();
  • trunk/MagicSoft/Mars/mimage/MImgCleanStd.cc

    r2239 r2445  
    329329    // set them to 'unused' state if necessary
    330330    //
     331
    331332    for (Int_t i=0; i<entries; i++ )
    332333    {
     
    373374        MCerPhotPix &pix = (*fEvt)[i];
    374375
    375         const Int_t id = pix.GetPixId();
     376        const Int_t idx = pix.GetPixId();
    376377
    377378        const Float_t  entry = pix.GetNumPhotons();
    378         const Double_t ratio = fCam->GetPixRatio(id);
     379        const Double_t ratio = fCam->GetPixRatio(idx);
    379380
    380381        // COBB: '<=' to skip entry=noise=0
     
    422423    // (MCerPhotEvt::IsPixelUsed) all the time.
    423424    //
     425    // We allocate the array ourself because the TArrays always do
     426    // range check which slows down the access to the array
     427    // by 25-50%
     428    //
    424429    Byte_t *ispixused = new Byte_t[fCam->GetNumPixels()];
     430    memset(ispixused, 0, sizeof(Byte_t)*fCam->GetNumPixels());
    425431
    426432    for (Int_t i=0; i<entries; i++)
     
    428434        const MCerPhotPix &pix = (*fEvt)[i];
    429435        ispixused[pix.GetPixId()] = pix.IsPixelUsed() ? 1 : 0 ;
    430     }
     436   }
    431437
    432438    for (Int_t i=0; i<entries; i++)
     
    436442
    437443        // get pixel id of this entry
    438         const Int_t id = pix.GetPixId();
     444        const Int_t idx = pix.GetPixId();
    439445
    440446        // check if pixel is in use, if not goto next pixel in list
    441         if (ispixused[id] == 0)
     447        if (ispixused[idx] == 0)
    442448            continue;
    443449 
    444450        // check for 'used' neighbors of this pixel
    445         const MGeomPix &gpix  = (*fCam)[id];
     451        const MGeomPix &gpix  = (*fCam)[idx];
    446452        const Int_t     nnmax = gpix.GetNumNeighbors();
    447453
     
    451457        for (Int_t j=0; j<nnmax; j++)
    452458        {
    453             const Int_t id2 = gpix.GetNeighbor(j);
     459            const Int_t idx2 = gpix.GetNeighbor(j);
    454460
    455461            // when you find an used neighbor, break the loop
    456             if (ispixused[id2] == 1)
     462            if (ispixused[idx2] == 1)
    457463            {
    458                 hasNeighbor = kTRUE;
    459                 break;
     464                hasNeighbor = kTRUE;
     465                break;
    460466            }
    461467        }
     
    478484    }
    479485}
     486
    480487
    481488// --------------------------------------------------------------------------
     
    518525    // get pixel id of this entry
    519526    //
    520     const Int_t id = pix.GetPixId();
     527    const Int_t idx = pix.GetPixId();
    521528
    522529    //
     
    524531    //
    525532    const Float_t  entry = pix.GetNumPhotons();
    526     const Double_t ratio = fCam->GetPixRatio(id);
     533    const Double_t ratio = fCam->GetPixRatio(idx);
    527534
    528535    return (entry * ratio <= fCleanLvl2 * fInnerNoise);
     
    531538void MImgCleanStd::CleanStep3b(MCerPhotPix &pix)
    532539{
    533     const Int_t id = pix.GetPixId();
     540    const Int_t idx = pix.GetPixId();
    534541
    535542    //
     
    537544    // if it is a core pixel set pixel state to: used.
    538545    //
    539     MGeomPix   &gpix  = (*fCam)[id];
     546    MGeomPix   &gpix  = (*fCam)[idx];
    540547    const Int_t nnmax = gpix.GetNumNeighbors();
    541548
    542549    for (Int_t j=0; j<nnmax; j++)
    543550    {
    544         const Int_t id2 = gpix.GetNeighbor(j);
    545 
    546         if (!fEvt->GetPixById(id2) || !fEvt->IsPixelCore(id2))
    547           continue;
     551        const Int_t idx2 = gpix.GetNeighbor(j);
     552
     553        if (!fEvt->GetPixById(idx2) || !fEvt->IsPixelCore(idx2))
     554            continue;
    548555
    549556        pix.SetPixelUsed();
    550            break;
     557        break;
    551558    }
    552559}
     
    568575    // and tell to which ring it belongs to.
    569576    //
    570     const Int_t id = pix.GetPixId();
    571     MGeomPix  &gpix  = (*fCam)[id];
     577    const Int_t idx = pix.GetPixId();
     578    MGeomPix  &gpix  = (*fCam)[idx];
    572579
    573580    const Int_t nnmax = gpix.GetNumNeighbors();
     
    575582    for (Int_t j=0; j<nnmax; j++)
    576583    {
    577         const Int_t id2 = gpix.GetNeighbor(j);
    578 
    579         MCerPhotPix &npix = *fEvt->GetPixById(id2);
    580 
    581         // FIXME!
    582         // Needed check to read CT1 data without having a Segmentation fault
    583         if (!fEvt->GetPixById(id2))
    584             continue;
    585 
    586         if (!npix.IsPixelUsed() || npix.GetRing()>r-1 )
     584        const Int_t idx2 = gpix.GetNeighbor(j);
     585
     586        MCerPhotPix *npix = fEvt->GetPixById(idx2);
     587
     588        if (!npix || !npix->IsPixelUsed() || npix->GetRing()>r-1 )
    587589            continue;
    588590
Note: See TracChangeset for help on using the changeset viewer.