Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
InternalInfosDumper.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* InternalInfosDumper.cc (C) 2000-2019 */
9/* */
10/* Sorties des informations internes de Arcane. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/impl/InternalInfosDumper.h"
15
16#include "arcane/utils/String.h"
17#include "arcane/utils/PlatformUtils.h"
18#include "arcane/utils/FatalErrorException.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/ScopedPtr.h"
21#include "arcane/utils/ApplicationInfo.h"
22#include "arcane/utils/JSONWriter.h"
23#include "arcane/utils/FileContent.h"
24
25#include "arcane/Parallel.h"
26#include "arcane/IParallelMng.h"
27#include "arcane/Directory.h"
28#include "arcane/ServiceFinder2.h"
29#include "arcane/IApplication.h"
30#include "arcane/ICodeService.h"
31#include "arcane/SubDomainBuildInfo.h"
32#include "arcane/IServiceLoader.h"
33#include "arcane/IParallelSuperMng.h"
34#include "arcane/IMainFactory.h"
35#include "arcane/ISession.h"
36#include "arcane/ISubDomain.h"
37#include "arcane/ITimeLoopMng.h"
38#include "arcane/IVariableMng.h"
39#include "arcane/IXmlDocumentHolder.h"
40#include "arcane/XmlNodeList.h"
41#include "arcane/IModuleMng.h"
42#include "arcane/IModule.h"
43#include "arcane/VariableRef.h"
44#include "arcane/VariableCollection.h"
45#include "arcane/IIOMng.h"
46#include "arcane/ITimeLoop.h"
47#include "arcane/ICaseMng.h"
48#include "arcane/ICaseOptions.h"
49#include "arcane/IRessourceMng.h"
50
51#include "arcane/impl/TimeLoopReader.h"
52
53#include <set>
54#include <map>
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59namespace Arcane
60{
61
62extern "C++" ARCANE_IMPL_EXPORT Ref<ICodeService>
63createArcaneCodeService(IApplication* app);
64
65/*---------------------------------------------------------------------------*/
66/*---------------------------------------------------------------------------*/
67
68InternalInfosDumper::
69InternalInfosDumper(IApplication* application)
70: m_application(application)
71{
72}
73
74/*---------------------------------------------------------------------------*/
75/*---------------------------------------------------------------------------*/
76
77Ref<ICodeService> InternalInfosDumper::
78_getDefaultService()
79{
80 String code_name = platform::getEnvironmentVariable("STDENV_CODE_NAME");
81 if (code_name.null())
82 ARCANE_FATAL("environment variable 'STDENV_CODE_NAME' is not defined");
83
84 IApplication* app = m_application;
85 ServiceFinder2T<ICodeService,IApplication> code_services_utils(app,app);
86 String full_code_name = code_name + "Code";
87 Ref<ICodeService> code = code_services_utils.createReference(full_code_name);
88 if (!code){
89 // Le service de code de nom Arcane est spécial et sert pour générer
90 // la documentation interne. S'il n'est pas enregistré, on créé directement
91 // l'instance.
92 if (code_name=="Arcane")
93 code = createArcaneCodeService(app);
94 }
95 if (!code)
96 ARCANE_FATAL("No code service named '{0}' found",full_code_name);
97 return code;
98}
99
100/*---------------------------------------------------------------------------*/
101/*---------------------------------------------------------------------------*/
102
103void InternalInfosDumper::
104dumpInternalInfos()
105{
106 ITraceMng* tr = m_application->traceMng();
107 IMainFactory* main_factory = m_application->mainFactory();
108 tr->info() << "Sortie des infos internes à Arcane";
109 Ref<ICodeService> code_service = _getDefaultService();
110 ISession* session(code_service->createSession());
111 IParallelSuperMng* psm = m_application->parallelSuperMng();
112 Ref<IParallelMng> world_pm = psm->internalCreateWorldParallelMng(0);
113 SubDomainBuildInfo sdbi(world_pm,0);
114 sdbi.setCaseFileName(String());
115 sdbi.setCaseBytes(ByteConstArrayView());
116 ISubDomain* sub_domain(session->createSubDomain(sdbi));
117 ScopedPtrT<IServiceLoader> service_loader(main_factory->createServiceLoader());
118 // Les services sont déjà enregistrées lors de la création du sous-domaine
119 {
120 TimeLoopReader stl(m_application);
121 stl.readTimeLoops();
122 stl.registerTimeLoops(sub_domain);
123 }
124 // Charge tous les modules disponibles
125 service_loader->loadModules(sub_domain,true);
126
127 // Conserve dans le tableau tous les IServiceInfo.
128 UniqueArray<IServiceInfo*> service_infos;
129 {
130 std::set<IServiceInfo*> done_set;
131 for( ServiceFactory2Collection::Enumerator j(m_application->serviceFactories2()); ++j; ){
132 Internal::IServiceFactory2* sf2 = *j;
133 IServiceInfo* s = sf2->serviceInfo();
134 if (done_set.find(s)==done_set.end()){
135 service_infos.add(s);
136 done_set.insert(s);
137 }
138 }
139 }
140
141 IModuleMng* module_mng = sub_domain->moduleMng();
142 IVariableMng* variable_mng = sub_domain->variableMng();
143
144 VariableRefList var_ref_list;
145
146 String us_name("name");
147 String us_ref("ref");
148 String us_datatype("datatype");
149 String us_dimension("dimension");
150 String us_kind("kind");
151 String us_root("root");
152 String us_modules("modules");
153 String us_module("module");
154 String us_services("services");
155 String us_service("service");
156
157 ScopedPtrT<IXmlDocumentHolder> doc_holder(m_application->ressourceMng()->createXmlDocument());
158 XmlNode doc_element = doc_holder->documentNode();
159 XmlNode root_element = doc_element.createAndAppendElement(us_root);
160
161 XmlNode modules = root_element.createAndAppendElement(us_modules);
162 // Liste des modules avec les variables qu'ils utilisent.
163 for( ModuleCollection::Enumerator i(module_mng->modules()); ++i; ){
164 XmlNode module_element = modules.createAndAppendElement(us_module);
165 module_element.setAttrValue(us_name,String((*i)->name()));
166 var_ref_list.clear();
167 variable_mng->variables(var_ref_list,*i);
168 for( VariableRefList::Enumerator j(var_ref_list); ++j; ){
169 XmlNode variable_element = module_element.createAndAppendElement("variable-ref");
170 variable_element.setAttrValue(us_ref,String((*j)->name()));
171 }
172 }
173
174 XmlNode variables = root_element.createAndAppendElement("variables");
175 // Liste des variables.
176 VariableCollection var_prv_list(variable_mng->variables());
177 for( VariableCollection::Enumerator j(var_prv_list); ++j; ){
178 IVariable* var = *j;
179 String dim(String::fromNumber(var->dimension()));
180 XmlNode variable_element = variables.createAndAppendElement("variable");
181 variable_element.setAttrValue(us_name,var->name());
182 variable_element.setAttrValue(us_datatype,dataTypeName(var->dataType()));
183 variable_element.setAttrValue(us_dimension,dim);
184 variable_element.setAttrValue(us_kind,itemKindName(var->itemKind()));
185 }
186
187 // Liste des boucles en temps
188 ITimeLoopMng* tm = sub_domain->timeLoopMng();
189 StringList timeloop_name_list;
190 tm->timeLoopsName(timeloop_name_list);
191
192 XmlNode timeloops = root_element.createAndAppendElement("timeloops");
193 for( StringCollection::Enumerator i(timeloop_name_list); ++i; ){
194 XmlNode timeloop_elem = timeloops.createAndAppendElement("timeloop");
195 timeloop_elem.setAttrValue(us_name,*i);
196 }
197
198 // Liste des services
199 {
200 // Liste des services qui implementent une interface donnée
201 std::map<String,List<IServiceInfo*> > interfaces_to_service;
202 XmlNode services_elem = root_element.createAndAppendElement(us_services);
203
204 for( int i=0, n=service_infos.size(); i<n; ++i ){
205 IServiceInfo* service_info = service_infos[i];
206 XmlNode service_elem = services_elem.createAndAppendElement(us_service);
207 service_elem.setAttrValue(us_name,service_info->localName());
208 {
209 auto xml_file_base_name = service_info->caseOptionsFileName();
210 if (!xml_file_base_name.null()){
211 service_elem.setAttrValue("file-base-name",xml_file_base_name);
212 }
213 }
214 for( StringCollection::Enumerator j(service_info->implementedInterfaces()); ++j; ){
215 XmlNode interface_elem = service_elem.createAndAppendElement("implement-class");
216 interface_elem.setAttrValue(us_name,*j);
217 interfaces_to_service[*j].add(service_info);
218 }
219 }
220
221 {
222 XmlNode classes_elem = services_elem.createAndAppendElement("services-class");
223 std::map<String,List<IServiceInfo*> >::const_iterator begin = interfaces_to_service.begin();
224 std::map<String,List<IServiceInfo*> >::const_iterator end = interfaces_to_service.end();
225 for( ; begin!=end; ++begin ){
226 XmlNode class_elem = classes_elem.createAndAppendElement("class");
227 class_elem.setAttrValue(us_name,begin->first);
228 for( List<IServiceInfo*>::Enumerator i(begin->second); ++i; ){
229 IServiceInfo* service_info = *i;
230 XmlNode service_elem = class_elem.createAndAppendElement(us_service);
231 service_elem.setAttrValue(us_name,service_info->localName());
232 {
233 auto xml_file_base_name = service_info->caseOptionsFileName();
234 if (!xml_file_base_name.null()){
235 service_elem.setAttrValue("file-base-name",xml_file_base_name);
236 }
237 }
238 }
239 }
240 }
241 }
242
243 Directory shared_dir(m_application->applicationInfo().dataDir());
244 String filename = shared_dir.file("arcane_internal.xml");
245 cerr << "** FILE IS " << filename << '\n';
246 sub_domain->ioMng()->writeXmlFile(doc_holder.get(),filename);
247}
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251
252void InternalInfosDumper::
253dumpInternalAllInfos()
254{
255 m_application->traceMng()->info() << "Sortie des infos sur les boucles en temps";
256 IMainFactory* main_factory = m_application->mainFactory();
257 Ref<ICodeService> code_service = _getDefaultService();
258
259 ByteConstSpan config_bytes = m_application->configBuffer();
260 ScopedPtrT<IXmlDocumentHolder> config_doc(m_application->ioMng()->parseXmlBuffer(config_bytes,String()));
261 if (!config_doc.get())
262 ARCANE_FATAL("Can not parse code configuration file");
263 XmlNode elem = config_doc->documentNode().documentElement();
264
265 // La boucle en temps est spécifiée dans le fichier de config.
266 // XmlNode elem = m_application->configRootElement();
267 elem = elem.child("Execution");
268 elem = elem.child("BouclesTemps");
269
270 IServiceLoader* service_loader = main_factory->createServiceLoader();
271
272 ScopedPtrT<IXmlDocumentHolder> doc_holder(m_application->ressourceMng()->createXmlDocument());
273 XmlNode doc_element = doc_holder->documentNode();
274 XmlNode root_element = doc_element.createAndAppendElement(String("root"));
275
276 String us_name("name");
277
278 TimeLoopReader stl(m_application);
279 stl.readTimeLoops();
280
281 {
282 const ApplicationInfo& app_info = m_application->applicationInfo();
284 XmlNode elem2(root_element.createAndAppendElement("general"));
285 elem2.createAndAppendElement("codename",String(app_info.codeName()));
286 elem2.createAndAppendElement("codefullversion",String(m_application->mainVersionStr()));
287 elem2.createAndAppendElement("codeversion",String(m_application->majorAndMinorVersionStr()));
288 }
289
290 IParallelSuperMng* psm = m_application->parallelSuperMng();
291 Ref<IParallelMng> world_pm = psm->internalCreateWorldParallelMng(0);
292
293 for( TimeLoopCollection::Enumerator i(stl.timeLoops()); ++i; ){
294 ITimeLoop* timeloop = *i;
295 const String& timeloop_name = timeloop->name();
296
297 ISession* session = nullptr;
298 ISubDomain* sd = nullptr;
299 try{
300 session = code_service->createSession();
301 service_loader->loadSessionServices(session);
302 SubDomainBuildInfo sdbi(world_pm,0);
303 sdbi.setCaseFileName(String());
304 sdbi.setCaseBytes(ByteConstArrayView());
305 sd = session->createSubDomain(sdbi);
306 //service_loader->loadSubDomainServices(sd);
307
308 ITimeLoopMng* loop_mng = sd->timeLoopMng();
309 loop_mng->registerTimeLoop(timeloop);
310 loop_mng->setUsedTimeLoop(timeloop_name);
311 }
312 catch(...){
313 session = nullptr;
314 sd = nullptr;
315 }
316 if (!sd)
317 continue;
318 XmlNode mng_element = root_element.createAndAppendElement("timeloop");
319 mng_element.setAttrValue(us_name,timeloop_name);
320 sd->dumpInternalInfos(mng_element);
321 }
322
323 Directory shared_dir(m_application->applicationInfo().dataDir());
324 String filename = shared_dir.file("arcane-caseinfos.xml");
325 cerr << "** FILE IS " << filename << '\n';
326 m_application->ioMng()->writeXmlFile(doc_holder.get(),filename);
327}
328
329/*---------------------------------------------------------------------------*/
330/*---------------------------------------------------------------------------*/
331
332void InternalInfosDumper::
333_dumpSubDomainInternalInfos(ISubDomain* sd,JSONWriter& json_writer)
334{
335 // Info sur la boucle en temps utilisée.
336 {
337 ITimeLoopMng* tlm = sd->timeLoopMng();
338 ITimeLoop* time_loop = tlm->usedTimeLoop();
339 JSONWriter::Object jo_timeloopinfo(json_writer,"timeloopinfo");
340 json_writer.write("title",time_loop->title());
341 json_writer.write("description",time_loop->description());
342
343 JSONWriter::Array ja_userclass(json_writer,"userclass");
344 for( StringCollection::Enumerator j(time_loop->userClasses()); ++j; ){
345 json_writer.writeValue(*j);
346 }
347 }
348
349 String ustr_module("module");
350 String ustr_name("name");
351 String ustr_activated("activated");
352 String ustr_variable("variable");
353 String ustr_variable_ref("variable-ref");
354 String ustr_ref("ref");
355 String ustr_datatype("datatype");
356 String ustr_dimension("dimension");
357 String ustr_kind("kind");
358 String ustr_caseblock("caseblock");
359 String ustr_tagname("tagname");
360
361 IVariableMng* var_mng = sd->variableMng();
362
363 // Liste des modules avec les variables qu'ils utilisent.
364 {
365 JSONWriter::Array ja_modules(json_writer,"modules");
366 for( IModule* module : sd->moduleMng()->modules() ){
367 JSONWriter::Object jo_module(json_writer);
368 json_writer.write(ustr_name,module->name());
369 json_writer.write(ustr_activated,module->used());
370
371 VariableRefList var_ref_list;
372 var_mng->variables(var_ref_list,module);
373 JSONWriter::Array ja_variables(json_writer,"variables");
374 for( VariableRef* vr : var_ref_list )
375 json_writer.writeValue(vr->variable()->fullName());
376 }
377 }
378
379 // Liste des variables.
380 {
381 VariableCollection var_prv_list = var_mng->variables();
382 JSONWriter::Array jo_variables(json_writer,"variables");
383 for( VariableCollection::Enumerator j(var_prv_list); ++j; ){
384 IVariable* var = *j;
385 JSONWriter::Object jo_variable(json_writer);
386 json_writer.write(ustr_name,var->fullName());
387 json_writer.write(ustr_datatype,dataTypeName(var->dataType()));
388 json_writer.write(ustr_dimension,(Int64)var->dimension());
389 json_writer.write(ustr_kind,itemKindName(var->itemKind()));
390 }
391 }
392
393 // Liste des blocs d'options
394 {
395 ICaseMng* cm = sd->caseMng();
396 CaseOptionsCollection blocks = cm->blocks();
397
398 JSONWriter::Array ja_blocks(json_writer,"caseblocks");
399 for( ICaseOptions* block : blocks ){
400 JSONWriter::Object jo_block(json_writer);
401 json_writer.write(ustr_tagname,block->rootTagName());
402
403 IModule* block_module = block->caseModule();
404 if (block_module)
405 json_writer.write(ustr_module,block_module->name());
406 }
407 }
408}
409
410/*---------------------------------------------------------------------------*/
411/*---------------------------------------------------------------------------*/
415void InternalInfosDumper::
416dumpArcaneDatabase()
417{
418 IApplication* app = m_application;
419 ITraceMng* tr = app->traceMng();
420 IMainFactory* main_factory = m_application->mainFactory();
421 tr->info() << "Generating Arcane Database";
422 Ref<ICodeService> code_service = _getDefaultService();
423 ISession* session(code_service->createSession());
424 IParallelSuperMng* psm = app->parallelSuperMng();
425 Ref<IParallelMng> world_pm = psm->internalCreateWorldParallelMng(0);
426 SubDomainBuildInfo sdbi(world_pm,0);
427 sdbi.setCaseFileName(String());
428 sdbi.setCaseBytes(ByteConstArrayView());
429 ISubDomain* sub_domain(session->createSubDomain(sdbi));
430 ScopedPtrT<IServiceLoader> service_loader(main_factory->createServiceLoader());
431
432 ByteConstSpan config_bytes = m_application->configBuffer();
433 ScopedPtrT<IXmlDocumentHolder> config_doc(app->ioMng()->parseXmlBuffer(config_bytes,String()));
434 if (!config_doc.get())
435 ARCANE_FATAL("Can not parse code configuration file");
436
437 // Les services sont déjà enregistrées lors de la création du sous-domaine
438 {
439 TimeLoopReader stl(m_application);
440 stl.readTimeLoops();
441 stl.registerTimeLoops(sub_domain);
442 }
443 // Charge tous les modules disponibles
444 service_loader->loadModules(sub_domain,true);
445
446 // Conserve dans ce tableau tous les IServiceInfo créés
447 UniqueArray<IServiceInfo*> service_infos;
448 {
449 std::set<IServiceInfo*> done_set;
450 for( ServiceFactory2Collection::Enumerator j(m_application->serviceFactories2()); ++j; ){
451 Internal::IServiceFactory2* sf2 = *j;
452 IServiceInfo* s = sf2->serviceInfo();
453 if (done_set.find(s)==done_set.end()){
454 service_infos.add(s);
455 done_set.insert(s);
456 }
457 }
458 }
459
460 IModuleMng* module_mng = sub_domain->moduleMng();
461 IVariableMng* variable_mng = sub_domain->variableMng();
462
463 String us_name("name");
464 String us_ref("ref");
465 String us_datatype("datatype");
466 String us_dimension("dimension");
467 String us_kind("kind");
468 String us_root("root");
469 String us_modules("modules");
470 String us_module("module");
471 String us_services("services");
472 String us_service("service");
473
474 ScopedPtrT<IXmlDocumentHolder> doc_holder(m_application->ressourceMng()->createXmlDocument());
475 XmlNode doc_element = doc_holder->documentNode();
476 XmlNode root_element = doc_element.createAndAppendElement(us_root);
477
478 JSONWriter json_writer(JSONWriter::FormatFlags::None);
479 json_writer.beginObject();
480 json_writer.write("version","1");
481
482 // Liste des modules avec les variables qu'ils utilisent.
483 {
484 JSONWriter::Array ja_modules(json_writer,"modules");
485 for( IModule* module : module_mng->modules() ){
486 JSONWriter::Object jo(json_writer);
487 json_writer.write(us_name,module->name());
488 VariableRefList var_ref_list;
489 variable_mng->variables(var_ref_list,module);
490 JSONWriter::Array ja_var_ref(json_writer,"variable-references");
491 for( VariableRefList::Enumerator j(var_ref_list); ++j; ){
492 json_writer.writeValue((*j)->name());
493 }
494 }
495 }
496
497 // Liste des variables avec leurs caractéristiques
498 {
499 VariableCollection var_prv_list(variable_mng->variables());
500 JSONWriter::Array ja(json_writer,"variables");
501 for( VariableCollection::Enumerator j(var_prv_list); ++j; ){
502 IVariable* var = *j;
503
504 JSONWriter::Object jo(json_writer);
505 json_writer.write(us_name,var->name());
506 json_writer.write(us_datatype,dataTypeName(var->dataType()));
507 json_writer.write(us_dimension,(Int64)var->dimension());
508 json_writer.write(us_kind,itemKindName(var->itemKind()));
509 }
510 }
511
512 // Liste des services qui implémentent une interface donnée
513 std::map<String,List<IServiceInfo*> > interfaces_to_service;
514
515 // Liste des services
516 {
517 JSONWriter::Array ja_services(json_writer,us_services);
518
519 for( IServiceInfo* service_info : service_infos ){
520 JSONWriter::Object jo(json_writer);
521 json_writer.write(us_name,service_info->localName());
522 json_writer.writeIfNotNull("file-base-name",service_info->caseOptionsFileName());
523
524 // Sauver le contenu en splittant en plusieurs chaînes de
525 // caractères ce qui permet de ne pas avoir de lignes trop longues.
526 Span<const Byte> content = service_info->axlContent().bytes();
527 Int64 content_size = content.size();
528 if (content_size>0){
529 Int64 block_size = 80;
530 Int64 nb_block = content_size / block_size;
531 if ((content_size%block_size)!=0)
532 ++nb_block;
533 JSONWriter::Array ja_axl_content(json_writer,"axl-content");
534 Int64 index = 0;
535 for( Integer k=0; k<nb_block; ++k ){
536 auto z = content.subSpan(index,block_size);
537 json_writer.writeValue(z);
538 index += block_size;
539 }
540 }
541
542 // Sauve la listes des interfaces implémentées par ce service
543 {
544 JSONWriter::Array ja_implemented_interfaces(json_writer,"implemented-interfaces");
545 for( StringCollection::Enumerator j(service_info->implementedInterfaces()); ++j; ){
546 interfaces_to_service[*j].add(service_info);
547 json_writer.writeValue(*j);
548 }
549 }
550 }
551 }
552
553 // Liste des interfaces de services et des services les implémentant.
554 {
555 JSONWriter::Array jo_services_interfaces(json_writer,"service-interfaces");
556 for( const auto& x : interfaces_to_service ){
557 JSONWriter::Object jo_class(json_writer);
558 json_writer.write(us_name,x.first);
559 JSONWriter::Array ja_services(json_writer,"services");
560 for( IServiceInfo* service_info : x.second ){
561 JSONWriter::Object jo_service(json_writer);
562 json_writer.write(us_name,service_info->localName());
563 json_writer.writeIfNotNull("file-base-name",service_info->caseOptionsFileName());
564 }
565 }
566 }
567
568 TimeLoopReader stl(m_application);
569 stl.readTimeLoops();
570
571 {
572 const ApplicationInfo& app_info = m_application->applicationInfo();
573 JSONWriter::Object jo_general(json_writer,"general");
574 json_writer.write("codename",app_info.codeName());
575 json_writer.write("codefullversion",m_application->mainVersionStr());
576 json_writer.write("codeversion",m_application->majorAndMinorVersionStr());
577 }
578
579 {
580 JSONWriter::Array jo_timeloops(json_writer,"timeloops");
581 for( TimeLoopCollection::Enumerator i(stl.timeLoops()); ++i; ){
582 ITimeLoop* timeloop = *i;
583 const String& timeloop_name = timeloop->name();
584
585 JSONWriter::Object jo_timeloop(json_writer);
586 json_writer.write(us_name,timeloop_name);
587
588 ISession* session = nullptr;
589 ISubDomain* sd = nullptr;
590 try{
591 session = code_service->createSession();
592 service_loader->loadSessionServices(session);
593 SubDomainBuildInfo sdbi(world_pm,0);
594 sdbi.setCaseFileName(String());
595 sdbi.setCaseBytes(ByteConstArrayView());
596 sd = session->createSubDomain(sdbi);
597
598 ITimeLoopMng* loop_mng = sd->timeLoopMng();
599 loop_mng->registerTimeLoop(timeloop);
600 loop_mng->setUsedTimeLoop(timeloop_name);
601 }
602 catch(...){
603 session = nullptr;
604 sd = nullptr;
605 }
606 // TODO: Indique si sd est nul.
607 if (sd){
608 _dumpSubDomainInternalInfos(sd,json_writer);
609 }
610 }
611 }
612
613 json_writer.endObject();
614
615 {
616 // Écrit le fichier JSON.
617 Directory shared_dir(m_application->applicationInfo().dataDir());
618 String json_filename = shared_dir.file("arcane_database.json");
619 cerr << "** FILE2 IS " << json_filename << '\n';
620 String buf(json_writer.getBuffer());
621 // TODO: regarder s'il ne serait pas préférable de sauver le fichier
622 // dans le répertoire courant.
623 std::ofstream ofile(json_filename.localstr());
624 buf.writeBytes(ofile);
625 }
626}
627
628/*---------------------------------------------------------------------------*/
629/*---------------------------------------------------------------------------*/
630
631} // End namespace Arcane
632
633/*---------------------------------------------------------------------------*/
634/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809
Arcane::ApplicationInfo
Informations sur une application.
Definition ApplicationInfo.h:40
Arcane::Directory
Classe gérant un répertoire.
Definition Directory.h:33
Arcane::IApplication
Interface de l'application.
Definition IApplication.h:57
Arcane::IMainFactory
Manufacture des classes d'Arcane.
Definition IMainFactory.h:93
Arcane::IModuleMng
Interface du gestionnaire de modules.
Definition IModuleMng.h:39
Arcane::IModule
Interface d'un module.
Definition IModule.h:39
Arcane::IParallelSuperMng
Classe abstraite du superviseur de parallélisme.
Definition IParallelSuperMng.h:41
Arcane::IServiceInfo
Interface des informations d'un service ou d'un module.
Definition IServiceInfo.h:37
Arcane::IServiceLoader
Interface de chargement des services.
Definition IServiceLoader.h:43
Arcane::ISession
Interface d'une session d'exécution d'un cas.
Definition ISession.h:44
Arcane::ISession::createSubDomain
virtual ISubDomain * createSubDomain(const SubDomainBuildInfo &sdbi)=0
Créé un sous-domaine avec les paramètres contenus dans sdbi.
Arcane::ISubDomain
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Arcane::ISubDomain::variableMng
virtual IVariableMng * variableMng()=0
Retourne le gestionnaire de variables.
Arcane::ISubDomain::caseMng
virtual ICaseMng * caseMng()=0
Retourne le gestionnaire du jeu de données.
Arcane::ITimeLoopMng
Interface du gestionnaire de la boucle en temps.
Definition ITimeLoopMng.h:69
Arcane::ITimeLoop
Interface d'une boucle en temps.
Definition ITimeLoop.h:41
Arcane::ITimeLoop::name
virtual String name() const =0
Nom de la boucle en temps.
Arcane::IVariableMng
Interface du gestionnaire de variables.
Definition IVariableMng.h:57
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:54
Arcane::JSONWriter
Ecrivain au format JSON.
Definition JSONWriter.h:33
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::SubDomainBuildInfo
Paramètres nécessaires à la construction d'un sous-domaine.
Definition SubDomainBuildInfo.h:53
Arcane::TimeLoopReader
Functor de chargement d'une boucle en temps.
Definition TimeLoopReader.h:44
Arcane::VariableCollection
Collection de variables.
Definition VariableCollection.h:81
Arcane::XmlNode
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::ITraceMng::info
virtual TraceMessage info()=0
Flot pour un message d'information.
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arccore::String::writeBytes
void writeBytes(std::ostream &o) const
Écrit la chaîne au format UTF-8 sur le flot o.
Definition String.cc:1236
Arccore::TraceAccessor::traceMng
ITraceMng * traceMng() const
Gestionnaire de trace.
Definition TraceAccessor.cc:72
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::ByteConstSpan
Span< const std::byte > ByteConstSpan
Vue en lecture seule d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:706
Arcane::CaseOptionsCollection
Collection< ICaseOptions * > CaseOptionsCollection
Collection d'options du jeu de données.
Definition ArcaneTypes.h:455
Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
Definition UtilsTypes.h:634
Arcane::StringList
List< String > StringList
Tableau de chaînes de caractères unicode.
Definition UtilsTypes.h:667
Arcane::itemKindName
const char * itemKindName(eItemKind kind)
Nom du genre d'entité.
Definition ArcaneTypes.cc:37
Arcane::VariableRefList
List< VariableRef * > VariableRefList
Tableau de références de variables.
Definition ArcaneTypes.h:476
Arcane::dataTypeName
const char * dataTypeName(eDataType type)
Nom du type de donnée.
Definition DataTypes.cc:70