ActiveDiagnoser.cc

Go to the documentation of this file.

#include <string>
#include <vector>
#include <set>
#include <iostream>
#include <fstream>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/program_options/parsers.hpp>
#include <utils/StringTools.hh>
#include <automata/Event.hh>
#include <automata/ObservableComponent.hh>
#include <automata/SpecialisedActiveDiagnoser.hh>
#include <sdmdl/SdmdlParser.hpp>
#include <sdmdl/SdmdlLexer.hpp>
#include <sdmdl/Unfolding.hh>

namespace po = boost::program_options;
using std::string;
using std::vector;
using std::cout;
using std::endl;
using std::set;
using std::ifstream;
using Diades::Automata::ObservableComponent;
using Diades::Automata::EventFactory;
using Diades::Automata::SpecialisedActiveDiagnoser;
using Diades::Sdmdl::Unfolding;
using Diades::Automata::State;


/**************************************************************************************/


string tag(SpecialisedActiveDiagnoser::Tag tag)
{
  switch(tag)
        {
        case SpecialisedActiveDiagnoser::Tag::Undiscriminable:
          {
                return "U";
          }
        case SpecialisedActiveDiagnoser::Tag::Discriminable:
          {
                return "D";
          }
         case SpecialisedActiveDiagnoser::Tag::Safe:
          {
                return "N";
          }
        case SpecialisedActiveDiagnoser::Tag::Sure:
          {
                return "Y";
          } 
        }
  return "";
}


int export2Hydiag(const SpecialisedActiveDiagnoser & diagnoser, const string & filename)
{
  bool result = 0;
  stringstream logStream;
  ofstream file(filename.c_str());
 
  
  if(!file)
        {
          result = 1;
          logStream << "cannot open file '" << filename << "'.";
        }
  else
        {
          file << (diagnoser.numberOfStates() - 1) << endl;
          if(!file)
                {
                  result = 1;
                  logStream << "cannot write the number of states in file " << filename << ".";
                }
          else
                {
                  file << diagnoser.events().size() << endl;
                  if(!file)
                        {
                          result = 1;
                          logStream << "cannot write the number of observable events in file " << filename << ".";
                        }
                  else
                        {
                          NodeMap<unsigned> indexOf(diagnoser.behaviour());
                          vector<State> states;
                          int index = 0;
                          indexOf[diagnoser.initialState()] = index;
                          ++index;
                          
                          // writing the states
                          stringstream streamStates;
                          streamStates << "(";
                          states.push_back(diagnoser.initialState());
                          streamStates << (indexOf[diagnoser.initialState()]+1) << "," << tag(diagnoser.tag(diagnoser.initialState())) << ")";
                          string initial = streamStates.str();
                          streamStates << endl;
                          // duplication of the initial state
                          streamStates <<  initial;
                          
                          for(SpecialisedActiveDiagnoser::StateIterator stateIt = diagnoser.stateBegin();
                                  stateIt != diagnoser.stateEnd();
                                  ++stateIt)
                                {
                                  if(*stateIt != diagnoser.initialState())
                                        {
                                          if(!diagnoser.isHole(*stateIt))
                                                {
                                                  states.push_back(*stateIt);
                                                  indexOf[*stateIt] = index;
                                                  ++index;
                                                  streamStates << " (" << (indexOf[*stateIt]+1) << "," << tag(diagnoser.tag(*stateIt)) << ")";
                                                }
                                        }
                                }
                          file << streamStates.str() << endl;
                          if(!file)
                                {
                                  result = 1;
                                  logStream << "cannot write the list of belief states in file " << filename << ".";
                                }
                          else
                                {
                                  string observationLabels;
                                  vector<Diades::Automata::Event> observations;
                                  // writing the observations
                                  for(const Diades::Automata::Event & evt : diagnoser.events())
                                        {
                                          observations.push_back(evt);
                                          observationLabels += evt.nickname() + " ";
                                        }
                                  file <<  observationLabels << endl;
                                  if(!file)
                                        {
                                          result = 1;
                                          logStream << "cannot write the list of observations in file " << filename << ".";
                                        }
                                  else
                                        {
                                          // writing the incidence matrix
                                          vector<Diades::Automata::Event>::size_type i = 0;
                                          while((result==0) && (i < observations.size()))
                                                {
                                                  stringstream matrixLine;
                                                  for(vector<State>::size_type j = 0; j < states.size(); ++j)
                                                        {
                                                          SpecialisedActiveDiagnoser::OutputEventTransitionIterator transIt = diagnoser.outputEventTransitionBegin(states[j],observations[i]);
                                                          if(transIt != diagnoser.outputEventTransitionEnd(states[j],observations[i]))
                                                                {
                                                                  if(!diagnoser.isHole(transIt->target()))
                                                                        {
                                                                          matrixLine << indexOf[transIt->target()] << " ";
                                                                        }
                                                                  else
                                                                        {
                                                                          matrixLine << -1 << " ";
                                                                        }
                                                                }
                                                          else
                                                                {
                                                                  matrixLine << -1 << " ";
                                                                }
                                                        }

                                                  file <<  matrixLine.str() << endl;
                                                  if(!file)
                                                        {
                                                          result = 1;
                                                          logStream << "cannot write the line " << i << " of the incidence matrix in file " << filename << ".";         
                                                        }
                                                  else
                                                        {
                                                          ++i;
                                                        }
                                                }
                                        }
                                }
                        }
                }
          if(result!= 0)
                {
                  cerr << "Export to HyDiag: " + logStream.str() << endl;
                }
        }
  return result;
}



