GlobalModel.cc

Go to the documentation of this file.

#include<iostream>
#include<fstream>
#include<list>
#include<string>
#include<set>

#include <boost/date_time/posix_time/posix_time.hpp>
#include<diades/utils/Exceptions.hh>
#include<diades/automata/Event.hh>
#include<diades/automata/ObservableComponent.hh>
#include<diades/automata/ClassicalDiagnoser.hh>
#include<diades/automata/SyncRulesLoad.hh>
#include"FaultDiagnosis.hh"

using namespace std;
using namespace Diades::Automata;
using namespace Diades::Utils;

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


void printUsage();
void readParameters(int argc, char * argv[],
        list<string> & modelFiles);
string getSuffix(const string & name);
void synchroniseModels(vector<const ObservableComponent *> & components,
        const ParametrizedSynchronisation & rules);

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

int main(int argc, char * argv[]) {
    list<string> modelFiles;
    readParameters(argc, argv, modelFiles);
    map<string,const ObservableComponent *> sortedComponents;
    vector<const ObservableComponent *> components;
    
    
    
    
    ParametrizedSynchronisation::ComponentVector vectorComp;
    unsigned nbModel = modelFiles.size() - 1;
    try {
        while (nbModel != 0) {
            ObservableComponent * component = new ObservableComponent();
            if (component->importDesCompModel(modelFiles.front())) {
                sortedComponents[component->name()] = component;
                modelFiles.pop_front();
                --nbModel;
            } else {
                throw (Failure("dd-global-model"));
            }
        }
        for(auto & pair : sortedComponents)
        {
            components.push_back(pair.second);
            vectorComp.push_back(pair.second);
        } 
        ParametrizedSynchronisation rules;
        if(!loadSynchronisationRules(vectorComp, modelFiles.front(), rules))
        {
            throw (Failure("dd-global-model"));
        }
        modelFiles.pop_front();

        cout << "Start synchronising..." << flush;
        synchroniseModels(components, rules);
        cout << "done" << endl;


        for (vector<const ObservableComponent *>::size_type i = 0;
                i != components.size();
                ++i) {
            if (components[i] != nullptr) {
                delete components[i];
                components[i] = nullptr;
            }
        }
    } catch (exception & e) {
        Diades::Utils::log< Diades::Utils::LgProcess>("global_model has failed, sorry for any inconvience: %1%")
                % e.what();
        saveLog(cerr);
        for (vector<const ObservableComponent *>::size_type i = 0;
                i != components.size();
                ++i) {
            if (components[i] != nullptr) {
                delete components[i];
                components[i] = nullptr;
            }
        }
    }
    Diades::Automata::Event::destroyEvents();
    Diades::Utils::LoggerFactory::destroy();
    return 0;
}

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

void printUsage() {

    cout << "Usage: global_model file1.des_comp file2.des_comp [file3.des_comp ...] sync.rules" << endl;
    cout << "   Compute the model file1||file2||..." << endl;
}

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

void readParameters(int argc, char * argv[],
        list<string> & modelFiles) {
    if (argc < 3) {
        printUsage();
        exit(1);
    }

    setVerboseLevel(VbProcess);
    string param = argv[1];
    int index = 1;
    int nbModel = 0;
    while (index < argc) {
        param = argv[index];
        string suffix = getSuffix(string(argv[index]));
        if (suffix == "des_comp") {
            ++nbModel;
            modelFiles.push_back(string(argv[index]));
            ++index;
        } else {
            if (suffix == "rules") {
                modelFiles.push_back(string(argv[index]));
                ++index;
                if (index < argc) {
                    printUsage();
                    exit(1);
                }
            }
        }
    }
}

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

string getSuffix(const string & name) {
    string::size_type idx = name.rfind('.');
    if (idx == string::npos) {
        return "";
    }
    return name.substr(idx + 1);
}

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

void synchroniseModels(vector<const ObservableComponent *> & components,
        const ParametrizedSynchronisation & rules) {
    vector<ComposableModel::ConstPointer> composableModels;
    for (vector<const ObservableComponent *>::size_type i = 0;
            i != components.size();
            ++i) {
        composableModels.push_back(new ComposableModel(*components[i], rules));
    }
    ObservableComponent result;
    ComposableModel synchronisation(composableModels, rules, false, &result);
    //ComposableModel * globalModel = new ComposableModel(composableModels,rules,false);
    //globalModel->component().exportDesCompModel(globalModel->component().name() + ".des_comp");
    //delete globalModel;

    ObservableMask synchronisedMask(rules,components);
//    for (auto it = rules.beginOfSynchronisedEvents();
//            it != rules.endOfSynchronisedEvents();
//            ++it) {
//        vector<Event> supportObservableEvents;
//        vector<string> supportCompNames;
//        vector<const ObservableMask *> supportMasks;
//        vector<ObservableMask::ObservableEventIterator> positions;
//        for (auto compIt = it->beginOfComponents();
//                compIt != it->endOfComponents();
//                ++compIt) {
//            SynchronisationEvent::ComponentIterator supportIt =
//                    it->findSupportComponent(*compIt);
//            if (supportIt != it->endOfSupport()) {
//                const ObservableMask * mask = masks[supportIt->name()];
//                if (mask->observableBegin(supportIt.getAssociatedEvent())
//                        != mask->observableEnd(supportIt.getAssociatedEvent())) {
//                    supportCompNames.push_back(supportIt->name());
//                    supportObservableEvents.push_back(supportIt.getAssociatedEvent());
//                    supportMasks.push_back(mask);
//                    positions.push_back(supportMasks.back()->observableBegin(supportObservableEvents.back()));
//                }
//            }
//        }
//        if (positions.empty()) {
//            // it->synchronisedEvent() is not observable
//            synchronisedMask.makeUnobservable(it->synchronisedEvent());
//        } else {
//            while (positions[0] != supportMasks[0]->observableEnd(supportObservableEvents[0])) {
//                Event::Label label;
//                string comps;
//                string names;
//                for (size_t i = 0; i < supportMasks.size(); ++i) {
//                    if (*(positions[i]) != supportMasks[i]->noEvent()) {
//                        if (comps.empty()) {
//                            comps = supportCompNames[i];
//                            names = supportObservableEvents[i].nickname();
//                        } else {
//                            comps = comps + "_" + supportCompNames[i];
//                            names = names + "_" +
//                                    supportObservableEvents[i].nickname();
//                        }
//
//                    }
//
//                }
//                if (!comps.empty()) {
//                    Event synchronisedObservableEvent =
//                            EventFactory::factory()->getEvent(comps + "." + names);
//                    synchronisedObservableEvent.setNickname(names);
//                    synchronisedMask.addMask(it->synchronisedEvent(),
//                            synchronisedObservableEvent);
//                } else {
//                    synchronisedMask.addMask(it->synchronisedEvent(), synchronisedMask.noEvent());
//                }
//                size_t index = positions.size() - 1;
//                ++positions[index];
//                while ((index > 0) &&
//                        (positions[index] == supportMasks[index]->observableEnd(supportObservableEvents[index]))) {
//                    positions[index] == supportMasks[index]->observableBegin(supportObservableEvents[index]);
//                    --index;
//                    ++positions[index];
//                }
//
//            }
//        }
//
//
//
//
//
//    }
    result.setMask(synchronisedMask);
    result.exportDesCompModel(result.name() + ".des_comp");
    for (vector<const ObservableComponent *>::size_type i = 0;
            i != components.size();
            ++i) {
        delete composableModels[i];
    }
}


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