mkKd2Kj                package:ccems                R Documentation

_M_a_k_e _K_d_2_K_j _M_a_p_p_i_n_g_s

_D_e_s_c_r_i_p_t_i_o_n:

     This function takes the 'g' component of the output list of
     'mkGrids' and converts it into a list of functions  that maps Kd
     (grid edge) values into Kj (spur edge) values.  Such functions are
     needed so that one generic full spur graph model can be used by
     all of the specific hypotheses of the model space.

_U_s_a_g_e:

      mkKd2Kj(g) 

_A_r_g_u_m_e_n_t_s:

       g: The 'g' component of the output list of 'mkGrids'. 

_D_e_t_a_i_l_s:

     Suppose a hub protein ligand has two binding sites (call them a-
     and h-sites) that are filled in (a,h) order.  The names of the
     Kd2Kj functions produced by calls to this function are then
     strings of 0's and 1's where a '1' implies that the a-site thread
     is infinite while its corresponding (within the same j-mer) h-site
     thread is finite   and a '0' implies that the a-site thread is
     finite. The relevance of this is that a '1' implies that a  
     finite tail Kj parameter must be inserted into an infinite a-site 
     thread to serve as the head of a downstream finite h-site thread;
     a '0' implies that no action need be taken. Thus, for monomers,
     dimers, tetramers and hexamers,     ''0000'' is used when no
     bridge spur edge insertions are needed and ''1111'') is used  when
     all h-site threads are finite and all a-site threads are infinite. 

     More sites can also be handled. Suppose we have three ordered (s,
     a, h) across  j-mers (m, d, t, h).  The digits then follow binary
     codings of the s- and a-site threads being infinity:  '0' is
     niether (and thus no insertions),  '1' is an finite a-site thread,
     '2' is an infite s-site thread, and '3' (binary 11)  is that both
     are infinite (this case is similar to   '1' in that only one
     a-site insertion is needed. If there were 4 binding  sites the
     digits would range from  '0' to '7' (binary 111).

_V_a_l_u_e:

     A list of functions that map vectors of Kd's into vectors of Kj's
     where, within  stoichiometric integer factors  in the numerators
     and denominators, an output Kj value is the product of  the input
     Kd that sit between the output Kj node and the root node  (free
     hub). Here Kd whose products are not heads are binary and those
     which are heads are already spur edges,  so they pass through an
     identity mapping.  Thus, the Kd inputs are of hybrid/generalized
     grid graphs (i.e. hanging thread network  topologies) and the Kj
     outputs are of  pure spur full model graphs (i.e. the generic
     model output  of 'mkg' that is used by the entire model space).

_N_o_t_e:

     Two functions with two different names can be identical.  This
     happen when the monomer a-site thread is the same whether it is
     finite as a  finite thread or finite because it was asked to
     support the subsequent monomer (e.g. h-site) thread; in longer
     threads these two scenarios yield different models: one where the
     thread nodes are all finite and one where only the tail node is
     finite while the rest are infinite.  

     This work was supported by the National Cancer Institute
     (K25CA104791).

_A_u_t_h_o_r(_s):

     Tom Radivoyevitch (txr24@case.edu)

_R_e_f_e_r_e_n_c_e_s:

     Radivoyevitch, T. (2008) Equilibrium model selection: dTTP induced
     R1 dimerization. _BMC Systems Biology_ *2*, 15. 

     Radivoyevitch, T.  Automated model generation and selection
     methods for combinatorially complex biochemical equilibriums. (to
     be submitted to _Biology Direct_).

_S_e_e _A_l_s_o:

     'mkGrids', 'ccems'

_E_x_a_m_p_l_e_s:

     library(ccems)
     topology <- list(  
             heads=c("R1t0","R2t0"),  
             sites=list(       
                     s=list(                     # s-site    thread #
                             m=c("R1t1"),        # monomer      1
                             d=c("R2t1","R2t2")  # dimer        2
                     )
             )
     ) 
     g <- mkg(topology,TCC=TRUE) # generic model
     gridL <- mkGrids(g,3)   
     mkKd2Kj(gridL$g) # when there is only one function its name is "default"

     topology <- list(
             heads=c("R1X0","R2X2","R4X4","R6X6"), # s-sites are already filled only in (j>1)-mer head nodes 
             sites=list(                    
                     a=list(                                                              # a-site       thread #
                             m=c("R1X1"),                                                 # monomer          1
                             d=c("R2X3","R2X4"),                                          # dimer            2
                             t=c("R4X5","R4X6","R4X7","R4X8"),                            # tetramer         3
                             h=c("R6X7","R6X8","R6X9","R6X10", "R6X11", "R6X12")          # hexamer          4
                     ),
                     h=list( ## tails of a-site threads are heads of h-site threads       # h-site
                             m=c("R1X2"),                                                 # monomer          5
                             d=c("R2X5", "R2X6"),                                         # dimer            6
                             t=c("R4X9", "R4X10","R4X11", "R4X12"),                       # tetramer         7
                             h=c("R6X13", "R6X14", "R6X15","R6X16", "R6X17", "R6X18")     # hexamer          8
                     )
             )
     )

     g <- mkg(topology,TCC=TRUE) 
     gridL <- mkGrids(g,maxnPs=3)   
     mkKd2Kj(gridL$g)  

     ## Not run: 
     topology <- list(
             heads=c("R1X0","R2X0","R4X0","R6X0"), # no requirement that s-sites are filled in oligomers
             sites=list(                    
                     s=list(                                                              # s-site       thread #
                             m=c("R1X1"),                                                 # monomer          1
                             d=c("R2X1","R2X2"),                                          # dimer            2
                             t=c("R4X1","R4X2","R4X3","R4X4"),                            # tetramer         3
                             h=c("R6X1","R6X2","R6X3","R6X4", "R6X5", "R6X6")             # hexamer          4
                     ),
                     a=list(                                                              # a-site       thread #
                             m=c("R1X2"),                                                 # monomer          5
                             d=c("R2X3","R2X4"),                                          # dimer            6
                             t=c("R4X5","R4X6","R4X7","R4X8"),                            # tetramer         7
                             h=c("R6X7","R6X8","R6X9","R6X10", "R6X11", "R6X12")          # hexamer          8
                     ),
                     h=list( ## tails of a-site threads are heads of h-site threads       # h-site
                             m=c("R1X3"),                                                 # monomer          9
                             d=c("R2X5", "R2X6"),                                         # dimer            10
                             t=c("R4X9", "R4X10","R4X11", "R4X12"),                       # tetramer         11
                             h=c("R6X13", "R6X14", "R6X15","R6X16", "R6X17", "R6X18")     # hexamer          12
                     )
             )
     )

     g <- mkg(topology,TCC=TRUE) 
     gridL <- mkGrids(g,maxnPs=3)   
     mkKd2Kj(gridL$g)  
     ## End(Not run)

