Lancement direct d'une exécution

Table des matières

• Mode Sous-domaine Autonome

Il est possible d'utiliser Arcane sans passer par les mécanismes utilisant les modules et la boucle en temps. Cela peut être utile pour des codes très simples ou des utilitaires mais ce mécanisme est déconseillé pour les gros codes de calcul car il ne permet pas d'accéder automatiquement à l'ensemble des fonctionnalités de Arcane comme par exemple l'équilibrage de charge, les protections/reprises ou les modules (même si ces mécanismes restent accessibles manuellement).

Il existe deux manière de lancer le mode autonome:

• le mode avec support des accélérateurs. Dans ce mode seule l'API accélérateur et les classes utilitaires de Arcane sont disponibles. La page Mode Autonome accélérateur décrit comment utiliser ce mode.
• le mode avec sous-domaine. Ce mode permet d'accéder manuellement à la plupart des fonctionnalités d'Arcane comme le maillage, le dépouillement ou l'équilibrage de charge.

Les deux exemples standalone_subdomain et standalone_accelerator montrent comment utiliser ces mécanismes.

La page Lancement d'un calcul explique comment fournir les paramètres pour initialiser Arcane.

Mode Sous-domaine Autonome

Ce mode permet de piloter manuellement la plupart des fonctionnalités d'Arcane comme les maillages et le dépouillement. Pour utiliser ce mode, il suffit d'utiliser la méthode de classe ArcaneLauncher::createStandaloneSubDomain() après avoir initialiser Arcane :

Arcane::String case_file_name = {};
Arcane::ArcaneLauncher::init(Arcane::CommandLineArguments(&argc, &argv));
Arcane::StandaloneSubDomain sub_domain(Arcane::ArcaneLauncher::createStandaloneSubDomain(case_file_name));

Il est possible de spécifier un nom de fichier pour le jeu de données. Dans ce cas, si ce fichier comporte des maillages, ces derniers seront automatiquement créés lors de la création du sous-domaine.

L'instance sub_domain doit rester valide tant qu'on souhaite utiliser le sous-domaine. Il est donc préférable de la définir dans le main() du code.

Avertissement

Un seul appel à ArcaneLauncher::createStandaloneSubDomain est autorisé.

Par exemple, le code suivant permet de lire un maillage, d'afficher le nombre de mailles, de calculer et d'afficher les coordonnées des centres des mailles.

 
#include "arcane/launcher/ArcaneLauncher.h"
 
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/Real3.h"
 
#include "arcane/core/MeshReaderMng.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/VariableTypes.h"
 
#include "arcane/utils/Exception.h"
 
#include <iostream>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
using namespace Arcane;
 
void executeSample(const String& case_file)
{
 
  // Create a standalone subdomain
  // Arcane will automatically call finalization when the variable
  // goes out of scope.
  Arcane::StandaloneSubDomain launcher{ ArcaneLauncher::createStandaloneSubDomain(case_file) };
  Arcane::ISubDomain* sd = launcher.subDomain();
 
  // Get the trace class to display messages
  Arcane::ITraceMng* tm = launcher.traceMng();
 
  // Create an instance of the Mesh Reader.
  Arcane::MeshReaderMng mrm(sd);
 
  // Create a mesh named 'Mesh1' from the file 'plancher.msh'.
  // The format is automatically choosen from the extension
  Arcane::IMesh* mesh = mrm.readMesh("AdditionalMesh", "plancher.msh", sd->parallelMng());
 
  Int32 nb_cell = mesh->nbCell();
  tm->info() << "NB_CELL=" << nb_cell;
 
  // Loop over the cells and compute the center of each cell
  Arcane::VariableNodeReal3& nodes_coordinates = mesh->nodesCoordinates();
  ENUMERATE_ (Cell, icell, mesh->allCells()) {
    Arcane::Cell cell = *icell;
    Arcane::Real3 cell_center;
    // Iteration over nodes of the cell
    for (Node node : cell.nodes()) {
      cell_center += nodes_coordinates[node];
    }
    cell_center /= cell.nbNode();
    tm->info() << "Cell=" << cell.uniqueId() << " center=" << cell_center;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int main(int argc, char* argv[])
{
  String case_file;
 
  auto func = [&] {
    std::cout << "Sample: StandaloneSubDomain\n";
    // Initialize Arcane
    Arcane::CommandLineArguments cmd_line_args(&argc, &argv);
    Arcane::ArcaneLauncher::init(cmd_line_args);
    if (argc > 1)
      case_file = argv[argc - 1];
    executeSample(case_file);
  };
 
  return arcaneCallFunctionAndCatchException(func);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 

---

Lancement d'un calcul Variables d'environnement