kinetics.c

GESPI 2.0动态系统模拟工具

/* irreversible Henri-Michaelis-Menten rate equation */
/*                                                   */

double ihmm( double s[], int r)
          /* eff[r][0] - substrate           */
          /* params[r][0] - Km for substrate    */
          /* params[r][1] - max forward vel.    */
{
 double sb;

 sb = s[eff[r][0]];
 return (sb*params[r][1])  / ( sb + params[r][0] );
}

double dihmms( double s[], int r, int e )
{
 double c;

  c = 1 + s[eff[r][0]]/params[r][0];
 return params[r][1]/(c*c*params[r][0]);
}


/*                                                 */
/* reversible Henri-Michaelis-Menten rate equation */
/*                                                 */

double hmm( double s[], int r)
          /* eff[r][0] - substrate           */
          /* eff[r][1] - product             */
          /* params[r][0] - Km for substrate    */
          /* params[r][1] - Km for product      */
          /* params[r][2] - max forward vel.    */
          /* params[r][3] - max reverse vel.    */
{
 double nsb, npr;

 nsb = s[eff[r][0]]/params[r][0];
 npr = s[eff[r][1]]/params[r][1];
 return (nsb*params[r][2] - npr*params[r][3]) / (1 + nsb + npr);
}

double dhmms( double s[], int r, int e )
{
  double c;

  c = s[eff[r][1]]*params[r][0] + s[eff[r][0]]*params[r][1] + params[r][0]*params[r][1];
  return ( params[r][0]*params[r][1] * ( s[eff[r][1]]*(params[r][2]+params[r][3]) + params[r][2]*params[r][1] ) ) / ( c*c );
}

double dhmmp( double s[], int r, int e )
{
 double c;

 c = s[eff[r][1]]*params[r][0] + s[eff[r][0]]*params[r][1] + params[r][0]*params[r][1];
 return - ( params[r][0]*params[r][1] * ( s[eff[r][0]]*(params[r][2]+params[r][3]) + params[r][0]*params[r][3] ) ) / ( c*c );
}


/*                                                                     */
/* reversible Henri-Michaelis-Menten rate equation w/ competitive inh. */
/*                                                                     */

double hmmsi( double s[], int r )
          /* eff[r][0] - substrate           */
          /* eff[r][1] - product             */
          /* eff[r][2] - inhibitor           */
          /* params[r][0] - Km for substrate    */
          /* params[r][1] - Km for product      */
          /* params[r][2] - max forward vel.    */
          /* params[r][3] - max reverse vel.    */
          /* params[r][4] - inhibition const.   */
{
 double nsb, npr, in;

 nsb = s[eff[r][0]]/params[r][0];
 npr = s[eff[r][1]]/params[r][1];
 in = s[eff[r][3]];
 return (nsb*params[r][2] - npr*params[r][3]) / (1 + nsb + npr + in/params[r][4]);
}

double dhmmsis( double s[], int r, int e )
{
 double sb, pr, inn, c;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 inn = s[eff[r][2]]/params[r][4];
  c = 1 + sb/params[r][0] + pr/params[r][1] + inn;
 return (params[r][2]*(1+inn)+pr*(params[r][2]+params[r][3])/params[r][1]) / (c*c*params[r][0]);
}

double dhmmsip( double s[], int r, int e )
{
 double nsb, pr, in, c;

 nsb = s[eff[r][0]]/params[r][0];
 pr = s[eff[r][1]];
 in = s[eff[r][2]];
  c = 1 + nsb + pr/params[r][1] + in/params[r][4];
 return - (params[r][3]*(1+in/params[r][4])+nsb*(params[r][2]+params[r][3])) / (c*c*params[r][1]);
}

double dhmmsii( double s[], int r, int e )
{
 double nsb, npr, in, c;

 nsb = s[eff[r][0]]/params[r][0];
 npr = s[eff[r][1]]/params[r][1];
 in  = s[eff[r][2]];
  c = 1 + nsb + npr + in/params[r][4];
 return - (nsb*params[r][2] - npr*params[r][3]) / (c*c*params[r][4]);
}

