├── docs
    ├── readthedocs
    │   ├── __init__.py
    │   ├── img
    │   │   └── favicon.ico
    │   ├── fonts
    │   │   ├── fontawesome-webfont.eot
    │   │   ├── fontawesome-webfont.ttf
    │   │   └── fontawesome-webfont.woff
    │   ├── mkdocs_theme.yml
    │   ├── 404.html
    │   ├── searchbox.html
    │   ├── main.html
    │   ├── toc.html
    │   ├── search.html
    │   ├── versions.html
    │   ├── nav.html
    │   ├── breadcrumbs.html
    │   ├── footer.html
    │   ├── license
    │   │   └── highlight.js
    │   │   │   └── LICENSE
    │   ├── css
    │   │   ├── highlight.css
    │   │   └── theme_extra.css
    │   ├── js
    │   │   └── theme.js
    │   └── base.html
    ├── sources
    │   ├── images
    │   │   ├── hbind-logo.jpg
    │   │   ├── hbind-logo.png
    │   │   ├── 1kpf_interact.png
    │   │   └── hbind-viz-logo.png
    │   ├── changelog.md
    │   ├── contact.md
    │   ├── hbind_tools.md
    │   ├── installation.md
    │   ├── cite.md
    │   └── index.md
    └── mkdocs.yml
├── src
    ├── .cvsignore
    ├── hbind
    │   ├── inc
    │   │   ├── demo.h
    │   │   ├── check_key.h
    │   │   ├── bump_check.h
    │   │   ├── sum_charges.h
    │   │   ├── adj_list.h
    │   │   ├── hashing.h
    │   │   ├── find_cycles.h
    │   │   ├── initialize.h
    │   │   ├── assign_type.h
    │   │   ├── quicksort.h
    │   │   ├── analyze_ligand.h
    │   │   ├── assign_fragments.h
    │   │   ├── check_connectivity.h
    │   │   ├── assign_hydrogens.h
    │   │   ├── number_ligand_atoms.h
    │   │   ├── read_hyd_defn.h
    │   │   ├── eigen.h
    │   │   ├── read_flex_defn.h
    │   │   ├── read_pts_file.h
    │   │   ├── target_flexibility.h
    │   │   ├── unbump_water.h
    │   │   ├── insertion_sort.h
    │   │   ├── mean_field_minimization.h
    │   │   ├── find_carbon_ring_centers.h
    │   │   ├── read_batch_file.h
    │   │   ├── unbump_ligand_side_chains.h
    │   │   ├── write_log_file.h
    │   │   ├── initialize_unbump_matrices.h
    │   │   ├── compute_ligand_angles.h
    │   │   ├── compute_target_angles.h
    │   │   ├── rotate.h
    │   │   ├── trace.h
    │   │   ├── compute_unbump_dependencies.h
    │   │   ├── read_pdb.h
    │   │   ├── score_complex.h
    │   │   ├── unbump_anchor.h
    │   │   ├── intra_hbonds.h
    │   │   ├── find_flexible_bonds.h
    │   │   ├── unbump_target_side_chain.h
    │   │   ├── read_parameter_file.h
    │   │   ├── screen_single_compounds.h
    │   │   ├── transform_molecule.h
    │   │   ├── find_hyd_atoms.h
    │   │   ├── read_waters.h
    │   │   ├── least_square_fit.h
    │   │   ├── write_target_pdb.h
    │   │   ├── print_interaction.h
    │   │   ├── debug_funs.h
    │   │   ├── read_rule.h
    │   │   ├── neighbors.h
    │   │   ├── read_template.h
    │   │   ├── rotate_unbump_bonds.h
    │   │   ├── compute_all_rotation_angles.h
    │   │   ├── count_flexible_bonds.h
    │   │   ├── write_ligand_mol2.h
    │   │   ├── unbump_translate.h
    │   │   ├── write_waters_pdb.h
    │   │   ├── match_triangles.h
    │   │   ├── mymalloc.h
    │   │   ├── distance_matrices.h
    │   │   ├── docking_features.h
    │   │   ├── dist_fun.h
    │   │   ├── distance_array.h
    │   │   ├── find_all_bumps.h
    │   │   ├── check_rule.h
    │   │   ├── intra_bump_check.h
    │   │   ├── unbump_side_chains.h
    │   │   ├── trans_rotate.h
    │   │   ├── hbond_check.h
    │   │   ├── intra_hbonds_flag.h
    │   │   ├── hash_class.h
    │   │   ├── rotatable_bonds.h
    │   │   ├── read_mol2.h
    │   │   ├── params.h
    │   │   ├── params.h~
    │   │   ├── check_complementarity.h
    │   │   ├── bitstrings.h
    │   │   ├── atom.h
    │   │   ├── hydro.h
    │   │   ├── calc_score_from_terms.h
    │   │   └── sf_weights.h
    │   ├── .cvsignore
    │   ├── number_ligand_atoms.c
    │   ├── quicksort.c
    │   ├── dist_fun.c
    │   ├── check_connectivity.c
    │   ├── insertion_sort.c
    │   ├── write_waters_pdb.c
    │   ├── trace.c
    │   ├── least_square_fit.c
    │   ├── write_target_pdb.c
    │   ├── print_interaction.c
    │   ├── adj_list.c
    │   ├── read_hyd_defn.c
    │   ├── Makefile
    │   ├── analyze_ligand.c
    │   ├── read_flex_defn.c
    │   ├── write_ligand_mol2.c
    │   ├── unbump_translate.c
    │   ├── find_cycles.c
    │   ├── rotate.c
    │   ├── read_waters.c
    │   ├── distance_matrices.c
    │   ├── intra_hbonds.c
    │   ├── check_rule.c
    │   ├── unbump_anchor.c
    │   ├── assign_hydrogens.c
    │   ├── read_pts_file.c
    │   ├── write_log_file.c
    │   ├── find_hyd_atoms.c
    │   ├── debug_funs.c
    │   ├── initialize_unbump_matrices.c
    │   ├── distance_array.c
    │   ├── eigen.c
    │   ├── find_flexible_bonds.c
    │   └── read_template.c
    └── utils
    │   ├── .cvsignore
    │   ├── inc
    │       ├── basics.h
    │       ├── mymalloc.h
    │       ├── hbind_itimer.h
    │       └── err_handle.h
    │   ├── Makefile
    │   ├── basics.c
    │   ├── hbind_itimer.c
    │   └── err_handle.c
├── params
    ├── hbond.defn
    ├── hbind.parameters
    └── flex.defn
├── .gitignore
├── example_files
    └── 1KPF_AMP.mol2
└── install_hbind.pl


/docs/readthedocs/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/.cvsignore:
--------------------------------------------------------------------------------
1 | Makefile.in
2 | *~
3 | 


--------------------------------------------------------------------------------
/docs/readthedocs/img/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/readthedocs/img/favicon.ico


--------------------------------------------------------------------------------
/src/hbind/inc/demo.h:
--------------------------------------------------------------------------------
1 | /* uncomment the follows for demo version */
2 | 
3 | /*#define DEMO_VERSION */
4 | 
5 | 


--------------------------------------------------------------------------------
/docs/sources/images/hbind-logo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/sources/images/hbind-logo.jpg


--------------------------------------------------------------------------------
/docs/sources/images/hbind-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/sources/images/hbind-logo.png


--------------------------------------------------------------------------------
/src/hbind/.cvsignore:
--------------------------------------------------------------------------------
1 | slide
2 | slide_score
3 | ligand_flag
4 | *~
5 | *.o
6 | .deps
7 | stamp*
8 | Makefile.in
9 | 


--------------------------------------------------------------------------------
/docs/sources/images/1kpf_interact.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/sources/images/1kpf_interact.png


--------------------------------------------------------------------------------
/docs/sources/images/hbind-viz-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/sources/images/hbind-viz-logo.png


--------------------------------------------------------------------------------
/src/hbind/inc/check_key.h:
--------------------------------------------------------------------------------
1 | #ifndef _CHECK_KEY_H
2 | #define _CHECK_KEY_H
3 | 
4 | 	void check_key(char *sdir);
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/docs/readthedocs/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/readthedocs/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/readthedocs/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/readthedocs/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/readthedocs/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasbt/Hbind/HEAD/docs/readthedocs/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/src/hbind/inc/bump_check.h:
--------------------------------------------------------------------------------
1 | #ifndef _BUMP_CHECK_H
2 | #define _BUMP_CHECK_H
3 | 
4 | extern int  bump_check ( global_data_pt  global );
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/src/hbind/inc/sum_charges.h:
--------------------------------------------------------------------------------
1 | #ifndef _SUM_CHARGES_H
2 | #define _SUM_CHARGES_H
3 | 
4 | extern void  sum_charges ( molecule_pt molecule );
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/src/hbind/inc/adj_list.h:
--------------------------------------------------------------------------------
1 | #ifndef _ADJ_LIST_H
2 | #define _ADJ_LIST_H
3 | 
4 | extern void  construct_adjacency_list ( molecule_pt molecule );
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/src/hbind/inc/hashing.h:
--------------------------------------------------------------------------------
1 | #ifndef _HASHING_H
2 | #define _HASHING_H
3 | #include "types.h"
4 | 
5 | int create_hash_table(global_data_pt global);
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/find_cycles.h:
--------------------------------------------------------------------------------
1 | #ifndef  _FIND_CYCLES_H
2 | #define  _FIND_CYCLES_H
3 | #include "types.h"
4 | 
5 | int find_cycles(molecule_pt  molecule);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/initialize.h:
--------------------------------------------------------------------------------
1 | #ifndef _INITIALIZE_H
2 | #define _INITIALIZE_H
3 | 
4 | extern global_data_pt  initialize_global_data_structure ( void );
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/src/utils/.cvsignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | *.o
 3 | gen_lig_box
 4 | remove_close_points
 5 | template
 6 | ligand_based_template
 7 | metal_template
 8 | .deps
 9 | Makefile.in
10 | *.a
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/assign_type.h:
--------------------------------------------------------------------------------
1 | #ifndef _ASSIGN_TYPE_H
2 | #define _ASSIGN_TYPE_H
3 | 
4 | int  assign_type_and_orbit ( char  *str, int   *type, int   *orbit);
5 | 
6 | #endif
7 | 
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/quicksort.h:
--------------------------------------------------------------------------------
1 | #ifndef _MAX_SORT
2 | #define _MAX_SORT 1000
3 | 
4 | extern void quicksort_int( int  in_array[],
5 | 			int left,
6 | 			int right );
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/docs/readthedocs/mkdocs_theme.yml:
--------------------------------------------------------------------------------
1 | # Config options for 'readthedocs' theme
2 | 
3 | static_templates:
4 |     - 404.html
5 | 
6 | include_search_page: true
7 | search_index_only: false
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/analyze_ligand.h:
--------------------------------------------------------------------------------
1 | #ifndef  _ANALYZE_LIGAND_H
2 | #define  _ANALYZE_LIGAND_H
3 | #include "types.h"
4 | 
5 | int analyze_ligand ( global_data_pt  global );
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/assign_fragments.h:
--------------------------------------------------------------------------------
1 | #ifndef  _ASSIGN_FRAGMENTS_H
2 | #define  _ASSIGN_FRAGMENTS_H
3 | 
4 | extern void  assign_fragments ( molecule_pt  molecule );
5 | 
6 | #endif
7 | 
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/check_connectivity.h:
--------------------------------------------------------------------------------
1 | #ifndef  _CHECK_CONNECTIVITY_H
2 | 
3 | #define  _CHECK_CONNECTIVITY_H
4 | 
5 | extern int  check_connectivity ( molecule_pt  molecule );
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/assign_hydrogens.h:
--------------------------------------------------------------------------------
1 | #ifndef _ASSIGN_HYDROGENS_H
2 | #define _ASSIGN_HYDROGENS_H
3 | #include "types.h"
4 | 
5 | int assign_hydrogens(molecule_pt  molecule);
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/number_ligand_atoms.h:
--------------------------------------------------------------------------------
1 | #ifndef  _NUMBER_LIGAND_ATOMS_H
2 | #define  _NUMBER_LIGAND_ATOMS_H
3 | 
4 | extern void  number_ligand_atoms ( molecule_pt  ligand );
5 | 
6 | #endif
7 | 
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_hyd_defn.h:
--------------------------------------------------------------------------------
1 | #ifndef _READ_HYD_DEFN_H
2 | #define _READ_HYD_DEFN_H
3 | #include "types.h"
4 | 
5 | void read_hyd_defn(char *filename, hyd_defn_pt hyd_rules);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/eigen.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EIGEN_H
 2 | #define _EIGEN_H
 3 | 
 4 | 
 5 | extern int  eigen ( double  a[6][6], 
 6 | 		    double  b[6][6], 
 7 | 		    double  c[6] );
 8 | 
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_flex_defn.h:
--------------------------------------------------------------------------------
1 | #ifndef _READ_FLEX_DEFN_H
2 | #define _READ_FLEX_DEFN_H
3 | #include "types.h"
4 | 
5 | int read_flex_defn(char *filename, flex_bond_defn_pt bond_rule);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_pts_file.h:
--------------------------------------------------------------------------------
1 | #ifndef  _READ_PTS_FILE_H
2 | #define  _READ_PTS_FILE_H
3 | #include "types.h"
4 | 
5 | int  read_pts_file ( global_data_pt  global, char *filename );
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/target_flexibility.h:
--------------------------------------------------------------------------------
1 | #ifndef  _TARGET_FLEXIBILITY_H
2 | 
3 | #define  _TARGET_FLEXIBILITY_H
4 | 
5 | extern int  check_target_side_chains ( global_data_pt  global );
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_water.h:
--------------------------------------------------------------------------------
1 | #ifndef  _UNBUMP_WATER_H
2 | 
3 | #define  _UNBUMP_WATER_H
4 | 
5 | extern int  unbump_water ( global_data_pt  global,
6 | 			   atom_pt         water );
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/insertion_sort.h:
--------------------------------------------------------------------------------
1 | #ifndef  _INSERTION_SORT_H
2 | #define  _INSERTION_SORT_H
3 | 
4 | extern void  insertion_sort ( sort_array_pt array,
5 | 			      int           length );
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/mean_field_minimization.h:
--------------------------------------------------------------------------------
1 | #ifndef  _MEAN_FIELD_MINIMIZATION_H
2 | #define  _MEAN_FIELD_MINIMIZATION_H
3 | 
4 | extern void  mean_field_minimization ( global_data_pt  global );
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/docs/readthedocs/404.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | 
 5 |   <h1 id="404-page-not-found">404</h1>
 6 | 
 7 |   <p><strong>Page not found</strong></p>
 8 | 
 9 | {% endblock %}
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/find_carbon_ring_centers.h:
--------------------------------------------------------------------------------
1 | #ifndef  _FIND_CARBON_RING_CENTERS_H
2 | #define  _FIND_CARBON_RING_CENTERS_H
3 | 
4 | extern void  find_carbon_ring_centers ( molecule_pt  molecule );
5 | 
6 | #endif
7 | 
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_batch_file.h:
--------------------------------------------------------------------------------
1 | #ifndef  _READ_BATCH_FILE_H
2 | #define  _READ_BATCH_FILE_H
3 | 
4 | extern void  read_batch_file ( global_data_pt global,
5 | 			       char           *batchfile );
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_ligand_side_chains.h:
--------------------------------------------------------------------------------
1 | #ifndef _UNBUMP_LIGAND_SIDE_CHAINS_H
2 | 
3 | #define _UNBUMP_LIGAND_SIDE_CHAINS_H
4 | 
5 | extern int  unbump_ligand_side_chains ( global_data_pt global );
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/write_log_file.h:
--------------------------------------------------------------------------------
1 | #ifndef _WRITE_LOG_FILE_H
2 | 
3 | #define _WRITE_LOG_FILE_H
4 | 
5 | extern void  write_log_file ( global_data_pt global,
6 | 			      char           *filename );
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/initialize_unbump_matrices.h:
--------------------------------------------------------------------------------
1 | #ifndef  _INITIALIZE_UNBUMP_MATRICES_H
2 | #define  _INITIALIZE_UNBUMP_MATRICES_H
3 | 
4 | extern void  initialize_unbump_matrices ( global_data_pt  global );
5 | 
6 | #endif
7 | 
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/compute_ligand_angles.h:
--------------------------------------------------------------------------------
1 | #ifndef _COMPUTE_LIGAND_ANGLES_H
2 | #define _COMPUTE_LIGAND_ANGLES_H
3 | 
4 | void  compute_ligand_angles ( global_data_pt  global,
5 | 			      int             bump );
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/compute_target_angles.h:
--------------------------------------------------------------------------------
1 | #ifndef _COMPUTE_TARGET_ANGLES_H
2 | #define _COMPUTE_TARGET_ANGLES_H
3 | 
4 | void  compute_target_angles ( global_data_pt  global,
5 | 			     int             bump );
6 | 
7 | #endif
8 | 
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/rotate.h:
--------------------------------------------------------------------------------
 1 | #ifndef _ROTATE_H
 2 | #define _ROTATE_H
 3 | 
 4 | extern int rotate ( double  a[3][3],   
 5 | 		    double  b[3][3],   
 6 | 		    double  weights[3],
 7 | 		    double  r[3][3] );
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/trace.h:
--------------------------------------------------------------------------------
 1 | #ifndef _TRACE_H
 2 | #define _TRACE_H
 3 | #include "types.h"
 4 | 
 5 | void  print_template ( global_data_pt  global );
 6 | 
 7 | void  print_compounds ( global_data_pt  global );
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/compute_unbump_dependencies.h:
--------------------------------------------------------------------------------
1 | #ifndef  _COMPUTE_UNBUMP_DEPENDENCIES_H
2 | #define  _COMPUTE_UNBUMP_DEPENDENCIES_H
3 | #include "types.h"
4 | void  compute_unbump_dependencies ( global_data_pt  global );
5 | 
6 | #endif
7 | 
8 | 


--------------------------------------------------------------------------------
/docs/readthedocs/searchbox.html:
--------------------------------------------------------------------------------
1 | <div role="search">
2 |   <form id ="rtd-search-form" class="wy-form" action="{{ base_url }}/search.html" method="get">
3 |     <input type="text" name="q" placeholder="Search docs" />
4 |   </form>
5 | </div>
6 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_pdb.h:
--------------------------------------------------------------------------------
1 | #ifndef _READ_PDB_H
2 | #define _READ_PDB_H
3 | 
4 | void read_pdb(char *fname, atom_pt atoms, residue_pt residues,
5 |               int what_to_read, int *number_of_atoms, int *number_of_residues);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/src/hbind/inc/score_complex.h:
--------------------------------------------------------------------------------
1 | #ifndef _SCORE_COMPLEX_H
2 | #define _SCORE_COMPLEX_H
3 | #include "types.h"
4 | 
5 | void score_complex(global_data_pt global, dock_feats_pt features,
6 |                    FILE *good_acts_file);
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_anchor.h:
--------------------------------------------------------------------------------
 1 | #ifndef _UNBUMP_ANCHOR_H
 2 | #define _UNBUMP_ANCHOR_H
 3 | 
 4 | extern int  unbump_anchor ( global_data_pt global,
 5 | 			    bump_pt        bump,
 6 | 			    int            number_of_bumps );
 7 | 
 8 | #endif
 9 | 
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/intra_hbonds.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _INTRA_HBONDS_H
 2 | #define  _INTRA_HBONDS_H
 3 | #include "types.h"
 4 | 
 5 | int  intra_target_hbonds ( global_data_pt  global );
 6 | 
 7 | int  target_to_water_hbonds ( global_data_pt  global );
 8 | 
 9 | #endif
10 | 
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/find_flexible_bonds.h:
--------------------------------------------------------------------------------
1 | #ifndef _FIND_FLEXIBLE_BONDS_H
2 | #define _FIND_FLEXIBLE_BONDS_H
3 | #include "types.h"
4 | 
5 | int find_flexible_bonds(molecule_pt molecule, flex_bond_defn_pt flex_bond_rules,
6 |                         int number_of_rules);
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_target_side_chain.h:
--------------------------------------------------------------------------------
 1 | #ifndef _UNBUMP_TARGET_SIDE_CHAIN_H
 2 | 
 3 | #define _UNBUMP_TARGET_SIDE_CHAIN_H
 4 | 
 5 | extern int  unbump_target_side_chain ( global_data_pt global,
 6 | 				       int            *bump_atoms,
 7 | 				       int            number_of_bumps );
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_parameter_file.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _READ_PARAMETER_FILE_H
 2 | #define  _READ_PARAMETER_FILE_H
 3 | #include "types.h"
 4 | 
 5 | int  read_parameter_file ( global_data_pt global, char           *file );
 6 | 
 7 | void  check_environment_parameter_variables ( global_data_pt  global );
 8 | 
 9 | #endif
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/src/hbind/inc/screen_single_compounds.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _SCREEN_SINGLE_COMPOUNDS_H
 2 | #define  _SCREEN_SINGLE_COMPOUNDS_H
 3 | 
 4 | extern void  screen_single_compounds ( global_data_pt  global,
 5 | 				       char            **argv,
 6 | 				       int             argc,
 7 | 				       FILE            *fp );
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/transform_molecule.h:
--------------------------------------------------------------------------------
 1 | #ifndef _TRANSFORM_MOLECULE_H
 2 | #define _TRANSFORM_MOLECULE_H
 3 | 
 4 | int transform_molecule(global_data_pt global, int *template_matches,
 5 |                        int *matched_type, int *ligand_matches);
 6 | void reset_target_and_waters(global_data_pt global);
 7 | 
 8 | #endif
 9 | 
10 | 


--------------------------------------------------------------------------------
/src/hbind/inc/find_hyd_atoms.h:
--------------------------------------------------------------------------------
 1 | #ifndef _FIND_HYD_ATOMS_H
 2 | #define _FIND_HYD_ATOMS_H
 3 | 
 4 | extern int  check_hyd_atom ( molecule_pt  molecule,
 5 | 			     hyd_defn_pt  rules,
 6 | 			     int          index );
 7 | 
 8 | extern void  find_hyd_atoms ( molecule_pt molecule,
 9 | 			      hyd_defn_pt rules );
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_waters.h:
--------------------------------------------------------------------------------
 1 | #ifndef _WATERS_H
 2 | #define _WATERS_H
 3 | #include "types.h"
 4 | 
 5 | int find_hbond_partner(atom_pt target, int num_target_atoms, atom_pt water);
 6 | 
 7 | int read_waters(atom_pt waters, int *num_waters, char *filename, atom_pt target,
 8 |                 int num_target_atoms);
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/least_square_fit.h:
--------------------------------------------------------------------------------
 1 | #ifndef _LEAST_SQUARE_FIT_H
 2 | #define _LEAST_SQUARE_FIT_H
 3 | 
 4 | extern int least_square_fit ( double  a[3][3], 
 5 | 			      double  b[3][3], 
 6 | 			      double  c[3][3],
 7 | 			      double  weights[3],
 8 | 			      double  matrix[3][3], 
 9 | 			      double  vector[3] );
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------
/docs/sources/changelog.md:
--------------------------------------------------------------------------------
 1 | # Release Notes
 2 | 
 3 | ---
 4 | 
 5 | 
 6 | ### Version 1.0.0
 7 | 
 8 | ##### Download Links
 9 | 
