petscUtilities.hpp

#ifndef ABLATELIBRARY_PETSCUTILITIES_HPP
#define ABLATELIBRARY_PETSCUTILITIES_HPP
#include <petsc.h>
#include <map>
#include <string>
namespace ablate::utilities {
 
class PetscUtilities {
   public:
    class ErrorChecker {
       public:
        struct PetscError : public std::runtime_error {
           private:
            static std::string GetMessage(PetscErrorCode ierr) {
                const char* text;
                char* specific;
 
                PetscErrorMessage(ierr, &text, &specific);
 
                return std::string(text) + ": " + std::string(specific);
            }
 
           public:
            explicit PetscError(PetscErrorCode ierr) : std::runtime_error(GetMessage(ierr)) {}
        };
 
        inline friend void operator>>(PetscErrorCode ierr, const ErrorChecker&) {
            if (ierr != 0) {
                throw PetscError(ierr);
            }
        }
    };
 
   public:
    static void Initialize(const char[] = nullptr);
 
    static inline utilities::PetscUtilities::ErrorChecker checkError;
 
    static void Set(const std::string& prefix, const std::map<std::string, std::string>& options, bool override = true);
 
    static void Set(const std::map<std::string, std::string>& options);
 
    static void Set(PetscOptions petscOptions, const std::map<std::string, std::string>& options);
 
    static void Set(PetscOptions petscOptions, const char name[], const char value[], bool override = true);
 
    static void PetscOptionsDestroyAndCheck(const std::string& name, PetscOptions* options);
 
    // keep this class static
    PetscUtilities() = delete;
};
 
std::istream& operator>>(std::istream& is, PetscDataType& v);
 
std::ostream& operator<<(std::ostream& os, const PetscDataType& dt);
 
}  // namespace ablate::utilities
#endif  // ABLATELIBRARY_PETSCUTILITIES_HPP