/**************************************************************************************/


int initialiseModelFromDesComp(const string & filename,
                                                           ObservableComponent & globalModel,
                                                           const set<string> & shortNameFaults,
                                                           unordered_map<string,string> & dictionary,
                                                           set<string> & faults,
                                                           set<string> & nominals)
{
  int result = 0;
  try
        {
          string log;
          if( ! globalModel.import(filename.c_str()))
                {
                  cerr << "Model import: problem, see the log below: " << endl;
                  cerr << "LOG START:" << endl;
                  cerr << log << endl;
                  cerr << "LOG END" << endl;
                  result = 1;
                }
          else
                {
                  for(const Diades::Automata::Event & evt : globalModel.events())
                        {
                          dictionary[evt.label()]= evt.nickname();
                          if(shortNameFaults.find(evt.nickname()) != shortNameFaults.end())
                                {
                                  faults.insert(evt.label());
                                }
                          else
                                {
                                  nominals.insert(evt.label());
                                }
                        }
                }
        }
  catch(std::exception & e)
        {
          result = 1;
        }

  return result;
}



/**************************************************************************************/

int initialiseModelFromSdmdl(const string & filename,
                                                         ObservableComponent & globalModel,
                                                         VariableFactory & factory,
                                                         const set<string> & shortNameIgnored,
                                                         const set<string> & shortNameFaults,
                                                         unordered_map<string,string> & dictionary,
                                                         set<string> & faults,
                                                         set<string> & nominals)
{
  int result = 0;
  map<string,ComponentType *> results;
  try
        {
          ifstream file(filename);
          SdmdlLexer lexer(file);
          bool verbose = false;
          SdmdlParser parser(lexer);
          stringstream parsingLog;
          parser.libraryUnit(results,factory,verbose,parsingLog);
          file.close();
          if(results.empty())
                {
                  cerr << "Error: no model is loaded." << endl;
                  cerr <<  parsingLog.str() << endl;
                  result = 1;
                }
          else
                {
                  ComponentType & component = *results.begin()->second; 
                  set<string> nonNominalEvents;
                 

                  for(set<string>::const_iterator it = shortNameIgnored.begin();
                          it != shortNameIgnored.end();
                          ++it)
                        {
                          if(component.containsSpontaneousEventOfLabel(*it))
                                {
                                  nonNominalEvents.insert(component.spontaneousPort().label() + "." + *it);
                                }
                          else
                                {
                                  nonNominalEvents.insert(*it);
                                }                       
                        }

                  for(set<string>::const_iterator it = shortNameFaults.begin();
                          it != shortNameFaults.end();
                          ++it)
                        {
                          if(component.containsSpontaneousEventOfLabel(*it))
                                {
                                  nonNominalEvents.insert(component.spontaneousPort().label() + "." + *it);
                                  faults.insert(component.spontaneousPort().label() + "." + *it);
                                }
                          else
                                {
                                  nonNominalEvents.insert(*it);
                                  faults.insert(*it);             
                                }                       
                        }

                  for(ComponentType::EventIterator it = component.beginOfInputEvents();
                          it != component.endOfInputEvents();
                          ++it)
                        {
                          if(nonNominalEvents.find((*it)->label()) == nonNominalEvents.end())
                                {
                                  nominals.insert((*it)->label());
                                }
                        }

                   set<string> triggers = nominals;
                   for(set<string>::const_iterator faultIt = faults.begin();
                           faultIt != faults.end();
                           ++faultIt)
                         {
                           triggers.insert(*faultIt);
                         }
                   Unfolding unfold2(component,triggers,dictionary,"global_model");
                   string log;
                   string globalModelFileName ("global_model.des_comp");
                   if( ! globalModel.import(globalModelFileName.c_str()))
                         {
                           cerr << "Model import: problem, see the log below: " << endl;
                           cerr << "LOG START:" << endl;
                           cerr << log << endl;
                           cerr << "LOG END" << endl;
                           result = 1;
                         }
                }
        }
  catch(std::exception & e)
        {
          result = 1;
        }
  for(std::pair<const string,ComponentType *> & p : results)
        {
          if(p.second != nullptr)
                {
                  delete p.second;
                  p.second = nullptr;
                }
        }
  results.clear();
  return result;
}

