FSBB erste funktionierende Version

diff --git a/MABS_run_analyzer/MAPS.c b/MABS_run_analyzer/MAPS.c
index 64659623021b7b1bedb7e76236bbc9e409af0a8f..6d21333e44ef652b9111e34ba39f9034669ca8a4 100644 (file)
--- a/MABS_run_analyzer/MAPS.c
+++ b/MABS_run_analyzer/MAPS.c
@@ -57,6 +57,7 @@ Bool_t MAPS::initNewRootFile() {
         fHitTree->Branch("frame"    , &fFrameInfo.frame ,     "frame/i"         , 32000);
         fHitTree->Branch("hits"     , &fFrameInfo.hits  ,     "hits/i"          , 32000);
         fHitTree->Branch("pixel"    , &fFrameInfo.pixel[0]  , "pixel[hits]/i"   , 32000);
+               fHitTree->Branch("pixelRaw"    , &fFrameInfo.pixelRaw[0]  , "pixelRaw[hits]/i"   , 32000);
         fHitTree->Branch("pixelthreshold", &fFrameInfo.pixelthreshold[0],"pixelthreshold[hits]/i", 32000);
         for(int i=0; i<25; i++) {
             fHitTree->Branch( Form("p%i",i+1)   , &fFrameInfo.p[i][0]   , Form("p%i [hits]/F",i+1)  , 32000);
@@ -198,6 +199,7 @@ Bool_t MAPS::initMapsRun( ) {
     fColumns = run->sensorinfocur.columns;
     fPixels            = fRows*fColumns;
        fMatrix =  run->labbook.matrix;
+       fOrderCode = run->labbook.chipGen;
        fSystem = run->labbook.system;
     fConfigFile = fInDir+Form("/RUN_%i_i.rz",fRunNumber);
     fRootFile   = fOutDir+Form("/RUN_%i_i.root",fRunNumber);
@@ -647,11 +649,12 @@ bool MAPS::getFrame(UInt_t FrameNumber) {
 // - fF1matrix
 // Use 'fOrderCode' to choose the respective order!
 // -----------------
-        if                     (fOrderCode == "")              { }
-//             else if         (fOrderCode == "Mi26")  { reorderMi26();        }
-        else if                (fOrderCode == "Mi29a") {
-            reorderMi29a();
-        }
+
+        if                     (fOrderCode == "")               { }
+               else if         (fOrderCode == "Mi34")   {      }
+               else if         (fOrderCode == "Pegasus"){      }
+               else if         (fOrderCode == "FSBB")   {  reorderFSBB();      }
+        else if                (fOrderCode == "Mi29a")  {  reorderMi29a(); }
 //             else if         (fOrderCode == "Mi29b") { reorderMi29b();       }
 //==========================================================================
         delete[] HDRDATA;
@@ -1221,11 +1224,24 @@ void MAPS::hitana() {
         Bool_t bordercluster=false;
         Float_t noisesumincluster=0;
         Float_t chargesumincluster=0;
-                
+               
+               Float_t cdsMatrixSum=0;
+               Float_t cdsmatrixCorrPed[fPixels];
+               for(Int_t i=0; i<fPixels; i++)
+        {
+                       cdsMatrixSum+=fCdsmatrix[i];
+               //      cout<<fCdsmatrix[i]<<",";
+               }
+       
+       //      cout<<fFrameNumber<<":________:"<<cdsMatrixSum<<endl;
+       //    debugStream<>(fCdsmatrix, fPixels, fColumns, 2, 20);
+       //      cout<<"Pedestals"<<endl;
+       //      debugStream<>(fPedestals, fPixels, fColumns, 2, 20);            
         for(Int_t i=0; i<fPixels; i++)
         {
+                       cdsmatrixCorrPed[i]=(float)(1.*fCdsmatrix[i]-fPedestals[i]);
             fHittedPixel[i] = 0;
-            
+        //    if( (float)(1.*fCdsmatrix[i]-fPedestals[i]) > (50.) )
             if( (float)(1.*fCdsmatrix[i]-fPedestals[i]) > (5.*fNoise[i]) )
             {
                 HITNR++;
@@ -1248,6 +1264,7 @@ void MAPS::hitana() {
         for(Int_t i=0; i<HITNR; i++)
         {
             Hitlist[i]=HITS.At(i);
+                       fFrameInfo.pixelRaw[i] = Hitlist[i];
         }
         
 //         Begin loop over all negative CDS pixel
@@ -1318,7 +1335,7 @@ void MAPS::hitana() {
                     }
                 }
             }
-        
+          
             //Check seeds (whether lowest entry in cluster):
             for(Int_t i=6; i<19; i++)
             {
@@ -1367,13 +1384,14 @@ void MAPS::hitana() {
                         }
                     }
                 }
-                //                 cout<<"Hitted pixel discriminator matrix:"<<endl;
-                //                 debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
+                 //                cout<<"Hitted pixel discriminator matrix:"<<endl;
+                 //                debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
                 fHittedPixel[rechargePixellist[rechargingpixeli]] = -4;
                 
             }
             
         }
+               
         
         //Begin: loop over all potential seed pixels:
         //Determine 'hit-vicinity':
@@ -1465,21 +1483,56 @@ void MAPS::hitana() {
                     }
                 }
             }
-            noisesumincluster=TMath::Sqrt(noisesumincluster);
-//             cout << coloryellow << "Noise     für Cluster: " << noisesumincluster << endlr;
-//             cout << coloryellow << "ChargeSum für Cluster: " << chargesumincluster << endlr;
-//             debug
-//             for(Int_t row=0; row<5; row++)
-//             {
-//                 for(Int_t column=0; column<5; column++)
-//                 {
-//                     std::cout.width(10);
-//                     std::cout << std::fixed;
-//                     std::cout << std::left << std::setprecision(2) << pixelchargeincluster[row*5+column];
-//                 }
-//                 cout << endl;
-//             }
-//             cout << endl;
+                       int index[25];
+                       TMath::Sort(25,pixelchargeincluster,index,1);
+                       // for(int i=0;i<25;i++)
+                       // cout<<pixelchargeincluster[i]<<",";
+                       // cout<<endl;
+                       // for(int i=0;i<25;i++)
+                       // cout<<index[i]<<",";
+                       // cout<<endl;
+                       // cout<<"ChargeSorted"<<endl;
+                       // for(int i=0;i<25;i++)
+                       // cout<<pixelchargeincluster[index[i]]<<",";
+                       // cout<<endl;
+                       // cout<<"NoiseSorted"<<endl;
+                       // for(int i=0;i<25;i++)
+                       // cout<<noiseincluster[index[i]]<<",";
+                       // cout<<endl;
+                       Float_t chargesumincluster4=0;
+                       Float_t noisesumincluster4=0;
+                       Float_t noisesumincluster4Square=0;
+                       for(Int_t iClusterLauf=0;iClusterLauf<4;iClusterLauf++)
+                       {
+                               chargesumincluster4+=pixelchargeincluster[index[iClusterLauf]];
+                               //noisesumincluster4+=noiseincluster[index[iClusterLauf]];
+                               noisesumincluster4Square+=TMath::Power(noiseincluster[index[iClusterLauf]],2);
+                       }
+                       noisesumincluster=TMath::Sqrt(noisesumincluster);
+                       noisesumincluster4=TMath::Sqrt(noisesumincluster4Square);
+               //      cout<<"Chargesumme"<<chargesumincluster4<<","<<noisesumincluster4<<","<<noisesumincluster4Square<<endl;
+                       // Float_t cdsMatrixMinusPedestal[fPixels];
+                       // Float_t cdsMatrixSum=0;
+                       // for(Int_t i=0; i<fPixels; i++)
+                       // {
+                                               // cdsMatrixMinusPedestal[i]=fCdsmatrix[i]-fPedestals[i];
+                                               // cdsMatrixSum+=cdsMatrixMinusPedestal[i];
+                   // }
+                       // debugStream<>(cdsMatrixMinusPedestal, fPixels, fColumns, 0, 20);
+            // cout << colorred << "Noise     für Cluster: " << noisesumincluster << endlr;
+            // cout << colorred << "ChargeSum für Cluster: " << chargesumincluster <<"WholeMatrix:"<<cdsMatrixSum<< endlr;
+           
+            // for(Int_t row=0; row<5; row++)
+            // {
+                // for(Int_t column=0; column<5; column++)
+                // {
+                    // std::cout.width(10);
+                    // std::cout << std::fixed;
+                    // std::cout << std::left << std::setprecision(2) << pixelchargeincluster[row*5+column];
+                // }
+                // cout << endl;
+            // }
+            // cout << endl;
             
             //Check seeds (whether highest entry in cluster):
             for(Int_t i=6; i<19; i++) // why not over full cluster? (I=0 i<25 TODO
@@ -1510,10 +1563,20 @@ void MAPS::hitana() {
             //Begin: loop evaluate true seeds:
             if(CHANCE==100)
             {
+                       if(fOrderCode=="FSBB")
+                       {
+                               if (B < 2 || B > fColumns-3 || A < 1 || A > fRows-2)
+                                       bordercluster = true;
+                else
+                    bordercluster = false;
+                       }
+                       else //if not FSBB
+                       {
                 if (B < 2 || B > fColumns-3 || A < 2 || A > fRows-3)
                     bordercluster = true;
                 else
                     bordercluster = false;
+                       }
                 for(Int_t row=0; row<5; row++)
                 {
                     for(Int_t column=0; column<5; column++)
@@ -1534,8 +1597,8 @@ void MAPS::hitana() {
                         }
                     }
                 }
-//                 cout<<"Hitted pixel discriminator matrix:"<<endl;
-//                 debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
+          //       cout<<"Hitted pixel discriminator matrix:"<<endl;
+          //       debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
                 if (bordercluster)
                     fHittedPixel[Hitlist[hit]] = -2;
                 else
@@ -1548,25 +1611,60 @@ void MAPS::hitana() {
                     {
                         fFrameInfo.p [clupos][fHits] = pixelchargeincluster[clupos];
                     }
-                    
+             // for(Int_t row=0; row<5; row++)
+            // {
+                // for(Int_t column=0; column<5; column++)
+                // {
+                    // std::cout.width(10);
+                    // std::cout << std::fixed;
+                    // std::cout << std::left << std::setprecision(2) << pixelchargeincluster[row*5+column];
+                // }
+                // cout << endl;
+            // }
+            // cout << endl;
                     // if cluster charge > clusternoise * const
-                    if (1.0*chargesumincluster > noisesumincluster*2.0)
-                        fFrameInfo.pixelthreshold[fHits] = Hitlist[hit];
-                    else
-                        fFrameInfo.pixelthreshold[fHits] = 0;
-                        
+                                       if(fOrderCode=="FSBB")
+                                       {
+                                               if (1.0*chargesumincluster4 > noisesumincluster4*6.0)
+                                                       fFrameInfo.pixelthreshold[fHits] = Hitlist[hit];
+                                               else
+                                                       fFrameInfo.pixelthreshold[fHits] = 0;
+                                       }
+                                       else
+                                       {
+                                               if (1.0*chargesumincluster > noisesumincluster*2.0)
+                                                       fFrameInfo.pixelthreshold[fHits] = Hitlist[hit];
+                                               else
+                                                       fFrameInfo.pixelthreshold[fHits] = 0;
+                                       }           
                     if(fSave) {
                         hint1->Fill( Hitlist[hit]%fColumns, (int)(Hitlist[hit]/fColumns) );
                     }
-                    fHits++;
-                    
+                    // if(fFrameInfo.pixelthreshold[fHits]!=0)
+                                       // {
+                                               
+                                              // debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
+                                               // for(Int_t row=0; row<5; row++)
+                                               // {
+                                                       // for(Int_t column=0; column<5; column++)
+                                                       // {
+                                                               // std::cout.width(10);
+                                                               // std::cout << std::fixed;
+                                                               // std::cout << std::left << std::setprecision(2) << pixelchargeincluster[row*5+column];
+                                                       // }
+                                                       // cout << endl;
+                                               // }
+                                               // cout << endl;
+                                               // debugStream<>(cdsmatrixCorrPed, fPixels, fColumns, 1, 10);  
+                                       // }
+                                       fHits++;
                 }
                 
             }
         }
         //End: loop evaluate true seeds:
         //End: loop over all potential seed pixels:
