util.hpp

Go to the documentation of this file.

#include <petscmat.h>
 
#include <cctype>
#include <cstring>
#include <map>
#include <optional>
#include <string>
#include <fstream>
#include <iostream>
#include <vector>
#include "version.hpp"
#ifdef WITH_SLEPC
#include <slepceps.h>
#endif
 
#pragma once
 
struct ParsedArgs {
  bool quietmode = false; 
  std::string config_filename; 
  int petsc_argc = 0; 
  std::vector<std::string> petsc_tokens; 
  std::vector<char*> petsc_argv; 
};
 
void printHelp();
 
ParsedArgs parseArguments(int argc, char** argv);
 
double sigmoid(double width, double x);
 
double sigmoid_diff(double width, double x);
 
double getRampFactor(const double time, const double tstart, const double tstop, const double tramp);
 
double getRampFactor_diff(const double time, const double tstart, const double tstop, const double tramp);
 
PetscInt getVecID(const PetscInt row, const PetscInt col, const PetscInt dim);
 
PetscInt mapEssToFull(const PetscInt i, const std::vector<size_t> &nlevels, const std::vector<size_t> &nessential);
 
PetscInt mapFullToEss(const PetscInt i, const std::vector<size_t> &nlevels, const std::vector<size_t> &nessential);
 
int isEssential(const int i, const std::vector<size_t> &nlevels, const std::vector<size_t> &nessential);
 
int isGuardLevel(const int i, const std::vector<size_t> &nlevels, const std::vector<size_t> &nessential);
 
PetscErrorCode Ikron(const Mat A, const int dimI, const double alpha, Mat *Out, InsertMode insert_mode);
 
PetscErrorCode kronI(const Mat A, const int dimI, const double alpha, Mat *Out, InsertMode insert_mode);
 
PetscErrorCode AkronB(const Mat A, const Mat B, const double alpha, Mat *Out, InsertMode insert_mode);
 
PetscErrorCode MatIsAntiSymmetric(Mat A, PetscReal tol, PetscBool *flag);
 
PetscErrorCode StateIsHermitian(Vec x, PetscReal tol, PetscBool *flag);
 
PetscErrorCode StateHasTrace1(Vec x, PetscReal tol, PetscBool *flag);
 
PetscErrorCode SanityTests(Vec x, PetscReal time);
 
int read_vector(const char *filename, double *var, int dim, bool quietmode=false, int skiplines=0, const std::string testheader="");
 
int getEigvals(const Mat A, const int neigvals, std::vector<double>& eigvals, std::vector<Vec>& eigvecs);
 
bool isUnitary(const Mat A, const Mat B);
 
template <typename Tval>
void copyLast(std::vector<Tval>& fillme, int tosize){
    // int norg = fillme.size();
 
    for (int i=fillme.size(); i<tosize; i++) 
      fillme.push_back(fillme[fillme.size()-1]);
 
    // if (norg < tosize) {
      // std::cout<< "I filled this: ";
      // for (int i=0; i<fillme.size(); i++) std::cout<< " " << fillme[i];
      // std::cout<<std::endl;
    // }
};
 
 
std::string toLower(std::string str);
 
bool hasSuffix(const std::string& str, const std::string& suffix);
 
 
template<typename T>
std::optional<T> parseEnum(const std::string& str, const std::map<std::string, T>& enum_map) {
  auto it = enum_map.find(toLower(str));
  if (it != enum_map.end()) {
    return it->second;
  } else {
    return std::nullopt;
  }
}
 
template <typename EnumType>
std::string enumToString(EnumType value, const std::map<std::string, EnumType>& type_map) {
  for (const auto& [str, enum_val] : type_map) {
    if (enum_val == value) return str;
  }
  return "unknown";
}
 
template<typename T>
T parseEnum(const std::optional<std::string>& opt_str, const std::map<std::string, T>& enum_map, const T& default_value) {
  if (!opt_str.has_value()) {
    return default_value;
  }
  auto result = parseEnum(opt_str.value(), enum_map);
  return result.value_or(default_value);
}