add probestation setup to analysis, add few pixel multiplicty plots

diff --git a/.gitignore b/.gitignore
index d203a76f4d4f930364ce512b60927bc928d4908c..eff0e81b79771663277f21798b3c38aab614566b 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,5 @@ scripts/dac_scan/*.csv
 *.d
 *.so
 *.pcm
+hld
+*.hotstart

diff --git a/analysis/rawreader/first.C b/analysis/rawreader/first.C
index ef62a4c912f654b1f7ae3909cd0c18ff17466572..9a4e4a9c0e33b3cf2b0f02df142b4af3ac79c6c1 100644 (file)
--- a/analysis/rawreader/first.C
+++ b/analysis/rawreader/first.C
@@ -34,9 +34,11 @@ void first()
    // create TRB processor which holds custom data
    hadaq::TrbProcessor* trb = new hadaq::TrbProcessor(0xa000, hld);
    hadaq::TrbProcessor* trb1 = new hadaq::TrbProcessor(0xa001, hld);
+   hadaq::TrbProcessor* trb2 = new hadaq::TrbProcessor(0xa100, hld);
    // create custom processor
    hadaq::MimosisProcessor *mimosis = new hadaq::MimosisProcessor(trb, 0xa000);
    hadaq::MimosisProcessor *mimosis1 = new hadaq::MimosisProcessor(trb1, 0xa001);
+   hadaq::MimosisProcessor *mimosis2 = new hadaq::MimosisProcessor(trb2, 0xa100);
 
 
 

diff --git a/analysis/rawreader/mimosis.h b/analysis/rawreader/mimosis.h
index ab861e18e92d0cebe7b774c86b0494662ee8894f..7f556e5f9166f719d36cedccce8c6dc7ce8c05b3 100644 (file)
--- a/analysis/rawreader/mimosis.h
+++ b/analysis/rawreader/mimosis.h
@@ -20,20 +20,36 @@ class MimosisProcessor : public SubProcessor {
 
 protected:
 
-   base::H1handle FrameLength;    
-   base::H1handle NumHeaders;    
-   base::H1handle NumTrailers;    
-   base::H1handle NumHTDiff;    
-   base::H1handle RegionHeaders;    
-   base::H1handle Columns;    
-   base::H1handle ErrorFlags;    
+   base::H1handle FrameLength;
+   base::H1handle NumHeaders;
+   base::H1handle NumTrailers;
+   base::H1handle NumHTDiff;
+   base::H1handle RegionHeaders;
+   base::H1handle Columns;
+   base::H1handle ErrorFlags;
    base::H2handle Matrix;
+   base::H2handle MatrixCurrent;
+   base::H2handle MatrixLast;
    base::H2handle FrameLengthDist;
    base::H2handle LengthvsError;
+   base::H1handle PixelMultiplicity;
+   base::H1handle PixelMultiplicityTotal;
+   base::H1handle PixelMultiplicityA;
+   base::H1handle PixelMultiplicityB;
+   base::H1handle PixelMultiplicityC;
+   base::H1handle PixelMultiplicityD;
+   base::H1handle PixelMultiplicityATotal;
+   base::H1handle PixelMultiplicityBTotal;
+   base::H1handle PixelMultiplicityCTotal;
+   base::H1handle PixelMultiplicityDTotal;
 
    uint32_t length = 0;
    uint32_t region = 0;
-   
+   int frameCounter = 0;
+   int lastRegion = 0;
+   unsigned sensor=0;
+
+
    virtual bool DecodePixel(uint16_t word, uint32_t* column, uint32_t* row) {
         uint32_t pixelcode = (word >> 6) & 0x3ff;
         uint32_t side = 0;
@@ -42,12 +58,12 @@ protected:
           side = 1;
         if((pixelcode&3) == 0x3 || (pixelcode&3) == 0x2)
           topdown = 1;
-        
+
         *row    = (pixelcode>>2)*2 + topdown;
         *column = (((word>>3)&0x7) + region*8)*2 + side;
        return true;
      }
-   
+
 public:
 
    MimosisProcessor(TrbProcessor* trb, unsigned subid);
@@ -77,8 +93,21 @@ hadaq::MimosisProcessor::MimosisProcessor(TrbProcessor* trb, unsigned subid) :
   Columns     = MakeH1("Columns", "Hits per Column", 1024, 0, 1024, "#");
   ErrorFlags  = MakeH1("ErrorFlags", "", 9, 0, 9, "Bit");
   Matrix      = MakeH2("Matrix", "", 1024,0,1024,508,0,508);
+  MatrixCurrent = MakeH2("MatrixCurrent", "", 1024,0,1024,508,0,508);
+  MatrixLast  = MakeH2("MatrixLast", "", 1024,0,1024,508,0,508);
   FrameLengthDist = MakeH2("FrameLengthDist", "", 1024,0,1024,1024,0,1024,"this frame ; last frame");
   LengthvsError = MakeH2("LengthvsError", "", 1024,0,1024,2,0,2,"frame size; limit marker");
+  PixelMultiplicity = MakeH1("PixelMultiplicity", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityTotal = MakeH1("PixelMultiplicityTotal", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityA = MakeH1("PixelMultiplicityA", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityB = MakeH1("PixelMultiplicityB", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityC = MakeH1("PixelMultiplicityC", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityD = MakeH1("PixelMultiplicityD", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityATotal = MakeH1("PixelMultiplicityATotal", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityBTotal = MakeH1("PixelMultiplicityBTotal", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityCTotal = MakeH1("PixelMultiplicityCTotal", "", 10000, 0, 1, "Hit probability");
+  PixelMultiplicityDTotal = MakeH1("PixelMultiplicityDTotal", "", 10000, 0, 1, "Hit probability");
+  sensor = subid-0xa000;
   }
 
 bool hadaq::MimosisProcessor::FirstBufferScan(const base::Buffer &buf)
@@ -86,6 +115,7 @@ bool hadaq::MimosisProcessor::FirstBufferScan(const base::Buffer &buf)
   unsigned len = buf.datalen()/4;
   uint32_t* arr = (uint32_t*) buf.ptr();
   uint32_t column, row;
+  uint32_t lastcolumn =-1, lastrow=-1;
   uint32_t headers = 0, trailers = 0;
   unsigned n=0;
   unsigned headersnow = 0;
@@ -105,20 +135,69 @@ bool hadaq::MimosisProcessor::FirstBufferScan(const base::Buffer &buf)
       }
     else if((data & 0xFF000000) == 0xFF000000) {
       trailers++;
-/*      if (headersnow && headersnow != 4) {
-        printf("%i\t%i\n",headersnow,n);
-        if(n>6) {
-          printf("%08x %08x %08x %08x %08x %08x %08x %08x\n",arr[n-7],arr[n-6],arr[n-5],arr[n-4],arr[n-3],arr[n-2],arr[n-1],arr[n]);
+      frameCounter++;
+      FillH2(MatrixCurrent,-1,-1);
+      if(frameCounter == 10000) {
+
+        ((TH2F*) MatrixCurrent)->Copy(*((TH2F*) MatrixLast));
+
+        ((TH1*)PixelMultiplicityTotal)->Add((TH1*)PixelMultiplicityTotal, (TH1*)PixelMultiplicity);
+
+        ((TH1*)PixelMultiplicityATotal)->Add((TH1*)PixelMultiplicityATotal, (TH1*)PixelMultiplicityA);
+        ((TH1*)PixelMultiplicityBTotal)->Add((TH1*)PixelMultiplicityBTotal, (TH1*)PixelMultiplicityB);
+        ((TH1*)PixelMultiplicityCTotal)->Add((TH1*)PixelMultiplicityCTotal, (TH1*)PixelMultiplicityC);
+        ((TH1*)PixelMultiplicityDTotal)->Add((TH1*)PixelMultiplicityDTotal, (TH1*)PixelMultiplicityD);
+
+        ClearH2(PixelMultiplicity);
+        for(int x = 1; x<=1024; x++)
+          for(int y = 1; y<=508; y++) {
+            double_t pixelcount = ((TH2F*)MatrixCurrent)->GetBinContent(x,y);
+            if(pixelcount > 0)
+              FillH1(PixelMultiplicity,(pixelcount+0.5)/frameCounter);
           }
+
+        ClearH2(PixelMultiplicityA);
+        for(int x = 1; x<=128; x++)
+            for(int y = 1; y<=508; y++) {
+                double_t pixelcount = ((TH2F*)MatrixCurrent)->GetBinContent(x,y);
+                if(pixelcount > 0)
+                    FillH1(PixelMultiplicityA,(pixelcount+0.5)/frameCounter);
+            }
+
+        ClearH2(PixelMultiplicityB);
+        for(int x = 129; x<=512; x++)
+            for(int y = 1; y<=508; y++) {
+                double_t pixelcount = ((TH2F*)MatrixCurrent)->GetBinContent(x,y);
+                if(pixelcount > 0)
+                    FillH1(PixelMultiplicityB,(pixelcount+0.5)/frameCounter);
+            }
+
+        ClearH2(PixelMultiplicityC);
+        for(int x = 513; x<=896; x++)
+            for(int y = 1; y<=508; y++) {
+                double_t pixelcount = ((TH2F*)MatrixCurrent)->GetBinContent(x,y);
+                if(pixelcount > 0)
+                    FillH1(PixelMultiplicityC,(pixelcount+0.5)/frameCounter);
+            }
+
+        ClearH2(PixelMultiplicityD);
+        for(int x = 897; x<=1024; x++)
+            for(int y = 1; y<=508; y++) {
+                double_t pixelcount = ((TH2F*)MatrixCurrent)->GetBinContent(x,y);
+                if(pixelcount > 0)
+                    FillH1(PixelMultiplicityD,(pixelcount+0.5)/frameCounter);
+            }
+
+        frameCounter = 0;
+        ClearH2(MatrixCurrent);
         }
-*/
       headersnow = 0;
       FillH1(FrameLength,length);
       if(lastlength != -1)
         FillH2(FrameLengthDist, length, lastlength);
