/***********************************************************
afvp.h
Header file for the AF-VP model
Author: Jie Lian
************************************************************/
#ifndef _AFVP_H_
#define _AFVP_H_
#define MAX_AVJ_TM 3 // max count of waves allowed in AVJ
#define MAX_VENT_TM 3 // max count of waves allowed in ventricle
#define BUFLIM 80 // string buffer length
enum {ANTEGRADE,RETROGRADE,BIDIRECTION}; // direction of activation
enum {REFRACTORY,PHASE4}; // AVJ phases
enum {SENSE,PACE}; // A/V event type
typedef struct { // data structure of simulation environment
// programmable parameters
char fnRR[BUFLIM]; // output RR interval filename
char fnAA[BUFLIM]; // output AA interval filename
char fnAV[BUFLIM]; // output AVJ status filename
char fnLOG[BUFLIM]; // output event log filename
long MAX_RR; // max RR intervals to run
double MAX_TIME; // max running time in seconds
double Ts; // sampling interval
double RR0; // initial RR interval
// working parameters
FILE *fprr; // point to fnRR
FILE *fpaa; // point to fnAA
FILE *fpav; // point to fnAV
FILE *fplog; // point to fnLog
long beat; // beat counter [0 .. MAX_RR]
double t; // simulation time [0 .. MAX_TIME]
} EnvStruct;
typedef struct { // data structure of atrium model
// programmable parameters
int AA_MODEL; // AA interval generator method
double lambda; // mean rate of Afib bombardment on AV junction
double AAstd; // standard deviation of AA interval
double dVmean; // mean potential increment by Afib bombardment
double dVstd; // standard deviation of dV
double AtrDly; // atrial conduction delay from SA node to AVJ
double S1S2; // atrial pacing protocol S1S2 interval
double S2S3; // atrial pacing protocol S2S3 interval
// working parameters
double dV; // actual calculated dV
double NextAA; // time interval to the next Afib impulse
double t; // timer started after A event
long nF[2]; // number of atrial fusions in phase 4 & refr period
long nAf[2]; // number of AF events in phase 4 & refr period
} AtrStruct;
typedef struct { // data structure of AV junction model
// programmable parameters
double Vt; // AV junction threshold potential
double Vr; // AV junction resting potential
double dVdt; // original V4 (AVJ spontaneous depolarization slope)
double MinAVDa; // minimum anterograde AV conduction delay
double MinAVDr; // minimum retrograde AV conduction delay
double MinRef; // minimum AVJ refractory period
double Ref_std; // standard deviation of the AVJ refractory period
double alpha; // max extension of AV conduction time
double beta; // max extension of AVJ refractory period
double tau_c; // time constant for AV conduction curve
double tau_r; // time constant for AVJ recovery curve
double delta; // electrotonic modulation control parameter (strength)
double theta; // electrotonic modulation control parameter (time)
// working parameters
int phase; // AVJ phase flag (phase4 or refractory)
int dir; // direction of most recent activation
double Vm; // AVJ membrane potential
double V4; // actual AVJ spontaneous depolarization slope
double ref; // actually calculated refractory period
double AVDa; // corrected antegrade AV delay
double AVDr; // corrected retrograde AV delay
double RT; // AVJ recovery time
double RT0; // time at the start of AVJ recovery period
double tmA[MAX_AVJ_TM][2]; // AVJ ante activation timer & conduction time
double tmR[MAX_AVJ_TM][2]; // AVJ retr activation timer & conduction time
int nA; // number of active ante. AV conduction timers
int nR; // number of active retr. AV conduction timers
double t; // timer started after AVJ enters refractory period
long nF[2]; // number of AVJ fusions in phase 4 & refr period
long nB[2]; // number of blocked impulses (ante & retr)
} AvjStruct;
typedef struct { // data structure of ventricle model
// programmable parameters
double AntDly; // anterograde conduction delay from AVJ to RV electrode
double RetDly; // retrograde conduction delay from RV electrode to AVJ
double ref; // ventricular refractory period
// working parameters
double tmA[MAX_VENT_TM]; // timer starts after AV depol, ante cond for Vs
double tmR[MAX_VENT_TM]; // timer starts after Vp for retr conduction
int nA; // number of active retrograde conduction timers
int nR; // number of active antegrade conduction timers
double tmA0; // time of last ante AV timeout, start ante cond
double tmR0; // time of last Vp delivery, start retr cond
double t; // timer started after V event
long nF[2]; // number of ventricular fusions in phase 4 & refr period
long nB[2]; // number of blocked impulses (ante & retr)
} VtrStruct;
typedef struct { // data structure of RV electrode model
// programmable parameters
int VP_MODEL; // ventricular pacing method
double BI; // standby ventricular pacing basic interval
// working parameters
int VpFlg; // ventricular pacing flag, 1-Vp, 0-Vs
double NextVV; // ventricular pacing interval (escape interval)
double RR; // measured RR interval
double t; // clock timer for Vp
long cnt[2]; // event counters for Vp and Vs
} VeleStruct;
// functions defined by AF-VP model
//double gamdev(int x, long *idum);
double poidev(double xm, long *idum);
double expdev(double xm, long *idum);
double gaussian(double mean, double sd, double r1, double r2);
double ran2(long *i);
double ran3(int *i);
void ErrMsg(char *msg, int errcode);
void ReadConfig(char *fn);
double ReadLine(FILE *fp, double v, char *str);
void LogConfig(FILE *fp);
void LogEvent(FILE *fp, char *msg);
void LogStat(FILE *fp);
void ModelInit(void);
void ModelExit(void);
void UpdateAtTs(void);
void AnteHitAvj(void);
void RetrHitAvj(void);
void StartAvjTm(int dir);
void StopAvjTm(int dir);
void StartVtrTm(int dir);
void StopVtrTm(int dir);
void AnteEscAvj(void);
void RetrEscAvj(void);
void ActivateAvj(void);
void StartAvjRef(void);
void StartAvjPh4(void);
void VtrFusion(void);
void VtrSense(void);
void VtrPace(void);
void RegEventV(int event);
double GetVpIntv(double RR, double BI, double VpIntv, int method);
double GetAfIntv(double lambda, double sd, int method);
#endif // #ifndef _AFVP_H_