WarpXUtil.H

Go to the documentation of this file.

/* Copyright 2019-2020 Andrew Myers, Luca Fedeli, Maxence Thevenet
 * Revathi Jambunathan
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_UTILS_H_
#define WARPX_UTILS_H_

#include <AMReX_Extension.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_Parser.H>
#include <AMReX_REAL.H>
#include <AMReX_Utility.H>
#include <AMReX_Vector.H>

#include <AMReX_BaseFwd.H>

#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>

void ParseGeometryInput();

void ReadBoostedFrameParameters(amrex::Real& gamma_boost, amrex::Real& beta_boost,
                                amrex::Vector<int>& boost_direction);

void ConvertLabParamsToBoost();

void ReadBCParams ();

void CheckGriddingForRZSpectral();

void NullifyMF(amrex::MultiFab& mf, int lev, amrex::Real zmin,
               amrex::Real zmax);

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

namespace WarpXUtilIO{
bool WriteBinaryDataOnFile(std::string filename, const amrex::Vector<char>& data);

constexpr uint64_t
localIDtoGlobal(int const id, int const cpu)
{
    static_assert(sizeof(int) * 2u <= sizeof(uint64_t),
                  "int size might cause collisions in global IDs");
    // implementation:
    //   - we cast both 32-bit (or smaller) ints to a 64bit unsigned int
    //   - this will leave half of the "upper range" bits in the 64bit unsigned int zeroed out
    //     because the corresponding (extended) value range was not part of the value range in
    //     the int representation
    //   - we bit-shift the cpu into the upper half of zero bits in the 64 bit unsigned int
    //     (imagine this step as "adding a per-cpu/rank offset to the local integers")
    //   - then we add this offset
    //     note: the add is expressed as bitwise OR (|) since this saves us from writing
    //           brackets for operator precedence between + and <<
    return uint64_t(id) | uint64_t(cpu) << 32u;
}
}

namespace WarpXUtilAlgo{

template<typename T> AMREX_GPU_DEVICE AMREX_FORCE_INLINE
const T* upper_bound(const T* first, const T* last, const T& val)
{
    const T* it;
    size_t count, step;
    count = last-first;
    while(count>0){
        it = first;
        step = count/2;
        it += step;
        if (!(val<*it)){
            first = ++it;
                count -= step + 1;
        }
        else{
            count = step;
        }
    }
        return first;
}

template<typename T> AMREX_GPU_DEVICE AMREX_FORCE_INLINE
T linear_interp(T x0, T x1, T f0, T f1, T x)
{
    return ((x1-x)*f0 + (x-x0)*f1)/(x1-x0);
}

template<typename T> AMREX_GPU_DEVICE AMREX_FORCE_INLINE
T bilinear_interp(T x0, T x1, T y0, T y1, T f00, T f01, T f10, T f11, T x, T y)
{
    const T fx0 = linear_interp(x0, x1, f00, f10, x);
    const T fx1 = linear_interp(x0, x1, f01, f11, x);
    return linear_interp(y0, y1, fx0, fx1, y);
}

template<typename T> AMREX_GPU_DEVICE AMREX_FORCE_INLINE
T trilinear_interp(T x0, T x1,T y0, T y1, T z0, T z1,
    T f000, T f001, T f010, T f011, T f100, T f101, T f110, T f111,
    T x, T y, T z)
{
    const T fxy0 = bilinear_interp(
        x0, x1, y0, y1, f000, f010, f100, f110, x, y);
    const T fxy1 = bilinear_interp(
        x0, x1, y0, y1, f001, f011, f101, f111, x, y);
    return linear_interp(z0, z1, fxy0, fxy1, z);
}

}

int
safeCastToInt(amrex::Real x, const std::string& real_name);

amrex::Parser makeParser (std::string const& parse_function, amrex::Vector<std::string> const& varnames);

amrex::Real parseStringtoReal(std::string str);

int parseStringtoInt(std::string str, 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>{};
    }
}

int queryWithParser (const amrex::ParmParse& a_pp, char const * const str, amrex::Real& val);
int queryArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<amrex::Real>& val,
                        const int start_ix, const int num_val);
int queryWithParser (const amrex::ParmParse& a_pp, char const * const str, int& val);
int queryArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<int>& val,
                        const int start_ix, const int num_val);

void getWithParser (const amrex::ParmParse& a_pp, char const * const str, amrex::Real& val);
void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<amrex::Real>& val);
void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<amrex::Real>& val,
                       const int start_ix, const int num_val);
void getWithParser (const amrex::ParmParse& a_pp, char const * const str, int& val);
void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<int>& val);
void getArrWithParser (const amrex::ParmParse& a_pp, char const * const str, std::vector<int>& val,
                       const int start_ix, const int num_val);

namespace WarpXUtilMsg{

void AlwaysAssert(bool is_expression_true, const std::string& msg);

}

namespace WarpXUtilStr
{
    bool is_in(const std::vector<std::string>& vect,
               const std::string& elem);

    bool is_in(const std::vector<std::string>& vect,
               const std::vector<std::string>& elems);

    template <typename Container>
    auto split (std::string const& instr, std::string const& separator,
                  bool const trim = false, std::string const& trim_space = " \t")
    {
        Container cont;
        std::size_t current = instr.find(separator);
        std::size_t previous = 0;
        while (current != std::string::npos) {
            if (trim){
                cont.push_back(amrex::trim(instr.substr(previous, current - previous),trim_space));}
            else{
                cont.push_back(instr.substr(previous, current - previous));}
            previous = current + separator.size();
            current = instr.find(separator, previous);
        }
        if (trim){
            cont.push_back(amrex::trim(instr.substr(previous, current - previous),trim_space));}
        else{
            cont.push_back(instr.substr(previous, current - previous));}
        return cont;
    }

}

#endif //WARPX_UTILS_H_