Ignore:
Timestamp:
05/27/04 16:38:48 (20 years ago)
Author:
aliu
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/MagicSoft/Mars/mtemp/mifae/library/MIslandCalc.cc

    r3976 r4218  
    33!
    44!   Author(s): Ester Aliu, 2/2004 <aliu@ifae.es>
    5 
     5!   
     6!   Last Update: 5/2004
    67!
    78\* ======================================================================== */
     
    1819//   - fPixNum[20];        //  number of pixels in the island
    1920//   - fSigToNoise[20];    //  signal to noise of the island
    20 //   - fTimeHi[20][577]    //  mean of the arrival time in the hi gain 
    21 //   - fTimeLo[20][577]    //  mean of the arrival time in the lo gain
    22 //   - fTimeSpreadHi[20];  //  mean arrival time spread of the island 
    23 //   - fTimeSpreadLo[20];  //  mean arrival time spread of the island
     21//   - fTime[20][577]      //  mean of the arrival time 
     22//   - fTimeSpread[20];    //  mean arrival time spread of the island
    2423//
    2524//
     
    3029//   MArrivalTimeCam
    3130//
    32 //  Output Containers:
     31// Output Containers:
    3332//   MIslands
    3433//
     
    109108      {
    110109        fIsl = (MIslands*)pList->FindCreateObj("MIslands", AddSerialNumber(fIslName));
    111         cout << "kk1" << endl;
     110        //cout << "kk1" << endl;
    112111      }
    113112    else
    114113      {
    115114      fIsl = (MIslands*)pList->FindCreateObj(AddSerialNumber("MIslands"));
    116       cout << "kk2" << endl;
     115      //cout << "kk2" << endl;
    117116      }
    118117    if (!fIsl)
     
    130129
    131130  Int_t    npix = 577;
     131
    132132  Int_t    sflag;
    133133  Int_t    control;
     
    148148 
    149149
     150  MCerPhotPix *pix;
     151
    150152  //loop over all pixels
    151   for(Int_t idx=0 ; idx<npix ; idx++)
    152     {
     153  MCerPhotEvtIter Next(fEvt, kFALSE);
     154 
     155  while ((pix=static_cast<MCerPhotPix*>(Next())))
     156    {
     157      const Int_t idx = pix->GetPixId();
     158
    153159      const MGeomPix &gpix  = (*fCam)[idx];
    154160      const Int_t    nnmax  = gpix.GetNumNeighbors();
    155      
    156       if(idx<0 || idx==npix)
    157         {
    158           cout << "Pixel (software) index out of range [0-576]. Available number of pixels=" << npix << endl;
    159           return 1;
    160         }
    161      
    162      
     161
    163162      if( fEvt->IsPixelUsed(idx))
    164163        {
     
    193192  fIslNum = nvect;
    194193 
    195 
     194 
    196195  // Repeated Chain Corrections
    197 
     196 
    198197  for(Int_t i = 1; i <= nvect; i++)
    199198    {
     
    203202          for(Int_t k = 0; k < npix; k++)
    204203            {
    205        
     204             
    206205              if (vect[i][k] == 1 && vect[j][k] == 1)
    207206                {
     
    225224    }
    226225 
    227  
     226  
    228227  Int_t l = 1;
    229 
     228 
    230229  for(Int_t i = 1;  i<= nvect ; i++)
    231230    {
     
    239238        }
    240239    }
    241    
     240 
    242241 
    243242  //set the number of islands in one event
     
    249248  Float_t time[577];
    250249  Float_t timeVariance[fIslNum];
    251   //Float_t timeHi[577], timeLo[577]; 
    252   //Float_t timeVarianceHi[fIslNum];
    253   //Float_t timeVarianceLo[fIslNum];
    254  
     250 
    255251  //reset the "sets" functions
    256252  if (fIslNum <1)
     
    262258      fIsl->SetSigToNoise(i,-1);
    263259      fIsl->SetTimeSpread(i,-1);
    264       //      fIsl->SetTimeSpreadHi(i,-1);
    265       // fIsl->SetTimeSpreadLo(i,-1);
    266 
     260   
    267261      for(Int_t idx = 0; idx<npix; idx++)
    268262        {
    269263          fIsl->SetIslId(idx, -1);
    270264          fIsl->SetArrivalTime(i, idx, -1 );
    271           // fIsl->SetArrivalTimeHiGain(i, idx, -1 );
    272           // fIsl->SetArrivalTimeLoGain(i, idx, -1);
    273265        }
    274266    }
    275267 
    276     
    277   for(Int_t i = 1; i<=fIslNum ; i++)
     268   
     269   for(Int_t i = 1; i<=fIslNum ; i++)
    278270    {
    279271      Int_t n = 0;
    280272      Int_t ncore = 0;
    281 
    282       Float_t MINhi = 10000;
    283       Float_t MINlo = 10000;
    284       Float_t MAXhi = 0;
    285       Float_t MAXlo = 0;
     273     
    286274      Float_t MIN = 10000;
    287275      Float_t MAX = 0;
    288 
    289       //cout << "Isl #" << i << endl;
    290276
    291277      signal = 0;
     
    293279      fPixNum[i-1] = 0;
    294280      timeVariance[i-1] = 0;
    295       // timeVarianceHi[i-1] = 0;
    296       // timeVarianceLo[i-1] = 0;
    297 
     281     
    298282      for(Int_t idx=0 ; idx<npix ; idx++)
    299283        {
    300           const MCerPhotPix &pix = (*fEvt)[idx];
     284         
     285          MCerPhotPix *pix = fEvt->GetPixById(idx);
    301286          const MPedestalPix &ped  = (*fPed)[idx];
    302287          const MArrivalTimePix &timepix = (*fTime)[idx];
    303          
     288
     289          if (pix == NULL) break;
     290           
    304291          if (vect[i][idx]==1){
    305    
     292           
    306293            fPixNum[i-1]++;
    307             signal += pix.GetNumPhotons() * (fCam->GetPixRatio(idx));
     294            signal += pix->GetNumPhotons() * (fCam->GetPixRatio(idx));
    308295            noise += pow(ped.GetPedestalRms(),2);
    309 
     296           
    310297            time[n] = timepix.IsLoGainUsed() ? timepix.GetArrivalTimeLoGain() : timepix.GetArrivalTimeHiGain();
    311 
    312             // timeHi[n] = timepix.GetArrivalTimeHiGain();
    313             // cout << "timeHi" << timeHi[n] << endl;       
    314 
    315             //timeLo[n] = timepix.GetArrivalTimeLoGain();
    316             //cout << "timeHi" << timeLo[n] << endl;       
    317        
     298           
     299           
    318300            if (fEvt->IsPixelCore(idx)){
    319301             
    320               /*  if (timeHi[n] < MINhi)
    321                 MINhi = timeHi[n];
    322               if (timeLo[n] < MINlo)
    323                 MINlo = timeLo[n];
    324 
    325               if (timeHi[n] > MAXhi)
    326                 MAXhi = timeHi[n];
    327               if (timeLo[n] > MAXlo)
    328                 MAXlo = timeLo[n];
    329 
    330               */
    331 
    332302              if (time[n] > MAX)
    333303                MAX = time[n];
     
    335305                MIN = time[n];
    336306             
    337               //control2[n] = 1;   
    338               //timeVarianceHi[i-1] += timeHi[n];
    339               //timeVarianceLo[i-1] += timeLo[n];
    340307              ncore++;
    341308            }
    342 
     309           
    343310            fIsl->SetIslId(idx, i-1);
    344311            fIsl->SetArrivalTime(i-1, idx, time[n]);
    345             // fIsl->SetArrivalTimeHiGain(i-1, idx, timeHi[n]);
    346             // fIsl->SetArrivalTimeLoGain(i-1, idx, timeLo[n]);
    347        
     312               
    348313            n++;
    349314          }
     
    351316        }
    352317
    353       Float_t mean = timeVariance[i-1]/ncore;
    354       // Float_t meanHi = timeVarianceHi[i-1]/ncore;
    355       // Float_t meanLo = timeVarianceLo[i-1]/ncore;
    356      
     318      // Float_t mean = timeVariance[i-1]/ncore;
     319           
    357320      timeVariance[i-1] = 0;
    358       //timeVarianceHi[i-1] = 0;
    359       //timeVarianceLo[i-1] = 0;
    360 
    361       /*
    362       //old
    363         for (Int_t k = 0; k <n ; k++)
    364         {
    365         if (control2[k] == 1){
    366        
    367         timeVarianceHi[i-1] += pow(timeHi[k]- meanHi,2);
    368         timeVarianceLo[i-1] += pow(timeLo[k]- meanLo,2);
    369         }
    370         }
    371         timeVarianceHi[i-1] = sqrt(timeVarianceHi[i-1]/(ncore-1));
    372         timeVarianceLo[i-1] = sqrt(timeVarianceLo[i-1]/(ncore-1)); */
    373      
    374       //timeVarianceHi[i-1] = (MAXhi - MINhi)/ncore;
    375       //timeVarianceLo[i-1] = (MAXlo - MINlo)/ncore;
    376 
     321     
    377322      timeVariance[i-1] = (MAX - MIN)/ncore;
    378323      timeVariance[i-1] = (MAX - MIN)/ncore;
     
    383328      fIsl->SetSigToNoise(i-1,fSigToNoise[i-1]);
    384329      fIsl->SetTimeSpread(i-1, timeVariance[i-1]);
    385       //fIsl->SetTimeSpreadHi(i-1, timeVarianceHi[i-1]);
    386       //fIsl->SetTimeSpreadLo(i-1, timeVarianceLo[i-1]);
    387 
    388       //cout << " TimeHi Spread: " << timeVarianceHi[i-1] << endl;
    389       //cout << " # core pixels: " << ncore << endl;
    390       //cout << " # used pixels: " << n << endl;
    391       //cout << " SigToNoise: " << fSigToNoise[i-1] << endl << endl;
    392330     
    393331    }
Note: See TracChangeset for help on using the changeset viewer.