SCC/TFndSCCMan.cxx

// @(#)fROOT/SCC:$Name:  $:$Id: TFndSCCMan.cxx,v 1.43 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/02/07

//                                                       //
//   Control class for the FINUDA Slow Control Manager   //
//                                                       //
// - If you need to debug SCC you must set the           //
//     "K_DEBUG_LEV" in the "TFndSCCStd" namespace       //
//                                                       //
// - Low voltages status reading is handled apart.       //
//                                                       //
// - Raw data are handled by the TFndSCCRaw parent class //
//                                                       //

#include "TFndSCCMan.h"

#include "TDatime.h"

#if defined(__CINT__)
#include <netinet/in.h>
#endif
#include <sys/ioctl.h>
#include <sys/socket.h>

ClassImp(TFndSCCMan) // Manager of the Slow-Control-Manager

TFndSCCMan *gSCCManager;

//_________________________
TFndSCCMan::TFndSCCMan():
  fReceiveThread(),
  fSockDescr(),fLocSockAddr(),fCurReceivedEv(),
  fSendThread(),fCurSent(),
  fTimer(),fUpdateInterval(),fCounterUpdate(),fRatioUpdate(),
  fMustSendToDAQ(),fMustSaveLocalRaw(),
  fSendingData(),
  fCurLogFile(),fCurOutRawFile()
{
  Init();
}

//_________________________
TFndSCCMan::~TFndSCCMan(){

  StopAllThreads();

  // Now perform delete operations
  Printf("Performing delete operations.");
  
  delete fTimer;

  // ---
  gSCCManager = 0;
}

//_________________________
void TFndSCCMan::Init(){
  
  gSCCManager = this;

  fCounterUpdate = 0;
  fRatioUpdate = 6;
  // set the update interval for raw-saving
  // (text logging will be performed every "fRatioUpdate" raw-updates)
  //fUpdateInterval = 10; // seconds 
  fUpdateInterval = 300; // seconds
  
  fTimer = new TTimer();  
  fTimer->Connect("Timeout()","TFndSCCMan",this,"ScheduledOperation()");

  fSendingData = kFALSE;
  //   fSend_GUI_comm = E_SCC_MAN_GuiComm_Idle;
  
  //   fLogFilesPath[(Int_t) E_SCC_Log_Status] = "/data02/SHARED_online/SCC/scc_log";
  //   fLogFilesPath[(Int_t) E_SCC_Log_Store] = "/data02/SHARED_online/SCC/scc_log_data_store";
  //   fRawFilesPath = "/data02/SHARED_online/SCC/scc_raw_data";
  fLogFilesPath[(Int_t) E_SCC_Log_Status] = gSystem->ExpandPathName("$FND_SCC_LOG");
  fLogFilesPath[(Int_t) E_SCC_Log_Store] = gSystem->ExpandPathName("$FND_SCC_LOG_DATA_STORE");
  fRawFilesPath = gSystem->ExpandPathName("$FND_SCC_RAW");
  
}

//______________________
void TFndSCCMan::StopAllThreads(){
  //  Remember TThread states:
  //    enum EState {
  //       kInvalidState,            // thread was not created properly
  //       kNewState,                // thread object exists but hasn't started
  //       kRunningState,            // thread is running
  //       kTerminatedState,         // thread has terminated but storage has not
  //                                 // yet been reclaimed (i.e. waiting to be joined)
  //       kFinishedState,           // thread has finished
  //       kCancelingState,          // thread in process of canceling
  //       kCanceledState,           // thread has been canceled
  //       kDeletingState            // thread in process of deleting
  //    };

  // Stop all receiver threads
  for(Int_t slow_id=0;slow_id<K_N_SLOWS;slow_id++){
    StopReceiveThread(slow_id);
    usleep(80000);
  }
  Printf("All receiver threads succesfully stopped.");

  StopSendThread();  
  Printf("Sender thread succesfully stopped.");

  for(Int_t i=(Int_t)E_SCC_Log_Status; i< (Int_t)E_SCC_Log_End; i++){
    CloseLogFile((E_SCC_LogType)i);
  }
  CloseRawFile(); //  not really needed, but safe
}

//______________________
void* TFndSCCMan::Receiver(void *arg){
  //  enum SlowSocksIn_e {SOCK_TOFI = 0, SOCK_TOFO, SOCK_LMD, SOCK_STB, SOCK_GAS, SOCK_SIL, SOCK_SIL_MSG, SOCK_MAG};
  //  enum SlowDetectors_e {TOFI = 0,      TOFO,      LMD,      STB,      GAS,      SIL,        (SIL),      MAG};

  Int_t sock_idx = (Int_t)(arg);
  Int_t slow_det = gSCCManager->SockId2SlowId(sock_idx);
  
  TThread::SetCancelOff();
  TThread::SetCancelDeferred();

  Printf("Starting receiver thread for \"%s\" (UDP port: %i)",fSlowDetNames[slow_det].Data(),K_SLOW_UDP_PORT[sock_idx]);

  Int_t SkDesc = gSCCManager->GetSocketDescriptor(sock_idx);
  UInt_t LocLength;
  //fCurReceivedEv[slow_det]
  UInt_t RawData[K_SLOW_SOCK_LEN] = {0};
  struct sockaddr_in ShrSockAddr; // used to share data via socket
  LocLength=sizeof(gSCCManager->GetLocSockAddr(sock_idx)); // do not remove this line (otherwise...segmentation fault)
    
  Int_t istop = 0;
  while(istop == 0) {
    TThread::CancelPoint();
    Int_t is_there_data=0;
    
    if(gSCCManager->fSendingData == kTRUE){
      gROOT->Info("TFndSCCMan::Receiver","Now sending data (waiting...)");
      //     TThread::Sleep(0,100000);
      usleep(100000);
      //      gROOT->Info("TFndSCCMan::Receiver","...\b");
      usleep(50000);
      continue;
    }


    if(K_DEBUG_LEV > 1) Printf(" ---> waiting for a new event (%s)",fSlowDetNames[slow_det].Data());
    
    while(is_there_data == 0){
      TThread::CancelPoint();
      ioctl(SkDesc,FIONREAD,(Int_t *)&is_there_data);
      if(is_there_data) break;
      usleep(100000);
    }
    /*    
    do {
      TThread::CancelPoint();
      //cout << "check socket " << ++nn << endl;
      usleep(10000);
      ioctl(SkDesc,FIONREAD,(Int_t *)&is_there_data);
    } while (is_there_data == 0);
    */

    Int_t nread = recvfrom(SkDesc, (char*)RawData, sizeof(RawData),0 ,(struct sockaddr*) &ShrSockAddr ,&LocLength);
    gSCCManager->IncrReceivedEv(sock_idx);
    //    const Int_t n_words = nread/4;
    if(K_DEBUG_LEV > 0) Printf(" ---> %s UDP packet received: nread = %i (event %i);",fSlowDetNames[slow_det].Data(),nread,gSCCManager->GetReceivedEv(sock_idx));
    TThread::CancelPoint();
    Int_t dpart = 0;
    if(sock_idx == SOCK_SIL_MSG){ // SIL messages (every 6 seconds)
      dpart = 1;
      if(K_DEBUG_LEV > 0) {
        Printf("+++++++ SIL MESSAGE REPORT ++++++++");
        Printf("%s",(Char_t *) RawData);
        Printf("+++++++++++++++++++++++++++++++");
      }
    }
    else if(sock_idx == SOCK_SIL){ // SIL complete report (every minute)
      dpart = 2;
      if(K_DEBUG_LEV > 0) {
        Printf("+++++++ SIL COMPLETE REPORT ++++++++");
        Printf("%s",(Char_t *) RawData);
        Printf("+++++++++++++++++++++++++++++++");
      }
      gSCCManager->GetSilRecode() -> SetReceivedString(RawData);
      gSCCManager->GetSilRecode() -> ReadSilString();
      gSCCManager->GetSilRecode() -> ReBuildSilSlowRaw();
      
      UInt_t *silraw = gSCCManager->GetSilRecode() ->GetRawBuf();
      
      bzero(RawData,sizeof(RawData));
      memcpy(RawData, silraw, silraw[0] );
    }
    
    
    gSCCManager->SetSingleRawData(slow_det,RawData,dpart);
    gSCCManager->ReceivedEvent(slow_det,dpart);

  }
  return 0;
}

