MULTI_ION_IF.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) NumeriCor GmbH
// SPDX-License-Identifier: LicenseRef-APL-1.1
 
#ifndef MULTI_ION_IF_H
#define MULTI_ION_IF_H
 
#include <ctime>
#include <cstdarg>
#include <cstddef>
#include <string>
#include <sys/resource.h>
 
#include "ION_IF.h"
 
#include "timer_utils.h"
#include "fem_types.h"
#include "sf_interface.h"
 
#define FARADAY 96485                   
 
namespace limpet {
 
typedef double Real;
 
// Format history:
//   2 - per-IMP state written as whole data-layout-optimized SoA blocks keyed by
//       the block leader's canonical id. Partition-dependent: a cross-rank restart
//       with dlo_vector_size() > 1 regroups nodes into different blocks and reads
//       mismatched (or never-written) slots -> corrupt state. Still read for
//       backwards compatibility (correct only when restored on the same layout).
//   3 - per-IMP state de-interleaved to one contiguous per-node record keyed by the
//       node's own canonical id, like the global data. Partition-independent. Each
//       IMP/plugin header also stores a fingerprint of its state-variable layout
//       (ordered field names and per-lane sizes); on restore a mismatch marks the
//       region incompatible instead of misreading a changed model field-for-field.
static const unsigned int MIIF_Format = 3;               
static const char *Magic_MIIF_ID      = "Dump_MIIF_ID";  
 
struct SV_DUMP {
  int                   active;
  int                   n;        
  opencarp::FILE_SPEC*  hdls;     
  char**                fn;       
  int*                  reg;      
  char**                svnames;  
  double                intv;     
  double                t_dump;   
  int                   n_dumps;  
  long                  nwr;      
  int*                  offset;   
  int*                  size;     
  int*                  dtype;    
  node_count_t*         num;      
  void**                svtab;    
  size_t*               svsize;   
  int*                  dlo_vs;
};
 
struct Trace_Info {
  bool found;      
  bool ignored;    
  node_index_t node_idx;   
  int  region;
  opencarp::FILE_SPEC file;
};
 
class MULTI_IF {
 
 public:
  std::string              name;                          
  bool                     doppel;                        
  node_count_t*            N_Nodes;                       
  node_index_t**           NodeLists;                     
  std::vector<IonIfBase*>      IIF;                           
  SV_DUMP                  svd;                           
  GlobalData_t*            procdata[NUM_IMP_DATA_TYPES];  
  GlobalData_t***          ldata;                         
  bool*                    contiguous;                    
  Trace_Info*              trace_info;                    
  bool                     extUpdateVm;                   
  int*                     numplugs;                      
  node_count_t             numNode;                       
  int                      N_IIF;                         
  IonTypeList              iontypes;                      
  std::vector<Target>      targets;                       
  IIF_Mask_t*              IIFmask;                       
  std::vector<IonTypeList> plugtypes;                     
  opencarp::sf_vec*  gdata[NUM_IMP_DATA_TYPES];     
  opencarp::FILE_SPEC      logger;
 
  double dt;          
  int numSubDt;       
 
#ifdef HDF5
  hid_t file;            
#endif  // ifdef HDF5
 
  MULTI_IF() : doppel(false), N_Nodes(NULL), NodeLists(NULL), IIF({}), extUpdateVm(false), logger(NULL)
  {
    zero_data();
  }
 
  ~MULTI_IF() {}
 
  void zero_data() {
    name = "";
    N_Nodes = NULL;
    NodeLists = NULL;
    IIF = {};
    STRUCT_ZERO(svd);
    STRUCT_ZERO(procdata);
    ldata = NULL;
    contiguous = NULL;
    trace_info = NULL;
    numplugs = NULL;
    iontypes = {};
    IIFmask = NULL;
    plugtypes = {};
    STRUCT_ZERO(gdata);
  }
 
  void initialize_MIIF();
  void initialize_currents(double, int);
 
  void compute_ionic_current(bool flag_send = 1, bool flag_receive = 1);  // pMIIF
 
  void free_MIIF();  // pMIIF
 
  void sv_dump_add(int, const IonType&, int, int, int, const char *, const char *);
  int  sv_dump_add_by_name(int, char *, char *, char *, char *);
  void sv_dump_add_by_name_list(int, char *, char *, char *, char *,
                                char *, double, double);
  size_t dump_svs(opencarp::base_timer *);
  void close_svs_dumps();
  void dump_luts_MIIF(bool);
 
  void  dump_state(char *, float, opencarp::mesh_t gid, bool, unsigned int);
  void  transmem_stim_species(float, const char *, float, int *, int);
  float restore_state(const char *, opencarp::mesh_t gid, bool);
  void  releaseRealData();
  void  releaseRealDataDuringInit();
  void  getRealData();
  int   adjust_MIIF_variables(const char* variable,
                              const SF::vector<SF_int> & indices,
                              const SF::vector<SF_real> & values);
  void MIIF_change_dt(double);
  bool use_stretch();
 
  void *thread_initialize_MIIF();
};
 
extern opencarp::FILE_SPEC _nc_logf;
 
void doppel_MIIF(MULTI_IF *, MULTI_IF *);
void doppel_update(MULTI_IF *, MULTI_IF *);
void free_doppel(MULTI_IF *);
void dup_IMP_node_state(IonIfBase&, node_index_t, node_index_t, GlobalData_t **ldata);
 
void* get_IIF_plugparam(IonIfBase&, int);
int   get_plug_flag(char *, int *, IonTypeList&);
int   IMPdataLabel2Index(const char *);
char* tokstr_r(char *s1, const char *s2, char **lasts);
 
void open_trace(MULTI_IF *MIIF, int n_traceNodes, int *traceNodes, int *label, opencarp::sf_mesh* imesh);
void dump_trace(MULTI_IF *MIIF, limpet::Real time);
 
 
#define USED_DAT(I, F) ( (I)->get_reqdat()&F || (I)->get_moddat()&F)
 
#define get_plug_params(M, R, P) (P ## _Params *)get_IIF_plugparam(*(M.IIF[R]), P ## _ID)
 
 
#define SVD_add(I, R, T, M) {T ## _state *sv; int dtype = 0; sv_dump_add(&I, R,                                          \
                                                                         T ## _ID, offsetof(T ## _state,                 \
                                                                                            M),                          \
                                                                         sizeof(sv->M), dtype, # R "." # T "." # M, # T, \
                                                                         # R); }
}  // namespace limpet
 
#endif  // MULTI_ION_IF_H