AuxiliarMethods.hpp

Go to the documentation of this file.

/*
 *  This file is part of AQUAgpusph, a free CFD program based on SPH.
 *  Copyright (C) 2012  Jose Luis Cercos Pita <jl.cercos@upm.es>
 *
 *  AQUAgpusph is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AQUAgpusph is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AQUAgpusph.  If not, see <http://www.gnu.org/licenses/>.
 */

 
#ifndef AUXILIARMETHODS_H_INCLUDED
#define AUXILIARMETHODS_H_INCLUDED
 
#include "sphPrerequisites.hpp"
#include <string>
#include <vector>
#include <tuple>
#include <deque>
#include <limits>
#include <filesystem>
#include "aquagpusph/ext/boost/numeric/conversion/cast.hpp"
 
#ifdef HAVE_MPI
#include <mpi.h>
#endif
 
namespace Aqua {

bool
hasPrefix(const std::string& str, const std::string& prefix);

inline bool
startswith(const std::string& str, const std::string& prefix)
{
        return hasPrefix(str, prefix);
}

bool
hasSuffix(const std::string& str, const std::string& suffix);

inline bool
endswith(const std::string& str, const std::string& prefix)
{
        return hasSuffix(str, prefix);
}

void
replaceAll(std::string& str,
           const std::string& search,
           const std::string& replace);

std::string
replaceAllCopy(std::string str, std::string search, std::string replace);

void
ltrim(std::string& s);

void
rtrim(std::string& s);

void
trim(std::string& s);

std::string
ltrimCopy(std::string s);

std::string
rtrimCopy(std::string s);

std::string
trimCopy(std::string s);

std::string
xxd2string(unsigned char* arr, unsigned int len);

void
toLower(std::string& str);

std::string
toLowerCopy(std::string str);

void
setStrConstants(std::string& str);

std::string
setStrConstantsCopy(std::string str);

std::vector<std::string>
split(std::string str, char chr);

inline std::vector<std::string>
split(const std::string& s)
{
        return split(s, ' ');
}

std::vector<std::string>
split_formulae(std::string str);

std::string
newFilePath(const std::string& basename,
            unsigned int& i,
            unsigned int digits = 5);


template <typename T>
inline bool
isPowerOf2(T x) { return !(x & (x - 1)); }


template <typename T>
inline T
nextPowerOf2(T n)
{
        if (n && isPowerOf2(n))
                return n;
 
        T p = 1;
        while (p < n) {
                p <<= 1;
        }
        return p;
}
 


template<typename T=unsigned int>
T
roundUp(T x, T divisor)
{
        T rest = x % divisor;
        if (rest) {
                x -= rest;
                x += divisor;
        }
        return x;
}

template<typename Tout=int, typename Tin>
inline Tout
round(Tin n) { return (Tout)(n + ((n >= 0) ? 0.5 : -0.5)); }

const std::string
getExePath();

const std::string
getRootPath();


const std::string
getFolderFromFilePath(const std::string file_path);


const std::string
getFileNameFromFilePath(const std::string file_path);


const std::string
getExtensionFromFilePath(const std::string file_path);

bool
isFile(const std::string file_name);

bool
isRelativePath(const std::string path);


size_t
getLocalWorkSize(cl_command_queue queue);


size_t
getGlobalWorkSize(size_t n, size_t local_work_size);


inline float
clamp(float x, float a, float b)
{
        return x < a ? a : (x > b ? b : x);
}

template<class Tdst, class Torg>
inline Tdst
narrow_cast(Torg v)
{
        Tdst r;
        try 
        {
                 r = boost::numeric_cast<Torg>(v);
        }
        catch(boost::numeric::bad_numeric_cast& e) {
        throw std::out_of_range("narrow_cast<>() failed");
                throw std::out_of_range(e.what());
        }
        return r;
}


unsigned int
numberOfDigits(unsigned int number);
 
#ifdef HAVE_MPI
 
namespace MPI {

std::string error_str(int errorcode);

DECLDIR void init(int *argc, char ***argv);

DECLDIR void finalize();

int rank(MPI_Comm comm);

int size(MPI_Comm comm);

DECLDIR void barrier(MPI_Comm comm);

void send(const void *buf, int count, MPI_Datatype datatype, int dest, int tag,
          MPI_Comm comm);

MPI_Request isend(const void *buf, int count, MPI_Datatype datatype, int dest,
                  int tag, MPI_Comm comm);

MPI_Status recv(void *buf, int count, MPI_Datatype datatype, int source,
                int tag, MPI_Comm comm);

MPI_Request irecv(void *buf, int count, MPI_Datatype datatype,
                  int source, int tag, MPI_Comm comm);

MPI_Status wait(MPI_Request *request);
 
} // ::MPI
 
#endif
 
} // ::Aqua
 
#endif // AUXILIARMETHODS_H_INCLUDED