Merge pull request #79 from ECP-WarpX/parser

MaxThevenet · web-flow · commit 0605ce27e604 · 2019-03-29T15:15:54.000+01:00
use parser's setConstant function instead of using string replacement
diff --git a/Docs/source/running_cpp/parameters.rst b/Docs/source/running_cpp/parameters.rst
@@ -103,20 +103,17 @@ distribution or the laser field (see below `Particle initialization` and
 
 The parser reads python-style expressions between double quotes, for instance
 ``"a0*x**2 * (1-y*1.e2) * (x>0)"`` is a valid expression where ``a0`` is a
-user-defined constant and ``x`` and ``y`` are variables. The factor
+user-defined constant and ``x`` and ``y`` are variables. The names are case sensitive. The factor
 ``(x>0)`` is `1` where `x>0` and `0` where `x<=0`. It allows the user to
 define functions by intervals. User-defined constants can be used in parsed
-functions only (i.e., ``density_function(x,y,z)`` and ``field_function(x,y,t)``,
-see below). They are specified with:
+functions only (i.e., ``density_function(x,y,z)`` and ``field_function(X,Y,t)``,
+see below). User-defined constants can contain only letter, numbers and character _.
+The name of each constant has to begin with a letter. The following names are used 
+by WarpX, and cannot be used as user-defined constants: `x`, `y`, `z`, `X`, `Y`, `t`.
+For example, parameters ``a0`` and ``z_plateau`` can be specified with:
 
-* ``constants.use_my_constants`` (`bool`)
-    Whether to use user-defined constants.
-
-* ``constants.constant_names`` (`strings, separated by spaces`)
-    A list of variables the user wants to define, e.g., ``constants.constant_names = a0 n0``.
-
-* ``constants.constant_values`` (`floats, sepatated by spaces`)
-    Values for the user-defined constants., e.g., ``constants.constant_values = 3. 1.e24``.
+* ``my_constants.a0 = 3.0``
+* ``my_constants.z_plateau = 150.e-6``
 
 Particle initialization
 -----------------------
@@ -164,8 +161,7 @@ Particle initialization
       It requires additional argument ``<species_name>.density_function(x,y,z)``, which is a
       mathematical expression for the density of the species, e.g.
       ``electrons.density_function(x,y,z) = "n0+n0*x**2*1.e12"`` where ``n0`` is a
-      user-defined constant, see above. Note that using this density profile will turn
-      ``warpx.serialize_ics`` to ``1``, which may slow down the simulation.
+      user-defined constant, see above.
 
 * ``<species_name>.momentum_distribution_type`` (`string`)
     Distribution of the normalized momentum (`u=p/mc`) for this species. The options are:
@@ -187,8 +183,6 @@ Particle initialization
       file. It requires additional arguments ``<species_name>.momentum_function_ux(x,y,z)``,
       ``<species_name>.momentum_function_uy(x,y,z)`` and ``<species_name>.momentum_function_uz(x,y,z)``,
       which gives the distribution of each component of the momentum as a function of space.
-      Note that using this momentum distribution type will turn
-      ``warpx.serialize_ics`` to ``1``, which may slow down the simulation.
 
 * ``<species_name>.zinject_plane`` (`float`)
     Only read if  ``<species_name>`` is in ``particles.rigid_injected_species``.
diff --git a/Examples/Physics_applications/laser_acceleration/inputs.2d.boost b/Examples/Physics_applications/laser_acceleration/inputs.2d.boost
@@ -48,9 +48,11 @@ warpx.dt_snapshots_lab = 1.6678204759907604e-12
 #################################
 ############ PLASMA #############
 #################################
-constants.use_my_constants = 1
-constants.constant_names  = zmax    rc     rmax    n0     kp
-constants.constant_values = 30.e-2  50.e-6 110.e-6 3.5e24 353352.
+my_constants.zmax = 30.e-2
+my_constants.rc   = 50.e-6
+my_constants.rmax = 110.e-6
+my_constants.n0   = 3.5e24
+my_constants.kp   = 353352.
 
 particles.nspecies = 3
 particles.species_names = electrons ions beam
diff --git a/Examples/Physics_applications/plasma_acceleration/inputs.2d.boost b/Examples/Physics_applications/plasma_acceleration/inputs.2d.boost
@@ -31,9 +31,9 @@ warpx.cfl = .99
 warpx.do_moving_window = 1
 warpx.moving_window_dir = z
 warpx.moving_window_v = 1. # in units of the speed of light
-constants.use_my_constants = 1
-constants.constant_names  = lramp  pi                 dens
-constants.constant_values = 8.e-3  3.141592653589793  1e+23
+my_constants.lramp = 8.e-3
+my_constants.pi    = 3.141592653589793
+my_constants.dens  = 1e+23
 interpolation.nox = 3
 interpolation.noy = 3
 interpolation.noz = 3
diff --git a/Examples/Physics_applications/plasma_acceleration/inputs.3d.boost b/Examples/Physics_applications/plasma_acceleration/inputs.3d.boost
@@ -30,9 +30,9 @@ warpx.cfl = .99
 warpx.do_moving_window = 1
 warpx.moving_window_dir = z
 warpx.moving_window_v = 1. # in units of the speed of light
-constants.use_my_constants = 1
-constants.constant_names  = lramp  pi                 dens
-constants.constant_values = 8.e-3  3.141592653589793  1e+23
+my_constants.lramp = 8.e-3
+my_constants.pi    = 3.141592653589793
+my_constants.dens  = 1e+23
 interpolation.nox = 3
 interpolation.noy = 3
 interpolation.noz = 3
diff --git a/Examples/Physics_applications/plasma_mirror/inputs.2d b/Examples/Physics_applications/plasma_mirror/inputs.2d
@@ -25,9 +25,12 @@ algo.particle_pusher = 0
 interpolation.nox = 3
 interpolation.noy = 3
 interpolation.noz = 3
-constants.use_my_constants = 1
-constants.constant_names  = zc     zp                       lgrad  nc      zp2    zc2
-constants.constant_values = 20.e-6 20.05545177444479562e-6  .08e-6 1.74e27 24.e-6 24.05545177444479562e-6
+my_constants.zc    = 20.e-6
+my_constants.zp    = 20.05545177444479562e-6
+my_constants.lgrad = .08e-6
+my_constants.nc    = 1.74e27
+my_constants.zp2   = 24.e-6
+my_constants.zc2   = 24.05545177444479562e-6
 warpx.cfl = 1.0
 warpx.do_dynamic_scheduling = 0
 warpx.load_balance_int = 66
diff --git a/Examples/Tests/Langmuir/inputs.multi.2d.rt b/Examples/Tests/Langmuir/inputs.multi.2d.rt
@@ -39,9 +39,9 @@ interpolation.noz = 1
 warpx.cfl = 1.0
 
 # Parameters for the plasma wave
-constants.use_my_constants = 1
-constants.constant_names = epsilon kp k
-constants.constant_values = 0.01 376357.71524190728 314159.2653589793
+my_constants.epsilon = 0.01
+my_constants.kp = 376357.71524190728
+my_constants.k = 314159.2653589793
 # Note: kp is calculated in SI for a density of 4e24 (i.e. 2e24 electrons + 2e24 positrons)
 # k is calculated so as to have 2 periods within the 40e-6 wide box.
 
diff --git a/Examples/Tests/Langmuir/inputs.multi.rt b/Examples/Tests/Langmuir/inputs.multi.rt
@@ -39,9 +39,9 @@ interpolation.noz = 1
 warpx.cfl = 1.0
 
 # Parameters for the plasma wave
-constants.use_my_constants = 1
-constants.constant_names = epsilon kp k
-constants.constant_values = 0.01 376357.71524190728 314159.2653589793
+my_constants.epsilon = 0.01
+my_constants.kp      = 376357.71524190728
+my_constants.k       = 314159.2653589793
 # Note: kp is calculated in SI for a density of 4e24 (i.e. 2e24 electrons + 2e24 positrons)
 # k is calculated so as to have 2 periods within the 40e-6 wide box.
 
diff --git a/Python/pywarpx/Constants.py b/Python/pywarpx/Constants.py
@@ -3,30 +3,14 @@
 class Constants(Bucket):
     """
     The purpose of this class is to be hold user defined constants
-    The constants will be concatenated into names and values string.
     """
     def __init__(self):
-        Bucket.__init__(self, 'constants')
+        Bucket.__init__(self, 'my_constants')
 
     def __setattr__(self, name, value):
         # Make sure that any constants redefined have a consistent value
         if name in self.argvattrs:
-            assert self.argvattrs[name] == value, Exception('In consistent values given for user defined constants')
+            assert self.argvattrs[name] == value, Exception('An consistent values given for user defined constants')
         Bucket.__setattr__(self, name, value)
 
-    def attrlist(self):
-        "Concatenate the attributes into a string"
-        if self.argvattrs:
-            names = ''
-            values = ''
-            for attr, value in self.argvattrs.items():
-                names += ' ' + attr
-                values += ' {}'.format(value)
-            return ['constants.use_my_constants = 1',
-                    'constants.constant_names = ' + names,
-                    'constants.constant_values = ' + values]
-        else:
-            return []
-
-
-constants = Constants()
+my_constants = Constants()
diff --git a/Python/pywarpx/WarpX.py b/Python/pywarpx/WarpX.py
@@ -1,5 +1,5 @@
 from .Bucket import Bucket
-from .Constants import constants
+from .Constants import my_constants
 from .Amr import amr
 from .Geometry import geometry
 from .Algo import algo
@@ -18,7 +18,7 @@ class WarpX(Bucket):
     def create_argv_list(self):
         argv = []
         argv += warpx.attrlist()
-        argv += constants.attrlist()
+        argv += my_constants.attrlist()
         argv += amr.attrlist()
         argv += geometry.attrlist()
         argv += algo.attrlist()
diff --git a/Python/pywarpx/__init__.py b/Python/pywarpx/__init__.py
@@ -1,5 +1,5 @@
 from .WarpX import warpx
-from .Constants import constants
+from .Constants import my_constants
 from .Amr import amr
 from .Geometry import geometry
 from .Algo import algo
diff --git a/Python/pywarpx/picmi.py b/Python/pywarpx/picmi.py
@@ -188,7 +188,7 @@ def initialize_inputs(self, species_number, layout, species):
         species.__setattr__('density_function(x,y,z)', self.density_expression)
 
         for k,v in self.user_defined_kw.items():
-            setattr(pywarpx.constants, k, v)
+            setattr(pywarpx.my_constants, k, v)
 
         if np.any(np.not_equal(self.rms_velocity, 0.)):
             species.momentum_distribution_type = "gaussian"
diff --git a/Source/Initialization/PlasmaInjector.H b/Source/Initialization/PlasmaInjector.H
@@ -68,7 +68,6 @@ public:
     virtual amrex::Real getDensity(amrex::Real x,
                                    amrex::Real y,
                                    amrex::Real z) const override;
-    UserConstants my_constants;
 private:
     std::string _parse_density_function;
     WarpXParser parser_density;
@@ -173,7 +172,6 @@ public:
                              amrex::Real x,
                              amrex::Real y,
                              amrex::Real z) override;
