Index: trunk/FACT++/src/EventBuilder.c
===================================================================
--- trunk/FACT++/src/EventBuilder.c	(revision 15462)
+++ trunk/FACT++/src/EventBuilder.c	(revision 15463)
@@ -71,4 +71,6 @@
 
 
+int evtCtrl_frstPtr;
+int evtCtrl_lastPtr;
 
 
@@ -116,13 +118,13 @@
 //uint gp_EvtTot  = 0 ;
 
-PIX_MAP g_pixMap[NPIX];
+//PIX_MAP g_pixMap[NPIX];
 
 EVT_STAT gi;
 GUI_STAT gj;
 
-EVT_CTRL evtCtrl;               //control of events during processing
-int evtIdx[MAX_EVT * MAX_RUN];  //index from mBuffer to evtCtrl
-
-WRK_DATA mBuffer[MAX_EVT * MAX_RUN];    //local working space
+//int evtIdx[MAX_EVT * MAX_RUN];  //index from mBuffer to evtCtrl
+
+EVT_CTRL evtCtrl[MAX_EVT * MAX_RUN]; //control of events during processing
+WRK_DATA mBuffer[MAX_EVT * MAX_RUN]; //local working space
 
 //#define MXSTR 1000
@@ -322,5 +324,5 @@
 
 RUN_CTRL runCtrl[MAX_RUN];
-RUN_TAIL runTail[MAX_RUN];
+//RUN_TAIL runTail[MAX_RUN];
 
 
@@ -506,7 +508,7 @@
       mBuffer[i].runNum = 0;
 
-      evtCtrl.evtBuf[i] = -1;
-      evtCtrl.evtStat[i] = -1;
-      evtCtrl.pcTime[i] = actime;       //initiate to far future
+      evtCtrl[i].mBuffer_idx = -1;
+      evtCtrl[i].evtStat = -1;
+      //evtCtrl[i].lastRecv = actime;       //initiate to far future
 
 #ifdef ETIENNE_MALLOC
@@ -525,6 +527,6 @@
    //actRun.FADhead = malloc (NBOARDS * sizeof (PEVNT_HEADER));
 
-   evtCtrl.frstPtr = 0;
-   evtCtrl.lastPtr = 0;
+   evtCtrl_frstPtr = 0;
+   evtCtrl_lastPtr = 0;
 
    return 0;
