dpocket.c File Reference

#include "../headers/dpocket.h"

Go to the source code of this file.

Functions
void	dpocket (s_dparams *par)
void	desc_pocket (char fcomplexe[], const char ligname[], s_dparams *par, FILE *f[3])
s_atm **	get_explicit_desc (s_pdb *pdb_cplx_l, s_lst_vvertice *verts, s_atm **lig, int nal, s_dparams *par, int *nai, s_desc *desc)
void	write_pocket_desc (const char fc[], const char l[], s_desc *d, float lv, float ovlp, float dst, float c4, float c5, FILE *f)

---

Function Documentation

void desc_pocket	(	char	fcomplexe[],
		const char	ligname[],
		s_dparams *	par,
		FILE *	f[3]
	)

## FUNCTION: desc_pocket

## SPECIFICATION: @ const char fcomplexe[] : File containing the PDB @ const char ligname[] : Ligand resname identifier @ s_dparams *par : Parameters @ FILE *f[3] : The 3 FILE * to write output in

## PARAMETRES:

## RETURN:

Definition at line 184 of file dpocket.c.

References allocate_s_desc(), atm_corsp(), s_pocket::bary, c_lst_pocket_free(), count_atm_prop_vert_neigh(), count_pocket_lig_vert_ovlp(), dist(), c_lst_pockets::first, s_dparams::fpar, free_pdb_atoms(), get_explicit_desc(), get_mol_volume_ptr(), get_pocket_pvertices(), get_vert_contacted_atms(), s_pdb::latm_lig, M_CRIT4_D, M_CRIT5_D, M_DONT_KEEP_LIG, M_KEEP_LIG, my_free(), s_pdb::natm_lig, s_fparams::nb_mcv_iter, node_pocket::next, s_pocket::pdesc, node_pocket::pocket, s_atm::res_id, rpdb_open(), rpdb_read(), search_pocket(), s_pocket::size, s_pocket::v_lst, c_lst_pockets::vertices, and write_pocket_desc().

Referenced by dpocket().

{
        c_lst_pockets *pockets = NULL ;
        s_lst_vvertice *verts = NULL ;
        
        s_atm **interface = NULL ;
        s_desc *edesc ;
        s_atm **lig = NULL,
                  **patoms ;

        float vol, ovlp, dst = 0.0, tmp, c4, c5 ;
        int nal = 0,
                nai = 0,        /* Number of atoms in the interface */
                nbpa ;
        int j ;

/*
        fprintf(stdout, "dpocket: Loading pdb... ") ; fflush(stdout) ;
*/
        s_pdb *pdb_cplx_l = rpdb_open(fcomplexe, ligname, M_KEEP_LIG);
        s_pdb *pdb_cplx_nl = rpdb_open(fcomplexe, ligname, M_DONT_KEEP_LIG) ;
        
        if(! pdb_cplx_l || !pdb_cplx_nl || pdb_cplx_l->natm_lig <= 0) {
                if(pdb_cplx_l->natm_lig <= 0) {
                        fprintf(stdout, "ERROR - No ligand %s found in %s.\n", ligname, fcomplexe) ;

                }
                else fprintf(stdout, "ERROR - PDB file %s could not be opened\n", fcomplexe) ;
                
                return ;
        }

        rpdb_read(pdb_cplx_l, ligname, M_KEEP_LIG) ;
        rpdb_read(pdb_cplx_nl, ligname, M_DONT_KEEP_LIG) ;
/*
        fprintf(stdout, " OK\n") ;
*/

        lig = pdb_cplx_l->latm_lig ;
        nal = pdb_cplx_l->natm_lig ;

        /*check if there are multiple ligand mols*/
        int n_lig_molecules=1;
        char chain_tmp[2];
        int resnumber_tmp;
        strcpy(chain_tmp,lig[0]->chain);
        resnumber_tmp = lig[0]->res_id;
        
        for (j = 1 ; j < nal ; j++) {
            if(strcmp(chain_tmp,lig[j]->chain) !=0 || resnumber_tmp!=lig[j]->res_id){
                n_lig_molecules++;
                strcpy(chain_tmp,lig[j]->chain);
                resnumber_tmp =lig[j]->res_id;
            }
        }
        
                /* Getting explicit interface using the known ligand */
/*
                fprintf(stdout, "dpocket: Explicit pocket definition... \n") ; 
                fflush(stdout) ;
*/
        pockets = search_pocket(pdb_cplx_nl, par->fpar,pdb_cplx_l) ;
        if(pockets == NULL) {
                fprintf(stdout, "ERROR - No pocket found for %s\n", fcomplexe) ;
                return ;
        }
        //else write_out_fpocket(pockets, pdb_cplx_nl, fcomplexe);
/*
        verts = load_vvertices(pdb_cplx_nl, 3, par->fpar->asph_min_size,
                                                   par->fpar->asph_max_size) ;
*/

        verts = pockets->vertices ;
        edesc = allocate_s_desc() ;
        interface = get_explicit_desc(pdb_cplx_l, verts, lig, nal, par,
                                                                   &nai, edesc) ;

        /* Writing output */
        vol = get_mol_volume_ptr(lig, nal, par->fpar->nb_mcv_iter) ;
        write_pocket_desc(fcomplexe, ligname, edesc, vol, 100.0, 0.0, 1.0, 1.0, f[0]) ;

        node_pocket *cur = pockets->first ;
        s_vvertice **pvert = NULL ;
        while(cur) {
                /* Get the natomic overlap */
                patoms = get_vert_contacted_atms(cur->pocket->v_lst, &nbpa) ;
                ovlp = atm_corsp(interface, nai, patoms, nbpa) ;

                /* Get the smallest distance of the ligand to the pocket
                   (PocketPicker criteria) */
                for (j = 0 ; j < nal ; j++) {
                        tmp = dist(lig[j]->x, lig[j]->y, lig[j]->z,
                                           cur->pocket->bary[0], cur->pocket->bary[1],
                                           cur->pocket->bary[2]) ;
                        if(j == 0) dst = tmp ;
                        else {
                                if(tmp < dst) dst = tmp ;
                        }
                }

                /* Get the consensus criteria too */
                pvert = get_pocket_pvertices(cur->pocket) ;

                c4 = count_atm_prop_vert_neigh( lig, pdb_cplx_l->natm_lig,
                                                                            pvert, cur->pocket->size, M_CRIT4_D,n_lig_molecules) ;
                c5 = count_pocket_lig_vert_ovlp(lig, pdb_cplx_l->natm_lig,
                                                                                pvert, cur->pocket->size, M_CRIT5_D) ;

                /* */
                if(ovlp > 40.0 || dst < 4.0) {
                        write_pocket_desc(fcomplexe, ligname, cur->pocket->pdesc, vol,
                                                          ovlp, dst, c4, c5, f[1]) ;
                }
                else {
                        write_pocket_desc(fcomplexe, ligname, cur->pocket->pdesc, vol,
                                                          ovlp, dst, c4, c5, f[2]) ;
                }
                my_free(patoms) ;
                cur = cur->next ;
        }

        /* Free memory */
        c_lst_pocket_free(pockets) ;
        my_free(interface) ;
        free_pdb_atoms(pdb_cplx_l) ;
        free_pdb_atoms(pdb_cplx_nl) ;
        
}