-    UserConstants my_constants;
 private:
     std::string _parse_momentum_function_ux;
     std::string _parse_momentum_function_uy;
diff --git a/Source/Initialization/PlasmaInjector.cpp b/Source/Initialization/PlasmaInjector.cpp
@@ -1,6 +1,7 @@
 #include "PlasmaInjector.H"
 
 #include <sstream>
+#include <functional>
 
 #include <WarpXConst.H>
 #include <WarpX_f.H>
@@ -72,10 +73,26 @@ CustomDensityProfile::CustomDensityProfile(const std::string& species_name)
 ParseDensityProfile::ParseDensityProfile(std::string parse_density_function)
     : _parse_density_function(parse_density_function)
 {
-    my_constants.ReadParameters();
-    parse_density_function = my_constants.replaceStringValue(parse_density_function);
     parser_density.define(parse_density_function);
     parser_density.registerVariables({"x","y","z"});
+
+    ParmParse pp("my_constants");
+    std::set<std::string> symbols = parser_density.symbols();
+    symbols.erase("x");
+    symbols.erase("y");
+    symbols.erase("z"); // after removing variables, we are left with constants
+    for (auto it = symbols.begin(); it != symbols.end(); ) {
+        Real v;
+        if (pp.query(it->c_str(), v)) {
+            parser_density.setConstant(*it, v);
+            it = symbols.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    for (auto const& s : symbols) { // make sure there no unknown symbols
+        amrex::Abort("ParseDensityProfile: Unknown symbol "+s);
+    }
 }
 
 Real ParseDensityProfile::getDensity(Real x, Real y, Real z) const
@@ -137,16 +154,32 @@ ParseMomentumFunction::ParseMomentumFunction(std::string parse_momentum_function
       _parse_momentum_function_uy(parse_momentum_function_uy),
       _parse_momentum_function_uz(parse_momentum_function_uz)
 {
-    my_constants.ReadParameters();
-    parse_momentum_function_ux = my_constants.replaceStringValue(parse_momentum_function_ux);
-    parse_momentum_function_uy = my_constants.replaceStringValue(parse_momentum_function_uy);
-    parse_momentum_function_uz = my_constants.replaceStringValue(parse_momentum_function_uz);
     parser_ux.define(parse_momentum_function_ux);
     parser_uy.define(parse_momentum_function_uy);
     parser_uz.define(parse_momentum_function_uz);
-    parser_ux.registerVariables({"x","y","z"});
-    parser_uy.registerVariables({"x","y","z"});
-    parser_uz.registerVariables({"x","y","z"});
+
+    amrex::Array<std::reference_wrapper<WarpXParser>,3> parsers{parser_ux, parser_uy, parser_uz};
+    ParmParse pp("my_constants");
+    for (auto& p : parsers) {
+        auto& parser = p.get();
+        parser.registerVariables({"x","y","z"});
+        std::set<std::string> symbols = parser.symbols();
+        symbols.erase("x");
+        symbols.erase("y");
+        symbols.erase("z"); // after removing variables, we are left with constants
+        for (auto it = symbols.begin(); it != symbols.end(); ) {
+            Real v;
+            if (pp.query(it->c_str(), v)) {
+                parser.setConstant(*it, v);
+                it = symbols.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        for (auto const& s : symbols) { // make sure there no unknown symbols
+            amrex::Abort("ParseMomentumFunction: Unknown symbol "+s);
+        }
+    }
 }
 
 void ParseMomentumFunction::getMomentum(vec3& u, Real x, Real y, Real z)
diff --git a/Source/Laser/LaserParticleContainer.H b/Source/Laser/LaserParticleContainer.H
@@ -44,8 +44,6 @@ public:
 
     virtual void PostRestart () final;
 
-    UserConstants my_constants;
-
 private:
 
     // runtime paramters
diff --git a/Source/Laser/LaserParticleContainer.cpp b/Source/Laser/LaserParticleContainer.cpp
@@ -74,10 +74,26 @@ LaserParticleContainer::LaserParticleContainer (AmrCore* amr_core, int ispecies)
         if ( profile == laser_t::parse_field_function ) {
             // Parse the properties of the parse_field_function profile
             pp.get("field_function(X,Y,t)", field_function);
-            // User-defined constants: replace names by value
-            my_constants.ReadParameters();
-            field_function = my_constants.replaceStringValue(field_function);
             parser.define(field_function);
+            parser.registerVariables({"X","Y","t"});
+
+            ParmParse pp("my_constants");
+            std::set<std::string> symbols = parser.symbols();
+            symbols.erase("X");
+            symbols.erase("Y");
+            symbols.erase("t"); // after removing variables, we are left with constants
+            for (auto it = symbols.begin(); it != symbols.end(); ) {
+                Real v;
+                if (pp.query(it->c_str(), v)) {
+                    parser.setConstant(*it, v);
+                    it = symbols.erase(it);
+                } else {
+                    ++it;
+                }
+            }
+            for (auto const& s : symbols) { // make sure there no unknown symbols
+                amrex::Abort("Laser Profile: Unknown symbol "+s);
+            }
         }
 
 	// Plane normal
@@ -393,14 +409,8 @@ LaserParticleContainer::Evolve (int lev,
 	    }
 
             if (profile == laser_t::parse_field_function) {
-                Real parser_X, parser_Y, parser_t;
-                parser.registerVariable("X", parser_X);
-                parser.registerVariable("Y", parser_Y);
-                parser.registerVariable("t", t);
                 for (int i = 0; i < np; ++i) {
-                    parser_X = plane_Xp[i];
-                    parser_Y = plane_Yp[i];
-                    amplitude_E[i] = parser.eval();
+                    amplitude_E[i] = parser.eval(plane_Xp[i], plane_Yp[i], t);
                 }
 	    }
 	    // Calculate the corresponding momentum and position for the particles
diff --git a/Source/Parser/WarpXParser.H b/Source/Parser/WarpXParser.H
@@ -4,7 +4,7 @@
 #include <array>
 #include <vector>
 #include <string>
-#include <cstdarg>
+#include <set>
 
 #include "wp_parser_c.h"
 #include "wp_parser_y.h"
@@ -44,6 +44,8 @@ public:
 
     std::string const& expr () const;
 
+    std::set<std::string> symbols () const;
+
 private:
     void clear ();
 
diff --git a/Source/Parser/WarpXParser.cpp b/Source/Parser/WarpXParser.cpp
@@ -136,3 +136,15 @@ WarpXParser::expr () const
 {
     return m_expression;
 }
+
+std::set<std::string>
+WarpXParser::symbols () const
+{
+    std::set<std::string> results;
+#ifdef _OPENMP
+    wp_ast_get_symbols(m_parser[omp_get_thread_num()]->ast, results);
+#else
+    wp_ast_get_symbols(m_parser->ast, results);
+#endif
+    return results;
+}
diff --git a/Source/Parser/wp_parser.l b/Source/Parser/wp_parser.l
@@ -50,7 +50,7 @@ EXP	([Ee][-+]?[0-9]+)
 "max"         { yylval.f2 = WP_MAX;       return F2; }
 
  /* We use SYMBOL to hold variables and constants */
-[a-zA-Z][a-zA-Z0-9]*  { yylval.s = wp_makesymbol(yytext); return SYMBOL; }
+[a-zA-Z_][a-zA-Z0-9_]*  { yylval.s = wp_makesymbol(yytext); return SYMBOL; }
 
  /* Number */
 [0-9]+"."[0-9]*{EXP}? |
diff --git a/Source/Parser/wp_parser.lex.c b/Source/Parser/wp_parser.lex.c
@@ -414,7 +414,7 @@ static yyconst YY_CHAR yy_ec[256] =
        16,   17,    1,    1,   18,   18,   18,   18,   19,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
-        1,   20,    1,   21,    1,    1,   22,   23,   24,   25,
+        1,   20,    1,   21,   18,    1,   22,   23,   24,   25,
 
        26,   27,   28,   29,   30,   18,   18,   31,   32,   33,
        34,   35,   36,   37,   38,   39,   18,   40,   41,   42,
diff --git a/Source/Parser/wp_parser_c.h b/Source/Parser/wp_parser_c.h
diff --git a/Source/Utils/Make.package b/Source/Utils/Make.package
diff --git a/Source/Utils/WarpXConst.H b/Source/Utils/WarpXConst.H
diff --git a/Source/Utils/WarpXConst.cpp b/Source/Utils/WarpXConst.cpp
