atom.c File Reference

#include "../headers/atom.h"

Go to the source code of this file.

Functions
float	get_mol_mass (s_atm *latoms, int natoms)
float	get_mol_mass_ptr (s_atm **latoms, int natoms)
void	set_mol_barycenter_ptr (s_atm **latoms, int natoms, float bary[3])
float	get_mol_volume_ptr (s_atm **atoms, int natoms, int niter)
int	is_in_lst_atm (s_atm **lst_atm, int nb_atm, int atm_id)
float	atm_corsp (s_atm **al1, int nal1, s_atm **al2, int nal2)
void	print_atoms (FILE *f, s_atm *atoms, int natoms)

---

Function Documentation

float atm_corsp	(	s_atm **	al1,
		int	nal1,
		s_atm **	al2,
		int	nal2
	)

## FUNCTION: atm_corsp

## SPECIFICATION: Calculate correspondance between two list of atoms, using the first list as reference.

## PARAMETRES: @ s_atm **al1 : First list @ int nal1 : Number of atoms of the first list @ s_atm **al2 : Second list @ int nal2 : Number of atoms of the second list

## RETURN: float: % of atoms of the first list present in the second list

Definition at line 287 of file atom.c.

References s_atm::id, s_atm::name, and s_atm::res_id.

Referenced by check_pockets(), and desc_pocket().

{
        int i, j,
                nb_atm_found = 0 ;
        s_atm *cural = NULL,
                  *curap ;
        
        if(nal1 <=0 || nal2 <= 0){
                return 0.0 ;
        }

        for(i = 0 ; i < nal1 ; i++) {
                for(j = 0 ; j < nal2 ; j++) {
                        cural = al1[i] ;
                        curap = al2[j] ;

                        if(curap->res_id == cural->res_id && 
                        ( (curap->id == cural->id) || strcmp(cural->name, curap->name) == 0 ) ) {
                                nb_atm_found++ ;
                                break ;
                        }
                }
        }

        
        return ((float)nb_atm_found)/((float)nal1)*100.0 ;
}

float get_mol_mass	(	s_atm *	latoms,
		int	natoms
	)

## FUNCTION: get_mol_mass

## SPECIFICATION: Calculate mass of a molecule represented by a list of atoms. (structure) Perform a simple sum of atoms mass.

## PARAMETRES: @ s_atm *atoms : List of atoms structures @ int natoms : Number of atoms

## RETURN: float: mass of the molecule

Definition at line 85 of file atom.c.

References s_atm::mass.

{
        float mass = 00.0 ;
        int i ;
        if(latoms) {
                for(i = 0 ; i < natoms ; i++) {
                        mass += latoms[i].mass ;
                }
        }
        return mass ; 
}

float get_mol_mass_ptr	(	s_atm **	latoms,
		int	natoms
	)

## FUNCTION: get_mol_mass_ptr

## SPECIFICATION: Same as previous, but using different input type (array of pointers)

## PARAMETRES: @ s_atm **atoms : List of pointers to atom structures @ int natoms : Number of atoms

## RETURN: float: mass of the molecule

Definition at line 112 of file atom.c.

References s_atm::mass.

Referenced by test_set().

{
        float mass = 00.0 ;
        int i ;
        if(latoms) {
                
                for(i = 0 ; i < natoms ; i++) {
                        mass += latoms[i]->mass ;
                }
        }
        return mass ; 
}

float get_mol_volume_ptr	(	s_atm **	atoms,
		int	natoms,
		int	niter
	)

## FUNCTION: get_mol_volume_ptr

## SPECIFICATION: Get an monte carlo approximation of the volume occupied by the atoms given in argument (list of pointers).

## PARAMETRES: @ s_atm **atoms : List of pointer to atoms @ int natoms : Number of atoms @ int niter : Number of monte carlo iteration to perform

## RETURN: float: calculated volume (approximation).

Definition at line 179 of file atom.c.

References s_atm::radius, rand_uniform(), s_atm::x, s_atm::y, and s_atm::z.

Referenced by desc_pocket(), and test_set().