/**************************************************************************************/


int initialiseDiagnosers(const ObservableComponent & model, const set<string> & faults,
                                                  unordered_map<string,string> & dictionnary,
                                                  unordered_map<string,SpecialisedActiveDiagnoser *> & activeDiagnoser)
{
  int result = 0;
  for(set<string>::const_iterator faultIt = faults.begin();
          faultIt != faults.end();
          ++faultIt)
        {
          std::cout << "Computation of the diagnoser..." << (model.name()+ "." + dictionnary[*faultIt]) << std::endl;
          activeDiagnoser[*faultIt] = new SpecialisedActiveDiagnoser(model,EventFactory::factory()->getEvent(model.name()+ "." + dictionnary[*faultIt]));
          std::cout << "this is done" << std::endl;
          string log;
          if(!activeDiagnoser[*faultIt]->sanityCheck(log))
                {
                  cout << "SANITY CHECK ERROR of the active diagnoser of fault " << *faultIt << ":" << endl;
                  cout << log << endl;
                  return 1;
                }
          
        }
  return result;
}

/**************************************************************************************/


void printUsage(const po::options_description & desc)
{
  cout << "Diades: active diagnoser" << endl;
  cout << "LAAS, CNRS, Univ. Toulouse, FRANCE. Copyright 2006-2014" << endl;
  cout << "Contact: ypencole@laas.fr" << endl << endl;
        
  cout << desc << endl;
  cout <<  "Compute the active diagnoser of the file 'file.sdmdl' or the file" << endl;
  cout << "'file.des_comp'. The events listed after '--faults' are considered" << endl;
  cout << "as fault events. The events listed after '--ignored' are simply" << endl;
  cout << "ignored INPUT events in the model 'file.sdmdl' (this option is" << endl;
  cout << "simply ignored if the model is in 'des_comp' format. Any event" << endl;
  cout << "that is in the model but not listed as a fault or as an ignored" << endl;
  cout << "event is considered as a normal event." << endl;
}

/**************************************************************************************/


