timer_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 TIMER_H
#define TIMER_H

#include <cstdio>
#include <cstdlib>
#include <cstdbool>
#include <cmath>

#include <string>
#include <vector>


namespace opencarp {

enum io_time {iotm_console = 0, iotm_state_var, iotm_spacedt, iotm_chkpt_list, iotm_chkpt_intv, iotm_trace, iotm_num_timers};

enum t_timer {EQUDIST, NONEQUDIST};

struct base_timer {
  t_timer       type;          
  const char*   name;          
  bool          triggered;     
  int           trigger_count; 
  int           numIOs;        
  double        trigger_dur;   
  long          d_trigger_dur; 
  int           active;        
  std::string   pool;          

  virtual void update() = 0;
  virtual void reset() = 0;

  inline void assign_pool(const char* poolname)
  {
    pool = poolname;
  }
};


class timer_manager {
public:

  double time;       
  long   d_time;     
  double time_step;  
  double start;      
  long   d_start;    
  double end;        
  long   d_end;      

  std::vector<base_timer*> timers; 

  timer_manager(double inp_dt, double inp_start, double inp_end)
  {
    setup(inp_dt, inp_start, inp_end);
    timers.assign(iotm_num_timers, nullptr);
  }

  inline void update_timers()
  {
    d_time++;
    time = d_time * time_step;

    for (base_timer* t : timers)
      if(t != nullptr) t->update();
  }

  inline void reset_timers() {
    time = start;
    d_time = d_start;

    for (base_timer* t : timers)
      if(t != nullptr) t->reset();
  }

  int add_eq_timer(double istart, double iend, int ntrig, double iintv, double idur,
                   const char *iname, const char *poolname = nullptr);

  int add_neq_timer(const std::vector<double> & itrig, double idur, const char *iname,
                    const char *poolname = nullptr);

  inline int
  add_singlestep_timer(double tg, double idur, const char *iname,
                       const char *poolname = nullptr)
  {
    return add_eq_timer(tg, tg, 0, 0, idur, iname, poolname);
  }

  void initialize_eq_timer(double istart, double iend, int ntrig, double iintv,
                           double idur, int ID, const char *iname, const char* poolname = nullptr);

  void initialize_neq_timer(const std::vector<double> & itrig, double idur, int ID,
                            const char *iname, const char* poolname = nullptr);

  inline void
  initialize_singlestep_timer(double tg, double idur, int ID, const char *iname,
                              const char *poolname = nullptr)
  {
    initialize_eq_timer(tg, tg, 0, 0, idur, ID, iname, poolname);
  }

  inline size_t num_timers()           const {return timers.size();}
  inline double timer_duration(int ID) const {return ID > -1 ? timers[ID]->trigger_dur : 0.0;}
  inline bool   elapsed()              const {return d_time > d_end;}

  inline bool trigger(int ID) const
  {
    return ID > -1 && timers[ID] != nullptr && timers[ID]->triggered;
  }

  inline bool triggered_now(int ID) const
  {
    return ID > -1 &&
           timers[ID] != nullptr &&
           ((timers[ID]->d_trigger_dur) - (timers[ID]->active)) == 1;
  }

  inline bool trigger_end(int ID) const
  {
    return ID > -1 &&
           timers[ID] != nullptr &&
           timers[ID]->triggered &&
           !timers[ID]->active;
  }

  inline int  trigger_elapse(int ID) const
  {
    if(ID > -1 && timers[ID] != nullptr)
      return timers[ID]->d_trigger_dur - timers[ID]->active - 1;
    else
      return 0;
  }

  inline int active_ticks(int ID) const
  {
    if(ID > -1 && timers[ID] != nullptr)
      return timers[ID]->triggered ? timers[ID]->d_trigger_dur - timers[ID]->active : 0;
    else
      return 0;
  }

  void setup(double inp_dt, double inp_start, double inp_end);
};


struct timer_eq : base_timer
{
  const timer_manager* mng;

  double        start;      
  long          d_start;    
  double        end;        
  long          d_end;      
  double        intv;       
  long          d_intv;     
  double        nxt;        
  int           d_nxt;      

  void initialize(const timer_manager* t, double istart, double iend, int ntrig, double iintv,
                  double idur, const char *iname);
  void update();
  void reset();
};

struct timer_neq : base_timer
{
  const timer_manager* mng;

  std::vector<double> trig;    
  std::vector<long>   d_trig;  

  void initialize(const timer_manager* t, const std::vector<double> & itrig,
                  const double idur, const char *iname);
  void update();
  void reset();
};

}  // namespace opencarp

#endif