/home/kopmann/git-mirror/fdhwlib/fdhwlib/Hw/eventloop.h

Go to the documentation of this file.

/***************************************************************************
                          eventloop.h  -  description
                             -------------------
    begin                : Di Jun 20 2006
    copyright            : (C) 2006 by 
    email                : 
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef EVENTLOOP_H
#define EVENTLOOP_H

#include <fdhwlib.h>


#include <cstdio>
#include <string>

#ifdef USE_MYSQL
#include <mysql/mysql.h>
#endif // of USE_MYSQL


#define PAGE_STACK_LEN 100 // Must be larger than the physical available number
                           // of pages.

#include <Hw/SltTime.h>                           
#include <Hw/sltpagestatus.h>

#include <akutil/simpleserver.h>


class keyboard;
class sharedMemory;
class SimpleSocket;
class Slt;

class EventLoop : public SimpleServer {
public:
  EventLoop(Slt *slt, unsigned short port = 0);

  //EventLoop(char *host, unsigned short port);
  
  ~EventLoop();

  void readInifile(char *inifile);

  /* Set number of stored pages */
  void setNStoredPages(int n);         

  void clearPageBuffer();

  /* Check the if dead time counters are active */
  bool isDeadTimeEnabled();

  void clear();
  
  virtual void initRun(int n=0);

  virtual int stopRun();

  void startServer(FILE *fout);

  void stopServer();
  
  int handle_timeout();

  int read_from_keyboard();
  
  void executeCmd(int client, short cmd, unsigned long *arg, short n);
    
  void run(FILE *fout, int n=0);

  void handleKeyboard(FILE *fout, keyboard *kb);  

  virtual void keyboard_cmds(FILE *fout, char *line);
  
  virtual void displayHeader(FILE *fout);

  virtual int getEvent(FILE *fout);

  virtual int getEventData(FILE *fout);

  void freeMemory();

  virtual void displayEvent(FILE *fout);

  virtual void displaySummary(FILE *fout);

  void analyse();

  virtual void help(FILE *fout);

  //void fprintf(FILE *fout, const char *fmt, ...);

  void print(const char *fmt, ...);
  
    
#ifdef USE_MYSQL

  void enableDatabase();

  void disableDatabase();

  void setPassword(char *passwd);
  
  int openDatabase(FILE *fout);

  void closeDatabase();

  void setDatabase(EventLoop *loop);  
  
  void displayDatabase(FILE *fout);

  void displayRuns(FILE *fout, int nStart=0, int nRow=0);

  void displayEventsFromDb(FILE *fout, int runId, char *param = 0);

  void storeRunHeader(FILE *fout);

  void updateRunHeader(FILE *fout);

  virtual void storeConfig();

  virtual void storeEvent();

  void setRunDuration(int sec);

  int getRunDuration();  

  int getActualRunDuration();
    
#endif // of MYSQL
    
protected:
  //int isClient;

  //SimpleSocket *readout;

  fd_set raw_data_fd_set;
  
  int runDaemon;

  FILE *floop;  
  
  int numEvents;

  int maxEvents;

  int filledPage[PAGE_STACK_LEN];

  int nextFreeSlot;

  int nextPage;

  int nextPageToFree;

  SltPageStatus lastPageStatus;

  unsigned long sumDelay;

  unsigned long sumPagesLeft;

  unsigned long sumStopped;

  sharedMemory *eventBuffer;
  

  // Eventloop control switches
  bool evlStopOnError;        // Flag wether to stop on errors seen in the diagnostics
  int evlStoredPages;         // Keep a number of pages in memory without clearing
  int evlSampleTime;          // Sample time [ms]
  bool evlRateAnalysis;       // Calculate trigger rate ...
  bool evlLoadAnalysis;       // Display eventloop load parameter
  bool evlHistogramming;      // Enable histogramming

  float evlRateUpdateFactor;  // Update factor for sliding rate calculation

  std::string evlGuiHost;          // Host where the eventloop GUI is running
  int evlGuiPort;             // Port of the GUI

  // Histogram data collected during the event loop
  int hisCol;                 // selected column
  int hisPix;                 // selected pixel

  int hisN[24];               // number of samples
  float hisPedestal[24];      // Pedestal
  float hisPeak[24];          // Peak
  float hisBin[24];           // Bin of the peak
  float hisRelPeak[24];       // Relative peak height
                              // pedestal = 0% ... mean peak = 100%
  float hisNorm[24];          // calibration factor
  float hisStaticNorm[24];    // static calibration factor
                              // has to be loaded from the ini file
  bool hisUseStaticNorm;      // use the static calibration data

  int hisLight[100];          // distribution of light level
  int hisImpact[100];         // distribution of center of gravity

  
protected:
  char lastKey;  // Last key typed at the keyboard
  int i, j, n, err, page, offset, nReadout, parameter;
  int statOffset;
  bool running;
  bool first;
  bool firstTime;
  bool slt;
  bool tlt;
  bool analysis;
  bool adc;
  //bool clear;
  bool paused;
  bool hwStopped;
  bool syntilator;
  SltPageStatus pageStatus;
  SltPageStatus mask;
  SltTime actTime;
  SltTime timeStamp;
  SltTime startTime;
  SltTime stopTime;
  SltTime firstEvTime;
  SltTime lastTimeStamp;
  SltTime deltaTimeStamp;
  SltTime deltaTime;
  SltTime delayTime;
  unsigned long delay; // [us]
  float meanDelay;
  unsigned long realTime, realFirst;
  SltTime timeAct, timeLast, timeFirst;
  float actRate, meanRate, meanPagesLeft, meanStopped, realRate;
  float slidingRate;
  float slidingFactor;
  float diffTime;
  int firstEvent;
  int trigAddr;
  bool stopped;
  int lastHeader;
  unsigned long nSamples;
  float pedestal[20][22];
  //procDuration dur;
  //const char *source[] = {"0", "Sw", "R", "3", "L", "5", "6", "7", "Int",
  //                 "9", "10", "11", "12", "13", "14", "15", "Ext"};
  SimpleSocket *gui;
  int numStoredEvents;


  // Dead time counters
  bool checkDeadTime;
  unsigned long long deadTimeRef, deadTime, deadTimeLast, deadTimeEnd;
  //unsigned long long vetoTimeRef, vetoTime;

  //EventBase ev;

  // Pointer to the Slt
  Slt *theSlt;

  //
  // Database parameter
  //
#ifdef USE_MYSQL

  bool dbRecord;

  bool dbRecordPixel;

  std::string dbServer;

  std::string dbUser;

  std::string dbPassword;

  std::string dbName;

  std::string dbRunTable;

  std::string dbEventTable;

  std::string dbAdcTable;

  unsigned long dbRunId;

  unsigned long dbEventId;
  
  MYSQL *db;

  int runDuration;
  
#endif // of USE_MYSQL

};

#endif