int main(int ac, char ** av)
{
  // Declare the supported options.
  po::options_description desc("Allowed options");
  desc.add_options()
    ("help", "produce this help message")
        ("model-file", po::value<string>(), "model file")
        ("fault", po::value< vector<string> >(), "fault event")
        ("ignored", po::value< vector<string> >(), "ignored input event (sdmdl model only)")
        ("had",  po::value<string>(), "Hydiag Active Diagnoser format")
        ("dot",  po::value<string>(), "dot (graphviz) format")
        ;
  po::positional_options_description p;
  p.add("model-file", -1);
  po::variables_map vm;
  po::store(po::command_line_parser(ac, av).
                        options(desc).positional(p).run(), vm);
  po::notify(vm);

  if (vm.count("help"))
        {
          printUsage(desc);
          return 0;
        }
  string filename;
  if(vm.count("model-file"))
        {
          filename = vm["model-file"].as<string>();
        }
  else
        {
          cout << "ERROR: expecting a model file (sdmdl or des_comp extensions)" << endl << endl;
          printUsage(desc);
          return 1;
        }
  vector<string> suffixes = { "sdmdl", "des_comp" };
  vector<string>::const_iterator it = Diades::Utils::getFileExtension(filename,suffixes.begin(),suffixes.end());
  if(it == suffixes.end())
        {
          cout << "ERROR: wrong suffix in the name of the model file. Expecting 'sdmdl' or 'des_comp' formats." << endl << endl;
          printUsage(desc);
          return 1;
        }
  bool isSdmdl = (*it == "sdmdl");
  set<string> shortNameFaults;
  if(vm.count("fault"))
        {
          const vector<string> & vtr = vm["fault"].as<vector<string>>();
          for(size_t i = 0; i <  vtr.size(); ++i)
                {
                  shortNameFaults.insert(vtr[i]);
                }
        }
  set<string> shortNameIgnored;
  if(isSdmdl)
        {
          if(vm.count("ignored"))
                {
                  const vector<string> & vtr = vm["ignored"].as<vector<string>>();
                  for(size_t i = 0; i <  vtr.size(); ++i)
                        {
                          shortNameIgnored.insert(vtr[i]);
                        }
                }
        }
  bool had = vm.count("had");
  bool dot = vm.count("dot");
  string hadfilename;
  string dotfilename;
  if(had)
        {
          hadfilename = vm["had"].as<string>();
        }
  if(dot)
        {
          dotfilename = vm["dot"].as<string>();
        }
  

  
  
  ObservableComponent globalModel;
  unordered_map<string,string> dictionary;
  set<string> faultEvents;
  set<string> nominalEvents;
  if(isSdmdl)
        {
          VariableFactory * factory = new VariableFactory();      
          int result = initialiseModelFromSdmdl(filename,globalModel,*factory,shortNameIgnored,shortNameFaults,dictionary,faultEvents,nominalEvents);
          if(result!=0)
                {
                  cout << "ERROR: the generation of the global model (automaton) from the sdmdl description has failed. Check your model." << endl;
                  delete factory;
                  return 1;
                }
        }
  else
        {
          int result = initialiseModelFromDesComp(filename,globalModel,shortNameFaults,dictionary,faultEvents,nominalEvents);
          if(result!=0)
                {
                  cout << "ERROR: the import of the global model (automaton) from the des_comp file has failed. Check your model." << endl;
                  return 1;
                }
        }
  unordered_map<string,SpecialisedActiveDiagnoser *> activeDiagnoser;
  int result = initialiseDiagnosers(globalModel, faultEvents, dictionary, activeDiagnoser);
  if(result != 0)
        {
          cout << "ERROR: the sanity check of the active diagnosers has failed." << endl;
          return 1;
        }
  if(dot)
        {
          if(faultEvents.size()==1)
                {
                  for(std::pair<const string,SpecialisedActiveDiagnoser *> & p : activeDiagnoser)
                        {
                          p.second->diagnoser2Dot(dotfilename);
                        }
                }
          else
                {
                  string dotfilenameprefix;
                  unsigned found = dotfilename.find_last_of(".dot");
                  if(found!= string::npos)
                        {
                          if(found+1 == dotfilename.size())
                                {
                                  dotfilenameprefix = dotfilename.substr(0,found-3);
                                }
                          else
                                {
                                  dotfilenameprefix = dotfilename;
                                }
                        }
                  for(std::pair<const string,SpecialisedActiveDiagnoser *> & p : activeDiagnoser)
                        {
                          string filename = dotfilenameprefix +  p.first.substr(p.first.find_first_of(".")+1,p.first.size())  + ".dot";
                          p.second->diagnoser2Dot(filename);
                        }
                }
        }
  if(had)
        {
           if(faultEvents.size()==1)
                {
                  for(std::pair<const string,SpecialisedActiveDiagnoser *> & p : activeDiagnoser)
                        {
                          int result = export2Hydiag(*p.second,hadfilename);
                          if(result != 0)
                                {
                                  cout << "ERROR: abort." << endl;
                                }
                        }
                }
          else
                {
                  string hadfilenameprefix;
                  unsigned found = hadfilename.find_last_of(".had");
                  if(found!= string::npos)
                        {
                          if(found+1 == hadfilename.size())
                                {
                                  hadfilenameprefix = hadfilename.substr(0,found-3);
                                }
                          else
                                {
                                  hadfilenameprefix = hadfilename;
                                }
                        }
                  for(std::pair<const string,SpecialisedActiveDiagnoser *> & p : activeDiagnoser)
                        {
                          string filename = hadfilenameprefix + p.first.substr(p.first.find_first_of(".")+1,p.first.size()) + ".had";
                          int result = export2Hydiag(*p.second,filename);
                          if(result != 0)
                                {
                                  cout << "ERROR: abort." << endl;
                                }
                        }
                }
        }
  return 0;
}


// /*
//  * ActiveDiagnoser.cc
//  *
//  *  Created on: 30 sept. 2008
//  *      Author: ypencole
//  */