void dpocket

(

s_dparams *

par

)

## FUNCTION: dpocket

## SPECIFICATION: Dpocket main function. Simple loop is performed over all files.

## PARAMETRES: @ s_dparams *par: Parameters of the programm

## RETURN: void

Definition at line 116 of file dpocket.c.

References desc_pocket(), s_dparams::f_exp, s_dparams::f_fpcknp, s_dparams::f_fpckp, s_dparams::fcomplex, get_aa_name3(), s_dparams::ligs, M_DP_OUTP_HEADER, and s_dparams::nfiles.

Referenced by main().

{
        int i, j ;
        FILE *fout[3] ;

        if(par) {
        /* Opening output file file */

                fout[0] = fopen(par->f_exp,"w") ;
                fout[1] = fopen(par->f_fpckp,"w") ;
                fout[2] = fopen(par->f_fpcknp,"w") ;

                if(fout[0] && fout[1] && fout[2]) {

                /* Writing column names */
        
                        for( i = 0 ; i < 3 ; i++ ) {
                                fprintf(fout[i], M_DP_OUTP_HEADER) ;
                                for( j = 0 ; j < 20 ; j++ ) fprintf(fout[i], " %s", get_aa_name3(j));
                                fprintf(fout[i], "\n");
                        }
        
                /* Begins dpocket */
                        for(i = 0 ; i < par->nfiles ; i++) {
                                fprintf(stdout, "<dpocket>s %d/%d - %s:",
                                                i+1, par->nfiles, par->fcomplex[i]) ;

                                desc_pocket(par->fcomplex[i], par->ligs[i], par, fout) ;
                                if(i == par->nfiles - 1) fprintf(stdout,"\n") ;
                                else fprintf(stdout,"\r") ;

                                fflush(stdout) ;
                        }

                        for( i = 0 ; i < 3 ; i++ ) fclose(fout[i]) ;
                }
                else {
                        if(! fout[0]) {
                                fprintf(stdout, "! Output file <%s> couldn't be opened.\n", 
                                                par->f_exp) ;
                        }
                        else if (! fout[1]) {
                                fprintf(stdout, "! Output file <%s> couldn't be opened.\n", 
                                                par->f_fpckp) ;
                        }
                        else {
                                fprintf(stdout, "! Output file <%s> couldn't be opened.\n", 
                                                par->f_fpcknp) ;
                        }
                }
        }
}