/*                                                                         */
/* reversible Henri-Michaelis-Menten rate equation w/ non-competitive inh. */
/*                                                                         */

double hmmci( double s[], int r )
          /* eff[r][0] - substrate           */
          /* eff[r][1] - product             */
          /* eff[r][2] - inhibitor           */
          /* params[r][0] - Km for substrate    */
          /* params[r][1] - Km for product      */
          /* params[r][2] - max forward vel.    */
          /* params[r][3] - max reverse vel.    */
          /* params[r][4] - inhibition const.   */
{
 double nsb, npr, in;

 nsb = s[eff[r][0]]/params[r][0];
 npr = s[eff[r][1]]/params[r][1];
 in = s[eff[r][2]];
 return (nsb*params[r][2] - npr*params[r][3]) / ((1 + nsb + npr) * (1 + in/params[r][4]));
}

double dhmmcis( double s[], int r, int e )
{
 double npr, c;

 npr = s[eff[r][1]]/params[r][1];
   c = 1 + s[eff[r][0]]/params[r][0] + npr;
 return (params[r][2] + npr*(params[r][2]+params[r][3])) / (c*c*params[r][0]*(1+s[eff[r][2]]/params[r][4]));
}

double dhmmcip( double s[], int r, int e )
{
 double nsb, c;

 nsb = s[eff[r][0]]/params[r][0];
 c = 1 + nsb + s[eff[r][1]]/params[r][1];
 return -(params[r][3] + nsb*(params[r][2]+params[r][3])) / (c*c*params[r][1]*(1+s[eff[r][2]]/params[r][4]));
}

double dhmmcii( double s[], int r, int e )
{
 double nsb, npr, c, d;

 nsb = s[eff[r][0]]/params[r][0];
 npr = s[eff[r][1]]/params[r][1];
  c = 1 + nsb + npr;
  d = 1 + s[eff[r][2]]/params[r][4];
 return (npr*params[r][3] - nsb*params[r][2]) / (d*d*c*params[r][4]);
}

/*                                                                     */
/* reversible Henri-Michaelis-Menten rate equation w/ mixed inhibition */
/*                                                                     */

double hmmmi( double s[], int r )
          /* eff[r][0] - substrate            */
          /* eff[r][1] - product              */
          /* eff[r][2] - inhibitor            */
          /* params[r][0] - Km for substrate     */
          /* params[r][1] - Km for product       */
          /* params[r][2] - max forward vel.     */
          /* params[r][3] - max reverse vel.     */
          /* params[r][4] - spec. inh. const.    */
          /* params[r][5] - catal.inh. const.    */
{
 double sb, pr, in;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 in = s[eff[r][2]];
 return (sb*params[r][2]/params[r][0] - pr*params[r][3]/params[r][1]) /
        (1 + in/params[r][4] + (sb/params[r][0] + pr/params[r][1])*(1 + in/params[r][5]) );
}

double dhmmmis( double s[], int r, int e )
{
 double sb, pr, in, c, d;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 in = s[eff[r][2]];
  c = 1 + pr/params[r][1] + in/params[r][4] + pr*in/(params[r][5]*params[r][1]);
  d = c + sb/params[r][0]*(1 + in/params[r][5]);
 return (params[r][2]*c + params[r][3]*pr*(1+in/params[r][5])/params[r][1]) / (params[r][0]*d*d);
}

double dhmmmip( double s[], int r, int e )
{
 double sb, in, c, d;

 sb = s[eff[r][0]];
 in = s[eff[r][2]];
  c = 1 + sb/params[r][0] + in/params[r][4] + sb*in/(params[r][5]*params[r][0]);
  d = c + s[eff[r][1]]/params[r][1]*(1 + in/params[r][5]);
 return -(params[r][3]*c + params[r][2]*sb*(1+in/params[r][5])/params[r][0]) / (params[r][1]*d*d);
}


double dhmmmii( double s[], int r, int e )
{
 double sb, pr, in, c;

 sb = s[eff[r][0]]/params[r][0];
 pr = s[eff[r][1]]/params[r][1];
 in = s[eff[r][2]];
  c = 1  + in/params[r][4] + (sb + pr) * (1 + in/params[r][5]);
 return -(sb*params[r][2]-pr*params[r][3]) * (1/params[r][4]+(sb+pr)/params[r][5])
        / (c*c);
}