//______________________
// void* TFndSCCMan::Sender(void *arg){
//   // The GUI management must be drivedn within
//   // a dedicated thread (this method)

//   Printf("sender thread running...still doing nothing");

//   while(1){
//     //     Printf("===> Waiting for sending");
//     Int_t tout = 0;
//     while(tout<100){
//       if(gSCCManager->fSend_GUI_comm != E_SCC_MAN_GuiComm_Idle) break;
//       usleep(50000);
//     }

//     //     gSCCManager->PerformingScheduledOperation(); // implemented in GUI
    
//     //     gSCCManager->ScheduledOperationPerformed(); // implemented in GUI 
//     gSCCManager->fSend_GUI_comm = E_SCC_MAN_GuiComm_Idle;
//   }
  
//   return 0;
// }

//_________________________
Int_t TFndSCCMan::IsSingleReceiveThreadRunning(Int_t sock_idx){
  // -1: Thread not found
  // != -1: Thread state
  
  Int_t slow_det = SockId2SlowId(sock_idx);
  if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSingleReceiveThreadRunning ---> Checking thread state for %s (socket id: %d)",fSlowDetNames[slow_det].Data(),sock_idx);
  if(K_DEBUG_LEV > 2){
    TThread::Ps();
    Printf("Thread address: %d",fReceiveThread[sock_idx]);
  }
  
  if(!fReceiveThread[sock_idx]){
    if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSingleReceiveThreadRunning ---> Thread not found.");
    return -1;
  }
  
  Int_t state = fReceiveThread[sock_idx]->GetState();
  if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSingleReceiveThreadRunning ---> Thread state ID is %d",state);
  
  if(K_DEBUG_LEV > 1){
    if(state != TThread::kRunningState) Printf("TFndSCCMan::IsSingleReceiveThreadRunning ---> Thread found, but not running");
    else Printf("TFndSCCMan::IsSingleReceiveThreadRunning ---> Thread found: running.");
  }
  return state; 
}