// #include <unordered_map>
// #include <iostream>
// #include <fstream>
// #include <map>
// #include <ctime>
// #include <automata/Trace.hh>
// #include <automata/SpecialisedActiveDiagnoser.hh>
// #include <utils/Substring.hh>
// #include <sdmdl/ComponentType.hh>
// #include <sdmdl/Unfolding.hh>
// #include <sdmdl/SdmdlLexer.hpp>
// #include <sdmdl/SdmdlParser.hpp>
// #include <active/aostar.h>
// #include <active/fault.h>
// #include <active/test.h>
// #include <active/obs.h>

// using namespace Diades::Automata;
// using namespace Diades::Utils;
// using namespace Diades::Sdmdl;

// using namespace aostar;

// /// print out how to use the program on the standard output
// void printUsage();

// /**
//    1) load the sdmdl file into a ComponentType object (symbolic/logic representation)
//    2) translate into a Model object (DES representation, see SAFEPROCESS article)
//    and write the file "global_model.lafmodel
//    3) create a dictionnary (sdmdl event -> lafmodel event)
// **/
// void initialiseModels(int argc, char ** argv, VariableFactory * factory, ComponentType ** component,
//                                        ObservableComponent ** model, unordered_map<string,string> & dictionnary,
//                                        set<string> & faults, set<string> & nominal);

// /**
//    Initialise a specialised diagnoser for each fault (see SAFEPROCESS article)
// **/
// void initialiseDiagnosers(const  ObservableComponent * model, const set<string> & faults,
//                                                unordered_map<string,string> & dictionnary,
//                                                unordered_map<string,SpecialisedActiveDiagnoser *> & activeDiagnoser);

// /******************************************************************************************/

// /**
//    1) load the cost file
//    2) initialize C_Obs, C_Test and C_Fault structures
// **/
// vector<C_Obs*> initObs(unordered_map<string,string> dictionnary);

// void costFilePaser(string fileName, unordered_map<string,string> & dictionnary,
//                    vector<C_Obs*>& obs, vector<C_Test*>& test, vector<C_Fault*>& fault);

// /**
//    generate a scenario on globalModel
// **/
// vector<string> scenario(const ObservableComponent * model, const set<string> & faults, State& initialState);
// Diades::Graph::OutEdgeIterator randTrans(State currentState);

// /**
//    browse the scenario on the active diagnoser en return the initial state for AO*
// **/
// vector<State> activeDiagnoserBrowser(vector<string> seq, const set<string> & faults,
//                                      unordered_map<string,SpecialisedActiveDiagnoser *> & activeDiagnoser);

// /******************************************************************************************/

// int main(int argc, char ** argv)
// {
//   // Offline computation
//   VariableFactory * factory = new VariableFactory();
//   ObservableComponent * globalModel;
//   ComponentType * component;
//   unordered_map<string,SpecialisedActiveDiagnoser *> activeDiagnoser;
//   unordered_map<string,string> dictionnary;
//   set<string> faultEvents;
//   set<string> nominalEvents;

//   initialiseModels(argc, argv, factory,  &component, &globalModel, dictionnary, faultEvents, nominalEvents);
//   initialiseDiagnosers(globalModel, faultEvents, dictionnary, activeDiagnoser);

//   // globalModel contains the DES model (see AModel/Model.hh)
//   // activeDiagnoser[faultEvent] contains the specialised active diagnoser of the fault 'fault event'

//   //Online computation (NICOLAS)

//   // cost file parser

//   vector<C_Obs*> r_pObs = initObs(dictionnary);
//   vector<C_Test*> r_pTest;
//   vector<C_Fault*> r_pFault;
//   string filename = argv[1];
//   string key = "sdmdl";
//   size_t found = filename.rfind(key);
//   if (found!=string::npos)
//     filename.replace (found,key.length(),"cost");

//   costFilePaser(filename, dictionnary, r_pObs, r_pTest, r_pFault);

//   // 1) générer un scénario (séquences d'événements) sur le globalModel
  
//   vector<State> currentState;
//   State initialState;
//   vector<string> sequence;

// //do {
//   cout << "Generation of a scenario...." << flush;
//   sequence = scenario(globalModel, faultEvents, initialState);
//   cout << "Done." << endl;
  
//   // 2) faire tourner chaque diagnostiqueur sur la séquence d'observation associée au scénario
  
//   currentState = activeDiagnoserBrowser(sequence, faultEvents, activeDiagnoser);

// //}while( !(currentState[0].id()== 9) );//65 && currentState[1].id()== 26) );

