CheckAccuracy.cc

Go to the documentation of this file.

#include<set>
#include<sstream>
#include<utils/Log.hh>
#include<utils/Verbose.hh>
#include<utils/StringTools.hh>
#include<utils/Exceptions.hh>
#include<automata/Topology.hh>
#include<automata/ObservableComponent.hh>
#include<automata/ConnectionMap.hh>
#include<automata/SubConfiguration.hh>
#include<automata/Accuracy.hh>

using namespace std;
using namespace Diades::Utils;

enum Parameter {
  NOPARAMETER,
  VERBOSE,
  DEPTH
};


void generateLatexPreamble( ofstream & latexfile)
{
  latexfile << "\\documentclass[11pt]{article}" << endl;
  latexfile << "\\usepackage{array}" << endl;
  latexfile << "\\textwidth 17cm \\textheight 26cm  \\voffset -3cm \\hoffset -1.6cm" << endl;
   latexfile << "\\title{Report on the accuracy analysis}" << endl;
  time_t rawtime;
  time ( &rawtime );
  latexfile << "\\date{" <<  ctime( &rawtime )  << "}"  << endl;
  latexfile << "\\author{Diades::check\\_accuracy tool, CNRS-LAAS, 2006-2011}" << endl;
  latexfile << "\\begin{document}" << endl;
  latexfile << "\\maketitle" << endl;
}

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

void generateLatexEpilog(ofstream & latexfile)
{
  latexfile << "\\end{document}" << endl;
}
/*************************************************************************************/


void printUsage()
{
  verbose<VbOutput>("Usage: check_accuracy Component.Fault topology.topo topologymap.maptopo subconfiguration.subconf [--depth number | --verbose verbose_mode --no_observable_interactions]\n");
  verbose<VbOutput>("     - Component.Fault: label of an event. 'Component' corresponds to the name of a component and\n");
  verbose<VbOutput>("     and Fault corresponds to the label of the event as written in the corresponding des_comp file\n");
  verbose<VbOutput>("     - verbose_mode is ether 'on' (simple output) or 'debug' (more details)\n");
  verbose<VbOutput>("     - the depth number is to limit the search for recommendations to a given depth.\n");
  verbose<VbOutput>("     Without this option, there is no limit, with depth= 0 there is no limit. BE CAREFUL,\n");
  verbose<VbOutput>("     THE RECOMMENDATION ALGORITHM IS EXPONENTIAL TO DEPTH. It may happen that for a given\n");
  verbose<VbOutput>("     depth, the algorithm does not find a solution, in this case it will return the whole set\n");
  verbose<VbOutput>("     of events that are relaxed and present in the traces generating an accuracy problem.\n\n"); 
  exit(0);
}

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


