ionicsOnFace.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
// ----------------------------------------------------------------------------
 
#if WITH_EMI_MODEL
 
#ifndef _IONICSONFACE_H
#define _IONICSONFACE_H
 
#include "physics_types.h"
#include "sim_utils.h"
#include "stimulate.h"
#include "IGBheader.h"
#include "timers.h"
 
#include "sf_interface.h"
#include "MULTI_ION_IF.h"
#include "sv_init.h"
 
namespace opencarp {
 
 
void region_mask_onFace(mesh_t meshspec, 
                        std::vector<std::string> & tags_data,   
                        hashmap::unordered_map<SF::tuple<mesh_int_t>, 
                        std::pair<SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>,
                        SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>>> & line_face,
                        hashmap::unordered_map<SF::triple<mesh_int_t>, 
                        std::pair<SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>,
                        SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>>> & tri_face,
                        hashmap::unordered_map<SF::quadruple<mesh_int_t>, 
                        std::pair<SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>, 
                        SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>>> & quad_face,
                        hashmap::unordered_map<std::pair<mesh_int_t,mesh_int_t>, mesh_int_t> & map_vertex_tag_to_dof,
                        hashmap::unordered_map<mesh_int_t, std::pair<mesh_int_t, mesh_int_t>> & map_elem_uniqueFace_to_tags,
                        const hashmap::unordered_set<int> & intra_tags,
                        SF::vector<RegionSpecs_EMI> & regspec,
                        SF::vector<int> & regionIDs, bool mask_elem, const char* reglist);
 
class IonicsOnFace : public Basic_physic
{
  public:
  limpet::MULTI_IF* miif = NULL; 
  mesh_t    ion_domain;          
 
  generic_timing_stats comp_stats; 
 
  hashmap::unordered_map<SF::tuple<mesh_int_t>, 
                         std::pair<SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>,
                                   SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>>> line_face;
  hashmap::unordered_map<SF::triple<mesh_int_t>, 
                         std::pair<SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>,
                                   SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>>> tri_face;
  hashmap::unordered_map<SF::quadruple<mesh_int_t>, 
                        std::pair<SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>, 
                                  SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>>> quad_face;
 
  hashmap::unordered_map<std::pair<mesh_int_t,mesh_int_t>, mesh_int_t> map_vertex_tag_to_dof;
 
  std::vector<std::string> tags_data; 
 
  hashmap::unordered_set<int> intra_tags; 
  hashmap::unordered_map<mesh_int_t, std::pair<mesh_int_t, mesh_int_t>> map_elem_uniqueFace_to_tags; 
 
  IonicsOnFace(mesh_t gid) : ion_domain(gid)
  {
    switch(ion_domain) {
      case intra_elec_msh:
        name = "Myocard IonicsOnFace"; break;
      default:
        name = "IonicsOnFace"; break;
    }
  }
 
  void set_tags_onFace(std::vector<std::string> & tags_data_)
  {
    tags_data.assign(tags_data_.begin(),tags_data_.end());
  }
 
  void set_surface_mesh_data( hashmap::unordered_map<SF::tuple<mesh_int_t>, 
                              std::pair<SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>,
                              SF::emi_face<mesh_int_t,SF::tuple<mesh_int_t>>>> & line_face_,
                              hashmap::unordered_map<SF::triple<mesh_int_t>, 
                              std::pair<SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>,
                              SF::emi_face<mesh_int_t,SF::triple<mesh_int_t>>>> & tri_face_,
                              hashmap::unordered_map<SF::quadruple<mesh_int_t>, 
                              std::pair<SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>, 
                              SF::emi_face<mesh_int_t,SF::quadruple<mesh_int_t>>>> & quad_face_,
                              hashmap::unordered_map<std::pair<mesh_int_t,mesh_int_t>, mesh_int_t> & map_vertex_tag_to_dof_){
    line_face = line_face_;
    tri_face = tri_face_;
    quad_face = quad_face_;
    map_vertex_tag_to_dof = map_vertex_tag_to_dof_;
  }
 
  void set_face_region_data(hashmap::unordered_set<int> intra_tags_,
                            hashmap::unordered_map<mesh_int_t, std::pair<mesh_int_t, mesh_int_t>> & map_elem_uniqueFace_to_tags_)
  {
    intra_tags = intra_tags_;
    map_elem_uniqueFace_to_tags = map_elem_uniqueFace_to_tags_;
  }
  void initialize();
 
  void destroy();
 
  void compute_step();
 
  void output_step();
  ~IonicsOnFace() = default;
 
  double timer_val(const int timer_id);
  std::string timer_unit(const int timer_id);
 
  private:
  double setup_MIIF(limpet::node_count_t nnodes, int nreg, IMPregion_EMI* impreg, int* mask,
             const char *start_fn, int numadjust, IMPVariableAdjustment *adjust,
             double time_step, bool close);
 
};
 
void compute_IIF_OnFace(limpet::IonIfBase& pIF, limpet::GlobalData_t** impdata, limpet::node_index_t n);
 
struct sv_data_onFace {
  char*        name;        
  char**       imps;        
  char**       svNames;     
  int*         svInds;      
  int*         svSizes;     
  int*         svOff;       
  FILE_SPEC    outf;        
  void**       getsv;       
  sf_vec* ordered;     
  char*        units;       
  float        bogus;       
};
 
struct gvec_data_OnFace {
  unsigned int           nRegs;        
  bool                   inclPS;       
  SF::vector<sv_data_onFace>    vecs;         
  bool                   rm_dumps;     
};
 
void init_sv_gvec_onFace(gvec_data_OnFace& GVs, limpet::MULTI_IF* miif, sf_vec & tmpl,
                         igb_output_manager & output_manager);
 
void assemble_sv_gvec_onFace(gvec_data_OnFace & gvecs, limpet::MULTI_IF *miif);
}
#endif
#endif