// #ifdef __DEBUG
//   for(unsigned i = 0;i < currentState.size() ; ++i)
//     {
//       cout << activeDiagnoser[r_pFault[i]->Get_Name()]->eventLabel() << " " << currentState[i];
//       switch(activeDiagnoser[r_pFault[i]->Get_Name()]->tag(currentState[i]))
//         {
//           case 0 : cout <<  "\tUndiscriminable" << endl;break;
//           case 1 : cout <<  "\tDiscriminable" << endl;break;
//           case 2 : cout <<  "\tSafe" << endl;break;
//           case 3 : cout <<  "\tSure" << endl;break;
//         }
//     }
// #endif

//   // 3) en fonction des tags courants des diagnostiqueurs, lancé la planif diag actif

//   vector<string> seq;

//   C_Aostar l_Ao(r_pFault,r_pTest,r_pObs,sequence,activeDiagnoser);

//   if(l_Ao.Init(currentState))
//     seq = l_Ao.Run();

//   // A FAIRE

//   // 4) appliquer le plan conditionnel sur le globalModel

//   return EXIT_SUCCESS;
// }

// /******************************************************************************************/

// void initialiseModels(int argc, char ** argv, VariableFactory * factory, ComponentType ** component,
//                                        ObservableComponent ** model, unordered_map<string,string> & dictionnary,
//                                        set<string> & faults, set<string> & nominal)
// {
//   if(argc < 4)
//      {
//        printUsage();
//        exit(1);
//      }
//   string currentParameter = argv[1];
//   string goodSuffix = ".sdmdl";
//   if (currentParameter.size() <= goodSuffix.size())
//      {
//        cerr << "Error: the file name " << currentParameter << " is incorrect." << endl;
//        printUsage();
//        exit(1);
//      }
//   else
//      {
//        string suffix = currentParameter.substr(currentParameter.size()-goodSuffix.size(),
//                                                                                        currentParameter.size()-1); 
//        if(suffix != goodSuffix)
//              {       
//                cerr << "Error: the file name " << currentParameter << " is incorrect." << endl;
//                exit(1);
//              }
//      }
        
//   currentParameter = argv[2];
//   if(currentParameter != "--faults")
//      {
//        cerr << "Error: '--faults' is expected but it is " << currentParameter << " instead." << endl;
//        printUsage();
//        exit(1);
//      }

//   // load the faulty events
//   set<string> faultsWithShortName;
//   int index = 3;

// #ifdef __DEBUG
//   cout << "Fault events: " << endl;
// #endif

//   while(index < argc && (currentParameter != "--ignored"))
//      {
//        currentParameter = argv[index];
//        if(currentParameter != "--ignored")
//              {
//                faultsWithShortName.insert(currentParameter);

// #ifdef __DEBUG
//                cout << "\t " << currentParameter << endl;
// #endif

//                ++index;
//              }
//      }
        
//   set<string> ignored;
        
//   if(index != argc)
//      {
//        if(faultsWithShortName.empty())
//              {
//                cerr << "Error: no fault is listed so it is useless to compute an active diagnoser." << endl;
//                printUsage();
//                exit(1);
//              }
//        ++index;

//        // load the ignored events
// #ifdef __DEBUG
//        cout << "Ignored events: " << endl;
// #endif

//        while(index < argc)
//              {
//                currentParameter = argv[index];

// #ifdef __DEBUG
//                cout << "\t " << currentParameter << endl;
// #endif

//                ignored.insert(currentParameter);
//                ++index;
//              }
//      }

//   // Load the model
// #ifdef __DEBUG
//   cout << "Model loading: " << argv[1] << endl;
// #endif

//   ifstream file(argv[1]);
//   SdmdlLexer lexer(file);
//   bool verbose = false;
//   SdmdlParser parser(lexer);
//   map<string,ComponentType *> results;
//   stringstream parsingLog;
//   parser.libraryUnit(results,*factory,verbose,parsingLog);

// #ifdef __DEBUG
//   cout << "Model sucessfully loaded" << endl;
// #endif

//   if(results.empty())
//      {
//        cerr << "Error: no model is loaded." << endl;
//        cerr <<  parsingLog.str() << endl;
//        exit(1);
//      }
        
//   *component = results.begin()->second;      
 
//   set<string> nonNominalEvents;

//   for(set<string>::const_iterator it = ignored.begin();
//        it != ignored.end();
//        ++it)
//      {
//        if((*component)->containsSpontaneousEventOfLabel(*it))
//              {
//                nonNominalEvents.insert((*component)->spontaneousPort().label() + "." + *it);
//              }
//        else
//              {
//                nonNominalEvents.insert(*it);
//              }                       
//      }
  
