Arcane  v3.16.6.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ArcanePostProcessing_axl.h
1/*---------------------------------------------------------------------------*/
2/*---------------------------------------------------------------------------*/
3// #WARNING#: This file has been generated automatically. Do not edit.
4// Axlstar version 1.0
5/*---------------------------------------------------------------------------*/
6/*---------------------------------------------------------------------------*/
7
8#ifndef ARCANE_CASEOPTION_AXLSTAR_ARCANEPOSTPROCESSING_H
9#define ARCANE_CASEOPTION_AXLSTAR_ARCANEPOSTPROCESSING_H
10
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/String.h"
15
16#include "arcane/CaseOptions.h"
17#include "arcane/CaseOptionsMulti.h"
18#include "arcane/CaseOptionBuildInfo.h"
19#include "arcane/XmlNodeList.h"
20#include "arcane/ItemGroup.h"
21#include "arcane/CaseOptionService.h"
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26ARCANE_BEGIN_NAMESPACE
27extern "C++" bool
28_caseOptionConvert(const Arcane::CaseOptionBase&,
29 const Arcane::String&,
31ARCANE_END_NAMESPACE
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
37class CaseOptionsArcanePostProcessing
38{
39public:
40
41 /*-------------------------------------------------------------------------*/
42 /*--------------------------- Complex Options -----------------------------*/
43 /*-------------------------------------------------------------------------*/
44 // Generation for option 'output'
45 // Generating simple arity CaseOption for option 'output'
46 class CaseOptionOutput
47 : public Arcane::CaseOptions
48 {
49 public:
50
51 CaseOptionOutput(Arcane::ICaseOptionList* icl,
52 const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
53 : Arcane::CaseOptions(icl,s,element,is_optional)
54 , variable(Arcane::CaseOptionBuildInfo(_configList(),
55 /* name */ "variable", _element(),
56 /* default */ Arcane::String(),
57 /* min-occurs */ 0,
58 /* max-occurs */ -1,
59 /* optional */ false))
60 , group(Arcane::CaseOptionBuildInfo(_configList(),
61 /* name */ "group", _element(),
62 /* default */ Arcane::String(),
63 /* min-occurs */ 0,
64 /* max-occurs */ -1,
65 /* optional */ false),
66 /* type */ "Arcane::ItemGroup")
67 {
68
70 /* language */ Arcane::String("fr"),
71 /* alternative name */ Arcane::String("variable"));
72group.addAlternativeNodeName(
73 /* language */ Arcane::String("fr"),
74 /* alternative name */ Arcane::String("groupe"));
76 /* language */ Arcane::String("fr"),
77 /* alternative name */ Arcane::String("depouillement"));
78 }
79
80 const CaseOptionOutput& operator()() const { return *this; }
81
82 public:
83 // Interfaces for simple arity CaseOptions
84
85 Arcane::ConstArrayView< Arcane::String > getVariable() { return variable.values(); }
86
87 Arcane::ConstArrayView< Arcane::ItemGroup > getGroup() { return group; }
88
89
90 // Interfaces for complex options
91
92
93 private:
94 // Méthodes pour unifier la construction des options.
95 Arcane::ICaseOptionList* _configList() { return configList(); }
96 Arcane::XmlNode _element() { return Arcane::XmlNode(); }
97
98 public:
99
102
103 };
104 // Generation for option 'experimental-python-plugin'
105 // Generating simple arity CaseOption for option 'experimental-python-plugin'
106 class CaseOptionExperimentalPythonPlugin
107 : public Arcane::CaseOptions
108 {
109 public:
110
111 CaseOptionExperimentalPythonPlugin(Arcane::ICaseOptionList* icl,
112 const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
113 : Arcane::CaseOptions(icl,s,element,is_optional)
114 , functionName(Arcane::CaseOptionBuildInfo(_configList(),
115 /* name */ "function-name", _element(),
116 /* default */ Arcane::String(),
117 /* min-occurs */ 1,
118 /* max-occurs */ 1,
119 /* optional */ false))
120 , externalPlugin(Arcane::CaseOptionBuildInfo(_configList(),
121 /* name */ "external-plugin", _element(),
122 /* default */ "BasicDotNetPythonExternalPlugin",
123 /* min-occurs */ 1,
124 /* max-occurs */ 1,
125 /* optional */ false),
126 /* allow-null */ true,
127 /* optional */ false)
128 {
129
130 }
131
132 const CaseOptionExperimentalPythonPlugin& operator()() const { return *this; }
133
134 public:
135 // Interfaces for simple arity CaseOptions
136
137 Arcane::String getFunctionName() { return functionName(); }
138 Arcane::ICaseFunction* getFunctionNameFunction() { return functionName.function(); }
139 Arcane::IStandardFunction* getFunctionNameStandardFunction() { return functionName.standardFunction(); }
140
141
142
143 Arcane::IExternalPlugin* getExternalPlugin() { return externalPlugin(); }
144 // Interfaces for complex options
145
146
147 private:
148 // Méthodes pour unifier la construction des options.
149 Arcane::ICaseOptionList* _configList() { return configList(); }
150 Arcane::XmlNode _element() { return Arcane::XmlNode(); }
151
152 public:
153
154 Arcane::CaseOptionString functionName;
156
157 };
158
159 /*-------------------------------------------------------------------------*/
160 /*--------------------------- Non Complex Options -------------------------*/
161 /*-------------------------------------------------------------------------*/
162
163 CaseOptionsArcanePostProcessing(Arcane::ICaseMng* cm)
164 : m_case_options(new Arcane::CaseOptions(cm,"arcane-post-processing"))
165 , outputFrequency(Arcane::CaseOptionBuildInfo(_configList(),
166 /* name */ "output-frequency", _element(),
167 /* default */ "0.0",
168 /* min-occurs */ 1,
169 /* max-occurs */ 1,
170 /* optional */ false))
171 , outputPeriod(Arcane::CaseOptionBuildInfo(_configList(),
172 /* name */ "output-period", _element(),
173 /* default */ "0",
174 /* min-occurs */ 1,
175 /* max-occurs */ 1,
176 /* optional */ false))
177 , outputHistoryPeriod(Arcane::CaseOptionBuildInfo(_configList(),
178 /* name */ "output-history-period", _element(),
179 /* default */ "1",
180 /* min-occurs */ 1,
181 /* max-occurs */ 1,
182 /* optional */ false))
183 , outputHistoryShrink(Arcane::CaseOptionBuildInfo(_configList(),
184 /* name */ "output-history-shrink", _element(),
185 /* default */ "false",
186 /* min-occurs */ 1,
187 /* max-occurs */ 1,
188 /* optional */ false))
189 , saveInit(Arcane::CaseOptionBuildInfo(_configList(),
190 /* name */ "save-init", _element(),
191 /* default */ "false",
192 /* min-occurs */ 1,
193 /* max-occurs */ 1,
194 /* optional */ false))
195 , saveFinalTime(Arcane::CaseOptionBuildInfo(_configList(),
196 /* name */ "save-final-time", _element(),
197 /* default */ "true",
198 /* min-occurs */ 1,
199 /* max-occurs */ 1,
200 /* optional */ false))
201 , endExecutionOutput(Arcane::CaseOptionBuildInfo(_configList(),
202 /* name */ "end-execution-output", _element(),
203 /* default */ "false",
204 /* min-occurs */ 1,
205 /* max-occurs */ 1,
206 /* optional */ false))
207 , format(Arcane::CaseOptionBuildInfo(_configList(),
208 /* name */ "format", _element(),
209 /* default */ "Ensight7PostProcessor",
210 /* min-occurs */ 1,
211 /* max-occurs */ 1,
212 /* optional */ false),
213 /* allow-null */ false,
214 /* optional */ false)
215 , output(_configList(),
216 /* name */ "output", _element())
217 , experimentalPythonPlugin(_configList(),
218 /* name */ "experimental-python-plugin", _element(),
219 /* optional */ true)
220 {
221
222format.addAlternativeNodeName(
223 /* language */ Arcane::String("fr"),
224 /* alternative name */ Arcane::String("format-service"));
225outputFrequency.addAlternativeNodeName(
226 /* language */ Arcane::String("fr"),
227 /* alternative name */ Arcane::String("frequence-sortie"));
228outputPeriod.addAlternativeNodeName(
229 /* language */ Arcane::String("fr"),
230 /* alternative name */ Arcane::String("periode-sortie"));
231outputHistoryPeriod.addAlternativeNodeName(
232 /* language */ Arcane::String("fr"),
233 /* alternative name */ Arcane::String("periode-sortie-historique"));
234outputHistoryShrink.addAlternativeNodeName(
235 /* language */ Arcane::String("fr"),
236 /* alternative name */ Arcane::String("compression-sortie-historique"));
237saveInit.addAlternativeNodeName(
238 /* language */ Arcane::String("fr"),
239 /* alternative name */ Arcane::String("sauvegarde-initiale"));
240saveFinalTime.addAlternativeNodeName(
241 /* language */ Arcane::String("fr"),
242 /* alternative name */ Arcane::String("sauvegarde-temps-final"));
243endExecutionOutput.addAlternativeNodeName(
244 /* language */ Arcane::String("fr"),
245 /* alternative name */ Arcane::String("sortie-fin-execution"));
246output.addAlternativeNodeName(
247 /* language */ Arcane::String("fr"),
248 /* alternative name */ Arcane::String("depouillement"));
249addAlternativeNodeName(
250 /* language */ Arcane::String("fr"),
251 /* alternative name */ Arcane::String("arcane-post-traitement"));
252 }
253
254public:
255 // Interfaces for main CaseOptions
256
257 Arcane::Real getOutputFrequency() { return outputFrequency(); }
258 Arcane::ICaseFunction* getOutputFrequencyFunction() { return outputFrequency.function(); }
259 Arcane::IStandardFunction* getOutputFrequencyStandardFunction() { return outputFrequency.standardFunction(); }
260 Arcane::Integer getOutputPeriod() { return outputPeriod(); }
261 Arcane::ICaseFunction* getOutputPeriodFunction() { return outputPeriod.function(); }
262 Arcane::IStandardFunction* getOutputPeriodStandardFunction() { return outputPeriod.standardFunction(); }
263 Arcane::Integer getOutputHistoryPeriod() { return outputHistoryPeriod(); }
264 Arcane::ICaseFunction* getOutputHistoryPeriodFunction() { return outputHistoryPeriod.function(); }
265 Arcane::IStandardFunction* getOutputHistoryPeriodStandardFunction() { return outputHistoryPeriod.standardFunction(); }
266 bool getOutputHistoryShrink() { return outputHistoryShrink(); }
267 Arcane::ICaseFunction* getOutputHistoryShrinkFunction() { return outputHistoryShrink.function(); }
268 Arcane::IStandardFunction* getOutputHistoryShrinkStandardFunction() { return outputHistoryShrink.standardFunction(); }
269 bool getSaveInit() { return saveInit(); }
270 Arcane::ICaseFunction* getSaveInitFunction() { return saveInit.function(); }
271 Arcane::IStandardFunction* getSaveInitStandardFunction() { return saveInit.standardFunction(); }
272 bool getSaveFinalTime() { return saveFinalTime(); }
273 Arcane::ICaseFunction* getSaveFinalTimeFunction() { return saveFinalTime.function(); }
274 Arcane::IStandardFunction* getSaveFinalTimeStandardFunction() { return saveFinalTime.standardFunction(); }
275 bool getEndExecutionOutput() { return endExecutionOutput(); }
276 Arcane::ICaseFunction* getEndExecutionOutputFunction() { return endExecutionOutput.function(); }
277 Arcane::IStandardFunction* getEndExecutionOutputStandardFunction() { return endExecutionOutput.standardFunction(); }
278
279
280
281 Arcane::IPostProcessorWriter* getFormat() { return format(); }
282 // Interfaces for complex options
283 bool hasExperimentalPythonPlugin() const
284 { return experimentalPythonPlugin.isPresent(); }
285
286
287public:
288
289 Arcane::ICaseOptions* caseOptions() const
290 {
291 return m_case_options.get();
292 }
293
294 Arcane::ICaseOptionList* configList() const
295 {
296 return m_case_options->configList();
297 }
298
299 void setCaseModule(Arcane::IModule* m)
300 {
301 m_case_options->setCaseModule(m);
302 }
303
304 void setCaseServiceInfo(Arcane::IServiceInfo* si)
305 {
306 m_case_options->setCaseServiceInfo(si);
307 }
308
309 void addAlternativeNodeName(const Arcane::String& lang,
310 const Arcane::String& name)
311 {
312 m_case_options->addAlternativeNodeName(lang,name);
313 }
314
315private:
316
317 Arcane::ICaseOptionList* _configList() const { return configList(); }
318 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
319
320private:
321
322 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
323
324 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
325
326public:
327
328
329 Arcane::CaseOptionReal outputFrequency;
330 Arcane::CaseOptionInteger outputPeriod;
331 Arcane::CaseOptionInteger outputHistoryPeriod;
332 Arcane::CaseOptionBool outputHistoryShrink;
333 Arcane::CaseOptionBool saveInit;
334 Arcane::CaseOptionBool saveFinalTime;
335 Arcane::CaseOptionBool endExecutionOutput;
336 Arcane::CaseOptionServiceT< Arcane::IPostProcessorWriter > format;
337 CaseOptionOutput output;
338 CaseOptionExperimentalPythonPlugin experimentalPythonPlugin;
339};
340
341/*---------------------------------------------------------------------------*/
342/*---------------------------------------------------------------------------*/
343
344#endif
345
346
347
348/*---------------------------------------------------------------------------*/
349/*---------------------------------------------------------------------------*/
350// #WARNING#: This file has been generated automatically. Do not edit.
351// Axlstar version 1.0
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
355#ifndef ARCANE_MODULE_AXLSTAR_ARCANEPOSTPROCESSING_H
356#define ARCANE_MODULE_AXLSTAR_ARCANEPOSTPROCESSING_H
357
358/*---------------------------------------------------------------------------*/
359/*---------------------------------------------------------------------------*/
360
361#include "arcane/VariableTypes.h"
362#include "arcane/EntryPoint.h"
363#include "arcane/ISubDomain.h"
364#include "arcane/ModuleBuildInfo.h"
365#include "arcane/ModuleFactory.h"
366#include "arcane/ServiceRegisterer.h"
367#include "arcane/BasicModule.h"
368#include "arcane/ServiceInfo.h"
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373namespace Arcane
374{
375class ISubDomain;
376class IModule;
377}
378
379/*---------------------------------------------------------------------------*/
380/*---------------------------------------------------------------------------*/
381
383
384/*---------------------------------------------------------------------------*/
385/*---------------------------------------------------------------------------*/
386
388class ArcaneArcanePostProcessingObject
389 : public Arcane::BasicModule
390{
391public:
392
393 static void fillServiceInfo(Arcane::ServiceInfo* si)
394 {
395 si->setCaseOptionsFileName("ArcanePostProcessing_arcane_std");
396 si->setAxlVersion(1.0);
397 si->setDefaultTagName(Arcane::String("arcane-post-processing"));
398 si->setAxlContent(getAxlContent());
399 si->setTagName(Arcane::String("arcane-post-traitement"),Arcane::String("fr"));
400 }
401
402public:
403
404 ArcaneArcanePostProcessingObject(const Arcane::ModuleBuildInfo& mb)
406 , m_options(nullptr)
407 , m_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingNextIteration" ))
408 , m_next_global_time(Arcane::VariableBuildInfo(this, "PostProcessingNextGlobalTime" ))
409 , m_curves_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingCurvesNextIteration" ))
410 , m_curves_next_global_time(Arcane::VariableBuildInfo(this, "PostProcessingCurvesNextGlobalTime" ))
411 , m_history_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingHistoryNextIteration" ))
412 {
414 m_options->setCaseModule(this);
415 addEntryPoint(this, "PostProcessingExportData",
419 addEntryPoint(this, "PostProcessingExportDataStart",
420 &ArcaneArcanePostProcessingObject::exportDataStart,
423 addEntryPoint(this, "PostProcessingStartInit",
424 &ArcaneArcanePostProcessingObject::postProcessingStartInit,
427 addEntryPoint(this, "PostProcessingInit",
428 &ArcaneArcanePostProcessingObject::postProcessingInit,
431 addEntryPoint(this, "PostProcessingExit",
432 &ArcaneArcanePostProcessingObject::postProcessingExit,
433 Arcane::IEntryPoint::WExit,
435 }
436
437 virtual ~ArcaneArcanePostProcessingObject()
438 {
439 delete m_options;
440 }
441
442public:
443
445 virtual void exportData() = 0; // ExportData
446 virtual void exportDataStart() = 0; // ExportDataStart
447 virtual void postProcessingStartInit() = 0; // PostProcessingStartInit
448 virtual void postProcessingInit() = 0; // PostProcessingInit
449 virtual void postProcessingExit() = 0; // PostProcessingExit
450
453
454private:
455
458
459protected:
460
463 Arcane::VariableScalarReal m_next_global_time;
464 Arcane::VariableScalarInteger m_curves_next_iteration;
465 Arcane::VariableScalarReal m_curves_next_global_time;
466 Arcane::VariableScalarInteger m_history_next_iteration;
467
468private:
469 static Arcane::FileContent getAxlContent()
470 {
471 const char* str_content = "";
472 const Arcane::Byte* content = (const Arcane::Byte*)(str_content);
473 Arcane::Span<const Arcane::Byte> bytes(content,0);
474 int file_version = 1;
475 return Arcane::FileContent(bytes,file_version,"");
476 }
477
478};
479
480/*---------------------------------------------------------------------------*/
481/*---------------------------------------------------------------------------*/
482
483#define ARCANE_REGISTER_MODULE_ARCANEPOSTPROCESSING(class_name) \
484 ARCANE_REGISTER_AXL_MODULE(class_name,Arcane::ModuleProperty("ArcanePostProcessing",false))
485
486/*---------------------------------------------------------------------------*/
487/*---------------------------------------------------------------------------*/
488
489#endif
490
CaseOptionsArcanePostProcessing * options() const
Options du jeu de données du module.
Arcane::VariableScalarInteger m_next_iteration
Variables du module.
virtual void exportData()=0
points d'entrée
CaseOptionsArcanePostProcessing * m_options
Options du jeu de données du module.
Module basique.
Definition BasicModule.h:41
Classe de base d'une option du jeu de donnée.
Informations pour construire une option de jeu de données.
Option du jeu de donnée de type liste de types étendus.
Classe de base d'une liste d'options du jeu de données.
Definition CaseOptions.h:57
void addAlternativeNodeName(const String &lang, const String &name) override
Ajoute une traduction pour le nom de l'option. Ajoute le nom name de l'option correspondant au langag...
Vue constante d'un tableau de type T.
Description et contenu d'un fichier.
Definition FileContent.h:32
Interface d'une fonction du jeu de données.
Interface du gestionnaire de cas.
Definition ICaseMng.h:56
Interface d'une liste d'options du jeu de données.
static const char *const WComputeLoop
appelé pendant la boucle de calcul
Definition IEntryPoint.h:42
static const char *const WStartInit
appelé pendant l'initialisation d'un nouveau cas
Definition IEntryPoint.h:50
@ PAutoLoadEnd
Chargé automatiquement à la fin. Cela signifie qu'un module possédant un point d'entrée avec cette pr...
Definition IEntryPoint.h:80
@ PAutoLoadBegin
Chargé automatiquement au début. Cela signifie qu'un module possédant un point d'entrée avec cette pr...
Definition IEntryPoint.h:73
static const char *const WInit
appelé pendant l'initialisation
Definition IEntryPoint.h:46
Interface du service de chargement de services externes.
Interface d'un module.
Definition IModule.h:39
Interface gérant une fonction standard.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
virtual ICaseMng * caseMng()=0
Retourne le gestionnaire du jeu de données.
Informations d'un service.
Definition ServiceInfo.h:46
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Informations pour construire un module.
ISubDomain * subDomain() const
Accès au sous-domaine associé
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Chaîne de caractères unicode.
Paramètres nécessaires à la construction d'une variable.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
VariableRefScalarT< Real > VariableScalarReal
Variable scalaire de type réel.
VariableRefScalarT< Integer > VariableScalarInteger
Variable scalaire de type entier.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43