-      lastlength = length; 
+      lastlength = length;
       FillH2(LengthvsError,length,(data & 0x00080000)?1:0);
-      
+
       if(data & 0x00010000) FillH1(ErrorFlags,0);
       if(data & 0x00020000) FillH1(ErrorFlags,1);
       if(data & 0x00040000) FillH1(ErrorFlags,2);
@@ -130,29 +209,49 @@ bool hadaq::MimosisProcessor::FirstBufferScan(const base::Buffer &buf)
       if(!(data & 0x00FF0000)) FillH1(ErrorFlags,8);
       }
     else {
-/*      if (headersnow && headersnow != 4) {
-        printf("%i\t%i\n",headersnow,n);
-        if(n>6) {
-          printf("%08x %08x %08x %08x %08x %08x %08x %08x\n",arr[n-7],arr[n-6],arr[n-5],arr[n-4],arr[n-3],arr[n-2],arr[n-1],arr[n]);
-          }
-        }*/
+
       headersnow = 0;
       if((data & 0xFF000000) == 0xFD000000) {
-        region = (data>>16) & 0xff;
+        lastRegion = region;
+        int tmp =  (data>>16) & 0xff;
+//         if(tmp >63) {
+//           printf("%08x %08x %08x %i %i %i %i\n",arr[n-1],arr[n],arr[n+1],tmp, lastRegion, sensor, n%4);
+//         }
+        if(tmp > 63) continue;
+        region = tmp;
         FillH1(RegionHeaders,region);
         }
       else {
         DecodePixel(data>>16,&column,&row);
         FillH1(Columns,column);
+//         if(column > 1023 || row > 507) {
+//           printf("1: %i %i\n",column,row);
+//           }
         FillH2(Matrix,column,row);
+        FillH2(MatrixCurrent,column,row);
+
+//         if(lastrow != -1 && lastcolumn/2 == column/2 && lastrow > row) {
+//           printf("%i %i -> %i %i / %08x %08x %08x %i \n",lastcolumn,lastrow,column,row,arr[n-1],arr[n],arr[n+1],length);
+//           }
+        lastcolumn = column; lastrow = row;
         }
       if ((data & 0x0000FF00) != 0x0000FC00) {
         DecodePixel(data&0xffff,&column,&row);
+//         if(column > 1023 || row > 507) {
+//           printf("2: %i %i\n",column,row);
+//           }
         FillH1(Columns,column);
         FillH2(Matrix,column,row);
+        FillH2(MatrixCurrent,column,row);
+
+//         if(lastrow != -1 && lastcolumn/2 == column/2 && lastrow > row) {
+//           printf("%i %i -> %i %i / %08x %08x %08x %i *\n",lastcolumn,lastrow,column,row,arr[n-1],arr[n],arr[n+1],length);
+//           }
+
+        lastcolumn = column; lastrow = row;
         }
       }
-      
+
     }