basics.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// openCARP is an open cardiac electrophysiology simulator.
//
// Copyright (C) 2020 openCARP project
//
// This program is licensed under the openCARP Academic Public License (APL)
// v1.0: You can use and redistribute it and/or modify it in non-commercial
// academic environments under the terms of APL as published by the openCARP
// project v1.0, or (at your option) any later version. Commercial use requires
// a commercial license (info@opencarp.org).
//
// This program is distributed without any warranty; see the openCARP APL for
// more details.
//
// You should have received a copy of the openCARP APL along with this program
// and can find it online: http://www.opencarp.org/license
// ----------------------------------------------------------------------------
 
#ifndef _BASICS_H
#define _BASICS_H
 
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <cstring>
#include <cassert>
#include <string>
 
#include <unistd.h>
#include <sys/stat.h>
#include <mpi.h>
#include <petscsys.h> // TODO: review this (needed for PETSC_COMM_WORLD)
 
#include "vect.h"
#include "SF_vector.h"
 
#ifndef CARP_PARAMS
#define CARP_PARAMS
#include "openCARP_p.h"
#include "openCARP_d.h"
#endif
 
#define STRUCT_ZERO(S) memset(&(S), 0, sizeof(S))
#define SLIST_APPEND( S, P ) sltlst_append( S, &(P), sizeof(P) )
 