-        
+       
         if(fSave)
         {
             for(Int_t i=0; i<fPixels; i++)
@@ -1575,6 +1673,7 @@ void MAPS::hitana() {
                 {
                     fdiscriminatedhitmatrix->SetBinContent(i%fColumns, (int)(i/fColumns), fHittedPixel[i]);
                     fADCHitmatrix->SetBinContent(i%fColumns, (int)(i/fColumns), fCdsmatrix[i]);
+                               //      cout<<"HITHERE"<<i<<":"<<fHittedPixel[i]<<";"<<fCdsmatrix[i]<<endl;
                 }
             }
             
@@ -1593,7 +1692,6 @@ void MAPS::hitana() {
     }
 }
 
-
 //####################################################################
 
 void MAPS::filterCommonMode() {
@@ -1619,7 +1717,7 @@ void MAPS::filterCommonMode() {
         else
             minus++;
         
-        if(TMath::Abs(CommonModeInRow)>20) // TODO better warning criteria
+        if(TMath::Abs(CommonModeInRow)>1000) // TODO better warning criteria
         {
             warning = true;
         }
@@ -1650,7 +1748,8 @@ void MAPS::plotFrame(Int_t FrameNumber) {
         cout <<endl <<endl << colorwhite << "---------------- FRAME " << fFrameNumber << " ----------------" << colorreset << endl << endl;
         cout<<"CDS matrix:"<<endl;
         debugStream<>(fCdsmatrix, fPixels, fColumns, 0, 39);
-        
+        debugStream<>(fCdsmatrix, fPixels, 512, 0, 39);
+               cout<<fCdsmatrix[0]<<","<<fCdsmatrix[1]<<","<<fCdsmatrix[2]<<","<<fCdsmatrix[3]<<","<<fCdsmatrix[4]<<","<<fCdsmatrix[5]<<","<<fCdsmatrix[6]<<endl;
         cout<<"Hitted pixel discriminator matrix:"<<endl;
         debugStream<>(fHittedPixel, fPixels, fColumns, 1, 1);
         
@@ -2297,6 +2396,149 @@ void MAPS::reorderMi29a() {
     }
 }
 
+//####################################################################
+void MAPS::reorderFSBB() {
+                       
+        Float_t CDSMATRIX2     [4*208];
+               Float_t CDSMATRIX       [fPixels];
+        Int_t F0MATRIX [fPixels];
+        Int_t F1MATRIX [fPixels];
+               for(Int_t i=0; i<fPixels; i++)
+        {
+            CDSMATRIX  [i] = fCdsmatrix[i];
+            F0MATRIX   [i] = fF0matrix [i];
+            F1MATRIX   [i] = fF1matrix [i];
+        }
+               fRows           = 4;
+        fColumns       = 208;
+        fPixels                = fRows*fColumns;
+       //      debugStream(CDSMATRIX, fPixels, 208, 0, 39);
+               Int_t a0[4][208];
+               Int_t a1[4][208];
+               Int_t aMerge[4][2*208];
+               Int_t subMatrix0[4][208];
+               Int_t subMatrix1[4][208];
+               //Divide CDSMATRIX in the channels. First 208 pixels are from A0-0, then A0-1, then A0-2, then A0-3, then A1-0, then A1-1, then A1-2, then A1-3
+                for(Int_t iOutChannel=0; iOutChannel<4; iOutChannel++)
+        {
+                       for(Int_t iPixelInZeile=0; iPixelInZeile<208; iPixelInZeile++)
+                       {
+                          a0[iOutChannel][iPixelInZeile]=CDSMATRIX     [iOutChannel*208+iPixelInZeile];
+                          a1[iOutChannel][iPixelInZeile]=CDSMATRIX     [(4+iOutChannel)*208+iPixelInZeile];//4+iOutChannel, because this is A1, which is shifted by four channels of A0
+                       }
+               }
+                // for(Int_t i=0; i<208; i++)
+        // {
+          // cout<< a0[3][i]<<",";
+        // }
+               // cout<<endl;
+                // for(Int_t i=0; i<208; i++)
+        // {
+          // cout<< a1[3][i]<<",";
+        // }
+               // cout<<endl;
+               
+               for(Int_t iOutChannel=0; iOutChannel<4; iOutChannel++)
+        {
+                       for(Int_t iMerge2channels=0; iMerge2channels<208;iMerge2channels++)
+                       {
+                       //Merge A0-0[0],A1-0[0],A0-0[1],A1-0[1],A0-0[2],A1-0[2],... output is an array of 4 geometrically columns
+                               aMerge[iOutChannel][iMerge2channels*2]=a0[iOutChannel][iMerge2channels];//A0-iOutChannel[iMerge2channels]
+                               aMerge[iOutChannel][iMerge2channels*2+1]=a1[iOutChannel][iMerge2channels];//A1-iOutChannel[iMerge2channels]
+                       }
+               }
+               // for(Int_t ichannel=0; ichannel<4; ichannel++)
+        // {
+                       // Int_t precision=0;
+                       // Float_t highlightabove=30;
+                                // for(Int_t i=0; i<2*208; i++)
+                               // {
+                                       // if (abs(aMerge[ichannel][i]) > highlightabove)
+                                       // std::cout << colorred;
+                                       // std::cout.width(precision+5);
+                                       // std::cout << std::fixed;
+                                       // std::cout << std::left << std::setprecision(precision);          
+                                       // std::cout << aMerge[ichannel][i] << colorreset;
+                                        
+                               // }
+                       // cout<<endl;
+                       // cout<<endl;
+               // }
+               for(Int_t iOutChannel=0; iOutChannel<4; iOutChannel++)
+        {
+                       for(Int_t iDivideMatrix=0; iDivideMatrix<208;iDivideMatrix++)
+                       { 
+                               //Divide in 2 submatrices
+                               subMatrix0[iOutChannel][iDivideMatrix]=aMerge[iOutChannel][iDivideMatrix];
+                               subMatrix1[iOutChannel][iDivideMatrix]=aMerge[iOutChannel][208+iDivideMatrix];
+                       }
+               }
+                // for(Int_t i=0; i<208; i++)
+        // {
+          // cout<< subMatrix1[2][i]<<",";
+        // }
+               // cout<<endl;
+               // cout<<endl;
+                        // for(Int_t i=0; i<208; i++)
+        // {
+          // cout<< subMatrix1[3][i]<<",";
+        // }
+               // cout<<endl;
+               // cout<<endl;
+               Int_t choiceSubMatrix=0;
+               if(choiceSubMatrix==0)//Choose a submatrix and combine its value in an array
+               {
+                       for(Int_t iOutChannel=0; iOutChannel<4; iOutChannel++)
+                       {
+                               for(Int_t iPixel=0; iPixel<208;iPixel++)
+                               { 
+                               CDSMATRIX2[iOutChannel*208+iPixel]=subMatrix0[iOutChannel][iPixel];
+                               }
+                       }       
+               }
+               else
+               {
+                       for(Int_t iOutChannel=0; iOutChannel<4; iOutChannel++)
+                       {
+                               for(Int_t iPixel=0; iPixel<208;iPixel++)
+                               { 
+                               CDSMATRIX2[iOutChannel*208+iPixel]=subMatrix1[iOutChannel][iPixel];
+                               }
+                       }       
+               }
+       //      debugStream(CDSMATRIX2, 4*208, 208,0,30);
+               
+               for(Int_t i=0; i<4*208; i++)
+        {
+          fCdsmatrix[i]=  CDSMATRIX    [i];
+        }
+               
+               
+               /*
+               Int_t pixel=4*416;
+               Int_t array[pixel];
+               for(int i=0;i<pixel;i++)
+               array[i]=CDSMATRIX      [i];
+               
+               //Divide array in two submatrices
+               Int_t submatrix=0;
+               Int_t nMatrix=2;
+               Int_t pixelInSubMatrix=pixel/nMatrix;
+               Int_t arrayDiv[pixelInSubMatrix];
+               for(int i=0;i<pixelInSubMatrix;i++)
+               arrayDiv[i]=array[i+submatrix*pixelInSubMatrix];
+               debugStream(arrayDiv, pixelInSubMatrix, 208, 0, 39);
+               for(Int_t i=0; i<pixelInSubMatrix; i++)
+        {
+            fCdsmatrix[i]= arrayDiv[i];
+               }
+               for(Int_t i=pixelInSubMatrix; i<fPixels; i++)
+        {
+            fCdsmatrix[i]= 0;
+               }       
+  //  exit(1);*/
+}
+
 //####################################################################
 #endif
 

diff --git a/MABS_run_analyzer/MAPS.h b/MABS_run_analyzer/MAPS.h
index 97182ba2f40d10068270ea2c999b90e8693e2880..4577d3fa1204547f2589b5bd0a4767ad17e30794 100644 (file)
--- a/MABS_run_analyzer/MAPS.h
+++ b/MABS_run_analyzer/MAPS.h
@@ -274,7 +274,12 @@ private:
      * Pixels are counted different here - account for this
      */
     void reorderMi29a();
-    
+    /**
+    * @brief Reorder pixels for FSBB chip
+    *
+    * Pixels are counted different here - account for this Two lines are merged together CURRENTLY A TODO
+    */
+      void reorderFSBB();  
     /**
      * @brief Sums over a given array
      *
@@ -463,7 +468,6 @@ public:
      * 
      */
     void hitana         ();
-    
     /**
      * @brief Old routine, shoould be deletable without side effects */
     void hitana2        ();

diff --git a/MABS_run_analyzer/Run.c b/MABS_run_analyzer/Run.c
index b805a681de6753de8ef91d5269448c0a906e8442..41b31cfdbbadfc6e20dad111113d05c753064535 100644 (file)
--- a/MABS_run_analyzer/Run.c
+++ b/MABS_run_analyzer/Run.c
@@ -244,12 +244,12 @@ Bool_t Run::analyzeRun(Bool_t force)
             processed->InitialDynNoise();
             int start   = 0;
             int nframes = processed->GetNumberFrames();
-            // for(int i=15580; i<15685;i++) // TODO remove 100000 run 342272
-            for(int i=0; i<nframes;i++) // TODO remove 100000 run 342272
+         //    for(int i=0; i<1000000;i++) // TODO remove 100000 run 342272
+           for(int i=0; i<nframes;i++) // TODO remove 100000 run 342272
             {
 //                 cout << "getframe " << i << endl;
                 processed->getFrame(i);
-                //                 processed->filterCommonMode();
+                                processed->filterCommonMode();
 //                     cout << "hitana " << i << endl;
                 processed->hitana();
 //                 cout << "regetDynNoise " << endl;
@@ -392,8 +392,10 @@ Bool_t Run::analyzeFrame(Int_t frame)
         {
             processed->InitialDynNoise(100);
             processed->getFrame(frame);
-//             processed->filterCommonMode();
+                       
+             processed->filterCommonMode();
             processed->hitana();
+                       exit(1);
             processed->plotFrame(frame);
             delete processed;
             return 0;
@@ -699,12 +701,32 @@ Bool_t Run::binSeedSumVeto()
                 // sum histogram
                 pixelSum = 0;
                 notSeedSum = 0;
-                for (Int_t clusteri=0; clusteri<processed->clustersize*processed->clustersize; clusteri++)
-                {
-                    pixelSum += processed->fFrameInfo.p[clusteri][hiti];
-                    if (clusteri != 12)
-                        notSeedSum += processed->fFrameInfo.p[clusteri][hiti];
-                }
+                               if(labbook.chipGen=="FSBB")
+                               {       
+                                       Float_t clusterArray[processed->clustersize*processed->clustersize];
+                                       Int_t index[processed->clustersize*processed->clustersize];
+                                       for (Int_t clusteri=0; clusteri<processed->clustersize*processed->clustersize; clusteri++)
+                                       {
+                                               clusterArray[clusteri] = processed->fFrameInfo.p[clusteri][hiti];
+                                               if (clusteri != 12)
+                                                       notSeedSum += processed->fFrameInfo.p[clusteri][hiti];
+                                       }
+                                       TMath::Sort(processed->clustersize*processed->clustersize,clusterArray,index,1);
+                                       for (Int_t clusteri=0; clusteri<4; clusteri++)
+                                       {
+                                               pixelSum += clusterArray[index[clusteri]];
+                                               
+                                       }
+                               }
+                               else
+                               {
+                                       for (Int_t clusteri=0; clusteri<processed->clustersize*processed->clustersize; clusteri++)
+                                       {
+                                               pixelSum += processed->fFrameInfo.p[clusteri][hiti];
+                                               if (clusteri != 12)
+                                                       notSeedSum += processed->fFrameInfo.p[clusteri][hiti];
+                                       }
+                               }
                 histogram.Sum->Fill(pixelSum);                
                 
                 // veto spectrum
@@ -837,7 +859,7 @@ Bool_t Run::plotAllHistograms(histogramstruct* histogramstructpointer)
         plotVerticalLine(histogramstructpointer->Seed, histogramstructpointer->posSeed);
         lastbin = histogramstructpointer->Seed->GetBinCenter(histogramstructpointer->Seed->FindLastBinAbove(2,1));
         histogramstructpointer->Seed->SetAxisRange(0,lastbin*1.1,"X");
-        gPad->SetLogy(1);
+       // gPad->SetLogy(1);
         canvas->cd(2);
         histogramstructpointer->Sum->Draw();
         plotVerticalLine(histogramstructpointer->Sum, histogramstructpointer->posSum);

diff --git a/MABS_run_analyzer/Run.h b/MABS_run_analyzer/Run.h
index d0a688b24ce65d9d7410ce286e6a06c42a714367..1f157ed8a454bf36b70f24f89941450cbfa57642 100644 (file)
--- a/MABS_run_analyzer/Run.h
+++ b/MABS_run_analyzer/Run.h
@@ -240,9 +240,9 @@ private:
         150
     };
         systemparam systemparamFSBB {
-        2800, // maxbin;
-        2800/4,// nbins;
-        25, //vetothreshold
+        400, // maxbin;
+        400/4,// nbins;
+        15, //vetothreshold
         10,
         100
     };

diff --git a/MABS_run_analyzer/help.h b/MABS_run_analyzer/help.h
index 51aa0f013ae942b7e72db1977874d22a7a6cd84b..04b8045d94c499a7b889386b2e45def9f5478567 100644 (file)
--- a/MABS_run_analyzer/help.h
+++ b/MABS_run_analyzer/help.h
@@ -107,6 +107,8 @@ struct frameInfo{
        UInt_t  hits;   
     /// holds pixel number of hitted seed pixel in frame
     UInt_t     pixel           [MAXHITS];
+           /// holds pixel number of hitted seed pixel in frame for play!
+    UInt_t     pixelRaw                [MAXHITS];
     /// holds pixel number of hitted cluster seed pixel over the threshold in frame
     UInt_t  pixelthreshold       [MAXHITS];
     /// holds charge collected by cluster for a given hit in frame, p[12][7] f.e. holds seed pixel charge of hit number 8 in frame