/*                                                                  */
/* reversible Henri-Michaelis-Menten rate equation w/ specific act. */
/*                                                                  */

double hmmsa( double s[], int r )
          /* eff[r][0] - substrate            */
          /* eff[r][1] - product              */
          /* eff[r][2] - activator            */
          /* params[r][0] - Km for substrate     */
          /* params[r][1] - Km for product       */
          /* params[r][2] - max forward vel.     */
          /* params[r][3] - max reverse vel.     */
          /* params[r][4] - activation const.    */
{
 double sb, pr, ac;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
 return  ac * (sb*params[r][2]*params[r][1] - pr*params[r][3]*params[r][0])
         /
         ( ac * ( params[r][0]*params[r][1] + params[r][0]*pr + params[r][1]* sb )
           + params[r][0]*params[r][1]*params[r][4] );
}

double dhmmsas( double s[], int r, int e )
{
 double pr, ac, c;

 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
  c =  ac * ( params[r][0]*params[r][1] + params[r][0]*pr + params[r][1]* s[eff[r][0]] )
       + params[r][0]*params[r][1]*params[r][4];
 return ac*params[r][0]*params[r][1] * (  params[r][1]*params[r][2]*(ac+params[r][4])
                                        + ac*pr*( params[r][2]+params[r][3])
                                       )
       / ( c * c );
}

double dhmmsap( double s[], int r, int e )
{
 double sb, ac, c;

 sb = s[eff[r][0]];
 ac = s[eff[r][2]];
  c =  ac * ( params[r][0]*params[r][1] + params[r][0]*s[eff[r][1]] + params[r][1]*sb )
       + params[r][0]*params[r][1]*params[r][4];
 return - ac*params[r][0]*params[r][1] * (  ac*sb*(params[r][2]+params[r][3])
                                         + params[r][0]*params[r][3]*(ac+params[r][4])
                                        )
        / ( c * c );
}

double dhmmsaa( double s[], int r, int e )
{
 double sb, pr, ac, c;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
  c =  ac * ( params[r][0]*params[r][1] + params[r][0]*pr + params[r][1]* s[eff[r][0]] )
       + params[r][0]*params[r][1]*params[r][4];
 return params[r][0]*params[r][1]*params[r][4] * (  sb*params[r][1]*params[r][2]
                                                  - pr*params[r][0]*params[r][3]
                                                 )
       / ( c * c );
}


/*                                                                         */
/* reversible Henri-Michaelis-Menten rate equation w/ catalytic activation */
/*                                                                         */

double hmmca( double s[], int r )
          /* eff[r][0] - substrate            */
          /* eff[r][1] - product              */
          /* eff[r][2] - activator            */
          /* params[r][0] - Km for substrate     */
          /* params[r][1] - Km for product       */
          /* params[r][2] - max forward vel.     */
          /* params[r][3] - max reverse vel.     */
          /* params[r][4] - activation const.    */
{
 double sb, pr, ac;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
 return   ac * ( sb*params[r][1]*params[r][2] - pr*params[r][0]*params[r][3] )
        / (   (ac+params[r][4])
            * (sb*params[r][1] + pr*params[r][0] + params[r][0]*params[r][1])
          );
}

double dhmmcas( double s[], int r, int e )
{
 double ac, pr, c;

 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
  c = s[eff[r][0]]*params[r][1] + pr*params[r][0] + params[r][0]*params[r][1];
 return   ac*params[r][0]*params[r][1] * (  pr*(params[r][2]+params[r][3])
                                          + params[r][1]*params[r][2]
                                         )
        / ( c * c * ( ac + params[r][4] ) );
}

double dhmmcap( double s[], int r, int e )
{
 double sb, ac, c;

 sb = s[eff[r][0]];
 ac = s[eff[r][2]];
  c = sb*params[r][1] + s[eff[r][1]]*params[r][0] + params[r][0]*params[r][1];
 return - ac*params[r][0]*params[r][1] * (  sb*(params[r][2]+params[r][3])
                                          + params[r][0]*params[r][3]
                                         )
        / ( c * c * ( ac + params[r][4] ) );
}

