QSequence.cc

Go to the documentation of this file.

#include "QSequence.hh"
#include "QBaseModule.hh"
#include "QReader.hh"
#include "QDriver.hh"
#include "QWriter.hh"
#include "QModule.hh"
#include "QMessage.hh"
#include "QOptions.hh"
#include "QEventAssembler.hh"
#include "QEventList.hh"
#include "QError.hh"
#include "QGlobalReaderDispatcher.hh"
#include "QGlobalWriterDispatcher.hh"
#include "QProcessStatus.hh"
#include "QFrameWorkConfig.hh"
 
Q_BEGIN_NAMESPACE
 
size_t QSequence::fCounter = 0;
 
//_____________________________________________________________________________
QSequence::QSequence(const std::string& n)
  : QNamed(n), p_Reader(NULL), p_Writer(NULL),  p_Driver(NULL) {
  fCounter++;
  fIteration = 0;
  modules.clear();
  fGlobalData.Clear();
  fConfig.Clear();
  fConfig.fName = n;
}
//_____________________________________________________________________________
QSequence::~QSequence() {
  // check not get params
  if(p_Reader->isEnabled()) {
    std::stringstream msg;
    QOptions::GetInstance().CheckNotGet(GetName(), msg);
    std::string smsg = msg.str();
    if(!smsg.empty()) {
      std::string s = "Sequence " + GetName();
      QMessageHandler::Get()->Send(WarnMsg,s,smsg);
    }
    // check default params
    std::stringstream msg2;
    QOptions::GetInstance().CheckAtDefault(GetName(), msg2);
    smsg = msg2.str();
    if(!smsg.empty()) {
      std::string s = "Sequence " + GetName();
      QMessageHandler::Get()->Send(DebugMsg,s,smsg);
      QMessageHandler::Get()->Send(InfoMsg,s,"Modules default parameters dumped into the logfile");
    }
  }
  // delete modules
  if(p_Reader) delete p_Reader;
  
  std::vector<QBaseModule*>::iterator it;
  for( it = modules.begin(); it != modules.end(); it++) 
    delete (*it);
  
  if(p_Writer)   delete p_Writer;
  if(p_Driver)   delete p_Driver;
  
  modules.clear();
  
  // close i/o files
  fGlobalData.Clear();
  QGlobalReaderDispatcher::GetInstance().Clear();
  QGlobalWriterDispatcher::GetInstance().Clear();
}
//_____________________________________________________________________________
void QSequence::Dump(std::ostream& o) const {
  o << "Sequence: " << GetName() << std::endl;
  std::vector<QBaseModule*>::iterator it;
  std::vector<QBaseModule*> allModules = modules;
  if(p_Reader)   allModules.insert(allModules.begin(),p_Reader);
  if(p_Driver)   allModules.push_back(p_Driver);
  if(p_Writer)   allModules.push_back(p_Writer);
  for(it=allModules.begin(); it != allModules.end(); it++) {
    QBaseModule *m=(*it);
    m->UpdateEnableFlag();
    // MV FIXME add module category
    o << m->GetName() <<": ";
    if (m->isEnabled())
      o << "enabled" << std::endl;
    else
      o << "disabled" << std::endl;
  }
  o << "End of sequence: " << GetName();
}
//_____________________________________________________________________________
bool QSequence::Run() {
  fSequenceStatus = kSequenceConfig;
  // MV FIXME  fRWCommon.Clear();
  fRunAgain = false;
  fIteration++;
  fConfig.fModules.clear();
  fGlobalData.SetInputVersion(QOptions::GetInstance().GetString("General.GlobalDataInputVersion"));
  
  // check that all modules are of the same type
  std::string s = "Sequence " + GetName();
  std::vector<QBaseModule*>::iterator it;
  if ( !p_Reader ) QMessageHandler::Get()->Send(PanicMsg,s,"Reader not defined!");
  // build enable flag
  std::vector<QBaseModule*> allModules = modules;
  if(p_Reader)   allModules.insert(allModules.begin(),p_Reader);
  if(p_Driver)   allModules.push_back(p_Driver);
  if(p_Writer)   allModules.push_back(p_Writer);
  std::vector<QBaseModule*>::iterator m_iter = allModules.begin();
  while(m_iter != allModules.end()) {
    (*m_iter)->UpdateEnableFlag();
    fConfig.fModules.push_back(&(*m_iter)->GetConfig());
    m_iter++;
  }
  if(p_Driver && p_Driver->isEnabled()) {
    // Driver knows modules list
    p_Driver->SetModulesList(allModules);
  }
  p_Reader->fRWCommon = &fRWCommon;
  if(p_Writer)  p_Writer->fRWCommon = &fRWCommon;
  
  // Create event and event lists
  QEventAssembler ev;
  QEventList evList,oevList;
  ev.Clear();
  evList.Clear();
  oevList.Clear();
  
  // Init
  fSequenceStatus = kSequenceInit;
  QMessageHandler::Get()->Send(NoFilterMsg,s,"Init modules");
  try{
    if ( p_Reader->isEnabled() ) p_Reader->BeginBase(ev);
    else {
      m_iter = allModules.begin();
      while(m_iter != allModules.end()) {
        (*m_iter)->Disable();
        m_iter++;
      }
      QMessageHandler::Get()->Send(NoFilterMsg,s,"Reader disabled, not executing this sequence");
      return false;
    }
    for( it = modules.begin(); it != modules.end(); it++ ) { 
      QBaseModule *m = (*it);
      if ( m->isEnabled() ) m->BeginBase(ev);
    }
    if ( p_Driver && p_Driver->isEnabled()) p_Driver->BeginBase(ev);
    if ( p_Writer && p_Writer->isEnabled()) p_Writer->BeginBase(ev);
  }
  catch(const QError& err) {
    std::stringstream msg;
    msg<<err;
    QMessageHandler::Get()->Send(ErrorMsg,s,msg.str());
    if(err == QERR_GLOBAL_GENERIC || err == QERR_GLOBAL_HANDLE) 
      PrintGlobal(); 
    else 
      PrintEvents(ev.GetEvent(),oevList);
    
    QMessageHandler::Get()->Send(PanicMsg,s,"Fatal error");
  }
  catch(...) {
    PrintEvents(ev.GetEvent(),oevList);
    throw;
  }
  
  ev.Consolidate();
    
  // main loop on events
  fSequenceStatus = kSequenceDo;
  QMessageHandler::Get()->Send(NoFilterMsg,s,"Do modules");
  QProcessStatus &dianaStatus = QProcessStatus::GetInstance();
  try {
    
    // get events to be skipped and events to be processed
    int NumSkip = QOptions::GetInstance().GetInt("General.EventsToBeSkipped");
    int NumProcess = QOptions::GetInstance().GetInt("General.EventsToBeProcessed");
    
    // skip events at first iteration only
    bool ret = true;
    if ( GetIteration() == 1 ) {
      while(NumSkip--) {
        if (!p_Reader->ProcessBase(ev,evList,true,oevList)) {
          ret = false;
          break;
        }
      }
    }
      
    //int thisProcess = NumProcess;
    if(ret && ( (p_Driver && p_Driver->isEnabled()) ? !p_Driver->StopRun() : true)) {
      while(dianaStatus.isRunning() && p_Reader->ProcessBase(ev,evList,true,oevList)) {
        // manage config at first Do, not used since
        // the object may be in the last partial
        /*
          if(thisProcess == NumProcess) {
          SaveConfig();
          }*/
        bool ret = true;
        
        // run enabled modules 
        for( it = modules.begin(); it != modules.end(); it++) {
          QBaseModule *m = (*it);
          // modules that return false will skip subsequent modules
          
          if ( m->isEnabled() )  {
            ret = m->ProcessBase(ev, evList, ret, oevList);
          }
        }
        
        if(p_Driver && p_Driver->isEnabled())
          ret = p_Driver->ProcessBase(ev,evList,ret,oevList);
        
        //  do writer
        if (p_Writer && p_Writer->isEnabled()) {
          p_Writer->ProcessBase( ev ,evList, ret,oevList);
        }
        
        // check if we have processed enough events
        NumProcess--;
        
        if (NumProcess == 0) break;
        if (p_Driver && p_Driver->isEnabled() && p_Driver->StopRun()) break;
        if(dianaStatus.HasChanged())
          dianaStatus.Notify();
      }
      
    }
  }// try
  catch(const QError& err) {
    std::stringstream msg;
    msg<<err;
    QMessageHandler::Get()->Send(ErrorMsg,s,msg.str());
    if(err == QERR_GLOBAL_GENERIC || err == QERR_GLOBAL_HANDLE) 
      PrintGlobal(); 
    else 
      PrintEvents(ev.GetEvent(),oevList);
    
    QMessageHandler::Get()->Send(PanicMsg,s,"Fatal error");
  }
  catch(...) {
    PrintEvents(ev.GetEvent(),oevList);
    throw;
  }
  
  // save module config 
  SaveConfig();
  
  QMessageHandler::Get()->Send(NoFilterMsg,s,"Done modules");
  // end modules
  fSequenceStatus = kSequenceDone;
  try {
    p_Reader->EndBase();
    for( it = modules.begin(); it != modules.end(); it++) {
      QBaseModule *m = (*it);
      if ( m->isEnabled() ) m->EndBase();
    }
    if(p_Driver && p_Driver->isEnabled()) p_Driver->EndBase();
    
    // write module config
    if(p_Writer && p_Writer->isEnabled()) {
      GlobalHandle<QFrameWorkConfig> fwcHandle("Config");
      fGlobalData.SetOwner("Diana");
      fGlobalData.Get(&fwcHandle,"");
      QError err = GlobalData().Set(&fwcHandle,"CurrentWriter");
      if(err == QERR_SUCCESS) {
        QMessageHandler::Get()->Send(InfoMsg,s,"Diana@Config saved to CurrentWriter");
        
      }
      fGlobalData.SetOwner("");
      p_Writer->EndBase();
    }
    CheckModuleWithNeighbours();
  }
  catch(const QError& err) {
    std::stringstream msg;
    msg<<err;
    QMessageHandler::Get()->Send(ErrorMsg,s,msg.str());
    if(err == QERR_GLOBAL_GENERIC || err == QERR_GLOBAL_HANDLE) 
      PrintGlobal(); 
    QMessageHandler::Get()->Send(PanicMsg,s,"Fatal error");
  }
  catch(...) {
    throw;
  }
  
  // check diana status
  if(dianaStatus.isError()) {
    QMessageHandler::Get()->Send(ErrorMsg,s,dianaStatus.GetError());
    return false;
  }
  if(dianaStatus.isExiting()) {
    QMessageHandler::Get()->Send(NoFilterMsg,s,"User Interrupt detected");
    QMessageHandler::Get()->Send(WarnMsg,s,"User Interrupt detected");
    return false;
  }
  
  return fRunAgain;
}
//_____________________________________________________________________________
void QSequence::CheckModuleWithNeighbours() {
  std::vector<QBaseModule*>::iterator it;
  std::vector<QBaseModule*> allModules = modules;
  if(p_Driver)   allModules.push_back(p_Driver);
  if(p_Writer)   allModules.push_back(p_Writer);
  
  std::string s = "Sequence " + GetName();
  std::stringstream msg;
  msg<<"Modules that needed neigbours:";
  bool need = false;
  for(it=allModules.begin(); it != allModules.end(); it++) {
    QBaseModule *m=(*it);
    if(m->NeedNeighbours()) {
      need = true;
      msg<<" "<<m->GetName();
    }
    }
  if(!need) return;
  if(p_Reader->NeighboursOn()) {
    QMessageHandler::Get()->Send(DebugMsg,s,msg.str());
    }
  else {
    QMessageHandler::Get()->Send(ErrorMsg,s,"Neighbours not enabled in the reader");
    QMessageHandler::Get()->Send(ErrorMsg,s,msg.str());
  }
}
//_____________________________________________________________________________
const QError& QSequence::JumpToEvent(Long64_t event, QBaseModule* caller) {
  static QBaseModule* firstCaller = caller;
  static QError err = QERR_UNKNOWN_ERR;
  if(caller!=firstCaller) { 
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("JumpToEvent already owned by module:" + firstCaller->GetName());
    return err;
  } 
  return p_Reader->BaseJumpToEvent(event);
}
//_____________________________________________________________________________
void QSequence::PrintEvents(const QEvent& ev, const QEventList& evList) const {
  std::string s = "Sequence " + GetName();
  std::stringstream estr;
  std::string caller = "unknown";
  if(ev.GetOwner()) caller = *ev.GetOwner();
 
  switch(GetSequenceStatus()){
  case kSequenceConfig:
    estr << "Detected error during sequence configuration \"" << caller
         << "\". (Iteration " << GetIteration()
         << "). Printing the event template"; break;
  case kSequenceInit:
    estr << "Detected error during module Init loop \"" << caller
         << "\". (Iteration " << GetIteration()
         << "). Printing the event template"; break;
  case kSequenceDo:
    estr << "Detected error in event loop, caller \"" << caller
         << "\". (Iteration " << GetIteration()
         << "). Printing the last event"; break;
  default:
    break;
  }
  if(!evList.Empty())
    estr<<" and its "<<evList.Size()<<" neighbours:"<<std::endl;
  else estr<<":"<<std::endl;
  QMessageHandler::Get()->Send(ErrorMsg,s,estr.str());
  
  std::stringstream estr2;
  estr2<<"Main Event: ";
  ev.Dump(estr2);
  QMessageHandler::Get()->Send(InfoMsg,s,estr2.str());
  
  for(size_t i = 0; i < evList.Size(); i++) {
    std::stringstream estr;
    estr<<"Neighbour "<<i<<": ";
    evList[i].Dump(estr);
    QMessageHandler::Get()->Send(InfoMsg,s,estr.str());
  }
}
//_____________________________________________________________________________
void QSequence::PrintGlobal() const {
  std::string s = "Sequence " + GetName();
  std::stringstream estr;
  estr<<"Detected error in GlobalData. Printing GlobalData:"<<std::endl;
  QMessageHandler::Get()->Send(ErrorMsg,s,estr.str());
  
  std::stringstream estr2;
  fGlobalData.Dump(estr2);
  QMessageHandler::Get()->Send(InfoMsg,s,estr2.str());
}
//_____________________________________________________________________________
std::string QSequence::GetReaderName() const { 
  if(p_Reader) return p_Reader->GetName();
  else return "";
}
//_____________________________________________________________________________
std::string QSequence::GetWriterName() const { 
  if(p_Writer) return p_Writer->GetName();
  else return "";
}
//_____________________________________________________________________________
std::string QSequence::GetDriverName() const { 
  if(p_Driver) return p_Driver->GetName();
  else return "";
}
//_____________________________________________________________________________
void QSequence::SaveConfig() {
  std::string s = "Sequence " + GetName();
  // save framework config
  fGlobalData.SetOwner("Diana");
  
  GlobalHandle<QFrameWorkConfig> fwcHandle("Config");
  fGlobalData.Get(&fwcHandle,"CurrentReader");
  
  QFrameWorkConfig fwc; // empty
  if(!fRWCommon.fFrameWorkConfigOld.fSequences.empty()) {
    QMessageHandler::Get()->Send(InfoMsg,s,"Object Diana@Config loaded from output files");
    fwc = fRWCommon.fFrameWorkConfigOld;
  }
  else if(fwcHandle.IsValid()) {
    QMessageHandler::Get()->Send(DebugMsg,s,"Object Diana@Config loaded from input files");
    fwc = fwcHandle.Get();
  }
  else {
    QMessageHandler::Get()->Send(DebugMsg,s,fwcHandle.GetError().GetDescription());
    QMessageHandler::Get()->Send(DebugMsg,s,"Could not find object Diana@Config from input or output files files");
  }
  
  if(GetIteration() == 1 ) fwc.fSequences.push_back(&fConfig);
  GlobalHandle<QFrameWorkConfig> fwcHandle2("Config");
  fwcHandle2.Set(fwc);
  QError cerr = fGlobalData.Set(&fwcHandle2,"");
  fGlobalData.SetOwner("");
}
//_____________________________________________________________________________
 
 
Q_END_NAMESPACE