Loading...
Searching...
No Matches
POD_application_example_00001.cpp
1/*---------------------------------------------------------------------------*\
2 *
3 * bitpit
4 *
5 * Copyright (C) 2015-2021 OPTIMAD engineering Srl
6 *
7 * -------------------------------------------------------------------------
8 * License
9 * This file is part of bitpit.
10 *
11 * bitpit is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License v3 (LGPL)
13 * as published by the Free Software Foundation.
14 *
15 * bitpit is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
18 * License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with bitpit. If not, see <http://www.gnu.org/licenses/>.
22 *
23\*---------------------------------------------------------------------------*/
24
34#if BITPIT_ENABLE_MPI
35#include <mpi.h>
36#endif
37
38#include "pod.hpp"
39
40using namespace bitpit;
41
42//=================================================================================== //
43
48enum class Verbose{
49 QUIET=0 ,
50 NORMAL=1 ,
51 FULL=2
52};
53
54//=================================================================================== //
64struct InfoBitpodPP{
65
66 std::string dictName;
67 Verbose vconsole;
68 Verbose vlog;
71 InfoBitpodPP(){
72 dictName = "pod.xml";
73 vlog = Verbose::FULL;
74 vconsole = Verbose::NORMAL;
75 }
77 ~InfoBitpodPP(){};
78
80 InfoBitpodPP(const InfoBitpodPP & other){
81 *this = other;
82 }
83
85 InfoBitpodPP & operator=(const InfoBitpodPP & other){
86 dictName = other.dictName;
87 vlog = other.vlog;
88 vconsole = other.vconsole;
89 return *this;
90 }
91};
92
93//=================================================================================== //
94
99InfoBitpodPP readArguments(int argc, char*argv[] ){
100 //reading arguments
101 if(argc <2) {
102 std::cout<<"Error. Not enough arguments found launching the application"<<std::endl;
103 std::cout<<"Please run application_example_00001 --help for a brief guide on how to use it"<<std::endl;
104 exit(1);
105 }
106
107 std::unordered_set<std::string> input;
108 for(int i=1; i<argc; ++i){
109 std::string temp = argv[i];
110 input.insert(bitpit::utils::string::trim(temp));
111 }
112
113 if(input.count("--help")>0){
114 std::cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<std::endl;
115 std::cout<<""<<std::endl;
116 std::cout<<" Brief application_example_00001 helper, version 1.0"<<std::endl;
117 std::cout<<""<<std::endl;
118 std::cout<<""<<std::endl;
119 std::cout<<" This is the executable command for running POD instructions from XML Control Dictionaries"<<std::endl;
120 std::cout<<" The command needs mandatorily a XML dictionary to run. It can return execution info on "<<std::endl;
121 std::cout<<" both console(screen) and external log file. As further debug info, it can plot optional "<<std::endl;
122 std::cout<<" results of its execution. "<<std::endl;
123 std::cout<<" "<<std::endl;
124 std::cout<<" The full list of options for running the application are: "<<std::endl;
125 std::cout<<" "<<std::endl;
126 std::cout<<" "<<std::endl;
127 std::cout<<" "<<std::endl;
128 std::cout<<" --help : print this helper "<<std::endl;
129 std::cout<<" "<<std::endl;
130 std::cout<<" --dict=<dictionary name> : full path to the target xml dictionary. Mandatory. "<<std::endl;
131 std::cout<<" "<<std::endl;
132 std::cout<<" --vconsole=<quiet/normal/full> : print info on the execution on console(screen). "<<std::endl;
133 std::cout<<" full is meant for full debug message verbosity, normal for "<<std::endl;
134 std::cout<<" a medium verbosity, quiet shut off messaging on console. "<<std::endl;
135 std::cout<<" Default verbosity is medium. "<<std::endl;
136 std::cout<<" "<<std::endl;
137 std::cout<<" --vlog=<quiet/normal/full> : print info on the execution external file bitpit.log. "<<std::endl;
138 std::cout<<" full is meant for full debug message verbosity, normal for "<<std::endl;
139 std::cout<<" a medium verbosity, quiet shut off messaging on file. "<<std::endl;
140 std::cout<<" Default verbosity is full. "<<std::endl;
141 std::cout<<" "<<std::endl;
142 std::cout<<" "<<std::endl;
143 std::cout<<" "<<std::endl;
144 std::cout<<" For any problem, bug and malfunction please contact bitpit developers. "<<std::endl;
145 std::cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<std::endl;
146 exit(1);
147 }
148
149 std::unordered_map<int, std::string> keymap;
150 keymap[0] = "dict=";
151 keymap[1] = "vlog=";
152 keymap[2] = "vconsole=";
153
154 std::map<int, std::string> final_map;
159 for(const auto &val: input){
160 std::size_t pos = std::string::npos;
161 int counter=0;
162 while (pos == std::string::npos && counter <3){
163 pos = val.find(keymap[counter]);
164 ++counter;
165 }
166
167 if(pos != std::string::npos) final_map[counter-1] =val.substr(pos+keymap[counter-1].size());
168 }
169
170 if(final_map.count(0) < 1) {
171 std::cout<<"Error. Not valid xml dictionary found launching the application"<<std::endl;
172 std::cout<<"Please run application_example_00001 --help for a brief guide on how to use it"<<std::endl;
173 exit(1);
174 }
175
176
178 InfoBitpodPP result;
179 result.dictName = final_map[0];
180
181 if(final_map.count(1)){
182 int check = -1 + int(final_map[1]=="quiet") + 2*int(final_map[1]=="normal") + 3*int(final_map[1]=="full");
183 if(check == -1) check = 2;
184 result.vlog = static_cast<Verbose>(check);
185 }
186
187 if(final_map.count(2)){
188 int check = -1 + int(final_map[2]=="quiet") + 2*int(final_map[2]=="normal") + 3*int(final_map[2]=="full");
189 if(check == -1) check = 1;
190 result.vconsole = static_cast<Verbose>(check);
191 }
192
193 return result;
194}
195
196//=================================================================================== //
197
224void read_podXML(const bitpit::Config::Section & slotXML, POD & podInst){
225
226 if(slotXML.hasOption("Directory")){
227 std::string input = slotXML.get("Directory");
228 input = bitpit::utils::string::trim(input);
229 std::string temp = ".";
230 if(!input.empty())
231 podInst.setDirectory(input);
232 else
233 podInst.setDirectory(temp);
234 }
235
236 if(slotXML.hasOption("Name")){
237 std::string input = slotXML.get("Name");
238 input = bitpit::utils::string::trim(input);
239 std::string temp = "pod";
240 if(!input.empty())
241 podInst.setName(input);
242 else
243 podInst.setName(temp);
244 }
245
246 if(slotXML.hasOption("MemoryMode")){
247 std::string input = slotXML.get("MemoryMode");
248 input = bitpit::utils::string::trim(input);
249 if(input =="MEMORY_LIGHT")
250 podInst.setMemoryMode(POD::MemoryMode::MEMORY_NORMAL);
251 else
252 podInst.setMemoryMode(POD::MemoryMode::MEMORY_NORMAL);
253 }
254
255 if(slotXML.hasOption("RunMode")){
256 std::string input = slotXML.get("RunMode");
257 input = bitpit::utils::string::trim(input);
258 if(input =="RESTORE")
259 podInst.setRunMode(POD::RunMode::RESTORE);
260 else
261 podInst.setRunMode(POD::RunMode::COMPUTE);
262 }
263
264 if(slotXML.hasOption("WriteMode")){
265 std::string input = slotXML.get("WriteMode");
266 input = bitpit::utils::string::trim(input);
267 if(input =="NONE")
268 podInst.setWriteMode(POD::WriteMode::NONE);
269 else if(input =="DEBUG")
270 podInst.setWriteMode(POD::WriteMode::DEBUG);
271 else
272 podInst.setWriteMode(POD::WriteMode::DUMP);
273 }
274
275 if(slotXML.hasOption("ReconstructionMode")){
276 std::string input = slotXML.get("ReconstructionMode");
277 input = bitpit::utils::string::trim(input);
278 if(input =="MINIMIZATION")
279 podInst.setReconstructionMode(POD::ReconstructionMode::MINIMIZATION);
280 else
281 podInst.setReconstructionMode(POD::ReconstructionMode::PROJECTION);
282 }
283
284 if(slotXML.hasOption("ErrorMode")){
285 std::string input = slotXML.get("ErrorMode");
286 input = bitpit::utils::string::trim(input);
287 if(input =="SINGLE")
288 podInst.setErrorMode(POD::ErrorMode::SINGLE);
289 else if(input =="COMBINED")
290 podInst.setErrorMode(POD::ErrorMode::COMBINED);
291 else
292 podInst.setErrorMode(POD::ErrorMode::NONE);
293 }
294
295 if(slotXML.hasOption("StaticMesh")){
296 std::string input = slotXML.get("StaticMesh");
297 input = bitpit::utils::string::trim(input);
298 bool value = false;
299 if(!input.empty()){
300 std::stringstream ss(input);
301 ss >> value;
302 }
303 podInst.setStaticMesh(value);
304 }
305
306 if(slotXML.hasOption("MeshType")){
307 std::string input = slotXML.get("MeshType");
308 input = bitpit::utils::string::trim(input);
309 if(input =="VOLOCTREE")
310 podInst.setMeshType(POD::MeshType::VOLOCTREE);
311 else
312 podInst.setMeshType(POD::MeshType::UNDEFINED);
313 }
314 else{
316 podInst.setMeshType(POD::MeshType::VOLOCTREE);
317 }
318
319 if(slotXML.hasOption("MeshDirectory")){
320 std::string meshDir = slotXML.get("MeshDirectory");
321 meshDir = bitpit::utils::string::trim(meshDir);
322 if(!meshDir.empty()){
323 if(slotXML.hasOption("MeshName")){
324 std::string meshName = slotXML.get("MeshName");
325 meshName = bitpit::utils::string::trim(meshName);
326 if(!meshName.empty()){
327 podInst.setMesh(meshDir, meshName);
328 }
329 }
330 }
331 }
332
333 if(slotXML.hasOption("Mean")){
334 std::string input = slotXML.get("Mean");
335 input = bitpit::utils::string::trim(input);
336 bool value = false;
337 if(!input.empty()){
338 std::stringstream ss(input);
339 ss >> value;
340 }
341 podInst.setUseMean(value);
342 }
343
344 if(slotXML.hasOption("Modes")){
345 std::string input = slotXML.get("Modes");
346 input = bitpit::utils::string::trim(input);
347 std::size_t temp = std::numeric_limits<std::size_t>::max();
348 if(!input.empty()){
349 std::stringstream ss(input);
350 ss>>temp;
351 }
352 podInst.setModeCount(temp);
353 }
354
355 if(slotXML.hasOption("Energy")){
356 std::string input = slotXML.get("Energy");
357 input = bitpit::utils::string::trim(input);
358 double temp = 100;
359 if(!input.empty()){
360 std::stringstream ss(input);
361 ss>>temp;
362 }
363 podInst.setEnergyLevel(temp);
364 }
365
367 if(slotXML.hasOption("ErrorThreshold")){
368 std::string input = slotXML.get("ErrorThreshold");
369 input = bitpit::utils::string::trim(input);
370 double temp = 0;
371 if(!input.empty()){
372 std::stringstream ss(input);
373 ss>>temp;
374 }
375 podInst.setErrorThreshold(temp);
376 }
377
378 std::vector<std::string> tempsf;
379 std::vector<std::array<std::string,3>> tempvf;
380
381 if(slotXML.hasOption("targetErrorScalarFields")){
382 std::string input = slotXML.get("targetErrorScalarFields");
383 input = bitpit::utils::string::trim(input);
384
385 if(!input.empty()){
386 std::stringstream ss(input);
387 ss>>tempsf;
388 }
389 }
390
391 if(slotXML.hasOption("targetErrorVectorFields")){
392 std::string input = slotXML.get("targetErrorVectorFields");
393 input = bitpit::utils::string::trim(input);
394
395 if(!input.empty()){
396 std::stringstream ss(input);
397 ss>>tempvf;
398 }
399
400 }
401 podInst.setTargetErrorFields(tempsf,tempvf);
402
403 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
404 log::cout()<< "Finished reading XML dictionary"<<std::endl;
405 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
406
408 {
409 std::vector<std::string> emode(2, "restore");
410 emode[1] = "compute";
411
412 std::vector<std::string> mmode(2, "normal");
413 emode[1] = "light";
414
415 std::vector<std::string> wmode(3, "dump");
416 wmode[1] = "debug";
417 wmode[2] = "none";
418
419 std::vector<std::string> rmode(2, "projection");
420 wmode[1] = "minimization";
421
422 std::vector<std::string> errmode(3, "combined");
423 wmode[1] = "single";
424 wmode[2] = "none";
425
426 log::cout()<< "Resume of arguments in "<< podInst.getName() << " : " << std::endl;
427 log::cout()<< "execution mode: "<<emode[static_cast<int>(podInst.getRunMode())]<<std::endl;
428 log::cout()<< "memory mode: "<<mmode[static_cast<int>(podInst.getMemoryMode())]<<std::endl;
429 log::cout()<< "write mode: "<<wmode[static_cast<int>(podInst.getWriteMode())]<<std::endl;
430 log::cout()<< "reconstruction mode: "<<rmode[static_cast<int>(podInst.getReconstructionMode())]<<std::endl;
431 log::cout()<< "error mode: "<<errmode[static_cast<int>(podInst.getErrorMode())]<<std::endl;
432 log::cout()<< "number of modes: "<<podInst.getModeCount()<<std::endl;
433 log::cout()<< "energy level: "<<podInst.getEnergyLevel()<<std::endl;
434 log::cout()<< "error threshold: "<<podInst.getErrorThreshold()<<std::endl;
435 log::cout()<< " "<<std::endl;
436 log::cout()<< " "<<std::endl;
437 }
438}
439
440//=================================================================================== //
441
454std::vector<bool> read_jobControlsXML(const bitpit::Config::Section & slotXML, POD & podInst){
455
456 BITPIT_UNUSED(podInst);
457
458 std::vector<bool> controls;
459 controls.resize(3,false);
460
461 if(slotXML.hasOption("doPODbasis")){
462 std::string input = slotXML.get("doPODbasis");
463 input = bitpit::utils::string::trim(input);
464 bool temp=true;
465 if(!input.empty()){
466 std::stringstream ss(input);
467 ss>>temp;
468 }
469 controls[0]=temp;
470 }
471 else
472 controls[0]=true;
473
474 if(slotXML.hasOption("doLeave1out")){
475 std::string input = slotXML.get("doLeave1out");
476 input = bitpit::utils::string::trim(input);
477 bool temp=false;
478 if(!input.empty()){
479 std::stringstream ss(input);
480 ss>>temp;
481 }
482 controls[1]=temp;
483 }
484
485 if(slotXML.hasOption("doBoundingBox")){
486 std::string input = slotXML.get("doBoundingBox");
487 input = bitpit::utils::string::trim(input);
488 bool temp=false;
489 if(!input.empty()){
490 std::stringstream ss(input);
491 ss>>temp;
492 }
493 controls[2]=temp;
494 }
495
496 return controls;
497
498}
499
500//=================================================================================== //
501
562std::vector<bool> read_Dictionary(POD & podInst) {
563
564 std::vector<bool> exeFlags;
565 exeFlags.resize(3,false);
566
567 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
568 log::cout()<< "Currently reading XML dictionary"<<std::endl;
569 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
570
571 if(config::root.hasSection("POD")){
572
573 bitpit::Config::Section & podXML = config::root.getSection("POD");
574
575 read_podXML(podXML, podInst);
576
577 log::cout() << "...Instantiated pod: "<< podInst.getName() << std::endl;
578
579 }else{
580 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
581 log::cout()<<"No POD section available in the XML dictionary"<<std::endl;
582 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
583 }
584
586 if(config::root.hasSection("Database")){
587
588 bitpit::Config::Section & blockXML = config::root.getSection("Database");
589
590 for(auto & sect : blockXML.getSections()){
591
592 std::string name = ".";
593 std::string path = ".";
594 std::size_t ns, first = 0;
595 std::size_t stride = 1;
596
597 name = sect.second->get("Case");
598 path = sect.second->get("Directory");
599 std::string nss = sect.second->get("NSnapshots");
600 std::stringstream ss(nss);
601 ss >> ns;
602 if(sect.second->hasOption("Stride")){
603 std::string sstride = sect.second->get("Stride");
604 std::stringstream ssstride(sstride);
605 ssstride >> stride;
606 }
607 if(sect.second->hasOption("FirstSnapshot")){
608 std::string sfirst = sect.second->get("FirstSnapshot");
609 std::stringstream ssfirst(sfirst);
610 ssfirst >> first;
611 }
612 for (std::size_t i = first; i < ns; i+=stride){
613 pod::SnapshotFile snap;
614 snap.directory = path;
615 snap.name = name + "." + std::to_string(i);
616 podInst.addSnapshot(snap);
617 }
618
619 }
620
621 }else{
622 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
623 log::cout()<<"No Database section available in the XML dictionary"<<std::endl;
624 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
625 }
626
628 if(config::root.hasSection("Reconstruction")){
629
630 bitpit::Config::Section & blockXML = config::root.getSection("Reconstruction");
631
632 for(auto & sect : blockXML.getSections()){
633
634 std::string name = ".";
635 std::string path = ".";
636 std::size_t ns, first = 0;
637 std::size_t stride = 1;
638
639 name = sect.second->get("Case");
640 path = sect.second->get("Directory");
641 std::string nss = sect.second->get("NSnapshots");
642 std::stringstream ss(nss);
643 ss >> ns;
644 if(sect.second->hasOption("Stride")){
645 std::string sstride = sect.second->get("Stride");
646 std::stringstream ssstride(sstride);
647 ssstride >> stride;
648 }
649 if(sect.second->hasOption("FirstSnapshot")){
650 std::string sfirst = sect.second->get("FirstSnapshot");
651 std::stringstream ssfirst(sfirst);
652 ssfirst >> first;
653 }
654
655 for (std::size_t i = first; i < ns; i+=stride){
656 pod::SnapshotFile snap;
657 snap.directory = path;
658 snap.name = name + "." + std::to_string(i);
659 podInst.addReconstructionSnapshot(snap);
660 }
661 }
662 }
663
665 if(config::root.hasSection("Leave1out")){
666 bitpit::Config::Section & blockXML = config::root.getSection("Leave1out");
667 for(auto & sect : blockXML.getSections()){
668
669 std::string name = ".";
670 std::string path = ".";
671 std::size_t ns, first = 0;
672 std::size_t stride = 1;
673
674 name = sect.second->get("Case");
675 path = sect.second->get("Directory");
676 std::string nss = sect.second->get("NSnapshots");
677 std::stringstream ss(nss);
678 ss >> ns;
679
680 if(sect.second->hasOption("Stride")){
681 std::string sstride = sect.second->get("Stride");
682 std::stringstream ssstride(sstride);
683 ssstride >> stride;
684 }
685 if(sect.second->hasOption("FirstSnapshot")){
686 std::string sfirst = sect.second->get("FirstSnapshot");
687 std::stringstream ssfirst(sfirst);
688 ssfirst >> first;
689 }
690
691 for (std::size_t i = first; i < ns; i+=stride){
692 pod::SnapshotFile snap;
693 snap.directory = path;
694 snap.name = name + "." + std::to_string(i);
695 podInst.removeLeave1outSnapshot(snap);
696 }
697 }
698 }
699
700 if(config::root.hasSection("JobControls")){
701 bitpit::Config::Section & jobXML = config::root.getSection("JobControls");
702 exeFlags=read_jobControlsXML(jobXML, podInst);
703 }else
704 exeFlags[0]=true;
705
706 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
707 log::cout()<< "Finished reading XML dictionary"<<std::endl;
708 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
709
710 return exeFlags;
711
712}
713
714
715// =================================================================================== //
716
718void podcore(const InfoBitpodPP & info) {
720 std::string log = "bitpit";
721 bitpit::log::cout(log);
722 switch(int(info.vconsole)){
723 case 1 :
724 bitpit::log::setConsoleVerbosity(log::cout(), bitpit::log::LEVEL_INFO);
725 break;
726 case 2 :
727 bitpit::log::setConsoleVerbosity(log::cout(), bitpit::log::LEVEL_DEBUG);
728 break;
729 case 0 :
730 bitpit::log::setConsoleVerbosity(log::cout(), bitpit::log::LEVEL_QUIET);
731 break;
732 default:
733 break;
734 }
735
736 switch(int(info.vlog)){
737 case 1 :
738 bitpit::log::setFileVerbosity(log::cout(), bitpit::log::LEVEL_INFO);
739 break;
740 case 2 :
741 bitpit::log::setFileVerbosity(log::cout(), bitpit::log::LEVEL_DEBUG);
742 break;
743 case 0 :
744 bitpit::log::setFileVerbosity(log::cout(), bitpit::log::LEVEL_QUIET);
745 break;
746 default:
747 break;
748
749 }
750
752 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
753 {
754 std::vector<std::string> verb(3, "quiet");
755 verb[1] = "normal";
756 verb[2] = "full";
757
758 log::cout()<< "Resume of arguments:"<<std::endl;
759 log::cout()<< "dictionary: "<<info.dictName<<std::endl;
760 log::cout()<< "console verbosity: "<<verb[static_cast<int>(info.vconsole)]<<std::endl;
761 log::cout()<< "log file verbosity: "<<verb[static_cast<int>(info.vlog)]<<std::endl;
762 log::cout()<< " "<<std::endl;
763 log::cout()<< " "<<std::endl;
764 }
765 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
766
767 bitpit::config::reset("podXML", 1);
768 bitpit::config::read(info.dictName);
769
770 POD podInst;
771
773 std::vector<bool> exes;
774 exes=read_Dictionary(podInst);
775
777 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
778 log::cout()<<"Execution of pod... ";
779 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
780
782 if (exes[1])
783 podInst.leave1out();
784
785 if (exes[2])
786 podInst.evalErrorBoundingBox();
787
788 if (exes[0])
789 podInst.run();
790
791 log::cout().setDefaultSeverity(bitpit::log::LEVEL_INFO);
792 log::cout()<<"...execution of pod done"<<std::endl;
793
794 log::cout().setDefaultSeverity(bitpit::log::DEBUG);
795}
796
797//=================================================================================== //
798
799int main( int argc, char *argv[] ) {
800
801#if BITPIT_ENABLE_MPI
802 MPI_Init(&argc, &argv);
803
804 {
805#endif
806 try{
808 InfoBitpodPP info = readArguments(argc, argv);
809 podcore(info);
810 }
811 catch(std::exception & e){
812 std::cout<<"application_example_00001 exited with an error of type : "<<e.what()<<std::endl;
813 return 1;
814 }
815
816#if BITPIT_ENABLE_MPI
817 }
818
819 MPI_Finalize();
820#endif
821
822 return 0;
823}
bitpit::Config
Configuration storage.
Definition configuration_config.hpp:36
bitpit::Config::get
const std::string & get(const std::string &key) const
Definition configuration_config.cpp:154
bitpit::Config::getSection
Section & getSection(const std::string &key)
Definition configuration_config.cpp:299
bitpit::Config::hasOption
bool hasOption(const std::string &key) const
Definition configuration_config.cpp:141
bitpit::Logger::setDefaultSeverity
void setDefaultSeverity(log::Level severity)
Definition logger.cpp:537
bitpit::POD
The POD (Proper Orthogonal Decomposition) class provides an interface for defining POD object.
Definition pod.hpp:41
bitpit::POD::setErrorThreshold
void setErrorThreshold(double threshold)
Definition pod.cpp:346
bitpit::POD::getModeCount
std::size_t getModeCount()
Definition pod.cpp:315
bitpit::POD::run
void run()
Definition pod.cpp:836
bitpit::POD::setRunMode
void setRunMode(RunMode mode)
Definition pod.cpp:542
bitpit::POD::setTargetErrorFields
void setTargetErrorFields(std::vector< std::string > &namesf, std::vector< std::array< std::string, 3 > > &namevf)
Definition pod.cpp:367
bitpit::POD::setMeshType
void setMeshType(MeshType type)
Definition pod.cpp:390
bitpit::POD::setStaticMesh
void setStaticMesh(bool flag)
Definition pod.cpp:483
bitpit::POD::setMemoryMode
void setMemoryMode(MemoryMode mode)
Definition pod.cpp:505
bitpit::POD::getErrorThreshold
double getErrorThreshold()
Definition pod.cpp:356
bitpit::POD::setDirectory
void setDirectory(const std::string &directory)
Definition pod.cpp:180
bitpit::POD::getEnergyLevel
double getEnergyLevel()
Definition pod.cpp:336
bitpit::POD::getName
const std::string & getName()
Definition pod.cpp:170
bitpit::POD::getRunMode
RunMode getRunMode()
Definition pod.cpp:566
bitpit::POD::leave1out
void leave1out()
Definition pod.cpp:1121
bitpit::POD::getReconstructionMode
ReconstructionMode getReconstructionMode()
Definition pod.cpp:623
bitpit::POD::evalErrorBoundingBox
void evalErrorBoundingBox()
Definition pod.cpp:1503
bitpit::POD::getMemoryMode
MemoryMode getMemoryMode()
Definition pod.cpp:530
bitpit::POD::setUseMean
void setUseMean(bool flag)
Definition pod.cpp:493
bitpit::POD::addReconstructionSnapshot
void addReconstructionSnapshot(const std::string &directory, const std::string &name)
Definition pod.cpp:282
bitpit::POD::removeLeave1outSnapshot
void removeLeave1outSnapshot(const std::string &directory, const std::string &name)
Definition pod.cpp:243
bitpit::POD::setWriteMode
void setWriteMode(WriteMode mode)
Definition pod.cpp:576
bitpit::POD::getErrorMode
ErrorMode getErrorMode()
Definition pod.cpp:648
bitpit::POD::setReconstructionMode
void setReconstructionMode(ReconstructionMode mode)
Definition pod.cpp:598
bitpit::POD::setEnergyLevel
void setEnergyLevel(double energy)
Definition pod.cpp:326
bitpit::POD::setModeCount
void setModeCount(std::size_t nmodes)
Definition pod.cpp:304
bitpit::POD::setName
void setName(const std::string &name)
Definition pod.cpp:160
bitpit::POD::getWriteMode
WriteMode getWriteMode()
Definition pod.cpp:587
bitpit::POD::setErrorMode
void setErrorMode(ErrorMode mode)
Definition pod.cpp:635
bitpit::POD::setMesh
void setMesh(const std::string &directory, const std::string &name)
Definition pod.cpp:443
bitpit::POD::addSnapshot
void addSnapshot(const std::string &directory, const std::string &name)
Definition pod.cpp:208
BITPIT_UNUSED
#define BITPIT_UNUSED(variable)
Definition compiler.hpp:63
bitpit::utils::string::trim
std::string & trim(std::string &s)
Definition stringUtils.tpp:98
bitpit::config::root
GlobalConfigParser & root
Definition configuration.cpp:353
bitpit::config::reset
void reset(const std::string &rootName)
Definition configuration.cpp:361
bitpit::config::read
void read(const std::string &filename, bool append)
Definition configuration.cpp:401
bitpit::dgf::check
unsigned int check(std::ifstream &, std::vector< std::vector< int > > &)
Definition DGF.cpp:1169
bitpit::log::cout
Logger & cout(log::Level defaultSeverity, log::Visibility defaultVisibility)
Definition logger.cpp:1705
bitpit::log::setFileVerbosity
Logger & setFileVerbosity(Logger &logger, const log::Level &threshold)
Definition logger.cpp:2105
bitpit::log::info
Logger & info(log::Visibility defaultVisibility)
Definition logger.cpp:1847
bitpit::log::setConsoleVerbosity
Logger & setConsoleVerbosity(Logger &logger, const log::Level &threshold)
Definition logger.cpp:2078
InfoBitpodPP
database of essential information absorbed from the custom arguments
Definition POD_application_example_00001.cpp:64
InfoBitpodPP::InfoBitpodPP
InfoBitpodPP(const InfoBitpodPP &other)
Definition POD_application_example_00001.cpp:80
InfoBitpodPP::operator=
InfoBitpodPP & operator=(const InfoBitpodPP &other)
Definition POD_application_example_00001.cpp:85
bitpit::pod::SnapshotFile
The SnapFile structure is used to store the file names inside POD classes.
Definition pod_common.hpp:46
--- layout: doxygen_footer ---
Generated on Wed Jun 19 2024 10:21:04 for bitpit by   doxygen 1.10.0