SCC/TFndSCCMan.h

// @(#)fROOT/SCC:$Name:  $:$Id: TFndSCCMan.h,v 1.33 2007/09/05 10:34:58 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/02/07

#ifndef FROOT_TFndSCCMan
#define FROOT_TFndSCCMan

//                                                      //
//  Control class for the FINUDA Slow Control Manager   //
//                                                      //
// the following lines are required in order to compile under Mac-OS
//#ifdef __CINT__
#if !defined(linux) && !defined(__linux) && !defined(__linux__)
#undef __GNUC__
#endif

#if !defined(__CINT__)
#include <netinet/in.h>
#else
struct sockaddr_in;
#endif

#include <Riostream.h>
#include "TTimer.h"

#include "TThread.h"
#include "TFndSCCRaw.h"

#include "FROOT.h"

class TFndSCCMan: public TFndSCCRaw
{

 protected:  
  enum E_SCC_LogType{
    E_SCC_Log_Status = 0, // information about all detectors
    E_SCC_Log_Store = 1,  // log of every stored (sent) event
    E_SCC_Log_End = 2  // used for arrays
  };


  TThread *fReceiveThread[K_N_SOCKS_IN];

  Int_t fSockDescr[K_N_SOCKS_IN]; // socket descriptors
  struct sockaddr_in fLocSockAddr[K_N_SOCKS_IN];

  Int_t fCurReceivedEv[K_N_SOCKS_IN]; // SIL will be incremented at every completed event

  // complete data send management
  TThread *fSendThread;
  Int_t fCurSent;
  TTimer *fTimer;
  Int_t fUpdateInterval; // time interval for update (seconds)
  Int_t fCounterUpdate; // used to count updates
  Int_t fRatioUpdate; // text-log/raw-store interval ratio

  Bool_t fMustSendToDAQ;
  Bool_t fMustSaveLocalRaw;

  // --- logging support (Feb, 2007)
  ofstream *fCurLogFile[(Int_t)E_SCC_Log_End]; 
  ofstream *fCurOutRawFile; 

  TString fLogFilesPath[(Int_t)E_SCC_Log_End];
  TString fRawFilesPath;


  FILE *fRawFile; // used for reading raw-files

 private:
  void Init();
  Int_t IsSingleReceiveThreadRunning(Int_t sock_idx); // return value: -1: Thread not found ; != -1: Thread state

  Int_t StartSingleReceiveThread(Int_t sock_idx);
  Int_t StopSingleReceiveThread(Int_t sock_idx);
  

 public:
  TFndSCCMan();
  ~TFndSCCMan();

  Bool_t fSendingData;
  
  enum E_SCC_MAN_GuiComm_t{
    E_SCC_MAN_GuiComm_Idle = 0,
    E_SCC_MAN_GuiComm_Building = 1,
    E_SCC_MAN_GuiComm_Sent = 2,
    E_SCC_MAN_GuiComm_Stored = 3,
  };
  /*   E_SCC_MAN_GuiComm_t fSend_GUI_comm; // used for GUI updates */
  
  Int_t SockId2SlowId(Int_t sock_idx);
  Int_t SlowId2SockId(Int_t slow_det,Int_t part = 1); // part is used by SIL only
  void StopAllThreads();

  static void *Receiver(void *arg); // Receive raw-events from SlowControls
  /*   static void *Sender(void *arg); // Send the complete event to DAQ */
  
  Int_t IsReceiveThreadRunning(Int_t slow_det);
  Int_t StartReceiveThread(Int_t slow_det);
  Int_t StopReceiveThread(Int_t slow_det);
  Int_t GetSocketDescriptor(Int_t sock_idx) { return fSockDescr[sock_idx]; }

  // --- print methods
  // print header is supported by the base class "TFndSCCRaw"
  void PrintSlowDetDataValues(Int_t slow_det);
  void PrintSlowDetMessage(Int_t slow_det);
  void PrintSlowDetMiscValues(Int_t slow_det);
  Int_t PrintSlowDetInfo(Int_t slow_det, Bool_t check_receive_thread = kFALSE);
  Int_t PrintAllInfo(Bool_t check_receive_thread=kFALSE);