{
        int i = 0, j = 0,
                nb_in = 0;

        float xmin = 0.0, xmax = 0.0,
                  ymin = 0.0, ymax = 0.0,
                  zmin = 0.0, zmax = 0.0,
                  xtmp = 0.0, ytmp = 0.0, ztmp = 0.0,
                  xr   = 0.0, yr   = 0.0, zr   = 0.0,
                  vbox = 0.0 ;

        s_atm *acur = NULL ;

        /* First, search extrems coordinates to get a contour box of the molecule */
        for(i = 0 ; i < natoms ; i++) {
                acur = atoms[i] ;

                if(i == 0) {
                        xmin = acur->x - acur->radius ; xmax = acur->x + acur->radius ;
                        ymin = acur->y - acur->radius ; ymax = acur->y + acur->radius ;
                        zmin = acur->z - acur->radius ; zmax = acur->z + acur->radius ;
                }
                else {
                /* Update the minimum and maximum extreme point */
                        if(xmin > (xtmp = acur->x - acur->radius)) xmin = xtmp ;
                        else if(xmax < (xtmp = acur->x + acur->radius)) xmax = xtmp ;
        
                        if(ymin > (ytmp = acur->y - acur->radius)) ymin = ytmp ;
                        else if(ymax < (ytmp = acur->y + acur->radius)) ymax = ytmp ;
        
                        if(zmin > (ztmp = acur->z - acur->radius)) zmin = ztmp ;
                        else if(zmax < (ztmp = acur->z + acur->radius)) zmax = ztmp ;
                }
        }

        /* Next calculate the contour box volume */
        vbox = (xmax - xmin)*(ymax - ymin)*(zmax - zmin) ;

        /* Then apply monte carlo approximation of the volume.   */
        for(i = 0 ; i < niter ; i++) {
                xr = rand_uniform(xmin, xmax) ;
                yr = rand_uniform(ymin, ymax) ;
                zr = rand_uniform(zmin, zmax) ;

                for(j = 0 ; j < natoms ; j++) {
                        acur = atoms[j] ;
                        xtmp = acur->x - xr ;
                        ytmp = acur->y - yr ;
                        ztmp = acur->z - zr ;

                /* Compare r^2 and dist(center, random_point)^2 */
                        if((acur->radius*acur->radius) > (xtmp*xtmp + ytmp*ytmp + ztmp*ztmp)) {
                        /* The point is inside one of the vertice!! */
                                nb_in ++ ; break ;
                        }
                }
        }

        /* Ok lets just return the volume Vpok = Nb_in/Niter*Vbox */
        return ((float)nb_in)/((float)niter)*vbox;
}

int is_in_lst_atm	(	s_atm **	lst_atm,
		int	nb_atm,
		int	atm_id
	)

## FUNCTION: is_in_lst_atm

## SPECIFICATION: Says wether an atom of id atm_id is in a list of atoms or not

## PARAMETRES: @ s_atm **lst_atm : List of atoms @ int nb_atms : Number of atoms in the list @ int atm_id : ID of the atom to look for.

## RETURN: 1 if the atom is in the tab, 0 if not

Definition at line 258 of file atom.c.

Referenced by get_mol_atm_neigh(), and write_pocket_pdb().

{
        int i ;
        for(i = 0 ; i < nb_atm ; i++) {
                if(atm_id == lst_atm[i]->id) return 1 ;
        }

        return 0 ;
}

void print_atoms	(	FILE *	f,
		s_atm *	atoms,
		int	natoms
	)

## FUNCTION: void print_atoms(FILE *f, s_atm *atoms, int natoms)

## SPECIFICATION: Print list of atoms...

## PARAMETRES: @ FILE *f : File to write in. @ s_atm *atoms : List of atoms @ int natoms : Number of atoms

## RETURN:

Definition at line 330 of file atom.c.

References s_atm::bfactor, s_atm::chain, s_atm::charge, s_atm::id, s_atm::mass, s_atm::name, s_atm::occupancy, s_atm::radius, s_atm::res_id, s_atm::res_name, s_atm::symbol, s_atm::type, s_atm::x, s_atm::y, and s_atm::z.

{
        s_atm *atom = NULL ;
        int i ;
        for(i = 0 ; i < natoms ; i++) {
                atom = atoms + i ; 
                fprintf(f, "======== Atom %s (%d) ========\n", atom->name, atom->id) ;
                fprintf(f, "Type: '%s', Residu: '%s' (%d), Chain: '%s'\n",
                                        atom->type, atom->res_name, atom->res_id, atom->chain);
                fprintf(f, "x: %f, y: %f, z: %f, occ: %f, bfact: %f\n", 
                                        atom->x, atom->y, atom->z, atom->occupancy, atom->bfactor);
                fprintf(f, "symbol: '%s', charge: %d, mass: %f, vdw: %f\n", 
                                        atom->symbol, atom->charge, atom->mass, atom->radius);
        }
}

void set_mol_barycenter_ptr	(	s_atm **	latoms,
		int	natoms,
		float	bary[3]
	)

## FUNCTION: set_mol_barycenter_ptr

## SPECIFICATION: Calculate the barycenter of a molecule represented by a list of atoms pointers.

## PARAMETRES: @ s_atm **atoms : List of pointers to atoms structures @ int natoms : Number of atoms @ float bary[3] : OUTPUT: Where to store the calculated barycenter

## RETURN: void (the OUTPUT is set using the input parameter bary)

Definition at line 142 of file atom.c.

References s_atm::x, s_atm::y, and s_atm::z.

{
        float xsum = 0.0, 
                  ysum = 0.0,
                  zsum = 0.0 ;
        int i ;
        if(latoms) {
                
                for(i = 0 ; i < natoms ; i++) {
                        xsum += latoms[i]->x ;
                        ysum += latoms[i]->y ;
                        zsum += latoms[i]->z ;
                }
        }

        bary[0] = xsum / natoms ;
        bary[1] = xsum / natoms ;
        bary[2] = xsum / natoms ;
}