ParserUtils.H

Go to the documentation of this file.

/* Copyright 2022 Andrew Myers, Burlen Loring, Luca Fedeli
 * Maxence Thevenet, Remi Lehe, Revathi Jambunathan
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
 
#ifndef WARPX_UTILS_PARSER_PARSERUTILS_H_
#define WARPX_UTILS_PARSER_PARSERUTILS_H_
 
#include <AMReX_ParmParse.H>
#include <AMReX_Parser.H>
#include <AMReX_REAL.H>
#include <AMReX_Vector.H>
 
#include <cmath>
#include <string>
#include <type_traits>
 
namespace utils::parser
{
    int
    safeCastToInt(amrex::Real x, const std::string& real_name);
 
 
    long
    safeCastToLong(amrex::Real x, const std::string& real_name);
 
 
    amrex::Parser makeParser (
        std::string const& parse_function,
        amrex::Vector<std::string> const& varnames);
 
 
    void Store_parserString(
        const amrex::ParmParse &pp,
        std::string query_string,
        std::string& stored_string);
 
 
    double parseStringtoDouble(const std::string& str);
 
 
    int parseStringtoInt(const std::string& str, const std::string& name);
 
 
    template <int N>
    amrex::ParserExecutor<N> compileParser (amrex::Parser const* parser)
    {
        if (parser) {
            return parser->compile<N>();
        } else {
            return amrex::ParserExecutor<N>{};
        }
    }
 
 
    template <typename T>
    int queryWithParser (const amrex::ParmParse& a_pp, char const * const str, T& val)
    {
        // call amrex::ParmParse::query, check if the user specified str.
        std::string tmp_str;
        const int is_specified = a_pp.query(str, tmp_str);
        if (is_specified)
        {
            // If so, create a parser object and apply it to the value provided by the user.
            std::string str_val;
            Store_parserString(a_pp, str, str_val);
 
            auto parser = makeParser(str_val, {});
 
            if constexpr (std::is_same<T, int>::value) {
 
                val = safeCastToInt(
                    static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
            }
            else {
                val = static_cast<T>(parser.compileHost<0>()());
            }
        }
        // return the same output as amrex::ParmParse::query
        return is_specified;
    }
 
 
    template <typename T>
    int queryArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val)
    {
        // call amrex::ParmParse::query, check if the user specified str.
        std::vector<std::string> tmp_str_arr;
        const int is_specified = a_pp.queryarr(str, tmp_str_arr);
        if (is_specified)
        {
            // If so, create parser objects and apply them to the values provided by the user.
            int const n = static_cast<int>(tmp_str_arr.size());
            val.resize(n);
            for (int i=0 ; i < n ; i++) {
                auto parser = makeParser(tmp_str_arr[i], {});
                if constexpr (std::is_same<T, int>::value) {
                    val[i] = safeCastToInt(
                        static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
                }
                else {
                    val[i] = static_cast<T>(parser.compileHost<0>()());
                }
            }
        }
        // return the same output as amrex::ParmParse::query
        return is_specified;
    }
 
 
    template <typename T>
    int queryArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val,
                            const int start_ix, const int num_val)
    {
        // call amrex::ParmParse::query, check if the user specified str.
        std::vector<std::string> tmp_str_arr;
        const int is_specified = a_pp.queryarr(str, tmp_str_arr, start_ix, num_val);
        if (is_specified)
        {
            // If so, create parser objects and apply them to the values provided by the user.
            int const n = static_cast<int>(tmp_str_arr.size());
            val.resize(n);
            for (int i=0 ; i < n ; i++) {
                auto parser = makeParser(tmp_str_arr[i], {});
                if constexpr (std::is_same<T, int>::value) {
                    val[i] = safeCastToInt(
                        static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
                }
                else {
                    val[i] = static_cast<T>(parser.compileHost<0>()());
                }
            }
        }
        // return the same output as amrex::ParmParse::query
        return is_specified;
    }
 
 
    template <typename T>
    void getWithParser (const amrex::ParmParse& a_pp, char const * const str, T& val)
    {
        // If so, create a parser object and apply it to the value provided by the user.
        std::string str_val;
        Store_parserString(a_pp, str, str_val);
 
        auto parser = makeParser(str_val, {});
        if constexpr (std::is_same<T, int>::value) {
            val = safeCastToInt(
                static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
        }
        else {
            val = static_cast<T>(parser.compileHost<0>()());
        }
    }
 
    template <typename T>
    void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val)
    {
        // Create parser objects and apply them to the values provided by the user.
        std::vector<std::string> tmp_str_arr;
        a_pp.getarr(str, tmp_str_arr);
 
        int const n = static_cast<int>(tmp_str_arr.size());
        val.resize(n);
        for (int i=0 ; i < n ; i++) {
            auto parser = makeParser(tmp_str_arr[i], {});
            if constexpr (std::is_same<T, int>::value) {
                val[i] = safeCastToInt(
                    static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
            }
            else {
                val[i] = static_cast<T>(parser.compileHost<0>()());
            }
        }
    }
 
 
    template <typename T>
    void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val,
                        const int start_ix, const int num_val)
    {
        // Create parser objects and apply them to the values provided by the user.
        std::vector<std::string> tmp_str_arr;
        a_pp.getarr(str, tmp_str_arr, start_ix, num_val);
 
        int const n = static_cast<int>(tmp_str_arr.size());
        val.resize(n);
        for (int i=0 ; i < n ; i++) {
            auto parser = makeParser(tmp_str_arr[i], {});
            if constexpr (std::is_same<T, int>::value) {
                val[i] = safeCastToInt(
                    static_cast<amrex::Real>(std::round(parser.compileHost<0>()())), str);
            }
            else {
                val[i] = static_cast<T>(parser.compileHost<0>()());
            }
        }
    }
 
}
 
#endif // WARPX_UTILS_PARSER_PARSERUTILS_H_