  // methods used within Receiver threads
  struct sockaddr_in GetLocSockAddr(Int_t sock_idx) { return fLocSockAddr[sock_idx]; }
  Int_t GetReceivedEv(Int_t sock_idx) { return fCurReceivedEv[sock_idx]; }
  void IncrReceivedEv(Int_t sock_idx) { fCurReceivedEv[sock_idx]++; }

  // the "ReceivedEvent" method will be connected to the application class
  virtual void ReceivedEvent(Int_t slow_det,Int_t part) = 0; // Automatically called by receiver threads
  //  virtual void PerformingScheduledOperation() = 0; // Automatically called by receiver threads
  virtual void ScheduledOperationPerformed(E_SCC_MAN_GuiComm_t oper,Bool_t UpdateTime = kFALSE) = 0; // Automatically called by receiver threads

  TThread *GetReceiveThread(Int_t slow_det) { return fReceiveThread[slow_det]; }
  
  // complete data send management
  Int_t StartSendThread(); // used also for saving local raw-data
  Int_t StopSendThread(); // used also for saving local raw-data
  Int_t IsSendThreadThreadRunning(); // return value: -1: Thread not found ; != -1: Thread state

  void SetMustSendToDAQ(const Bool_t &val) { fMustSendToDAQ = val; }
  void SetMustSaveLocalRaw(const Bool_t &val) { fMustSaveLocalRaw = val; }
  
  Bool_t GetMustSendToDAQ() { return fMustSendToDAQ; }
  Bool_t GetMustSaveLocalRaw() { return fMustSaveLocalRaw; }
  
  Int_t ScheduledOperation();
  
  // --- logging support (Feb, 2007)
  virtual void OpenLogFile(E_SCC_LogType log_type,const TString &fdir, const TString &fnam,const Bool_t &reset_old);
  virtual void CloseLogFile(E_SCC_LogType log_type);
  virtual void WriteLogFile(E_SCC_LogType log_type,const TString &line);
  virtual void UpdateCurrentLogFile(); // used for status log-file

  // --- raw-saving support (Feb, 2007)
 private:
  // writing raw-file is handled apart
  virtual void OpenOutRawFile(const Bool_t &reset_old);
  virtual void WriteOutRawFile(UInt_t *data);
  virtual void UpdateCurrentOutRawFile();
  virtual void CloseOutRawFile();
 public:
  // support for several open-sintaxes
  virtual Int_t OpenRawFile(const TString &fpath);
  virtual Int_t CloseRawFile();
  virtual UInt_t *GetNextRawEvent(Int_t &exit_val);
  virtual Int_t GlobalEventToGlobalHeader();
  virtual Int_t GlobalEventToDetEvents();
  virtual Int_t DetEventToMsgPart(const Int_t &slow_det);

  virtual Int_t OpenRawFile(const TString &fdir,const TString &fnam)
    {
      TString pth; pth.Form("%s/%s",gSystem->ExpandPathName(fdir),fnam.Data());
      return OpenRawFile(pth);
    }
  
  virtual Int_t OpenRawFile(const TString &fdir,const UInt_t &day,const UInt_t &month,const UInt_t &year)
    {
      TString fnam;
      fnam.Form("%u_%u_%u.scc.raw",day,month,year);
      
      TString path_str = "";
      path_str.Form("%s/%s",gSystem->ExpandPathName(fdir.Data()),fnam.Data());
      return OpenRawFile(path_str);      
    }
  
  virtual Int_t OpenRawFile(const TString &fdir,const TDatime &date_time)
    {   
      TString fnam;
      fnam.Form("%d_%d_%d.scc.raw",
                date_time.GetDay(),
                date_time.GetMonth(),
                date_time.GetYear()
                );
      
      TString path_str = "";
      path_str.Form("%s/%s",gSystem->ExpandPathName(fdir.Data()),fnam.Data());
      return OpenRawFile(path_str);
    }
  

  // ---
  ClassDef(TFndSCCMan,0) // Manager of the Slow-Control-Manager
};
    
//R__EXTERN TFndSCCMan *gSCCManager;

#endif // FROOT_TFndSCCMan

---