double dhmmcaa( double s[], int r, int e )
{
 double sb, pr, c;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
  c = s[eff[r][2]] + params[r][4];
 return   params[r][4] * ( sb*params[r][1]*params[r][2] + pr*params[r][0]*params[r][3] )
        / ( c * c * ( params[r][0]*params[r][1] + pr*params[r][0] + sb*params[r][1]) );

/* WHAT IS THIS DOING HERE???
 ( (params[r][4]*(sb*params[r][2]/params[r][0] - pr*params[r][3]/params[r][1])) / (c*c*(1+sb/params[r][0]+pr/params[r][1])) );
*/
}


/*                                                                     */
/* reversible Henri-Michaelis-Menten rate equation w/ mixed activation */
/*                                                                     */

double hmmma( double s[], int r )
          /* eff[r][0] - substrate           */
          /* eff[r][1] - product             */
          /* eff[r][2] - activator           */
          /* params[r][0] - Km for substrate    */
          /* params[r][1] - Km for product      */
          /* params[r][2] - max forward vel.    */
          /* params[r][3] - max reverse vel.    */
          /* params[r][4] - spec.act. const.    */
          /* params[r][5] - cat. act. const.    */
{
 double sb, pr, ac;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
 return   ac * (sb*params[r][2]*params[r][1] - pr*params[r][3]*params[r][0])
        / (  params[r][0]*params[r][1]*(ac+params[r][4])
           + (ac+params[r][5])*(sb*params[r][1]+pr*params[r][0])
          );
}

double dhmmmas( double s[], int r, int e )
{
 double pr, ac, c;

 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
  c =  params[r][0]*params[r][1]*(ac+params[r][4])
     + (ac+params[r][5])*(s[eff[r][0]]*params[r][1]+pr*params[r][0]);
 return   ac*params[r][0]*params[r][1] *
          (  params[r][1]*params[r][2]*(ac+params[r][4])
           + pr*(ac+params[r][5])*(params[r][2]+params[r][3])
          )
        / (c * c);
}

double dhmmmap( double s[], int r, int e )
{
 double sb, ac, c;

 sb = s[eff[r][0]];
 ac = s[eff[r][2]];
  c =  params[r][0]*params[r][1]*(ac+params[r][4])
     + (ac+params[r][5])*(sb*params[r][1]+s[eff[r][1]]*params[r][0]);
 return - ac*params[r][0]*params[r][1] *
          (  params[r][0]*params[r][3]*(ac+params[r][4])
           + sb*(ac+params[r][5])*(params[r][2]+params[r][3])
          )
        / (c * c);
}

double dhmmmaa( double s[], int r, int e )
{
 double sb, pr, ac, c;

 sb = s[eff[r][0]];
 pr = s[eff[r][1]];
 ac = s[eff[r][2]];
  c =  params[r][0]*params[r][1]*(ac+params[r][4])
     + (ac+params[r][5])*(sb*params[r][1]+pr*params[r][0]);
 return    (sb*params[r][1]*params[r][2] - pr*params[r][0]*params[r][3])
         * (  params[r][4]*params[r][0]*params[r][0]
            + params[r][5]*(sb*params[r][1]+pr*params[r][0])
           )
        / (c * c);
}


/*                    */
/* Hill rate equation */
/*                    */

double hill( double s[], int r )
          /* eff[r][0] - substrate           */
          /* params[r][0] - K for substrate    */
          /* params[r][1] - max forward vel.    */
          /* params[r][2] - Hill coef.      */
{
 double sb;

 sb = pow(s[eff[r][0]],params[r][2]);
 return sb*params[r][1]/(pow(params[r][0],params[r][2])+sb);
}

double dhills( double s[], int r, int e )
{
 double sb, kh, sb1, d;

 sb = pow(s[eff[r][0]], params[r][2]);
 kh = pow(params[r][0], params[r][2]);
 sb1 = pow(s[eff[r][0]], params[r][2] - 1);
 d = ( kh + sb );
 return (kh*sb1*params[r][2]*params[r][1]) / (d * d) ;
}