void getInterface(int argc, char ** argv, Diades::Utils::Identifier & component, Diades::Utils::Identifier & event,
                                  string & topologyFile, string & topologyMapFile, string & subconfigurationFile, 
                                  int & depth, VerboseLevel & level)
{
  if((argc < 5) || (argc > 9))
        {
          
          printUsage();
        }
  else
        {
          topologyFile.clear();
          topologyMapFile.clear();
          subconfigurationFile.clear();

          stringstream stream;
          stream << argv[1];
          char point;
          stream >> component >> point >> event;
          if(point != '.')
                {
                  cerr << "The interpretation of the fault event has failed, please check the format COMP.EVENT" << endl;
                  throw Diades::Utils::Failure("main");
                }
          list<string> extensions;
          extensions.push_back("topo");
          extensions.push_back("subconf");
          extensions.push_back("maptopo");
          list<string>::const_iterator it =  Diades::Utils::getFileExtension(string(argv[2]),extensions.begin(),extensions.end());
          string ext1 = *it;
          if(ext1=="topo")
                {
                  topologyFile = argv[2];
                }
          else
                {
                  if(ext1=="subconf")
                        {
                          subconfigurationFile = argv[2];
                        }
                  else
                        {
                          if(ext1=="maptopo")
                                {
                                  topologyMapFile = argv[2];
                                }
                          else
                                {
                                  
                                  printUsage();
                                }
                        }
                }
          it= Diades::Utils::getFileExtension(string(argv[3]),extensions.begin(),extensions.end());
          string ext2(*it);
          if((ext2 == "topo") && (topologyFile.empty()))
                {
                  topologyFile = argv[3];
                }
          else
                {
                  if((ext2 == "subconf") && (subconfigurationFile.empty()))
                        {
                          subconfigurationFile = argv[3];
                        }
                  else
                        {
                          if((ext2 == "maptopo") && (topologyMapFile.empty()))
                                {
                                  topologyMapFile = argv[3];
                                }
                          else
                                {
                                  printUsage();
                                }
                        }
                }
         
          it = Diades::Utils::getFileExtension(string(argv[4]),extensions.begin(),extensions.end());
          string ext3(*it);
          if((ext3 == "topo") && (topologyFile.empty()))
                {
                  topologyFile = argv[4];
                }
          else
                {
                  if((ext3 == "subconf") && (subconfigurationFile.empty()))
                        {
                          subconfigurationFile = argv[4];
                        }
                  else
                        {
                          if((ext3 == "maptopo") && (topologyMapFile.empty()))
                                {
                                  topologyMapFile = argv[4];
                                }
                          else
                                {
                                  printUsage();
                                }
                        }
                }
         

          int index = 5;
          while(argc > index)
                {
                  string currentParameter = argv[index];
                  Parameter param =  NOPARAMETER;
                  if((param == NOPARAMETER) && (currentParameter == "--verbose")) { param = VERBOSE; } 
                  if((param == NOPARAMETER) && (currentParameter == "--depth")) { param = DEPTH; }
                  switch(param)
                        {
                        case VERBOSE:
                          {
                                ++index;
                                if(argc == index)
                                  {
                                        printUsage();
                                  }
                                currentParameter = argv[index];
                                if(currentParameter=="debug")
                                  {
                                        level = VbDebug;
                                  }
                                else
                                  {
                                        if(currentParameter=="on")
                                          {
                                                level = VbInfo;
                                          }
                                        else
                                          {
                                                printUsage();
                                          }
                                  }
                                break;
                          }
                        case DEPTH:
                          {
                                ++index;
                                if(argc == index)
                                  {
                                        printUsage();
                                  }
                                currentParameter = argv[index];
                                cout << "string = " << currentParameter << endl;
                                stringstream stream;
                                stream << currentParameter << endl;
                                stream >> depth;
                                cout << depth << endl;
                                break;
                          }
                        default:
                          {
                                printUsage();
                          }
                          break;
                        }
                  ++index;
                }
        }
}

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

