Processus.cpp

Go to the documentation of this file.

// $Id: Processus.cpp,v 1.11 2006/06/07 15:34:35 fmachefe Exp $

// include files 
#include <algorithm>
#include <iostream>

// ROOT include file
#include "TFile.h"

#include "Tools.h"
#include "ProcDataBase.h"
#include "Processus.h"

//-----------------------------------------------------------------------------
// Implementation file for class : Processus
//
// 2004-07-23 : Frederic Machefert
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
Processus::Processus(  ) : 
  m_element (0),
  m_data    (0),
  m_rootFile(0),
  m_options (application()->options()),
  m_state   (0),
  m_storage (std::string("")),
  m_logMsg  (std::string(""))
#ifdef _NETWORK_
  ,  
  m_service (false),
  m_updateDelay  (2),
  m_timerService (0),
  m_valueService (0)  
  m_stateService (0)
#endif  
{
  m_data=new Data();
  add(8); add(9);
}

//=============================================================================
// Destructor
//=============================================================================
Processus::~Processus() {
  if (0!=m_data) delete m_data;
  if (0!=m_element)
  {
    if (0!=m_state)
    {
      delete m_state;      
    }
  }
#ifdef _NETWORK_
  if ( 0 != m_timerService ){
    delete m_timerService;
  }
  if ( 0 != m_stateService ){
    delete m_stateService;
  }
  if ( 0 != m_valueService ){
    delete m_valueService;
  }
#endif
}

//=============================================================================
// increment error number
//=============================================================================
void Processus::incNErrors() {
  m_state->nerrors++;
}

//=============================================================================
// set the number of errors
//=============================================================================
void Processus::setNErrors( unsigned int nerr) {
  m_state->nerrors = nerr ;
}

//=============================================================================
// get the number of errors
//=============================================================================
unsigned int Processus::nErrors() {
  return ( m_state->nerrors++ );
}

//=============================================================================
// general processing initialization
//=============================================================================
StatusCode Processus::startProcessing() {
  info("==========================================================================");
  info("   * " + name() + " *" );
  m_options->setNErrors ( 0 );
  setNErrors ( 0 );
  m_data->purge();
#ifdef _NETWORK_
  if ( 0 != m_timerService ){
    m_timerService->setRunning ( true );
    m_timerService->timeHandler() ;
  }
#endif
  // start measuring processus duration
  
  startChrono();
  openRootFile();
  return initialize();
}

//=============================================================================
// general processing termination
//=============================================================================
StatusCode Processus::endProcessing() {
  setState( NOT_OK );
  // 
  info("--------------------------------------------------------------------------");
  info("Processed Run Number       : " + itos (m_options->runNumber()) , "finalize");
  info("Number of events processed : " + itos (m_options->nEvt())      , "finalize");
  info("Number of Errors           : " + itos (nErrors())           , "finalize");  
  info("Number of App errors       : " + itos (m_options->nErrors())   , "finalize");
  info("Elapsed time               : " + ftos (elapsedTime())       , "finalize");
  info("--------------------------------------------------------------------------");
  if (!m_data->empty()) 
    m_data->print();
  else 
    info("No data Stored.","finalize");
  info("--------------------------------------------------------------------------");

#ifdef _NETWORK_
  if ( 0 != m_timerService ){
    m_timerService->setRunning ( false );
  }
#endif
  StatusCode sc = finalize();
  m_data->buildHistos();  
  closeRootFile();
  return sc;
}


//=========================================================================
//  
//=========================================================================
void Processus::openRootFile ( ) {
  if ( m_options->dataStorage() ){
    m_rootFile = new TFile(m_options->dataFileFullName().c_str(),
                           "RECREATE",name().c_str());
        std::string mess=std::string("Opening root file ");
        mess.append(m_options->dataFileFullName());
        info(mess,"openRootFile");
  }
}


//=========================================================================
//  
//=========================================================================
void Processus::closeRootFile ( ) {
  if ( 0!= m_rootFile && m_options->dataStorage() ){
    m_rootFile->Write();
        std::string mess=std::string("Closing root file ");
        mess.append(m_options->dataFileFullName());
        info(mess,"closeRootFile");
    m_rootFile->Delete();
    m_rootFile = 0;
  }
}

//=========================================================================
//  
//=========================================================================
void Processus::setState ( int state ) {
  m_state->nevent  = m_options->nEvt();
  m_state->nerrors = m_options->nErrors();
  m_state->time    = (float) ( elapsedTime() );
  switch ( state ){
  case OK:
    strcpy(m_state->state,"OK");
    break;
  case NOT_OK:
    strcpy(m_state->state,"NOT_OK");
    break;
  case ERR:
    strcpy(m_state->state,"ERROR");
  }
}

#ifdef _NETWORK_

//=========================================================================
//  
//=========================================================================
bool Processus::startService () { return true; }

//=========================================================================
//  
//=========================================================================
bool Processus::startServices () {
  if ( m_service ) {
    std::string str = application()->name();
    str.append("/");
    str.append(name());
    str.append("/state");
    m_stateService = new DimService ( str.c_str(),
                      "I:2;F:1;C",
                      m_state,
                      sizeof(*m_state));
    startService ();    
    m_timerService = new ProcTimer ( m_updateDelay , this );
  }
  else {
    msgSvc(DEBUG,"startService","No Dim service for Processus "+
       name());
  }
  return true;
}

//=========================================================================
//  
//=========================================================================
bool Processus::updateServices () { 
  if ( 0!=m_stateService ) { 
    info("Updating service StateService", "updateServices");
    m_stateService->updateService(); 
  }
  if ( 0!=m_valueService ) { 
    info("Updating service ValueService", "updateServices" );
    m_valueService->updateService(); 
  }
  return true;
}

#endif