//_________________________
Int_t TFndSCCMan::StartSingleReceiveThread(Int_t sock_idx){

  Int_t slow_det = SockId2SlowId(sock_idx);
  TString th_name = TString("Receiver_");
  th_name+=fSlowDetNames[slow_det];
  if(sock_idx == SOCK_SIL_MSG) th_name+="_msg";

  Printf("Starting new receiver thread (\"%s\")",fSlowDetNames[slow_det].Data());

  UInt_t LocLength=sizeof(fLocSockAddr[sock_idx]); // do not remove this line (otherwise...segmentation fault)               

  // reset (and set) fLocSockAddr[sock_idx]
  bzero((Char_t *)&fLocSockAddr[sock_idx], LocLength);
  fLocSockAddr[sock_idx].sin_family      = AF_INET; // (TCP-IP addressing)
  fLocSockAddr[sock_idx].sin_addr.s_addr = INADDR_ANY; // receive requests from any ip-address 
  //  fLocSockAddr[sock_idx].sin_addr.s_addr = htonl(0x7f000001); // receive requests the specified ip-address 
  fLocSockAddr[sock_idx].sin_port = htons(K_SLOW_UDP_PORT[sock_idx]); // UDP port used to send data

  // create new socket and get the socket descriptor
  /* create socket */
  if ( (fSockDescr[sock_idx] = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { // UDP (datagram) socket
    perror("Socket creation error");
    return 0; // relace with enum errors
  }

  //  fSockDescr[sock_idx] = socket(AF_INET, SOCK_DGRAM, 0);
  if(K_DEBUG_LEV > 0) Printf("New socket created with socket descriptor = %d; now binding it...",fSockDescr[sock_idx]);
  Int_t bind_output = bind(fSockDescr[sock_idx],(struct sockaddr*) &fLocSockAddr[sock_idx], LocLength);
  if(K_DEBUG_LEV > 0) Printf("...done ( bind_output= %d)",bind_output);
  // tell this socket to be a "server" ("send requests")
  setsockopt(fSockDescr[sock_idx],SOL_SOCKET,SO_SNDBUF,&K_SLOW_SOCK_LEN,sizeof(K_SLOW_SOCK_LEN)); // optional

  // -----------------------------
  //  fReceiveThread[sock_idx] = new TThread(th_name,(void(*)(void *))(&Receiver),(void *)this);
  fReceiveThread[sock_idx] = new TThread(th_name,Receiver,(void *)sock_idx);
  //  fReceiveThread[sock_idx] = new TThread(th_name,(void(*)(void *))(&Receiver),(void *)sock_idx);
  if(K_DEBUG_LEV > 1) TThread::Ps();
  fReceiveThread[sock_idx]->Run();
  return 0; // relace with enum errors

}

//_________________________
Int_t TFndSCCMan::StopSingleReceiveThread(Int_t sock_idx){

  Int_t slow_det = SockId2SlowId(sock_idx);
  TString ThName = "Receiver_"; ThName+=fSlowDetNames[slow_det];

  //fReceiveThread[sock_idx]
  //  TThread *fReceiveThread[sock_idx] = (TThread *)(TThread::GetThread(ThName));

  if(!fReceiveThread[sock_idx]){
    if(K_DEBUG_LEV > 0) Printf("%s thread not found",ThName.Data());    
    return -1;
  }
  if(fReceiveThread[sock_idx]->GetState() != TThread::kRunningState){
    if(K_DEBUG_LEV > 0) Printf("%s thread found, but not running",fReceiveThread[sock_idx]->GetName()); 
    return -2;
  }

  Printf("Stopping receiver thread (%s)",fReceiveThread[sock_idx]->GetName());
  fReceiveThread[sock_idx]->Kill();
  TThread::Delete(fReceiveThread[sock_idx]);
  delete fReceiveThread[sock_idx];
  fReceiveThread[sock_idx] = 0;
  if(K_DEBUG_LEV > 0) Printf("Now closing socket (socket descriptor = %d)",fSockDescr[sock_idx]);
  //  Int_t close_output = shutdown(fSockDescr[sock_idx],2);
  Int_t close_output = close(fSockDescr[sock_idx]);
  if(K_DEBUG_LEV > 0) Printf("...done ( bind_output= %d)",close_output);   
  else Printf("...done");   
  return 0;
}

//_________________________
Int_t TFndSCCMan::IsReceiveThreadRunning(Int_t slow_det){
  // -1: Thread not found
  // != -1: Thread state

  Int_t ret_val[2] = {0};
  Int_t sock_idx[2] = {0};
  sock_idx[0] = SlowId2SockId(slow_det,1);
  sock_idx[1] = SlowId2SockId(slow_det,2);

  ret_val[0] = IsSingleReceiveThreadRunning(sock_idx[0]);
  if(sock_idx[1] != -1) ret_val[1] = IsSingleReceiveThreadRunning(sock_idx[1]);
  else return ret_val[0];

  if(ret_val[0] == -1 && ret_val[1] == -1){
    if(K_DEBUG_LEV > 0) Printf(" TFndSCCMan::IsReceiveThreadRunning ---> Thread not found for slow_det %d",slow_det);
    return -1; 
  }

  if(ret_val[0] != ret_val[1]) Printf("Warning in TFndSCCMan::IsReceiveThreadRunning ---> No match between two threads");
  return ret_val[0];
}

//_________________________
Int_t TFndSCCMan::StartReceiveThread(Int_t slow_det){
  // two threads must start for SIL event reception
  
  Int_t ret_val[2] = {0}; // could be replaced with enum_Thread_ERR_VAL

  Int_t sock_idx[2] = {0};
  sock_idx[0] = SlowId2SockId(slow_det,1);
  sock_idx[1] = SlowId2SockId(slow_det,2);
  ret_val[0] = StartSingleReceiveThread(sock_idx[0]);

  if(sock_idx[1] != -1) ret_val[1] = StartSingleReceiveThread(sock_idx[1]);

  Int_t  ret_tot = 0;   // further conditions on ret_val[0] ret_val[1]
  return ret_tot;

}

//_________________________
Int_t TFndSCCMan::StopReceiveThread(Int_t slow_det){
  // return value:
  //               0: thread succesfully stopped
  //              -1: thread not found
  //              -2: thread found but not running

  Int_t ret_val[2] = {0}; // could be replaced with enum_Thread_ERR_VAL

  Int_t sock_idx[2] = {0};
  sock_idx[0] = SlowId2SockId(slow_det,1);
  sock_idx[1] = SlowId2SockId(slow_det,2);
  ret_val[0] = StopSingleReceiveThread(sock_idx[0]);
  if(sock_idx[1] != -1) ret_val[1] = StopSingleReceiveThread(sock_idx[1]);

  Int_t  ret_tot = 0;   // further conditions on ret_val[0] ret_val[1]
  return ret_tot;

}

//_________________________
Int_t TFndSCCMan::StartSendThread(){
  // used also for saving local raw-data
  
  fTimer->Start(fUpdateInterval * 1000, kFALSE);   // kTRUE:single-shot ; kFALSE:repetitive          
  fTimer->TurnOn();

  //   Info("StartSendThread","Starting sender (and save) thread");
  //   fSendThread = new TThread("SCC_SenderThread",Sender,(void*)0);
  //   fSendThread->Run();
  //   Info("StartSendThread","Sender (and save) thread started");

  // --- log-file name management  (status of detectors)
  TString cur_lognam = "";
  for(Int_t lognum = 1; lognum <= 99999; lognum++){
    cur_lognam = "";
    TString lnum_str = "";
    lnum_str += lognum;
    while(lnum_str.Sizeof() < 6 ) lnum_str.Prepend("0");
    cur_lognam.Form("SCC_%s.log",lnum_str.Data());
    
    TString chkstr = "";
    chkstr.Form( "%s/%s",fLogFilesPath[(Int_t) E_SCC_Log_Status].Data(),cur_lognam.Data() );
    if( gSystem->AccessPathName(chkstr.Data()) ) break;
  }
  
  OpenLogFile(E_SCC_Log_Status,fLogFilesPath[(Int_t) E_SCC_Log_Status], cur_lognam.Data(),kFALSE);
  WriteLogFile(E_SCC_Log_Status,"Date\t\tTime\t\tTOFINO\tSIL\tLMD\tSTB\tTOFONE\tGAS");

  // --- log-file name management  (status of detectors)
  for(Int_t lognum = 1; lognum <= 99999; lognum++){
    cur_lognam = "";
    TString lnum_str = "";
    lnum_str += lognum;
    while(lnum_str.Sizeof() < 6 ) lnum_str.Prepend("0");
    cur_lognam.Form("SCC_data_store_%s.log",lnum_str.Data());
    
    TString chkstr = "";
    chkstr.Form( "%s/%s",fLogFilesPath[(Int_t) E_SCC_Log_Store].Data(),cur_lognam.Data() );
    if( gSystem->AccessPathName(chkstr.Data()) ) break;
  }
  
  OpenLogFile(E_SCC_Log_Store,fLogFilesPath[(Int_t) E_SCC_Log_Store], cur_lognam.Data(),kFALSE);
  TString st_tit = "\n  --------------------------------------------\n";
  st_tit += " |              SCC Data store log            |\n";
  st_tit += "  --------------------------------------------\n\n";
  WriteLogFile(E_SCC_Log_Store,st_tit);

  return 0;
}

//_________________________
Int_t TFndSCCMan::StopSendThread(){
  // used also for saving local raw-data
  
  fTimer->TurnOff();

  TString ThName = "SCC_SenderThread";
  if(!fSendThread){
    if(K_DEBUG_LEV > 0) Printf("%s thread not found",ThName.Data());    
    return -1;
  }
  if(fSendThread->GetState() != TThread::kRunningState){
    if(K_DEBUG_LEV > 0) Printf("%s thread found, but not running",fSendThread->GetName());      
    return -2;
  }
  
  Printf("Stopping sender thread (%s)",fSendThread->GetName());
  fSendThread->Kill();
  TThread::Delete(fSendThread);
  delete fSendThread;
  fSendThread = 0;
  
  return 0;
}

//_________________________
Int_t TFndSCCMan::IsSendThreadThreadRunning(){
  // return value: -1: Thread not found ; != -1: Thread state

  if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSendThreadRunning ---> Checking thread state...");
  if(K_DEBUG_LEV > 2){
    TThread::Ps();
    Printf("Thread address: %d",fSendThread);
  }
  
  if(!fSendThread){
    if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSendThreadRunning ---> Thread not found.");
    return -1;
  }
  
  Int_t state = fSendThread->GetState();
  if(K_DEBUG_LEV > 1) Printf("TFndSCCMan::IsSendThreadRunning ---> Thread state ID is %d",state);
  
  if(K_DEBUG_LEV > 1){
    if(state != TThread::kRunningState) Printf("TFndSCCMan::IsSendThreadRunning ---> Thread found, but not running");
    else Printf("TFndSCCMan::IsSendThreadRunning ---> Thread found: running.");
  }
  return state; 
  
}

//_________________________
// void TFndSCCMan::ReceivedEvent(Int_t slow_det,Int_t part) {
//   // "part" is used by SIL only (messages and data are asynchronous):
//   //                            1: Message (or complete data)
//   //                            2: Data
//   //
//   //
//   // This method is called by every receiver thread
//   // this method is virtual: it must be implemented
//   // within the daughter class
//   //
//   // NOTE: The SetSingleRawData method is called previousely

//   //  Int_t slow_det = SockId2SlowId(sock_idx);
//   Int_t sock_idx = SlowId2SockId(slow_det, part);
//   if(K_DEBUG_LEV > 0) Printf("TFndSCCMan standard ReceivedEvent method for socket_id %d",sock_idx);
//   if(K_DEBUG_LEV > 1) PrintHeader(slow_det);  
//   if(K_DEBUG_LEV > 2) PrintBuffer(slow_det);  
// }

//_________________________
Int_t TFndSCCMan::SockId2SlowId(Int_t sock_idx){  
  // -999 is returned in case of errors
  Int_t slow_det = -1;
  
  switch(sock_idx){
  case SOCK_TOFI: slow_det = TOFI; break;
  case SOCK_TOFO: slow_det = TOFO; break;
  case SOCK_LMD : slow_det = LMD; break;
  case SOCK_STB : slow_det = STB; break;
  case SOCK_GAS : slow_det = GAS; break;
  case SOCK_SIL : slow_det = SIL; break;
  case SOCK_SIL_MSG: slow_det = SIL; break;
  case SOCK_MAG : slow_det = MAG; break;
  default: Printf("TFndSCCMan::Receiver BUG! socket index \"%i\" not available!",sock_idx); return -999;
  }
  return slow_det;
}

//_________________________
Int_t TFndSCCMan::SlowId2SockId(Int_t slow_det,Int_t part){  
  // "part" is used by SIL only (messages and data are asynchronous):
  //                            1: complete Data
  //                            2: Message
  //
  // -999 is returned in case of errors

  if(part==2 && slow_det!=SIL) return -1; // "part = 2" is available for SIL only
  switch(slow_det){
  case TOFI: return SOCK_TOFI; break;
  case TOFO: return SOCK_TOFO; break;
  case LMD : return SOCK_LMD; break;
  case STB : return SOCK_STB; break;
  case GAS : return SOCK_GAS; break;
  case SIL : 
    if(part==1) return SOCK_SIL_MSG;
    else if(part==2) return SOCK_SIL;
    else Printf("TFndSCCMan::SlowId2SockId BUG!");
    break;
  case MAG : return SOCK_MAG; break;
  default: Printf("TFndSCCMan::Receiver BUG! slow detector index \"%i\" not available!",slow_det); return -999;
  }
  Printf("TFndSCCMan::Receiver BUG! You should never read this message!");
  return -999;
}

//_________________________
void TFndSCCMan::PrintSlowDetDataValues(Int_t slow_det){

  if( !IsDataReady(slow_det) ) return;

  for(UInt_t ch=0;ch<fSingleRawData[slow_det][HdrDet_nchans];ch++){
    UInt_t data_offset =  (UInt_t)( (fSingleRawData[slow_det][HdrDet_dataoff]) / 4);
    UInt_t entry = fSingleRawData[slow_det][data_offset + ch];
    
    Bool_t power;
    UInt_t voltage;
    UInt_t current;
    Bool_t trip;
    DecodeDataElement(entry, power, voltage, current, trip);

    // Bad encoding from STB Slow-Control machine
    //      ( FINUDA data-taking 2006/2007 )
    if( slow_det == (Int_t)(STB) ){
      TDatime StbSysTime(fSingleRawData[(Int_t)(STB)][(Int_t)(HdrDet_systime)]);
      if(StbSysTime.Convert() <= FROOT::DTak_2006_SftwStopTime) power = !power;
    }

    TString pow_str = (power) ? "ON" : "OFF";
    TString trip_str =   (trip) ? "TRIP!" : "";  
    
    TString pr_msg;
    pr_msg.Form("%s \t PW: %s \t Voltage: %u \t Current: %u \t %s", 
                GetChannelName(slow_det,ch).Data(), 
                pow_str.Data(), 
                voltage,
                current,
                trip_str.Data()
                );
    
    Printf(pr_msg.Data());
  }
}

//_________________________
void TFndSCCMan::PrintSlowDetMessage(Int_t slow_det){

  if( !IsDataReady(slow_det) ) return;

  UInt_t msg_offset =  (UInt_t)( (fSingleRawData[slow_det][HdrDet_msgoff]) / 4);
  
  TString msg;
  msg.Form("%s", (const Char_t *) (&fSingleRawData[slow_det][msg_offset]));
  Printf(msg);
  
}

//_________________________
void TFndSCCMan::PrintSlowDetMiscValues(Int_t slow_det){

  if( !IsDataReady(slow_det) ) return;

  UInt_t mnum = 0;  

  UInt_t misc_offset = (UInt_t)( (fSingleRawData[slow_det][HdrDet_miscoff]) / 4);
  UInt_t end_num =  (UInt_t)( (fSingleRawData[slow_det][HdrDet_evlen]) / 4);

  if(K_DEBUG_LEV> 0){
    Printf("misc_offset: %u",misc_offset);
    Printf("end_num: %u",end_num);
  }
  
  UInt_t nmaxmisc = (UInt_t)(K_MISC_MAX_SIZE / 4 );  
  Float_t divider[nmaxmisc];
  TString misc_nam[nmaxmisc];
  
  for(Int_t i=0;i<nmaxmisc;i++){
    divider[i] = 1;
    misc_nam[i].Form("Misc[%i]",i);
  }

  //
  switch(slow_det){
  case TOFI:
    // no misc expected
    break;
  case TOFO:
    // no misc expected
    break;
  case LMD:
    misc_nam[0] = "Mixture (C4H10 %) ";
    divider[0] = 100;
    break;
  case STB:
    misc_nam[0] = "Delta-P Mixer ";
    misc_nam[1] = "Temp  Mixer   ";
    misc_nam[2] = "Ethan flux    ";
    misc_nam[3] = "Argon flux    ";
    for(Int_t mid= 4;mid<=9;mid++)  misc_nam[mid].Form("Flow IN  %d",mid-3); 
    for(Int_t mid=10;mid<=15;mid++)  misc_nam[mid].Form("Flow OUT %d",mid-9); 

    for(Int_t i=0;i<nmaxmisc;i++) divider[i] = 100;
    
    break;
  case GAS:
    // 
    break;
  case SIL:
    // to be implemented
    return;
    break;
  case MAG:
    // still not supported
    break;
  default:
      Printf("GetChannelName","Slow control ID \"%d\" not available",slow_det);
      return;
  }
  
  
  for(UInt_t ch = misc_offset; ch < end_num; ch++){
    Float_t res_data = ( (Float_t) GetMiscInfo(slow_det,mnum)) / divider[mnum];
    Printf("%s: %.2f",misc_nam[mnum].Data(),res_data); 
    mnum++;
  }
  
}

//_________________________
Int_t TFndSCCMan::PrintSlowDetInfo(Int_t slow_det, Bool_t check_receive_thread){
  // return value:
  //              0: ok
  //             -1: error
  
  if( !IsDataReady(slow_det) ) return -1;

  if(K_DEBUG_LEV> 0) Printf("TFndSCCMan::PrintSlowDetInfo called for %s",fSlowDetNames[slow_det].Data());

  if(check_receive_thread && IsReceiveThreadRunning(slow_det) != TThread::kRunningState){
    Warning("PrintSlowDetInfo","Can not print info for %s: receiver not running",fSlowDetNames[slow_det].Data());
    return -1;  
  }

  Printf("\n\n --------------------------------------------");
  Printf("Printing information for detector \"%s\"",fSlowDetNames[slow_det].Data());

  // --- header (not really needed here)
  Printf("\n ----------------> HEADER <------------------");
  PrintHeader(slow_det);

  // --- data part
  Printf("\n -----------------> DATA <-------------------");
  PrintSlowDetDataValues(slow_det);

  // --- messages part
  Printf("\n ---------------> MESSAGES <-----------------");
  PrintSlowDetMessage(slow_det);

  // --- miscellaneous  part
  Printf("\n -----------------> MISC <-------------------");
  PrintSlowDetMiscValues(slow_det);
  Printf(" --------------------------------------------\n\n");

  if(K_DEBUG_LEV> 0) Printf("TFndSCCMan::PrintSlowDetInfo completed for %s",fSlowDetNames[slow_det].Data());
  return 0;
}

//_________________________
Int_t TFndSCCMan::PrintAllInfo(Bool_t check_receive_thread) {
  // return value:
  //              0: ok
  //             -1: error

  Bool_t at_least_one = kFALSE;  
  Printf("TFndSCCgui::PrintAllInfo called");

  for(Int_t i=0;i<K_N_SLOWS;i++){
    Int_t res = PrintSlowDetInfo(i,check_receive_thread);
    if(res != 0) continue;
    at_least_one = kTRUE;  
  }
  
  if(!at_least_one){
    Warning("PrintAllInfo","Can not print info for any slow control");
    return -1;  
  }

  return 0; 
}

//_________________________
Int_t TFndSCCMan::ScheduledOperation(){
  // return value:
  //              0: ok
  //             -1: no receiver running (nothing to do)
  
  Bool_t at_least_one = kFALSE;
  for(Int_t slow_det = (Int_t)TOFI ; slow_det <= (Int_t)MAG ; slow_det++){ 
    if(IsReceiveThreadRunning(slow_det) == TThread::kRunningState) at_least_one = kTRUE;
  }
  
  if(!at_least_one){
    Info("ScheduledOperation","No receiver running: can not build complete data");
    return -1;
  }
  
  Info("ScheduledOperation","Performing scheduled operation");
  //  TThread::Lock();
  fSendingData = kTRUE; 

  fCounterUpdate++;
  //  usleep(250000);
  // ---
  if(fCounterUpdate >= fRatioUpdate ) {
    UpdateCurrentLogFile();
    fCounterUpdate = 0;
  }
  
  ScheduledOperationPerformed(E_SCC_MAN_GuiComm_Building); // implemented in GUI 

  TString build_message;
  if( BuildGlobalEvent(build_message) != 0){
    fSendingData = kFALSE;
    return -1;
  }
  WriteLogFile(E_SCC_Log_Store,build_message);


  if(fMustSaveLocalRaw){
    //     Info("StoreCompleteData","Storing data");  
    UpdateCurrentOutRawFile();
    Info("ScheduledOperation","Data stored to local raw file");  
    ScheduledOperationPerformed(E_SCC_MAN_GuiComm_Stored); // implemented in GUI 
  }
  
  if(fMustSendToDAQ){
    //     Info("StoreCompleteData","Sending data to DAQ");  
    
    //     Info("StoreCompleteData","Data sent to DAQ");    
    ScheduledOperationPerformed(E_SCC_MAN_GuiComm_Sent); // implemented in GUI 
  }
  
  
  ScheduledOperationPerformed(E_SCC_MAN_GuiComm_Idle,kTRUE); // implemented in GUI 

  //      TThread::Sleep(0,500000);
  //  usleep(50000);
  
  fSendingData = kFALSE;
  //  TThread::UnLock();

  return 0; 
}

// --- logging support (Feb, 2007)
//_________________________
void TFndSCCMan::OpenLogFile(E_SCC_LogType log_type,const TString &fdir, const TString &fnam,const Bool_t &reset_old){

  if( gSystem->AccessPathName( gSystem->ExpandPathName(fdir.Data()) ) ){
    Printf("\n\n\n *********************************************************************");
    Error("OpenLogFile","directory \"%s\" not found: can not start");
    Info("OpenLogFile","You may need to give the \"mount -a\" command as super-user (root user)");
    Printf(" *********************************************************************\n\n\n");
    gApplication->Terminate();
  }

  CloseLogFile(log_type);
  
  TString path_str = "";
  path_str.Form("%s/%s",gSystem->ExpandPathName(fdir.Data()),fnam.Data());
  
  
  fCurLogFile[(Int_t)log_type] = new ofstream();
  if(reset_old) fCurLogFile[(Int_t)log_type]->open(path_str.Data(),ofstream::out | ofstream::trunc);
  else fCurLogFile[(Int_t)log_type]->open(path_str.Data(),ofstream::out | ofstream::app);
  
}

//_________________________
void TFndSCCMan::CloseLogFile(E_SCC_LogType log_type){

  if(!fCurLogFile[(Int_t)log_type]) return;
  fCurLogFile[(Int_t)log_type]->close();
  delete fCurLogFile[(Int_t)log_type];
  fCurLogFile[(Int_t)log_type] = 0;
  
}

//_________________________
void TFndSCCMan::WriteLogFile(E_SCC_LogType log_type,const TString &line){

  if(!fCurLogFile[(Int_t)log_type]) return;
  *fCurLogFile[(Int_t)log_type] << line.Data() << endl;
  
}

//_________________________
void TFndSCCMan::UpdateCurrentLogFile(){
  
  if(!fCurLogFile[(Int_t)E_SCC_Log_Status]) return;
  
  TDatime timenow;
  timenow.Set();
  
  TString cur_date = "";
  cur_date.Form("%2d/%2d/%4d",
                timenow.GetDay(),
                timenow.GetMonth(),
                timenow.GetYear()
                );
  
  TString cur_time = "";
  cur_time.Form("%2d:%2d:%2d",
                timenow.GetHour(),
                timenow.GetMinute(),
                timenow.GetSecond()
                );
  
  TString det_status[K_N_SLOWS];
  det_status[TOFI] = "-----";
  det_status[TOFO] = "-----";
  det_status[LMD]  = "-----";
  det_status[STB]  = "-----";
  det_status[GAS]  = "-----";
  det_status[SIL]  = "-----";
  det_status[MAG]  = "-----";
  
  // --- checking messages from raw
  TString CmpStr[3] = {0};
  CmpStr[0] = "ok";
  CmpStr[1] = "warning";
  CmpStr[2] = "error";
  
  for(Int_t i=0; i<K_N_SLOWS; i++ ){
    TString d_mes = GetMessagePart(i);
    if(d_mes.IsNull()) continue;
    Printf(d_mes.Data());
    if(!strncasecmp(CmpStr[0],d_mes.Data(),CmpStr[0].Sizeof()-1)) det_status[i] = "ACTIVE";
    else if(!strncasecmp(CmpStr[1],d_mes.Data(),CmpStr[1].Sizeof()-1)) det_status[i] = "WARNING";
    else if(!strncasecmp(CmpStr[2],d_mes.Data(),CmpStr[2].Sizeof()-1)) det_status[i] = "ERROR";
  }

  
  // --- complete message
  TString msg = "";
  msg.Form("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
           cur_date.Data(),
           cur_time.Data(),
           det_status[TOFI].Data(),
           det_status[SIL] .Data(),
           det_status[LMD] .Data(),
           det_status[STB] .Data(),
           det_status[TOFO].Data(),
           det_status[GAS] .Data()
           );
  
  WriteLogFile(E_SCC_Log_Status,msg);
}


// --- raw-saving support (Feb, 2007)
//_________________________
void TFndSCCMan::OpenOutRawFile(const Bool_t &reset_old){

  // --- raw
  TString fdir = fRawFilesPath;
  
  TDatime datim;
  datim.Set();
  
  TString fnam;
  fnam.Form("%d_%d_%d.scc.raw",
            datim.GetDay(),
            datim.GetMonth(),
            datim.GetYear()
            );
  
  
  if( gSystem->AccessPathName( gSystem->ExpandPathName(fdir.Data()) ) ){
    Printf("\n\n\n *********************************************************************");
    Error("OpenOutRawFile","directory \"%s\" not found: can not start");
    Info("OpenOutRawFile","You may need to give the \"mount -a\" command as super-user (root user)");
    Printf(" *********************************************************************\n\n\n");
    gApplication->Terminate();
  }
  
  CloseOutRawFile();
  
  TString path_str = "";
  path_str.Form("%s/%s",gSystem->ExpandPathName(fdir.Data()),fnam.Data());
  
  fCurOutRawFile = new ofstream();
  if(reset_old) fCurOutRawFile->open(path_str.Data(),ofstream::out | ios::binary | ofstream::trunc);
  else fCurOutRawFile->open(path_str.Data(),ofstream::out | ios::binary | ofstream::app);
  
}

//_________________________
void TFndSCCMan::CloseOutRawFile(){

  if(!fCurOutRawFile) return;
  fCurOutRawFile->close();
  delete fCurOutRawFile;
  fCurOutRawFile = 0;
 
}

//_________________________
void TFndSCCMan::WriteOutRawFile(UInt_t *data){

  //   Info("WriteOutRawFile","method disabled");
  //   return;

  if(!fCurOutRawFile) return;
  if(data[0] <= 0 || data[0] >= K_TOT_SCC_MAX_SIZE){
    Error("WriteOutRawFile","raw-buffer too big");
    return;
  }

  Printf("\nWriting event (%u bytes)",data[0]);
  if(K_DEBUG_LEV > 0)
    PrintAllInfo();

  fCurOutRawFile->write((Char_t *)(data),(UInt_t)(data[0]));

  if(0){ // debug lines
    cout << endl << endl << "----------------------------------" << endl;
    for(Int_t i=0; i< (Int_t)(data[0]) ; i++ ){
      cout << "data[" << i << "]: " << data[i] << endl;
    }
    cout << "----------------------------------" << endl << endl << endl;
  }

}

//_________________________
void TFndSCCMan::UpdateCurrentOutRawFile(){

  OpenOutRawFile(kFALSE);
  WriteOutRawFile(&fGlobalEvent[0]);
  CloseOutRawFile();
}

// --- raw-reading support (Feb, 2007)
//_________________________
Int_t TFndSCCMan::OpenRawFile(const TString &fpath){
  // return value: 
  //              0: ok
  //             -1: file not found

  if(K_DEBUG_LEV > 0) Printf("TFndSCCMan::OpenRawFile ===> opening file \"%s\"",fpath.Data());
  
  fRawFile = fopen(fpath.Data(),"rb");
  if(fRawFile == NULL){
    if(K_DEBUG_LEV > 0) Printf("TFndSCCMan::OpenRawFile ===> opening file \"%s\" (trying zip)",fpath.Data());
    fRawFile = popen(fpath.Data(),"rb");
    if(fRawFile == NULL){
      if(K_DEBUG_LEV > 0) Printf("TFndSCCMan::OpenRawFile ===> file \"%s\" not found",fpath.Data());
    return -1;
    }
  }

  return 0;
}

//_________________________
UInt_t *TFndSCCMan::GetNextRawEvent(Int_t &exit_val){
  // exit_val value:
  //                0: ok
  //               -1: error

  UInt_t evlen_bytes = 0;
  if(! fRawFile){
    Warning("GetNextRawEvent","Could not get event: raw-file not defined.");
    return 0;
  }

  if(fread(&evlen_bytes, sizeof(UInt_t), 1 , fRawFile)!=1) {
    if(K_DEBUG_LEV > 0) Info("GetNextRawEventFromFile", "End of Raw-file reached");
    exit_val = -1;
    return 0;
  }

  if(K_DEBUG_LEV > 0) cout << "TFndSCCMan::GetNextRawEvent ===> evlen (bytes): " << evlen_bytes << endl;

  Float_t div_by_four = ((Float_t)evlen_bytes)  / 4.;
  Float_t rem_by_four = div_by_four - TMath::Floor(div_by_four);  
  if(rem_by_four !=0 ){
    Error("GetNextRawEvent","evlen_bytes not multiple of four (%u)",evlen_bytes);
    exit_val = -1;
    return 0;
  }

  UInt_t evlen = (UInt_t) ( ((Float_t)(evlen_bytes)) / 4.); 


  bzero(fGlobalEvent,sizeof(fGlobalEvent));
  fGlobalEvent[0] = (UInt_t) evlen_bytes;
  Int_t read_length = 1 + fread(fGlobalEvent+1, sizeof(UInt_t), evlen-1, fRawFile);
  if(read_length != evlen){
    Error("GetNextRawEventFromFile","wrong length from freed (%d ; %d)",read_length,evlen); 
    exit_val = -1;
    return 0;
  }
  
  GlobalEventToGlobalHeader();
  GlobalEventToDetEvents();

  exit_val = 0;
  return fGlobalEvent;
}

//_________________________
Int_t TFndSCCMan::GlobalEventToGlobalHeader(){
  // return value:
  //              0: ok
  //             -1: error

  UInt_t HdrEntries =  (UInt_t)((Float_t)(K_SCC_HDR_SIZE) / (Float_t)(4.));
  
  for(UInt_t id=0;id<HdrEntries;id++){
    fGlobalHdr[id] = fGlobalEvent[id];
  }
  
  if( fGlobalHdr[HdrTot_Magic] != 0xBABA ){
    Error("GlobalEventToGlobalHeader","Wrong magic number in global header: \"%X\"",fGlobalHdr[HdrTot_Magic]);
    bzero(fGlobalHdr,HdrEntries);
    return -1;
  }
  
  return 0;
}

//_________________________
Int_t TFndSCCMan::DetEventToMsgPart(const Int_t &slow_det){
  // return value:
  //              0: ok
  //             -1: error

  // TO BE IMPLEMENTED!!!
  fMsgPart[slow_det] = "OK";
}

//_________________________
Int_t TFndSCCMan::GlobalEventToDetEvents(){
  // return value:
  //              0: ok
  //             -1: error

  UInt_t t_siz = fGlobalEvent[HdrTot_EvLen];

  // eval number of U32 from bytes
  UInt_t tofi_off = (fGlobalEvent[HdrTot_TofiOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_TofiOff] -1 ) / 4)  : 0;
  UInt_t tofi_size = (fGlobalEvent[tofi_off] !=0 && fGlobalEvent[tofi_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[tofi_off] ) / 4)  : 0;

  UInt_t tofo_off = (fGlobalEvent[HdrTot_TofoOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_TofoOff] -1 ) / 4)  : 0;
  UInt_t tofo_size = (fGlobalEvent[tofo_off] !=0 && fGlobalEvent[tofo_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[tofo_off] ) / 4)  : 0;

  UInt_t lmd_off = (fGlobalEvent[HdrTot_LmdOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_LmdOff] -1 ) / 4)  : 0;
  UInt_t lmd_size = (fGlobalEvent[lmd_off] !=0 && fGlobalEvent[lmd_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[lmd_off] ) / 4)  : 0;

  UInt_t stb_off = (fGlobalEvent[HdrTot_StbOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_StbOff] -1 ) / 4)  : 0;
  UInt_t stb_size = (fGlobalEvent[stb_off] !=0 && fGlobalEvent[stb_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[stb_off] ) / 4)  : 0;

  UInt_t gas_off = (fGlobalEvent[HdrTot_GasOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_GasOff] -1 ) / 4)  : 0;
  UInt_t gas_size = (fGlobalEvent[gas_off] !=0 && fGlobalEvent[gas_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[gas_off] ) / 4)  : 0;

  UInt_t sil_off = (fGlobalEvent[HdrTot_SilOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_SilOff] -1 ) / 4)  : 0;
  UInt_t sil_size = (fGlobalEvent[sil_off] !=0 && fGlobalEvent[sil_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[sil_off] ) / 4)  : 0;

  UInt_t mag_off = (fGlobalEvent[HdrTot_MagOff] !=0) ? (UInt_t)( (Float_t)( fGlobalEvent[HdrTot_MagOff] -1 ) / 4)  : 0;
  UInt_t mag_size = (fGlobalEvent[mag_off] !=0 && fGlobalEvent[mag_off] < t_siz) ? (UInt_t)( (Float_t)( fGlobalEvent[mag_off] ) / 4)  : 0;

  // --- tofino
  if(tofi_off != 0 && tofi_size != 0){
    for(UInt_t i=tofi_off; i< tofi_off + tofi_size; i++) fSingleRawData[TOFI][i-tofi_off] = fGlobalEvent[i];
    fDataReady[TOFI] = kTRUE;
  }
  else{ 
    fDataReady[TOFI] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[TOFI].Data(),tofi_off);
  }
  
  // --- tofone
  if(tofo_off != 0 && tofo_size != 0){
    for(UInt_t i=tofo_off; i< tofo_off + tofo_size; i++) fSingleRawData[TOFO][i-tofo_off] = fGlobalEvent[i];
    fDataReady[TOFO] = kTRUE;
  }
  else{ 
    fDataReady[TOFO] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[TOFO].Data(),tofo_off);
  }

  // --- lmd
  if(lmd_off != 0 && lmd_size != 0){
    for(UInt_t i=lmd_off; i< lmd_off + lmd_size; i++) fSingleRawData[LMD][i-lmd_off] = fGlobalEvent[i];
    fDataReady[LMD] = kTRUE;
  }
  else{ 
    fDataReady[LMD] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[LMD].Data(),lmd_off);
  }

  // --- stb
  if(stb_off != 0 && stb_size != 0){
    for(UInt_t i=stb_off; i< stb_off + stb_size; i++) fSingleRawData[STB][i-stb_off] = fGlobalEvent[i];
    fDataReady[STB] = kTRUE;
  }
  else{ 
    fDataReady[STB] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[STB].Data(),stb_off);
  }

  // --- gas
  if(gas_off != 0 && gas_size != 0){
    for(UInt_t i=gas_off; i< gas_off + gas_size; i++) fSingleRawData[GAS][i-gas_off] = fGlobalEvent[i];
    fDataReady[GAS] = kTRUE;
  }
  else{ 
    fDataReady[GAS] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[GAS].Data(),gas_off);
  }

  // --- sil
  if(sil_off != 0 && sil_size != 0){
    for(UInt_t i=sil_off; i< sil_off + sil_size; i++) fSingleRawData[SIL][i-sil_off] = fGlobalEvent[i];
    fDataReady[SIL] = kTRUE;
  }
  else{ 
    fDataReady[SIL] = kFALSE;
    if(K_DEBUG_LEV> 0) Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[SIL].Data(),sil_off);
  }
  
  // --- mag
  if(mag_off != 0 && mag_size != 0){
    for(UInt_t i=mag_off; i< mag_off + mag_size; i++) fSingleRawData[MAG][i-mag_off] = fGlobalEvent[i];
    fDataReady[MAG] = kTRUE;
  }
  else{ 
    // NOTE: warning disabled: MAG has not been acquired!
    fDataReady[MAG] = kFALSE;
    // Warning("GlobalEventToDetEvents","can not grab single raw-data for \"%s\" (offset: %u)",fSlowDetNames[MAG].Data(),mag_off);
  }
  
  // --- now store misc parts
  for(Int_t slow_det = (Int_t)TOFI ; slow_det <= (Int_t)MAG ; slow_det++){ 
    UInt_t offm = ( fSingleRawData[slow_det][HdrDet_miscoff] ) ? (UInt_t) ( (Float_t)(fSingleRawData[slow_det][HdrDet_miscoff]) / 4.)  : 0;
    UInt_t endm = ( fSingleRawData[slow_det][HdrDet_evlen] ) ? (UInt_t) ( (Float_t)(fSingleRawData[slow_det][HdrDet_evlen]) / 4.)  : 0;
    if(offm && endm) for(UInt_t m_i=offm; m_i < endm; m_i++)
      fMiscArray[slow_det][m_i - offm] = fSingleRawData[slow_det][m_i];
  }
  

  Int_t res_msg = 0;
  for(Int_t slow_id=0;slow_id<K_N_SLOWS;slow_id++){
    res_msg += DetEventToMsgPart(slow_id);
  }

  if(res_msg) return -1;
  return 0;
}

//_________________________
Int_t TFndSCCMan::CloseRawFile(){
  // return value: 
  //              0: ok
  //             -1: file not open
  
  if(!fRawFile){
    if(K_DEBUG_LEV> 0) Warning("CloseRawFile","no file to be closed.");
    return -1;
  }
  
  fclose(fRawFile);
  //   delete fRawFile;
  fRawFile = 0;
  return 0;
  
}

---