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
{
    amrex::Parser makeParser (
        std::string const& parse_function,
        amrex::Vector<std::string> const& varnames);
 

    void Store_parserString(
        amrex::ParmParse const& pp,
        std::string const& query_string,
        std::string& stored_string);

    void Store_parserString(
        const amrex::ParmParse &pp,
        std::string const& group,
        std::string const& query_string,
        std::string& stored_string);

    bool Query_parserString(
        amrex::ParmParse const& pp,
        std::string const& query_string,
        std::string& stored_string);
 
    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)
    {
        return a_pp.queryAsDouble(str, val);
    }
 
 
    template <typename T>
    int queryArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val)
    {
        auto nvals = a_pp.countval(str);
        if (nvals > 0) {
            val.resize(nvals);
            return a_pp.queryarrAsDouble(str, nvals, val.data());
        } else {
            return 0;
        }
    }
 

    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)
    {
        const int is_specified = queryArrWithParser(a_pp, str, val);
        if (is_specified)
        {
            val.erase(val.begin(), val.begin()+start_ix);
            if (num_val != amrex::ParmParse::LAST) {
                if (num_val > int(val.size())) { return 0; }
                val.resize(num_val);
            }
        }
        // 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)
    {
        a_pp.getAsDouble(str, val);
    }
 
    template <typename T>
    void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<T>& val)
    {
        int const is_specified = queryArrWithParser(a_pp, str, val);
        if (is_specified == 0) {
            throw std::runtime_error("utils::parser::getArrWithParser failed");
        }
    }
 

    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)
    {
        int const is_specified = queryArrWithParser(a_pp, str, val, start_ix, num_val);
        if (is_specified == 0) {
            throw std::runtime_error("utils::parser::getArrWithParser failed");
        }
    }
 

    template <typename T>
    int queryWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, T& val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            return queryWithParser(a_pp, str, val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            return queryWithParser(a_pp, grp_str.c_str(), val);
        }
    }
 
 
    template <typename T>
    int queryArrWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, std::vector<T>& val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            return queryArrWithParser(a_pp, str, val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            return queryArrWithParser(a_pp, grp_str.c_str(), val);
        }
    }
 

    template <typename T>
    int queryArrWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, std::vector<T>& val,
                            const int start_ix, const int num_val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            return queryArrWithParser(a_pp, str, val, start_ix, num_val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            return queryArrWithParser(a_pp, grp_str.c_str(), val, start_ix, num_val);
        }
    }

    int query (const amrex::ParmParse& a_pp, std::string const& group, char const * str, std::string& val);

    template <typename T>
    void getWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, T& val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            getWithParser(a_pp, str, val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            getWithParser(a_pp, grp_str.c_str(), val);
        }
    }
 
    template <typename T>
    void getArrWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, std::vector<T>& val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            getArrWithParser(a_pp, str, val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            getArrWithParser(a_pp, grp_str.c_str(), val);
        }
    }
 

    template <typename T>
    void getArrWithParser (const amrex::ParmParse& a_pp, std::string const& group, char const * const str, std::vector<T>& val,
                        const int start_ix, const int num_val)
    {
        const bool is_specified_without_group = a_pp.contains(str);
        const std::string grp_str = group + "." + std::string(str);
        const bool is_specified_with_group = (group.empty() ? false : a_pp.contains(grp_str.c_str()));
 
        if (is_specified_without_group && !is_specified_with_group) {
            // If found without the group but not with the group, then use the one without the group.
            getArrWithParser(a_pp, str, val, start_ix, num_val);
        } else {
            // Otherwise, use the one with the group even if not found, in which case an exception may be raised.
            getArrWithParser(a_pp, grp_str.c_str(), val, start_ix, num_val);
        }
    }

    void get (amrex::ParmParse const& a_pp, std::string const& group, char const * str, std::string& val);
 
}
 
#endif // WARPX_UTILS_PARSER_PARSERUTILS_H_