int main(int argc, char ** argv)
{
  ofstream latexFile("check_accuracy_report.tex");
  generateLatexPreamble(latexFile);
  latexFile << "\\section{General information about the analysed model}" << endl;
  latexFile << "\\begin{itemize}" << endl;
  VerboseLevel level = VbOutput;
  setVerboseLevel(level);
  verbose<VbOutput>("Accuracy checker\n");
  verbose<VbOutput>("LAAS-CNRS, 2006-2011, 7 avenue du Colonel Roche, Toulouse, France\n");
  verbose<VbOutput>("Contact: yannick.pencole@laas.fr\n");
  vector<Diades::Automata::ObservableComponent *> components;
  try
        {

          int depth = 0;  
          string topologyFile;
          string subconfigurationFile;
          string topologyMapFile;
          Diades::Utils::Identifier component,event;
          getInterface(argc,argv,component,event,topologyFile,topologyMapFile,subconfigurationFile,depth,level);
          latexFile << "\\item Fault event to be analysed: {\\tt " << event << "} from the component {\\tt " << component << "}." << endl;        
          setVerboseLevel(level);
          Diades::Automata::Topology topology;
          Diades::Automata::TopologyMap topoMap(topology);
          topology.import(topologyFile);
          latexFile << "\\end{itemize}" << endl;
          latexFile << "\\subsection{Topology}" << endl;
          latexFile << "\\begin{itemize}" << endl;
          latexFile << "\\item Topology to analyse: " << topology.numberOfNodes() << " nodes, " << topology.numberOfConnections() << " connections." << endl;
          double numberFreeProductStates = 1.0;
          string information;
          Diades::Automata::Topology::Node root;
          Diades::Automata::Event studiedEvent = Diades::Automata::EventFactory::factory()->getEvent(component.str() + "." + event.str());
          for( Diades::Automata::Topology::NodeIterator it = topology.nodeBegin();
                   it != topology.nodeEnd();
                   ++it)
                {
                  components.push_back(new Diades::Automata::ObservableComponent());
                  if(components.back()->importDesCompModel(topology.getNodeName(*it).str() + ".des_comp"))
                        {
                          topoMap.mapComponentToNode(*components.back(),*it);
                          latexFile << "\\item Node {\\tt " << topology.getNodeName(*it).str() << "}: " << components.back()->numberOfStates() << " states, " <<  components.back()->numberOfTransitions() << " transitions." << endl;
                          numberFreeProductStates = numberFreeProductStates * components.back()->numberOfStates(); 
                          latexFile << "\\item Events of Node {\\tt " << topology.getNodeName(*it).str() << "}: ";
                          for(Diades::Automata::ObservableComponent::EventIterator eventIt= components.back()->eventBegin();
                                  eventIt != components.back()->eventEnd();
                                  ++eventIt)
                                {
                                  latexFile << "{\\tt " << eventIt->nickname() << "} ";
                                }
                          latexFile << endl;
                                
                          if(component.str() == topology.getNodeName(*it).str())
                                {
                                  if(!components.back()->containsEvent(studiedEvent))
                                        {
                                          log<LgProcess>("The event %1% does not belong to the component %2%")
                                                % studiedEvent.label()
                                                % topology.getNodeName(*it).str();
                                          log<LgProcess>("Here are the events contained in this component: %1%")
                                                % toStream(components.back()->eventBegin(), components.back()->eventEnd());
                                          throw   Diades::Utils::Failure("main");
                                        }
                                  root = *it;
                                }
                        }
                  else
                        {
                          throw Diades::Utils::Failure("main");
                        }
                }
          latexFile << "\\item Number of free product states: \\verb|" << numberFreeProductStates << "|" << endl;
          
          topoMap.importMap(topologyMapFile);

          for(Diades::Automata::Topology::ConnectionIterator connIt = topology.connectionBegin();
                  connIt != topology.connectionEnd();++connIt)
                {
                  latexFile << "\\item Connection {\\tt " << topology.getConnectionLabel(*connIt) << "} involves the events: " << endl;
                  const Diades::Automata::ConnectionMap & connMap = topoMap.getConnectionMap(*connIt);
                  for(Diades::Automata::ConnectionMap::EventIterator eventIt = connMap.eventBegin();
                          eventIt != connMap.eventEnd();
                          ++eventIt)
                        {
                          latexFile << "{\\tt " << *eventIt << "} ";
                        }
                  latexFile << endl;
                }
          
          
          Diades::Automata::SubConfiguration subconf(topology);
          ifstream file(subconfigurationFile.c_str());
          subconf.importSubConf(file);
          file.close();
          
          latexFile << "\\end{itemize}" << endl;
          latexFile << "\\subsection{Subconfiguration}" << endl;
          latexFile << "\\begin{itemize}" << endl;
          latexFile << "\\item Contains " << subconf.numberOfComponents() << " components: ";
          for(Diades::Automata::SubConfiguration::ComponentIterator compIt = subconf.componentBegin();
                  compIt != subconf.componentEnd();
                  ++compIt)
                {
                  latexFile << "{\\tt " << topology.getNodeName(*compIt).str() << "} ";

                }
          latexFile << endl;
          
          if(subconf.isMaximal())
                {
                  latexFile << "\\item This subconfiguration is maximal, that there is no relaxed connections involving two components of the subconfiguration" << endl;
                }
          else
                {
                  latexFile << "\\item This subconfiguration is not maximal, that there are some  relaxed connections involving two components of the subconfiguration." << endl;
                }
          latexFile << "\\item Contains " << subconf.numberOfEffectiveConnections() << " effective connections: ";
          for(Diades::Automata::SubConfiguration::ConnectionIterator connIt = subconf.effectiveConnectionBegin();
                  connIt != subconf.effectiveConnectionEnd();
                  ++connIt)
                {
                  latexFile << "{\\tt " << topology.getConnectionLabel(*connIt).str() << "} ";

                }

            latexFile << "\\item Contains " << subconf.numberOfRelaxedConnections() << " relaxed connections: ";
          for(Diades::Automata::SubConfiguration::ConnectionIterator connIt = subconf.relaxedConnectionBegin();
                  connIt != subconf.relaxedConnectionEnd();
                  ++connIt)
                {
                  latexFile << "{\\tt " << topology.getConnectionLabel(*connIt).str() << "} ";

                }

          
              latexFile << "\\item Contains " << subconf.numberOfExternalConnections() << " external connections: ";
          for(Diades::Automata::SubConfiguration::ConnectionIterator connIt = subconf.externalConnectionBegin();
                  connIt != subconf.externalConnectionEnd();
                  ++connIt)
                {
                  latexFile << "{\\tt " << topology.getConnectionLabel(*connIt).str() << "} ";

                }
          
          // finally let check that the root node is the correct one
          if(subconf.root() != root)
                {
                  latexFile<< "\\item The root node of the subconfiguration is not the component where the fault takes place." << endl;
                  throw Diades::Utils::Failure("main: the root node in the subconfiguration is not the correct one.");
                }
          latexFile<< "\\item The root node of the subconfiguration is {\\tt " <<  topology.getNodeName(subconf.root()).str()
                           << "} that is the component where the fault to analyse occurs." << endl;

          latexFile << "\\item If there is an accuracy problem with this subconfiguration, it is due to the following shared events: " << endl;
          latexFile << "\\begin{description}" << endl;
          for(Diades::Automata::SubConfiguration::ConnectionIterator connIt = subconf.externalConnectionBegin();
                  connIt != subconf.externalConnectionEnd();
                  ++connIt)
                { latexFile << "\\item[External event] ";
                  const Diades::Automata::ConnectionMap & connMap = topoMap.getConnectionMap(*connIt);
                  for(Diades::Automata::ConnectionMap::EventIterator eventIt = connMap.eventBegin();
                          eventIt != connMap.eventEnd();
                          ++eventIt)
                        {
                          latexFile << "{\\tt " << *eventIt << "} ";
                        }
                  latexFile << " from connection {\\tt " << topology.getConnectionLabel(*connIt).str() << "} ";
                }
          for(Diades::Automata::SubConfiguration::ConnectionIterator connIt = subconf.relaxedConnectionBegin();
                  connIt != subconf.relaxedConnectionEnd();
                  ++connIt)
                { latexFile << "\\item[Relaxed event] ";
                  const Diades::Automata::ConnectionMap & connMap = topoMap.getConnectionMap(*connIt);
                  for(Diades::Automata::ConnectionMap::EventIterator eventIt = connMap.eventBegin();
                          eventIt != connMap.eventEnd();
                          ++eventIt)
                        {
                          latexFile << "{\\tt " << *eventIt << "} ";
                        }
                  latexFile << " from connection {\\tt " << topology.getConnectionLabel(*connIt).str() << "} ";
                }
          latexFile << "\\end{description}" << endl;
          set<Diades::Automata::Event> events;
          events.insert(studiedEvent);
          bool result;
          set< set<Diades::Automata::Event> >  minimalCombinations;
          latexFile << "\\end{itemize}" << endl;
          latexFile << "\\section{Accuracy analysis}" << endl;
          latexFile << "\\begin{itemize}" << endl;
          checkSubconfigurationAccuracy(topoMap,subconf,events, information, result, minimalCombinations,depth,latexFile);
          if(result)
                {
                  verbose<VbOutput>("ACCURATE\n");
                  verbose<VbProcess>("Here are some details:\n %1% \n") % information;
                }
          else
                {
                  verbose<VbOutput>("MAY BE NOT ACCURATE\n");
                  verbose<VbInfo>("Here are some details:\n %1% \n") % information;
                  for(set< set<Diades::Automata::Event> >::const_iterator it = minimalCombinations.begin();
                          it != minimalCombinations.end(); ++it)
                        {
                          verbose<VbOutput>("%1%\n") % toStream( it->begin(), it->end());
                        }
                }
        }
  catch(exception & e)
        {
          latexFile << "\\end{itemize}" << endl;
          latexFile << "\\newpage \\huge{ALERT: failure}\\\\" << endl;
          latexFile << "Here are the logs recorded during the analysis." << endl;
          latexFile << "\\begin{verbatim}" << endl;
          log<LgProcess>("check_accuracy has failed, sorry for any inconvience: %1%")
                % e.what();
          saveLog(cerr);
          saveLog(latexFile);
          latexFile << "\\end{verbatim}" << endl;
          generateLatexEpilog(latexFile);
          latexFile.close();
          for(vector<Diades::Automata::ObservableComponent *>::size_type i = 0; i < components.size();
                  ++i)
                {
                  if(components[i]!=0)
                        {
                          delete components[i];
                        }
                }
        }
  latexFile << "\\end{itemize}" << endl;
  latexFile << "End of the accuracy analysis." << endl;
  generateLatexEpilog(latexFile);
  latexFile.close();
  return 0;
}