//   for(set<string>::const_iterator it = faultsWithShortName.begin();
//        it != faultsWithShortName.end();
//        ++it)
//      {
//        if((*component)->containsSpontaneousEventOfLabel(*it))
//              {
//                nonNominalEvents.insert((*component)->spontaneousPort().label() + "." + *it);
//                faults.insert((*component)->spontaneousPort().label() + "." + *it);
//              }
//        else
//              {
//                nonNominalEvents.insert(*it);
//                faults.insert(*it);

// #ifdef __DEBUG
//                cout << *it << " is a fault non-spontaneous event" << endl;
// #endif

//              }                       
//      }
  
//   for(ComponentType::EventIterator it = (*component)->beginOfInputEvents();
//        it != (*component)->endOfInputEvents();
//        ++it)
//      {
//        if(nonNominalEvents.find((*it)->label()) == nonNominalEvents.end())
//              {
//                nominal.insert((*it)->label());
//              }
//      }
  
//   // compute the whole model of the system
// #ifdef __DEBUG
//   cout << "Compute the global behavioural model of the system..." << endl; 
// #endif

//   set<string> triggers = nominal;
//   for(set<string>::const_iterator faultIt = faults.begin();
//        faultIt != faults.end();
//        ++faultIt)
//      {
//        triggers.insert(*faultIt);
//      }
//   Unfolding unfold2(**component,triggers,dictionnary,"global_model");
//   *model = new ObservableComponent();
//   string log;
//   string globalModelFileName ("global_model.des_comp");
  
// //  (*model)->import(globalModelFileName.c_str(),true);
//   if( ! (*model)->import(globalModelFileName.c_str()) )
//      {
//        cerr << "Model import: problem, see the log below: " << endl;
//        cerr << "LOG START:" << endl;
//        cerr << log << endl;
//        cerr << "LOG END" << endl;
//      }
//   if(! (*model)->component2dot("global_model.dot") )
//      {
//        cerr << "Model export: problem, see the log below: " << endl;
//        cerr << "LOG START:" << endl;
//        cerr << log << endl;
//        cerr << "LOG END" << endl;      
//      }

// #ifdef __DEBUG
//   cout << "Done" << endl;
// #endif
// }

// /******************************************************************************************/

// void initialiseDiagnosers(const ObservableComponent * model, const set<string> & faults,
//                                                unordered_map<string,string> & dictionnary,  
//                                                unordered_map<string,SpecialisedActiveDiagnoser *> & activeDiagnoser)
// {
//   for(set<string>::const_iterator faultIt = faults.begin();
//        faultIt != faults.end();
//        ++faultIt)
//      { 
// #ifdef __DEBUG
//        cout << "Compute the active diagnoser of the fault " << dictionnary[*faultIt] << " = " << *faultIt << "." << endl;
// #endif

          
//        activeDiagnoser[*faultIt] = new SpecialisedActiveDiagnoser(*model,EventFactory::factory()->getEvent(model->name()+ "." + dictionnary[*faultIt]));
//        activeDiagnoser[*faultIt]->diagnoser2Dot(*faultIt + "_active_diagnoser.dot");

// #ifdef __DEBUG
//        cout << "Done." << endl;
// #endif
//      }
// }

// /*******************************************************************************************/

// void printUsage()
// {
//   cerr << "ActiveDiagnoser file.sdmdl --faults evt1 [evt2 ...] [--ignored  evt3 [evt4 ...]]" << endl;
//   cerr << "     Compute the active diagnoser of the file 'file.sdmdl'. " << endl;
//   cerr << "     The events listed after '--faults' are considered as fault events in the model 'file.sdmdl'." << endl;
//   cerr << "     The events listed after '--ignored' are simply ignored INPUT events in the model 'file.sdmdl'." << endl;
//   cerr << "     Any event that is in the model but not listed as a fault or as an ignored event is considered as a normal event." << endl;
// }

// /*******************************************************************************************/
//   // cost file parser

// vector<C_Obs*> initObs(unordered_map<string,string> dictionnary)
// {
//   vector<C_Obs*> obs;

//   for(unordered_map<string,string>::const_iterator it = dictionnary.begin();it != dictionnary.end();++it)
//     if (it->second[0] == 'o')
//       obs.push_back(new C_Obs(it->second,it->first));
//   return obs;
// }

