Utiliser le .

dll de back-end Simio

Aperçu
Avec la sortie de Simio Sprint 45, le moteur d'exécution Simio peut être accessible par programme.
sans exécuter l'interface graphique Simio (interface utilisateur graphique). Une bibliothèque .NET est fournie ([Link])
qui peut être référencé directement par 3rdlogiciel tiers. Notez que cet assemblage est conçu pour être architecturé -
neutre ; si l'exécutable appelé est en 32 bits, alors l'assemblage sera chargé en tant qu'assemblage 32 bits, et si le
calling .exe is 64-bit, then the assembly will be loaded as 64-bit.

Chargement d'un projet

SimioProjectFactory est utilisé pour charger un fichier de projet Simio en mémoire. SimioProjectFactory est statique.
class in the [Link] assembly. It exposes the LoadProject method that takes a string containing the
chemin vers le fichier à charger, et renvoie une référence au ISimioProject résultant. En utilisant le ISimioProject
interface, vous pouvez ensuite manipuler le projet chargé de diverses manières. Notez que les interfaces API et
Les classes disponibles sous ISimioProject sont les mêmes que celles accessibles aux rédacteurs d'extensions (c'est-à-dire celles
création d'étapes écrites par l'utilisateur, d'éléments, de règles, et de modules complémentaires de conception et d'expérimentation.

