Description sommaire

DIESE est une bibliothèque de classes C++, orientée vers le développement de simulateurs.

Ce fonctionnement passe par une modification très localisée du moteur de simulation de BASIC DIESE : la méthode Run() de la classe Simulation.

D'une manière ou d'une autre, le programme maître doit assurer ou déléguer les tâches suivantes :

D'un point de vue pratique, le programmeur du code "maître" doit provoquer la séquence suivante d'opérations, de manière adaptée à son contexte logiciel, son application, ... et à son style de codage.

  • L'initialisation de la simulation :

    ParseParameterFile("/home/durand/.../sim1.par");
    
    pCurrentSim = new OpenSimulation();
    //----------------------------------------------------------------------------
    pCurrentSim->ClockTimeUnit(DAY);           // ou bien :
    pCurrentSim->ClockTimeUnitQuantity(1);     // ParseSimulationFile(
    pCurrentSim->SetBeginningDate(1, 9, 2009); //     "/home/durand/.../sim1.sim");
    //----------------------------------------------------------------------------
    
    //----------------------------------------------------------------------------
    ContinuousProcess pCP = new ProcessusA();      // en complément ou 
    int processInitClock = 0;                      // en remplacement de :
                                                   // ParseStructureFile( 
    pCP->PostInitialisationEvent(processInitClock);// "/home/durand/.../sim1.str");
    ...
    //----------------------------------------------------------------------------
    

    Solfege génère une version standard de cette initialisation : c'est la fonction InitOpenSimulation, argumentée avec les trois fichiers évoqués ('paramètres', 'simulation', 'structure'). On note au passage qu'on ignore les deux autres fichiers ('spécifications de sortie' et 'directives') qu'on place en entrée d'un simulateur OPEN DIESE ou CONTROL DIESE. En effet, dans un simulateur OPEN DIESE, les spécifications de sorties sont remplacées par les instances d'InterfaceDataItem, et le fichier des directives est remplacé par le contrôle opéré par le programme maître.
    Cette fonction est partiellement modifiable par le développeur pour y ajouter, notamment, des initialisations du système par processus.

    Il reste, le cas échéant, à provoquer lés dépilements d'événements qui gèrent les processus d'initialisation, par :

    //----------------------------------------------------------------------------
    int iterationCounter = 0;
    int pauseClock = processInitClock +1; // hypothèse : un unique ProcessusA
    StructTmToStringISO(ClockValueToTm(pauseClock));
    ((OpenSimulation*)pCurrentSim)->RunOpenSimulationToDate(iterationCounter, 
    														gTimeString);
    //----------------------------------------------------------------------------
    

  • La gestion de la simulation et la communication avec le simulateur :

    //
    // Definition de l'interface d'entrée
    //
    pEntityTab* IN_tab = new pEntityTab();
    Entity* pIN_1 = new InterfaceDataItem();
    pIN_1->SetIntConstValue(TYPE_ATTRIBUTE, FLOAT);
    pIN_1->SetStringConstValue(ENTITY_NAME_ATTRIBUTE, "parcelle_1");
    pIN_1->SetIntConstValue(DESCRIPTOR_ID_ATTRIBUTE, QUANTITE_EAU);
    IN_tab->push_back(pIN_1);
    //
    // Definition de l'interface de sortie
    //
    pEntityTab* OUT_tab = new pEntityTab();
    Entity* pOUT_1 = new InterfaceDataItem();
    pOUT_1->SetIntConstValue(TYPE_ATTRIBUTE, FLOAT);
    pOUT_1->SetStringConstValue(ENTITY_NAME_ATTRIBUTE, "culture_1");
    pOUT_1->SetIntConstValue(DESCRIPTOR_ID_ATTRIBUTE, QUANTITE_MS);
    OUT_tab->push_back(pOUT_1);
    //
    // Le contrôle de la simulation
    //
    Boolean simulationIsOver = FALSE;
    for(int j=0;j<100 && !simulationIsOver;j=j+10) {
      //
      // valeurs datées transmises au simulateur   (par défaut : date de l'appel)
      //
      float quantiteEau_j = <...>; // à la discrétion du programme maître
      pIN_1->SetInterfaceValue(quantiteEau_j); // valeur transmise au simulateur
      //
      // dates pour les valeurs reçues             (par défaut : date de retour)
      //
      // date prochaine pause
      //
      char* nextPause = <...>; // date ISO 8601 à la discrétion du programme maître
    
      simulationIsOver = pCurrentSim->RunOpenSimulationToDate(iterationCounter, 
                                                              IN_tab,
                                                              nextPause,
                                                              OUT_tab);
      float quantiteMS_j 
          = pOUT_1->GetFloatInterfaceValue();  // valeur émise par le simulateur
      // utilisation de quantiteMS_j à la discrétion du programme maître 
    }
    

    A un endroit ou à un autre, ce type de code doit figurer, globalement dans cet ordre, dans le programme maître, lequel peut accéder à toutes les références DIESE (fonctions, méthodes, classes, ...) dans la bibliothèque attachée lors de l'édition de liens.

  • Cas particulier : un simulateur OPEN DIESE autonome

    Un simulateur développé avec OPEN DIESE peut être exploité de manière autonome, c'est-à-dire hors du contrôle d'un programme maître. C'est notamment le cas en phase de développement et, conjointement, de test de ses propres fonctionnalités de simulation.

    Le code doit alors avoir la forme, non seulement d'une bibliothèque, mais aussi d'un exécutable. On sait que son point d'entrée est alors la fonction main, laquelle doit donc être écrite.

    Solfege génère une version standard de cette fonction, identique à celle générée sous BASIC DIESE et CONTROL DIESE. Elle peut être modifiée par le développeur, pour des besoins spécifiques, mais ce n'est généralement pas nécessaire. Cette version invoque, non pas la fonction InitOpenSimulation, mais la fonction InitSimulation. Elle enchaîne la lecture et l'interprétation des cinq fichiers de la liste standard en entrée.


This page was generated with the help of DOC++.