// void costFilePaser(string fileName, unordered_map<string,string> & dictionnary,
//                    vector<C_Obs*>& obs, vector<C_Test*>& test, vector<C_Fault*>& fault)
// {
//   string label,type,name;
//   set<C_Obs*> tmp;
//   vector<C_Obs*> obj;
//   vector<C_Test*> repair;
//   int nb,nbs;
//   double cost;
//   bool repairable;

//   ifstream file(fileName.c_str());
  
//   if (!file)
//     {
//       cerr << "fichier inexistant" << endl;
//       return;
//     }

//   while (!file.eof())
//     {
//       file >> type >> nb;
//       for (int i=0; i<nb; ++i)
//         {
//           if (type == "ACTION")
//             {
//               file >> label >> cost;
//               test.push_back(new C_Test(dictionnary[label],label,cost));
//             }
//           else if  (type == "OBJECTIF")
//             {
//               file >> label >> cost;
//               for(unsigned j = 0;j < obs.size();++j)
//                 if (obs[j]->Get_Name().find(label) != string::npos)
//                   obs[j]->Add_Reward(cost);
//             }
//           else if  (type == "PANNE")
//             {
//               obj.clear();
//               repair.clear();
//               file >> label >> repairable >> nbs;
//               if (repairable == 0)
//                 {
//                   for (int k = 0; k < nbs; ++k)
//                     {
//                       file >> name;
//                       for(unsigned j = 0;j < obs.size();++j)
//                         if (obs[j]->Get_Name().find(name) != string::npos)
//                           tmp.insert(obs[j]);
//                     }
//                   for(set<C_Obs*>::const_iterator it = tmp.begin();it != tmp.end();++it)
//                     obj.push_back(*it);
// //                  cout << "obj : " << obj.size() << endl;
//                   fault.push_back(new C_Fault(dictionnary[label],label,repairable,obj));
//                 }
//               else
//                 {
//                   for (int k = 0; k < nbs ; ++k)
//                     {
//                       file >> name;
//                       for(unsigned j = 0;j < test.size();++j)
//                         if (test[j]->Get_Name() == name)
//                           repair.push_back(test[j]);
//                     }
// //                  cout << "repair : " << repair.size() << endl;
//                   fault.push_back(new C_Fault(dictionnary[label],label,repairable,repair));
//                 }
//             }
//           else cerr << "mauvais fichier" << endl;
//         }
//       if  (type == "PANNE") break;
//     }
// //  cout << test.size() << " " << fault.size() << " " << obs.size() << endl;
// }

// /*******************************************************************************************/
//   // 1) générer un scénario (séquences d'événements) sur le globalModel

// vector<string> scenario(const ObservableComponent * model, const set<string> & faults,State& finalState)
// {
//   vector<string> seq;
//   Diades::Graph::OutEdgeIterator it;
//   bool fin = false;

//   srand(time(NULL));
//   State currentState = *(model->initialStateBegin());

//   while(1)
//     {
//       it=randTrans(currentState);
//       currentState = it->target();
//       seq.push_back( model->getEvent(*it).label() );
//       if (model->getEvent(*it).label()[4] == 's' && model->getEvent(*it).label()[5] == 'p')
//         fin = true;
//       else if (fin == true) break;
//     }
//   finalState = currentState;
//   return seq;
// }

// Diades::Graph::OutEdgeIterator randTrans(State currentState)
// {
//   int nb = rand() % currentState.outDeg();
//   Diades::Graph::OutEdgeIterator it = currentState.outEdgeBegin();
//   for(;nb>0;--nb)
//       ++it;
//   return it; 
// }

// /*******************************************************************************************/
//   // 2) faire tourner chaque diagnostiqueur sur la séquence d'observation associée au scénario

// vector<State> activeDiagnoserBrowser(vector<string> seq, const set<string> & faults,
//                                      unordered_map<string,SpecialisedActiveDiagnoser *> & activeDiagnoser)
// {
//   unsigned int count=0;
//   State current;
//   vector<State> currentState(faults.size());

//   for(set<string>::const_iterator faultIt = faults.begin();faultIt != faults.end();++faultIt)
//     {
//       current = activeDiagnoser[*faultIt]->initialState();
//       for(unsigned i=0; i<seq.size();++i)
//         {
//           for(EdgeIterator it = activeDiagnoser[*faultIt]->transitionBegin();it != activeDiagnoser[*faultIt]->transitionEnd();++it)
//             if (current == it->source() && seq[i] == activeDiagnoser[*faultIt]->getEvent(*it).label())
//               {
//                 current = it->target();
//                 break;
//               }
//         }
//       currentState.at(count++)=current;
//     }
//   return currentState;
// }