LUT.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 LUT_H
#define LUT_H
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>
#include "limpet_types.h"
#include "target.h"
 
// define so that LUT exist only in device memory
#define LUT_DEV_ONLY
 
namespace limpet {
 
typedef double LUT_data_t;
 
struct LUT {
  char       *name;   
  int         rows;   
  int       cols;   
  float         mn;   
  float         mx;   
  float        res;   
  float       step;   
  int     mn_ind;   
  int       mx_ind;   
  float         dt;   
  LUT_data_t **tab;   
};
 
 
void         LUT_alloc( LUT *psv, int cols, float mn, float mx, float res,
                        const char*, Target target );
int          LUT_dump( LUT *plut, const char * );
int          check_LUT( LUT* );
LUT_data_t   LUT_interp( LUT *t, int i, int j, GlobalData_t x );
LUT_data_t   LUT_derror( LUT *t, int idx, GlobalData_t x );
#if defined MLIR_CODEGEN && (defined __CUDA__ || defined __HIP__)
#ifdef __cplusplus
extern "C"
{
#endif  // ifdef __cplusplus
__host__ __device__
#endif
LUT_data_t   LUT_interpRow( LUT *tab, GlobalData_t val, int i, LUT_data_t*);
#if defined MLIR_CODEGEN && (defined __CUDA__ || defined __HIP__)
#ifdef __cplusplus
}
#endif  // ifdef __cplusplus
#endif
void         LUT_problem( LUT *, double, int, const char * );
void         IIF_warn(const int wv, const char* error);
void         destroy_lut( LUT *plut, Target target );
 
using ::opencarp::dupstr;
using ::opencarp::f_open;
using ::opencarp::FILE_SPEC;
using ::opencarp::is_big_endian;
using ::opencarp::log_msg;
 
template<typename T>
T** build_matrix_ns(int m, int n, int size, Target target)
{
  T **ptr = NULL;
  T *buf;
 
  buf = allocate_on_target<T>(target, m * n);
  if( buf==NULL ) {
    log_msg(0, 5, 0, "Not enough memory for matrix\n" );
    exit(1);
  }
 
  ptr = allocate_on_target<T*>(target, m);
  for ( int i=0; i<m; i++ )
    ptr[i] = buf + i*n;
 
  return ptr;
}
 
LUT_data_t*  LUT_row( LUT *lut, GlobalData_t val, int locind );
 
#ifdef __cplusplus
extern "C"
{
#endif  // ifdef __cplusplus
// LUT functions for MLIR models
// Implements LUT_interpRow for multiple elements to be placed in a vector
void
LUT_interpRow_n_elements(char *tab, char *val_ptr, int offset, int distance,
                         int index,  int n, char* row_ptr, int lut_numelements);
 
void LUT_interpRow_mlir(char *table, int i, char* row_ptr,
                        int lut_num_elements, int vector_size);
                        
void LUT_problem_mlir( char *tab, GlobalData_t val, int locind);
 
#ifdef __cplusplus
}
#endif  // ifdef __cplusplus
 
#define LUT_entry(A, I, J) (A)->tab[I][J]
 
#ifdef IMP_FAST
#define LUT_index( T, V, W )  (int)((V)*T->step)
#define LUT_constrain( T, V, W )
 
#else
 
int LUT_index( LUT *tab, GlobalData_t val, int locind );
 
#define LUT_constrain(T, V, W, N )  \
  if( V>=T->mx){/*fprintf(stderr, "table overbound:  %g\n", V );*/V=T->mx;}\
  if( V<=T->mn){/*fprintf(stderr, "table underbound: %g\n", V );*/V=T->mn;}
#endif
 
}  // namespace limpet
 
#endif