s_atm** get_explicit_desc	(	s_pdb *	pdb_cplx_l,
		s_lst_vvertice *	verts,
		s_atm **	lig,
		int	nal,
		s_dparams *	par,
		int *	nai,
		s_desc *	desc
	)

## FUNCTION: get_explicit_desc

## SPECIFICATION: Determine the explicit pocket (see comments at the top of the file), and calculate descriptors (and fill the input structure)

## PARAMETRES: @ s_pdb *pdb_cplx_l : The pdb structure @ s_lst_vvertice *verts : The vertices found @ s_atm **lig : Atoms of the ligand @ int nal : Number of atom in the ligand @ s_dparams *par : Parameters @ int *nai : OUTPUT Number of atom in the interface @ s_desc *desc : OUTPUT Descriptors

## RETURN: s_atm **: List of pointer to atoms defining the explicit pocket. plus nai and desc are filled.

Definition at line 336 of file dpocket.c.

References s_fparams::flag_do_asa_and_volume_calculations, s_dparams::fpar, get_mol_atm_neigh(), get_mol_ctd_atm_neigh(), get_mol_vert_neigh(), s_dparams::interface_dist_crit, s_dparams::interface_method, s_pdb::latoms_p, M_INTERFACE_METHOD2, M_INTERFACE_SEARCH, my_free(), s_pdb::natoms, s_fparams::nb_mcv_iter, s_lst_vvertice::nvert, s_lst_vvertice::pvertices, and set_descriptors().

Referenced by desc_pocket().

{
        int nvn = 0 ;   /* Number of vertices in the interface */

        s_atm **interface = NULL ;

/*
        fprintf(stdout, "dpocket: Determning explicit interface... ") ; 
        fflush(stdout) ;
*/
        
        if(par->interface_method == M_INTERFACE_METHOD2) {
        /* Use the distance-based method to define the interface */
                interface = get_mol_atm_neigh(  lig, nal, pdb_cplx_l->latoms_p,
                                                                                pdb_cplx_l->natoms,
                                                                                par->interface_dist_crit, nai) ;
        }
        else {
        /* Use the voronoi vertices-based method to define the interface */
                
                interface = get_mol_ctd_atm_neigh(lig, nal, verts->pvertices, verts->nvert,
                                                                                  par->interface_dist_crit,
                                                                                  M_INTERFACE_SEARCH, nai) ;
        }

        /* Get a tab of pointer for interface's vertices to send a correct argument 
         * type to set_descriptors */
        s_vvertice **tpverts = get_mol_vert_neigh(lig, nal, verts->pvertices, verts->nvert,
                                                                                          par->interface_dist_crit, &nvn) ;
        
        /* Ok we have the interface and the correct vertices list, now calculate 
         * descriptors and write it.
         **/
/*
        fprintf(stdout, "dpocket: Calculating descriptors... ") ; fflush(stdout) ;
*/
        set_descriptors(interface, *nai, tpverts, nvn, desc, par->fpar->nb_mcv_iter,pdb_cplx_l,par->fpar->flag_do_asa_and_volume_calculations);
/*
        fprintf(stdout, " OK\n") ;
*/

        /* Free memory */
        my_free(tpverts) ;

        return interface ;
}

void write_pocket_desc	(	const char	fc[],
		const char	l[],
		s_desc *	d,
		float	lv,
		float	ovlp,
		float	dst,
		float	c4,
		float	c5,
		FILE *	f
	)

## FUNCTION: write_pocket_desc

## SPECIFICATION: Write pocket descriptors into a file.

## PARAMETRES: @ const char fc[] : Name of the pdb file @ const char l[] : Resname of the ligand @ s_desc *d : Stucture of descriptors @ float lv : Ligand volume @ float ovlp : Overlap @ FILE *f : Buffer to write in

## RETURN: void

Definition at line 403 of file dpocket.c.

References s_desc::aa_compo, M_CRIT4_VAL, M_CRIT5_VAL, M_DP_OUTP_FORMAT, and M_DP_OUTP_VAR.

Referenced by desc_pocket().

{
        int status = 0 ;
        if(dst < 4.0) status = 1 ;

        int c6 = (c4 >= M_CRIT4_VAL && c5 >= M_CRIT5_VAL) ?1:0 ;
        float c6_c = ((c4 - M_CRIT4_VAL)/ (1-M_CRIT4_VAL)) + ((c5 - M_CRIT5_VAL)/ (1-M_CRIT5_VAL)) ;

        fprintf(f, M_DP_OUTP_FORMAT, M_DP_OUTP_VAR(fc, l, ovlp, status, dst, c4, c5, c6, c6_c, lv, d)) ;

        int i ;
        for(i = 0 ; i < 20 ; i++) fprintf(f, " %3d", d->aa_compo[i]) ;
        
        fprintf(f, "\n") ;
}