@@ -632,4 +634,5 @@
         if (runCtrl[k].runId == runID)
         {
+            // FIXME: Compare to previous event
             if (runCtrl[k].roi0 != nRoi[0] || runCtrl[k].roi8 != nRoi[8])
             {
@@ -694,6 +697,6 @@
 
         runCtrl[evFree].runId      = runID;
-        runCtrl[evFree].roi0       = nRoi[0];
-        runCtrl[evFree].roi8       = nRoi[8];
+        runCtrl[evFree].roi0       = nRoi[0];  // FIXME: Make obsolete!
+        runCtrl[evFree].roi8       = nRoi[8];  // FIXME: Make obsolete!
         runCtrl[evFree].fileId     = -2;
         runCtrl[evFree].procId     = -2;
@@ -702,9 +705,9 @@
         runCtrl[evFree].procEvt    = 0;         // Number of successfully checked events (checkEvent)
         runCtrl[evFree].maxEvt     = 999999999; // max number events allowed
-        runCtrl[evFree].firstTime  = tsec;
-        runCtrl[evFree].firstUsec  = tusec;
+        //runCtrl[evFree].firstTime  = tsec;
+        //runCtrl[evFree].firstUsec  = tusec;
         runCtrl[evFree].lastTime   = tsec;      // Time when the last event was written
         runCtrl[evFree].closeTime  = tsec + 3600 * 24;     //max time allowed
-
+/*
         runTail[evFree].nEventsOk  = 0;
         runTail[evFree].nEventsRej = 0;
@@ -712,4 +715,5 @@
         runTail[evFree].PCtime0    = 0;
         runTail[evFree].PCtimeX    = 0;
+        */
     }
 
@@ -733,6 +737,6 @@
     mBuffer[i].Errors[3] = 0;
     mBuffer[i].fEvent    = NULL;
-    mBuffer[i].buffer    = NULL;
     mBuffer[i].FADhead   = NULL;
+    //mBuffer[i].buffer    = NULL;
 
 /*
@@ -787,4 +791,5 @@
 {
     mBuffer[i].fEvent = (EVENT*)((char*)mBuffer[i].FADhead+MAX_HEAD_MEM);
+    memset(mBuffer[i].fEvent->Adc_Data, 0, (NPIX+NTMARK)*2*mBuffer[i].nRoi);
 
     //flag all pixels as unused
@@ -834,5 +839,5 @@
 
 //   free (mBuffer[i].buffer);
-   mBuffer[i].buffer = NULL;
+//   mBuffer[i].buffer = NULL;
 //END ETIENNE
 //   headmem = NBOARDS * sizeof (PEVNT_HEADER);
@@ -902,10 +907,8 @@
 }*/ /*-----------------------------------------------------------------*/
 
-void reportIncomplete(int k0)
-{
-    const int id = evtCtrl.evtBuf[k0];
-
-    factPrintf(kWarn, 601, "%5d skip incomplete evt %8d %8d %2d",
-               mBuffer[id].evNum, evtCtrl.evtBuf[k0], k0, evtCtrl.evtStat[k0]);
+void reportIncomplete(int id)
+{
+    factPrintf(kWarn, 601, "%5d skip incomplete evt %8d",
+               mBuffer[id].evNum, id);
 
     uint64_t report = 0;
@@ -1174,6 +1177,6 @@
 
  START:
-   evtCtrl.frstPtr = 0;
-   evtCtrl.lastPtr = 0;
+   evtCtrl_frstPtr = 0;
+   evtCtrl_lastPtr = 0;
 
    //time in seconds
@@ -1547,12 +1550,12 @@
 
               //register event in 'active list (reading)'
-              evtIdx[evID] = evtCtrl.lastPtr;
-
-              evtCtrl.evtBuf[evtCtrl.lastPtr]  = evID;
-              evtCtrl.evtStat[evtCtrl.lastPtr] = 0;
-              evtCtrl.pcTime[evtCtrl.lastPtr]  = g_actTime;
-
-              evtCtrl.lastPtr++;
-              evtCtrl.lastPtr %= MAX_EVT * MAX_RUN;
+              mBuffer[evID].evtCtrl_idx = evtCtrl_lastPtr;
+
+              evtCtrl[evtCtrl_lastPtr].mBuffer_idx = evID;
+              evtCtrl[evtCtrl_lastPtr].evtStat = 0;
+              //evtCtrl[evtCtrl.lastPtr].pcTime  = g_actTime;
+
+              evtCtrl_lastPtr++;
+              evtCtrl_lastPtr %= MAX_EVT * MAX_RUN;
           }
 
@@ -1591,12 +1594,12 @@
           // now we have stored a new board contents into Event structure
 
-          const int iDx = evtIdx[evID];       //index into evtCtrl
-
           mBuffer[evID].fEvent->NumBoards++;
           mBuffer[evID].board[board] = board;
           mBuffer[evID].nBoard++;
 
-          evtCtrl.evtStat[iDx] = mBuffer[evID].nBoard;
-          evtCtrl.pcTime[iDx]  = g_actTime;
+          const int iDx = mBuffer[evID].evtCtrl_idx;//evtIdx[evID];       //index into evtCtrl
+
+          evtCtrl[iDx].evtStat  = mBuffer[evID].nBoard;
+          //evtCtrl[iDx].lastRecv = g_actTime;
 
           // have we already reported first (partial) event of this run ???
@@ -1640,5 +1643,5 @@
 
           // Flag that the event is ready for processing
-          evtCtrl.evtStat[iDx] = 99;
+          evtCtrl[iDx].evtStat = 99;
 
       } // end for loop over all sockets
@@ -1657,10 +1660,10 @@
       //loop over all active events and flag those older than read-timeout
       //delete those that are written to disk ....
-      for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+      for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
       {
-          if (k0==evtCtrl.frstPtr && evtCtrl.evtStat[k0]<0)
+          if (k0==evtCtrl_frstPtr && evtCtrl[k0].evtStat<0)
           {
-              evtCtrl.frstPtr++;
-              evtCtrl.frstPtr %= MAX_EVT * MAX_RUN;
+              evtCtrl_frstPtr++;
+              evtCtrl_frstPtr %= MAX_EVT * MAX_RUN;
 
               // Continue because evtCtrl.evtStat[k0] must be <0
@@ -1669,16 +1672,18 @@
 
           // Check the more likely case first: incomplete events
-          if (evtCtrl.evtStat[k0]>0 && evtCtrl.evtStat[k0]<92)
+          if (evtCtrl[k0].evtStat>0 && evtCtrl[k0].evtStat<92)
           {
               gj.bufNew++;     //incomplete event in Buffer
 
               // Event has not yet timed out or was reported already
-              if (evtCtrl.evtStat[k0]>=90 || evtCtrl.pcTime[k0]>=g_actTime - 30)
+              const int id = evtCtrl[k0].mBuffer_idx;
+
+              if (evtCtrl[k0].evtStat>=90 || mBuffer[id].pcTime[0]/*evtCtrl[k0].lastRecv*/>=g_actTime - 30)
                   continue;
 
-              reportIncomplete(k0);
+              reportIncomplete(id);
 
               //timeout for incomplete events
-              evtCtrl.evtStat[k0] = 91;
+              evtCtrl[k0].evtStat = 91;
               gj.evtSkip++;
 
@@ -1687,16 +1692,16 @@
 
           // complete event in Buffer
-          if (evtCtrl.evtStat[k0] >= 95)
+          if (evtCtrl[k0].evtStat >= 95)
               gj.bufEvt++;
 
           // Check the less likely case: 'useless' or 'delete'
-          if (evtCtrl.evtStat[k0]==0 || evtCtrl.evtStat[k0] >= 9000)
+          if (evtCtrl[k0].evtStat==0 || evtCtrl[k0].evtStat >= 9000)
           {
-              const int id = evtCtrl.evtBuf[k0];
+              const int id = evtCtrl[k0].mBuffer_idx;
 #ifdef EVTDEBUG
               factPrintf(kDebug, -1, "%5d free event buffer, nb=%3d", mBuffer[id].evNum, mBuffer[id].nBoard);
 #endif
               mBufFree (id);   //event written--> free memory
-              evtCtrl.evtStat[k0] = -1;
+              evtCtrl[k0].evtStat = -1;
               gj.evtWrite++;
               gj.rateWrite++;
@@ -1782,9 +1787,9 @@
    {
        //flag all events as 'read finished'
-      for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+      for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
       {
-           if (evtCtrl.evtStat[k0] > 0 && evtCtrl.evtStat[k0] < 90)
+           if (evtCtrl[k0].evtStat > 0 && evtCtrl[k0].evtStat < 90)
            {
-               evtCtrl.evtStat[k0] = 91;
+               evtCtrl[k0].evtStat = 91;
                //gi.evtSkp++;
                //gi.evtTot++;
@@ -1810,23 +1815,23 @@
          numclear = 0;
 
-         for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+         for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
          {
-             if (evtCtrl.evtStat[k0] > minclear)
+             if (evtCtrl[k0].evtStat > minclear)
              {
-                 const int id = evtCtrl.evtBuf[k0];
+                 const int id = evtCtrl[k0].mBuffer_idx;
 #ifdef EVTDEBUG
                  factPrintf(kDebug, -1, "ev %5d free event buffer, nb=%3d", mBuffer[id].evNum, mBuffer[id].nBoard);
 #endif
                  mBufFree (id);   //event written--> free memory
-                 evtCtrl.evtStat[k0] = -1;
+                 evtCtrl[k0].evtStat = -1;
              }
              else
-                 if (evtCtrl.evtStat[k0] > 0)
+                 if (evtCtrl[k0].evtStat > 0)
                      numclear++;      //writing is still ongoing...
 
-             if (k0 == evtCtrl.frstPtr && evtCtrl.evtStat[k0] < 0)
+             if (k0 == evtCtrl_frstPtr && evtCtrl[k0].evtStat < 0)
              {
-                 evtCtrl.frstPtr++;
-                 evtCtrl.frstPtr %= MAX_EVT * MAX_RUN;
+                 evtCtrl_frstPtr++;
+                 evtCtrl_frstPtr %= MAX_EVT * MAX_RUN;
              }
          }
@@ -1882,9 +1887,9 @@
         int numProc = 0;
 
-        for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+        for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
         {
-            if (!(evtCtrl.evtStat[k0] == 1000 + threadID))
+            if (evtCtrl[k0].evtStat != 1000 + threadID)
             {
-                if (evtCtrl.evtStat[k0] < 1000 + threadID)
+                if (evtCtrl[k0].evtStat < 1000 + threadID)
                     numWait++;
 
@@ -1898,8 +1903,8 @@
             if (gi_resetR<=1)
             {
-                const int id = evtCtrl.evtBuf[k0];
+                const int id = evtCtrl[k0].mBuffer_idx;
 
                 jret = subProcEvt(threadID, mBuffer[id].FADhead,
-                                  mBuffer[id].fEvent, mBuffer[id].buffer);
+                                  mBuffer[id].fEvent, NULL/*mBuffer[id].buffer*/);
 
 
@@ -1915,5 +1920,5 @@
             }
 
-            evtCtrl.evtStat[k0] = jret;
+            evtCtrl[k0].evtStat = jret;
             numProc++;
         }
@@ -1981,9 +1986,9 @@
        int numProc = 0;
 
-       for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+       for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
        {
-           if (evtCtrl.evtStat[k0] <= 90 || evtCtrl.evtStat[k0] >= 1000)
+           if (evtCtrl[k0].evtStat <= 90 || evtCtrl[k0].evtStat >= 1000)
            {
-               if (evtCtrl.evtStat[k0] >= 0 && evtCtrl.evtStat[k0] < 90)
+               if (evtCtrl[k0].evtStat >= 0 && evtCtrl[k0].evtStat< 90)
                    numWait++;
 
@@ -1994,5 +1999,5 @@
            if (gi_resetR > 1)
            {
-               evtCtrl.evtStat[k0] = 9991;
+               evtCtrl[k0].evtStat = 9991;
                continue;
            }
@@ -2000,5 +2005,5 @@
            //-------- it is better to open the run already here, so call can be used to initialize
            //-------- buffers etc. needed to interprete run (e.g. DRS calibration)
-           const int id = evtCtrl.evtBuf[k0];
+           const int id = evtCtrl[k0].mBuffer_idx;
 
            const uint32_t irun = mBuffer[id].runNum;
@@ -2044,19 +2049,13 @@
 
                RUN_HEAD actRun;
-
-               actRun.Version = 1;
+               actRun.Version =  1;
                actRun.RunType = -1;  //to be adapted
-
-               actRun.Nroi   = runCtrl[lastRun].roi0;
-               actRun.NroiTM = runCtrl[lastRun].roi8;
-               //ETIENNE don't reset it to zero as it is taken care of in DataWriteFits
-               //                  if (actRun.Nroi == actRun.NroiTM)
-               //                     actRun.NroiTM = 0;
-               actRun.RunTime = runCtrl[lastRun].firstTime;
-               actRun.RunUsec = runCtrl[lastRun].firstUsec;
+               actRun.Nroi    = mBuffer[id].nRoi;      //runCtrl[lastRun].roi0;
+               actRun.NroiTM  = mBuffer[id].nRoiTM;    //runCtrl[lastRun].roi8;
+               actRun.RunTime = mBuffer[id].pcTime[0]; //runCtrl[lastRun].firstTime;
+               actRun.RunUsec = mBuffer[id].pcTime[1]; //runCtrl[lastRun].firstUsec;
                actRun.NBoard  = NBOARDS;
                actRun.NPix    = NPIX;
                actRun.NTm     = NTMARK;
-               actRun.Nroi    = mBuffer[id].nRoi;
 
                memcpy(actRun.FADhead, mBuffer[id].FADhead, NBOARDS*sizeof(PEVNT_HEADER));
@@ -2093,5 +2092,5 @@
            if (runCtrl[lastRun].procId != 0)
            {
-               evtCtrl.evtStat[k0] = 9091;
+               evtCtrl[k0].evtStat = 9091;
                continue;
            }
@@ -2100,5 +2099,5 @@
            //--------
 
-           const int roi = mBuffer[id].nRoi;
+           //const int roi = mBuffer[id].nRoi;
            //const int roiTM = mBuffer[id].nRoiTM;
 
@@ -2107,4 +2106,5 @@
            //                  if (roiTM == roi)
            //                     roiTM = 0;
+           /*
            for (int ip=0; ip<NPIX; ip++)
            {
@@ -2123,5 +2123,5 @@
                    memset(&mBuffer[id].fEvent->Adc_Data[dest], 0, roi * 2);
                }
-           }
+           }*/
 
            //and set correct event header ; also check for consistency in event (not yet)
@@ -2159,10 +2159,10 @@
            if (rc < 0)
            {
-               evtCtrl.evtStat[k0] = 9999;        //flag event to be skipped
+               evtCtrl[k0].evtStat = 9999;        //flag event to be skipped
                //gi.procErr++;
            }
            else
            {
-               evtCtrl.evtStat[k0] = 1000;
+               evtCtrl[k0].evtStat = 1000;
                runCtrl[lastRun].procEvt++;
            }
@@ -2194,8 +2194,8 @@
    }
 
-   for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+   for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    {
-       if (evtCtrl.evtStat[k0] >= 0 && evtCtrl.evtStat[k0] < 1000)
-           evtCtrl.evtStat[k0] = 9800;    //flag event as 'processed'
+       if (evtCtrl[k0].evtStat >= 0 && evtCtrl[k0].evtStat < 1000)
+           evtCtrl[k0].evtStat = 9800;    //flag event as 'processed'
    }
 
@@ -2271,5 +2271,5 @@
     runCtrl[j].closeTime = g_actTime - 1;
 
-    const int rc = runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]));
+    const int rc = runClose(runCtrl[j].fileHd, NULL, 0);//&runTail[j], sizeof(runTail[j]));
     if (rc<0)
     {
@@ -2314,9 +2314,9 @@
        int numWait  = 0;
 
-       for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
+       for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
        {
-           if (evtCtrl.evtStat[k0] <= 5000 || evtCtrl.evtStat[k0] >= 9000)
+           if (evtCtrl[k0].evtStat <= 5000 || evtCtrl[k0].evtStat >= 9000)
            {
-               if (evtCtrl.evtStat[k0] > 0 && evtCtrl.evtStat[k0] < 9000)
+               if (evtCtrl[k0].evtStat > 0 && evtCtrl[k0].evtStat < 9000)
                    numWait++;
 
@@ -2327,9 +2327,9 @@
            if (gi_resetR > 1)
            {
-               evtCtrl.evtStat[k0] = 9904;
+               evtCtrl[k0].evtStat = 9904;
                continue;
            }
 
-           const int id = evtCtrl.evtBuf[k0];
+           const int id = evtCtrl[k0].mBuffer_idx;
 
            const uint32_t irun = mBuffer[id].runNum;
@@ -2360,19 +2360,13 @@
            {
                RUN_HEAD actRun;
-
-               actRun.Version = 1;
+               actRun.Version =  1;
                actRun.RunType = -1;  //to be adapted
-
-               actRun.Nroi   = runCtrl[lastRun].roi0;
-               actRun.NroiTM = runCtrl[lastRun].roi8;
-               //ETIENNE don't reset it to zero as it is taken care of in DataWriteFits
-               //                  if (actRun.Nroi == actRun.NroiTM)
-               //                     actRun.NroiTM = 0;
-               actRun.RunTime = runCtrl[lastRun].firstTime;
-               actRun.RunUsec = runCtrl[lastRun].firstUsec;
+               actRun.Nroi    = mBuffer[id].nRoi;     //runCtrl[lastRun].roi0;
+               actRun.NroiTM  = mBuffer[id].nRoiTM;   //runCtrl[lastRun].roi8;
+               actRun.RunTime = mBuffer[id].pcTime[0];//runCtrl[lastRun].firstTime;
+               actRun.RunUsec = mBuffer[id].pcTime[1];//runCtrl[lastRun].firstUsec;
                actRun.NBoard  = NBOARDS;
                actRun.NPix    = NPIX;
                actRun.NTm     = NTMARK;
-               actRun.Nroi    = mBuffer[id].nRoi;
 
                memcpy(actRun.FADhead, mBuffer[id].FADhead, NBOARDS * sizeof (PEVNT_HEADER));
@@ -2400,5 +2394,5 @@
                }*/
 
-               evtCtrl.evtStat[k0] = 9903;
+               evtCtrl[k0].evtStat = 9903;
            }
 
@@ -2413,10 +2407,11 @@
                    runCtrl[lastRun].lastTime = g_actTime;
                    runCtrl[lastRun].actEvt++;
-                   evtCtrl.evtStat[k0] = 9901;
+
+                   evtCtrl[k0].evtStat = 9901;
                }
                else
                {
                    factPrintf(kError, 503, "writeEvt: Writing event for run %d failed (runWrite)", irun);
-                   evtCtrl.evtStat[k0] = 9902;
+                   evtCtrl[k0].evtStat = 9902;
                }
 
@@ -2543,6 +2538,6 @@
    }
 //partially initialize event control logics
-   evtCtrl.frstPtr = 0;
-   evtCtrl.lastPtr = 0;
+   evtCtrl_frstPtr = 0;
+   evtCtrl_lastPtr = 0;
 
 //start all threads (more to come) when we are allowed to ....