10 | - [Source code (zip)](https://github.com/psa-lab/hbind/archive/v1.0.0.zip)
11 | - [Source code (tar.gz)](https://github.com/psa-lab/hbind/archive/v1.0.0.tar.gz)
12 | 
13 | ##### Notes
14 | 
15 | - First release
16 | 


--------------------------------------------------------------------------------
/src/hbind/inc/write_target_pdb.h:
--------------------------------------------------------------------------------
 1 | #ifndef _WRITE_TARGET_PDB_H
 2 | #define _WRITE_TARGET_PDB_H
 3 | #include "types.h"
 4 | 
 5 | void write_target_pdb(residue_pt residues, int num_res, atom_pt atoms, 
 6 |                       int num_atoms, char *filename, int *rotations, 
 7 |                       float *positions);
 8 | 
 9 | #endif
10 | 
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/print_interaction.h:
--------------------------------------------------------------------------------
1 | #ifndef _PRINT_INTERACTION_H_
2 | #define _PRINT_INTERACTION_H_
3 | #include "types.h"
4 | void print_interaction(atom_pt atom1, int atom1_type, int atom1_index, 
5 |                        atom_pt atom2, int atom2_type, int atom2_index,
6 |                        const char *interaction_type, FILE *fout);
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/src/hbind/inc/debug_funs.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef DEBUG_FUNCTIONS_HEADER_FILE_INCLUDED
 3 | #define DEBUG_FUNCTIONS_HEADER_FILE_INCLUDED
 4 | 
 5 | void write_mol2(char *filename, float *positions, global_data_pt global);
 6 | 
 7 | void write_pdb(atom_pt atoms, int num_atoms, char *filename, float *positions);
 8 | 
 9 | const char* act2str(int act);
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_rule.h:
--------------------------------------------------------------------------------
 1 | #ifndef _READ_RULE_H
 2 | #define _READ_RULE_H
 3 | #include "types.h"
 4 | 
 5 | char  *get_rule_item ( char         *line, rule_list_pt rule);
 6 |   
 7 | void  parse_definition_line ( char    *line, rule_pt rule);
 8 | 
 9 | void  print_rule_item ( rule_list_pt rule );
10 | 
11 | void  print_rule ( rule_pt  rule );
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/docs/sources/contact.md:
--------------------------------------------------------------------------------
1 | # Contact
2 | 
3 | If you encounter bugs or other technical issues with the Hbind software package, please send an email to [kuhnlab@msu.edu](mailto:kuhnlab@msu.edu) or use the GitHub [Issue Tracker](https://github.com/psa-lab/hbind/issues). 
4 | 
5 | For questions about the [Hbind research article](cite/index.html), please contact the publisher or corresponding author instead.
6 | 


--------------------------------------------------------------------------------
/src/hbind/inc/neighbors.h:
--------------------------------------------------------------------------------
 1 | #ifndef _NEIGHBORS_H
 2 | 
 3 | #define _NEIGHBORS_H
 4 | /*
 5 | void identify_atom_neighbors(atom_pt atoms, int number_of_atoms);
 6 | */
 7 | 
 8 | extern void  identify_water_neighbors ( atom_pt  waters,
 9 | 					atom_pt  target_atoms,
10 | 					int      number_of_waters,
11 | 					int      number_of_target_atoms,
12 | 					global_data_pt global);
13 | #endif
14 | 
15 | 


--------------------------------------------------------------------------------
/src/hbind/inc/read_template.h:
--------------------------------------------------------------------------------
 1 | #ifndef _READ_TEMPLATE_H
 2 | #define _READ_TEMPLATE_H
 3 | #include "types.h"
 4 | 
 5 | int  find_atom_index ( global_data_pt global,
 6 | 			      char           *residue,
 7 | 			      char           *residue_num,
 8 | 			      char           *atom_name );
 9 | 
10 | int  read_template ( char           *filename,
11 | 			    global_data_pt global );
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/src/hbind/inc/rotate_unbump_bonds.h:
--------------------------------------------------------------------------------
 1 | #ifndef _ROTATE_UNBUMP_BONDS_H
 2 | #define _ROTATE_UNBUMP_BONDS_H
 3 | 
 4 | extern int  rotate_unbump_bonds ( global_data_pt global,
 5 | 				  int            *number_of_actual_rotations );
 6 | 
 7 | extern int  compute_atoms_to_rotate ( global_data_pt  global,
 8 | 	     		              int             index,
 9 | 			              int             *atom_indices );
10 | 
11 | #endif
12 | 
13 | 


--------------------------------------------------------------------------------
/src/hbind/inc/compute_all_rotation_angles.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _COMPUTE_ALL_ROTATION_ANGLES_H
 2 | #define  _COMPUTE_ALL_ROTATION_ANGLES_H
 3 | 
 4 | extern double  compute_rotation_angle ( atom_pt            fixed_atom,
 5 | 					atom_pt            rotated_atom,
 6 | 					float              max_overlap,
 7 | 				        transform_matrix_t matrix );
 8 | 
 9 | extern int  compute_all_rotation_angles ( global_data_pt  global );
10 | 
11 | #endif
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/docs/readthedocs/main.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {#
 4 | The entry point for the ReadTheDocs Theme.
 5 |  
 6 | Any theme customisations should override this file to redefine blocks defined in
 7 | the various templates. The custom theme should only need to define a main.html
 8 | which `{% extends "base.html" %}` and defines various blocks which will replace
 9 | the blocks defined in base.html and its included child templates.
10 | #}
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/count_flexible_bonds.h:
--------------------------------------------------------------------------------
 1 | #ifndef _FIND_FLEXIBLE_BONDS_H
 2 | #define _FIND_FLEXIBLE_BONDS_H
 3 | 
 4 | extern int  count_flexible_ligand_bonds ( molecule_pt     molecule,
 5 |                                           short           ligand_flag[MAX_LIGAND_ATOMS] );
 6 | 
 7 | extern int  count_flexible_target_bonds ( global_data_pt  global,
 8 |                                           short           target_flag[MAX_PDB_ATOMS] );
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/docs/readthedocs/toc.html:
--------------------------------------------------------------------------------
 1 | {% for toc_item in page.toc %}
 2 |     <li class="toctree-l{{ navlevel + 1 }}"><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
 3 |     {% if toc_item.children %}
 4 |         <ul>
 5 |         {% for toc_item in toc_item.children %}
 6 |             <li><a class="toctree-l{{ navlevel + 2 }}" href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
 7 |         {% endfor %}
 8 |         </ul>
 9 |     {% endif %}
10 | {% endfor %}
11 | 


--------------------------------------------------------------------------------
/src/hbind/inc/write_ligand_mol2.h:
--------------------------------------------------------------------------------
 1 | #ifndef _WRITE_LIGAND_MOL2_H
 2 | #define _WRITE_LIGAND_MOL2_H
 3 | #include "types.h"
 4 | 
 5 | /*! Write out the ligand corresponding to a docking
 6 |  *
 7 |  * If positions is NULL, use the positions in global.  Otherwise, use the 
 8 |  * positions vector for the atoms' positions.  
 9 |  */
10 | void write_ligand_mol2(char *filename, float *positions, 
11 |                        dock_feats_pt features, global_data_pt global);
12 | 
13 | #endif
14 | 
15 | 


--------------------------------------------------------------------------------
/src/utils/inc/basics.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BASICS_H
 2 | #define _BASICS_H
 3 | 
 4 | #include <stdio.h>
 5 | 
 6 | #define MIN_DOUBLE 0.00000001
 7 | 
 8 | static inline int compare_double(double d1, double d2)
 9 | {
10 |   double my_diff = d1 - d2;
11 |   if(my_diff > MIN_DOUBLE) return 1;
12 |   else if(my_diff < -MIN_DOUBLE) return -1;
13 |   return 0;
14 | }
15 | 
16 | int hbind_strtod(const char *nptr, double *rv);
17 | 
18 | FILE *hbind_fopen(const char *path, const char *mode);
19 | 
20 | 
21 | #endif
22 | 
23 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_translate.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _UNBUMP_TRANSLATE_H
 2 | #define  _UNBUMP_TRANSLATE_H
 3 | 
 4 | extern void  compute_global_vector ( vector_pt vectors,
 5 | 				     int       number_of_points,
 6 | 				     vector_t  sum_vector );
 7 | 
 8 | extern int  quadratic_formula ( double  a, 
 9 | 				double  b, 
10 | 				double  c,
11 | 				double  *sol );
12 | 
13 | extern int  compute_translation_coefficient ( vector_t v,
14 | 					      vector_t w,
15 | 					      double   r,
16 | 					      double   *factor );
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/src/utils/Makefile:
--------------------------------------------------------------------------------
 1 | CC = gcc
 2 | COPTS = -O2 # Use for distribution
 3 | 
 4 | INCLUDES = -Iinc
 5 | 
 6 | VERSION = -DVERSION=\"1.0.0\"
 7 | CFLAGS = $(COPTS) $(INCLUDES) $(VERSION)
 8 | LIBS =  -lm
 9 | 
10 | OBJS =	basics.o hbind_itimer.o err_handle.o
11 | 
12 | libslideutils.a: $(OBJS)
13 | 	rm -f libhbindutils.a && \
14 |         ar -r libhbindutils.a *.o && \
15 | 	ranlib libhbindutils.a
16 | 
17 | .c.o: 
18 | 	$(CC) $(CFLAGS) -c $< 
19 | 
20 | clean:
21 | 	rm -f *.a *.o *.gcda *.gcno 
22 | 
23 | touch:  
24 | 	touch *.c
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/src/hbind/inc/write_waters_pdb.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _WRITE_WATERS_H
 2 | #define  _WRITE_WATERS_H
 3 | #include "types.h"
 4 | 
 5 | /*! Write the conserved waters 
 6 |  *
 7 |  * If either water_states OR water_positions is NULL the states and positions
 8 |  * are taken from the waters array.  Otherwise the positions and states
 9 |  * are taken from the water_positions and water_arrays respectively
10 |  */
11 | void write_waters_pdb(atom_pt waters, int num_waters, char *filename, 
12 |                       int *water_states, float *water_positions);
13 | #endif
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/src/hbind/inc/match_triangles.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _MATCH_TRIANGLES_H
 2 | #define  _MATCH_TRIANGLES_H
 3 | #include "types.h"
 4 | 
 5 | void match_triangles(global_data_pt global);
 6 | 
 7 | int compute_triangles(global_data_pt global, int *array, int index, int length,
 8 |                       int offset);
 9 | 
10 | void report_docking(dock_feats_pt features, moved_positions_pt moved_positions,
11 |                     char* lig_fname, global_data_pt global);
12 | 
13 | int score(dock_feats_pt features, global_data_pt global, FILE *good_acts_file);
14 | 
15 |      
16 | #endif
17 | 


--------------------------------------------------------------------------------
/docs/sources/hbind_tools.md:
--------------------------------------------------------------------------------
 1 | ## Hbind Tools
 2 | 
 3 | 
 4 | ###  Protein Recognition Index (PRI) 
 5 | 
 6 | Software for assessing the native-likeness of designed or predicted protein-ligand interfaces, which can be used to guide protein mutagenesis and ligand design.
 7 | 
 8 | - [https://psa-lab.github.io/protein-recognition-index/](https://psa-lab.github.io/protein-recognition-index/)
 9 | 
10 | ### Hbind Interaction Viz
11 | 
12 | A program for creating PyMOL H-bond interaction views from Hbind tables.
13 | 
14 | - [http://psa-lab.github.io/HbindViz](http://psa-lab.github.io/HbindViz


--------------------------------------------------------------------------------
/docs/readthedocs/search.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | 
 5 |   <h1 id="search">Search Results</h1>
 6 | 
 7 |   <form id="content_search" action="search.html">
 8 |     <span role="status" aria-live="polite" class="ui-helper-hidden-accessible"></span>
 9 |     <input name="q" id="mkdocs-search-query" type="text" class="search_input search-query ui-autocomplete-input" placeholder="Search the Docs" autocomplete="off" autofocus>
10 |   </form>
11 | 
12 |   <div id="mkdocs-search-results" class="search-results">
13 |     Searching...
14 |   </div>
15 | 
16 | {% endblock %}
17 | 


--------------------------------------------------------------------------------
/params/hbond.defn:
--------------------------------------------------------------------------------
 1 | #  definition of hydrogen-bond donor and acceptors
 2 | donor         N. ( H )
 3 | donor         N.4 [ * ]
 4 | acceptor      O. [ H ] [ N. ] ( * )
 5 | acceptor      O.3 ( 1 * ) [ N. ]
 6 | acceptor      O.co2 ( C.2 ( O.co2 ) )
 7 | acceptor      N. [ H ] [ O. ] [ 3 . ] ( * )
 8 | #acceptor      N. [ H ] [ N. ] [ O. ] [ 3 . ] ( * )
 9 | # the following rule has changed, now all sp2 O's can accept
10 | # acceptor      O.2 [ * ]
11 | acceptor      O.2
12 | # new rules
13 | acceptor      O.3 ( H ) ( C )
14 | acceptor      O.3 [ H ] ( 2 * )
15 | donor         O.3 ( H ) ( C )
16 | acceptor      F ( C )
17 | acceptor      Cl ( C )
18 | 


--------------------------------------------------------------------------------
/params/hbind.parameters:
--------------------------------------------------------------------------------
 1 | #  default parameter file
 2 | DME_THRESHOLD (A)                     0.3
 3 | RMS_THRESHOLD (A)                     0.3
 4 | ANCHOR_TRANSLATION (A)                0.3
 5 | ANCHOR_OVERLAP (A)                    0.3
 6 | SIDE_CHAIN_OVERLAP (A)                0.3
 7 | INTRA_OVERLAP (A)                     0.1
 8 | INTERMEDIATELY_TOLERATED_OVERLAP (A)  2.0
 9 | FINALLY_TOLERATED_MAX_BUMP (A)        0.5
10 | FINALLY_TOLERATED_OVERLAP (A)         2.0
11 | SCORE_CUTOFF (kcal/mol)               0.0
12 | MAX_TEMPLATE_TRIANGLES (#)        1500000
13 | MATCH_2_KEY_POINTS (n/a) 	False
14 | GROUP_CONFORMERS (n/a)	 	True
15 | RESTART_MOLECULE (n/a)          None
16 | 


--------------------------------------------------------------------------------
/src/hbind/inc/mymalloc.h:
--------------------------------------------------------------------------------
 1 | #ifndef _MYMALLOC_H
 2 | #define _MYMALLOC_H
 3 | 
 4 | #include <stdlib.h>
 5 | #include <err_handle.h>
 6 | 
 7 | static inline void*
 8 | mymalloc ( size_t  size )
 9 | {
10 |   void  *adr;
11 |   adr = malloc ( size );
12 |   if ( !adr ) err_panic( "mymalloc", "malloc failed" );
13 |   return ( adr );
14 | }
15 | 
16 | static inline void*
17 | myrealloc ( void    *old, size_t  size )
18 | {
19 |   void  *adr;
20 | 
21 |   adr = realloc ( old, size );
22 |   if ( !adr ) err_panic( "myrealloc", "realloc failed" );
23 |   return ( adr );
24 | }
25 | 
26 | static inline void
27 | my_free(void *ptr)
28 | {
29 |   if(ptr) free(ptr);
30 |   ptr = NULL;
31 | }
32 | #endif
33 | 


--------------------------------------------------------------------------------
/src/hbind/inc/distance_matrices.h:
--------------------------------------------------------------------------------
 1 | #ifndef DISTANCE_MATRICES_HEADER_FILE_INCLUDED
 2 | #define DISTANCE_MATRICES_HEADER_FILE_INCLUDED
 3 | 
 4 | #include <octree_array.h>
 5 | 
 6 | static inline int diff_int(int  a, int  b)
 7 | {
 8 |   return (a > b ? a - b : b - a);
 9 | }
10 | 
11 | void
12 | init_target_nbr_arrays(atom_pt target_atoms, const int num_atoms);
13 | 
14 | void
15 | initialize_inter_dist_matrix(const float* targ_positions, 
16 |                              const size_t num_targ_atoms, 
17 |                              const float* lig_positions, 
18 |                              const size_t num_lig_atoms,
19 |                              float *M, const float max_dist);
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/src/hbind/inc/docking_features.h:
--------------------------------------------------------------------------------
 1 | #ifndef FEATURES_HEADER_FILE_INCLUDED
 2 | #define FEATURES_HEADER_FILE_INCLUDED
 3 | 
 4 | #include "types.h"
 5 | 
 6 | void save_features(dock_feats_pt features, score_data_pt score,
 7 |                    int number_of_bumps, float total_overlap);
 8 | 
 9 | void write_features_line(dock_feats_pt features, char *lig_fname, FILE *fout,
10 |                          int docking);
11 | 
12 | void write_features_header(dock_feats_pt features, FILE *fp, char *lig_fname,
13 |                            interaction_pt template_interactions, 
14 |                            atom_pt ligand_atoms, atom_pt target_atoms);
15 | 
16 | void init_features(dock_feats_pt features);
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/src/utils/inc/mymalloc.h:
--------------------------------------------------------------------------------
 1 | #ifndef _MYMALLOC_H
 2 | #define _MYMALLOC_H
 3 | 
 4 | #include <stdlib.h>
 5 | #include <err_handle.h>
 6 | #include <mymalloc.h>
 7 | 
 8 | static inline void*
 9 | mymalloc ( size_t  size )
10 | {
11 |   void  *adr;
12 |   adr = malloc ( size );
13 |   if ( !adr ) err_panic( "mymalloc", "malloc failed" );
14 |   return ( adr );
15 | }
16 | 
17 | static inline void*
18 | myrealloc ( void    *old, size_t  size )
19 | {
20 |   void  *adr;
21 | 
22 |   adr = realloc ( old, size );
23 |   if ( !adr ) err_panic( "myrealloc", "realloc failed" );
24 |   return ( adr );
25 | }
26 | 
27 | static inline void
28 | my_free(void *ptr)
29 | {
30 |   if(ptr) free(ptr);
31 |   ptr = NULL;
32 | }
33 | #endif
34 | 


--------------------------------------------------------------------------------
/src/hbind/inc/dist_fun.h:
--------------------------------------------------------------------------------
 1 | #ifndef _DIST_FUN_H
 2 | #define _DIST_FUN_H
 3 | 
 4 | static inline float
 5 | squared_dist(const float *a, const float *b)
 6 | {
 7 |   return (b[0] - a[0])*(b[0] - a[0]) + (b[1] - a[1])*(b[1] - a[1]) + 
 8 |          (b[2] - a[2])*(b[2] - a[2]); 
 9 | }
10 | 
11 | static inline double
12 | squared_dist_double(const double *a, const double *b)
13 | {
14 |   return (b[0] - a[0])*(b[0] - a[0]) + (b[1] - a[1])*(b[1] - a[1]) + 
15 |          (b[2] - a[2])*(b[2] - a[2]); 
16 | }
17 | 
18 | extern float  dist_fun ( float  pos1[3], float  pos2[3] );
19 | 
20 | extern double dist_fun_cut ( float  pos1[3], float pos2[3] );
21 | 
22 | extern double dist_fun_double ( double  pos1[3], double  pos2[3] );
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | 
 3 | # Binaries
 4 | bin/
 5 | 
 6 | # Prerequisites
 7 | *.d
 8 | 
 9 | # Object files
10 | *.o
11 | *.ko
12 | *.obj
13 | *.elf
14 | 
15 | # Linker output
16 | *.ilk
17 | *.map
18 | *.exp
19 | 
20 | # Precompiled Headers
21 | *.gch
22 | *.pch
23 | 
24 | # Libraries
25 | *.lib
26 | *.a
27 | *.la
28 | *.lo
29 | 
30 | # Shared objects (inc. Windows DLLs)
31 | *.dll
32 | *.so
33 | *.so.*
34 | *.dylib
35 | 
36 | # Executables
37 | *.exe
38 | *.out
39 | *.app
40 | *.i*86
41 | *.x86_64
42 | *.hex
43 | 
44 | # Debug files
45 | *.dSYM/
46 | *.su
47 | *.idb
48 | *.pdb
49 | 
50 | # Kernel Module Compile Results
51 | *.mod*
52 | *.cmd
53 | .tmp_versions/
54 | modules.order
55 | Module.symvers
56 | Mkfile.old
57 | dkms.conf
58 | 


--------------------------------------------------------------------------------
/src/hbind/inc/distance_array.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef DISTANCE_ARRAY_HEADER_INCLUDED
 3 | #define DISTANCE_ARRAY_HEADER_INCLUDED
 4 | 
 5 | #include <atom.h>
 6 | 
 7 | typedef struct{
 8 |   atom_pt *atoms;
 9 |   int num_atoms;
10 |   int size;
11 | }*dist_bin_pt, dist_bin_t;
12 |   
13 | typedef struct{
14 |   dist_bin_pt bins;
15 |   float box_width;
16 |   float min_corner[3];
17 |   float max_corner[3];
18 |   int num_bins[3];
19 | }*dist_array_pt, dist_array_t;
20 | 
21 | void
22 | distance_array(dist_array_pt darray, const atom_pt atoms, int num_atoms,
23 |                const float box_width, const float max_dist);
24 | 
25 | void
26 | free_distance_array(dist_array_pt d);
27 | 
28 | dist_bin_pt 
29 | get_bin(dist_array_pt darray, float *pt);
30 | 
31 | #endif
32 | 


--------------------------------------------------------------------------------
/src/hbind/inc/find_all_bumps.h:
--------------------------------------------------------------------------------
 1 | #ifndef _FIND_ALL_BUMPS_H
 2 | #define _FIND_ALL_BUMPS_H
 3 | 
 4 | #include <types.h>
 5 | 
 6 | int find_all_bumps(dock_feats_pt features, global_data_pt global);
 7 | 
 8 | int atoms_overlap(const atom_pt a, const atom_pt b, const float distance,
 9 | 		  const float overlap_tolerance, float *overlap);
10 | 
11 | int atoms_overlap2(const atom_pt a, const atom_pt b, const float sq_dist, 
12 |                    const float overlap_tolerance, float *overlap, float *dist);
13 | 
14 | /*! At the present this method is not used -- if the handling of water is
15 |  * turned back on, then this will need to be verified for correctness
16 |  */
17 | int water_atom_overlap(const atom_pt a, const float distance, 
18 |                        const float overlap_tolerance, atom_pt w);
19 | #endif
20 | 


--------------------------------------------------------------------------------
/src/hbind/inc/check_rule.h:
--------------------------------------------------------------------------------
 1 | #ifndef _CHECK_RULE_H
 2 | #define _CHECK_RULE_H
 3 | 
 4 | static inline int 
 5 | check_atom(int rule_atom, int rule_orbit, int atom, int orbit)
 6 | {
 7 |   if((rule_atom == ANY || rule_atom == atom ) && 
 8 |      (rule_orbit == ANY || rule_orbit == orbit)) return SUCCESS;
 9 |   return FAILURE;
10 | }
11 | #if 0
12 | extern int  check_atom ( int  rule_atom,
13 | 			 int  rule_orbit,
14 | 			 int  atom,
15 | 			 int  orbit );
16 | #endif
17 | 
18 | extern int  check_prohibited_rule ( molecule_pt  molecule,
19 | 				    int          base_atom,
20 | 				    int          bond_atom,
21 | 				    rule_list_pt rule );
22 | 
23 | extern int  check_required_rule ( molecule_pt  molecule,
24 | 				  int          base_atom,
25 | 				  int          bond_atom,
26 | 				  rule_list_pt rule );
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/src/utils/basics.c:
--------------------------------------------------------------------------------
 1 | #include <float.h>
 2 | #include <stdio.h>
 3 | #include <stdlib.h>
 4 | #include <errno.h>
 5 | #include <string.h>
 6 | #include <err_handle.h>
 7 | 
 8 | int hbind_strtod(const char *nptr, double *rv)
 9 | {
10 |   char *end;
11 |   *rv = strtod(nptr, &end);
12 |   if(end == nptr){
13 |     char msg[200];
14 |     snprintf(msg, 200, "Unable to perform the conversion of \"%s\" to double."
15 |              "\n", nptr);
16 |     err_error("hbind_strtod", msg);
17 |     return 0;
18 |   } 
19 |   return 1;
20 | }
21 | 
22 | FILE *hbind_fopen(const char *path, const char *mode)
23 | {
24 |   FILE *rv;
25 |   int errsv;
26 |   rv = fopen(path, mode);
27 |   if(rv == 0){
28 |     errsv = errno;
29 |     fprintf(stderr, "Unable to open the file: %s\nReason: %s\n",
30 |             path, strerror(errsv));
31 |   }
32 |   return rv;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/hbind/inc/intra_bump_check.h:
--------------------------------------------------------------------------------
 1 | #ifndef _INTRA_BUMP_CHECK_H
 2 | #define _INTRA_BUMP_CHECK_H
 3 | 
 4 | extern int  intra_ligand_bump ( molecule_pt ligand,
 5 | 				float       max_overlap,
 6 | 				int         *rotated_atoms,
 7 | 				int         number_of_rotated_atoms );
 8 | 
 9 | extern int  check_for_intra_ligand_bump ( global_data_pt      global,
10 | 					  transform_matrix_pt matrix,
11 | 					  int                 flex_bond,
12 | 					  double              angle );
13 | 
14 | extern void  identify_second_grade_neighbors ( global_data_pt  global );
15 | 
16 | extern float  intra_molecular_bump_check ( atom_pt  atoms,
17 | 					   int      number_of_atoms );
18 | 
19 | extern double  bump_check_neighbors ( atom_pt  atoms,
20 | 				      int      *atoms_to_check,
21 | 				      int      number_of_atoms_to_check,
22 | 				      float    allowed_overlap );
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/src/hbind/number_ligand_atoms.c:
--------------------------------------------------------------------------------
 1 | #include "types.h"
 2 | 
 3 | int  assign_number ( molecule_pt  ligand, 
 4 | 		     int          atom, 
 5 | 		     int          prohibited,
 6 | 		     int          number )
 7 | {
 8 |   int  *neighbors;
 9 |   int  i;
10 | 
11 |   ligand->atoms[atom].number = number;
12 |   neighbors = ligand->neighbors[atom];
13 |   for ( i = 0; i < ligand->number_of_neighbors[atom]; i++ )
14 |     if ( neighbors[i] != prohibited
15 | 	 && ligand->atoms[neighbors[i]].number == -1 )
16 |       number = assign_number ( ligand,
17 | 			       ligand->neighbors[atom][i],
18 | 			       atom,
19 | 			       number + 1 );
20 |   return number;
21 | }
22 | 
23 | void  number_ligand_atoms ( molecule_pt  ligand )
24 | {
25 |   int  i;
26 | 
27 |   for ( i = 0; i < ligand->number_of_atoms; i++ )
28 |     ligand->atoms[i].number = -1;
29 |   assign_number ( ligand, 0, -1, 0 );
30 | }
31 | 


--------------------------------------------------------------------------------
/docs/readthedocs/versions.html:
--------------------------------------------------------------------------------
 1 | <div class="rst-versions" role="note" style="cursor: pointer">
 2 |     <span class="rst-current-version" data-toggle="rst-current-version">
 3 |       {% if config.repo_name == 'GitHub' %}
 4 |           <a href="{{ config.repo_url }}" class="fa fa-github" style="float: left; color: #fcfcfc"> GitHub</a>
 5 |       {% elif config.repo_name == 'Bitbucket' %}
 6 |           <a href="{{ config.repo_url }}" class="icon icon-bitbucket" style="float: left; color: #fcfcfc"> BitBucket</a>
 7 |       {% endif %}
 8 |       {% if page.previous_page %}
 9 |         <span><a href="{{ page.previous_page.url }}" style="color: #fcfcfc;">&laquo; Previous</a></span>
10 |       {% endif %}
11 |       {% if page.next_page %}
12 |         <span style="margin-left: 15px"><a href="{{ page.next_page.url }}" style="color: #fcfcfc">Next &raquo;</a></span>
13 |       {% endif %}
14 |     </span>
15 | </div>
16 | 


--------------------------------------------------------------------------------
/src/hbind/inc/unbump_side_chains.h:
--------------------------------------------------------------------------------
 1 | #ifndef _UNBUMP_SIDE_CHAINS_H
 2 | #define _UNBUMP_SIDE_CHAINS_H
 3 | 
 4 | extern void  initialize_distance_table ( global_data_pt  global );
 5 | 
 6 | extern int  compute_matrix ( atom_pt            side_chain_atoms,
 7 | 			     atom_pt            ligand_atom,
 8 | 			     int                res_type,
 9 | 			     int                bond,
10 | 			     transform_matrix_t matrix );
11 | 
12 | extern double  compute_unbump_angle ( double  x2,
13 | 				      double  d,
14 | 				      double  y1,
15 | 				      double  y2,
16 | 				      double  lxz,
17 | 				      double  l );
18 | 
19 | extern int  check_resolvability ( float              fixed_atom_pos[3],
20 | 				  float              rotated_atom_pos[3],
21 | 				  float              final_distance,
22 | 				  transform_matrix_t matrix );
23 | 
24 | extern int  unbump_side_chains ( global_data_pt  global );
25 | 
26 | #endif
27 | 
28 | 


--------------------------------------------------------------------------------
/docs/readthedocs/nav.html:
--------------------------------------------------------------------------------
 1 | {%- if nav_item.url %}
 2 |     <a class="{% if nav_item.active%}current{%endif%}" href="{{ nav_item.url }}">{{ nav_item.title }}</a>
 3 | {%- else %}
 4 |     <span class="caption-text">{{ nav_item.title }}</span>
 5 | {%- endif %}
 6 | 
 7 | {%- if nav_item == page or nav_item.children %}
 8 |     <ul class="subnav">
 9 |         {%- if nav_item == page %}
10 |             {% include 'toc.html' %}
11 |         {%- endif %}
12 |         {%- if nav_item.children %}
13 |             {%- set navlevel = navlevel + 1%}
14 |             {%- for nav_item in nav_item.children %}
15 |                 <li class="{% if navlevel > 2 %}toctree-l{{ navlevel }}{% endif %}{% if nav_item.active%} current{%endif%}">
16 |                     {% include 'nav.html' %}
17 |                 </li>
18 |             {%- endfor %}
19 |             {%- set navlevel = navlevel - 1%}
20 |         {%- endif %}
21 |     </ul>
22 | {%- endif %}
23 | 


--------------------------------------------------------------------------------
/src/hbind/inc/trans_rotate.h:
--------------------------------------------------------------------------------
 1 | #ifndef _TRANS_ROTATE_H
 2 | 
 3 | #define _TRANS_ROTATE_H
 4 | 
 5 | extern void  compute_yzx_matrix ( double             angle[3],
 6 | 				  double             trans[3],
 7 | 				  transform_matrix_t matrix );
 8 | 
 9 | extern void  compute_transformation_matrix ( float              n[3],
10 | 					     float              ca[3],
11 | 					     float              cb[3],
12 | 					     transform_matrix_t matrix );
13 | 
14 | extern void  transform_point ( float              pos[3],
15 | 			       transform_matrix_t matrix );
16 | 
17 | extern void  transform_point_back ( float              pos[3],
18 | 				    transform_matrix_t matrix );
19 | 
20 | extern void  rotate_around_y_axis ( atom_pt atoms,
21 | 				    int     number,
22 | 				    int     level,
23 | 				    double  angle );
24 | 
25 | extern void  rotate_single_atom_around_y_axis ( float   *position,
26 | 						double  angle );
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/src/hbind/inc/hbond_check.h:
--------------------------------------------------------------------------------
 1 | #ifndef _HBOND_CHECK_H
 2 | #define _HBOND_CHECK_H
 3 | #include "types.h"
 4 | 
 5 | int  check_hydrogen_angle ( global_data_pt global,
 6 | 				   int            target_index,
 7 | 				   int            ligand_index,
 8 | 				   float          *angle );
 9 | 
10 | float  compute_target_hydrogen_angle ( atom_pt    atoms,
11 | 					      residue_pt residues,
12 | 					      int        index,
13 | 					      float      *acceptor_position,
14 | 					      float      *hydrogen_position,
15 | 					      global_data_pt  global);
16 | 
17 | int  compute_ligand_hydrogen_angle ( global_data_pt global,
18 | 					    int            ligand_donor_index,
19 | 					    float          *acceptor_position,
20 | 					    float          *angle );
21 | int
22 | target_preacc_angle(atom_pt acceptor, float *hydrogen_position,
23 |                     atom_pt residue_atoms, int number_of_residue_atoms,
24 |                     float *angle);
25 | 
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/docs/readthedocs/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | <div role="navigation" aria-label="breadcrumbs navigation">
 2 |   <ul class="wy-breadcrumbs">
 3 |     <li><a href="{{ nav.homepage.url }}">Docs</a> &raquo;</li>
 4 |     {% if page %}
 5 |       {% for doc in page.ancestors %}
 6 |         {% if doc.link %}
 7 |           <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
 8 |         {% else %}
 9 |           <li>{{ doc.title }} &raquo;</li>
10 |         {% endif %}
11 |       {% endfor %}
12 |     {% endif %}
13 |     {% if page %}<li>{{ page.title }}</li>{% endif %}
14 |     <li class="wy-breadcrumbs-aside">
15 |       {%- block repo %}
16 |       {% if config.repo_url %}
17 |         <a href="{{ config.repo_url }}"
18 |         {%- if config.repo_name|lower == 'github' %}
19 |           class="icon icon-github"
20 |         {%- elif config.repo_name|lower == 'bitbucket' %}
21 |           class="icon icon-bitbucket"
22 |         {% endif %}> Edit on {{ config.repo_name }}</a>
23 |       {% endif %}
24 |       {%- endblock %}
25 |     </li>
26 |   </ul>
27 |   <hr/>
28 | </div>
29 | 


--------------------------------------------------------------------------------
/src/hbind/inc/intra_hbonds_flag.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _INTRA_HBONDS_REC_H
 2 | #define  _INTRA_HBONDS_REC_H
 3 | 
 4 | int intra_target_hbonds_flag(global_data_pt global, int index, 
 5 |                              short target_flag[MAX_PDB_ATOMS], FILE *fout);
 6 | 
 7 | extern void target_to_water_hbonds_flag ( global_data_pt  global,
 8 | 					  int             index,
 9 | 					  short           target_flag[MAX_PDB_ATOMS] );
10 | 
11 | extern void intra_ligand_hbonds_flag ( global_data_pt  global, 
12 | 				       int             index,
13 | 				       short           ligand_flag[MAX_PDB_ATOMS] );
14 | 
15 | extern void ligand_to_water_hbonds_flag ( global_data_pt  global,
16 | 					  int             index,
17 | 					  short           ligand_flag[MAX_PDB_ATOMS] );
18 | 
19 | int intra_target_polar_flag(residue_pt target_residues, atom_pt target_atoms,  
20 |                             const int num_targ_atoms, short *target_flag, 
21 |                             FILE *fout, float *num_of_intra_target_salt_bridges,
22 |                             global_data_pt global);
23 | #endif
24 | 
25 | 


--------------------------------------------------------------------------------
/src/hbind/quicksort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | #include <math.h>
 5 | #include <errno.h>
 6 | #include <unistd.h>
 7 | 
 8 | #include "defs.h"
 9 | #include "types.h"
10 | #include "basics.h"
11 | #include "quicksort.h"
12 | 
13 | void swap( int in_array[], int i, int j);
14 | 
15 | void quicksort_int( int in_array[], int left, int right )
16 | {
17 | 	int current=0, last=0;
18 | 
19 | 	if (left >= right)
20 |         	return;
21 | 	swap(in_array, left, (left+right)/2);
22 | 	last = left;
23 | 	for (current = left + 1; current <= right; current ++)
24 | 	    if ( in_array[current] < in_array[left] )
25 | 		swap(in_array, ++last, current);
26 | 	swap(in_array, left, last);
27 | 	quicksort_int(in_array, left, last-1);
28 | 	quicksort_int(in_array, last+1, right);
29 | }
30 | 
31 | /** The function swap interchanges the values in two positions of an array. **/ 
32 | 
33 | void swap( int in_array[], int i, int j )
34 | {
35 | 	int temp;
36 | 
37 | 	temp = in_array[i];
38 | 	in_array[i] = in_array[j];
39 | 	in_array[j] = temp;
40 | }
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/src/hbind/inc/hash_class.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _HASH_CLASS_H
 2 | #define  _HASH_CLASS_H
 3 | 
 4 | static int  hash_class[193] = {-1, -1, -1, 0, -1, -1, 1, -1, -1, 2, -1, -1, 
 5 | 			      3, -1, -1, -1, -1, -1, 4, -1, -1, 5, -1, -1, 
 6 | 			      6, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1, -1, 
 7 | 			      8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 8 | 			      9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 9 | 			      -1, -1, -1, -1, -1, -1, 10, -1, -1, 11, -1, -1, 
10 | 			      12, -1, -1, -1, -1, -1, -1, -1, -1, 13, -1, -1, 
11 | 			      14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
12 | 			      15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
13 | 			      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
14 | 			      -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, 
15 | 			      17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
16 | 			      18, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
17 | 			      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
18 | 			      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
19 | 			      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
20 | 			      19 };
21 | 
22 | #endif
23 | 
24 | 


--------------------------------------------------------------------------------
/docs/readthedocs/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {%- block next_prev %}
 3 |   {% if page and page.next_page or page.previous_page %}
 4 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 5 |       {% if page.next_page %}
 6 |         <a href="{{ page.next_page.url }}" class="btn btn-neutral float-right" title="{{ page.next_page.title }}">Next <span class="icon icon-circle-arrow-right"></span></a>
 7 |       {% endif %}
 8 |       {% if page.previous_page %}
 9 |         <a href="{{ page.previous_page.url }}" class="btn btn-neutral" title="{{ page.previous_page.title }}"><span class="icon icon-circle-arrow-left"></span> Previous</a>
10 |       {% endif %}
11 |     </div>
12 |   {% endif %}
13 |   {%- endblock %}
14 | 
15 |   <hr/>
16 | 
17 |   <div role="contentinfo">
18 |     <!-- Copyright etc -->
19 |     {% if config.copyright %}
20 |       <p>{{ config.copyright }}</p>
21 |     {% endif %}
22 |   </div>
23 | 
24 |   Built with <a href="http://www.mkdocs.org">MkDocs</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
25 | </footer>
26 | 


--------------------------------------------------------------------------------
/docs/mkdocs.yml:
--------------------------------------------------------------------------------
 1 | site_name: Hbind
 2 | site_url: http://psa-lab.github.io/hbind
 3 | site_author: Sebastian Raschka
 4 | site_description: Software to rigorously define intermolecular H-bonds by donor/acceptor chemistry and geometric constraints.
 5 | 
 6 | repo_url: https://github.com/psa-lab/hbind
 7 | 
 8 | docs_dir: sources
 9 | site_dir: html
10 | theme_dir: readthedocs
11 | 
12 | site_favicon: favicon.ico
13 | 
14 | markdown_extensions:
15 |   - extra
16 |   - tables
17 |   - fenced_code
18 |   - mathjax
19 | extra_javascript:
20 |   - https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML
21 |   - mathjaxhelper.js
22 | 
23 | copyright: Copyright &copy; 2018 Michigan State University. Developed in the <a href="http://www.kuhnlab.bmb.msu.edu">PSA Lab</a>.<br><em><a href="cite">Sebastian Raschka et al. 2018</a></em>.
24 | 
25 | 
26 | extra_css:
27 |   - extra.css
28 | 
29 | pages:
30 | - Home: index.md
31 | - Installation: installation.md
32 | - User Guide: user_guide.md
33 | - Hbind Tools: hbind_tools.md
34 | - About:
35 |   - Contact: contact.md
36 |   - Release Notes: changelog.md
37 |   - License: license.md
38 |   - Citing Hbind: cite.md
39 | 


--------------------------------------------------------------------------------
/src/hbind/dist_fun.c:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | 
 3 | float  dist_fun ( float  pos1[3], 
 4 | 		  float  pos2[3] )
 5 | {
 6 |   double dx, dy, dz, dist;
 7 | 
 8 |   dx = (double) pos1[0] - pos2[0];
 9 |   dy = (double) pos1[1] - pos2[1];
10 |   dz = (double) pos1[2] - pos2[2];
11 | 
12 |   dist = (double) sqrt ( (double) dx * dx + (double) dy * dy + (double) dz * dz );
13 |   return (float) dist;
14 |   
15 | }
16 | 
17 | 
18 | double dist_fun_cut ( float  pos1[3], 
19 | 	              float  pos2[3] )
20 | {
21 |   double dx, dy, dz;
22 |   int    temp;
23 |   double dist;
24 | 
25 |   dx = (double) ( pos1[0] - pos2[0] );
26 |   dy = (double) ( pos1[1] - pos2[1] );
27 |   dz = (double) ( pos1[2] - pos2[2] );
28 | 
29 |   dist = sqrt ( dx * dx + dy * dy + dz * dz );
30 | 
31 |   
32 |   temp = (int) ( (dist + 0.00005) * 10000 );
33 |   return ( (float) temp / 10000 );
34 |   
35 | }
36 | 
37 | 
38 | double dist_fun_double ( double  pos1[3],
39 | 			 double  pos2[3] )
40 | {
41 |    double dx, dy, dz;
42 | 
43 |    dx = pos1[0] - pos2[0];
44 |    dy = pos1[1] - pos2[1];
45 |    dz = pos1[2] - pos2[2];
46 | 
47 |    return sqrt ( dx * dx + dy * dy + dz * dz );
48 | }
49 | 
50 | 
51 | 


--------------------------------------------------------------------------------
/src/hbind/check_connectivity.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include "types.h"
 3 | #include "defs.h"
 4 | 
 5 | void  label_atoms ( molecule_pt  molecule,
 6 | 		    int          *label,
 7 | 		    int          atom,
 8 | 		    int          back )
 9 | {
10 |   int  *neighbors;
11 |   int  i;
12 | 
13 |   neighbors = molecule->neighbors[atom];
14 |   if ( label[atom] == UNVISITED )
15 |     {
16 |       /* this is the first time we visit this node */
17 |       label[atom] = VISITED;
18 |       for ( i = 0; i < molecule->number_of_neighbors[atom]; i++ )
19 | 	/* visit all neighbors, but don't take direct way back */
20 | 	if ( neighbors[i] != back )
21 | 	  {
22 | 	    label_atoms ( molecule,
23 | 			  label,
24 | 			  neighbors[i],
25 | 			  atom );
26 | 	  }
27 |     }
28 | }
29 |   
30 | int  check_connectivity ( molecule_pt  molecule )
31 | {
32 |   int     labels[MAX_NUMBER_OF_MOL2_ATOMS];
33 |   int     i;
34 | 
35 |   for ( i = 0; i < molecule->number_of_atoms; i++ )
36 |     labels[i] = UNVISITED;
37 |   label_atoms ( molecule, labels, 0, -1 );
38 |   for ( i = 0; i < molecule->number_of_atoms; i++ )
39 |     if ( labels[i] == UNVISITED )
40 | 	return FAILURE;
41 |   return SUCCESS;
42 | }
43 | 


--------------------------------------------------------------------------------
/src/utils/inc/hbind_itimer.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef _TIMER_H_INCLUDED
 3 | #define _TIMER_H_INCLUDED
 4 | #include <time.h>
 5 | 
 6 | int hbind_itimer_start(int interval_sec_in);
 7 | 
 8 | int hbind_itimer_get(double *real, double *virt, double *prof);
 9 | 
10 | char* hbind_get_local_time(char *buf, size_t buflen);
11 | 
12 | /*! Wrapper to eliminate buggy gcc warning about using "%c" in strftime.*/
13 | /*! From the man page for strftime:
14 |  * Some buggy versions of gcc complain about the use of %c: warning: `%c'
15 |  * yields only last 2 digits of year in some locales.  Of course
16 |  * programmers are encouraged to use %c, it gives the preferred date
17 |  * and time representation. One meets all kinds of strange obfuscations to
18 |  * circumvent this gcc problem. A relatively clean one is to add this
19 |  * intermediate function.
20 |  *
21 |  * @param s Character array of size max
22 |  * @param max Size of the array s
23 |  * @param fmt Format string
24 |  * @param tm The tm structure to convert to a string.
25 |  * @return The number of chars written to s if the time fits, else 0.
26 |  */
27 | size_t my_strftime(char *s, size_t max, const char  *fmt, const struct tm *tm);
28 | 
29 | #endif
30 | 


--------------------------------------------------------------------------------
/src/utils/inc/err_handle.h:
--------------------------------------------------------------------------------
 1 | #ifndef _ERR_HANDLE_H
 2 | #define _ERR_HANDLE_H
 3 | 
 4 | void set_err_filename(char *fname);
 5 | void  err_panic ( char  *function, char  *message );
 6 | 
 7 | void  err_error ( char  *function, char  *message );
 8 | 
 9 | void  err_warning ( char  *function, char  *message );
10 | 
11 | void  err_log ( char  *message );
12 | 
13 | void  err_usage ( char  *message );
14 | 
15 | void  err_unknown_atom ( char  *name, char  *residue, char  *residue_num );
16 | 
17 | void  err_unknown_residue ( char  *residue, char  *residue_num );
18 | 
19 | void  err_unknown_level ( char  *name, char  *residue, char  *residue_num );
20 | 
21 | 
22 | void  err_print ( char  *message);
23 | 
24 | void  err_panic2 ( char  *function, char  *message);
25 | 
26 | void  err_error2 ( char  *function, char  *message);
27 | 
28 | void  err_warning2 ( char  *function, char  *message);
29 | 
30 | void  err_log2 ( char  *message );
31 | 
32 | void  err_usage2 ( char  *message );
33 | 
34 | void  err_unknown_atom2 ( char  *name, char  *residue, char  *residue_num);
35 | 
36 | void  err_unknown_residue2 ( char  *residue, char  *residue_num);
37 | 
38 | void  err_unknown_level2 ( char  *name, char  *residue, char  *residue_num);
39 | 
40 | #endif
41 |  
42 | 


--------------------------------------------------------------------------------
/docs/sources/installation.md:
--------------------------------------------------------------------------------
 1 | ## Installation
 2 | 
 3 | Installing Hbind requires [Perl](https://www.perl.org) and the [GCC](https://gcc.gnu.org) compiler, both of which come pre-installed with most Unix- and Linux-based operating systems.
 4 | 
 5 | To install Hbind, simply download this repository, unpack it, and navigate into the main Hbind folder. Then, execute the following command in your terminal:
 6 | 
 7 |     perl install_hbind.pl
 8 | 
 9 | Upon successful installation, the Hbind software will be ready to use from the `bin/` subdirectory. To show the help and usage menu execute execute the following command in your terminal:
10 | 
11 |     ./bin/hbind -h
12 | 
13 | <br>
14 | 
15 | ```
16 | HBIND Version: 1.0.0
17 | 
18 | Documentation: http://psa-lab.github.io/Hbind
19 | Raschka, Wolf, Bemister-Buffington, Kuhn (2018)
20 | Protein Structure and Analysis Lab, MSU (http://kuhnlab.bmb.msu.edu)
21 | 
22 | 
23 | USAGE:
24 | -p STRING     Path to protein PDB file
25 | -l STRING     Path to ligand mol2 file (in docked conformation)
26 | -s            Include saltbridges in the output
27 | -t            Include a summary table in the output
28 | ```
29 | 
30 | 
31 |  Please see the "[User Guide](user_guide.md)" section for more information on how to use Hbind.


--------------------------------------------------------------------------------
/src/hbind/inc/rotatable_bonds.h:
--------------------------------------------------------------------------------
 1 | static int  number_of_rotatable_bonds[20] = 
 2 | {  0,  4,  2,  2,  1, 
 3 |    3,  3,  0,  2,  2, 
 4 |    2,  4,  3,  2,  0,  /* proline (last entry in this line) had originally 2 */
 5 |    1,  1,  2,  2,  1  };
 6 | 
 7 | static int  rotatable_bonds[20][6] = 
 8 | {
 9 |   /* ALA */
10 |   { CA },
11 |   /* ARG */
12 |   { CA, CB, CG, CD, NE, CZ },
13 |   /* ASN */
14 |   { CA, CB, CG, OD1 },
15 |   /* ASP */
16 |   { CA, CB, CG, OD1 },
17 |   /* CYS */
18 |   { CA, CB, SG },
19 |   /* GLN */
20 |   { CA, CB, CG, CD, OE1 },
21 |   /* GLU */
22 |   { CA, CB, CG, CD, OE1 },
23 |   /* GLY */
24 |   { CA },
25 |   /* HIS */
26 |   { CA, CB, CG, ND1 },
27 |   /* ILE */
28 |   { CA, CB, CG1, CD1 }, 
29 |   /* LEU */
30 |   { CA, CB, CG, CD1 },
31 |   /* LYS */
32 |   { CA, CB, CG, CD, CE, NZ },
33 |   /* MET */
34 |   { CA, CB, CG, SD, CE },
35 |   /* PHE */
36 |   { CA, CB, CG, CD1 },
37 |   /* PRO */
38 |   { CA }, /* , CB, CG, CD }, in the rotamer library rotamers for proline
39 | 	     have been given, but simple rotating those bonds does not work */
40 |   /* SER */
41 |   { CA, CB, OG },
42 |   /* THR */
43 |   { CA, CB, OG1 },
44 |   /* TRP */
45 |   { CA, CB, CG, CD1 },
46 |   /* TYR */
47 |   { CA, CB, CG, CD1 },
48 |   /* VAL */
49 |   { CA, CB, CG1 }
50 | };
51 | 


--------------------------------------------------------------------------------
/docs/sources/cite.md:
--------------------------------------------------------------------------------
 1 | # Citing Hbind
 2 | 
 3 | Hbind is research software and should be cited when you use it in your research. Please use the citation information given below.
 4 | 
 5 | **The journal article will appear in the *Journal of Computer-Aided Design* in 2018, currently, the information below refers to the manuscript preprint.**
 6 | 
 7 | ### BibTeX Entry
 8 | 
 9 | ```tex
10 | @article{Raschka2018-2,
11 | author = {Raschka, Sebastian and Wolf, Alex J and Bemister-Buffington, Joseph and Kuhn, Leslie A},
12 | doi = {10.1101/260612},
13 | journal = {bioRxiv},
14 | publisher = {Cold Spring Harbor Laboratory},
15 | title = {{Protein-ligand interfaces are polarized: Discovery of a strong trend for intermolecular hydrogen bonds to favor donors on the protein side with implications for predicting and designing ligand complexes}},
16 | url = {https://www.biorxiv.org/content/early/2018/02/05/260612},
17 | year = {2018}
18 | }
19 | 
20 | ```
21 | 
22 | 
23 | 
24 | 
25 | ### Formatted Citation Example
26 | 
27 | - Raschka S, Wolf AJ, Bemister-Buffington J, Kuhn LA (2018) *Protein-ligand interfaces are polarized: Discovery of a strong trend for intermolecular hydrogen bonds to favor donors on the protein side with implications for predicting and designing ligand complexes*. bioRxiv. doi: 10.1101/260612
28 | 


--------------------------------------------------------------------------------
/src/hbind/insertion_sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | #include <stdio.h>
 3 | #include "defs.h"
 4 | #include "types.h"
 5 | #include "basics.h"
 6 | 
 7 | void change_sort_array ( sort_array_pt item1, 
 8 | 			 sort_array_pt item2)
 9 | {
10 |     item1->index1 = item2->index1;
11 |     item1->index2 = item2->index2;
12 |     item1->value = item2->value;
13 | }
14 |  
15 | void  insertion_sort ( sort_array_pt array,
16 | 		       int           length )
17 | {
18 |   sort_array_t  help_item;
19 |   int           i = 0, j = 0;
20 | 
21 |   if ( length <= 1)
22 |     return;
23 | 
24 | #ifdef TRACE
25 |   printf("   insertion_sort: before sorting \n");
26 |   for ( i = 0; i < length; i++ )
27 | 	printf("insertion_sort: i=%d, value=%.16f, index1=%d, index2=%d\n", i, array[i].value, array[i].index1, array[i].index2);
28 |   printf("\n");
29 | #endif
30 | 
31 |     for (i = 1; i < length; i++)
32 | 	{
33 | 	    change_sort_array( &help_item, &array[i] );
34 | 	    j = i;
35 | 	    while ( j > 0 && compare_double( array[j-1].value, help_item.value ) == -1 )
36 | 		{
37 | 		    change_sort_array( &array[j], &array[j-1] );
38 | 		    j--;
39 | 		}
40 | 	    change_sort_array( &array[j], &help_item );
41 | 	}
42 | 
43 | #ifdef TRACE
44 |   for ( i = 0; i < length; i++ )
45 | 	printf("insertion_sort: i=%d, value=%.16f, index1=%d, index2=%d\n", i, array[i].value, array[i].index1, array[i].index2);
46 | #endif
47 | 
48 | }
49 | 
50 | 


--------------------------------------------------------------------------------
/docs/sources/index.md:
--------------------------------------------------------------------------------
 1 | ![](images/hbind-logo.png)
 2 | 
 3 | 
 4 | Software to rigorously define intermolecular H-bonds by donor/acceptor chemistry and geometric constraints, which was developed, used, and described in detail in 
 5 | 
 6 | - Raschka, Sebastian, Alex Wolf, Joseph Bemister‐Buffington, and Leslie A. Kuhn (2018) “Protein-ligand interfaces are polarized: discovery of a strong trend for intermolecular hydrogen bonds to favor donors on the protein side with implications for predicting and designing ligand complexes” Journal of Computer-Aided Molecular Design. *Journal of Computer-Aided Molecular Design* (accepted manuscript) [[biorxiv preprint](https://www.biorxiv.org/content/early/2018/02/05/260612)]
 7 | 
 8 | <br>
 9 | 
10 | ### Links
11 | 
12 | - Journal paper: [https://www.biorxiv.org/content/early/2018/02/05/260612](https://www.biorxiv.org/content/early/2018/02/05/260612)
13 | - Code repository: [https://github.com/psa-lab/Hbind](https://github.com/psa-lab/Hbind)
14 | - Documentation: [https://psa-lab.github.io/Hbind](https://github.com/psa-lab/Hbind)
15 | 
16 | <br>
17 | <br>
18 | <br>
19 | 
20 | 
21 | ---
22 | 
23 | 
24 | ![](images/1kpf_interact.png)
25 | 
26 | [Interactions between an PKCI-substrate analog ([1KPF](https://www.rcsb.org/pdb/explore.do?structureId=1kpf))  with its ligand (adenosine monophsophate) via [HbindViz](https://github.com/rasbt/HbindViz) and [PyMOL](https://pymol.org); hydrogen atoms not shown]


--------------------------------------------------------------------------------
/src/hbind/inc/read_mol2.h:
--------------------------------------------------------------------------------
 1 | #ifndef _READ_MOL2_H
 2 | #define _READ_MOL2_H
 3 | 
 4 | /*! /brief Assigns the type, orbit and vdw radius for given atom string
 5 |  * 
 6 |  * Assign the atom type, orbit (hybridization) and vdw radius for the given
 7 |  * SYBIL atom string.  
 8 |  *
 9 |  * @param str Input: string holding the atom name (PDB or mol2)
10 |  * @param type Output: pointer to type
11 |  * @param orbit Output: pointer to orbit
12 |  * @param radius Output: pointer to radius
13 |  * @param global_data_t Input: pointer to global stew
14 |  * @return SUCCESS or FAILURE
15 |  */
16 | int assign_type_orbit_radius(char *str, int *type, int *orbit, float *radius);
17 | 
18 | FILE* open_mol2(char *filename);
19 | 
20 | /*! /brief Given a file pointer, if needle, get the molecule that matches
21 |  *         needle; otherwise get the first molecule.
22 |  *
23 |  *  Start at the current position of the mol2 file in.  If needle is not null,
24 |  *  do a linear scan (from current position) until we find a molecule whose
25 |  *  name matches needle.  Otherwise, take the first molecule (from current
26 |  *  position).
27 |  *
28 |  * @param in Input: pointer to file to read
29 |  * @param filename Input: string holding the name of the open file (for error
30 |  *        messages
31 |  * @param global Input/Output: pointer to the global stew
32 |  * @param needle Input: Null or or name of molecule to find
33 |  * @return SUCCESS, FAILURE or FATAL_FAILURE
34 |  */
35 | int read_mol2(FILE* in, char *filename, global_data_pt global, char *needle);
36 | 
37 | #endif
38 | 


--------------------------------------------------------------------------------
/src/hbind/write_waters_pdb.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <errno.h>
 3 | #include <string.h>
 4 | #include "err_handle.h"
 5 | #include "defs.h"
 6 | #include "types.h"
 7 | 
 8 | void write_waters_pdb(atom_pt waters, int num_waters, char *filename, 
 9 |                       int *water_states, float *water_positions)
10 | {
11 |   atom_pt  water;
12 |   FILE     *fp;
13 |   int      i;
14 |   char     err_msg[2*FILENAME_MAX];
15 |   int errsv;
16 | 
17 |   if(num_waters <= 0) return;
18 | 
19 |   fp = fopen ( filename, "w" );
20 |   if ( fp == NULL ) {
21 |     errsv = errno;
22 |     sprintf(err_msg, "Could not open the file: %s\n\t%s", filename, 
23 |             strerror(errsv));
24 |     fprintf(stderr, err_msg);
25 |     err_print(err_msg);
26 |     err_panic2 ( "write_waters_pdb", "file open failed");
27 |   }
28 | 
29 |   water = waters;
30 |   if(water_states && water_positions){
31 |     for(i = 0; i < num_waters; i++, waters++){
32 |       if(water_states[i] != CONSERVED) continue;
33 | 
34 |       fprintf(fp, "HETATM %4d  O   HOH %5d     %7.3f %7.3f %7.3f  1.00  1.00\n",
35 |               water->number, water->number, water_positions[3*i],
36 |               water_positions[3*i + 1], water_positions[3*i + 2]);
37 |     }
38 |   }else{
39 |     for(i = 0; i < num_waters; i++, waters++){
40 |       if(water->state != CONSERVED) continue;
41 | 
42 |       fprintf(fp, "HETATM %4d  O   HOH %5d     %7.3f %7.3f %7.3f  1.00  1.00\n",
43 |               water->number, water->number, water->pos[0], water->pos[1], 
44 |               water->pos[2]);
45 |     }
46 |   }
47 |   fclose ( fp );
48 | }
49 | 


--------------------------------------------------------------------------------
/docs/readthedocs/license/highlight.js/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2006, Ivan Sagalaev
 2 | All rights reserved.
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are met:
 5 | 
 6 |     * Redistributions of source code must retain the above copyright
 7 |       notice, this list of conditions and the following disclaimer.
 8 |     * Redistributions in binary form must reproduce the above copyright
 9 |       notice, this list of conditions and the following disclaimer in the
10 |       documentation and/or other materials provided with the distribution.
11 |     * Neither the name of highlight.js nor the names of its contributors 
12 |       may be used to endorse or promote products derived from this software 
13 |       without specific prior written permission.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 | DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 


--------------------------------------------------------------------------------
/src/hbind/trace.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include "defs.h"
 3 | #include "types.h"
 4 | #include "err_handle.h"
 5 | 
 6 | void  print_template ( global_data_pt  global )
 7 | {
 8 |   interaction_pt  points;
 9 |   int             i;
10 | 
11 |   if ( global->template_interactions == NULL
12 |        || global->template_size == 0 )
13 |     err_panic2 ( "print_template", "no template_points");
14 |   points = global->template_interactions;
15 |   for ( i = 0; i < global->template_size; i++ )
16 |     printf ( "%d: %s %8.3f %8.3f %8.3f\n",
17 | 	     i, 
18 | 	     points[i].act == DONOR       ? "DONOR    " 
19 | 	     : points[i].act == ACCEPTOR  ? "ACCEPTOR "  
20 | 	     : points[i].act == HYDROPHOB ? "HYDROPHOB" 
21 | 	     : "NOTHING  ",
22 | 	     points[i].pos[X],
23 | 	     points[i].pos[Y],
24 | 	     points[i].pos[Z] );
25 | }
26 | 
27 | void  print_compounds ( global_data_pt  global )
28 | {
29 |   pts_compound_pt  compounds;
30 |   int              i;
31 |   
32 |   compounds = global->compound_interactions->compounds;
33 |   for ( i = 0; i < global->compound_interactions->number_of_compounds; i++ )
34 |     printf ( "%-16s  %3d points   first: %d\n",
35 | 	     compounds[i].name,
36 | 	     compounds[i].number_of_points,
37 | 	     compounds[i].first_point );
38 |   printf ( "%d points\n", global->compound_interactions->number_of_interaction_points );
39 |   for ( i = 0; 
40 | 	i < global->compound_interactions->number_of_interaction_points;
41 | 	i++ )
42 |     printf ( "%3d: act = %2d, index = %d\n",
43 | 	     i,
44 | 	     global->compound_interactions->act[i],
45 | 	     global->compound_interactions->atom_index[i] );
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/src/hbind/least_square_fit.c:
--------------------------------------------------------------------------------
 1 | #include "defs.h"
 2 | #include "rotate.h"
 3 | 
 4 | int least_square_fit ( double  a[3][3], 
 5 | 		       double  b[3][3], 
 6 | 		       double  c[3][3],
 7 | 		       double  weights[3],
 8 | 		       double  matrix[3][3], 
 9 | 		       double  vector[3] )
10 | {
11 |   double  newa[3][3],	
12 |           newb[3][3];	
13 |   double  ta[3],
14 |           tb[3],	
15 |           help[3];
16 |   double  weightsum;
17 |   int     i, j;
18 | 
19 |   for( i = 0; i < 3; i++ )
20 |     ta[i] = tb[i] = 0.0;
21 |   weightsum = 0.0;
22 |   for ( i = 0; i < 3; i++ ) 
23 |     {
24 |       weightsum += weights[i];
25 |       for ( j = 0; j < 3; j++ )
26 | 	{
27 | 	  ta[j] += weights[i] * a[i][j];
28 | 	  tb[j] += weights[i] * b[i][j];
29 | 	}
30 |     }
31 |   for ( i = 0; i < 3; i++ )
32 |     {
33 |       ta[i] /= weightsum;
34 |       tb[i] /= weightsum;
35 |     }
36 |   for ( i = 0; i < 3; i++ )
37 |     for ( j = 0; j < 3; j++ )
38 |       {
39 | 	newa[i][j] = a[i][j] - ta[j];
40 | 	newb[i][j] = b[i][j] - tb[j];
41 |       }
42 |   if ( rotate ( newa, 
43 | 		newb, 
44 | 		weights,
45 | 		matrix ) == FAILURE )   
46 |     return FAILURE;
47 |   for ( i = 0; i < 3; i++ ) 
48 |     {
49 |       for ( j = 0; j < 3; j++ )
50 | 	c[i][j] = a[i][j] - ta[j];
51 |       for ( j = 0; j < 3; j++ )
52 | 	{
53 | 	  help[j] = matrix[j][0] * c[i][0];
54 | 	  help[j] += matrix[j][1] * c[i][1];
55 | 	  help[j] += matrix[j][2] * c[i][2];
56 | 	}
57 |       for ( j = 0; j < 3; j++ )
58 | 	c[i][j] = help[j] + tb[j];
59 |       vector[i] = tb[i] - ( matrix[i][0] * ta[0] 
60 | 		          + matrix[i][1] * ta[1] 
61 | 			  + matrix[i][2] * ta[2] );
62 |     }
63 |   return SUCCESS;
64 | }
65 | 


--------------------------------------------------------------------------------
/src/hbind/write_target_pdb.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <errno.h>
 4 | #include "err_handle.h"
 5 | #include "defs.h"
 6 | #include "types.h"
 7 | #include "dist_fun.h"
 8 | 
 9 | void write_target_pdb(residue_pt residues, int num_res, atom_pt atoms, 
10 |                       int num_atoms, char *filename, int *rotations, 
11 |                       float *positions)
12 | {
13 |   FILE     *fp;
14 |   int      count;
15 |   int      i, j;
16 |   char     new_res_num[20];
17 |   char     check_new_res_num[20];
18 |   char     err_msg[2*FILENAME_MAX];
19 |   int errsv;
20 |   atom_pt atom;
21 |   float *atom_pos = 0;
22 | 
23 |   fp = fopen ( filename, "w" );
24 |   if ( fp == NULL ) {
25 |     errsv = errno;
26 |     sprintf(err_msg, "Could not open the file: %s\n\t%s", filename, 
27 |             strerror(errsv));
28 |     fprintf(stderr, err_msg);
29 |     err_print(err_msg);
30 |     err_panic2("write_target_pdb", "file open failed");
31 |   }
32 | 
33 |   count = 1;
34 |   for(i = 0; i < num_res; i++){
35 |     if(rotations[i] != YES) continue;
36 | 
37 |     atom = atoms + residues[i].start_atom;
38 |     if(positions) atom_pos = positions + 3*residues[i].start_atom;
39 |     else atom_pos = atom->pos;
40 |     for(j = 0; j < residues[i].number_of_atoms; j++){
41 |         fprintf(fp, "ATOM  %5d  %-3s%1c%-3s %1c%5s    %7.3f %7.3f %7.3f"
42 |                 "  1.00  1.00\n", count, atom->name, atom->alt_location,
43 |                 atom->residue, atom->chain_id, atom->residue_num,
44 |                 atom_pos[0], atom_pos[1], atom_pos[2]);
45 |       count++;
46 |       atom++;
47 |       atom_pos += 3;
48 |     }
49 |   }
50 | 
51 |   fclose ( fp );
52 | }
53 | 


--------------------------------------------------------------------------------
/src/hbind/inc/params.h:
--------------------------------------------------------------------------------
 1 | /* NOTE: This is the file that contains user adjustable parameters and definitions.  Please refer to the User Guide for recommended settings */
 2 | 
 3 | 
 4 | #undef  OUTPUT_ALL_MATCHES /* WARNING: turning on this option will result in MANY extra dockings, and may be unnecessary unless attempting to rescore dockings with an alternate scoring method.  When #undef it will output only the best scoring orientation for overlap free dockings and for dockings with tolerated overlap.  When #define it will output all dockings for overlap free dockings and for dockings with tolerated overlap */
 5 | 
 6 | #undef VERBOSE_OUTPUT /* When OUTPUT_ALL_MATCHES is undefined it is possible to still see the score output of the potential dockings in the stdout (or redirected file), if necessary. To turn on this option, simply set to #define.  This may, however, create a very large output file */
 7 | 
 8 | #define  FILTER_BURIED_CARBONS /* When #define it will output and score only dockings that have at least 50% of the ligand's carbons buried in the protein-ligand interface */
 9 | 
10 | /* Define the ranges of edge lengths for the triangles (units are Angstroms) */
11 | #define TRIANGLE_MIN_PERIMETER             7.0
12 | #define TRIANGLE_MAX_PERIMETER            30.0
13 | #define TRIANGLE_MIN_SHORTEST_SIDE         2.0
14 | #define TRIANGLE_MAX_SHORTEST_SIDE        10.0
15 | #define TRIANGLE_MAX_LONGEST_SIDE         12.0
16 | /* Support smaller triangle sides for smaller ligands */
17 | #define SMALL_TRIANGLE_MIN_LONGEST_SIDE    3.0
18 | #define LARGE_TRIANGLE_MIN_LONGEST_SIDE    5.0
19 | 
20 | /* Define in Angstroms the diameter of the sphere in which a small ligand 
21 |  * must fit
22 |  */
23 | #define SMALL_LIGAND_DIAMETER  10.0
24 | 


--------------------------------------------------------------------------------
/src/hbind/inc/params.h~:
--------------------------------------------------------------------------------
 1 | /* NOTE: This is the file that contains user adjustable parameters and definitions.  Please refer to the User Guide for recommended settings */
 2 | 
 3 | 
 4 | #define  OUTPUT_ALL_MATCHES /* WARNING: turning on this option will result in MANY extra dockings, and may be unnecessary unless attempting to rescore dockings with an alternate scoring method.  When #undef it will output only the best scoring orientation for overlap free dockings and for dockings with tolerated overlap.  When #define it will output all dockings for overlap free dockings and for dockings with tolerated overlap */
 5 | 
 6 | #undef VERBOSE_OUTPUT /* When OUTPUT_ALL_MATCHES is undefined it is possible to still see the score output of the potential dockings in the stdout (or redirected file), if necessary. To turn on this option, simply set to #define.  This may, however, create a very large output file */
 7 | 
 8 | #define  FILTER_BURIED_CARBONS /* When #define it will output and score only dockings that have at least 50% of the ligand's carbons buried in the protein-ligand interface */
 9 | 
10 | /* Define the ranges of edge lengths for the triangles (units are Angstroms) */
11 | #define TRIANGLE_MIN_PERIMETER             7.0
12 | #define TRIANGLE_MAX_PERIMETER            30.0
13 | #define TRIANGLE_MIN_SHORTEST_SIDE         2.0
14 | #define TRIANGLE_MAX_SHORTEST_SIDE        10.0
15 | #define TRIANGLE_MAX_LONGEST_SIDE         12.0
16 | /* Support smaller triangle sides for smaller ligands */
17 | #define SMALL_TRIANGLE_MIN_LONGEST_SIDE    3.0
18 | #define LARGE_TRIANGLE_MIN_LONGEST_SIDE    5.0
19 | 
20 | /* Define in Angstroms the diameter of the sphere in which a small ligand 
21 |  * must fit
22 |  */
23 | #define SMALL_LIGAND_DIAMETER  10.0
24 | 


--------------------------------------------------------------------------------
/src/hbind/inc/check_complementarity.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _CHECK_COMPLEMENTARITY_H
 2 | #define  _CHECK_COMPLEMENTARITY_H
 3 | #include "types.h"
 4 | 
 5 | int is_repulsive_polar( global_data_pt global,
 6 |                         atom_t lig, int lig_atom_idx, /* ligand*/
 7 |                         atom_t tgt, int tgt_atom_idx, /* target*/
 8 |                         float lig_tgt_dist);
 9 | 
10 | int is_repulsive_charged( global_data_pt global,
11 | 			  atom_t lig, int lig_atom_idx, /* ligand*/
12 | 			  atom_t tgt, int tgt_atom_idx, /* target*/
13 |                         float lig_tgt_dist);
14 | 						
15 | 
16 | 
17 | int is_hbond(atom_t a, atom_t b, int i, int j, float dist, float *angle, 
18 |              global_data_pt  global);
19 | int is_salt_bridge(int a_act, float a_charge, int b_act, float b_charge, 
20 |                    float dist);
21 | int is_metal_hbond(atom_t a, atom_t metal, float dist );
22 | int is_metal_salt_bridge(atom_t lig, atom_t metal, float dist);
23 | int is_hphobic_complementary( atom_t a , atom_t b, float dist);
24 | 
25 | static inline int
26 | is_hbond_interaction(int A_act, int B_act)
27 | {
28 |   int act_sum = A_act + B_act;
29 |   if(ACCEPTOR_DONOR == act_sum || DONOR_DONEPTOR == act_sum ||
30 |      ACCEPTOR_DONEPTOR == act_sum || DONEPTOR_DONEPTOR == act_sum) return 1;
31 |   return 0;
32 | }
33 | 
34 | static inline int
35 | is_polar_interaction(int A_act, int B_act)
36 | {
37 |   int act_sum = A_act + B_act;
38 |   if(ACCEPTOR_DONOR == act_sum || DONOR_DONEPTOR == act_sum ||
39 |      ACCEPTOR_DONEPTOR == act_sum || DONEPTOR_DONEPTOR == act_sum ||
40 |      ACCEPTOR_DONOR_HYDROGEN == act_sum || DONEPTOR_DONOR_HYDROGEN == act_sum ||
41 |      ACCEPTOR_METAL_1 == act_sum || ACCEPTOR_METAL_2 == act_sum ||
42 |      DONEPTOR_METAL_1 == act_sum || DONEPTOR_METAL_2 == act_sum) return 1;
43 |   return 0;
44 | }
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/src/hbind/inc/bitstrings.h:
--------------------------------------------------------------------------------
 1 | #ifndef  _BITSTRING_H
 2 | #define  _BITSTRING_H
 3 |  
 4 | extern int  min_int ( int  a, 
 5 | 		      int  b );
 6 | 
 7 | extern int  bitstring_get_bit ( bitstring_pt  vec, 
 8 | 				unsigned int  pos );
 9 |  
10 | extern int  bitstring_all_clear ( bitstring_pt  vec );
11 | 
12 | extern int  bitstring_all_set ( bitstring_pt vec );
13 | 
14 | extern void  bitstring_and_all ( bitstring_pt  vec, 
15 | 				 bitstring_pt  vec2 );
16 | 
17 | extern void  bitstring_clear_all ( bitstring_pt  vec );
18 | 
19 | extern int  bitstring_clear_bit ( bitstring_pt  vec, 
20 | 				  unsigned int  pos );
21 | 
22 | extern int  bitstring_cmp_all ( bitstring_pt  vec, 
23 | 				bitstring_pt  vec2 );
24 | 
25 | extern int  bitstring_cmp_and_0 ( bitstring_pt  vec1, 
26 | 				  bitstring_pt  vec2 );
27 | 
28 | extern int  bitstring_cmp_or_1 ( bitstring_pt  vec1, 
29 | 				 bitstring_pt  vec2 );
30 | 
31 | extern int bitstring_cmp_xor_1 ( bitstring_pt  vec1, 
32 | 				 bitstring_pt  vec2 );
33 | 
34 | extern unsigned int  bitstring_count_bits ( bitstring_pt  vec );
35 | 
36 | extern void  bitstring_cpy_all ( bitstring_pt  vec, 
37 | 				 bitstring_pt  vec2 );
38 | 
39 | extern bitstring_pt  bitstring_create ( unsigned int  len );
40 | 
41 | extern void  bitstring_free ( bitstring_pt  vec );
42 | 
43 | extern void  bitstring_or_all ( bitstring_pt  vec, 
44 | 				bitstring_pt  vec2 );
45 | 
46 | extern void  bitstring_print ( bitstring_pt  vec );
47 | 
48 | extern void  bitstring_print_part ( bitstring_pt  vec,
49 | 				    int           number );
50 | 
51 | extern void  bitstring_set_all ( bitstring_pt  vec );
52 | 
53 | extern int  bitstring_set_bit ( bitstring_pt  vec, 
54 | 				unsigned int  pos );
55 | 
56 | extern void  bitstring_ptoggle_all ( bitstring_pt  vec );
57 | 
58 | extern int  bitstring_ptoggle_bit( bitstring_pt  vec, 
59 | 				   unsigned int  pos );
60 | 
61 | extern void  bitstring_xor_all ( bitstring_pt  vec, 
62 | 				 bitstring_pt  vec2 );
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/src/hbind/print_interaction.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h> 
 2 | #include <stdlib.h>
 3 | #include "print_interaction.h"
 4 | #include "err_handle.h"
 5 | #include "dist_fun.h"
 6 | 
 7 | const char INTERACTION_SEPARATOR = '|';
 8 | 
 9 | int print_atom(FILE *fout, atom_pt a, int type);
10 | 
11 | void print_interaction(atom_pt atom1, int atom1_type, int atom1_index, 
12 |                        atom_pt atom2, int atom2_type, int atom2_index,
13 |                        const char *interaction_type, FILE *fout)
14 | {
15 |   fprintf(fout, "%s%c", interaction_type, INTERACTION_SEPARATOR);
16 | 
17 |   if(atom1_type == atom2_type && atom2_index < atom1_index){
18 |     if(!print_atom(fout, atom2, atom2_type))
19 |       err_panic2("print_interaction", "Second atom has unknown type");
20 |     fprintf(fout, "%c", INTERACTION_SEPARATOR);
21 |     if(!print_atom(fout, atom1, atom1_type))
22 |       err_panic2("print_interaction", "First atom has unknown type");
23 |   }else{
24 |     if(!print_atom(fout, atom1, atom1_type))
25 |       err_panic2("print_interaction", "First atom has unknown type");
26 |     fprintf(fout, "%c", INTERACTION_SEPARATOR);
27 |     if(!print_atom(fout, atom2, atom2_type))
28 |       err_panic2("print_interaction", "Second atom has unknown type");
29 |   }
30 |   fprintf(fout, "%c", INTERACTION_SEPARATOR);
31 |   fprintf(fout, "%f\n", dist_fun(atom1->pos, atom2->pos));
32 | }
33 | 
34 | int print_atom(FILE *fout, atom_pt a, int type)
35 | {
36 |   int rv = 1;
37 |   char *end;
38 |   if(type == TARGET) fprintf(fout, "T,");
39 |   else if(type == LIGAND) fprintf(fout, "L,");
40 |   else if(type == WATER) fprintf(fout, "W,");
41 |   else rv = 0;
42 | 
43 |   if(rv){
44 |     fprintf(fout, "%c,%s,%-s,%s,%d,", a->chain_id, a->residue, 
45 |             a->residue_num, a->name, a->atom_number);
46 |     if(a->act == DONOR) fprintf(fout, "D,");
47 |     else if(a->act == ACCEPTOR) fprintf(fout, "A,");
48 |     else if(a->act == DONEPTOR) fprintf(fout, "N,");
49 |     else fprintf(fout, ",");
50 |   }
51 | 
52 |   return rv;
53 | }
54 | 


--------------------------------------------------------------------------------
/src/hbind/adj_list.c:
--------------------------------------------------------------------------------
 1 | #include <types.h>
 2 | 
 3 | void  construct_adjacency_list ( molecule_pt molecule )
 4 | {
 5 |   bond_pt  bonds;
 6 |   int      **neighbors;
 7 |   int      **bond;
 8 |   int      *number_of_neighbors;
 9 |   int      *bond_order;
10 |   int      i, atom1, atom2;
11 |   
12 |   number_of_neighbors = molecule->number_of_neighbors;
13 |   bond_order = molecule->bond_order;
14 |   for(i = 0; i < molecule->number_of_atoms; i++){
15 |     number_of_neighbors[i] = 0;
16 |     bond_order[i] = 0;
17 |   }
18 |   bonds = molecule->bonds;
19 |   neighbors = molecule->neighbors;
20 |   number_of_neighbors = molecule->number_of_neighbors;
21 |   bond_order = molecule->bond_order;
22 |   bond = molecule->bond_to_neighbor;
23 |   for(i = 0; i < molecule->number_of_bonds; i++){
24 |     atom1 = bonds[i].atom1;
25 |     atom2 = bonds[i].atom2;
26 |     neighbors[atom1][number_of_neighbors[atom1]] = atom2;
27 |     bond[atom1][number_of_neighbors[atom1]++] = i;
28 |     neighbors[atom2][number_of_neighbors[atom2]] = atom1;
29 |     bond[atom2][number_of_neighbors[atom2]++] = i;
30 |       
31 |     if ( molecule->bonds[i].type == SINGLE ) {
32 |       bond_order[atom1] +=  1;
33 |       bond_order[atom2] +=  1;      
34 |     } else if ( molecule->bonds[i].type == DOUBLE ) {
35 |       bond_order[atom1] +=  2;
36 |       bond_order[atom2] +=  2;      
37 |     } else if ( molecule->bonds[i].type == TRIPLE ) {
38 |       bond_order[atom1] +=  3;
39 |       bond_order[atom2] +=  3;      
40 |     } else if ( molecule->bonds[i].type == QUADRUPLE ) {
41 |       bond_order[atom1] +=  4;
42 |       bond_order[atom2] +=  4;      
43 |     } else if ( molecule->bonds[i].type == DELOCALIZED ) {
44 |       bond_order[atom1] +=  1;
45 |       bond_order[atom2] +=  1;      
46 |     } else if ( molecule->bonds[i].type == AMIDE ) {
47 |       bond_order[atom1] +=  1;
48 |       bond_order[atom2] +=  1;      
49 |     } else if ( molecule->bonds[i].type == AROMATIC ) {
50 |       bond_order[atom1] +=  1.5;
51 |       bond_order[atom2] +=  1.5;      
52 |     }
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/hbind/read_hyd_defn.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include "err_handle.h"
 4 | #include "read_rule.h"
 5 | 
 6 | void read_hyd_defn(char *filename, hyd_defn_pt  hyd_rules)
 7 | {
 8 |   char    linebuffer[MAX_MOL2_LINELENGTH];
 9 |   FILE    *in;
10 |   rule_pt acceptor_rules,
11 |           donor_rules;
12 |   int     number_of_donor_rules,
13 |           number_of_acceptor_rules;
14 |   
15 |   in = fopen ( filename, "r" );
16 |   if ( in == NULL ){
17 |     perror ( "ERROR  " );
18 |     sprintf ( linebuffer, "unable to open file %s", filename );
19 |     err_panic2 ( "read_hyd_defn", linebuffer);
20 |   }
21 |   acceptor_rules = hyd_rules->acceptor_rules;
22 |   donor_rules = hyd_rules->donor_rules;
23 |   number_of_donor_rules = 0;
24 |   number_of_acceptor_rules = 0;
25 |   while(fgets ( linebuffer, sizeof ( linebuffer ), in ) != NULL ){
26 |     /* Skip comment and empty lines */
27 |     if(linebuffer[0] == '#' || linebuffer[0] == '\n' || linebuffer[0] == '\0' )
28 |       continue;
29 | 
30 |     /* superscribe `\n` with `\0` */
31 |     linebuffer[strlen(linebuffer)-1] = '\0';
32 |     /* this is the definition of a donor rule */
33 |     if ( strncmp ( linebuffer, "donor", 5 ) == 0 ){
34 |       if(number_of_donor_rules >= MAX_NUMBER_OF_HYD_RULES )
35 | 	err_panic2 ( "read_hyd_defn", "too many donor rules");
36 |       parse_definition_line(linebuffer, &donor_rules[number_of_donor_rules]);
37 |       number_of_donor_rules++;
38 |     }
39 |     /* this is the definition of a acceptor rule */
40 |     if ( strncmp ( linebuffer, "acceptor", 8 ) == 0 ){
41 |       if(number_of_acceptor_rules >= MAX_NUMBER_OF_HYD_RULES )
42 |         err_panic2 ( "read_hyd_defn", "too many acceptor rules");
43 |       parse_definition_line(linebuffer, 
44 |                             &acceptor_rules[number_of_acceptor_rules]);
45 |       number_of_acceptor_rules++;
46 |     }
47 |   }
48 |   hyd_rules->number_of_donor_rules = number_of_donor_rules;
49 |   hyd_rules->number_of_acceptor_rules = number_of_acceptor_rules;
50 |   fclose ( in );
51 | }
52 | 	  
53 | 


--------------------------------------------------------------------------------
/src/hbind/Makefile:
--------------------------------------------------------------------------------
 1 | BINPATH = ../../bin
 2 | 
 3 | CC = gcc -v
 4 | EXENAME = hbind
 5 | COPTS = -O2 # Use for distribution
 6 | 
 7 | INCLUDES = -Iinc -I../utils/inc
 8 | VERSION = -DVERSION=\"1.0.0\"
 9 | CFLAGS = $(COPTS) $(INCLUDES) $(VERSION)
10 | LIBS = ../utils/libhbindutils.a -lm
11 | 
12 | OBJS =	debug_funs.o \
13 | 	initialize.o  \
14 |         distance_array.o \
15 | 	distance_matrices.o \
16 | 	read_mol2.o \
17 | 	assign_type.o \
18 | 	read_pdb.o \
19 | 	dist_fun.o \
20 | 	bitstrings.o  \
21 | 	read_flex_defn.o \
22 | 	read_rule.o \
23 | 	adj_list.o \
24 | 	assign_hydrogens.o \
25 | 	find_cycles.o \
26 | 	find_flexible_bonds.o \
27 | 	check_rule.o \
28 | 	score_complex.o \
29 | 	trans_rotate.o \
30 | 	read_waters.o \
31 | 	hbond_check.o \
32 | 	find_hyd_atoms.o \
33 | 	read_hyd_defn.o \
34 | 	intra_hbonds.o \
35 | 	intra_hbonds_flag.o \
36 | 	sum_charges.o \
37 | 	calc_score_from_terms.o \
38 | 	check_complementarity.o \
39 | 	count_flexible_bonds.o \
40 | 	trace.o \
41 | 	hashing.o  \
42 | 	read_pts_file.o \
43 | 	read_template.o \
44 | 	analyze_ligand.o \
45 | 	transform_molecule.o \
46 | 	assign_fragments.o \
47 | 	bump_check.o \
48 | 	check_connectivity.o \
49 | 	compute_all_rotation_angles.o \
50 | 	unbump_side_chains.o \
51 | 	compute_target_angles.o \
52 | 	compute_ligand_angles.o \
53 | 	unbump_anchor.o \
54 | 	unbump_translate.o \
55 | 	find_all_bumps.o \
56 | 	compute_unbump_dependencies.o \
57 | 	eigen.o \
58 | 	rotate.o \
59 | 	least_square_fit.o \
60 | 	find_carbon_ring_centers.o \
61 | 	initialize_unbump_matrices.o \
62 | 	insertion_sort.o \
63 | 	rotate_unbump_bonds.o \
64 | 	intra_bump_check.o \
65 | 	mean_field_minimization.o \
66 | 	number_ligand_atoms.o \
67 | 	print_interaction.o \
68 | 	quicksort.o \
69 | 	read_parameter_file.o \
70 | 	write_target_pdb.o \
71 | 	write_waters_pdb.o \
72 | 	write_log_file.o \
73 | 	write_ligand_mol2.o  \
74 | 	docking_features.o \
75 |     match_triangles.o
76 | 
77 | 
78 | 
79 | $(BINPATH)/$(EXENAME): $(OBJS) main_hbind.o
80 | 	$(CC) $(COPTS) -o $(BINPATH)/$(EXENAME) $(OBJS) main_hbind.o \
81 | 	$(LIBS)
82 | 
83 | .c.o:
84 | 	$(CC) $(CFLAGS) -c $<
85 | 
86 | clean:
87 | 	rm -f *.o *.gcda *.gcno $(BINPATH)/$(EXENAME) $(BINPATH)/$(EXENAME)_hbind
88 | 
89 | touch:
90 | 	touch *.c
91 | 


--------------------------------------------------------------------------------
/src/hbind/analyze_ligand.c:
--------------------------------------------------------------------------------
 1 | #include <string.h>
 2 | #include "analyze_ligand.h"
 3 | #include "adj_list.h"
 4 | #include "find_carbon_ring_centers.h"
 5 | #include "assign_hydrogens.h"
 6 | #include "find_cycles.h"
 7 | #include "find_flexible_bonds.h"
 8 | #include "assign_fragments.h"
 9 | #include "number_ligand_atoms.h"
10 | 
11 | int  analyze_ligand ( global_data_pt  global )
12 | {
13 |   pts_compound_pt compounds;
14 |   molecule_pt     ligand;
15 |   int             *atom_index,
16 |                   *act,
17 |                   *neighbors;
18 |   int             first,
19 |                   real_index;
20 |   int             i, j;
21 | 
22 |   ligand = global->ligand;
23 |   compounds = global->compound_interactions->compounds;
24 |   atom_index = global->compound_interactions->atom_index;
25 |   act = global->compound_interactions->act;
26 |  
27 |   construct_adjacency_list(ligand);
28 |   find_carbon_ring_centers(ligand);
29 |   if(assign_hydrogens(ligand) == FAILURE) return FAILURE;  
30 |   if(find_cycles(ligand) == FAILURE) return FAILURE;
31 |   if(find_flexible_bonds(ligand, global->flex_bond_rules,
32 | 			 global->number_of_flex_bond_rules) == FAILURE) 
33 |     return FAILURE;
34 |   number_ligand_atoms(ligand);
35 |   assign_fragments(ligand);
36 | 
37 |   first = compounds[global->compound_index].first_point;
38 |   for ( i = 0; i < compounds[global->compound_index].number_of_points; i++ ){
39 | 
40 |     if ( act[first+i] == HYDROPHOB ) continue;
41 |       
42 |     real_index = ligand->atom_index[atom_index[first+i]+1];
43 |     ligand->atoms[real_index].act = act[first+i];
44 |     if ( act[first+i] == DONOR || act[first+i] == DONEPTOR ){
45 |       neighbors = ligand->neighbors[real_index];
46 |       for ( j = 0; j < ligand->number_of_neighbors[real_index]; j++ )
47 |         if ( ligand->atoms[neighbors[j]].type == H )
48 | 	  ligand->atoms[neighbors[j]].act = DONOR_HYDROGEN;
49 |     }
50 |   }
51 |   memcpy(ligand->orig_atom_positions, ligand->atom_positions, 
52 |          3*ligand->number_of_atoms * sizeof(*ligand->atom_positions));
53 |   for ( i = 0; i < ligand->number_of_atoms; i++ ) {
54 |     ligand->orig_act[i] = ligand->atoms[i].act;
55 |     ligand->orig_rad[i] = ligand->atoms[i].rad;
56 |   }
57 |   return SUCCESS;
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/docs/readthedocs/css/highlight.css:
--------------------------------------------------------------------------------
  1 | /*
  2 | This is the GitHub theme for highlight.js
  3 | 
  4 | github.com style (c) Vasily Polovnyov <vast@whiteants.net>
  5 | 
  6 | */
  7 | 
  8 | .hljs {
  9 |   display: block;
 10 |   overflow-x: auto;
 11 |   color: #333;
 12 |   -webkit-text-size-adjust: none;
 13 | }
 14 | 
 15 | .hljs-comment,
 16 | .diff .hljs-header,
 17 | .hljs-javadoc {
 18 |   color: #998;
 19 |   font-style: italic;
 20 | }
 21 | 
 22 | .hljs-keyword,
 23 | .css .rule .hljs-keyword,
 24 | .hljs-winutils,
 25 | .nginx .hljs-title,
 26 | .hljs-subst,
 27 | .hljs-request,
 28 | .hljs-status {
 29 |   color: #333;
 30 |   font-weight: bold;
 31 | }
 32 | 
 33 | .hljs-number,
 34 | .hljs-hexcolor,
 35 | .ruby .hljs-constant {
 36 |   color: #008080;
 37 | }
 38 | 
 39 | .hljs-string,
 40 | .hljs-tag .hljs-value,
 41 | .hljs-phpdoc,
 42 | .hljs-dartdoc,
 43 | .tex .hljs-formula {
 44 |   color: #d14;
 45 | }
 46 | 
 47 | .hljs-title,
 48 | .hljs-id,
 49 | .scss .hljs-preprocessor {
 50 |   color: #900;
 51 |   font-weight: bold;
 52 | }
 53 | 
 54 | .hljs-list .hljs-keyword,
 55 | .hljs-subst {
 56 |   font-weight: normal;
 57 | }
 58 | 
 59 | .hljs-class .hljs-title,
 60 | .hljs-type,
 61 | .vhdl .hljs-literal,
 62 | .tex .hljs-command {
 63 |   color: #458;
 64 |   font-weight: bold;
 65 | }
 66 | 
 67 | .hljs-tag,
 68 | .hljs-tag .hljs-title,
 69 | .hljs-rule .hljs-property,
 70 | .django .hljs-tag .hljs-keyword {
 71 |   color: #000080;
 72 |   font-weight: normal;
 73 | }
 74 | 
 75 | .hljs-attribute,
 76 | .hljs-variable,
 77 | .lisp .hljs-body,
 78 | .hljs-name {
 79 |   color: #008080;
 80 | }
 81 | 
 82 | .hljs-regexp {
 83 |   color: #009926;
 84 | }
 85 | 
 86 | .hljs-symbol,
 87 | .ruby .hljs-symbol .hljs-string,
 88 | .lisp .hljs-keyword,
 89 | .clojure .hljs-keyword,
 90 | .scheme .hljs-keyword,
 91 | .tex .hljs-special,
 92 | .hljs-prompt {
 93 |   color: #990073;
 94 | }
 95 | 
 96 | .hljs-built_in {
 97 |   color: #0086b3;
 98 | }
 99 | 
100 | .hljs-preprocessor,
101 | .hljs-pragma,
102 | .hljs-pi,
103 | .hljs-doctype,
104 | .hljs-shebang,
105 | .hljs-cdata {
106 |   color: #999;
107 |   font-weight: bold;
108 | }
109 | 
110 | .hljs-deletion {
111 |   background: #fdd;
112 | }
113 | 
114 | .hljs-addition {
115 |   background: #dfd;
116 | }
117 | 
118 | .diff .hljs-change {
119 |   background: #0086b3;
120 | }
121 | 
122 | .hljs-chunk {
123 |   color: #aaa;
124 | }
125 | 


--------------------------------------------------------------------------------
/src/hbind/read_flex_defn.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include "err_handle.h"
 4 | #include "read_rule.h"
 5 | 
 6 | int  read_flex_defn(char *filename, flex_bond_defn_pt bond_rule)
 7 | {
 8 |   char linebuffer[MAX_MOL2_LINELENGTH];
 9 |   FILE *in;
10 |   int number_of_rules;
11 | 
12 |   in = fopen ( filename, "r" );
13 |   if ( in == NULL ) {
14 |       perror ( "ERROR  " );
15 |       sprintf ( linebuffer, "unable to open file %s", filename );
16 |       err_panic2 ( "read_flex_defn", linebuffer);
17 |   }
18 |   number_of_rules = 0;
19 |   while ( fgets ( linebuffer, sizeof ( linebuffer ), in ) != NULL ){
20 |       /* superscribe `\n` with `\0` */
21 |       linebuffer[strlen(linebuffer)-1] = '\0';
22 |       if ( strncmp ( linebuffer, "name", 4 ) == 0 )
23 | 	sscanf ( linebuffer, "%*s %s", bond_rule[number_of_rules].name );      
24 |       if ( strncmp ( linebuffer, "flexible", 8 ) == 0 )
25 | 	/* this is to identify if the rule defines a flexible or rigid bond */
26 | 	{
27 | 	  sscanf ( linebuffer, "%*s %s", bond_rule[number_of_rules].flex_str );
28 | 	  if (!strcmp (bond_rule[number_of_rules].flex_str, "TRUE") || !strcmp (bond_rule[number_of_rules].flex_str, "YES"))
29 | 	    {
30 | 	      bond_rule[number_of_rules].flex = FLEX;
31 | 	    } 
32 | 	  if (!strcmp (bond_rule[number_of_rules].flex_str, "FALSE") || !strcmp (bond_rule[number_of_rules].flex_str, "NO"))
33 | 	    {
34 | 	      bond_rule[number_of_rules].flex = RIGID;
35 | 	    } 
36 | 	}
37 |       /* this is the first atom to be bonded to this flexible bond */
38 |       if ( strncmp ( linebuffer, "definition", 10 ) == 0 ){
39 | 	if ( number_of_rules >= MAX_NUMBER_OF_FLEX_BOND_RULES )
40 | 	  err_panic2 ( "read_flex_defn", "too many flexible-bond rules");
41 |         parse_definition_line(linebuffer, &bond_rule[number_of_rules].atom[0]);
42 | 	  
43 | 	/* get the definition for the other atom bonded to this bond */
44 | 	fgets ( linebuffer, sizeof ( linebuffer ), in );
45 | 	/* superscribe `\n` with `\0` */
46 | 	linebuffer[strlen(linebuffer)-1] = '\0';
47 |         if ( strncmp ( linebuffer, "definition", 10 ) != 0 )
48 | 	  err_panic2("read_flex_defn", 
49 | 		     "only one atom for flexible-bond rule defined");
50 | 	parse_definition_line(linebuffer, &bond_rule[number_of_rules].atom[1]);
51 | 	number_of_rules++;
52 |       }
53 |     }
54 |   fclose ( in );
55 | 
56 | 
57 |   return number_of_rules;
58 | }
59 | 	  
60 | 


--------------------------------------------------------------------------------
/src/hbind/write_ligand_mol2.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <errno.h>
 4 | #include <string.h>
 5 | #include "docking_features.h"
 6 | #include "err_handle.h"
 7 | #include "calc_score_from_terms.h"
 8 | #include "sf_weights.h"
 9 | 
10 | #define AFFINITY_SCORE 62  
11 | #define ORIENTATION_SCORE 63
12 | 
13 | void write_ligand_mol2(char *filename, float *positions, 
14 |                        dock_feats_pt features, global_data_pt global)
15 | {
16 |   FILE *fp;
17 |   int i;
18 |   char err_msg[2*FILENAME_MAX];
19 |   int errsv;
20 |   float *position;
21 | 
22 |   molecule_pt ligand = global->ligand;
23 |   atom_pt atoms = global->ligand->atoms;
24 |   bond_pt bonds = global->ligand->bonds;
25 |   atom_pt target_atoms = global->target_atoms;
26 | 
27 |   int num_atoms = ligand->number_of_atoms - ligand->number_of_added_hydrogens;
28 | 
29 |   int num_bonds = ligand->number_of_bonds - ligand->number_of_added_hydrogens;
30 | 
31 |   fp = fopen ( filename, "w" );
32 |   if ( fp == NULL ) {
33 |     errsv = errno;
34 |     sprintf(err_msg, "Could not open the file: %s\n\t%s", filename,
35 |             strerror(errsv));
36 |     fprintf(stderr, err_msg);
37 |     err_print(err_msg);
38 |     err_panic2 ( "write_ligand_mol2", "file open failed");
39 |   }
40 |   
41 | 
42 |   features->binding_modes_counter = global->binding_modes_counter;
43 |   
44 |   write_features_header(features, fp, global->ligand_file_name, 
45 |                         global->template_interactions, atoms, target_atoms);
46 |  
47 |   fprintf(fp, "@<TRIPOS>MOLECULE\n" );
48 | 
49 |   fprintf(fp, "%s%s\n", features->ligand_name_noconf, features->ligand_conf );
50 |   fprintf(fp, "%5d %5d %5d     0     0\n", num_atoms, num_bonds,
51 |           ligand->number_of_substructures );
52 |   fprintf ( fp, "SMALL\nUSER_CHARGES\n@<TRIPOS>ATOM\n" );
53 | 
54 |   for(i = 0; i < num_atoms; i++ ){
55 |     if(positions) position = positions + 3*i;
56 |     else position = atoms[i].pos;
57 |     fprintf(fp, "  %5d %-8s %9.4f %9.4f %9.4f %-9s%2d %s       %7.4f \n", 
58 |             atoms[i].atom_number, atoms[i].name, position[0], position[1], 
59 |             position[2], atoms[i].type_str, atoms[i].subst_id,
60 |             atoms[i].subst_name, atoms[i].charge );
61 |   }
62 | 
63 |   fprintf ( fp, "@<TRIPOS>BOND\n" );
64 |   for(i = 0; i < num_bonds; i++)
65 |     fprintf(fp, "%5d %5d %5d %s\n", bonds[i].number, 
66 |             atoms[bonds[i].atom1].atom_number, 
67 |             atoms[bonds[i].atom2].atom_number, bonds[i].type_str);
68 | 
69 |   fprintf ( fp, "@<TRIPOS>SUBSTRUCTURE\n" );
70 |   for(i = 0; i < ligand->number_of_substructures; i++)
71 |     fprintf( fp, "%s", ligand->substructure[i]);
72 |   fclose ( fp );
73 | }
74 | 


--------------------------------------------------------------------------------
/params/flex.defn:
--------------------------------------------------------------------------------
  1 | name		sp3-sp3
  2 | flexible	TRUE
  3 | definition	.3
  4 | definition	.3
  5 | name		sp3-sp2
  6 | flexible	TRUE
  7 | definition	.3
  8 | definition	.2
  9 | name		sp3-aromatic
 10 | flexible	TRUE
 11 | definition	.3
 12 | definition	.ar
 13 | name		sp3-n4
 14 | flexible	TRUE
 15 | definition	.3
 16 | definition	N.4
 17 | name		sp3-npl
 18 | flexible	TRUE
 19 | definition	.3
 20 | definition	N.pl3
 21 | name		sp3-n_amide
 22 | flexible	TRUE
 23 | definition	.3
 24 | definition	N.am
 25 | name		sp3-sp1
 26 | flexible	TRUE
 27 | definition	.3
 28 | definition	.1 ( . )
 29 | name		sp2-n4
 30 | flexible	TRUE
 31 | definition	.2
 32 | definition	N.4
 33 | name		acetyl-sp2
 34 | flexible	TRUE
 35 | definition	C.2 ( O.2 ) ( C.3 )
 36 | definition	.2
 37 | name		carboxyl-sp3
 38 | flexible	TRUE
 39 | definition	C.2 ( 2 O.co2 )
 40 | definition	.3
 41 | name		arom-oxygen
 42 | flexible	TRUE
 43 | definition	O.3
 44 | definition	C.ar
 45 | name		conj-oxygen
 46 | flexible	FALSE
 47 | definition	O.3 [ H ]
 48 | definition	.2 [ 2 H ]
 49 | name		arom-sulfur
 50 | flexible	TRUE
 51 | definition	S.3
 52 | definition	C.ar
 53 | name		conj-sulfur
 54 | flexible	FALSE
 55 | definition	S.3 [ H ]
 56 | definition	.2 [ 2 H ]
 57 | name		ester
 58 | flexible	FALSE
 59 | definition	C.2 ( O.2 )
 60 | definition	O.3 ( . )
 61 | name		sulfyl-ester
 62 | flexible	FALSE
 63 | definition	C.2 ( S.2 )
 64 | definition	S.3 ( . )
 65 | name		conj-hydroxyl
 66 | flexible	TRUE
 67 | definition	O.3 ( H )
 68 | definition	.2
 69 | name		conj-hydrosulfyl
 70 | flexible	TRUE
 71 | definition	S.3 ( H )
 72 | definition	.2 [ 2 H ]
 73 | name		phosph-ester
 74 | flexible	TRUE
 75 | definition	P.3 ( 2 O.co2 )
 76 | definition	O.3
 77 | name		sulfate-ester
 78 | flexible	TRUE
 79 | definition	S ( 4 O )
 80 | definition	O.3
 81 | name		sulfonate-arom
 82 | flexible	TRUE
 83 | definition	S ( 3 O [ * ] )
 84 | definition	C.ar
 85 | name		sulfonate-sp2
 86 | flexible	FALSE
 87 | definition	S ( 3 O [ * ] )
 88 | definition	.2 [ 2 H ]
 89 | name		sulfonamide
 90 | flexible	TRUE
 91 | definition	S ( 2 O [ * ] )
 92 | definition	N
 93 | name		aromatic_sulfonamide
 94 | flexible	TRUE
 95 | definition	S ( 2 O [ * ] ) ( C.ar )
 96 | definition	N [ 2 H ]
 97 | name		sulfone-sp3
 98 | flexible	TRUE
 99 | definition	S ( 2 O [ * ] )
100 | definition	.3
101 | name		sulfone-sp2
102 | flexible	TRUE
103 | definition	S ( 2 O [ * ] )
104 | definition	.2
105 | name		sulfone-aromatic
106 | flexible	TRUE
107 | definition	S ( 2 O [ * ] )
108 | definition	C.ar [ 2 H ]
109 | name		silicon-sp3
110 | flexible	TRUE
111 | definition	Si
112 | definition	.3
113 | name		silicon-oxygen
114 | flexible	TRUE
115 | definition	Si
116 | definition	O.3
117 | name            amide
118 | flexible        FALSE
119 | definition      N.am ( H )
120 | definition      C.2 ( O.2 )
121 | 


--------------------------------------------------------------------------------
/src/hbind/unbump_translate.c:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include "types.h"
 4 | #include "defs.h"
 5 | 
 6 | /*
 7 |  *  This function computes a global transformation vector that is 
 8 |  *  simply the sum of the different translation vectors needed to get
 9 |  *  rid of the single bumps. By taking the sum of the vectors, some kind
10 |  *  of a weighted global vector is computed, since the influence of
11 |  *  more intense bumps is larger than that of small bumps.
12 |  */
13 | void  compute_global_vector ( vector_pt vectors,
14 | 			      int       number_of_points,
15 | 			      vector_t  sum_vector )
16 | {
17 |   int       i, j;
18 |   
19 |   for ( i = 0; i < 3; i++ )
20 |     sum_vector[i] = 0;
21 |   for ( i = 0; i < number_of_points; i++ )
22 |     for ( j = 0; j < 3; j++ )
23 |       sum_vector[j] += vectors[i][j];
24 | }
25 | 
26 | /*
27 |  *  Simple function that returns the positive solution of the
28 |  *  quadratic formula  a * x^2 + b * x + c = 0
29 |  */ 
30 | int  quadratic_formula ( double  a, 
31 | 			 double  b, 
32 | 			 double  c,
33 | 			 double  *sol )
34 | {
35 |   double  discr;
36 |   double  sol1, sol2;
37 | 
38 |   discr = b * b - 4.0 * a * c;
39 |   if ( discr < 0 )
40 |     return FAILURE;
41 |   sol1 = ( (-1.0) * b - sqrt ( discr ) ) / ( 2.0 * a );
42 |   sol2 = ( (-1.0) * b + sqrt ( discr ) ) / ( 2.0 * a );
43 |   if ( sol1 >= 0 )
44 |     *sol = sol1;
45 |   else 
46 |     *sol = sol2;
47 |   return SUCCESS;
48 | }
49 | 
50 | /*
51 |  *  This function computes the coefficient `alpha' for the
52 |  *  translation vector w to move an atom out of the
53 |  *  bumping zone of another atom. Tails of vectors v and
54 |  *  u are at center of the fixed atom, head of v and tail of
55 |  *  w are at the center of the moving atom, and heads of vectors
56 |  *  w and u are at the target position for the moving atom
57 |  *  at the nearest bump-free point when translating it
58 |  *  along vector w. Length of vector u is r, which is the 
59 |  *  sum of the van der Waals radii of both atoms minus the allowed 
60 |  *  overlap. This function solves the following set of four equations
61 |  *  by the use of the quadratic formula:
62 |  *  (I)-(III)  (v) + alpha * (w) = (u)
63 |  *  (IV)       r = sqrt ( u_x * u_x + u_y * u_y + u_z * u_z )
64 |  *  if there is no solution to the quadratic formula, FAILURE is returned
65 |  */
66 | int  compute_translation_coefficient ( vector_t v,
67 | 				       vector_t w,
68 | 				       double   r,
69 | 				       double   *factor )
70 | {
71 |   double  a, b, c;
72 |   int     result;
73 |   
74 |   a = w[X] * w[X] + w[Y] * w[Y] + w[Z] * w[Z];
75 |   b = 2 * w[X] * v[X] + 2 * w[Y] * v[Y] + 2 * w[Z] * v[Z];
76 |   c = v[X] * v[X] + v[Y] * v[Y] + v[Z] * v[Z] - r * r;
77 | 
78 |   result = quadratic_formula ( a, b, c, factor );
79 |   return result;
80 | }
81 | 


--------------------------------------------------------------------------------
/src/hbind/find_cycles.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include "types.h"
 4 | #include "err_handle.h"
 5 | 
 6 | int  check_atoms ( molecule_pt  molecule,
 7 | 		   int          *label,
 8 | 		   int          *start_counter,
 9 | 		   int          bond,
10 | 		   int          atom,
11 | 		   int          back)
12 | {
13 |   int  *neighbors;
14 |   int  result,
15 |        cycles;
16 |   int  i;
17 |   char err_msg[FILENAME_MAX];
18 | 
19 |   result = 0;
20 |   neighbors = molecule->neighbors[atom];
21 |   if ( label[atom] == UNVISITED )
22 |     {
23 |       /* this is the first time we visit this node */
24 |       label[atom] = VISITED;
25 |       for ( i = 0; i < molecule->number_of_neighbors[atom]; i++ )
26 | 	/* visit all neighbors, but don't take direct way back */
27 | 	if ( neighbors[i] != back )
28 | 	  {
29 | 	    bond = molecule->bond_to_neighbor[atom][i];
30 | 	    cycles = check_atoms ( molecule,
31 | 				   label,
32 | 				   start_counter,
33 | 				   molecule->bond_to_neighbor[atom][i],
34 | 				   neighbors[i],
35 | 				   atom);
36 | 	    if ( cycles < 0 )
37 | 	      /* FATAL_FAILURE is -1 */
38 | 	      return FATAL_FAILURE;
39 | 	    if ( cycles > 0 )
40 | 	      /* the bond to this neighbor is in a cycle */
41 | 	      if ( molecule->bonds[bond].type < CYCLE_BOND )
42 | 		molecule->bonds[bond].type += CYCLE_BOND;
43 | 	    /* add the number of cycles this atom is in due to the 
44 | 	       the currten neighbor atom to the overall number of
45 | 	       cycles for the current atom */
46 | 	    result += cycles;
47 | 	  }
48 |       if ( result > 0 )
49 | 	{
50 | 	  /* this atom is in a cycle */
51 | 	  if ( start_counter[atom] > 0 )
52 | 	    /* if the cycle has started at this atom, then don't return
53 | 	       CYCLE any longer */
54 | 	    {
55 | 	      result--;
56 | 	      start_counter[atom]--;
57 | 	    }
58 | 	  else
59 | 	    label[atom] = CYCLE;
60 | 	}
61 |     }
62 |   /* we have been here before, so this is the first atom in the cycle */
63 |   else if ( label[atom] == VISITED ){
64 |     start_counter[atom]++;
65 |     result++;
66 |   }else if ( label[atom] != CYCLE ){
67 |     sprintf ( err_msg, "atom label: %d\n", label[atom] );
68 |     fprintf ( stderr, err_msg);
69 |     fprintf ( stdout, err_msg);
70 |     err_print (err_msg);
71 |     err_warning2 ( "check_atoms", "unknown label");
72 |     return FATAL_FAILURE;
73 |   }
74 |   return result;
75 | }
76 | 
77 | int  find_cycles ( molecule_pt  molecule)
78 | {
79 |   int     labels[MAX_NUMBER_OF_MOL2_ATOMS],
80 |           start[MAX_NUMBER_OF_MOL2_ATOMS];
81 |   int     i;
82 | 
83 |   memset(start, 0, molecule->number_of_atoms * sizeof(*start));
84 |   for ( i = 0; i < molecule->number_of_atoms; i++ ) labels[i] = UNVISITED;
85 |   if(check_atoms(molecule, labels, start, -1, 0, -1) == FATAL_FAILURE)
86 |     return FAILURE;
87 |   return SUCCESS;
88 | }
89 | 


--------------------------------------------------------------------------------
/src/hbind/rotate.c:
--------------------------------------------------------------------------------
  1 | #include <math.h>
  2 | #include "defs.h"
  3 | #include "eigen.h"
  4 | 
  5 | int  rotate ( double  a[3][3],  
  6 | 	      double  b[3][3],  
  7 | 	      double  weights[3],
  8 | 	      double  r[3][3] ) 
  9 | {
 10 |   double u[3][3],
 11 |          eigenvector[6][6],
 12 |          omega[6][6],	
 13 |          h[6][3],
 14 |          k[6][3];
 15 |   double eigenvalue[6],	
 16 |          d[6],
 17 |          x[3];
 18 |   double sum, 
 19 |          det,
 20 |          sqrt2;
 21 |   int    rank;
 22 |   int    i, j, l;
 23 |   
 24 |   for ( i = 0; i < 3; i++ )
 25 |     for ( j = 0; j < 3; j++ ) 
 26 |       {
 27 | 	u[i][j] = 0.0;
 28 | 	for ( l = 0; l < 3; l++ )
 29 | 	  u[i][j] += weights[l] * a[l][i] * b[l][j];
 30 |       }
 31 |   for ( i = 0; i < 3; i++ )
 32 |     for ( j = 0; j < 3; j++ )
 33 |       {
 34 | 	omega[i][j] = 0.0;
 35 | 	omega[i][j+3] = u[i][j];
 36 | 	omega[i+3][j] = u[j][i];
 37 |       }
 38 |   for ( i = 3; i < 6; i++ )
 39 |     for ( j = 3; j < 6; j++ )
 40 |       omega[i][j] = 0.0;
 41 |   if ( eigen ( omega, eigenvector, eigenvalue ) == FAILURE )
 42 |     return FAILURE;
 43 |   sqrt2 = sqrt ( 2.0 );
 44 |   for ( i = 0; i < 6; i++ )
 45 |     for ( j = 0; j < 3; j++ )
 46 |       {
 47 | 	h[i][j] = eigenvector[j][5-i] * sqrt2;
 48 | 	k[i][j] = eigenvector[j+3][5-i] * sqrt2;
 49 |       }
 50 |   for ( i = 0; i < 6; i++ )
 51 |     d[i] = eigenvalue[5-i];
 52 |   x[0] = h[0][1] * h[1][2] - h[0][2] * h[1][1];
 53 |   x[1] = h[0][2] * h[1][0] - h[0][0] * h[1][2];
 54 |   x[2] = h[0][0] * h[1][1] - h[0][1] * h[1][0];
 55 |   sum = 0.0;
 56 |   for ( i = 0; i < 3; i++ ) 
 57 |     sum += ( x[i] - h[2][i] ) * ( x[i] - h[2][i] );
 58 |   if ( sum > 1.0E-16 ) 
 59 |     for ( i = 0; i < 3; i++ ) 
 60 |       {
 61 | 	h[2][i] = - h[2][i];
 62 | 	k[2][i] = - k[2][i];
 63 |       }
 64 |   det = u[0][0] * ( u[1][1] * u[2][2] - u[1][2] * u[2][1] )
 65 |     + u[0][1] * ( u[2][0] * u[1][2] - u[1][0] * u[2][2] )
 66 |     + u[0][2] * ( u[1][0] * u[2][1] - u[2][0] * u[1][1] );
 67 |   if ( fabs ( det ) < 1.0E-8 )
 68 |     det = 0.0;
 69 |   rank = 0;
 70 |   for ( i = 0; i < 3; i++ )
 71 |     if ( fabs ( d[i] ) > 1.0E-8 ) 
 72 |       rank++;
 73 |   if ( det < -1.0E-8 ) 
 74 |     {
 75 |       if ( d[1] != d[2] ) 
 76 | 	for ( i = 0; i < 3; i++ )
 77 | 	  k[2][i] = - k[2][i];
 78 |       else
 79 | 	return FAILURE;
 80 |     }
 81 |   else 
 82 |     if ( rank == 2 ) 
 83 |       {
 84 | 	for ( i = 0; i < 3; i++ )
 85 | 	  h[2][i] = x[i];
 86 | 	k[2][0] = k[0][1] * k[1][2] - k[0][2] * k[1][1];
 87 | 	k[2][1] = k[0][2] * k[1][0] - k[0][0] * k[1][2];
 88 | 	k[2][2] = k[0][0] * k[1][1] - k[0][1] * k[1][0];
 89 |       }
 90 |     else 
 91 |       if ( rank < 2 ) 
 92 | 	return FAILURE; 
 93 |   for ( i = 0; i < 3; i++ )
 94 |     for ( j = 0; j < 3; j++ ) 
 95 |       {
 96 | 	r[i][j] = 0.0;
 97 | 	for ( l = 0; l < 3; l++ )
 98 | 	  r[i][j] += k[l][i] * h[l][j];
 99 | 	if ( fabs ( r[i][j] ) < 1.0E-8 ) 
100 | 	  r[i][j] = 0.0;
101 |       }
102 |   return SUCCESS;
103 | }
104 | 
105 | 


--------------------------------------------------------------------------------
/src/hbind/read_waters.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | #include <errno.h>
 5 | #include "read_waters.h" 
 6 | #include "err_handle.h"
 7 | #include "dist_fun.h" 
 8 | 
 9 | int find_hbond_partner(atom_pt target, int num_target_atoms, atom_pt water)
10 | {
11 |   float    min_dist,
12 |            distance;
13 |   int      partner;
14 |   int      i;
15 | 
16 |   partner = UNKNOWN;
17 |   
18 |   min_dist = 99.9;
19 |   for ( i = 0; i < num_target_atoms; i++ ){
20 |     if( target[i].act == NOTHING ) continue;
21 | 
22 |     distance = dist_fun ( target[i].pos, water->pos );
23 |     if ( distance < min_dist ){
24 |       partner = i;
25 |       min_dist = distance;
26 |     }
27 |   }
28 | 
29 |   if (partner == UNKNOWN){
30 |     err_warning2 ( "find_hbond_partner", "unable to find hbond partner");
31 |     return FAILURE;
32 |   }
33 |   else return partner;
34 | }
35 | 
36 | 
37 | int read_waters(atom_pt waters, int *num_waters, char *filename, atom_pt target,
38 |                 int num_target_atoms)
39 | {
40 |   FILE           *in;
41 |   char           line[MAX_TEMPLATE_LINELENGTH];
42 |   int            i;
43 |   int errsv;
44 |   atom_pt water = waters;
45 |   
46 |   *num_waters = 0;
47 |   in = fopen ( filename, "r" );
48 |   if ( in == NULL ) {
49 |     errsv = errno;
50 |     sprintf(line, "Unable to open the waters file: %s", strerror(errsv));
51 |     err_warning2("read_waters", line);
52 |     return FAILURE;
53 |   }
54 | 
55 |   while ( fgets ( line, MAX_TEMPLATE_LINELENGTH, in ) != NULL ){ 
56 |     /* comment line, empty line, regular ATOM entry or no water, skip */
57 |     if ( line[0] != 'H' || (strncmp ( line + 17, "HOH", 3 ) != 0 && 
58 |                             strncmp ( line + 17, "WAT", 3 ) != 0 && 
59 |                             strncmp ( line + 17, "H2O", 3 ) != 0 ) ) continue;
60 | 
61 |     water->number = atoi ( line + 22 );
62 |     water->pos[X] = (float) atof ( line + 30 );
63 |     water->pos[Y] = (float) atof ( line + 38 );
64 |     water->pos[Z] = (float) atof ( line + 46 );
65 |     water->prediction = (float) atof ( line + 54 );
66 |       
67 |     water->type = WATER;
68 |     water->orbit = UNKNOWN;
69 |     water->rad = WATER_RAD;
70 |     water->state = CONSERVED;
71 | 
72 |     /* find for the closest polar target atom, the water is considered
73 |      * to be connected to this atom, i.e., it will be displaced when
74 |      * this atom moves */
75 |     water->target_atom_index =  
76 |       find_hbond_partner(target, num_target_atoms, water);
77 |     (*num_waters)++;
78 |     water++;
79 |     if(*num_waters >= MAX_BINDING_SITE_WATERS )
80 |       err_panic2("read_waters", "more than MAX_BIDING_SITE_WATERS waters");
81 |   }
82 |   fclose ( in );
83 | 
84 |   water = waters;
85 |   printf ( "CHECK: water file read\n" );
86 |   for (i = 0; i < 3; i++)
87 |     printf("   Wat %d: %8.3f %8.3f %8.3f %4.2f\n", i, water[i].pos[X],
88 | 	   water[i].pos[Y], water[i].pos[Z], water[i].prediction);
89 | 
90 |   return SUCCESS;
91 | }
92 |        
93 | 


--------------------------------------------------------------------------------
/src/hbind/inc/atom.h:
--------------------------------------------------------------------------------
 1 | #ifndef ATOM_HEADER_FILE_INCLUDED
 2 | #define ATOM_HEADER_FILE_INCLUDED
 3 | 
 4 | #include <defs.h>
 5 | 
 6 | /*! data structure describing a bit string */
 7 | typedef struct {
 8 |   unsigned char *bits;            /*!< bits, stored in a byte vector */
 9 |   unsigned int len;               /*!< number of bits in this bit string */
10 | }*bitstring_pt, bitstring_t;
11 | 
12 | /*! atom entry in mol2 or pdb file */
13 | typedef struct atom_struct{
14 |   /* components for all atom types */
15 |   char          name[5];                            /* atom name in the file */
16 |   float *pos;
17 |   float         rad;                                 /* van der Waals radius */
18 |   float         charge;                      /* partial charge for this atom */
19 |   float         charge_sum;
20 |   int           atom_number; /* the number assigned to this atom in the file */
21 |   int           type;                                    /* type of the atom */
22 |   int           act;                   /* DONOR, ACCEPTOR, DONEPTOR, NOTHING */
23 | #if 0
24 |   int           *neighbors;  /* indices of neighbors for intramolecular bump */
25 | #endif
26 |   struct atom_struct **neighbors;
27 |   float         *neighbor_dist;
28 |   size_t        num_nbrs;
29 |   size_t        num_added_nbrs;
30 |   int           hydro;                               /* hydrophilicity value */
31 | 
32 |   /* components only relevant for mol2 atoms */
33 |   char          type_str[7];                /* string defining the atom type */
34 |   int           orbit;            /* orbit or whatever follows the . in type */
35 |   int           number;         /*!< ligand ==> # assigned for fragmentation */
36 |   bitstring_pt  fragments;                  /* fragments the atom is part of */
37 |   int           fragment;  /* number of the fragment this atom is located in */
38 |   int           subst_id;                                 /* substructure id */
39 |   char          subst_name[MAX_SUBST_NAME_LENGTH];      /* substructure name */
40 | 
41 |   /* components only relevant for PDB atoms */
42 |   int           level;                        /* level of atom in side-chain */
43 |   int           residue_index; /* index of the residue in the residue vector */
44 |   int           res;                          /* the residue type identifier */
45 |   char          residue[4];                                  /* residue type */
46 |   char          alt_location;               /* alternate location identifier */
47 |   char          chain_id;                                /* chain identifier */
48 |   char          insertion_code;                            /* insertion code */
49 |   char          residue_num[6];                            /* residue number */
50 | 
51 |   /* components only relevant for waters */
52 |   int                target_atom_index;  /* atom it is connected to (H-bond) */
53 |   int                state;                        /* CONSERVED or DISPLACED */
54 |   float              prediction;           /* the likelyhood of conservation */
55 | }*atom_pt, atom_t;
56 | 
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/src/hbind/distance_matrices.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <float.h>
 3 | #include <math.h>
 4 | #include <mymalloc.h>
 5 | #include <err_handle.h>
 6 | #include <dist_fun.h>
 7 | #include <distance_matrices.h>
 8 | 
 9 | static const float MAX_DIST = 8.0;
10 | static const float MAX_SQRD_DIST = 64.0;
11 | static const float SQRD_NBR_DIST = 64.0;
12 | 
13 | 
14 | int non_covalently_bound2(atom_pt atom1, atom_pt atom2);
15 | 
16 | void
17 | init_target_nbr_arrays(atom_pt target_atoms, const int num_atoms)
18 | {
19 |   int i, j; 
20 |   float sq_dist;
21 | 
22 |   for(i = 0; i < num_atoms; ++i){
23 |     for(j = 0; j < i; ++j){
24 |       sq_dist = squared_dist(target_atoms[i].pos, target_atoms[j].pos);
25 |       if(sq_dist <= SQRD_NBR_DIST && 
26 |          non_covalently_bound2(&target_atoms[i], &target_atoms[j])){
27 |         target_atoms[i].neighbors[target_atoms[i].num_nbrs] = &target_atoms[j];
28 |         target_atoms[j].neighbors[target_atoms[j].num_nbrs] = &target_atoms[i];
29 |         target_atoms[i].neighbor_dist[target_atoms[i].num_nbrs] = 
30 |           target_atoms[j].neighbor_dist[target_atoms[j].num_nbrs] = 
31 |           sqrt(sq_dist);
32 |         ++(target_atoms[i].num_nbrs);
33 |         ++(target_atoms[j].num_nbrs);
34 |       }
35 |     }
36 |   }
37 | }
38 | 
39 | int non_covalently_bound2(atom_pt atom1, atom_pt atom2)
40 | {
41 |   /* both atoms in the same residue, if level difference is 0, 1, 2 or 3
42 |    * then they are covalently bound */
43 |   if(atom1->residue_index == atom2->residue_index){
44 |     if(diff_int(atom1->level, atom2->level) > 3 && atom1->res != HIS &&
45 |        atom1->res != PRO && atom1->res != TYR && atom1->res != PHE &&
46 |        atom1->res != TRP) return TRUE;
47 |     else return FALSE;
48 |   }
49 |   /* atoms are main-chain atoms of neighbored residues, if they are both main 
50 |    * chain atoms, it is assumed that they are covalently bound. this is ok 
51 |    * since we do not change the main-chain conformation, thus there is no need 
52 |    * to check for a bump here */
53 |   if(diff_int ( atom1->residue_index, atom2->residue_index) == 1 &&
54 |      atom1->level == ALPHA && atom2->level == ALPHA) return FALSE;
55 |   /* disulfide bond */
56 |   if(atom1->res == CYS && atom1->type == SG &&
57 |      atom2->res == CYS && atom2->type == SG )return FALSE;
58 |   return TRUE;
59 | }
60 | 
61 | void
62 | initialize_inter_dist_matrix(const float* targ_positions, 
63 |                              const size_t num_targ_atoms,
64 |                              const float* lig_positions, 
65 |                              const size_t num_lig_atoms,
66 |                              float *M, const float max_dist)
67 | {
68 |   size_t i, j;
69 |   float *m = M;
70 |   float sq_dist;
71 |   const float* l_pos;
72 |   const float* t_pos;
73 |   const float max_sqrd_dist = max_dist * max_dist;
74 |   const float* targ_pos_end = targ_positions + 3*num_targ_atoms;
75 |   const float* lig_pos_end = lig_positions + 3*num_lig_atoms;
76 | 
77 |   for(l_pos = lig_positions; l_pos < lig_pos_end; l_pos += 3)
78 |     for(t_pos = targ_positions; t_pos < targ_pos_end; t_pos += 3, ++m){
79 |       sq_dist = squared_dist(l_pos, t_pos);
80 |       *m = (sq_dist <= max_sqrd_dist ? sq_dist : FLT_MAX);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/hbind/intra_hbonds.c:
--------------------------------------------------------------------------------
  1 | #include "defs.h"
  2 | #include "types.h"
  3 | #include "dist_fun.h"
  4 | #include "hbond_check.h"
  5 | 
  6 | int  intra_target_hbonds ( global_data_pt  global )
  7 | {
  8 |   atom_pt target;
  9 |   float   angle;
 10 |   int     donor,
 11 |           acceptor,
 12 |           sum,
 13 |           number_of_hbonds;
 14 |   int     i, j;
 15 |   float   hydrogen_position[3];
 16 | 
 17 |   target = global->target_atoms;
 18 |   number_of_hbonds = 0;
 19 |   for ( i = 0; i < global->number_of_target_atoms; i++ )
 20 |     for ( j = i + 1; j < global->number_of_target_atoms; j++ )
 21 |       if ( target[i].act != NOTHING 
 22 | 	   && target[j].act != NOTHING
 23 | 	   && dist_fun ( target[i].pos, target[j].pos ) <= MAX_HBOND_LENGTH )
 24 | 
 25 | 	{
 26 | 	  sum = target[i].act + target[j].act;
 27 | 	  if ( sum == ACCEPTOR_DONOR
 28 | 	       || sum == DONOR_DONEPTOR
 29 | 	       || sum == ACCEPTOR_DONEPTOR
 30 | 	       || sum == DONEPTOR_DONEPTOR ) 
 31 | 	    /* this is an intramolecular hydrogen bond in the target protein */
 32 | 	    {
 33 | 	      if ( target[i].act == DONOR 
 34 | 		   || ( target[i].act == DONEPTOR
 35 | 			&& target[j].act != DONOR ) )
 36 | 		{
 37 | 		  donor = i;
 38 | 		  acceptor = j;
 39 | 		}
 40 | 	      else
 41 | 		{
 42 | 		  donor = j;
 43 | 		  acceptor = i;
 44 | 		}		 
 45 | 	      /* now compute the donor-H-acceptor angle */
 46 | 	      angle = 
 47 | 		compute_target_hydrogen_angle ( target,
 48 | 						global->target_residues,
 49 | 						donor,
 50 | 						target[acceptor].pos,
 51 | 						hydrogen_position,
 52 | 						global);
 53 | 	      if ( angle >= MIN_HYDROGEN_ANGLE
 54 | 		   && angle <= MAX_HYDROGEN_ANGLE )
 55 | 		number_of_hbonds++;
 56 | 	    }
 57 | 	}
 58 |   return number_of_hbonds;
 59 | }
 60 |       
 61 | int  target_to_water_hbonds ( global_data_pt  global )
 62 | { 
 63 |   atom_pt target,
 64 |           waters;
 65 |   float   angle;
 66 |   float   number_of_hbonds;
 67 |   int     i, j;
 68 |   float   hydrogen_position[3];
 69 | 
 70 |   if ( global->number_of_waters == 0 )
 71 |     /* no binding-site waters */
 72 |     return 0;
 73 |   target = global->target_atoms;
 74 |   waters = global->waters;
 75 |   number_of_hbonds = 0.0;
 76 |   for ( i = 0; i < global->number_of_target_atoms; i++ )
 77 |     if ( target[i].act != NOTHING )
 78 |       for ( j = 0; j < global->number_of_waters; j++ )
 79 | 	if ( waters[j].state == CONSERVED
 80 | 	     && dist_fun ( target[i].pos, waters[j].pos ) < MAX_HBOND_LENGTH )
 81 | 	  {
 82 | 	    if ( target[i].act == DONOR )
 83 | 	      /* compute the donor-H-acceptor angle */
 84 | 	      {
 85 | 		angle = 
 86 | 		  compute_target_hydrogen_angle ( target,
 87 | 						  global->target_residues,
 88 | 						  i,
 89 | 						  waters[j].pos,
 90 | 						  hydrogen_position,
 91 | 						  global);
 92 | 		if ( angle >= MIN_HYDROGEN_ANGLE
 93 | 		     && angle <= MAX_HYDROGEN_ANGLE )
 94 | 		  number_of_hbonds += waters[j].prediction;
 95 | 	      }
 96 | 	    else
 97 | 	      /* target is either DONEPTOR or ACCEPTOR, in both cases
 98 | 		 we already have a hydrogen bond, since we only consider
 99 | 		 the distance between this atom and the water */
100 | 	      number_of_hbonds += waters[j].prediction;
101 | 	  }
102 |   return (int) number_of_hbonds;
103 | }
104 |  
105 | 


--------------------------------------------------------------------------------
/src/hbind/inc/hydro.h:
--------------------------------------------------------------------------------
 1 | static float hydro[20][37+1] = {
 2 | /* ALA : CA CB C O N */
 3 | { 0, 72, 232, 7, 584, 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 4 | /* ARG : CA CB C O N CD CG CZ NE NH1 NH2 */
 5 | { 0, 39, 33, 12, 606, 470, 172, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 26, 0, 0, 0, 0, 237, 0, 0, 440, 445, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 6 | /* ASN : CA CB C O N CG ND2 OD1 */
 7 | { 0, 21, 88, 17, 448, 367, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 464, 0, 0, 0, 0, 0, 0, 459, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 8 | /* ASP : CA CB C O N CG OD1 OD2 */
 9 | { 0, 11, 82, 6, 503, 301, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 546, 546, 0, 0, 0, 0, 0, 0, 0, 0 },
10 | /* CYS : CA CB C O N SG */
11 | { 0, 36, 100, 14, 583, 400, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 139 },
12 | /* GLN : CA CB C O N CD CG NE2 OE1 */
13 | { 0, 40, 64, 9, 502, 415, 20, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, 0, 0, 453, 0, 0, 0, 0, 0, 0, 0 },
14 | /* GLU : CA CB C O N CD CG OE1 OE2 */
15 | { 0, 40, 70, 6, 513, 343, 14, 0, 0, 0, 0, 0, 0, 109, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 481, 469, 0, 0, 0, 0, 0, 0 },
16 | /* GLY : CA C O N */
17 | { 0, 139, 0, 28, 521, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
18 | /* HIS : CA CB C O N CD2 CE1 CG ND1 NE2 */
19 | { 0, 23, 99, 22, 442, 359, 0, 0, 140, 0, 165, 0, 0, 60, 0, 0, 0, 0, 0, 0, 441, 0, 0, 0, 353, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
20 | /* ILE : CA CB C O N CD1 CG1 CG2 */
21 | { 0, 24, 18, 0, 545, 380, 0, 87, 0, 0, 0, 0, 0, 0, 31, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
22 | /* LEU : CA CB C O N CD1 CD2 CG */
23 | { 0, 10, 35, 0, 548, 384, 0, 125, 117, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
24 | /* LYS : CA CB C O N CD CE CG NZ */
25 | { 0, 12, 60, 9, 474, 271, 81, 0, 0, 129, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 476, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
26 | /* MET : CA CB C O N CE CG SD */
27 | { 0, 30, 132, 30, 591, 486, 0, 0, 0, 208, 0, 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0 },
28 | /* PHE : CA CB C O N CD1 CD2 CE1 CE2 CG CZ */
29 | { 0, 14, 29, 0, 503, 406, 0, 67, 76, 0, 99, 48, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
30 | /* PRO : CA CB C O N CD CG */
31 | { 0, 49, 132, 35, 488, 16, 146, 0, 0, 0, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
32 | /* SER : CA CB C O N OG */
33 | { 0, 22, 150, 0, 491, 245, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 568, 0, 0, 0, 0, 0 },
34 | /* THR : CA CB C O N CG2 OG1 */
35 | { 0, 21, 54, 0, 601, 292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 193, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 536, 0, 0, 0, 0 },
36 | /* TRP : CA CB C O N CD1 CD2 CE2 CE3 CG CH2 CZ2 CZ3 NE1 */
37 | { 0, 46, 49, 31, 569, 429, 0, 149, 67, 0, 0, 100, 27, 0, 0, 0, 115, 0, 72, 71, 0, 0, 0, 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
38 | /* TYR : CA CB C O N CD1 CD2 CE1 CE2 CG CZ OH */
39 | { 0, 6, 69, 74, 551, 374, 0, 83, 51, 0, 68, 50, 0, 22, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 635, 0, 0, 0 },
40 | /* VAL : CA CB C O N CG1 CG2 */
41 | { 0, 13, 0, 0, 534, 482, 0, 0, 0, 0, 0, 0, 0, 0, 85, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
42 | 


--------------------------------------------------------------------------------
/src/hbind/inc/calc_score_from_terms.h:
--------------------------------------------------------------------------------
 1 | #ifndef _CALC_SCORE_FROM_TERMS_
 2 | #define _CALC_SCORE_FROM_TERMS_
 3 | 
 4 | void score_from_terms (float raw_term_counts[], float affinity_scores[], int max_num_of_score_functions );
 5 | 
 6 | enum raw_term_indices								    /* alphabetic symbol*/
 7 |   { 	NUMBER_OF_LIGAND_NONH_ATOMS = 0,					/* A*/
 8 | 	TOTAL_SUM_HPHOB_HPHOB,								/* B*/
 9 | 	TOTAL_DIFF_HPHOB_HPHOB,								/* C*/
10 | 	TOTAL_DIFF_HPHOB_HPHIL,								/* D*/
11 | 	TOTAL_SUM_HPHIL_HPHIL,								/* E*/
12 | 	TOTAL_DIFF_HPHIL_HPHIL,								/* F*/
13 | 	NUMBER_OF_METAL_HBONDS,								/* G*/
14 | 	NUMBER_OF_SALT_BRIDGES,								/* H*/
15 | 	NUMBER_OF_HBONDS,									/* I*/
16 | 	NUMBER_OF_UNSAT_POLAR,								/* J*/
17 | 	NUMBER_OF_UNSAT_CHARGE,								/* K*/
18 | 	NUMBER_OF_REPULSIVE_POLAR,							/* L*/
19 | 	NUMBER_OF_REPULSIVE_CHARGE,							/* M*/
20 | 	RATIO_OF_INTERFACIAL_LIGAND_HEAVY_ATOMS,			/* N*/
21 | 	NUMBER_OF_INTERFACIAL_LIGAND_ATOMS,					/* O*/
22 | 	NUMBER_OF_EXPOSED_HYDRO_LIGAND_ATOMS,				/* P*/
23 | 	NUMBER_OF_LIGAND_FLEXIBLE_BONDS,					/* Q*/
24 | 	NUMBER_OF_ALL_INTERFACIAL_FLEXIBLE_BONDS,			/* R*/
25 | 	NUMBER_OF_HPHOB_HPHOB_CONTACT,						/* S*/
26 | 	TOTAL_AVG_HPHOB_HPHOB,								/* T*/
27 | 	OLD_HBIND_TOTAL_SUM_HPHOB_HPHOB,					/* U*/
28 | 	NUMBER_OF_FLEXIBLE_INTERFACIAL_LIGAND_BONDS,		/* V*/
29 | 	NUMBER_OF_HPHOB_HPHIL_CONTACT,						/* W*/
30 | 	TOTAL_HPHOB_COMP,                                                      /*X*/
31 | 	TOTAL_HPHOB_HPHOB_COMP,                                                      /*Y*/
32 | 	CONTACT_HPHOB_HPHOB,                                                      /*Z*/
33 | 	CONTACT_HPHIL_HPHIL,                                                      /*AA*/
34 | 	CONTACT_HPHOB_HPHIL,                                                      /*AB*/
35 | 	TOTAL_TARGET_HPHOB_HPHOB,                                                      /*AC*/
36 | 	INCREASE_HPHOB_ENVIRON,                                                      /*AD*/
37 | 	TOTAL_TARGET_HYDRO,                                                      /*AE*/
38 | 	NORM_TARGET_HPHOB_HPHOB,                                                      /*AF*/
39 | 	TOTAL_TARGET_HPHOB_CONTACT,                                                      /*AG*/
40 | 	NORM_TARGET_HPHOB_CONTACT,                                                      /*AH*/
41 | 	TOTAL_LIGAND_HYDRO,                                                      /*AI*/
42 | 	HBOND_RATIO,
43 | 	NORM_POLAR,
44 | 	NORM_UNSAT,
45 | 	NORM_HPHOB_COMP,						/* N_HPHOB_COMP*/
46 | 	NUMBER_OF_INTRA_TARGET_HBONDS,						/* X*/
47 | 	NUMBER_OF_INTRA_TARGET_SALT_BRIDGES,				/* Y*/
48 | 	INTERMEDIATE_OVERLAP,								/* Z*/
49 | 	TOTAL_OVERLAP,										/* [*/
50 | 	NUMBER_OF_UNSAT_LIGAND_POLAR,						/* \ */
51 | 	NUMBER_OF_UNSAT_TARGET_POLAR,						/* ]*/
52 | 	NUMBER_OF_UNSAT_LIGAND_CHARGE,						/* ^*/
53 | 	NUMBER_OF_UNSAT_TARGET_CHARGE,						/* _*/
54 | 	NORM_HPHOB_COMP_2,						/* ELECTRO_ENVIRON*/
55 | 	TOTAL_AVG_HPHOB_HPHOB_NEW,								/* T_NEW*/
56 | 	TOTAL_BURIED_HPHOB,								/* B_HYDRO	*/
57 | 	TOTAL_EXPOSED_HPHOB,								/* E_HYDRO	*/
58 | 	NORM_HPHOB_COMP_3,								/* TE_HYDRO	*/
59 | 
60 |   /* Repulsive interaction is an atom pair of P-L. 
61 |    * So following numbers are halves of NUMBER_OF_REPULSIVE_POLAR,
62 | 	NUMBER_OF_REPULSIVE_CHARGE resp.
63 | 	NUMBER_OF_REPULSIVE_LIGAND_POLAR,					 LL
64 | 	NUMBER_OF_REPULSIVE_TARGET_POLAR,					 LT
65 | 	NUMBER_OF_REPULSIVE_LIGAND_CHARGE,					 ML
66 | 	NUMBER_OF_REPULSIVE_TARGET_CHARGE					 MT
67 | 	*/
68 | 		
69 | };
70 | 
71 | #endif
72 | 


--------------------------------------------------------------------------------
/src/hbind/check_rule.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "types.h"
  3 | #include "defs.h"
  4 | #include "check_rule.h"
  5 | 
  6 | int  check_prohibited_rule ( molecule_pt  molecule,
  7 | 			     int          base_atom,
  8 | 			     int          bond_atom,
  9 | 			     rule_list_pt rule )
 10 | {
 11 |   int      *neighbors;
 12 |   atom_pt  atom;
 13 |   int      result,
 14 |            number_of_neighbors,
 15 |            number_of_matches;
 16 |   int      i;
 17 | 
 18 |   neighbors = molecule->neighbors[base_atom];
 19 |   number_of_neighbors = molecule->number_of_neighbors[base_atom];
 20 |   number_of_matches = 0;
 21 |   for ( i = 0; i < number_of_neighbors; i++ )
 22 |     if ( neighbors[i] != bond_atom )
 23 |       /* don't consider atom on the other end of the bond we are checking */
 24 |       {
 25 | 	atom = &molecule->atoms[neighbors[i]];
 26 | 	result = check_atom ( rule->type,
 27 | 			      rule->orbit,
 28 | 			      atom->type, 
 29 | 			      atom->orbit );
 30 | 	if ( result == SUCCESS )
 31 | 	  {
 32 | 	    /*	    printf("prohibited match!\n");*/
 33 | 	    number_of_matches++;
 34 | 	    /* atom matches, so check, if we have counted enough of this type,
 35 | 	     if so, since this is a prohibited rule, return FAILURE */
 36 | 	    if ( number_of_matches == rule->number )
 37 | 	      {
 38 | 		/*		printf("FAILURE!!!!\n");*/
 39 | 		return FAILURE;
 40 | 	      }
 41 | 	    /* now check, if this is a nested rule */
 42 | 	    if ( rule->prohibited != NULL )
 43 | 		result = check_prohibited_rule ( molecule,
 44 | 						 neighbors[i],
 45 | 						 base_atom,
 46 | 						 rule->prohibited );
 47 | 	    if ( result == FAILURE )
 48 | 	      return FAILURE;
 49 | 	    if ( rule->required != NULL )
 50 | 	      result = check_required_rule ( molecule,
 51 | 					     neighbors[i],
 52 | 					     base_atom,
 53 | 					     rule->required );
 54 | 	    if ( result == FAILURE )
 55 | 	      return FAILURE;
 56 | 	  }
 57 |       }
 58 |   /*  printf("SUCCESS!!!\n");*/
 59 |   /* return SUCCESS, since rule is fulfilled (or satisfied?) */
 60 |   return SUCCESS;
 61 | }
 62 | 
 63 | int  check_required_rule ( molecule_pt  molecule,
 64 | 			   int          base_atom,
 65 | 			   int          bond_atom,
 66 | 			   rule_list_pt rule )
 67 | {
 68 |   int      *neighbors;
 69 |   atom_pt  atom;
 70 |   int      result,
 71 |            number_of_neighbors,
 72 |            number_of_matches;
 73 |   int      i;
 74 | 
 75 |   neighbors = molecule->neighbors[base_atom];
 76 |   number_of_neighbors = molecule->number_of_neighbors[base_atom];
 77 |   number_of_matches = 0;
 78 |   for ( i = 0; i < number_of_neighbors; i++ )
 79 |     if ( neighbors[i] != bond_atom )
 80 |       /* don't consider atom on the other end of the bond we are checking */
 81 |       {
 82 | 	atom = &molecule->atoms[neighbors[i]];
 83 | 	result = check_atom ( rule->type,
 84 | 			      rule->orbit,
 85 | 			      atom->type, 
 86 | 			      atom->orbit );
 87 | 	if ( result == SUCCESS )
 88 | 	  {
 89 | 	    number_of_matches++;
 90 | 	    if ( rule->prohibited != NULL )
 91 | 	      result = check_prohibited_rule ( molecule,
 92 | 					       neighbors[i],
 93 | 					       base_atom,
 94 | 					       rule->prohibited );
 95 | 	    if ( result == FAILURE )
 96 | 	      return FAILURE;
 97 | 	    if ( rule->required != NULL )
 98 | 	      result = check_required_rule ( molecule,
 99 | 					     neighbors[i],
100 | 					     base_atom,
101 | 					     rule->required );
102 | 	    if ( result == FAILURE )
103 | 	      return FAILURE;
104 | 	  }	    
105 |     }
106 |   /* check, if we have found enough atoms of the required type, if so, the
107 |      rule is fulfilled, so return SUCCESS */
108 |   if ( number_of_matches >= rule->number )
109 |     return SUCCESS;
110 |   return FAILURE;
111 | }
112 | 
113 | 


--------------------------------------------------------------------------------
/docs/readthedocs/js/theme.js:
--------------------------------------------------------------------------------
  1 | $( document ).ready(function() {
  2 |     // Shift nav in mobile when clicking the menu.
  3 |     $(document).on('click', "[data-toggle='wy-nav-top']", function() {
  4 |       $("[data-toggle='wy-nav-shift']").toggleClass("shift");
  5 |       $("[data-toggle='rst-versions']").toggleClass("shift");
  6 |     });
  7 | 
  8 |     // Close menu when you click a link.
  9 |     $(document).on('click', ".wy-menu-vertical .current ul li a", function() {
 10 |       $("[data-toggle='wy-nav-shift']").removeClass("shift");
 11 |       $("[data-toggle='rst-versions']").toggleClass("shift");
 12 |     });
 13 | 
 14 |     // Keyboard navigation
 15 |     document.addEventListener("keydown", function(e) {
 16 |         if ($(e.target).is(':input')) return true;
 17 |         var key = e.which || e.keyCode || window.event && window.event.keyCode;
 18 |         var page;
 19 |         switch (key) {
 20 |             case 39:  // right arrow
 21 |                 page = $('[role="navigation"] a:contains(Next):first').prop('href');
 22 |                 break;
 23 |             case 37:  // left arrow
 24 |                 page = $('[role="navigation"] a:contains(Previous):first').prop('href');
 25 |                 break;
 26 |             default: break;
 27 |         }
 28 |         if (page) window.location.href = page;
 29 |     });
 30 | 
 31 |     $(document).on('click', "[data-toggle='rst-current-version']", function() {
 32 |       $("[data-toggle='rst-versions']").toggleClass("shift-up");
 33 |     });
 34 | 
 35 |     // Make tables responsive
 36 |     $("table.docutils:not(.field-list)").wrap("<div class='wy-table-responsive'></div>");
 37 | 
 38 |     hljs.initHighlightingOnLoad();
 39 | 
 40 |     $('table').addClass('docutils');
 41 | });
 42 | 
 43 | window.SphinxRtdTheme = (function (jquery) {
 44 |     var stickyNav = (function () {
 45 |         var navBar,
 46 |             win,
 47 |             stickyNavCssClass = 'stickynav',
 48 |             applyStickNav = function () {
 49 |                 if (navBar.height() <= win.height()) {
 50 |                     navBar.addClass(stickyNavCssClass);
 51 |                 } else {
 52 |                     navBar.removeClass(stickyNavCssClass);
 53 |                 }
 54 |             },
 55 |             enable = function () {
 56 |                 applyStickNav();
 57 |                 win.on('resize', applyStickNav);
 58 |             },
 59 |             init = function () {
 60 |                 navBar = jquery('nav.wy-nav-side:first');
 61 |                 win    = jquery(window);
 62 |             };
 63 |         jquery(init);
 64 |         return {
 65 |             enable : enable
 66 |         };
 67 |     }());
 68 |     return {
 69 |         StickyNav : stickyNav
 70 |     };
 71 | }($));
 72 | 
 73 | // The code below is a copy of @seanmadsen code posted Jan 10, 2017 on issue 803.
 74 | // https://github.com/mkdocs/mkdocs/issues/803
 75 | // This just incorporates the auto scroll into the theme itself without
 76 | // the need for additional custom.js file.
 77 | //
 78 | $(function() {
 79 |   $.fn.isFullyWithinViewport = function(){
 80 |       var viewport = {};
 81 |       viewport.top = $(window).scrollTop();
 82 |       viewport.bottom = viewport.top + $(window).height();
 83 |       var bounds = {};
 84 |       bounds.top = this.offset().top;
 85 |       bounds.bottom = bounds.top + this.outerHeight();
 86 |       return ( ! (
 87 |         (bounds.top <= viewport.top) ||
 88 |         (bounds.bottom >= viewport.bottom)
 89 |       ) );
 90 |   };
 91 |   if( $('li.toctree-l1.current').length && !$('li.toctree-l1.current').isFullyWithinViewport() ) {
 92 |     $('.wy-nav-side')
 93 |       .scrollTop(
 94 |         $('li.toctree-l1.current').offset().top -
 95 |         $('.wy-nav-side').offset().top -
 96 |         60
 97 |       );
 98 |   }
 99 | });
100 | 


--------------------------------------------------------------------------------
/example_files/1KPF_AMP.mol2:
--------------------------------------------------------------------------------
 1 | @<TRIPOS>MOLECULE
 2 | *****
 3 |    35    37     0     0     0
 4 | SMALL
 5 | USER_CHARGES
 6 | 
 7 | @<TRIPOS>ATOM
 8 |       1 P1         13.3010    8.7680   10.5910 P.3       1 <0>         1.3712
 9 |       2 O1         14.4420    9.0450    9.7030 O.2       1 <0>        -1.0333
10 |       3 O2         13.3220    7.3880   11.1670 O.3       1 <0>        -1.0333
11 |       4 O3         11.9560    9.1760   10.0120 O.3       1 <0>        -1.0333
12 |       5 O4         13.5830    9.7760   11.8450 O.3       1 <0>        -0.5512
13 |       6 C1         12.6470    9.8190   12.9640 C.3       1 <0>         0.2800
14 |       7 C2         11.7550   11.0530   12.7000 C.3       1 <0>         0.2800
15 |       8 O5         10.7670   11.1650   13.7880 O.3       1 <0>        -0.5600
16 |       9 C3         12.6700   12.4610   12.6860 C.3       1 <0>         0.2800
17 |      10 O6         12.1150   13.2920   11.5540 O.3       1 <0>        -0.6800
18 |      11 C4         12.3000   13.0480   14.1470 C.3       1 <0>         0.2800
19 |      12 O7         12.1240   14.4480   14.1570 O.3       1 <0>        -0.6800
20 |      13 C5         10.8060   12.4580   14.3970 C.3       1 <0>         0.5356
21 |      14 N1         10.5530   12.2850   15.8410 N.pl3     1 <0>         0.0476
22 |      15 C6         11.3730   11.6590   16.7880 C.2       1 <0>         0.0365
23 |      16 N2         10.9320   11.6420   18.0630 N.2       1 <0>        -0.5653
24 |      17 C7          9.7310   12.3380   17.8890 C.ar      1 <0>         0.2272
25 |      18 C8          8.7060   12.6060   18.8050 C.ar      1 <0>         0.4100
26 |      19 N3          8.9030   12.3110   20.1410 N.pl3     1 <0>        -0.9000
27 |      20 N4          7.5690   13.1660   18.2640 N.ar      1 <0>        -0.6200
28 |      21 C9          7.4550   13.4810   16.9720 C.ar      1 <0>         0.4700
29 |      22 N5          8.3890   13.2990   16.0380 N.ar      1 <0>        -0.5670
30 |      23 C10         9.4820   12.7210   16.5500 C.ar      1 <0>         0.1054
31 |      24 H1         12.0436    8.9003   13.0066 H         1 <0>         0.0000
32 |      25 H2         13.1678    9.8901   13.9303 H         1 <0>         0.0000
33 |      26 H3         11.2650   10.9273   11.7232 H         1 <0>         0.0000
34 |      27 H4         13.7568   12.3898   12.5318 H         1 <0>         0.0000
35 |      28 H5         11.9984   14.1884   11.8462 H         1 <0>         0.4000
36 |      29 H6         13.0904   12.7897   14.8671 H         1 <0>         0.0000
37 |      30 H7         12.0844   14.7562   15.0547 H         1 <0>         0.4000
38 |      31 H8         10.0544   13.1452   13.9812 H         1 <0>         0.0000
39 |      32 H9         12.3154   11.2103   16.5104 H         1 <0>         0.1500
40 |      33 H10         8.9506   11.3193   20.2604 H         1 <0>         0.4000
41 |      34 H11         9.7587   12.7253   20.4510 H         1 <0>         0.4000
42 |      35 H12         6.5222   13.9231   16.6545 H         1 <0>         0.1500
43 | @<TRIPOS>BOND
44 |      1    1    2 2
45 |      2    1    4 1
46 |      3    1    3 1
47 |      4    1    5 1
48 |      5    9   10 1
49 |      6    5    6 1
50 |      7    7    9 1
51 |      8    9   11 1
52 |      9    6    7 1
53 |     10    7    8 1
54 |     11    8   13 1
55 |     12   11   12 1
56 |     13   11   13 1
57 |     14   13   14 1
58 |     15   14   23 1
59 |     16   14   15 1
60 |     17   22   23 ar
61 |     18   21   22 ar
62 |     19   17   23 ar
63 |     20   15   16 2
64 |     21   20   21 ar
65 |     22   16   17 1
66 |     23   17   18 ar
67 |     24   18   20 ar
68 |     25   18   19 1
69 |     26    6   24 1
70 |     27    6   25 1
71 |     28    7   26 1
72 |     29    9   27 1
73 |     30   10   28 1
74 |     31   11   29 1
75 |     32   12   30 1
76 |     33   13   31 1
77 |     34   15   32 1
78 |     35   19   33 1
79 |     36   19   34 1
80 |     37   21   35 1
81 | 


--------------------------------------------------------------------------------
/src/hbind/unbump_anchor.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *  This file contains routines to correct the position of ligands
  3 |  *  which failed the bump-check, but only bump no more than at
  4 |  *  MAX_BUMP_POINTS positions. The main routine in this file is
  5 |  *  'unbump_anchor()', which tries to move the ligand minimally away from
  6 |  *  the bumping protein atoms to get rid of all bumps. After this
  7 |  *  the bump-check has to be repeated for the new ligand position,
  8 |  *  since new bumps might have been caused by the transformation.
  9 |  */
 10 | 
 11 | #include <math.h>
 12 | #include <stdio.h>
 13 | #include "types.h"
 14 | #include "defs.h"
 15 | #include "unbump_translate.h"
 16 | #include "basics.h"
 17 | /*
 18 |  *  This function translates the ligand according to vector 'vector' 
 19 |  */
 20 | void  translate_ligand ( global_data_pt global,
 21 | 			 vector_t       vector )
 22 | {
 23 |   atom_pt   atom;
 24 |   int       i, j;
 25 | 
 26 |   atom = global->ligand->atoms;
 27 |   for ( i = 0; i < global->ligand->number_of_atoms; i++ )
 28 |     {
 29 |       for ( j = 0; j < 3; j++ )
 30 | 	atom->pos[j] += vector[j];
 31 |       atom++;
 32 |     }
 33 | }
 34 | 
 35 | 
 36 | /*
 37 |  *  The name of this function might be confusing: it computes the minimal
 38 |  *  translation along the global vector that is needed to get rid of
 39 |  *  all bumps, and so the maximal factor of all bumps has to be found.
 40 |  */
 41 | int compute_minimal_translation ( vector_pt target_vectors,
 42 | 				  bump_pt   bump,
 43 | 				  int       number_of_bumps,
 44 | 				  vector_t  global_vector,
 45 | 				  double    overlap,
 46 | 				  double    *maximal_translation )
 47 | {
 48 |   int    i;
 49 |   double translation;
 50 |   
 51 |   *maximal_translation = 0.0;
 52 |   for ( i = 0; i < number_of_bumps; i++ )
 53 |     {
 54 |       if ( compute_translation_coefficient ( target_vectors[i],
 55 | 					     global_vector,
 56 | 					     bump[i].protein_atom_rad
 57 | 					     + bump[i].ligand_atom_rad
 58 | 					     - overlap
 59 | 					     + 0.00001,
 60 | 					     &translation ) == FAILURE )
 61 | 	return FAILURE;
 62 |       if ( compare_double(translation, *maximal_translation) == 1 )
 63 | 	  *maximal_translation = translation;
 64 |     }
 65 |   return SUCCESS;
 66 | }
 67 | 
 68 | int  unbump_anchor ( global_data_pt global,
 69 | 		     bump_pt        bump,
 70 | 		     int            number_of_bumps )
 71 | {
 72 |   vector_t  target_vectors[MAX_ANCHOR_BUMPS]; /* translation vector to ideal
 73 | 					       position for each bump_point */
 74 |   vector_t  global_vector;        /* the global averaged translation vector */
 75 |   int       i, j;
 76 |   double    factor;
 77 | 
 78 |   for ( i = 0; i < number_of_bumps; i++ )
 79 |     for ( j = 0; j < 3; j++ )
 80 |       target_vectors[i][j] =
 81 | 	bump[i].ligand_atom_pos[j] - bump[i].protein_atom_pos[j];
 82 | 
 83 |   compute_global_vector ( target_vectors,
 84 | 			  number_of_bumps,
 85 | 			  global_vector );
 86 | 
 87 |   if ( compute_minimal_translation ( target_vectors,
 88 | 				     bump,
 89 | 				     number_of_bumps,
 90 | 				     global_vector,
 91 | 				     (double) global->anchor_overlap,
 92 | 				     &factor ) == FAILURE )
 93 |     return FAILURE;
 94 | 
 95 |   for ( i = 0; i < 3; i++ )
 96 |     global_vector[i] *= factor;
 97 | 
 98 |   if ( fabs ( global_vector[0] ) > global->anchor_translation
 99 |        || fabs ( global_vector[1] ) > global->anchor_translation
100 |        || fabs ( global_vector[2] ) > global->anchor_translation )
101 |     /* at least one component of the translation vector is larger than
102 |        the threshold, i.e., one can no longer assume that the template
103 |        points are matched, so this main-chain collisions are not
104 |        resolvable */
105 |     return FAILURE;
106 |   translate_ligand ( global,
107 | 		     global_vector );
108 |   return SUCCESS;
109 | }  
110 | 
111 | 
112 | 


--------------------------------------------------------------------------------
/src/hbind/assign_hydrogens.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    assign_hydrogens.c   Volker Schnecke     Mon Feb 16 21:17:11 EST 1998
 4 |  *
 5 |  *    function: assign_hydrogens()
 6 |  *
 7 |  *    assigns hydrogens to those nitrogens and oxygens where they seem to 
 8 |  *    be missing in the structure (adds only atoms but no positions)
 9 |  *
10 |  */
11 | #include <stdio.h>
12 | #include "types.h"
13 | #include "defs.h"
14 | #include "err_handle.h"
15 | 
16 | /*
17 |  *  This routine checks all nitrogens and oxygens in 'molecule' by counting 
18 |  *  the number of bonds (considering double bonds as two bonds, triple as 
19 |  *  three) and adding hydrogens, if less than three (two for oxygen) bonds 
20 |  *  are found.
21 |  */
22 | int  assign_hydrogens ( molecule_pt  molecule)
23 | {
24 |   int i;
25 |   char errmsg[FILENAME_MAX];
26 |   int total_bonds = 0;
27 |   int number_of_atoms = molecule->number_of_atoms;
28 | 
29 |   molecule->number_of_added_hydrogens = 0;
30 |   for ( i = 0; i < number_of_atoms; i++ )
31 |     if ( molecule->atoms[i].type == N || molecule->atoms[i].type == O )
32 |       /* only check nitrogens and oxygens */
33 |       {
34 | 	if ( molecule->atoms[i].type == N )
35 | 	  {
36 | 	    if ( (molecule->atoms[i].orbit == SP3) || (molecule->atoms[i].orbit == SP2) || (molecule->atoms[i].orbit == SP1) || (molecule->atoms[i].orbit == AR) || (molecule->atoms[i].orbit == AM))
37 | 	      {
38 | 		/* printf("orbit %d %d\n", i, molecule->atoms[i].orbit);*/
39 | 		/* nitrogen should have three bonds, otherwise it is assumed
40 | 		   that hydrogens are not included in the structure */
41 | 		total_bonds = 3;
42 | 	      }
43 | 	    else
44 | 	      {
45 | 		total_bonds = 4;
46 | 	      }
47 | 	  }
48 | 	else 
49 | 	  {
50 | 	    if ( ( molecule->atoms[i].orbit == SP3 ) || ( molecule->atoms[i].orbit == SP2 ) )
51 | 	      {
52 | 		/* oxygens should have two bonds */
53 | 		/*printf("orbit %d %d\n", i, molecule->atoms[i].orbit);*/
54 | 		total_bonds = 2;
55 | 	      }
56 | 	  }
57 | 	/*	if ( molecule->number_of_neighbors[i] != total_bonds )  toneroma 09FEB07 added bond_order check and used it instead, since it gives a better indication of valency */
58 | 	if ((  molecule->bond_order[i] != total_bonds ) && (( molecule->atoms[i].type != O ) && ( molecule->atoms[i].orbit != CO2 )) && (( molecule->atoms[i].type != N ) && ( molecule->atoms[i].orbit != PL3 )))
59 | 	  {
60 | 	    /*	    printf ( "%d %d %s %d %d, #bonds %s BO: %d\n", i, molecule->atoms[i].type, molecule->atoms[i].type_str,  molecule->number_of_neighbors[i], total_bonds, molecule->bonds[i].type_str, molecule->bond_order[i] ); */
61 | 	    sprintf (errmsg, "mol2 file incorrectly protonated. Protonate and re-analyze ligand %s\n", molecule->name );
62 | 	    err_error2 ( "assign_hydrogens", errmsg);
63 | 	    return FAILURE;
64 | 	  }
65 | 	else if ((  molecule->bond_order[i] > 2 ) && (( molecule->atoms[i].type == O ) && ( molecule->atoms[i].orbit == CO2 )))
66 | 	  {
67 | 	    /*	    printf ( "%d %d %s %d %d, #bonds %s BO: %d\n", i, molecule->atoms[i].type, molecule->atoms[i].type_str,  molecule->number_of_neighbors[i], total_bonds, molecule->bonds[i].type_str, molecule->bond_order[i] ); */
68 | 	    sprintf (errmsg, "mol2 file incorrectly protonated. Protonate and re-analyze ligand %s\n", molecule->name );
69 | 	    err_error2 ( "assign_hydrogens", errmsg);
70 | 	    return FAILURE;
71 | 	  }
72 | 	else if ((  molecule->number_of_neighbors[i] != 3 ) && (( molecule->atoms[i].type == N ) && ( molecule->atoms[i].orbit == PL3 )))
73 | 	  {
74 | 	    /*	    printf ( "%d %d %s %d %d, #bonds %s BO: %d\n", i, molecule->atoms[i].type, molecule->atoms[i].type_str,  molecule->number_of_neighbors[i], total_bonds, molecule->bonds[i].type_str, molecule->bond_order[i] ); */
75 | 	    sprintf (errmsg, "mol2 file incorrectly protonated. Protonate and re-analyze ligand %s\n", molecule->name );
76 | 	    err_error2 ( "assign_hydrogens", errmsg);
77 | 	    return FAILURE;
78 |  	  }
79 |       }
80 |   return SUCCESS;
81 | }
82 | 


--------------------------------------------------------------------------------
/src/utils/hbind_itimer.c:
--------------------------------------------------------------------------------
  1 | #include <sys/time.h>
  2 | #include <signal.h>
  3 | #include <errno.h>
  4 | #include <stdio.h>
  5 | #include <string.h>
  6 | #include "hbind_itimer.h"
  7 | 
  8 | static long real_elapsed_sec;
  9 | static long virt_elapsed_sec;
 10 | static long prof_elapsed_sec;
 11 | static long timer_interval_sec;
 12 | 
 13 | 
 14 | void hbind_itimer_sig_handler(int signum, siginfo_t *siginfo, void *ucontext)
 15 | {
 16 |   if(signum == SIGALRM) real_elapsed_sec += timer_interval_sec;
 17 |   else if(signum == SIGVTALRM) virt_elapsed_sec += timer_interval_sec;
 18 |   else if(signum == SIGPROF) prof_elapsed_sec += timer_interval_sec;
 19 | }
 20 | 
 21 | 
 22 | int hbind_itimer_start(int interval_sec_in)
 23 | {
 24 |   struct sigaction alrm_act;
 25 |   struct itimerval tval;
 26 |   timer_interval_sec = interval_sec_in;
 27 |   alrm_act.sa_sigaction = hbind_itimer_sig_handler;
 28 |   alrm_act.sa_flags = SA_SIGINFO | SA_RESTART;
 29 |   sigemptyset(&(alrm_act.sa_mask));
 30 |   real_elapsed_sec = 0;
 31 |   virt_elapsed_sec = 0;
 32 |   prof_elapsed_sec = 0;
 33 |   tval.it_value.tv_sec = timer_interval_sec;
 34 |   tval.it_value.tv_usec = 0;
 35 |   tval.it_interval.tv_sec = timer_interval_sec;
 36 |   tval.it_interval.tv_usec = 0;
 37 | 
 38 |   if(sigaction(SIGALRM, &alrm_act, NULL)){
 39 |     fprintf(stderr, "Unable to create SIGALRM for the profile timer");
 40 |     return -1;
 41 |   }else if(sigaction(SIGVTALRM, &alrm_act, NULL)){
 42 |     fprintf(stderr, "Unable to create SIGVTALRM for the profile timer");
 43 |     return -1;
 44 |   }else if(sigaction(SIGPROF, &alrm_act, NULL)){
 45 |     fprintf(stderr, "Unable to create SIGPROF for the profile timer");
 46 |     return -1;
 47 |   }else if( setitimer(ITIMER_REAL, &tval, 0) == -1){
 48 |     fprintf(stderr, "Unable to set the real timer: %s", strerror(errno)); 
 49 |     return -1;
 50 |   }else if( setitimer(ITIMER_VIRTUAL, &tval, 0) == -1){
 51 |     fprintf(stderr, "Unable to set the virtual timer: %s", strerror(errno)); 
 52 |     return -1;
 53 |   }else if( setitimer(ITIMER_PROF, &tval, 0) == -1){
 54 |     fprintf(stderr, "Unable to set the profile timer: %s", strerror(errno)); 
 55 |     return -1;
 56 |   }
 57 |   return 0;
 58 | }
 59 | 
 60 | int get_itimer(double *rv, int which, long elapsed_sec)
 61 | {
 62 |   struct itimerval tval;
 63 |   if( getitimer(which, &tval) == -1){
 64 |     fprintf(stderr, "Unable to get the current value of the timer: %s",
 65 |             strerror(errno));
 66 |     *rv = -1.0;
 67 |     return -1;
 68 |   }
 69 |   /* timers count down from starting value*/
 70 |   *rv = elapsed_sec + timer_interval_sec - tval.it_value.tv_sec;
 71 |   *rv -= tval.it_value.tv_usec / 1000000.0;
 72 |   if(*rv < 0) *rv = 0;
 73 |   return 0;
 74 | 
 75 | }
 76 | 
 77 | int hbind_itimer_get(double *real, double *virt, double *prof)
 78 | {
 79 |   if (get_itimer(real, ITIMER_REAL, real_elapsed_sec) == 0
 80 |       && get_itimer(virt, ITIMER_VIRTUAL, virt_elapsed_sec) == 0  
 81 |       &&  get_itimer(prof, ITIMER_PROF, prof_elapsed_sec) == 0 ) 
 82 |     return 0;
 83 |   else
 84 |     return 1;
 85 | }
 86 | 
 87 | char* hbind_get_local_time(char *buf, size_t buflen)
 88 | {
 89 |   struct timeval tv;
 90 |   struct timezone tz;
 91 |   struct tm ltime;
 92 | 
 93 |   if(buflen <= 0) return buf;
 94 |   if(gettimeofday(&tv, &tz) == -1){
 95 |     fprintf(stderr, "Unable to get time using the \"gettimeofday\" function: %s",
 96 |             strerror(errno));
 97 |     buf[0] = 0; 
 98 |     return buf;
 99 |   }
100 | 
101 |   if(!localtime_r(&(tv.tv_sec), &ltime)){
102 |     fprintf(stderr, "Unable to get the local time using \"localtime_r\": %s",
103 |             strerror(errno));
104 |     buf[0] = 0; 
105 |     return buf;
106 |   }
107 | 
108 |   if(my_strftime(buf, buflen, "%c", &ltime) == 0) buf[buflen - 1] = 0;
109 |   return buf;
110 | }
111 | 
112 | size_t my_strftime(char *s, size_t max, const char  *fmt,
113 |                    const struct tm *tm)
114 | { return strftime(s, max, fmt, tm); }
115 | 


--------------------------------------------------------------------------------
/src/hbind/read_pts_file.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <string.h>
  3 | #include <sys/types.h>
  4 | #include <sys/stat.h>
  5 | #include <unistd.h>
  6 | #include <errno.h>
  7 | #include "defs.h"
  8 | #include "types.h"
  9 | #include "err_handle.h"
 10 | 
 11 | int  read_pts_file ( global_data_pt  global,
 12 | 		      char            *filename )
 13 | {
 14 |   FILE            *in;
 15 |   pts_compound_pt compounds;
 16 |   char            linebuffer[128],
 17 |                   name[MAX_COMPOUNDNAME_LEN],
 18 |                   oldname[MAX_COMPOUNDNAME_LEN];
 19 |   float           *pos;
 20 |   int             *act,
 21 |                   *atom_index;
 22 |   char            type_char;
 23 |   int             number_of_compounds,
 24 |                   points,
 25 |                   count,
 26 |                   ind;
 27 |   char            err_msg[FILENAME_MAX];
 28 | 
 29 |   struct stat file_stat_buf;
 30 |   if(stat(filename, &file_stat_buf)){
 31 |     sprintf(err_msg, "FATAL ERROR:  Unable to open the file %s\n%s\n\n", 
 32 |             filename, strerror(errno));
 33 |     err_print(err_msg);
 34 |     fprintf(stderr, err_msg);
 35 |     printf("FATAL ERROR: Unable to open the interaction points file %s -- Please see err file\n", filename);
 36 |     return FAILURE;
 37 |   }else if(file_stat_buf.st_size == 0){
 38 |     sprintf(err_msg, "\nFATAL ERROR: Database file %s is empty\n\n", filename);
 39 |     err_print(err_msg);
 40 |     fprintf(stderr, err_msg);
 41 |     fprintf(stdout, err_msg);
 42 |     return FAILURE;
 43 |   }
 44 |   in = fopen ( filename, "r" );
 45 |   if( in == NULL){
 46 |     perror ( "ERROR  " );
 47 |     sprintf (err_msg, "unable to open file %s", filename );
 48 |     err_warning2 ("read_pts_file", err_msg);
 49 |     return FAILURE;
 50 |   }
 51 | 
 52 |   compounds = global->compound_interactions->compounds;
 53 |   act = global->compound_interactions->act;
 54 |   pos = global->compound_interactions->pos;
 55 |   atom_index = global->compound_interactions->atom_index;
 56 |   count = 0; 
 57 |   points = 0;
 58 |   number_of_compounds = 0;
 59 | 
 60 |   while ( fgets ( linebuffer, sizeof (linebuffer), in ) != NULL ){
 61 |     if(linebuffer[0] == '\0' || linebuffer[0] == '\n' || linebuffer[0] == ' ' )
 62 |       continue;
 63 |     ind = 3 * count;
 64 |     sscanf(linebuffer, "%s %c %f %f %f %d", name, &type_char, &pos[ind+X],
 65 |            &pos[ind+Y], &pos[ind+Z], &atom_index[count] );
 66 |     if ( type_char == 'A' ) act[count] = ACCEPTOR;
 67 |     else if ( type_char == 'D' ) act[count] = DONOR;
 68 |     else if ( type_char == 'H' ) act[count] = HYDROPHOB;
 69 |     else if ( type_char == 'N' ) act[count] = DONEPTOR;
 70 |     else {
 71 |       printf ( "%s", linebuffer );
 72 |       err_panic2 ( "read_pts_file", "illegal interaction type");
 73 |     }
 74 |     if ( count == 0 ){
 75 |       strcpy ( oldname, name ); 	
 76 |       strcpy ( compounds[0].name, name ); 
 77 |       compounds[0].first_point = 0;
 78 |     }
 79 |     if ( points > 0 && strcmp ( name, oldname ) != 0 ) {
 80 |       compounds[number_of_compounds].number_of_points = points;
 81 |       number_of_compounds++;
 82 |       strcpy ( compounds[number_of_compounds].name, name ); 
 83 |       strcpy ( oldname, name ); 
 84 |       compounds[number_of_compounds].first_point = count;
 85 |       points = 0;
 86 |     }
 87 |     count++;
 88 |     points++;
 89 |          
 90 |     if ( count > MAX_NUMBER_OF_TOTAL_COMPOUND_INTERACTION_POINTS )
 91 |       err_panic2("read_pts_file", 
 92 |                  "more than MAX_NUMBER_OF_TOTAL_COMPOUND_INTERACTION_POINTS "
 93 |                  " interaction_points");
 94 |     if ( number_of_compounds+1 > MAX_NUMBER_OF_PTS_COMPOUNDS )
 95 |       err_panic2 ( "read_pts_file",
 96 | 		  "more than MAX_NUMBER_OF_PTS_COMPOUNDS compounds");
 97 |   }
 98 |   compounds[number_of_compounds].number_of_points = points;
 99 |   global->compound_interactions->number_of_compounds = number_of_compounds + 1;
100 |   global->compound_interactions->number_of_interaction_points = count;
101 |   fclose ( in );
102 |   if ( count == 0 ) return FAILURE;
103 |   return SUCCESS;
104 | }
105 |   
106 | 


--------------------------------------------------------------------------------
/src/hbind/write_log_file.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | #include <stdio.h>
 3 | #include <time.h>
 4 | #include <sys/times.h>
 5 | #include <limits.h>
 6 | #include <unistd.h>
 7 | #include <netdb.h>
 8 | #include <sys/param.h>
 9 | #include "defs.h"
10 | #include "types.h"
11 | #include "err_handle.h"
12 | #include "hbind_itimer.h"
13 | 
14 | void write_log_file(global_data_pt global, char *filename )
15 | {
16 |   FILE       *fp;
17 |   char hname[MAXHOSTNAMELEN];
18 |   char tbuf[80];
19 |   double real, virt, prof;
20 | 
21 |   fp = fopen ( filename, "w");
22 |   if ( fp == NULL ) {
23 |       perror ( "ERROR  ");
24 |       err_panic2 ( "write_log_file", "file open failed");
25 |   }
26 |   fprintf(fp, "\n********************************\n");
27 |   fprintf(fp, "   HBIND screening statistics\n");
28 |   fprintf(fp, "********************************\n\n");
29 |   fprintf(fp, "target                   : %s\n", global->protein);
30 |   fprintf(fp, "template                 : %s\n", global->template);
31 |   fprintf(fp, "database                 : %s\n", global->database);
32 |   fprintf(fp, "compounds                : %d\n\n", 
33 | 	    global->number_of_screened_compounds);
34 |   fprintf(fp, "parameters\n");
35 |   fprintf(fp, "----------\n");
36 |   fprintf(fp, "DME threshold            : %3.1f\n", global->dmetol);
37 |   fprintf(fp, "RMS threshold            : %3.1f\n", global->rmstol);
38 |   fprintf(fp, "max anchor translation   : %3.1f\n", global->anchor_translation);
39 |   fprintf(fp, "anchor overlap           : %3.1f\n", global->anchor_overlap);
40 |   fprintf(fp, "side-chain overlap       : %3.1f\n", global->side_chain_overlap);
41 |   fprintf(fp, "intra overlap            : %3.1f\n", global->intra_overlap);
42 |   fprintf(fp, "intermediate overlap     : %3.1f\n",
43 | 	    global->intermediate_overlap);
44 |   fprintf(fp, "tolerated overlap        : %3.1f\n",
45 | 	    global->finally_tolerated_overlap);
46 |   fprintf(fp, "tolerated max bump       : %3.1f\n",
47 | 	    global->finally_tolerated_max_bump);
48 |   fprintf(fp, "score cutoff             : %3.1f\n\n", global->score_cutoff);
49 |   fprintf(fp, "hashing\n");
50 |   fprintf(fp, "-------\n");
51 |   fprintf(fp, "total template triangles : %d\n",
52 | 	    global->number_of_template_triangles);
53 |   fprintf(fp, "non-empty buckets        : %d\n",
54 | 	    global->number_of_hash_buckets);
55 |   fprintf(fp, "total triangle pointers  : %d\n",
56 | 	    global->number_of_triangle_pointers);
57 |   fprintf(fp, "average triangle pointers: %d\n",
58 | 	  global->number_of_triangle_pointers / global->number_of_hash_buckets);
59 |   fprintf(fp, "maximal triangle pointers: %d\n\n",
60 | 	    global->max_number_of_triangles);
61 |   fprintf(fp, "filter effectiveness\n");
62 |   fprintf(fp, "--------------------\n");
63 |   fprintf(fp, "triangle match           : %d\n", 
64 | 	    global->filter_counter[TRIANGLE_MATCH]);
65 |   fprintf(fp, "triangle DME             : %d\n", global->filter_counter[DME]);
66 |   fprintf(fp, "RMS deviation            : %d\n", 
67 | 	    global->filter_counter[RMS_DEVI]);
68 |   fprintf(fp, "anchor unbump            : %d\n", 
69 | 	    global->filter_counter[BUMP_ANCHOR]);
70 |   fprintf(fp, "side-chain unbump        : %d\n", 
71 | 	    global->filter_counter[BUMP_SIDE_CHAIN]);
72 |   fprintf(fp, "scoring                  : %d\n\n", 
73 | 	    global->filter_counter[SCORING]);
74 |   fprintf(fp, "potential ligands        : %d\n\n", 
75 | 	    global->number_of_potential_ligands);
76 |   fprintf(fp, "best affiscore           : %0.3f (name: %s, significance: %0.3f)\n",
77 | 	  global->best_affiscore_so_far, global->best_affi_name, global->affiscore_significance);
78 |   fprintf(fp, "affiscore mean           : %0.3f\n",
79 | 	  global->affiscore_mean);
80 |   fprintf(fp, "affiscore stdd           : %0.3f\n\n",
81 | 	  global->affiscore_stdd);
82 |   fprintf(fp, "timing\n------\n");	    
83 |   gethostname(hname, MAXHOSTNAMELEN);
84 |   fprintf(fp, "host                     : %s\n", hname);
85 |   hbind_get_local_time(tbuf, 80);
86 |   fprintf(fp, "finished                 : %s", tbuf);
87 |   hbind_itimer_get(&real, &virt, &prof);
88 |   fprintf(fp, "Wall Clock Time (seconds): %8.2f", real);
89 |   fclose ( fp);
90 | }
91 | 
92 | 


--------------------------------------------------------------------------------
/src/hbind/find_hyd_atoms.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    find_hyd_atoms.c     Volker Schnecke     Fri Feb 13 14:42:40 EST 1998
  4 |  *
  5 |  *    functions:  check_hyd_atom()
  6 |  *                find_hyd_atoms()
  7 |  *
  8 |  *    checks all atoms in the structure to identify Hydrogen-bond
  9 |  *    donors and acceptors
 10 |  *    
 11 |  */
 12 | 
 13 | #include <stdio.h>
 14 | #include <types.h>
 15 | #include <defs.h>
 16 | #include <check_rule.h>
 17 | 
 18 | /*  This routine checks the atom with index 'index' in the molecule
 19 |  *  structure for donor or acceptor properties as described in 'rules'.
 20 |  *  The possible return values are DONOR, ACCEPTOR, or NOTHING 
 21 |  */
 22 | int check_hyd_atom(molecule_pt  molecule, hyd_defn_pt rules, int index )
 23 | {
 24 |   atom_pt  atoms;
 25 |   rule_pt  rule;
 26 |   int      result,
 27 |            temp_act;
 28 |   int      i, j;
 29 | 
 30 |   atoms = molecule->atoms;
 31 |   temp_act = NOTHING;
 32 | 
 33 |   /* check acceptor rules first */
 34 |   for(i = 0; i < rules->number_of_acceptor_rules && temp_act == NOTHING; i++){ 
 35 |     rule = &rules->acceptor_rules[i]; 
 36 | 
 37 |     /* atom matches current acceptor rule atom, so check required and
 38 |      * prohibited rules */
 39 |     if(check_atom(rule->type, rule->orbit, atoms[index].type, 
 40 |                   atoms[index].orbit)){
 41 |       result = SUCCESS; 
 42 |       for(j = 0; j < MAX_RULES_PER_BONDED_ATOM && result == SUCCESS; j++) 
 43 |         /* the third parameter is the index of a neighbored atom
 44 |          * that should not be included in the checks; this is only
 45 |          * relevant when checking flexible bond rules, so pass
 46 |          * index = -1 here */
 47 |         if(rule->prohibited[j] != NULL) 
 48 |           result = check_prohibited_rule(molecule, index, -1, 
 49 |                                          rule->prohibited[j]);
 50 | 
 51 |       for(j = 0; j < MAX_RULES_PER_BONDED_ATOM && result == SUCCESS; j++) 
 52 |         if(rule->required[j] != NULL ) 
 53 |           result = check_required_rule(molecule, index, -1, rule->required[j]); 
 54 | 
 55 |       /* all rules fulfilled, i.e. this atom is an ACCEPTOR, but
 56 |        * don't return, check first, if this atom can donate, too */
 57 |       if(result == SUCCESS) temp_act = ACCEPTOR;
 58 |     }
 59 |   }
 60 | 
 61 |   /* if current atom is no acceptor, it might still be a donor... */
 62 |   for ( i = 0; i < rules->number_of_donor_rules; i++){ 
 63 |     rule = &rules->donor_rules[i]; 
 64 |     if(check_atom(rule->type, rule->orbit, atoms[index].type, 
 65 |                   atoms[index].orbit)){ 
 66 |       result = SUCCESS; 
 67 |       for(j = 0; j < MAX_RULES_PER_BONDED_ATOM && result == SUCCESS; j++) 
 68 |         if(rule->prohibited[j] != NULL) 
 69 |           result = check_prohibited_rule(molecule, index, -1, 
 70 |                                          rule->prohibited[j]); 
 71 |       for ( j = 0; j < MAX_RULES_PER_BONDED_ATOM && result == SUCCESS; j++) 
 72 |         if(rule->required[j] != NULL ) 
 73 |           result = check_required_rule(molecule, index, -1, rule->required[j]); 
 74 | 
 75 |       /* hit, so this atom is a donor, but has it already been 
 76 |        * identified as an acceptor? */
 77 |       if(result == SUCCESS){ 
 78 |         if(temp_act == ACCEPTOR) return DONEPTOR;
 79 |         else return DONOR;
 80 |       }
 81 |     }
 82 |   }
 83 | 
 84 |   /* definitely no donor, in that case the routine would have been left
 85 |      before, so it might be nothing or a acceptor, temp_hyd has the answer */
 86 |   return temp_act;
 87 | }
 88 | 
 89 | /*  This routine checks all atoms in 'molecule' and assigns the 'hyd'
 90 |  *  properties to them
 91 |  */
 92 | void find_hyd_atoms(molecule_pt molecule, hyd_defn_pt rules)
 93 | {
 94 |   int i;
 95 | 
 96 |   for ( i = 0; i < molecule->number_of_atoms; i++ )
 97 |     /* only have a closer look at Nitrogens and Oxygens */
 98 |     if(molecule->atoms[i].type == N || molecule->atoms[i].type == O || 
 99 |        molecule->atoms[i].type == F || molecule->atoms[i].type == CL){
100 |       molecule->atoms[i].act = check_hyd_atom(molecule, rules, i);
101 |     }else molecule->atoms[i].act = NOTHING;
102 | }
103 | 


--------------------------------------------------------------------------------
/src/hbind/debug_funs.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <errno.h>
  4 | #include <string.h>
  5 | #include "types.h"
  6 | #include "err_handle.h"
  7 | 
  8 | const char*
  9 | act2str(int act)
 10 | {
 11 | 
 12 |   if(act == NOTHING) return "NOTHING";
 13 |   else if(act == ACCEPTOR) return "ACCEPTOR";
 14 |   else if(act == DONOR) return "DONOR";
 15 |   else if(act == HYDROPHOB) return "HYDROPHOB";
 16 |   else if(act == DONEPTOR) return "DONEPTOR";
 17 |   else if(act == DONOR_HYDROGEN) return "DONOR_HYDROGEN";
 18 |   else if(act == METAL_1) return "METAL_1";
 19 |   else if(act == METAL_2) return "METAL_2";
 20 | 
 21 | #if 0
 22 | /* summed interaction types*/
 23 | ACCEPTOR_ACCEPTOR
 24 | DONOR_DONOR
 25 | HYDROPHOB_HYDROPHOB
 26 | ACCEPTOR_DONOR
 27 | ACCEPTOR_DONEPTOR
 28 | DONOR_DONEPTOR
 29 | DONEPTOR_DONEPTOR
 30 | ACCEPTOR_DONOR_HYDROGEN
 31 | DONEPTOR_DONOR_HYDROGEN
 32 | ACCEPTOR_METAL_1
 33 | ACCEPTOR_METAL_2
 34 | DONEPTOR_METAL_1
 35 | DONEPTOR_METAL_2
 36 | #endif
 37 | 
 38 | }
 39 | 
 40 | void 
 41 | write_mol2(char *filename, float *positions, global_data_pt global)
 42 | {
 43 |   FILE *fp;
 44 |   int i;
 45 |   char err_msg[2*FILENAME_MAX];
 46 |   int errsv;
 47 |   float *position;
 48 | 
 49 |   molecule_pt ligand = global->ligand;
 50 |   atom_pt atoms = global->ligand->atoms;
 51 |   bond_pt bonds = global->ligand->bonds;
 52 |   /* do not print the added hydrogens that have been necessary to
 53 |      check the donor/acceptor and flexible bond rules */
 54 |   int num_atoms = ligand->number_of_atoms - ligand->number_of_added_hydrogens;
 55 |   /* do not print bonds to added hydrogens */
 56 |   int num_bonds = ligand->number_of_bonds - ligand->number_of_added_hydrogens;
 57 | 
 58 |   fp = fopen ( filename, "w" );
 59 |   if ( fp == NULL ) {
 60 |     errsv = errno;
 61 |     sprintf(err_msg, "Could not open the file: %s\n\t%s", filename,
 62 |             strerror(errsv));
 63 |     fprintf(stderr, err_msg);
 64 |     err_print(err_msg);
 65 |     err_panic2("write_mol2", "file open failed");
 66 |   }
 67 | 
 68 |   fprintf(fp, "@<TRIPOS>MOLECULE\n" );
 69 |   fprintf(fp, "%s\n", ligand->name );
 70 |   fprintf(fp, "%5d %5d %5d     0     0\n", num_atoms, num_bonds,
 71 |           ligand->number_of_substructures );
 72 |   fprintf ( fp, "SMALL\nUSER_CHARGES\n@<TRIPOS>ATOM\n" );
 73 |   for(i = 0; i < num_atoms; i++ ){
 74 |     if(positions) position = positions + 3*i;
 75 |     else position = atoms[i].pos;
 76 |     fprintf(fp, "  %5d %-8s %9.4f %9.4f %9.4f %-9s%2d %s       %7.4f \n",
 77 |             atoms[i].atom_number, atoms[i].name, position[0], position[1],
 78 |             position[2], atoms[i].type_str, atoms[i].subst_id,
 79 |             atoms[i].subst_name, atoms[i].charge );
 80 |   }
 81 | 
 82 |   fprintf ( fp, "@<TRIPOS>BOND\n" );
 83 |   for(i = 0; i < num_bonds; i++)
 84 |     fprintf(fp, "%5d %5d %5d %s\n", bonds[i].number,
 85 |             atoms[bonds[i].atom1].atom_number,
 86 |             atoms[bonds[i].atom2].atom_number, bonds[i].type_str);
 87 | 
 88 |   fprintf ( fp, "@<TRIPOS>SUBSTRUCTURE\n" );
 89 |   for(i = 0; i < ligand->number_of_substructures; i++)
 90 |     fprintf( fp, "%s", ligand->substructure[i]);
 91 |   fclose ( fp );
 92 | }
 93 | 
 94 | void
 95 | write_pdb(atom_pt atoms, int num_atoms, char *filename, float *positions)
 96 | {
 97 |   FILE     *fp;
 98 |   int       j;
 99 |   char     err_msg[2*FILENAME_MAX];
100 |   int errsv;
101 |   atom_pt atom;
102 |   float *atom_pos = 0;
103 | 
104 |   fp = fopen ( filename, "w" );
105 |   if ( fp == NULL ) {
106 |     errsv = errno;
107 |     sprintf(err_msg, "Could not open the file: %s\n\t%s", filename,
108 |             strerror(errsv));
109 |     fprintf(stderr, err_msg);
110 |     err_print(err_msg);
111 |     err_panic2("write_pdb", "file open failed");
112 |   }
113 | 
114 |   atom = atoms;
115 |   atom_pos = positions;
116 |   for(j = 0; j < num_atoms; j++){
117 |     fprintf(fp, "ATOM  %5d  %-3s%1c%-3s %1c%5s    %7.3f %7.3f %7.3f"
118 |             "  1.00  1.00\n", atom->atom_number, atom->name, 
119 |             atom->alt_location, atom->residue, atom->chain_id, 
120 |             atom->residue_num, atom_pos[0], atom_pos[1], atom_pos[2]);
121 |     atom++;
122 |     atom_pos += 3;
123 |   }
124 | 
125 |   fclose ( fp );
126 | }
127 | 


--------------------------------------------------------------------------------
/src/hbind/initialize_unbump_matrices.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "defs.h"
  3 | #include "types.h"
  4 | #include "bitstrings.h"
  5 | 
  6 | #define TRAC
  7 | 
  8 | void  initialize_probability_matrix ( global_data_pt  global )
  9 | {
 10 |   double         probability;
 11 |   int            count;
 12 |   int            b, r;
 13 |   unbump_data_pt **unbump_data = global->unbump_data;
 14 |   for(b = 0; b < global->number_of_bumps; b++){
 15 |     count = 0;
 16 |     for(r = 0; r < global->number_of_unbump_bonds; r++)
 17 |       if(unbump_data[b][r]) count++;
 18 |     if(!count) continue;
 19 | 
 20 |     probability = 1.0 / count;
 21 |     for(r = 0; r < global->number_of_unbump_bonds; r++)
 22 |       if(unbump_data[b][r]) unbump_data[b][r]->probability = probability;
 23 |   }
 24 |   
 25 | #ifdef TRACE
 26 |   for ( r = 0; r < global->number_of_unbump_bonds; r++){
 27 |     for ( b = 0; b < global->number_of_bumps; b++ ){
 28 |       if ( unbump_data[b][r] != NULL )
 29 |         printf ( " %6.3lf", unbump_data[b][r]->probability );
 30 |       else printf ( "  *.***" );
 31 |     }
 32 |     printf ( "\n" );
 33 |   }
 34 | #endif
 35 | }
 36 |       
 37 | int  number_of_rotating_atoms ( global_data_pt  global,
 38 | 				int             index )
 39 | {
 40 |   atom_pt  target,
 41 |            atoms;
 42 |   int      *unbump_bonds;
 43 |   int      res_index,
 44 |            bond,
 45 |            flex_bond,
 46 |            offset, 
 47 |            count;
 48 |   int      i;
 49 | 
 50 |   target = global->target_atoms;
 51 |   atoms = global->ligand->atoms;
 52 |   unbump_bonds = global->unbump_bonds;       
 53 |   count = 0;
 54 |   if ( unbump_bonds[index] >= 0 )
 55 |     /* this is a target bond */
 56 |     {
 57 |       res_index = unbump_bonds[index] / 10;
 58 |       bond = unbump_bonds[index] % 10;
 59 |       offset = global->target_residues[res_index].start_atom;
 60 |       for ( i = 0; 
 61 | 	    i < global->target_residues[res_index].number_of_atoms;
 62 | 	    i++ )
 63 | 	if ( target[offset+i].level > bond )
 64 | 	  count++;
 65 |     }
 66 |   else
 67 |     /* this is a ligand bond */
 68 |     {      
 69 |       flex_bond = ( (-1) * unbump_bonds[index] ) - 1;
 70 |       if ( global->ligand->bond_directions[flex_bond] == REVERSE )
 71 | 	{
 72 | 	  for ( i = 0; i < global->ligand->number_of_atoms; i++ )
 73 | 	    if ( bitstring_get_bit ( atoms[i].fragments,
 74 | 				     flex_bond ) 
 75 | 	     	 && atoms[i].type != H )
 76 | 	      /* this atom is located 'right' from the rotation bond, 
 77 | 		 i.e., at the side with the larger atom index, which is 
 78 | 		 the side pointing away from the base */
 79 | 	      count++;
 80 | 	}
 81 |       else
 82 | 	{
 83 | 	  for ( i = 0; i < global->ligand->number_of_atoms; i++ )
 84 | 	    if ( bitstring_get_bit ( atoms[i].fragments,
 85 | 				     flex_bond ) == 0 
 86 | 		 && atoms[i].type != H ) 
 87 | 	      /* this atom is located 'left' from the rotation bond */
 88 | 	      count++;
 89 | 	}      
 90 |     }
 91 |   return count;
 92 | }
 93 | 
 94 | void initialize_force_matrix(global_data_pt  global)
 95 | {
 96 |   int rotated_atoms;
 97 |   int b, r;
 98 |   unbump_data_pt  **unbump_data = global->unbump_data;
 99 |   
100 |   for(r = 0; r < global->number_of_unbump_bonds; r++){
101 |     rotated_atoms = number_of_rotating_atoms(global, r);
102 |     for ( b = 0; b < global->number_of_bumps; b++ ){
103 |       if(!unbump_data[b][r]) continue;
104 | 
105 |       if(unbump_data[b][r]->angle > 0)
106 |         unbump_data[b][r]->force = (double) rotated_atoms * 
107 |           unbump_data[b][r]->angle * unbump_data[b][r]->penalty;
108 |       else
109 |         unbump_data[b][r]->force = (double) rotated_atoms * 
110 |           (-1.0) * unbump_data[b][r]->angle * unbump_data[b][r]->penalty;
111 |     }
112 |   }
113 | #ifdef TRACE
114 |   for(r = 0; r < global->number_of_unbump_bonds; r++){
115 |     for(b = 0; b < global->number_of_bumps; b++){
116 |       if(unbump_data[b][r] != 0) printf(" %6.3lf", unbump_data[b][r]->force);
117 |       else printf ( "     **" );
118 |     }
119 |     printf ( "\n" );
120 |   }
121 | #endif
122 | }
123 | 
124 | void initialize_unbump_matrices(global_data_pt global)
125 | {
126 |   initialize_probability_matrix(global);
127 |   initialize_force_matrix(global);
128 | }
129 | 
130 | 


--------------------------------------------------------------------------------
/src/hbind/distance_array.c:
--------------------------------------------------------------------------------
  1 | #include <string.h>
  2 | #include <math.h>
  3 | #include <types.h>
  4 | #include <mymalloc.h>
  5 | #include <err_handle.h>
  6 | #include <dist_fun.h>
  7 | 
  8 | 
  9 | void
 10 | distance_array(dist_array_pt darray, const atom_pt atoms, int num_atoms, 
 11 |                const float box_width, const float max_dist)
 12 | {
 13 |   int i, j, k;
 14 |   float min_pt[3], max_pt[3];
 15 |   atom_pt a;
 16 |   const atom_pt atoms_end = atoms + num_atoms;
 17 |   dist_bin_pt bin_p;
 18 | 
 19 |   darray->box_width = box_width;
 20 | 
 21 |   /* Spin through the positions to find the min and max values */
 22 |   memcpy(min_pt, atoms->pos, 3*sizeof(min_pt[0]));
 23 |   memcpy(max_pt, atoms->pos, 3*sizeof(min_pt[0]));
 24 |   for(a = atoms; a < atoms_end; ++a){
 25 |     for(i = 0; i < 3; ++i){
 26 |       if(max_pt[i] < a->pos[i]) max_pt[i] = a->pos[i];
 27 |       if(a->pos[i] < min_pt[i]) min_pt[i] = a->pos[i];
 28 |     }
 29 |   }
 30 | 
 31 |   /* Make a box that has a buffer as well as side lengths divisible by 
 32 |    * box_width */
 33 |   for(i = 0; i < 3; ++i){
 34 |     max_pt[i] = box_width * ceil(max_pt[i] / box_width) + 2*box_width;
 35 |     min_pt[i] = box_width * floor(min_pt[i] / box_width) - 2*box_width;
 36 |     darray->num_bins[i] = (int) ((max_pt[i] - min_pt[i]) / box_width);
 37 |   }
 38 |   memcpy(darray->min_corner, min_pt, 3 * sizeof(min_pt[0]));
 39 |   memcpy(darray->max_corner, max_pt, 3 * sizeof(max_pt[0]));
 40 |  
 41 |   /* Populate the arrays */ 
 42 |   darray->bins = 
 43 |     (dist_bin_pt) mymalloc(darray->num_bins[0] * darray->num_bins[1] * 
 44 |                            darray->num_bins[2] * sizeof(dist_bin_t));
 45 |   bin_p = darray->bins;
 46 |   min_pt[0] = darray->min_corner[0];
 47 |   max_pt[0] = darray->min_corner[0] + box_width;
 48 |   for(i = 0; i < darray->num_bins[0]; ++i){
 49 |     min_pt[1] = darray->min_corner[1];
 50 |     max_pt[1] = darray->min_corner[1] + box_width;
 51 |     for(j = 0; j < darray->num_bins[1]; ++j){
 52 |       min_pt[2] = darray->min_corner[2];
 53 |       max_pt[2] = darray->min_corner[2] + box_width;
 54 |       for(k = 0; k < darray->num_bins[2]; ++k, ++bin_p){
 55 |         /* Intialize the bin variables */
 56 |         bin_p->atoms = 0;
 57 |         bin_p->num_atoms = 0;
 58 |         bin_p->size = 0;
 59 |         /* Populate the bin */
 60 |         for(a = atoms; a < atoms_end; ++a){
 61 |           if(min_pt[0] - max_dist <= a->pos[0] &&
 62 |              a->pos[0] <= max_pt[0] + max_dist &&
 63 |              min_pt[1] - max_dist <= a->pos[1] &&
 64 |              a->pos[1] <= max_pt[1] + max_dist && 
 65 |              min_pt[2] - max_dist <= a->pos[2] &&
 66 |              a->pos[2] <= max_pt[2] + max_dist){
 67 |             if(bin_p->size <= bin_p->num_atoms){
 68 |               bin_p->size = (bin_p->size ? 2*bin_p->size : 10);
 69 |               bin_p->atoms = (atom_pt *) myrealloc(bin_p->atoms, bin_p->size * 
 70 |                                                    sizeof(atom_pt));
 71 |             }
 72 |             bin_p->atoms[bin_p->num_atoms] = a;
 73 |             ++(bin_p->num_atoms);
 74 |           }
 75 |         }
 76 |         min_pt[2] += box_width;
 77 |         max_pt[2] += box_width;
 78 |       }
 79 |       min_pt[1] += box_width; 
 80 |       max_pt[1] += box_width; 
 81 |     }
 82 |     min_pt[0] += box_width;
 83 |     max_pt[0] += box_width;
 84 |   }
 85 | }
 86 | 
 87 | /*
 88 |  Need to fix this as it causes a segfault -- a bit confusing since my_free
 89 |  doesn't attempt to free null pointers.
 90 | */
 91 | void
 92 | free_distance_array(dist_array_pt d)
 93 | {
 94 |   int i;
 95 |   int num_bins = d->num_bins[0] * d->num_bins[1] * d->num_bins[2];
 96 |   for(i = 0; i < num_bins; ++i)
 97 |     my_free(d->bins[i].atoms);
 98 |   my_free(d->bins);
 99 | }
100 | 
101 | dist_bin_pt
102 | get_bin(dist_array_pt darray, float *pt)
103 | {
104 |   int i;
105 |   int idx[3];
106 | 
107 |   /* Check if point falls outside the range of the bins */
108 |   for(i = 0; i < 3; ++i)
109 |     if(pt[i] < darray->min_corner[i] || darray->max_corner[i] < pt[i]) return 0;
110 | 
111 |   /* Compute the index */
112 |   for(i = 0; i < 3; ++i)
113 |     idx[i] = (int) floor((pt[i] - darray->min_corner[i]) / darray->box_width);
114 |  
115 |   return darray->bins + (idx[0] * darray->num_bins[1]*darray->num_bins[2] +
116 |                          idx[1] * darray->num_bins[2] + idx[2]); 
117 | }
118 | 


--------------------------------------------------------------------------------
/src/hbind/eigen.c:
--------------------------------------------------------------------------------
  1 | #include <math.h>
  2 | #include "defs.h"
  3 | #include "basics.h"
  4 | 
  5 | void  tred2 ( double  a[6][6],
  6 | 	      double  z[6][6],
  7 | 	      double  d[6],
  8 | 	      double  e[6],
  9 | 	      double  tolerance )
 10 | {
 11 |   double  f, g, h, m;
 12 |   int     l;
 13 |   int     i, j, k;
 14 |   
 15 |   for ( i = 0; i < 6; i++ )
 16 |     for ( j = 0; j < 6; j++ )
 17 |       z[i][j] = a[i][j];
 18 |   for ( i = 5; i >= 1; i-- ) 
 19 |     {
 20 |       l = i - 2;
 21 |       f = z[i][i-1];
 22 |       g = 0.0;
 23 |       for ( k = 0; k <= l; k++ ) 
 24 | 	g += z[i][k] * z[i][k];
 25 |       h = g + f * f;	    
 26 |       if ( g <= tolerance ) 
 27 | 	{
 28 | 	  e[i] = f;
 29 | 	  h = 0.0;
 30 | 	}
 31 |       else 
 32 | 	{
 33 | 	  l++;
 34 | 	  if ( f >= 0.0 )	
 35 | 	    g = (-1.0) * sqrt ( h );
 36 | 	  else		
 37 | 	    g = sqrt ( h );
 38 | 	  e[i] = g;
 39 | 	  h -= f * g;
 40 | 	  z[i][i-1] = f - g;
 41 | 	  f = 0.0;
 42 | 	  for ( j = 0; j <= l; j++ ) 
 43 | 	    {
 44 | 	      z[j][i] = z[i][j] / h;
 45 | 	      g = 0.0;
 46 | 	      for ( k = 0; k <= j; k++ )
 47 | 		g += z[j][k] * z[i][k];
 48 | 	      for ( k = j + 1; k <= l; k++ )
 49 | 		g += z[k][j] * z[i][k];
 50 | 	      e[j] = g / h;
 51 | 	      f += g * z[j][i];
 52 | 	    }
 53 | 	  m  = f / ( h + h );
 54 | 	  for ( j = 0; j <= l; j++ ) 
 55 | 	    {
 56 | 	      f = z[i][j];
 57 | 	      g = e[j] - m * f;
 58 | 	      e[j] = g;
 59 | 	      for ( k = 0; k <= j; k++ )
 60 | 		z[j][k] = z[j][k] 
 61 | 		  - ( f * e[k] + g * z[i][k] );
 62 | 	    }
 63 | 	}
 64 |       d[i] = h;
 65 |     }
 66 |   d[0] = 0.0;
 67 |   e[0] = 0.0;
 68 |   for ( i = 0; i < 6; i++ ) 
 69 |     {
 70 |       l = i - 1;
 71 |       if ( d[i] != 0.0 )
 72 | 	for ( j = 0; j <= l; j++ ) 
 73 | 	  {
 74 | 	    g = 0.0;
 75 | 	    for ( k = 0; k <= l; k++ ) 
 76 | 	      g += ( z[i][k] * z[k][j] );
 77 | 	    for ( k = 0; k <= l; k++ ) 
 78 | 	      z[k][j] -= g * z[k][i];
 79 | 	  }
 80 |       d[i] = z[i][i];
 81 |       z[i][i] = 1.0;
 82 |       for ( j = 0; j <= l; j++ ) 
 83 | 	{
 84 | 	  z[i][j] = 0.0;
 85 | 	  z[j][i] = 0.0;
 86 | 	}
 87 |     }
 88 | }
 89 | 
 90 | int  tql2 ( double   z[6][6],
 91 | 	    double   d[6],
 92 | 	    double   e[6],
 93 | 	    double   eps )
 94 | {
 95 |   double h, p, r, b, c, f, g, s;
 96 |   int    L, k, m;
 97 |   int    i, j;
 98 | 
 99 |   for ( i = 1; i < 6; i++ )
100 |     e[i-1] = e[i];
101 |   e[5] = 0.0;
102 |   b = 0.0;
103 |   f = 0.0;
104 |   for ( L = 0; L < 6; L++ ) 
105 |     {
106 |       j = 0;
107 |       h = eps * ( fabs ( d[L] ) + fabs ( e[L] ) );
108 |       if ( b < h ) 
109 | 	b = h;
110 |       for ( m = L; compare_double( fabs ( e[m] ), b ) == 1 && m < 6; m++ ) ;
111 |       if ( m != L )
112 | 	do 
113 | 	  {
114 | 	    if ( j >= 30 ) 
115 | 	      return FAILURE; 
116 | 	    j++;
117 | 	    p = ( d[L+1] - d[L] ) / ( 2.0 * e[L] );
118 | 	    r = sqrt ( p * p + 1.0 );
119 | 	    if ( p < 0.0 )
120 | 	      h = p - r;
121 | 	    else
122 | 	      h = p + r;
123 | 	    h = d[L] - e[L] / h;
124 | 	    for ( i = L; i < 6; i++ )
125 | 	      d[i] -= h;
126 | 	    f += h;
127 | 	    p = d[m];
128 | 	    c = 1.0;
129 | 	    s = 0.0;
130 | 	    for ( i = m - 1; i >= L; i-- ) 
131 | 	      {
132 | 		g = c * e[i];
133 | 		h = c * p;
134 | 		if ( fabs ( p ) >= fabs ( e[i] ) ) 
135 | 		  {
136 | 		    c = e[i] / p;
137 | 		    r = sqrt ( c * c + 1.0 );
138 | 		    e[i+1] = s * p * r;
139 | 		    s = c / r;
140 | 		    c = 1.0 / r;
141 | 		  }
142 | 		else 
143 | 		  {
144 | 		    c = p / e[i];
145 | 		    r = sqrt ( c * c + 1.0 );
146 | 		    e[i+1] = s * e[i] * r;
147 | 		    s = 1.0 / r;
148 | 		    c *= s;
149 | 		  }
150 | 		p = c * d[i] - s * g;
151 | 		d[i+1] = h + s * ( c * g + s * d[i] );
152 | 		for ( k = 0; k < 6; k++ ) 
153 | 		  {
154 | 		    h = z[k][i+1];
155 | 		    z[k][i+1] = s * z[k][i] + c * h;
156 | 		    z[k][i] = c * z[k][i] - s * h;
157 | 		  }
158 | 	      }
159 | 	    e[L] = s * p;
160 | 	    d[L] = c * p;
161 | 	  } 
162 | 	while ( compare_double( fabs ( e[L] ), b ) == 1 );
163 |       d[L] += f;
164 |     }
165 |   for ( i = 0; i < 6; i++ ) 
166 |     {
167 |       k = i;
168 |       p = d[i];
169 |       for ( j = i + 1; j < 6; j++ )
170 | 	if ( d[j] < p ) 
171 | 	  {
172 | 	    k = j;
173 | 	    p = d[j];
174 | 	  }
175 |       if ( k != i ) 
176 | 	{
177 | 	  d[k] = d[i];
178 | 	  d[i] = p;
179 | 	  for ( j = 0; j < 6; j++ ) 
180 | 	    {
181 | 	      p = z[j][i];
182 | 	      z[j][i] = z[j][k];
183 | 	      z[j][k] = p;
184 | 	    }
185 | 	}
186 |     }
187 |   return SUCCESS;
188 | }
189 |  
190 | int  eigen ( double a[6][6],
191 | 	     double b[6][6],
192 | 	     double c[6] )	
193 | 
194 | {
195 |   double e[6];
196 | 
197 |   tred2 ( a, b, c, e, 1.0 / HG );
198 |   if ( tql2 ( b, c, e, 1.0E-20 ) == FAILURE )
199 |     return FAILURE;
200 |   return SUCCESS;
201 | }
202 | 
203 | 


--------------------------------------------------------------------------------
/src/hbind/inc/sf_weights.h:
--------------------------------------------------------------------------------
  1 | /* This file puts organizes the weights of various scoring function
  2 |  * into 2-dimensional arrays, so switching between scoring functions become easy at compile time
  3 |  * Sameer - 17/May/2005
  4 |  */
  5 | 
  6 | #ifndef _SF_WEIGHTS_H_
  7 | #define _SF_WEIGHTS_H_
  8 | 
  9 | 
 10 | #define NO_OF_SCORING_FUNCTIONS 68
 11 | #define MAX_SCORING_FUNC_TERMS 8
 12 | 
 13 | #define REGRESSION_CONST 	0
 14 | /* Added TERM_0 so that the constant could be printed in the output - toneroma 22MAR2006*/
 15 | #define TERM_0 0
 16 | #define TERM_1 1
 17 | #define TERM_2 2
 18 | #define TERM_3 3
 19 | #define TERM_4 4
 20 | #define TERM_5 5
 21 | #define TERM_6 6
 22 | #define TERM_7 7
 23 | 
 24 | 
 25 | 
 26 | /* Weights form multiple-regression training, testing against AFFINITY */
 27 | static float affinity_wts[NO_OF_SCORING_FUNCTIONS][MAX_SCORING_FUNC_TERMS ] =
 28 | {
 29 | 	{-5.972,-0.085,0.000,0.000,0.000,0.000,0.000 },
 30 | 	{-5.507,0.259,0.000,0.000,0.000,0.000,0.000 },
 31 | 	{-5.570,-1.172,0.000,0.000,0.000,0.000,0.000 },
 32 | 	{-5.217,-0.109,0.000,0.000,0.000,0.000,0.000 },
 33 | 	{-6.399,-0.253,0.000,0.000,0.000,0.000,0.000 },
 34 | 	{-6.775,-0.547,0.000,0.000,0.000,0.000,0.000 },
 35 | 	{-8.439,-0.031,0.000,0.000,0.000,0.000,0.000 },
 36 | 	{-8.414,-0.012,0.000,0.000,0.000,0.000,0.000 },
 37 | 	{-6.863,-0.276,0.000,0.000,0.000,0.000,0.000 },
 38 | 	{-7.241,-0.193,0.000,0.000,0.000,0.000,0.000 },
 39 | 	{-7.786,-0.461,0.000,0.000,0.000,0.000,0.000 },
 40 | 	{-7.718,-0.704,0.000,0.000,0.000,0.000,0.000 },
 41 | 	{-8.297,-0.196,0.000,0.000,0.000,0.000,0.000 },
 42 | 	{-8.858,0.431,0.000,0.000,0.000,0.000,0.000 },
 43 | 	{-5.486,-0.111,0.000,0.000,0.000,0.000,0.000 },
 44 | 	{-8.293,-0.132,0.000,0.000,0.000,0.000,0.000 },
 45 | 	{-6.812,-0.125,0.000,0.000,0.000,0.000,0.000 },
 46 | 	{-5.717,-0.100,0.000,0.000,0.000,0.000,0.000 },
 47 | 	{-5.435,-0.053,0.000,0.000,0.000,0.000,0.000 },
 48 | 	{-5.804,0.752,0.000,0.000,0.000,0.000,0.000 },
 49 | 	{-6.194,-0.097,0.000,0.000,0.000,0.000,0.000 },
 50 | 	{-6.707,-0.163,0.000,0.000,0.000,0.000,0.000 },
 51 | 	{-5.506,-0.100,0.263,0.169,0.000,0.000,0.000 },
 52 | 	{-5.529,-0.123,0.259,0.146,0.000,0.000,0.000 },
 53 | 	{-4.467,-0.040,-0.101,0.179,0.000,0.000,0.000 },
 54 | 	{-4.751,-0.734,-0.064,0.000,0.000,0.000,0.000 }, /* orientation score - Func # 26 */
 55 | 	{-4.666,-0.846,-0.035,-0.117,0.000,0.000,0.000 },
 56 | 	{-4.724,-0.812,-0.039,-0.078,0.000,0.000,0.000 },
 57 | 	{-4.299,0.314,-0.199,-0.147,0.052,-0.011,0.020 },
 58 | 	{-4.323,0.300,-0.167,-0.126,0.067,-0.003,0.000 },
 59 | 	{-4.220,0.258,-0.164,-0.117,0.010,0.000,0.000 },
 60 | 	{-4.206,0.305,-0.179,-0.002,0.030,0.000,0.000 },
 61 | 	{-4.211,0.306,-0.179,0.031,0.000,0.000,0.000 },
 62 | 	{-4.756,0.222,-0.156,-0.010,0.000,0.000,0.000 },
 63 | 	{-4.833,0.230,-0.175,0.000,0.000,0.000,0.000 },
 64 | 	{-5.690,-0.161,-0.020,0.179,0.000,0.000,0.000 },
 65 | 	{-5.853,-0.204,-0.095,0.156,0.080,0.000,0.000 },
 66 | 	{-5.673,-0.166,-0.019,0.180,0.094,0.000,0.000 },
 67 | 	{-4.012,-0.062,-0.197,-0.143,0.050,-0.029,0.008 },
 68 | 	{-4.027,-0.061,-0.184,-0.134,0.057,-0.025,0.000 },
 69 | 	{-3.964,-0.053,-0.179,-0.126,-0.011,0.000,0.000 },
 70 | 	{-3.928,-0.060,-0.176,-0.020,0.019,0.000,0.000 },
 71 | 	{-3.940,-0.056,-0.149,-0.009,0.000,0.000,0.000 },
 72 | 	{-3.936,-0.060,-0.175,0.018,0.000,0.000,0.000 },
 73 | 	{-4.538,-0.044,-0.154,-0.019,0.000,0.000,0.000 },
 74 | 	{-4.668,-0.047,-0.190,0.000,0.000,0.000,0.000 },
 75 | 	{-4.015,-0.063,-0.156,0.057,0.000,0.000,0.000 },
 76 | 	{-4.009,-0.063,-0.156,0.057,0.000,0.000,0.000 },
 77 | 	{-4.005,-0.063,-0.156,0.058,-0.023,0.000,0.000 },
 78 | 	{-4.087,0.267,-0.158,-0.732,-0.091,0.000,0.000 },
 79 | 	{-3.828,-0.056,-0.174,-0.723,-0.102,0.000,0.000 },
 80 | 	{-4.232,0.256,-0.164,-0.115,0.000,0.000,0.000 },
 81 | 	{-3.975,-0.054,-0.179,-0.125,0.000,0.000,0.000 },
 82 | 	{-5.103,0.726,-0.089,-0.088,0.000,0.000,0.000 },
 83 | 	{-5.101,0.743,-0.087,-0.092,0.048,0.000,0.000 },
 84 | 	{-5.599,1.033,-0.148,0.070,0.052,0.000,0.000 },
 85 | 	{-4.045,-0.069,-0.605,-0.122,-0.204,0.150,0.000 },
 86 | 	{-5.543,0.894,-0.493,-0.047,-0.214,0.154,0.000 },
 87 | 	{-4.071,-0.069,-0.600,-0.117,-0.198,0.154,-0.009 },
 88 | 	{-5.076,-0.115,-0.390,-0.118,-0.316,0.118,0.000 },
 89 | 	{-4.916,-0.124,-0.379,-0.143,-0.337,0.095,0.040 },
 90 | 	{-5.676,0.940,-0.070,0.150,0.000,0.000,0.000 },  /* affinity scoring function # 62*/
 91 | 	{-5.218,-0.239,-0.083,0.134,0.000,0.000,0.000 },  /* affinity scoring function # 64*/
 92 | 	{-3.917,-0.061,-0.023,-0.189,0.000,0.000,0.000 },  /* orientation scoring function # 99*/
 93 | 	{-3.407,-0.148,-0.037,-0.079,0.174,0.000,0.000 },  /* affinity scoring function # 100*/
 94 | 	{-3.712,-0.057,-0.031,-0.177,0.000,0.000,0.000 },   /* combo scoring function # 99*/
 95 | 	{-3.697,-0.047,-0.043,-0.126,0.000,0.000,0.000 },   /* affinity scoring function # 99*/
 96 | 	{-878.816,-45.329,-26.456,-110.823,71.603,0.000,0.000 }   /* conformer scoring function # 116*/
 97 | 
 98 | };
 99 | 
100 | #endif
101 | 


--------------------------------------------------------------------------------
/docs/readthedocs/css/theme_extra.css:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Sphinx doesn't have support for section dividers like we do in
  3 |  * MkDocs, this styles the section titles in the nav
  4 |  *
  5 |  * https://github.com/mkdocs/mkdocs/issues/175
  6 |  */
  7 | .wy-menu-vertical span {
  8 |     line-height: 18px;
  9 |     padding: 0.4045em 1.618em;
 10 |     display: block;
 11 |     position: relative;
 12 |     font-size: 90%;
 13 |     color: #838383;
 14 | }
 15 | 
 16 | .wy-menu-vertical .subnav a {
 17 |     padding: 0.4045em 2.427em;
 18 | }
 19 | 
 20 | /*
 21 |  * Long navigations run off the bottom of the screen as the nav
 22 |  * area doesn't scroll.
 23 |  *
 24 |  * https://github.com/mkdocs/mkdocs/pull/202
 25 |  *
 26 |  * Builds upon pull 202 https://github.com/mkdocs/mkdocs/pull/202
 27 |  * to make toc scrollbar end before navigations buttons to not be overlapping.
 28 |  */
 29 | .wy-nav-side {
 30 |     height: calc(100% - 45px);
 31 |     overflow-y: auto;
 32 |     min-height: 0;
 33 | }
 34 | 
 35 | .rst-versions{
 36 |     border-top: 0;
 37 |     height: 45px;
 38 | }
 39 | 
 40 | @media screen and (max-width: 768px) {
 41 |     .wy-nav-side {
 42 |         height: 100%;
 43 |     }
 44 | }
 45 | 
 46 | /*
 47 |  * readthedocs theme hides nav items when the window height is
 48 |  * too small to contain them.
 49 |  *
 50 |  * https://github.com/mkdocs/mkdocs/issues/#348
 51 |  */
 52 | .wy-menu-vertical ul {
 53 |   margin-bottom: 2em;
 54 | }
 55 | 
 56 | /*
 57 |  * Wrap inline code samples otherwise they shoot of the side and
 58 |  * can't be read at all.
 59 |  *
 60 |  * https://github.com/mkdocs/mkdocs/issues/313
 61 |  * https://github.com/mkdocs/mkdocs/issues/233
 62 |  * https://github.com/mkdocs/mkdocs/issues/834
 63 |  */
 64 | code {
 65 |     white-space: pre-wrap;
 66 |     word-wrap: break-word;
 67 |     padding: 2px 5px;
 68 | }
 69 | 
 70 | /**
 71 |  * Make code blocks display as blocks and give them the appropriate
 72 |  * font size and padding.
 73 |  *
 74 |  * https://github.com/mkdocs/mkdocs/issues/855
 75 |  * https://github.com/mkdocs/mkdocs/issues/834
 76 |  * https://github.com/mkdocs/mkdocs/issues/233
 77 |  */
 78 | pre code {
 79 |   white-space: pre;
 80 |   word-wrap: normal;
 81 |   display: block;
 82 |   padding: 12px;
 83 |   font-size: 12px;
 84 | }
 85 | 
 86 | /*
 87 |  * Fix link colors when the link text is inline code.
 88 |  *
 89 |  * https://github.com/mkdocs/mkdocs/issues/718
 90 |  */
 91 | a code {
 92 |     color: #2980B9;
 93 | }
 94 | a:hover code {
 95 |     color: #3091d1;
 96 | }
 97 | a:visited code {
 98 |     color: #9B59B6;
 99 | }
100 | 
101 | /*
102 |  * The CSS classes from highlight.js seem to clash with the
103 |  * ReadTheDocs theme causing some code to be incorrectly made
104 |  * bold and italic.
105 |  *
106 |  * https://github.com/mkdocs/mkdocs/issues/411
107 |  */
108 | pre .cs, pre .c {
109 |     font-weight: inherit;
110 |     font-style: inherit;
111 | }
112 | 
113 | /*
114 |  * Fix some issues with the theme and non-highlighted code
115 |  * samples. Without and highlighting styles attached the
116 |  * formatting is broken.
117 |  *
118 |  * https://github.com/mkdocs/mkdocs/issues/319
119 |  */
120 | .no-highlight {
121 |   display: block;
122 |   padding: 0.5em;
123 |   color: #333;
124 | }
125 | 
126 | 
127 | /*
128 |  * Additions specific to the search functionality provided by MkDocs
129 |  */
130 | 
131 | .search-results article {
132 |     margin-top: 23px;
133 |     border-top: 1px solid #E1E4E5;
134 |     padding-top: 24px;
135 | }
136 | 
137 | .search-results article:first-child {
138 |     border-top: none;
139 | }
140 | 
141 | form .search-query {
142 |     width: 100%;
143 |     border-radius: 50px;
144 |     padding: 6px 12px;  /* csslint allow: box-model */
145 |     border-color: #D1D4D5;
146 | }
147 | 
148 | .wy-menu-vertical li ul {
149 |     display: inherit;
150 | }
151 | 
152 | .wy-menu-vertical li ul.subnav ul.subnav{
153 |     padding-left: 1em;
154 | }
155 | 
156 | .wy-menu-vertical .subnav li.current > a {
157 |     padding-left: 2.42em;
158 | }
159 | .wy-menu-vertical .subnav li.current > ul li a {
160 |     padding-left: 3.23em;
161 | }
162 | 
163 | /*
164 |  * Improve inline code blocks within admonitions.
165 |  *
166 |  * https://github.com/mkdocs/mkdocs/issues/656
167 |  */
168 |  .admonition code {
169 |   color: #404040;
170 |   border: 1px solid #c7c9cb;
171 |   border: 1px solid rgba(0, 0, 0, 0.2);
172 |   background: #f8fbfd;
173 |   background: rgba(255, 255, 255, 0.7);
174 | }
175 | 
176 | /*
177 |  * Account for wide tables which go off the side.
178 |  * Override borders to avoid wierdness on narrow tables.
179 |  *
180 |  * https://github.com/mkdocs/mkdocs/issues/834
181 |  * https://github.com/mkdocs/mkdocs/pull/1034
182 |  */
183 | .rst-content .section .docutils {
184 |     width: 100%;
185 |     overflow: auto;
186 |     display: block;
187 |     border: none;
188 | }
189 | 
190 | td, th {
191 |    border: 1px solid #e1e4e5 !important; /* csslint allow: important */
192 |    border-collapse: collapse;
193 | }
194 | 
195 | 


--------------------------------------------------------------------------------
/src/hbind/find_flexible_bonds.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <string.h>
  3 | #include "types.h"
  4 | #include "check_rule.h"
  5 | #include "err_handle.h"
  6 | 
  7 | /*  This function checks, if the bond connecting 'atom1' and 'atom2'
  8 |  *  might be a flexible bond based on the rules for the adjacent
  9 |  *  atoms to a flexible bond. If the atoms match, the number returned
 10 |  *  depends on the order: if atom1 matches atom[0] in the rule and
 11 |  *  atom2 matches atom[1], then rule_number+1 is returned, if atom1
 12 |  *  matches atom[1] and atom2 matches atom[0] then -1*(rule_number+1)
 13 |  *  is returned, if the bond is not rotatable, then 0 is returned.
 14 |  */
 15 | int  check_bond_atoms ( flex_bond_defn_pt  rules,
 16 | 			int                number_of_rules,
 17 | 			atom_pt            atom1,
 18 | 			atom_pt            atom2 )
 19 | {
 20 |   int  rule_type1,
 21 |        rule_orbit1,
 22 |        rule_type2,
 23 |        rule_orbit2;
 24 |   int  i;
 25 |   
 26 |   i = number_of_rules;
 27 |   /*  for ( i = 0; i < number_of_rules; i++ )
 28 |       {*/
 29 |       rule_type1 = rules[i].atom[0].type;
 30 |       rule_orbit1 = rules[i].atom[0].orbit;
 31 |       rule_type2 = rules[i].atom[1].type;
 32 |       rule_orbit2 = rules[i].atom[1].orbit;
 33 |       if ( ( rule_type1 == atom1->type
 34 | 	     || rule_type1 == ANY )
 35 | 	   && ( rule_orbit1 == atom1->orbit
 36 | 		|| rule_orbit1 == ANY )
 37 | 	   && ( rule_type2 == atom2->type
 38 | 		|| rule_type2 == ANY )
 39 | 	   && ( rule_orbit2 == atom2->orbit
 40 | 		|| rule_orbit2 == ANY ) )
 41 | 	return i+1;
 42 |       if ( ( rule_type2 == atom1->type
 43 | 	     || rule_type2 == ANY )
 44 | 	   && ( rule_orbit2 == atom1->orbit
 45 | 		|| rule_orbit2 == ANY )
 46 | 	   && ( rule_type1 == atom2->type
 47 | 		|| rule_type1 == ANY )
 48 | 	   && ( rule_orbit1 == atom2->orbit
 49 | 		|| rule_orbit1 == ANY ) )
 50 | 	return (-1) * (i+1);
 51 | 
 52 |   return 0;
 53 | }
 54 | 
 55 | int find_flexible_bonds(molecule_pt molecule, flex_bond_defn_pt flex_bond_rules,
 56 |                         int number_of_rules)
 57 | {
 58 |   rule_pt  bond1,
 59 |            bond2;
 60 |   int      rule,
 61 |            atom1,
 62 |            atom2,
 63 |            result1,
 64 |            result2,
 65 |            bond_flex;
 66 |   int      i, j, k;
 67 |   int      rule_used;
 68 |   
 69 |   
 70 |   molecule->number_of_flexible_bonds = 0;
 71 |   for( i = 0; i < molecule->number_of_bonds; i++ ){
 72 |     if( molecule->bonds[i].type != SINGLE) continue;
 73 | 
 74 |     rule_used = 99;
 75 |     /* check if the atoms match one of the rules */
 76 |     for ( k = 0; k < number_of_rules; k++ ){
 77 | 
 78 |       rule = check_bond_atoms(flex_bond_rules, k,
 79 |                               &molecule->atoms[molecule->bonds[i].atom1],
 80 |                               &molecule->atoms[molecule->bonds[i].atom2] );
 81 |       if ( rule == 0) continue;
 82 |       if ( rule > 0 ){ 
 83 |         atom1 = molecule->bonds[i].atom1;
 84 |         atom2 = molecule->bonds[i].atom2;
 85 |       }else{
 86 |         atom1 = molecule->bonds[i].atom2;
 87 |         atom2 = molecule->bonds[i].atom1;
 88 |         rule *= -1;
 89 |       }
 90 | 	      
 91 |       result1 = SUCCESS;
 92 |       result2 = SUCCESS;
 93 |       bond1 = &flex_bond_rules[rule-1].atom[0];
 94 |       bond2 = &flex_bond_rules[rule-1].atom[1];
 95 |       bond_flex = flex_bond_rules[rule-1].flex;
 96 |       for(j = 0; j < MAX_RULES_PER_BONDED_ATOM && result1 == SUCCESS; j++ )
 97 |         if ( bond1->prohibited[j] != NULL )
 98 |           result1 = check_prohibited_rule(molecule, atom1, atom2, 
 99 |                                           bond1->prohibited[j] );
100 |       for(j = 0; j < MAX_RULES_PER_BONDED_ATOM && result1 == SUCCESS; j++ )
101 |         if(bond1->required[j] != NULL )
102 |           result1 = check_required_rule(molecule, atom1, atom2, 
103 |                                         bond1->required[j] );
104 |       for ( j = 0; j < MAX_RULES_PER_BONDED_ATOM && result2 == SUCCESS; j++ )
105 |         if ( bond2->prohibited[j] != NULL )
106 |           result2 = check_prohibited_rule(molecule, atom2, atom1,
107 |                                           bond2->prohibited[j] );
108 |       for ( j = 0; j < MAX_RULES_PER_BONDED_ATOM && result2 == SUCCESS; j++ )
109 |         if ( bond2->required[j] != NULL ) 
110 |           result2 = check_required_rule(molecule, atom2, atom1, 
111 |                                         bond2->required[j] );
112 | 
113 |       if ( result1 == SUCCESS && result2 == SUCCESS ){
114 |         rule_used = rule;
115 |         if (bond_flex == FLEX ) molecule->bonds[i].type = FLEX;
116 |         if (bond_flex == RIGID ) molecule->bonds[i].type = RIGID;
117 |       }
118 |     }
119 |     if(molecule->bonds[i].type == FLEX)
120 |       molecule->flexible_bonds[molecule->number_of_flexible_bonds++] = i;
121 | 
122 |     
123 |     if(molecule->number_of_flexible_bonds > MAX_NUMBER_OF_FLEXIBLE_BONDS ){
124 |       err_warning2("find_flexible_bonds",
125 |                    "more than MAX_NUMBER_OF_FLEXIBLE_BONDS flexible bonds");
126 |       return FAILURE;
127 |     }
128 |   }
129 |   molecule->number_of_fragments = molecule->number_of_flexible_bonds + 1;
130 |   return SUCCESS;
131 | }
132 | 


--------------------------------------------------------------------------------
/docs/readthedocs/base.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
  3 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
  4 | <head>
  5 |   {%- block site_meta %}
  6 |   <meta charset="utf-8">
  7 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
  8 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  9 |   {% if page and page.is_homepage %}<meta name="description" content="{{ config.site_description }}">{% endif %}
 10 |   {% if config.site_author %}<meta name="author" content="{{ config.site_author }}">{% endif %}
 11 |   {% if config.site_favicon %}<link rel="shortcut icon" href="{{ base_url }}/{{ config.site_favicon }}">
 12 |   {% else %}<link rel="shortcut icon" href="{{ base_url }}/img/favicon.ico">{% endif %}
 13 |   {%- endblock %}
 14 | 
 15 |   {%- block htmltitle %}
 16 |   <title>{% if page and page.title and not page.is_hompage %}{{ page.title }} - {% endif %}{{ config.site_name }}</title>
 17 |   {%- endblock %}
 18 | 
 19 |   {%- block styles %}
 20 |   <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>
 21 | 
 22 |   <link rel="stylesheet" href="{{ base_url }}/css/theme.css" type="text/css" />
 23 |   <link rel="stylesheet" href="{{ base_url }}/css/theme_extra.css" type="text/css" />
 24 |   <link rel="stylesheet" href="{{ base_url }}/css/highlight.css">
 25 |   {%- for path in extra_css %}
 26 |   <link href="{{ path }}" rel="stylesheet">
 27 |   {%- endfor %}
 28 |   {%- endblock %}
 29 | 
 30 |   {%- block libs %}
 31 |   {% if page %}
 32 |   <script>
 33 |     // Current page data
 34 |     var mkdocs_page_name = {{ page.title|tojson|safe }};
 35 |     var mkdocs_page_input_path = {{ page.input_path|tojson|safe }};
 36 |     var mkdocs_page_url = {{ page.abs_url|tojson|safe }};
 37 |   </script>
 38 |   {% endif %}
 39 |   <script src="{{ base_url }}/js/jquery-2.1.1.min.js"></script>
 40 |   <script src="{{ base_url }}/js/modernizr-2.8.3.min.js"></script>
 41 |   <script type="text/javascript" src="{{ base_url }}/js/highlight.pack.js"></script>
 42 |   {%- endblock %}
 43 | 
 44 |   {%- block extrahead %} {% endblock %}
 45 | 
 46 |   {%- block analytics %}
 47 |   {% if config.google_analytics %}
 48 |   <script>
 49 |       (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
 50 |       (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
 51 |       m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 52 |       })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
 53 | 
 54 |       ga('create', '{{ config.google_analytics[0] }}', '{{ config.google_analytics[1] }}');
 55 |       ga('send', 'pageview');
 56 |   </script>
 57 |   {% endif %}
 58 |   {%- endblock %}
 59 | </head>
 60 | 
 61 | <body class="wy-body-for-nav" role="document">
 62 | 
 63 |   <div class="wy-grid-for-nav">
 64 | 
 65 |     {# SIDE NAV, TOGGLES ON MOBILE #}
 66 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side stickynav">
 67 |       <div class="wy-side-nav-search">
 68 |     {%- block site_name %}
 69 |         <a href="{{ nav.homepage.url }}" class="icon icon-home"> {{ config.site_name }}</a>
 70 | 	  {%- endblock %}
 71 | 	  {%- block search_button %}
 72 |         {% if 'search' in config['plugins'] %}{% include "searchbox.html" %}{% endif %}
 73 | 	  {%- endblock %}
 74 |       </div>
 75 | 
 76 |       <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 77 |         {%- block site_nav %}
 78 | 	<ul class="current">
 79 | 	  {% set navlevel = 1 %}
 80 |           {% for nav_item in nav %}
 81 |             <li class="toctree-l{{ navlevel }}{% if nav_item.active and not nav_item.children %} current{%endif%}">
 82 | 		{% include 'nav.html' %}
 83 | 	    </li>
 84 |           {% endfor %}
 85 |         </ul>
 86 |     {%- endblock %}
 87 |       </div>
 88 |       &nbsp;
 89 |     </nav>
 90 | 
 91 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
 92 | 
 93 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
 94 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
 95 |         <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
 96 |         <a href="{{ nav.homepage.url }}">{{ config.site_name }}</a>
 97 |       </nav>
 98 | 
 99 |       {# PAGE CONTENT #}
100 |       <div class="wy-nav-content">
101 |         <div class="rst-content">
102 |           {% include "breadcrumbs.html" %}
103 |           <div role="main">
104 |             <div class="section">
105 |               {% block content %}
106 |                 {{ page.content }}
107 |               {% endblock %}
108 |             </div>
109 |           </div>
110 |       {%- block footer %}
111 |           {% include "footer.html" %}
112 |       {% endblock %}
113 |         </div>
114 |       </div>
115 | 
116 |     </section>
117 | 
118 |   </div>
119 | 
120 |   {% include "versions.html" %}
121 | 
122 |   {%- block scripts %}
123 |     <script>var base_url = '{{ base_url }}';</script>
124 |     <script src="{{ base_url }}/js/theme.js"></script>
125 |     {%- for path in extra_javascript %}
126 |       <script src="{{ path }}"></script>
127 |     {%- endfor %}
128 |   {%- endblock %}
129 | 
130 | </body>
131 | </html>
132 | {% if page and page.is_homepage %}
133 | <!--
134 | MkDocs version : {{ mkdocs_version }}
135 | Build Date UTC : {{ build_date_utc }}
136 | -->
137 | {% endif %}
138 | 


--------------------------------------------------------------------------------
/install_hbind.pl:
--------------------------------------------------------------------------------
  1 | unlink "./src/hbind/main.o";
  2 | unlink "./src/hbind/screen_single_compounds.o";
  3 | unlink "./src/hbind/read_pts_file.o";
  4 | unlink "./src/hbind/mean_field_minimization.o";
  5 | unlink "./src/hbind/read_parameter_file.o";
  6 | unlink "./src/hbind/match_triangles.o";
  7 | unlink "./src/hbind/distance_array.o";
  8 | unlink "./src/hbind/check_connectivity.o";
  9 | unlink "./src/hbind/find_flexible_bonds.o";
 10 | unlink "./src/hbind/read_rule.o";
 11 | unlink "./src/hbind/read_waters.o";
 12 | unlink "./src/hbind/print_interaction.o";
 13 | unlink "./src/hbind/check_complementarity.o";
 14 | unlink "./src/hbind/quicksort.o";
 15 | unlink "./src/hbind/docking_features.o";
 16 | unlink "./src/hbind/transform_molecule.o";
 17 | unlink "./src/hbind/intra_hbonds.o";
 18 | unlink "./src/hbind/find_hyd_atoms.o";
 19 | unlink "./src/hbind/check_rule.o";
 20 | unlink "./src/hbind/rotate_unbump_bonds.o";
 21 | unlink "./src/hbind/unbump_anchor.o";
 22 | unlink "./src/hbind/read_flex_defn.o";
 23 | unlink "./src/hbind/least_square_fit.o";
 24 | unlink "./src/hbind/read_template.o";
 25 | unlink "./src/hbind/intra_bump_check.o";
 26 | unlink "./src/hbind/insertion_sort.o";
 27 | unlink "./src/hbind/unbump_translate.o";
 28 | unlink "./src/hbind/write_log_file.o";
 29 | unlink "./src/hbind/read_pdb.o";
 30 | unlink "./src/hbind/compute_target_angles.o";
 31 | unlink "./src/hbind/main_score.o";
 32 | unlink "./src/hbind/hbind_score.o";
 33 | unlink "./src/hbind/analyze_ligand.o";
 34 | unlink "./src/hbind/write_waters_pdb.o";
 35 | unlink "./src/hbind/number_ligand_atoms.o";
 36 | unlink "./src/hbind/initialize_unbump_matrices.o";
 37 | unlink "./src/hbind/intra_hbonds_flag.o";
 38 | unlink "./src/hbind/trace.o";
 39 | unlink "./src/hbind/sum_charges.o";
 40 | unlink "./src/hbind/read_hyd_defn.o";
 41 | unlink "./src/hbind/distance_matrices.o";
 42 | unlink "./src/hbind/bump_check.o";
 43 | unlink "./src/hbind/rotate.o";
 44 | unlink "./src/hbind/find_all_bumps.o";
 45 | unlink "./src/hbind/compute_all_rotation_angles.o";
 46 | unlink "./src/hbind/bitstrings.o";
 47 | unlink "./src/hbind/count_flexible_bonds.o";
 48 | unlink "./src/hbind/initialize.o";
 49 | unlink "./src/hbind/write_target_pdb.o";
 50 | unlink "./src/hbind/assign_hydrogens.o";
 51 | unlink "./src/hbind/eigen.o";		
 52 | unlink "./src/hbind/unbump_side_chains.o";
 53 | unlink "./src/hbind/compute_ligand_angles.o";
 54 | unlink "./src/hbind/calc_score_from_terms.o";
 55 | unlink "./src/hbind/assign_type.o";
 56 | unlink "./src/hbind/hashing.o";
 57 | unlink "./src/hbind/assign_fragments.o";
 58 | unlink "./src/hbind/score_complex.o";
 59 | unlink "./src/hbind/find_carbon_ring_centers.o";
 60 | unlink "./src/hbind/debug_funs.o";
 61 | unlink "./src/hbind/adj_list.o";
 62 | unlink "./src/hbind/hbond_check.o";
 63 | unlink "./src/hbind/dist_fun.o";
 64 | unlink "./src/hbind/compute_unbump_dependencies.o";
 65 | unlink "./src/hbind/read_mol2.o";
 66 | unlink "./src/hbind/find_cycles.o";
 67 | unlink "./src/hbind/trans_rotate.o";
 68 | unlink "./src/hbind/write_ligand_mol2.o";
 69 | unlink "./src/utils/hbind_itimer.o";
 70 | unlink "./src/utils/err_handle.o";
 71 | unlink "./src/utils/basics.o";
 72 | unlink "./bin/hbind";
 73 | 
 74 | 
 75 | $hbind_dir = '.';
 76 | $perl = $^X;
 77 | 
 78 | mkdir "$hbind_dir";
 79 | mkdir "$hbind_dir/bin";
 80 | 
 81 | # unpack the Perl scripts and change the path to the perl binary
 82 | open IN, "$hbind_dir/src/scripts/perl_scripts";
 83 | print "\n*** extracting Perl scripts ***\n";
 84 | while ( <IN> )
 85 | {
 86 |     if ( /^____FILE\_START/ )
 87 |     {
 88 | 	chop;
 89 | 	# grep the name of packed Perl script
 90 | 	@line = split;
 91 | 	$file = "$hbind_dir/bin/$line[1]";
 92 | 	open OUT, ">$file";
 93 | 	# read the line that includes the path to the Perl binary
 94 | 	$_ = <IN>;
 95 | 	print OUT "\#\!$perl\n";
 96 | 	next;
 97 |     }
 98 |     if ( /^____FILE\_END/ )
 99 |     {
100 | 	# end of this script, close filehandle and change permissions
101 | 	close OUT;
102 | 	chmod 0755, "$file";
103 | 	next;
104 |     }
105 |     print OUT $_;
106 | }
107 | close IN;
108 | 
109 | # unpack the shell scripts
110 | open IN, "$hbind_dir/src/scripts/shell_scripts";
111 | print "\n*** extracting Shell scripts ***\n";
112 | while ( <IN> )
113 | {
114 |     if ( /^____FILE\_START/ )
115 |     {
116 | 	chop;
117 | 	# grep the name of packed Perl script
118 | 	@line = split;
119 | 	$file = "$hbind_dir/bin/$line[1]";
120 | 	open OUT, ">$file";
121 | 	next;
122 |     }
123 |     if ( /^____FILE\_END/ )
124 |     {
125 | 	# end of this script, close filehandle and change permissions
126 | 	close OUT;
127 | 	chmod 0755, "$file";
128 | 	next;
129 |     }
130 |     print OUT $_;
131 | }
132 | close IN;
133 | 
134 | # compile the libHBIND_utils first since the other programs will need to
135 | # link to it
136 | chdir "src/utils";
137 | print "\n*** compiling the static hbind utilties library ***\n\n";
138 | system "make";
139 | 
140 | # compile HBIND
141 | chdir "../hbind";
142 | print "\n*** compiling HBIND ***\n\n";
143 | system "make";
144 | # compile compute_interaction_centers, check_connectivity, and
145 | # generate_rasmol_script
146 | chdir "../interactions";
147 | print "\n*** compiling interactions auxiliaries ***\n\n";
148 | system "make";
149 | # compile average_template and unbiased_template
150 | chdir "../template";
151 | print "\n*** compiling template auxiliaries ***\n\n";
152 | system "make";
153 | print "\n*** HBIND installation completed ***\n";
154 | print "\n\n*** Please see license.txt for licensing and use information ***\n\n";
155 | 


--------------------------------------------------------------------------------
/src/utils/err_handle.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <string.h>
  4 | #include <basics.h>
  5 | #include <err_handle.h>
  6 | 
  7 | static char err_fname[FILENAME_MAX + 1];
  8 | static size_t err_fname_len = 0;
  9 | 
 10 | 
 11 | 
 12 | void set_err_filename(char *fname)
 13 | {
 14 |   if(strlen(fname) > FILENAME_MAX)
 15 |     err_panic("set_err_filename", "Path to error file is too long"); 
 16 |   strcpy(err_fname, fname);
 17 |   err_fname_len = strlen(fname);
 18 | }
 19 | 
 20 | void err_print(char *message)
 21 | { 
 22 |   FILE *log_fp = stderr;
 23 |   if(err_fname_len) log_fp = hbind_fopen(err_fname,"a+");
 24 |   if(log_fp){
 25 |     fprintf ( log_fp, message );
 26 |     if(err_fname_len) fclose(log_fp);
 27 |   }
 28 | }
 29 | 
 30 | void err_panic(char  *function, char  *message)
 31 | {
 32 |   fprintf(stdout, stderr, "FATAL ERROR: %s (%s)\n", message, function );
 33 |   exit(EXIT_FAILURE);
 34 | }
 35 | 
 36 | void err_panic2(char  *function, char  *message)
 37 | {
 38 |   FILE *log_fp;
 39 |   if(err_fname_len){
 40 |     log_fp = hbind_fopen(err_fname,"a+");
 41 |     if(log_fp){
 42 |       fprintf(log_fp, "FATAL ERROR: %s (%s)\n", message, function );
 43 |       fclose(log_fp);
 44 |     }
 45 |   }
 46 |   fprintf(stderr, "FATAL ERROR: %s (%s)\n", message, function );
 47 |   exit ( EXIT_FAILURE);
 48 | }
 49 | 
 50 | void err_error( char  *function, char  *message )
 51 | {
 52 |   fprintf ( stderr, "ERROR: %s (%s)\n", message, function );
 53 |   printf ( "ERROR: %s (%s) -- Please see err file\n", message, function );
 54 | }
 55 | 
 56 | void err_error2(char  *function, char  *message)
 57 | {
 58 |   FILE *log_fp;
 59 |   if(err_fname_len){
 60 |     log_fp = hbind_fopen(err_fname,"a+");
 61 |     if(log_fp){
 62 |       fprintf ( log_fp, "ERROR: %s (%s)\n", message, function );
 63 |       fclose(log_fp);
 64 |     }
 65 |   }
 66 |   fprintf ( stderr, "ERROR: %s (%s)\n", message, function );
 67 | }
 68 | 
 69 | void  err_warning ( char  *function, char  *message )
 70 | {
 71 |   fprintf ( stderr, "WARNING: %s (%s)\n", message, function );
 72 | }
 73 | 
 74 | void  err_warning2 ( char  *function, char  *message)
 75 | {
 76 |   FILE           *log_fp;
 77 |   if(err_fname_len){
 78 |     log_fp = hbind_fopen(err_fname,"a+");
 79 |     if(log_fp){
 80 |       fprintf ( log_fp, "WARNING: %s (%s)\n", message, function );
 81 |       fclose(log_fp);
 82 |     }
 83 |   }
 84 |   fprintf ( stderr, "WARNING: %s (%s)\n", message, function );
 85 | }
 86 | 
 87 | void err_usage(char  *message)
 88 | {
 89 |   fprintf ( stderr, "USAGE: %s\n", message );
 90 |   exit ( EXIT_FAILURE );
 91 | }
 92 | 
 93 | void  err_unknown_atom ( char  *name, char  *residue, char  *residue_num )
 94 | {
 95 |   fprintf(stdout, "ERROR: unknown atom type: %s %s %s\n", name, residue,
 96 | 	  residue_num );
 97 |   fprintf(stderr, "ERROR: unknown atom type: %s %s %s\n", name, residue,
 98 | 	  residue_num );
 99 |   /* whenever we see an unknown atom type, residue, or level in the PDB file,
100 |      HBIND exits, since this is something the user should have fixed prior
101 |      to screening */
102 |   exit ( EXIT_FAILURE );
103 | }
104 | 
105 | void err_unknown_atom2(char  *name, char  *residue, char  *residue_num)
106 | {
107 |   FILE           *log_fp;
108 |   if(err_fname_len){
109 |     log_fp = hbind_fopen(err_fname,"a+");
110 |     if(log_fp){
111 |       fprintf(log_fp, "ERROR: unknown atom type: %s %s %s\n", name, residue,
112 |               residue_num );
113 |       fclose(log_fp);
114 |     }
115 |   }
116 |   fprintf ( stdout, "ERROR: unknown atom type: %s %s %s\n", name, residue,
117 | 	    residue_num );
118 |   fprintf ( stderr, "ERROR: unknown atom type: %s %s %s\n", name, residue,
119 | 	    residue_num );
120 | 
121 |   exit ( EXIT_FAILURE );
122 | }
123 | 	    
124 | void  err_unknown_residue ( char  *residue, char  *residue_num )
125 | {
126 |   fprintf(stdout, "ERROR: unknown residue type: %s %s\n", residue, residue_num);
127 |   fprintf(stderr, "ERROR: unknown residue type: %s %s\n", residue, residue_num);
128 |   exit ( EXIT_FAILURE );
129 | }
130 | 
131 | void  err_unknown_residue2 ( char  *residue, char  *residue_num)
132 | {
133 |   FILE           *log_fp;
134 |   if(err_fname_len){
135 |     log_fp = hbind_fopen(err_fname,"a+");
136 |     if(log_fp){
137 |       fprintf(log_fp, "ERROR: unknown residue type: %s %s\n", residue, 
138 |               residue_num);
139 |       fclose(log_fp);
140 |     }
141 |   }
142 |   fprintf(stdout, "ERROR: unknown residue type: %s %s\n", residue, residue_num);
143 |   fprintf(stderr, "ERROR: unknown residue type: %s %s\n", residue, residue_num);
144 |   exit ( EXIT_FAILURE );
145 | }
146 | 
147 | void  err_unknown_level ( char  *name, char  *residue, char  *residue_num )
148 | {
149 |   fprintf ( stdout, "ERROR: unknown atom level: %s %s %s\n", name, residue,
150 | 	    residue_num );
151 |   fprintf ( stderr, "ERROR: unknown atom level: %s %s %s\n", name, residue,
152 | 	    residue_num );
153 |   exit ( EXIT_FAILURE );
154 | }  
155 | 
156 | void  err_unknown_level2 ( char  *name, char  *residue, char  *residue_num)
157 | {
158 |   FILE           *log_fp;
159 |   if(err_fname_len){
160 |     log_fp = hbind_fopen(err_fname,"a+");
161 |     if(log_fp){
162 |       fprintf(log_fp, "ERROR: unknown atom level: %s %s %s\n", name, residue,
163 | 	      residue_num );
164 |       fclose(log_fp);
165 |     }
166 |   }
167 |   fprintf ( stdout, "ERROR: unknown atom level: %s %s %s\n", name, residue,
168 | 	    residue_num );
169 |   fprintf ( stderr, "ERROR: unknown atom level: %s %s %s\n", name, residue,
170 | 	    residue_num );
171 |   exit ( EXIT_FAILURE );
172 | }  
173 | 
174 | 


--------------------------------------------------------------------------------
/src/hbind/read_template.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "read_template.h"
  3 | #include "err_handle.h"
  4 | 
  5 | /*
  6 |  *  Function 'read_template()' reads the coordinates and the types
  7 |  *  of the interaction-points from the template-file 'filename'.
  8 |  *  It returns the number of points read. If the file contains more
  9 |  *  than 'MAX_TEMPLATE_POINTS' then the function is exited via 'err_panic()'
 10 |  */
 11 | int read_template(char           *filename, global_data_pt global )
 12 | {
 13 |   FILE           *in;
 14 |   char           act[3];
 15 |   char           err_msg[FILENAME_MAX];
 16 |   char           line[MAX_TEMPLATE_LINELENGTH];
 17 |   interaction_pt inter, old_inter;
 18 |   int            number_of_points, /* this is the internal number of points */
 19 |                  number_of_read_points, /* count doneptors as single points */
 20 |                  number_of_key_points,
 21 |                  number_of_key2_points,
 22 |                  i;
 23 |   
 24 |   in = fopen ( filename, "r" );
 25 |   if ( in == NULL ) {
 26 |     perror ( "ERROR  " );
 27 |     err_panic2 ( "read_template", "unable to open file");
 28 |   }
 29 |   
 30 |   number_of_points = 0;
 31 |   number_of_key_points = 0;
 32 |   number_of_key2_points = 0;
 33 |   number_of_read_points = 0;
 34 |   inter = global->template_interactions;
 35 | 
 36 |   /* read interactions data for all interaction-points in the template */
 37 |   printf ("\nTemplate Parameters:\n");
 38 |   while ( fgets ( line, MAX_TEMPLATE_LINELENGTH, in ) != NULL ){
 39 |     if ( line[0] == '#' ){
 40 |       printf ("%s", line);
 41 |     }
 42 |     /* comment line or empty line, skip */
 43 |     if ( line[0] == '#' || line[0] == '\0' || line[0] == '\n' ) continue;
 44 |       
 45 |     /* read activity and position of this template point */
 46 |     sscanf(line, "%s %f %f %f", act, &inter->pos[X], &inter->pos[Y],
 47 |            &inter->pos[Z] );
 48 |     if ( act[1] == '*' ) {
 49 |       inter->key_point = TRUE;
 50 |       if ( act[2] == '*' ) inter->key_point = COVALENT;
 51 |       else number_of_key_points++;
 52 |       if (act[2] == '^' )
 53 | 	{
 54 | 	  inter->key2_point = TRUE;
 55 | 	  number_of_key2_points++;
 56 | 	}
 57 |     }
 58 |     else if ( act[1] == '^')
 59 |       {
 60 | 	inter->key2_point = TRUE;
 61 | 	number_of_key2_points++;
 62 | 	if (act[2] == '*' )
 63 | 	  {
 64 | 	    inter->key_point = TRUE;
 65 | 	    number_of_key_points++;
 66 | 	  }
 67 | 	
 68 |       }
 69 |     else 
 70 |       {
 71 | 	inter->key_point = FALSE;
 72 | 	inter->key2_point = FALSE;
 73 |       }
 74 | 
 75 |     /* determine activity of this point */
 76 |     inter->act = UNKNOWN;
 77 |     if ( act[0] == 'A' ) {
 78 |       inter->act = ACCEPTOR;
 79 |       inter->ref = number_of_read_points;  
 80 |     } if ( act[0] == 'D' ) {
 81 |       inter->act = DONOR;
 82 |       inter->ref = number_of_read_points; 
 83 |     } if ( act[0] == 'H' ) {
 84 |       inter->act = HYDROPHOB;
 85 |       inter->ref = number_of_read_points; 
 86 |     } if ( act[0] == 'N' ){
 87 |     /* this is a doneptor point, i.e., a template point where either
 88 |        a donor or an acceptor, or a doneptor of a ligand can be placed,
 89 |        this point is internally represented as two separate points,
 90 |        a donor and an acceptor point, which share the same position */
 91 |       inter->act = ACCEPTOR;
 92 |       inter->ref = number_of_read_points; 
 93 |       inter->type = UNKNOWN;
 94 |       inter->index = UNKNOWN;
 95 |       number_of_points++;
 96 |       old_inter = inter;
 97 |       inter++;
 98 |       inter->act = DONOR;
 99 |       inter->ref = number_of_read_points; 
100 |       inter->pos[X] = old_inter->pos[X];
101 |       inter->pos[Y] = old_inter->pos[Y];
102 |       inter->pos[Z] = old_inter->pos[Z];
103 |       inter->key_point = old_inter->key_point;
104 |       inter->key2_point = old_inter->key2_point;
105 |     }
106 |     if ( inter->act == UNKNOWN ) {
107 |       sprintf ( err_msg, "Wrong activity definition: %s", act );
108 |       err_panic2 ( "read_template", err_msg);
109 |     }
110 |     inter->type = UNKNOWN;
111 |     inter->index = UNKNOWN;
112 | 
113 |     inter++;
114 |     number_of_points++;
115 |     number_of_read_points++;
116 |     if ( number_of_points >= MAX_TEMPLATE_POINTS ) {
117 |       /* keep in mind that the internal number of template points is larger
118 |          than the number of points in the template file, since we represent
119 |          each doneptor point by two points */
120 |       sprintf(err_msg, "Number of (A + D + 2*N + H) template points more than "
121 |               "MAX_TEMPLATE_POINTS (%d)", MAX_TEMPLATE_POINTS);
122 |       err_panic2 ( "read_template", err_msg);
123 |     }
124 |   }
125 | 
126 |   fclose ( in );
127 |   global->template_size = number_of_points;
128 |   if ((number_of_key_points == 0) && (number_of_key2_points == 0))
129 |     err_panic2 ( "read_template", "no template key points");
130 |   if ((global->match_2_key_points) && (number_of_key2_points == 0))
131 |     err_panic2 ( "read_template", "no secondary key points");
132 |   global->template_key_points = number_of_key_points;
133 |   global->template_key2_points = number_of_key2_points;
134 | 
135 |   printf ("\nCHECK: template file read\n");
136 |   for (i = 0; i < 3; i++)
137 |     printf ("   %d: %s %8.3f %8.3f %8.3f\n",
138 | 	    i, 
139 | 	    global->template_interactions[i].act == DONOR       ? "DONOR    " 
140 | 	    : global->template_interactions[i].act == ACCEPTOR  ? "ACCEPTOR "  
141 | 	    : global->template_interactions[i].act == HYDROPHOB ? "HYDROPHOB" 
142 | 	    : "NOTHING  ",
143 | 	    global->template_interactions[i].pos[X],
144 | 	    global->template_interactions[i].pos[Y],
145 | 	    global->template_interactions[i].pos[Z] );
146 |   
147 |   return number_of_read_points;
148 | }
149 |        
150 | 


--------------------------------------------------------------------------------