Ignore:
Timestamp:
05/01/13 09:46:42 (12 years ago)
Author:
tbretz
Message:
Moved the index to an array of elements instead of arrays of structure members; use the mBuffer to determine the roi and start time of the first event, runCtrl is not needed for that; removed the *.first* elements from the runCtrl structure, they are obsolete now; some minor renamings for easier readability; removed the need of RUN_TAIL (at the moment it is not used at all -- we can later implement it as part of the runCtrl again if necessary
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/src/EventBuilder.c

    r15461 r15463  
    7171
    7272
     73int evtCtrl_frstPtr;
     74int evtCtrl_lastPtr;
    7375
    7476
    … …  
    116118//uint gp_EvtTot  = 0 ;
    117119
    118 PIX_MAP g_pixMap[NPIX];
     120//PIX_MAP g_pixMap[NPIX];
    119121
    120122EVT_STAT gi;
    121123GUI_STAT gj;
    122124
    123 EVT_CTRL evtCtrl;               //control of events during processing
    124 int evtIdx[MAX_EVT * MAX_RUN];  //index from mBuffer to evtCtrl
    125 
    126 WRK_DATA mBuffer[MAX_EVT * MAX_RUN];    //local working space
     125//int evtIdx[MAX_EVT * MAX_RUN];  //index from mBuffer to evtCtrl
     126
     127EVT_CTRL evtCtrl[MAX_EVT * MAX_RUN]; //control of events during processing
     128WRK_DATA mBuffer[MAX_EVT * MAX_RUN]; //local working space
    127129
    128130//#define MXSTR 1000
    … …  
    322324
    323325RUN_CTRL runCtrl[MAX_RUN];
    324 RUN_TAIL runTail[MAX_RUN];
     326//RUN_TAIL runTail[MAX_RUN];
    325327
    326328
    … …  
    506508      mBuffer[i].runNum = 0;
    507509
    508       evtCtrl.evtBuf[i] = -1;
    509       evtCtrl.evtStat[i] = -1;
    510       evtCtrl.pcTime[i] = actime;       //initiate to far future
     510      evtCtrl[i].mBuffer_idx = -1;
     511      evtCtrl[i].evtStat = -1;
     512      //evtCtrl[i].lastRecv = actime;       //initiate to far future
    511513
    512514#ifdef ETIENNE_MALLOC
    … …  
    525527   //actRun.FADhead = malloc (NBOARDS * sizeof (PEVNT_HEADER));
    526528
    527    evtCtrl.frstPtr = 0;
    528    evtCtrl.lastPtr = 0;
     529   evtCtrl_frstPtr = 0;
     530   evtCtrl_lastPtr = 0;
    529531
    530532   return 0;
    … …  
    632634        if (runCtrl[k].runId == runID)
    633635        {
     636            // FIXME: Compare to previous event
    634637            if (runCtrl[k].roi0 != nRoi[0] || runCtrl[k].roi8 != nRoi[8])
    635638            {
    … …  
    694697
    695698        runCtrl[evFree].runId      = runID;
    696         runCtrl[evFree].roi0       = nRoi[0];
    697         runCtrl[evFree].roi8       = nRoi[8];
     699        runCtrl[evFree].roi0       = nRoi[0];  // FIXME: Make obsolete!
     700        runCtrl[evFree].roi8       = nRoi[8];  // FIXME: Make obsolete!
    698701        runCtrl[evFree].fileId     = -2;
    699702        runCtrl[evFree].procId     = -2;
    … …  
    702705        runCtrl[evFree].procEvt    = 0;         // Number of successfully checked events (checkEvent)
    703706        runCtrl[evFree].maxEvt     = 999999999; // max number events allowed
    704         runCtrl[evFree].firstTime  = tsec;
    705         runCtrl[evFree].firstUsec  = tusec;
     707        //runCtrl[evFree].firstTime  = tsec;
     708        //runCtrl[evFree].firstUsec  = tusec;
    706709        runCtrl[evFree].lastTime   = tsec;      // Time when the last event was written
    707710        runCtrl[evFree].closeTime  = tsec + 3600 * 24;     //max time allowed
    708 
     711/*
    709712        runTail[evFree].nEventsOk  = 0;
    710713        runTail[evFree].nEventsRej = 0;
    … …  
    712715        runTail[evFree].PCtime0    = 0;
    713716        runTail[evFree].PCtimeX    = 0;
     717        */
    714718    }
    715719
    … …  
    733737    mBuffer[i].Errors[3] = 0;
    734738    mBuffer[i].fEvent    = NULL;
    735     mBuffer[i].buffer    = NULL;
    736739    mBuffer[i].FADhead   = NULL;
     740    //mBuffer[i].buffer    = NULL;
    737741
    738742/*
    … …  
    787791{
    788792    mBuffer[i].fEvent = (EVENT*)((char*)mBuffer[i].FADhead+MAX_HEAD_MEM);
     793    memset(mBuffer[i].fEvent->Adc_Data, 0, (NPIX+NTMARK)*2*mBuffer[i].nRoi);
    789794
    790795    //flag all pixels as unused
    … …  
    834839
    835840//   free (mBuffer[i].buffer);
    836    mBuffer[i].buffer = NULL;
     841//   mBuffer[i].buffer = NULL;
    837842//END ETIENNE
    838843//   headmem = NBOARDS * sizeof (PEVNT_HEADER);
    … …  
    902907}*/ /*-----------------------------------------------------------------*/
    903908
    904 void reportIncomplete(int k0)
    905 {
    906     const int id = evtCtrl.evtBuf[k0];
    907 
    908     factPrintf(kWarn, 601, "%5d skip incomplete evt %8d %8d %2d",
    909                mBuffer[id].evNum, evtCtrl.evtBuf[k0], k0, evtCtrl.evtStat[k0]);
     909void reportIncomplete(int id)
     910{
     911    factPrintf(kWarn, 601, "%5d skip incomplete evt %8d",
     912               mBuffer[id].evNum, id);
    910913
    911914    uint64_t report = 0;
    … …  
    11741177
    11751178 START:
    1176    evtCtrl.frstPtr = 0;
    1177    evtCtrl.lastPtr = 0;
     1179   evtCtrl_frstPtr = 0;
     1180   evtCtrl_lastPtr = 0;
    11781181
    11791182   //time in seconds
    … …  
    15471550
    15481551              //register event in 'active list (reading)'
    1549               evtIdx[evID] = evtCtrl.lastPtr;
    1550 
    1551               evtCtrl.evtBuf[evtCtrl.lastPtr] = evID;
    1552               evtCtrl.evtStat[evtCtrl.lastPtr] = 0;
    1553               evtCtrl.pcTime[evtCtrl.lastPtr]  = g_actTime;
    1554 
    1555               evtCtrl.lastPtr++;
    1556               evtCtrl.lastPtr %= MAX_EVT * MAX_RUN;
     1552              mBuffer[evID].evtCtrl_idx = evtCtrl_lastPtr;
     1553
     1554              evtCtrl[evtCtrl_lastPtr].mBuffer_idx = evID;
     1555              evtCtrl[evtCtrl_lastPtr].evtStat = 0;
     1556              //evtCtrl[evtCtrl.lastPtr].pcTime  = g_actTime;
     1557
     1558              evtCtrl_lastPtr++;
     1559              evtCtrl_lastPtr %= MAX_EVT * MAX_RUN;
    15571560          }
    15581561
    … …  
    15911594          // now we have stored a new board contents into Event structure
    15921595
    1593           const int iDx = evtIdx[evID];       //index into evtCtrl
    1594 
    15951596          mBuffer[evID].fEvent->NumBoards++;
    15961597          mBuffer[evID].board[board] = board;
    15971598          mBuffer[evID].nBoard++;
    15981599
    1599           evtCtrl.evtStat[iDx] = mBuffer[evID].nBoard;
    1600           evtCtrl.pcTime[iDx]  = g_actTime;
     1600          const int iDx = mBuffer[evID].evtCtrl_idx;//evtIdx[evID];       //index into evtCtrl
     1601
     1602          evtCtrl[iDx].evtStat  = mBuffer[evID].nBoard;
     1603          //evtCtrl[iDx].lastRecv = g_actTime;
    16011604
    16021605          // have we already reported first (partial) event of this run ???
    … …  
    16401643
    16411644          // Flag that the event is ready for processing
    1642           evtCtrl.evtStat[iDx] = 99;
     1645          evtCtrl[iDx].evtStat = 99;
    16431646
    16441647      } // end for loop over all sockets
    … …  
    16571660      //loop over all active events and flag those older than read-timeout
    16581661      //delete those that are written to disk ....
    1659       for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     1662      for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    16601663      {
    1661           if (k0==evtCtrl.frstPtr && evtCtrl.evtStat[k0]<0)
     1664          if (k0==evtCtrl_frstPtr && evtCtrl[k0].evtStat<0)
    16621665          {
    1663               evtCtrl.frstPtr++;
    1664               evtCtrl.frstPtr %= MAX_EVT * MAX_RUN;
     1666              evtCtrl_frstPtr++;
     1667              evtCtrl_frstPtr %= MAX_EVT * MAX_RUN;
    16651668
    16661669              // Continue because evtCtrl.evtStat[k0] must be <0
    … …  
    16691672
    16701673          // Check the more likely case first: incomplete events
    1671           if (evtCtrl.evtStat[k0]>0 && evtCtrl.evtStat[k0]<92)
     1674          if (evtCtrl[k0].evtStat>0 && evtCtrl[k0].evtStat<92)
    16721675          {
    16731676              gj.bufNew++;     //incomplete event in Buffer
    16741677
    16751678              // Event has not yet timed out or was reported already
    1676               if (evtCtrl.evtStat[k0]>=90 || evtCtrl.pcTime[k0]>=g_actTime - 30)
     1679              const int id = evtCtrl[k0].mBuffer_idx;
     1680
     1681              if (evtCtrl[k0].evtStat>=90 || mBuffer[id].pcTime[0]/*evtCtrl[k0].lastRecv*/>=g_actTime - 30)
    16771682                  continue;
    16781683
    1679               reportIncomplete(k0);
     1684              reportIncomplete(id);
    16801685
    16811686              //timeout for incomplete events
    1682               evtCtrl.evtStat[k0] = 91;
     1687              evtCtrl[k0].evtStat = 91;
    16831688              gj.evtSkip++;
    16841689
    … …  
    16871692
    16881693          // complete event in Buffer
    1689           if (evtCtrl.evtStat[k0] >= 95)
     1694          if (evtCtrl[k0].evtStat >= 95)
    16901695              gj.bufEvt++;
    16911696
    16921697          // Check the less likely case: 'useless' or 'delete'
    1693           if (evtCtrl.evtStat[k0]==0 || evtCtrl.evtStat[k0] >= 9000)
     1698          if (evtCtrl[k0].evtStat==0 || evtCtrl[k0].evtStat >= 9000)
    16941699          {
    1695               const int id = evtCtrl.evtBuf[k0];
     1700              const int id = evtCtrl[k0].mBuffer_idx;
    16961701#ifdef EVTDEBUG
    16971702              factPrintf(kDebug, -1, "%5d free event buffer, nb=%3d", mBuffer[id].evNum, mBuffer[id].nBoard);
    16981703#endif
    16991704              mBufFree (id);   //event written--> free memory
    1700               evtCtrl.evtStat[k0] = -1;
     1705              evtCtrl[k0].evtStat = -1;
    17011706              gj.evtWrite++;
    17021707              gj.rateWrite++;
    … …  
    17821787   {
    17831788       //flag all events as 'read finished'
    1784       for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     1789      for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    17851790      {
    1786            if (evtCtrl.evtStat[k0] > 0 && evtCtrl.evtStat[k0] < 90)
     1791           if (evtCtrl[k0].evtStat > 0 && evtCtrl[k0].evtStat < 90)
    17871792           {
    1788                evtCtrl.evtStat[k0] = 91;
     1793               evtCtrl[k0].evtStat = 91;
    17891794               //gi.evtSkp++;
    17901795               //gi.evtTot++;
    … …  
    18101815         numclear = 0;
    18111816
    1812          for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     1817         for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    18131818         {
    1814              if (evtCtrl.evtStat[k0] > minclear)
     1819             if (evtCtrl[k0].evtStat > minclear)
    18151820             {
    1816                  const int id = evtCtrl.evtBuf[k0];
     1821                 const int id = evtCtrl[k0].mBuffer_idx;
    18171822#ifdef EVTDEBUG
    18181823                 factPrintf(kDebug, -1, "ev %5d free event buffer, nb=%3d", mBuffer[id].evNum, mBuffer[id].nBoard);
    18191824#endif
    18201825                 mBufFree (id);   //event written--> free memory
    1821                  evtCtrl.evtStat[k0] = -1;
     1826                 evtCtrl[k0].evtStat = -1;
    18221827             }
    18231828             else
    1824                  if (evtCtrl.evtStat[k0] > 0)
     1829                 if (evtCtrl[k0].evtStat > 0)
    18251830                     numclear++;      //writing is still ongoing...
    18261831
    1827              if (k0 == evtCtrl.frstPtr && evtCtrl.evtStat[k0] < 0)
     1832             if (k0 == evtCtrl_frstPtr && evtCtrl[k0].evtStat < 0)
    18281833             {
    1829                  evtCtrl.frstPtr++;
    1830                  evtCtrl.frstPtr %= MAX_EVT * MAX_RUN;
     1834                 evtCtrl_frstPtr++;
     1835                 evtCtrl_frstPtr %= MAX_EVT * MAX_RUN;
    18311836             }
    18321837         }
    … …  
    18821887        int numProc = 0;
    18831888
    1884         for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     1889        for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    18851890        {
    1886             if (!(evtCtrl.evtStat[k0] == 1000 + threadID))
     1891            if (evtCtrl[k0].evtStat != 1000 + threadID)
    18871892            {
    1888                 if (evtCtrl.evtStat[k0] < 1000 + threadID)
     1893                if (evtCtrl[k0].evtStat < 1000 + threadID)
    18891894                    numWait++;
    18901895
    … …  
    18981903            if (gi_resetR<=1)
    18991904            {
    1900                 const int id = evtCtrl.evtBuf[k0];
     1905                const int id = evtCtrl[k0].mBuffer_idx;
    19011906
    19021907                jret = subProcEvt(threadID, mBuffer[id].FADhead,
    1903                                   mBuffer[id].fEvent, mBuffer[id].buffer);
     1908                                  mBuffer[id].fEvent, NULL/*mBuffer[id].buffer*/);
    19041909
    19051910
    … …  
    19151920            }
    19161921
    1917             evtCtrl.evtStat[k0] = jret;
     1922            evtCtrl[k0].evtStat = jret;
    19181923            numProc++;
    19191924        }
    … …  
    19811986       int numProc = 0;
    19821987
    1983        for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     1988       for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    19841989       {
    1985            if (evtCtrl.evtStat[k0] <= 90 || evtCtrl.evtStat[k0] >= 1000)
     1990           if (evtCtrl[k0].evtStat <= 90 || evtCtrl[k0].evtStat >= 1000)
    19861991           {
    1987                if (evtCtrl.evtStat[k0] >= 0 && evtCtrl.evtStat[k0] < 90)
     1992               if (evtCtrl[k0].evtStat >= 0 && evtCtrl[k0].evtStat< 90)
    19881993                   numWait++;
    19891994
    … …  
    19941999           if (gi_resetR > 1)
    19952000           {
    1996                evtCtrl.evtStat[k0] = 9991;
     2001               evtCtrl[k0].evtStat = 9991;
    19972002               continue;
    19982003           }
    … …  
    20002005           //-------- it is better to open the run already here, so call can be used to initialize
    20012006           //-------- buffers etc. needed to interprete run (e.g. DRS calibration)
    2002            const int id = evtCtrl.evtBuf[k0];
     2007           const int id = evtCtrl[k0].mBuffer_idx;
    20032008
    20042009           const uint32_t irun = mBuffer[id].runNum;
    … …  
    20442049
    20452050               RUN_HEAD actRun;
    2046 
    2047                actRun.Version = 1;
     2051               actRun.Version =  1;
    20482052               actRun.RunType = -1;  //to be adapted
    2049 
    2050                actRun.Nroi   = runCtrl[lastRun].roi0;
    2051                actRun.NroiTM = runCtrl[lastRun].roi8;
    2052                //ETIENNE don't reset it to zero as it is taken care of in DataWriteFits
    2053                //                  if (actRun.Nroi == actRun.NroiTM)
    2054                //                     actRun.NroiTM = 0;
    2055                actRun.RunTime = runCtrl[lastRun].firstTime;
    2056                actRun.RunUsec = runCtrl[lastRun].firstUsec;
     2053               actRun.Nroi    = mBuffer[id].nRoi;      //runCtrl[lastRun].roi0;
     2054               actRun.NroiTM  = mBuffer[id].nRoiTM;    //runCtrl[lastRun].roi8;
     2055               actRun.RunTime = mBuffer[id].pcTime[0]; //runCtrl[lastRun].firstTime;
     2056               actRun.RunUsec = mBuffer[id].pcTime[1]; //runCtrl[lastRun].firstUsec;
    20572057               actRun.NBoard  = NBOARDS;
    20582058               actRun.NPix    = NPIX;
    20592059               actRun.NTm     = NTMARK;
    2060                actRun.Nroi    = mBuffer[id].nRoi;
    20612060
    20622061               memcpy(actRun.FADhead, mBuffer[id].FADhead, NBOARDS*sizeof(PEVNT_HEADER));
    … …  
    20932092           if (runCtrl[lastRun].procId != 0)
    20942093           {
    2095                evtCtrl.evtStat[k0] = 9091;
     2094               evtCtrl[k0].evtStat = 9091;
    20962095               continue;
    20972096           }
    … …  
    21002099           //--------
    21012100
    2102            const int roi = mBuffer[id].nRoi;
     2101           //const int roi = mBuffer[id].nRoi;
    21032102           //const int roiTM = mBuffer[id].nRoiTM;
    21042103
    … …  
    21072106           //                  if (roiTM == roi)
    21082107           //                     roiTM = 0;
     2108           /*
    21092109           for (int ip=0; ip<NPIX; ip++)
    21102110           {
    … …  
    21232123                   memset(&mBuffer[id].fEvent->Adc_Data[dest], 0, roi * 2);
    21242124               }
    2125            }
     2125           }*/
    21262126
    21272127           //and set correct event header ; also check for consistency in event (not yet)
    … …  
    21592159           if (rc < 0)
    21602160           {
    2161                evtCtrl.evtStat[k0] = 9999;        //flag event to be skipped
     2161               evtCtrl[k0].evtStat = 9999;        //flag event to be skipped
    21622162               //gi.procErr++;
    21632163           }
    21642164           else
    21652165           {
    2166                evtCtrl.evtStat[k0] = 1000;
     2166               evtCtrl[k0].evtStat = 1000;
    21672167               runCtrl[lastRun].procEvt++;
    21682168           }
    … …  
    21942194   }
    21952195
    2196    for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     2196   for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    21972197   {
    2198        if (evtCtrl.evtStat[k0] >= 0 && evtCtrl.evtStat[k0] < 1000)
    2199            evtCtrl.evtStat[k0] = 9800;    //flag event as 'processed'
     2198       if (evtCtrl[k0].evtStat >= 0 && evtCtrl[k0].evtStat < 1000)
     2199           evtCtrl[k0].evtStat = 9800;    //flag event as 'processed'
    22002200   }
    22012201
    … …  
    22712271    runCtrl[j].closeTime = g_actTime - 1;
    22722272
    2273     const int rc = runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]));
     2273    const int rc = runClose(runCtrl[j].fileHd, NULL, 0);//&runTail[j], sizeof(runTail[j]));
    22742274    if (rc<0)
    22752275    {
    … …  
    23142314       int numWait  = 0;
    23152315
    2316        for (int k0=evtCtrl.frstPtr; k0!=evtCtrl.lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
     2316       for (int k0=evtCtrl_frstPtr; k0!=evtCtrl_lastPtr; k0++, k0 %= MAX_EVT*MAX_RUN)
    23172317       {
    2318            if (evtCtrl.evtStat[k0] <= 5000 || evtCtrl.evtStat[k0] >= 9000)
     2318           if (evtCtrl[k0].evtStat <= 5000 || evtCtrl[k0].evtStat >= 9000)
    23192319           {
    2320                if (evtCtrl.evtStat[k0] > 0 && evtCtrl.evtStat[k0] < 9000)
     2320               if (evtCtrl[k0].evtStat > 0 && evtCtrl[k0].evtStat < 9000)
    23212321                   numWait++;
    23222322
    … …  
    23272327           if (gi_resetR > 1)
    23282328           {
    2329                evtCtrl.evtStat[k0] = 9904;
     2329               evtCtrl[k0].evtStat = 9904;
    23302330               continue;
    23312331           }
    23322332
    2333            const int id = evtCtrl.evtBuf[k0];
     2333           const int id = evtCtrl[k0].mBuffer_idx;
    23342334
    23352335           const uint32_t irun = mBuffer[id].runNum;
    … …  
    23602360           {
    23612361               RUN_HEAD actRun;
    2362 
    2363                actRun.Version = 1;
     2362               actRun.Version =  1;
    23642363               actRun.RunType = -1;  //to be adapted
    2365 
    2366                actRun.Nroi   = runCtrl[lastRun].roi0;
    2367                actRun.NroiTM = runCtrl[lastRun].roi8;
    2368                //ETIENNE don't reset it to zero as it is taken care of in DataWriteFits
    2369                //                  if (actRun.Nroi == actRun.NroiTM)
    2370                //                     actRun.NroiTM = 0;
    2371                actRun.RunTime = runCtrl[lastRun].firstTime;
    2372                actRun.RunUsec = runCtrl[lastRun].firstUsec;
     2364               actRun.Nroi    = mBuffer[id].nRoi;     //runCtrl[lastRun].roi0;
     2365               actRun.NroiTM  = mBuffer[id].nRoiTM;   //runCtrl[lastRun].roi8;
     2366               actRun.RunTime = mBuffer[id].pcTime[0];//runCtrl[lastRun].firstTime;
     2367               actRun.RunUsec = mBuffer[id].pcTime[1];//runCtrl[lastRun].firstUsec;
    23732368               actRun.NBoard  = NBOARDS;
    23742369               actRun.NPix    = NPIX;
    23752370               actRun.NTm     = NTMARK;
    2376                actRun.Nroi    = mBuffer[id].nRoi;
    23772371
    23782372               memcpy(actRun.FADhead, mBuffer[id].FADhead, NBOARDS * sizeof (PEVNT_HEADER));
    … …  
    24002394               }*/
    24012395
    2402                evtCtrl.evtStat[k0] = 9903;
     2396               evtCtrl[k0].evtStat = 9903;
    24032397           }
    24042398
    … …  
    24132407                   runCtrl[lastRun].lastTime = g_actTime;
    24142408                   runCtrl[lastRun].actEvt++;
    2415                    evtCtrl.evtStat[k0] = 9901;
     2409
     2410                   evtCtrl[k0].evtStat = 9901;
    24162411               }
    24172412               else
    24182413               {
    24192414                   factPrintf(kError, 503, "writeEvt: Writing event for run %d failed (runWrite)", irun);
    2420                    evtCtrl.evtStat[k0] = 9902;
     2415                   evtCtrl[k0].evtStat = 9902;
    24212416               }
    24222417
    … …  
    25432538   }
    25442539//partially initialize event control logics
    2545    evtCtrl.frstPtr = 0;
    2546    evtCtrl.lastPtr = 0;
     2540   evtCtrl_frstPtr = 0;
     2541   evtCtrl_lastPtr = 0;
    25472542
    25482543//start all threads (more to come) when we are allowed to ....
Note: See TracChangeset for help on using the changeset viewer.