1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/* Copyright 2019-2020 Axel Huebl, David Grote, Luca Fedeli
* Remi Lehe, Weiqun Zhang, Yinjian Zhao
*
*
* This file is part of WarpX.
*
* License: BSD-3-Clause-LBNL
*/
#include "WarpXAlgorithmSelection.H"
#include <algorithm>
#include <cstring>
#include <map>
// Define dictionary with correspondance between user-input strings,
// and corresponding integer for use inside the code
const std::map<std::string, int> maxwell_solver_algo_to_int = {
{"yee", MaxwellSolverAlgo::Yee },
#ifndef WARPX_DIM_RZ // Not available in RZ
{"ckc", MaxwellSolverAlgo::CKC },
#endif
{"default", MaxwellSolverAlgo::Yee }
};
const std::map<std::string, int> electrostatic_solver_algo_to_int = {
{"none", ElectrostaticSolverAlgo::None },
{"relativistic", ElectrostaticSolverAlgo::Relativistic},
{"labframe", ElectrostaticSolverAlgo::LabFrame},
{"default", ElectrostaticSolverAlgo::None }
};
const std::map<std::string, int> particle_pusher_algo_to_int = {
{"boris", ParticlePusherAlgo::Boris },
{"vay", ParticlePusherAlgo::Vay },
{"higuera", ParticlePusherAlgo::HigueraCary },
{"default", ParticlePusherAlgo::Boris }
};
const std::map<std::string, int> current_deposition_algo_to_int = {
{"esirkepov", CurrentDepositionAlgo::Esirkepov },
{"direct", CurrentDepositionAlgo::Direct },
{"vay", CurrentDepositionAlgo::Vay },
#ifdef WARPX_USE_PSATD
{"default", CurrentDepositionAlgo::Direct }
#else
{"default", CurrentDepositionAlgo::Esirkepov }
#endif
};
const std::map<std::string, int> charge_deposition_algo_to_int = {
{"standard", ChargeDepositionAlgo::Standard },
{"default", ChargeDepositionAlgo::Standard }
};
const std::map<std::string, int> gathering_algo_to_int = {
{"energy-conserving", GatheringAlgo::EnergyConserving },
{"momentum-conserving", GatheringAlgo::MomentumConserving },
{"default", GatheringAlgo::EnergyConserving }
};
const std::map<std::string, int> load_balance_costs_update_algo_to_int = {
{"timers", LoadBalanceCostsUpdateAlgo::Timers },
{"heuristic", LoadBalanceCostsUpdateAlgo::Heuristic },
{"default", LoadBalanceCostsUpdateAlgo::Timers }
};
const std::map<std::string, int> MaxwellSolver_medium_algo_to_int = {
{"vacuum", MediumForEM::Vacuum},
{"macroscopic", MediumForEM::Macroscopic},
{"default", MediumForEM::Vacuum}
};
const std::map<std::string, int> MacroscopicSolver_algo_to_int = {
{"backwardeuler", MacroscopicSolverAlgo::BackwardEuler},
{"laxwendroff", MacroscopicSolverAlgo::LaxWendroff},
{"default", MacroscopicSolverAlgo::BackwardEuler},
};
int
GetAlgorithmInteger( amrex::ParmParse& pp, const char* pp_search_key ){
// Read user input ; use "default" if it is not found
std::string algo = "default";
pp.query( pp_search_key, algo );
// Convert to lower case
std::transform(algo.begin(), algo.end(), algo.begin(), ::tolower);
// Pick the right dictionary
std::map<std::string, int> algo_to_int;
if (0 == std::strcmp(pp_search_key, "maxwell_solver")) {
algo_to_int = maxwell_solver_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "do_electrostatic")) {
algo_to_int = electrostatic_solver_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "particle_pusher")) {
algo_to_int = particle_pusher_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "current_deposition")) {
algo_to_int = current_deposition_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "charge_deposition")) {
algo_to_int = charge_deposition_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "field_gathering")) {
algo_to_int = gathering_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "load_balance_costs_update")) {
algo_to_int = load_balance_costs_update_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "em_solver_medium")) {
algo_to_int = MaxwellSolver_medium_algo_to_int;
} else if (0 == std::strcmp(pp_search_key, "macroscopic_sigma_method")) {
algo_to_int = MacroscopicSolver_algo_to_int;
} else {
std::string pp_search_string = pp_search_key;
amrex::Abort("Unknown algorithm type: " + pp_search_string);
}
// Check if the user-input is a valid key for the dictionary
if (algo_to_int.count(algo) == 0) {
// Not a valid key ; print error message
std::string pp_search_string = pp_search_key;
std::string error_message = "Invalid string for algo." + pp_search_string
+ ": " + algo + ".\nThe valid values are:\n";
for ( const auto &valid_pair : algo_to_int ) {
if (valid_pair.first != "default"){
error_message += " - " + valid_pair.first + "\n";
}
}
amrex::Abort(error_message);
}
// If the input is a valid key, return the value
return algo_to_int[algo];
}
|
