OSHUN  beta
Arbitrary Order Spherical-Harmonic 1D-3P Vlasov-Fokker-Planck-Maxwell code
main.cpp
Go to the documentation of this file.
1 
13 // Standard libraries
14 #include <mpi.h>
15 #include <iostream>
16 #include <vector>
17 #include <valarray>
18 #include <complex>
19 
20 #include <time.h>
21 #include <math.h>
22 #include <stdio.h>
23 #include <float.h>
24 #include <stdarg.h>
25 
26 
27 #include <map>
28 #include <string>
29 #include <iomanip>
30 #include <fstream>
31 #include <cstdlib>
32 #include <sstream>
33 #include <cstring>
34 #include <ctime>
35 
36 
37 // My libraries
38 #include "lib-array.h"
39 #include "lib-algorithms.h"
40 #include "H5Cpp.h"
41 #include "exprtk.hpp"
42 
43 // Misc Declerations
44 #include "input.h"
45 #include "state.h"
46 #include "formulary.h"
47 #include "setup.h"
48 #include "fluid.h"
49 #include "vlasov.h"
50 #include "collisions.h"
51 #include "functors.h"
52 #include "parallel.h"
53 #include "implicitE.h"
54 
55 #include "export.h"
56 
57 
58 
59 //--------------------------------------------------------------
60 //**************************************************************
61 
62 //----------------------------------------------------------------------------------------------------------------------------
63  double startmessages(State1D& Y){
64 
65  Formulary formulas;
66  // double Tref = Input::List().pth_ref*Input::List().pth_ref;
67  double ND = 1.72e9*sqrt(pow(formulas.T0,3.0)/formulas.n);
68  double nuei_wp = sqrt(2.0/Formulary::pi)/9.0/ND*
69  formulas.LOGei(1.0,pow(Input::List().pth_ref,2.0),formulas.Zeta)*formulas.Zeta;
70 
71  double nu_ei = nuei_wp * formulas.wp;
72  double dt_out(Input::List().t_stop / Input::List().n_outsteps);
73  double CLF(Input::List().clf_dp);
74  size_t n_outsteps(Input::List().n_outsteps);
75  double numh = size_t(static_cast<int>(dt_out/CLF))+1;
76  double h = dt_out/static_cast<double>(numh);
77 
78 
79  std::cout << "\n\n";
80  std::cout<< "------- ---------------- */*/*/*/*/* ---------------- -------\n";
81  std::cout<< "------- ,-----. ,---. ,--. ,--.,--. ,--.,--. ,--. -------\n";
82  std::cout<< "-------' .-. '' .-' | '--' || | | || ,'.| | -------\n";
83  std::cout<< "-------| | | |`. `-. | .--. || | | || |' ' | -------\n";
84  std::cout<< "-------' '-' '.-' || | | |' '-' '| | ` | -------\n";
85  std::cout<< "------- `-----' `-----' `--' `--' `-----' `--' `--' -------\n";
86  std::cout<< "------- ---------------- */*/*/*/*/* ---------------- -------\n";
87 
88 
89 
90  std::cout << "\n\n";
91  std::cout << "---------------- OSHUN Beta - 1D 3P ---------------- \n";
92  std::cout << " Particle-in-Cell and Kinetic Simulation Center \n";
93  std::cout << "------------------- UCLA - 2017 -------------------- \n";
94 
95  std::cout << "----------------- Reference Units ------------------ \n";
96  std::cout << "normalizing density = " << formulas.n << " / cc \n";
97  std::cout << "plasma frequency = " << formulas.wp << " Hz \n";
98  std::cout << "background ions - Z = " << formulas.Zeta << " \n";
99  std::cout << "normalizing magnetic field = " << formulas.B0 << " T \n";
100  std::cout << "Reference Temperature = " << formulas.T0 << " eV \n";
101  std::cout << "Corresponding thermal velocity = " << Input::List().pth_ref*Formulary::cL << " m/s \n";
102 
103  std::cout << "\n";
104  std::cout << "Corresponding e-i log Lambda = " << formulas.LOGei(1.0,pow(Input::List().pth_ref,2.0),formulas.Zeta) << " \n";
105  std::cout << "Corresponding e-i collision frequency = " << nu_ei << " Hz \n";
106  std::cout << "Corresponding tau_e-i / tau_p = " << 1.0/nuei_wp << " \n";
107  std::cout << "Corresponding e-i mean free path = " << Input::List().pth_ref*Formulary::cL/nu_ei *1e6<< " microns \n";
108 
109  std::cout << "\n";
110  std::cout << "Corresponding e-e log Lambda = " << formulas.LOGee(1.0,pow(Input::List().pth_ref,2.0)) << " \n";
111  std::cout << "Corresponding e-e collision frequency = " << 1.0/formulas.Tau_e(1.0,pow(Input::List().pth_ref,2.0)) << " Hz \n";
112  // std::cout << "Corresponding thermal mean free path =" << Input::List().pth_ref/cL / nu_ei << "\n";
113  // std::cout << "Corresponding thermal velocity c =" << pow(Input::List().pth_ref*cL,2.0)*0.5*me << "\n";
114  std::cout << "\n";
115  std::cout << "\n";
116  std::cout << "-------------- Simulation parameters -------------- \n";
117  std::cout << "skin depth (normalizing distance) = " << formulas.skindepth*1e6 << " microns \n";
118  std::cout << "plasma period (normalizing time) = " << 1.0/formulas.wp*1e15 << " fs \n";
119  std::cout << "Time step (normalizing time) = " << h << " plasma periods \n";
120  std::cout << "\n";
121  std::cout << "\n";
122 
123 
124 
125  return 1.0/formulas.wp*1e15;
126  }
127 
128 //**************************************************************
129 int main(int argc, char** argv) {
130 
131  MPI_Init(&argc,&argv);
132 
134  Parallel_Environment_1D PE;
135 
136  time_t tstart, tend;
137  tstart = time(0);
138 
139 
142  Grid_Info grid(Input::List().ls, Input::List().ms,
143  Input::List().mass, Input::List().qs,
144  Input::List().xminLocal, Input::List().xmaxLocal, Input::List().NxLocal,
145  Input::List().xminGlobal, Input::List().xmaxGlobal, Input::List().NxGlobal,
146  Input::List().pmax, Input::List().ps, Input::List().Npx, Input::List().Npy, Input::List().Npz);
147 
148 
150  int tout_start;
151  if (Input::List().isthisarestart) tout_start = Input::List().restart_time;
152  else tout_start = 0;
153 
154  double dt_out(Input::List().t_stop / Input::List().n_outsteps);
155  double CLF(Input::List().clf_dp);
156  size_t n_outsteps(Input::List().n_outsteps);
157  double numh = size_t(static_cast<int>(dt_out/CLF))+1;
158  double h = dt_out/static_cast<double>(numh);
159 
161  if (PE.RANK() == 0) {
162  Export_Files::Folders();
163  }
164 
165  Export_Files::Restart_Facility Re(PE.RANK());
166 
167  State1D Y( grid.axis.Nx(0), Input::List().ls, Input::List().ms, grid.Np, Input::List().pmax, grid.charge, grid.mass, Input::List().hydromass, Input::List().hydrocharge);
168  Y = 0.0;
169  Setup_Y::initialize(Y, grid);
170 
171 
172  collisions collide(Y,h);
173 // InverseBremsstrahlung IB(Y.DF(0).pmax(),Y.SH(0,0,0).nump(),Y.SH(0,0,0).numx(),tout_start,grid.axis.x(0));
174  Hydro_Functor HydroFunc(grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
175 
176  Algorithms::RK3<State1D> RK(Y);
177 
178  // Algorithms::LEAPs<State1D> LEAP(Y);
179  // Algorithms::PEFRL<State1D> MAGIC(Y);
180 
181 
182  if (Input::List().isthisarestart) Re.Read(PE.RANK(),tout_start,Y);
183 
184  Output_Data::Output_Preprocessor_1D output( grid, Input::List().oTags);
185  output( Y, grid, tout_start, PE );
186  output.distdump(Y, grid, tout_start, PE );
187 
188 
189  double plasmaperiod;
190  if (!(PE.RANK())){
191  plasmaperiod = startmessages(Y);
192  }
193 
194 // --------------------------------------------------------------------------------------------------------------------------------
195 // --------------------------------------------------------------------------------------------------------------------------------
196 // --------------------------------------------------------------------------------------------------------------------------------
197 // ITERATION LOOP
198 // --------------------------------------------------------------------------------------------------------------------------------
199 // --------------------------------------------------------------------------------------------------------------------------------
200  if (Input::List().implicit_B) {
201  if (Input::List().implicit_E) {
202  // --------------------------------------------------------------------------------------------------------------------------------
203  // --------------------------------------------------------------------------------------------------------------------------------
204  // --------------------------------------------------------------------------------------------------------------------------------
205  // IMPLICIT E-FIELD
206  // --------------------------------------------------------------------------------------------------------------------------------
207  VlasovFunctor1D_implicitE_implicitB_p1 impE_p1_Functor(Input::List().ls, Input::List().ms, Input::List().pmax,
208  Input::List().ps,
209  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
210 
211  VlasovFunctor1D_implicitE_p2 impE_p2_Functor(Input::List().ls, Input::List().ms, Input::List().pmax,
212  Input::List().ps,
213  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
214 
215 // Magnetic_Field_1D Bfield(Input::List().ls[0], Input::List().ms[0], Input::List().pmax[0]/(2.0*Input::List().ps[0]-1), Input::List().pmax[0],
216 // Input::List().ps[0],
217 // grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
218 
219 
220  Magnetic_Field_1D Bfield(Input::List().ls[0], Input::List().ms[0],
221  0.0, Input::List().pmax[0], Input::List().ps[0],
222  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
223 
224 
225 
226  // --------------------------------------------------------------------------------------------------------------------------------
227  using Electric_Field_Methods::Efield_Method;
228  Electric_Field_Methods::Implicit_E_Field eim(Y.EMF(), h,
229  (grid.axis.xmax(0) - grid.axis.xmin(0)) / grid.axis.Nx(0));
230 
231  if (!Input::List().collisions) {
232  if (!PE.RANK())
233  std::cout << "\n Need collisions for implicit E field solver. \n Exiting. \n";
234  exit(0);
235  }
236 
237  for (size_t t_out(tout_start + 1); t_out < n_outsteps + 1; ++t_out) {
238  // --------------------------------------------------------------------------------------------------------------------------------
239  for (Clock W(t_out - 1, dt_out, CLF); W.tick() < W.numh(); ++W) {
240  // --------------------------------------------------------------------------------------------------------------------------------
241  // if (!(PE.RANK())) {
242  // // cout << "Time = " << W.time()<< "\n";
243  // printf("\r Time = %4.4f tau_p = %4.4f fs", W.time(), W.time() * plasmaperiod);
244  // fflush(stdout);
245  // }
246  // --------------------------------------------------------------------------------------------------------------------------------
247  // --------------------------------------------------------------------------------------------------------------------------------
248  // --------------------------------------------------------------------------------------------------------------------------------
249  // --------------------------------------------------------------------------------------------------------------------------------
250  // the guts
251  // --------------------------------------------------------------------------------------------------------------------------------
252  if (Input::List().ext_fields) Setup_Y::applyexternalfields(grid, Y, W.time());
253 
254  Y = RK(Y, W.h(),&impE_p1_Functor);
255  PE.Neighbor_ImplicitE_Communications(Y);
256  eim.advance(&RK, Y, collide,&impE_p2_Functor);
257  Y = RK(Y, W.h(),&impE_p2_Functor);
258 
260  for (size_t s(0); s < Y.Species(); ++s)
261  {
262  Bfield.implicit(Y.DF(s),Y.EMF().Bx(),Y.EMF().By(),Y.EMF().Bz(),W.h());
263  Y.DF(s) = Y.DF(s).Filterp();
264  }
265 
266  collide.advance(Y,W);
267 
268  if (Input::List().hydromotion)
269  Y = RK(Y, W.h(), &HydroFunc);
270  PE.Neighbor_Communications(Y);
272  // --------------------------------------------------------------------------------------------------------------------------------
273  // --------------------------------------------------------------------------------------------------------------------------------
274  // --------------------------------------------------------------------------------------------------------------------------------
275  // --------------------------------------------------------------------------------------------------------------------------------
276  // --------------------------------------------------------------------------------------------------------------------------------
277  }
278 
279  if (!(PE.RANK())) cout << " \n Output #" << t_out << "\n";
280  output(Y, grid, t_out, PE);
281  Y.checknan();
282 
283  if (!(t_out%Input::List().n_distoutsteps))
284  output.distdump(Y, grid, t_out, PE);
285  }
286  } else {
287  // --------------------------------------------------------------------------------------------------------------------------------
288  // --------------------------------------------------------------------------------------------------------------------------------
289  // --------------------------------------------------------------------------------------------------------------------------------
290  // EXPLICIT E-FIELD
291  // --------------------------------------------------------------------------------------------------------------------------------
292  VlasovFunctor1D_explicitE_implicitB rkF(Input::List().ls, Input::List().ms, Input::List().pmax, Input::List().ps,
293  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
294 
295  Magnetic_Field_1D Bfield(Input::List().ls[0], Input::List().ms[0],
296  0.0, Input::List().pmax[0], Input::List().ps[0],
297  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
298 
299  // --------------------------------------------------------------------------------------------------------------------------------
300  for (size_t t_out(tout_start + 1); t_out < n_outsteps + 1; ++t_out) {
301  for (Clock W(t_out - 1, dt_out, CLF); W.tick() < W.numh(); ++W) {
302  // --------------------------------------------------------------------------------------------------------------------------------
303  // if (!(PE.RANK())) {
304 
305  // printf("\r Time = %4.4f tau_p = %4.4f fs", W.time(), W.time() * plasmaperiod);
306  // fflush(stdout);
307  // }
308  // --------------------------------------------------------------------------------------------------------------------------------
309  // the guts
310  // --------------------------------------------------------------------------------------------------------------------------------
311 
312  if (Input::List().ext_fields) Setup_Y::applyexternalfields(grid, Y, W.time());
313 
314  Y = RK(Y, W.h(), &rkF);
315 
316  for (size_t s(0); s < Y.Species(); ++s)
317  {
318  Bfield.implicit(Y.DF(s),Y.EMF().Bx(),Y.EMF().By(),Y.EMF().Bz(),W.h());
319  Y.DF(s) = Y.DF(s).Filterp();
320  }
321 
322  if (Input::List().collisions)
323  collide.advance(Y,W);
324 
325  if (Input::List().hydromotion)
326  Y = RK(Y, W.h(), &HydroFunc);
327 
328  PE.Neighbor_Communications(Y);
329  }
330 
331  if (!(PE.RANK())) cout << " \n Output #" << t_out << "\n";
332  output(Y, grid, t_out, PE);
333  Y.checknan();
334 
335  if (!(t_out%Input::List().n_distoutsteps))
336  output.distdump(Y, grid, t_out, PE);
337 
338 
339  }
340  }
341  }
342  else {
343  if (Input::List().implicit_E) {
344  // --------------------------------------------------------------------------------------------------------------------------------
345  // --------------------------------------------------------------------------------------------------------------------------------
346  // --------------------------------------------------------------------------------------------------------------------------------
347  // IMPLICIT E-FIELD
348  // --------------------------------------------------------------------------------------------------------------------------------
349  VlasovFunctor1D_implicitE_p1 impE_p1_Functor(Input::List().ls, Input::List().ms, Input::List().pmax,
350  Input::List().ps,
351  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
352  VlasovFunctor1D_implicitE_p2 impE_p2_Functor(Input::List().ls, Input::List().ms, Input::List().pmax,
353  Input::List().ps,
354  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
355  // --------------------------------------------------------------------------------------------------------------------------------
356  using Electric_Field_Methods::Efield_Method;
357  Electric_Field_Methods::Implicit_E_Field eim(Y.EMF(), h,
358  (grid.axis.xmax(0) - grid.axis.xmin(0)) / grid.axis.Nx(0));
359 
360  if (!Input::List().collisions) {
361  if (!PE.RANK())
362  std::cout << "\n Need collisions for implicit E field solver. \n Exiting. \n";
363  exit(0);
364  }
365 
366  for (size_t t_out(tout_start + 1); t_out < n_outsteps + 1; ++t_out) {
367  // --------------------------------------------------------------------------------------------------------------------------------
368  for (Clock W(t_out - 1, dt_out, CLF); W.tick() < W.numh(); ++W) {
369  // --------------------------------------------------------------------------------------------------------------------------------
370  // if (!(PE.RANK())) {
371  // // cout << "Time = " << W.time()<< "\n";
372  // printf("\r Time = %4.4f tau_p = %4.4f fs", W.time(), W.time() * plasmaperiod);
373  // fflush(stdout);
374  // }
375  // --------------------------------------------------------------------------------------------------------------------------------
376  // --------------------------------------------------------------------------------------------------------------------------------
377  // --------------------------------------------------------------------------------------------------------------------------------
378  // --------------------------------------------------------------------------------------------------------------------------------
379  // the guts
380  // --------------------------------------------------------------------------------------------------------------------------------
381  if (Input::List().ext_fields) Setup_Y::applyexternalfields(grid, Y, W.time());
382 
383  Y = RK(Y, W.h(),
384  &impE_p1_Functor);
385  PE.Neighbor_ImplicitE_Communications(Y);
386  eim.advance(&RK, Y, collide,
387  &impE_p2_Functor);
388  Y = RK(Y, W.h(),
389  &impE_p2_Functor);
390  collide.advance(Y,W);
391 // if (Input::List().inverse_bremsstrahlung)
392 // IB.loop(Y.SH(0, 0, 0), Y.HYDRO().Zarray(), W.time()); /// Explicit IB heating for f00
393  if (Input::List().hydromotion)
394  Y = RK(Y, W.h(), &HydroFunc);
395  // Y.checknan(); /// Error Checking
396  PE.Neighbor_Communications(
397  Y);
398  // --------------------------------------------------------------------------------------------------------------------------------
399  // --------------------------------------------------------------------------------------------------------------------------------
400  // --------------------------------------------------------------------------------------------------------------------------------
401  // --------------------------------------------------------------------------------------------------------------------------------
402  // --------------------------------------------------------------------------------------------------------------------------------
403  }
404 
405  if (!(PE.RANK())) cout << " \n Output #" << t_out << "\n";
406  output(Y, grid, t_out, PE);
407  Y.checknan();
408 
409  if (!(t_out%Input::List().n_distoutsteps))
410  output.distdump(Y, grid, t_out, PE);
411  }
412  } else {
413  // --------------------------------------------------------------------------------------------------------------------------------
414  // --------------------------------------------------------------------------------------------------------------------------------
415  // --------------------------------------------------------------------------------------------------------------------------------
416  // EXPLICIT E-FIELD
417  // --------------------------------------------------------------------------------------------------------------------------------
418  VlasovFunctor1D_explicitE rkF(Input::List().ls, Input::List().ms, Input::List().pmax, Input::List().ps,
419  grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
420 
421  // VlasovFunctor1D_spatialpush SA(Input::List().ls, Input::List().ms, Input::List().pmax, Input::List().ps,
422  // grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
423 
424  // VlasovFunctor1D_momentumpush PA(Input::List().ls, Input::List().ms, Input::List().pmax, Input::List().ps,
425  // grid.axis.xmin(0), grid.axis.xmax(0), grid.axis.Nx(0));
426  // --------------------------------------------------------------------------------------------------------------------------------
427  for (size_t t_out(tout_start + 1); t_out < n_outsteps + 1; ++t_out) {
428  for (Clock W(t_out - 1, dt_out, CLF); W.tick() < W.numh(); ++W) {
429 
430  // --------------------------------------------------------------------------------------------------------------------------------
431  // if (!(PE.RANK())) {
432 
433  // printf("\r Time = %4.4f tau_p = %4.4f fs", W.time(), W.time() * plasmaperiod);
434 
435 
436  // }
437  // --------------------------------------------------------------------------------------------------------------------------------
438  // the guts
439  // --------------------------------------------------------------------------------------------------------------------------------
440 
441  if (Input::List().ext_fields) Setup_Y::applyexternalfields(grid, Y, W.time());
442  // if (Input::List().ext_fields) Setup_Y::applyexternalfields(grid, Y, t);
443  if (Input::List().trav_wave) Setup_Y::applytravelingwave(grid, Y, W.time());
444 
445  Y = RK(Y, W.h(), &rkF);
446  // Y = LEAP(Y, W.h(), &SA, &PA); /// Vlasov //
447  // Y = MAGIC(Y, W.h(), &SA, &PA); /// Vlasov //
448  if (Input::List().collisions)
449  collide.advance(Y,W);
450 
451  if (Input::List().hydromotion)
452  Y = RK(Y, W.h(), &HydroFunc);
453 
454  PE.Neighbor_Communications(Y);
455  }
456 
457 
458  if (!(PE.RANK())) cout << " \n Output #" << t_out << "\n";
459 
460  output(Y, grid, t_out, PE);
461  Y.checknan();
462 
463  if (!(t_out%Input::List().n_distoutsteps))
464  output.distdump(Y, grid, t_out, PE);
465 
466  if (!(t_out%Input::List().n_restarts))
467  Re.Write(PE.RANK(), t_out, Y);
468  }
469  }
470  }
471  tend = time(0);
472  if (!(PE.RANK())){
473  cout << "Simulation took "<< difftime(tend, tstart) <<" second(s)."<< endl;
474  }
475  MPI_Finalize();
476  return 0;
477 }
478 //**************************************************************
479 //---------------------------------------------------------------------------
lib-algorithms.h
Algorithms
formulary.h
Plasma Formulary and Units - Declarations.
Formulary::Tau_e
double Tau_e(double ne, double Te)
Definition: formulary.cpp:306
Formulary::T0
double T0
Definition: formulary.h:103
input.h
Input reader - Declarations.
lib-array.h
Underlying data structures.
Setup_Y::applyexternalfields
void applyexternalfields(Grid_Info &grid, State1D &Y, double time)
Definition: setup.cpp:51
Formulary::wp
double wp
Definition: formulary.h:100
main
int main(int argc, char **argv)
Definition: main.cpp:129
export.h
Export Files - Declarations.
Formulary::Zeta
double Zeta
Definition: formulary.h:104
Grid_Info::mass
const vector< double > mass
Definition: setup.h:44
Formulary::cL
static constexpr double cL
Definition: formulary.h:112
Electric_Field_Methods::Efield_Method
Definition: implicitE.h:99
Input::Input_List::ext_fields
bool ext_fields
External fields.
Definition: input.h:117
Output_Data::Output_Preprocessor_1D
Definition: export.h:406
Formulary::LOGee
double LOGee(double ne, double Te)
Definition: formulary.cpp:226
Export_Files::Folders
void Folders()
Definition: export.cpp:74
Setup_Y::initialize
void initialize(State1D &Y, Grid_Info &grid)
Definition: setup.cpp:177
Input::Input_List::hydrocharge
double hydrocharge
Definition: input.h:83
Parallel_Environment_1D::Neighbor_Communications
void Neighbor_Communications(State1D &Y)
Definition: parallel.cpp:1151
Input::Input_List::ls
std::vector< size_t > ls
Definition: input.h:156
Formulary::LOGei
double LOGei(double ne, double Te, double Z)
Definition: formulary.cpp:249
VlasovFunctor1D_implicitE_p1
Definition: functors.h:128
collisions.h
Collisions - Declarations.
Formulary::pi
static constexpr double pi
Definition: formulary.h:110
Clock::tick
size_t tick() const
Definition: lib-algorithms.h:940
Hydro_Functor
Definition: fluid.h:41
Magnetic_Field_1D
Definition: vlasov.h:84
Input::Input_List::trav_wave
bool trav_wave
Definition: input.h:117
vlasov.h
Functors for various time-integration methodds - Declarations.
Parallel_Environment_1D::Neighbor_ImplicitE_Communications
void Neighbor_ImplicitE_Communications(State1D &Y)
Definition: parallel.cpp:1099
Input::Input_List::ms
std::vector< size_t > ms
Definition: input.h:157
Output_Data::Output_Preprocessor_1D::distdump
void distdump(const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
Definition: export.cpp:1389
VlasovFunctor1D_implicitE_implicitB_p1
Definition: functors.h:154
State1D
Definition: state.h:577
Formulary::B0
double B0
Definition: formulary.h:102
Input::Input_List::collisions
bool collisions
Definition: input.h:46
startmessages
double startmessages(State1D &Y)
Definition: main.cpp:63
Input::Input_List::restart_time
int restart_time
Definition: input.h:54
VlasovFunctor1D_implicitE_p2
Definition: functors.h:180
collisions::advance
void advance(State1D &Y, const Clock &W)
Definition: collisions.cpp:1417
Parallel_Environment_1D::RANK
int RANK() const
Definition: parallel.cpp:1090
Input::Input_List::pmax
std::vector< double > pmax
Definition: input.h:38
Algorithms::AxisBundle::xmax
T xmax(size_t i) const
Definition: lib-algorithms.h:100
Export_Files::Restart_Facility
Definition: export.h:213
setup.h
Grid Setup - Declaration.
Grid_Info::Np
const vector< size_t > Np
Definition: setup.h:43
Input::Input_List::hydromass
double hydromass
Definition: input.h:83
state.h
Fields, Distributions, Harmonics, States - Declarations.
Formulary::n
double n
Definition: formulary.h:99
Formulary::skindepth
double skindepth
Definition: formulary.h:101
Grid_Info::axis
const Algorithms::AxisBundle< double > axis
Definition: setup.h:47
Grid_Info
Definition: setup.h:15
Setup_Y::applytravelingwave
void applytravelingwave(Grid_Info &grid, State1D &Y, double time)
Definition: setup.cpp:95
Input::List
Input_List & List()
Definition: input.cpp:1585
VlasovFunctor1D_explicitE
Definition: functors.h:16
Input::Input_List::pth_ref
double pth_ref
Definition: input.h:96
Parallel_Environment_1D
Definition: parallel.h:130
VlasovFunctor1D_explicitE_implicitB
Definition: functors.h:96
Algorithms::AxisBundle::Nx
size_t Nx(size_t i) const
Definition: lib-algorithms.h:98
Electric_Field_Methods::Implicit_E_Field
Definition: implicitE.h:145
Algorithms::AxisBundle::xmin
T xmin(size_t i) const
Definition: lib-algorithms.h:99
Grid_Info::charge
const vector< double > charge
Definition: setup.h:45