ion_type.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 LIMPET_ION_TYPE_H
#define LIMPET_ION_TYPE_H

#include "limpet_types.h"
#include "target.h"
#include <string>
#include <vector>
#include <stdio.h>

namespace limpet {

template<class T>
constexpr inline T max(T a, T b ){ return a > b ? a : b; }
template<class T>
constexpr inline T min(T a, T b ){ return a < b ? a : b; }

/*
MODEL SPECIFIC DEFINITIONS

Each ionic model must have a model_id, a name and a data structure
containing all its adjustable parameters. This data structure is
defined in the header files of the respective ionic models.
*/

#include "ION_IF_datatypes.h"

class IonIfBase;

typedef float Gatetype;
typedef GlobalData_t (*SVgetfcn)(IonIfBase&,int,int);
typedef void (*SVputfcn)(IonIfBase&,int,int,GlobalData_t);
typedef char   IIF_Mask_t;

class IonType {
public:
  using params_type = void; 
  using state_type = void; 
  using private_type = void; 
  using private_type_vector = void; 
private:
  std::string _name; 
  bool _plugin; 

public:
  IonType(std::string name, bool plugin) : _name(std::move(name)), _plugin(plugin) {}

  const std::string& get_name() const;

  bool is_plugin() const;

  virtual size_t params_size() const = 0;

  virtual size_t dlo_vector_size() const = 0;

  virtual uint32_t reqdat() const = 0;

  virtual uint32_t moddat() const = 0;

  virtual void initialize_params(IonIfBase& imp) const = 0;

  virtual void construct_tables(IonIfBase& imp) const = 0;

  virtual void destroy(IonIfBase& imp) const = 0;

  virtual void initialize_sv(IonIfBase& imp, GlobalData_t** data) const = 0;

  virtual Target select_target(Target target) const = 0;

  virtual void compute(Target target, int start, int end, IonIfBase& imp, GlobalData_t** data) const = 0;

  virtual bool has_trace() const = 0;

  virtual void trace(IonIfBase& imp, int node, FILE* file, GlobalData_t** data) const = 0;

  virtual void tune(IonIfBase& imp, const char* im_par) const = 0;

  virtual int read_svs(IonIfBase& imp, FILE* file) const = 0;

  virtual int write_svs(IonIfBase& imp, FILE* file, int node) const = 0;

  virtual SVgetfcn get_sv_offset(const char* svname, int* off, int* sz) const = 0;

  virtual int get_sv_list(char*** list) const = 0;

  virtual int get_sv_type(const char* svname, int* type, char** type_name) const = 0;

  virtual void print_params() const = 0;

  virtual void print_metadata() const = 0;

  virtual IonIfBase* make_ion_if(Target target, int num_node,
      const std::vector<std::reference_wrapper<IonType>>& plugins) const = 0;

  virtual void destroy_ion_if(IonIfBase *imp) const = 0;

  bool operator==(const IonType& other) const;

  bool operator!=(const IonType& other) const;
};

// Shorthand for lists of references to IonTypes
using IonTypeList = std::vector<std::reference_wrapper<IonType>>;

// TODO: replace with std::optional<std::reference_wrapper<IonType>>
// Using std::optional would be nice but requires C++17
IonType* get_ion_type(const std::string& name);

} // limpet namespace

#endif // LIMPET_ION_TYPE_H