Collections
L'API de Simio définit de nombreuses interfaces, dont plusieurs sont des collections d'autres interfaces. Par exemple,
ISimioProject a une propriété Models, de type IModels, qui est une collection d'interfaces IModel, chacune
un correspondant à un modèle dans le projet. De même, l'interface IProperties est une collection de
Interfaces IProperty. En général, une interface ISomethingsinterface (pluriel) est une collection d'interfaces ISomething.
(singulier). Toutes les collections Simio exposent une propriété entière Count, retournant le nombre de membres dans
la collection, et toutes les collections peuvent être indexées par une valeur d'indice entier basée sur zéro. L'indexation par entier
il retourne lesthISomethingin the ISomethingscollection, or throws an IndexOutOfRange exception ifiis
en dehors de la plage des valeurs d'index valides. De plus, si la collection contient des membres nommés, alors le
la collection peut également être « indexée » en utilisant une chaîne contenant le nom du membre souhaité. Indexation
ISomethingsby strings retourne l'ISomething avec des noms, si un existe, ou retourne null si un ISomething
avec le nom spécifié n'est pas présent dans la collection. Enfin, les collections de l'API Simio prennent en charge
énumération (utilisant foreach de C# ou For Each de [Link]), offrant un moyen pratique de
manipuler tous les membres d'une collection.

IModel
ISimioProject expose des Modèles, qui est une collection IModels de références IModel. Cet IModels
la collection, comme la plupart des autres collections dans l'API Simio, peut être indexée par un entier ou une chaîne, ou
énumérotés à l'aide de foreach. L'indexation et l'énumération retournent tous deux des membres IModel.

L'interface IModel fournit actuellement un accès programmatique à certains objets de premier niveau dans le modèle.
Cela inclut les propriétés, états et événements définis sur le modèle, ainsi que la structure du modèle.
qui contient les objets de structure qui composent la logique du modèle.
IModel also exposes properties for accessing the tables, function tables, and rate tables defined on the
modèle.

[Link] est une collection d'ITable, qui vous permet de définir des valeurs dans les données de table du modèle. Utilisez le

La collection [Link] pour déterminer le schéma de données de la table, en indexant par entier ou chaîne pour renvoyer
Membres d'ITableColumn. Indexez la collection [Link] pour accéder aux lignes du tableau, puis
indexer chaque IRow par entier ou [Link] pour obtenir ou définir la valeur en chaîne d'un seul élément de données
dans le tableau (actuellement, toutes les valeurs du tableau sont exposées en tant que chaînes dans l'API et interprétées en interne

selon le type de données de la colonne.

Objets d'installation
[Link] expose des IntelligentObjects, qui sont une collection IIntelligentObjects d'IIntelligentObject,
et fournit un accès aux instances d'objets de niveau supérieur dans le modèle. Chacune de ces instances d'objets
expose son ObjectName et sa collection de Propriétés (de type IProperties), qui peut être indexée par
entier ou chaîne pour obtenir ou définir les valeurs des propriétés Simio pour l'instance de l'objet. Par exemple,
en utilisant IIntelligentObject et sa collection de propriétés IProperty, vous pouvez définir le "Temps de traitement"
propriété d'une instance d'objet « Serveur ».

IExperiment
IModel expose des Expériences, une collection IExperiments de références IExperiment représentant le
des expériences définies sur ce modèle. IExperiments est également indexé par un entier ou une chaîne, ou peut être
énumérés à l'aide de foreach, tous retournent des membres de type IExperiment.

L'interface IExperiment est utilisée pour manipuler et exécuter des expériences sur le modèle. Utilisez
[Link] pour obtenir ou définir l'heure de début, l'heure de fin et la période de préchauffage à utiliser pour
l'expérience. Utilisez les propriétés Contrôles, Réponses et Contraintes de IExperiment pour renvoyer
Interfaces IExperimentControl, IExperimentResponse et IExperimentConstraint, respectivement. Ces
fournir l'accès à la partie définitionnelle des contrôles, des réponses et des contraintes.

Utilisez les interfaces IExperimentControls et IExperimentControl pour déterminer les noms et les types
(entier ou réel) des contrôles définis sur l'expérience. Utilisez les IExperimentResponses et
Les interfaces IExperimentResponse pour spécifier les différents paramètres de chaque réponse définie sur le
expérience. Par exemple, vous pouvez obtenir ou définir l'expression utilisée pour évaluer la réponse, ainsi que
les limites supérieures et/ou inférieures acceptables facultatives pour la réponse.

[Link] est une collection d'IScenario, représentant les différents scénarios définis sur le
expérience. Cette collection peut être modifiée via l'API en utilisant Clear pour supprimer tout IScenario existant.
entrées, et CreateScenario pour renvoyer une référence à un nouveau scénario.

L'interface IScenario est utilisée pour manipuler un seul scénario (c'est-à-dire une seule ligne dans une expérience dans le
Application de bureau Simio). Utilisez ReplicationsRequired pour indiquer combien de répliques de ce scénario
doit être exécuté. Utilisez SetControlValue pour fournir la valeur pour chaque contrôle spécifié par l'expérience. Appelez ceci
méthode avec une interface IExperimentControl (fournie par la collection de contrôles de l'expérience) et le
valeur souhaitée pour le contrôle. Après avoir exécuté l'expérience, utilisez GetResponseValue pour récupérer le
valeur moyenne de chaque réponse sur toutes les réplications, ou utiliser GetResponseValueForReplication pour
récupérer la valeur d'une réponse pour une réplication spécifique. Ces deux méthodes prennent en entrée un
Interface IExperimentResponse (fournie par la collection des réponses de l'expérience) pour indiquer lequel
la valeur de réponse est demandée.

Réaliser une expérience

L'interface IExperiment fournit des méthodes pour exécuter l'expérience, ainsi que des événements auxquels s'abonner.
pour surveiller l'état de l'exécution. Si le programme appelant est une application interactive, utilisez le
Méthode RunAsync pour exécuter une expérience sur un thread de fond. Cette méthode retourne à l'appelant
when the experimentstartsrunning, allowing the caller to remain responsive to the interactive user.
Alternativement, la méthode Run peut être appelée, mais c'est un appel synchrone (bloquant), qui ne
retourner à l'appelant jusqu'à ce que l'expérience soit terminée. C'est souvent un choix approprié pour les non-interactifs
utilisations.

Lors d'une exécution interactive, vous pouvez appeler [Link] pour annuler l'expérience en cours.
Entre les exécutions, appelez [Link] pour supprimer les résultats existants produits par une exécution précédente.
[Link] renvoie true si l'expérience est actuellement en cours d'exécution.

Il existe plusieurs événements définis sur IExperiment qui peuvent être utilisés pour suivre l'avancement de la
expérience lancée, et pour récupérer les statistiques à la fin de l'exécution. RunStarted est déclenché une fois après le
l'exécution de l'expérimentation est initialisée mais avant que l'exécution réelle ne commence. ScenarioStarted est appelé à chaque

scenario is about to begin running its replications. ReplicationStarted is raised once for each replication
alors qu'il est sur le point de commencer à courir.

De la même manière, ReplicationEnded est déclenché pour indiquer qu'une seule réplication est terminée, ou a
terminé avec une condition d'erreur. Les ReplicationEndedEventArgs peuvent être examinés pour déterminer
quelle réplication de quel scénario vient de se terminer, ainsi que tout texte d'erreur. ScenarioEnded est déclenché lorsque
toutes les répliques pour un scénario donné ont terminé de s'exécuter. Les ScenarioEndedEventArgs fournissent le
les résultats statistiques définis par le modèle collectés pendant l'exécution. Sa propriété IScenarioResults est une collection de
IScenarioResult éléments, chacun fournissant la valeur d'une seule statistique collectée pendant l'exécution. Ces
les statistiques sont les mêmes valeurs présentées dans le tableau croisé dynamique des Résultats d'Expérience de l'application de bureau Simio

table. Enfin, l'événement ExperimentCompleted est déclenché à la fin de l'exécution.

Extraits de code

utiliserSimioAPI;

namespaceUsageSamples
{
classe publiqueSnippetClass1
{
//
// Charger un fichier de projet Simio
//
voidLoadSimioProject()
{
stringfileName ="[Link]";

ISimioProjectprojet;
essayer
{
projet =[Link](nomDuFichier);
}

attraper(Exceptionex)
{
[Link](this, [Link],"Load failure");
}
}

//
// Exemples de définition de diverses valeurs dans un modèle.
//
voidMettreÀJourCertainsValeurs(IModelmodel)
{
Récupérer une instance spécifique de Serveur par nom.
IIntelligentObjectmonServeur = modè[Link]["MonServeur"];
Récupérer une propriété spécifique de ce serveur par son nom.
IPropertymyServerProcessingTime = [Link]["ProcessingTime"];
// Définir la valeur de la propriété. Toutes les valeurs de propriété sont passées en tant que chaînes.

[Link] ="12.34";
// Définir l'unité. Puisque nous savons que ProcessingTime est un temps,
// nous pouvons convertir l'Unité directement en ITimeUnit et définir la valeur.
([Link]).Time =[Link];

// Une manière pédante de définir le premier taux du tableau des premiers taux du modèle.
IRateTablerateTable = modè[Link][0];
IRateTableIntervalinterval = [Link][0];
[Link] = 5.5;
// Et une manière plus concise de le faire.
[Link][0].Intervals[0].Rate = 5.5;

// Définir une valeur de données dans une ligne d'une table.

stringtableName ="MyTable";
stringpropName ="MyProperty";
introwIndex = 4;
stringnewVal ="111.111";
[Link][tableName].Rows[rowIndex].Properties[propName].Value = newVal;
}
 //
// Récupérer les noms de toutes les tables et les propriétés des tables dans ce modèle.
//
voidTableExample(IModelmodel)
{
pour chaque(ITable table dans [Link])
{
// Faites quelque chose avec le nom de la table
stringstring1 = [Link];
// ...

// Faites quelque chose avec chaque nom de colonne

pour chaque (ITableColumn column dans [Link])
{
stringstring2 = [Link] +" ("+ [Link] +")";
// ...
}
}
}
}

public classSnippetClass2
{
//
Exécuter une expérience de manière asynchrone. C'est un modèle typique
// pour exécuter des expériences Simio dans une application interactive.
//
public void commencerExperiment(IExperiment experiment)
{
si([Link])
retourner;// Ça fonctionne déjà !

// Effacer toutes les données de réplication existantes.

experiment.Réinitialiser();

// Spécifiez les temps d'exécution.

IRunSetupsetup = expé[Link];
[Link] =newDateTime(2010, 10, 01);
[Link] =[Link](8.0);
[Link] = [Link] +[Link](100.0);

// Disons que nous nécessitons au moins 5 répliques pour chaque scénario.

foreach([Link])
si([Link] < 5)
[Link] = 5;

// Prêt à fonctionner. Connectez-vous aux différents événements d'exécution.

// Dans cet extrait, nous ne nous soucions que de ScenarioEnded et
// Exécution terminée, mais nous pourrions également nous abonner à d'autres événements.

[Link] += experiment_ScenarioEnded;
[Link] += experiment_RunCompleted;

// Maintenant, commencez l'exécution. RunAsync nous retournera après le

// l'expérience est initialisée et est sur le point de commencer à s'exécuter.
[Link]écuterAsync();
}

voidexperiment_ScenarioEnded(object sender, ScenarioEndedEventArgs e)

 {
// Ce gestionnaire d'événements sera appelé lorsque toutes les réplications pour une
// scénario donné est terminé. À ce stade, les statistiques
// produit par ce scénario devrait être disponible.
IExperimentexperiment = senderasIExperiment;

// Faites quelque chose avec les statistiques produites par les divers
// constructions de modélisation (c'est-à-dire Sources, Serveurs, Éviers, etc.)
foreach(IScenarioResult result in Results)
{
// Chaque résultat contient le nom, la catégorie, la valeur moyenne,
// valeur min et max, demi-largeur et écart type
// dans toutes les répétitions qui ont été effectuées pour ce scénario.

// C'est ici que vous enregistreriez ces observations.

// ...
}

// Récupérer également les valeurs moyennes de ce scénario pour toutes les réponses
// défini sur l'expérience.
pour chaque(IExperimentResponseresponseinexperiment.Réponses)
{
doubleresponseValue = 0.0;
si([Link](response,refresponseValue))
{
Nous avons obtenu une valeur valide pour cette réponse.
// Faites quelque chose avec ça ici.
// ...
}
sinon
{
// N'a pas obtenu de valeur.
}
}

}
voidexperiment_RunCompleted(object sender, RunCompletedEventArgs e)
{
// Ce gestionnaire d'événements est le dernier à être appelé lors de l'exécution.
Lors de l'exécution asynchrone, c'est le bon endroit pour arrêter les choses.
IExperimentexperiment = senderasIExperiment;

// Déconnectez-vous des événements d'exécution quand nous avons terminé.

[Link] -= experiment_ScenarioEnded;
[Link] -= experiment_RunCompleted;
}
}
}