sim_utils.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 _SIM_UTILS_H
#define _SIM_UTILS_H
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include "Typedefs.h"
#include "sf_interface.h"
#include "timer_utils.h"
#include "physics_types.h"
#include "build_info.h"
 
 
#ifndef CARP_PARAMS
#define CARP_PARAMS
#include "openCARP_p.h"
#include "openCARP_d.h"
#endif
 
#include "IGBheader.h"
 
 
namespace opencarp {
 
enum IO_t {INPUT, OUTPUT, POSTPROC, CURDIR};
 
enum tagreg_t {tagreg_sphere = 1, tagreg_block = 2, tagreg_cylinder = 3, tagreg_list = 4};
#define DATAOUT_NONE 0
#define DATAOUT_SURF 1
#define DATAOUT_VOL  2
#define DATAOUT_VTX  3
 
namespace user_globals {
  extern SF::scatter_registry scatter_reg;
  extern std::map<mesh_t, sf_mesh> mesh_reg;
  extern std::map<SF::quadruple<int>, SF::index_mapping<int> > map_reg;
  extern std::map<physic_t, Basic_physic*> physics_reg;
  extern timer_manager* tm_manager;
  extern std::map<datavec_t, sf_vec*> datavec_reg;
  extern FILE* petsc_error_fd;
  extern bool using_legacy_stimuli;
  extern MPI_Comm IO_Intercomm;
}
 
void parse_params_cpy(int argc, char** argv);
 
void register_physics();
void initialize_physics();
void destroy_physics();
 
void simulate();
 
void post_process();
 
void parse_mesh_types();
 
void setup_meshes();
 
void output_meshes();
 
// flags to go with solution type
#define SOLV_METH(A,B) (B & A##_FLAG)
#define MONODOMAIN_FLAG   1
#define ITERATE_FLAG      2
#define CN_PARAB_FLAG     4
#define PURKINJE_FLAG     8
#define O2dT_PARAB_FLAG  16
#define PSEUDO_BIDM_FLAG 32
 
// simulation modes
#define MONODOMAIN         0
#define BIDOMAIN           1
#define PSEUDO_BIDM        2
 
// post processting options
// keep in jive with post_processing_opts in carp.prm
#define RECOVER_PHIE           1
#define OPTICAL_MAP            2
#define ACTIVATING_FUNCTION    4
#define AXIAL_CURRENTS         8
#define FILAMENTS             16
#define CURRENT_DENSITIES     32
 
// experiment defs, keep in jive with carp.prm
#define EXP_NORMAL       0
#define EXP_OUTPUT_FEM   1
#define EXP_LAPLACE      2
#define EXP_SETUP_MESH   3
#define EXP_POSTPROCESS  4
 
unsigned int classify_soln_methods();
 
void check_and_convert_params();
 
void setup_petsc_err_log();
 
void set_io_dirs(char *sim_ID, char *pp_ID, IO_t init);
 
bool setup_IO(int argc, char **argv);
void update_cwd();
int set_dir(IO_t dest);
 
void basic_timer_setup();
 
int plot_protocols(const char *);
 
Basic_physic* get_physics(physic_t p, bool error_if_missing = true);
 
short get_mesh_dim(mesh_t id);
 
void register_data(sf_vec* dat, datavec_t d);
 
[[noreturn]] void cleanup_and_exit();
 
// return the direcotry path of a given file
char* get_file_dir(const char* file);
sf_vec* get_data(datavec_t d);
 
struct prog_stats {
  double op;      
  double start;   
  double last;    
  double curr;    
};
 
struct sync_io_item {
  sf_vec*                 data;      
  const SF::vector<mesh_int_t>* restr_idx; 
  IGBheader                     igb;       
  bool                          elem_flag; 
  SF::mixed_tuple<mesh_t, int>  spec;      
};
 
struct async_io_item {
  sf_vec*                 data;      
  int                           IO_id;     
  const SF::vector<mesh_int_t>* restr_idx; 
  SF::vector<mesh_int_t>        restr_petsc_idx; 
};
class igb_output_manager
{
  private:
  sf_vec* fill_output_buffer(const sync_io_item & it);
 
 
  void register_output_async(sf_vec* inp_data,
                             const mesh_t inp_meshid,
                             const int dpn,
                             const char* name,
                             const char* units,
                             const SF::vector<mesh_int_t>* idx,
                             bool elem_data);
 
  public:
  SF::vector<sync_io_item>  sync_IOs;
  SF::vector<async_io_item> async_IOs;
  std::map<SF::mixed_tuple<mesh_t, int>, sf_vec*> buffmap;
  std::map<SF::mixed_tuple<mesh_t, int>, sf_vec*> buffmap_elem;
 
  void register_output_sync(sf_vec* inp_data,
                            const mesh_t inp_meshid,
                            const int dpn,
                            const char* name,
                            const char* units,
                            const SF::vector<mesh_int_t>* idx = NULL,
                            bool elem_data = false);
 
  void register_output(sf_vec* inp_data,
                       const mesh_t inp_meshid,
                       const int dpn,
                       const char* name,
                       const char* units,
                       const SF::vector<mesh_int_t>* idx = NULL,
                       bool elem_data = false);
 
  void write_data();
 
  IGBheader* get_igb_header(const sf_vec* vec);
 
  void close_files_and_cleanup();
};
 
void output_parameter_file(const char *fname, int argc, char **argv);
 
void savequit();
 
void show_build_info();
 
}  // namespace opencarp
 
#endif