pHtools.h

Go to the documentation of this file.

/*

Copyright (C) 2011,2013 Daniel P. Dougherty

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef _pHtools_h
#define _pHtools_h

#include <math.h>
#include <stdlib.h> 
#include <stdio.h>
#include <string.h>


#define MAX_TRACKED_PHDERIVS 20
#define MAX_TRACKED_SPECIES 20


/*Bisection*/
/*#define CB_ROOT_METHOD 0 
*/
/*Brent -- usually many fewer iterations to converge.*/
#define CB_ROOT_METHOD 1
 
/*
Certainly more than enough space for typical fermentation end-products and up 
to some modest length peptides or polyomers.  Increase this number 
if your molecules have more dissociable groups in your application.
*/
#define MAX_BUFFERIONS 20 

/*
A solution can have thousands of components but this is the number we are willing
to model.  Increase if you need to.
*/
#define MAX_SOLCOMPS 10

/*
A solution can be a mixture of other components. This is the maximum number of
nested (contained) solutions.
*/
#define MAX_BUFFERCONTAINS 10

#define MAX_BRENT_ITER 100 
#define MAX_BRENT_EPS 3.0e-8

#define MAXBUFFSOL 20
#define LYTES 321

/*
We define some types to hold the "tableaus" describing the buffers according
to the published pHtools framework.
*/
typedef struct {
  int npKa;
  double pKa[MAX_BUFFERIONS]; 
  int npKb;
  double pKb[MAX_BUFFERIONS];
  double SaltType;
} BUFFERION;

typedef struct { 
  int ncomp;
  char *name[MAX_SOLCOMPS]; 
  double value[MAX_SOLCOMPS];
} BUFFERLIST;


typedef struct { 
  int charge;        /*The charge of the ion that you want to track*/                  
  char externvar[256];  /*The client program's variable name*/
  double *externval;    /*The client program's variable value*/
  double conc;       /*The molar concentration*/
} SPECIES;


typedef struct {
  char name[256];
  char nickname[256]; 
  char comment[256];
  char createdby[256];
  char createdon[256];
  char* externvar; 
  char* externval; 
  double conc;
  BUFFERLIST contains;
  int ngroups;
  BUFFERION group[MAX_BUFFERIONS];
  int nspecies; 
  SPECIES species[MAX_TRACKED_SPECIES];
} BUFFERCOMP;



typedef struct { 
  int ncomp;
  BUFFERCOMP comp[MAX_SOLCOMPS];
  char name[256];/*This is the unique xpp name identifying this buffer solution.*/
  char pHnam[256];
  double *pHval;
  double initpH;
  char dpHdtnam[256];
  double *dpHdtval;
  char bcapnam[256];
  double initBcap; 
  char istrnam[256];
  double initIstr;
  char cbnam[256];
  double initCb;
  int dospecies;
  int doionicstr;
  int doCb;
} BUFFERSOL;


void init_buffer_database(void);
void create_buffersol(char *name);
void deblank(char *s1);
int find_buffersol(char *name);
void show_all_buffersols(void);

void setpHtoolsValueSetter(int (*functionPtr)(char *name, double value));
void setpHtoolsValueGetter(int (*functionPtr)(char *name, double* value));
void setpHtoolsValueInitializer(int (*functionPtr)(char *name, double value));
void setpHtoolsLogFile(FILE *logger);

void strupr(char *s);

int pHtoolsprintf(char *fmt, ...);
void mix_buffersol(char *name, char *ord_pairs);
void add_buffersol(char *name, char *ord_pairs);
double initialize_pH(char *name);
double initialize_ionicstr(char *name);
double initialize_Cb(char *name);
double initialize_buffcap(char *name);
void track_buffersol(char *name, char *ord_pairs);
void track_species(char *name,char* ord_triplets);
void track_ionic_strength(char *name,char* istrnam);
void track_Cb(char *name,char* cbnam);
void track_buffcap(char *name,char* bcapnam);
void track_pH(char *name,char* pHnam,char* dpHdtnam);

int findspecies(int charge, SPECIES *sp, int nsp);
BUFFERSOL *mksol(BUFFERLIST *sollist);
void dilutesol(BUFFERSOL *SOL, double amount);
void mixintosol(BUFFERSOL *SOL1, BUFFERSOL *SOL2, double weight);
void addsol(BUFFERSOL *SOL1, BUFFERSOL *SOL2);
int struct_cmp_by_nickname(const void *a, const void *b);
void sortandwaterlast(BUFFERSOL *SOL1);
void listcpy(BUFFERLIST *dest, BUFFERLIST *src);
void groupcpy(BUFFERION *dest, BUFFERION *src);
void speciescpy(SPECIES *dest, SPECIES *src);
void compcpy(BUFFERCOMP *dest, BUFFERCOMP *src);
double initpHCall(BUFFERSOL *SOL, double x1, double x2, double tol);
double initpHBisection(BUFFERSOL *SOL, double x1, double x2, double xacc);
double initpHBrent(BUFFERSOL *SOL, double x1, double x2, double tol);
double Cb(BUFFERSOL *SOL, double pH, int doupdate);
double ionicstr(BUFFERSOL *SOL, double pH, int doupdate);
double buffcapeval(BUFFERSOL *SOL, double pH, int doupdate);
double dpHdt(BUFFERSOL *SOL, double pH, BUFFERLIST *derivs);
double dCbdt(BUFFERSOL *SOL, double pH, BUFFERLIST *derivs);
void showBuffer(BUFFERCOMP *C);
void showSol(BUFFERSOL *C);
void species(BUFFERSOL *SOL, double pH, int doupdate);
double dCbdH(BUFFERSOL *SOL, double pH);
BUFFERSOL* getBufferSolution(int j);


BUFFERCOMP* WATER; 

/*
Define and statically allocate the needed storage here.
*/
BUFFERSOL *buffersol[MAXBUFFSOL];

#endif