Processus.h

Go to the documentation of this file.

// $Id: Processus.h,v 1.9 2006/06/05 08:28:14 fmachefe Exp $
#ifndef INCLUDE_PROCESSUS_H
#define INCLUDE_PROCESSUS_H 1

#ifdef _NETWORK_
#include <dis.hxx>
#endif

#include "TFile.h"
#include "Application.h"
#include "Options.h"
#include "Object.h"
#include "Element.h"
#include "Data.h"
#include "ProcTimer.h"

struct ProcState {
  int   nevent;
  int   nerrors;
  float time;
  char  state[256];
};


class Processus : public Object {
public:
  enum states { ERR=-1 , NOT_OK , OK };
  Processus ( );

  virtual ~Processus( ); 

  //  bool cmdline( std::vector <std::string> );

  //  virtual bool command( std::vector <std::string> ) ;

  StatusCode startProcessing ();

  StatusCode endProcessing ();

  virtual StatusCode initialize( ) = 0 ;

  virtual StatusCode execute( ) = 0 ;

  virtual StatusCode finalize( ) = 0 ;

  virtual Processus* clone( ) = 0 ;

  void clean()
  {
    m_element=0;
    if (0!=m_state) {
      delete m_state;
      m_state=0;
    }
#ifdef _NETWORK_
    warning("Cleaning state service : should it be done ?","Processus::clean")
      if (0!=m_stateService)
      {
        delete m_stateService;
      }
#endif
  }


  void setStorage (std::string storage) {
    m_storage = storage;
  }

  Data* data(){
    return m_data;
  }

  std::vector<double> data(unsigned int row){
    return m_data->vector(row);
  }

  std::vector<double> data(std::string name){
    return m_data->vector(name);
  }

  Histo1D* hist1d(unsigned int row){
    return m_data->hist1d(row);
  }

  Histo2D* hist2d(unsigned int row){
    return m_data->hist2d(row);
  }

  void addDataStream (std::string name,  std::string title){
    m_data->addDataStream(name, title);
  }

  void addHisto1d (TH1D* h){
    m_data->addHisto1d(h);
  }

  void addHisto2d (TH2D* h){
    m_data->addHisto2d(h);
  }

  StatusCode dataFill(int i, double val){
    if (m_data->vectorPtr(i)!=0){
      m_data->vectorPtr(i)->push_back(val);
      return StatusCode::SUCCESS;
    }
    else {
      return StatusCode::FAILURE;
    }
  }

  StatusCode dataFill(std::string name, double val){
    int row=m_data->rowFromName(name);
    if (row<0) return StatusCode::FAILURE;
    if (m_data->vectorPtr(row)!=0){
      m_data->vectorPtr(row)->push_back(val);
      return StatusCode::SUCCESS;
    }
    else {
      return StatusCode::FAILURE;
    }
  }

  std::string storage () {
    if ( 0 == m_storage.compare("") )
    {
      return name();
    }
    return m_storage;
  }

  void setElement (Element* element) {
    m_state = new ProcState ();
    m_state->nevent  = 0;
    m_state->nerrors = 0;
    m_state->time    = 0;
    strcpy( m_state->state,"");
    //  setState( OK );
    m_element = element;
  }

  Element* element () {
    return m_element;
  }



  void incNErrors () ;

  void setNErrors ( unsigned int ) ;

  unsigned int nErrors () ;

  TFile* rootFile () {
    return m_rootFile;
  }

  void openRootFile ( ) ;

  void closeRootFile ( );

  void startChrono(){
    m_start = time(0);
  }

  void setLogMsg (std::string logMsg) {
    m_logMsg = logMsg;
  }

  std::string logMsg () {
    return m_logMsg;
  }

  void setState ( int state );

#ifdef _NETWORK_

  bool startServices();

  virtual bool startService();

  bool updateServices();

  void setUpdateDelay (int updateDelay) {
    m_updateDelay = updateDelay;
    if ( 0 != m_timerService ){
      m_timerService->setDelay ( updateDelay );
    }
  }

  int updateDelay () {
    return m_updateDelay;
  }

#endif
  double elapsedTime (){
    return difftime(time(0),m_start);
  }
  double elapsedTime (time_t start){
    return ((time(0)-start));
  }

protected:
  Element* m_element;   //< Element on which the processus is applied

#ifdef _NETWORK_
  bool        m_service;
  int         m_updateDelay;
  ProcTimer  *m_timerService;
  DimService *m_valueService;
#endif

private:
  Data    *m_data;
  TFile   *m_rootFile;
  Options *m_options;

  time_t m_start;
  ProcState *m_state;
  std::string m_storage; //< Storage file name
  std::string m_logMsg;
#ifdef _NETWORK_
  DimService* m_stateService;
#endif
};

#endif // INCLUDE_PROCESSUS_H