namespace opencarp {
 
struct Salt_list {
  void *data;    
  int   chunk;   
  int   nitems;  
  int   size;    
};
 
void sltlst_append(Salt_list* sl, void *p, int quantum);
 
char* dupstr(const char* old_str);
 
char *stringify(double r);
 
std::string get_basename(const std::string & path);
 
template<class STRVEC>
void split_string(const std::string & input, const char s, STRVEC & list)
{
  size_t fnd = 0, ofnd = 0;
  int num_parts = 1, idx = 0;
 
  fnd = input.find(s);
  while (fnd != std::string::npos)
  {
    num_parts++;
    ofnd = fnd+1;
    fnd = input.find(s, ofnd);
  }
 
  list.resize(num_parts);
 
  fnd = input.find(s); ofnd = 0;
  while (fnd != std::string::npos)
  {
    list[idx++].assign(input.begin() + ofnd, input.begin() + fnd);
    ofnd = fnd+1;
    fnd = input.find(s, ofnd);
  }
 
  if(ofnd < input.size())
    list[idx].assign(input.begin() + ofnd, input.end());
}
 
struct file_desc {
  FILE* fd;
  const char* name;
};
 
typedef file_desc* FILE_SPEC;
 
bool f_exist(const char *fname);
 
FILE_SPEC f_open(const char *fname, const char *mode);
 
void f_close(FILE_SPEC & f);
 
void f_read_par(void *ptr, size_t size, size_t nmemb, FILE_SPEC stream, MPI_Comm comm = PETSC_COMM_WORLD);
 
void f_write_par(void* ptr, size_t size, size_t nmemb, int source_pid, FILE_SPEC stream,
                 MPI_Comm comm = PETSC_COMM_WORLD);
 
char *read_bin_string(FILE_SPEC in);
 
char* read_bin_string_par(FILE_SPEC in);
 
char* f_gets_par(char* s, int size, FILE_SPEC stream, MPI_Comm comm = PETSC_COMM_WORLD);
 
void write_bin_string(FILE_SPEC out, const char *s);
 
template<typename T> inline
T get_global(T in, MPI_Op OP, MPI_Comm comm = PETSC_COMM_WORLD)
{
  double dat = in;
  MPI_Allreduce(MPI_IN_PLACE, &dat, 1, MPI_DOUBLE, OP, comm);
  return T(dat);
}
 
template<> inline
int get_global<int>(int in, MPI_Op OP, MPI_Comm comm)
{
  int dat = in;
  MPI_Allreduce(MPI_IN_PLACE, &dat, 1, MPI_INT, OP, comm);
  return dat;
}
 
template<> inline
long int get_global<long int>(long int in, MPI_Op OP, MPI_Comm comm)
{
  long int dat = in;
  MPI_Allreduce(MPI_IN_PLACE, &dat, 1, MPI_LONG, OP, comm);
  return dat;
}
 
template<typename T> inline
void get_global(SF::vector<T> & vec, int sender = 0, MPI_Comm comm = PETSC_COMM_WORLD)
{
  size_t sz = vec.size();
  MPI_Bcast(&sz, sizeof(size_t), MPI_BYTE, sender, comm);
  vec.resize(sz);
  MPI_Bcast(vec.data(), sz*sizeof(T), MPI_BYTE, sender, comm);
}
 
inline int get_rank(MPI_Comm comm = PETSC_COMM_WORLD)
{
  int rank;
  MPI_Comm_rank(comm, &rank);
 
  return rank;
}
 
inline int get_size(MPI_Comm comm = PETSC_COMM_WORLD)
{
  int size;
 
  MPI_Comm_size(comm, &size);
 
  return size;
}
 
inline int get_remote_size(MPI_Comm intercomm)
{
  int size;
 
  MPI_Comm_remote_size(intercomm, &size);
  return size;
}
 
// flags for log messages
#define ECHO    1   // screen output
#define LOCAL   2   // output all cores
#define SYNCED  4   // synchronized
#define FLUSH   8   // flush screen output
#define NONL   16   // no new line
 
#define MAX_MESG_LEN 2048
#define MAX_LOG_LEVEL 5
 
void log_msg(FILE_SPEC out, int level, unsigned char flag, const char *fmt, ...);
 
void init_iterations_logger(FILE_SPEC* & logger, const char* filename);
 
inline void remove_preceding_char(char* buff, const int buffsize, const char c)
{
  int ridx = 0, widx=0;
  while(ridx < buffsize && buff[ridx] == c) ridx++;
 
  while(ridx < (buffsize - 1))
    buff[widx++] = buff[ridx++];
 
  buff[widx] = '\0';
}
 
inline void remove_char(char* buff, const int buffsize, const char c)
{
  int ridx = 0, widx=0;
  while(ridx < buffsize) {
    if(buff[ridx] != c)
      buff[widx++] = buff[ridx];
    ridx++;
  }
 
  buff[widx] = '\0';
}
 
inline bool has_char(char* buff, const int buffsize, const char c)
{
  int ridx = 0;
  while(ridx < buffsize) {
    if(buff[ridx] == '\0') return false;
    if(buff[ridx] == c)    return true;
    ridx++;
  }
 
  return false;
}
 
class geom_shape {
  public:
  enum shape_t {sphere = 1, block = 2, cylinder = 3};
  shape_t type;
  Point p0;
  Point p1;
  double radius;
};
 
bool point_in_shape(const Point & p, const geom_shape & shape);
 
bool is_big_endian();
 
bool file_can_be_opened(const char* file);
 
 
bool path_is_absolute(const char* path);
 
/* fmemopen for OSX / BSD compilations */
#ifdef __APPLE__
#define USE_FMEM_WRAPPER 1
#endif
 
#ifdef OS_FREEBSD
#define USE_FMEM_WRAPPER 1
#endif
 
#ifdef USE_FMEM_WRAPPER
struct fmem {
    size_t pos;
    size_t size;
    char *buffer;
};
typedef struct fmem fmem_t;
 
FILE *fmemopen_(void *, size_t, const char *);
#else
/* Else use the normal fmemopen */
#define fmemopen_ fmemopen
#endif
 
inline void get_time(double & tm)
{
  tm = MPI_Wtime();
}
 
inline double get_time()
{
  double tm = MPI_Wtime();
  return tm;
}
 
template<typename V> inline
V timing(V & t2, const V & t1)
{
  t2 = get_time();
  return t2 - t1;
}
 
}  // namespace opencarp
 
// TODO: PETSc currently support neither float nor int64_T, so it's desactivated
// template _macro(std::int64_t, double)
#define OPENCARP_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(_macro) \
  template _macro(std::int32_t, double)
 
#endif