freesasa.h

Go to the documentation of this file.

#ifndef FREESASA_H
#define FREESASA_H
 
#include <stdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum freesasa_algorithm {
    FREESASA_LEE_RICHARDS, 
    FREESASA_SHRAKE_RUPLEY 
};
 
#ifndef __cplusplus
typedef enum freesasa_algorithm freesasa_algorithm;
#endif
 
enum freesasa_verbosity {
    FREESASA_V_NORMAL,     
    FREESASA_V_NOWARNINGS, 
    FREESASA_V_SILENT,     
    FREESASA_V_DEBUG,      
};
 
#ifndef __cplusplus
typedef enum freesasa_verbosity freesasa_verbosity;
#endif
 
/* Default parameters */
#define FREESASA_DEF_ALGORITHM FREESASA_LEE_RICHARDS 
#define FREESASA_DEF_PROBE_RADIUS 1.4                
#define FREESASA_DEF_SR_N 100                        
#define FREESASA_DEF_LR_N 20                         
#define freesasa_default_classifier freesasa_protor_classifier
 
#define FREESASA_CONFLICTING_CLASSIFIERS "conflicting-classifiers"
 
const extern int FREESASA_DEF_NUMBER_THREADS;
 
enum freesasa_error_codes {
    FREESASA_SUCCESS = 0, 
    FREESASA_FAIL = -1,   
    FREESASA_WARN = -2,   
};
 
enum freesasa_atom_class {
    FREESASA_ATOM_APOLAR = 0,
    FREESASA_ATOM_POLAR = 1,
    FREESASA_ATOM_UNKNOWN = 2,
};
 
#ifndef __cplusplus
typedef enum freesasa_atom_class freesasa_atom_class;
#endif
 
enum freesasa_structure_options {
    FREESASA_INCLUDE_HETATM = 1,             
    FREESASA_INCLUDE_HYDROGEN = 1 << 2,      
    FREESASA_SEPARATE_MODELS = 1 << 3,       
    FREESASA_SEPARATE_CHAINS = 1 << 4,       
    FREESASA_JOIN_MODELS = 1 << 5,           
    FREESASA_HALT_AT_UNKNOWN = 1 << 6,       
    FREESASA_SKIP_UNKNOWN = 1 << 7,          
    FREESASA_RADIUS_FROM_OCCUPANCY = 1 << 8, 
};
 
enum freesasa_output_options {
    FREESASA_OUTPUT_ATOM = 1,           
    FREESASA_OUTPUT_RESIDUE = 1 << 2,   
    FREESASA_OUTPUT_CHAIN = 1 << 3,     
    FREESASA_OUTPUT_STRUCTURE = 1 << 4, 
    FREESASA_LOG = 1 << 5,              
    FREESASA_RSA = 1 << 6,              
    FREESASA_JSON = 1 << 7,             
    FREESASA_XML = 1 << 8,              
    FREESASA_PDB = 1 << 9,              
    FREESASA_RES = 1 << 10,             
    FREESASA_SEQ = 1 << 11,             
    FREESASA_CIF = 1 << 12,             
    FREESASA_OUTPUT_SKIP_REL = 1 << 13,
};
 
#define FREESASA_MAX_SELECTION_NAME 50
 
struct freesasa_parameters {
    freesasa_algorithm alg;     
    double probe_radius;        
    int shrake_rupley_n_points; 
    int lee_richards_n_slices;  
    int n_threads;              
};
 
#ifndef __cplusplus
typedef struct freesasa_parameters freesasa_parameters;
#endif
 
extern const freesasa_parameters freesasa_default_parameters;
 
typedef struct freesasa_structure freesasa_structure;
 
struct freesasa_result {
    double total;                   
    double *sasa;                   
    int n_atoms;                    
    freesasa_parameters parameters; 
};
 
#ifndef __cplusplus
typedef struct freesasa_result freesasa_result;
#endif
 
struct freesasa_nodearea {
    const char *name;  
    double total;      
    double main_chain; 
    double side_chain; 
    double polar;      
    double apolar;     
    double unknown;    
};
 
#ifndef __cplusplus
typedef struct freesasa_nodearea freesasa_nodearea;
#endif
 
enum freesasa_nodetype {
    FREESASA_NODE_ATOM,      
    FREESASA_NODE_RESIDUE,   
    FREESASA_NODE_CHAIN,     
    FREESASA_NODE_STRUCTURE, 
    FREESASA_NODE_RESULT,    
    FREESASA_NODE_ROOT,      
    FREESASA_NODE_NONE       
};
 
#ifndef __cplusplus
typedef enum freesasa_nodetype freesasa_nodetype;
#endif
 
struct freesasa_cif_atom {
    const char *group_PDB;
    const char auth_asym_id;
    const char *auth_seq_id;
    const char *pdbx_PDB_ins_code;
    const char *auth_comp_id;
    const char *auth_atom_id;
    const char *label_alt_id;
    const char *type_symbol;
    const double Cartn_x;
    const double Cartn_y;
    const double Cartn_z;
};
 
#ifndef __cplusplus
typedef struct freesasa_cif_atom freesasa_cif_atom;
#endif
 
typedef struct freesasa_node freesasa_node;
 
typedef struct freesasa_selection freesasa_selection;
 
typedef struct freesasa_classifier freesasa_classifier;
 
extern const freesasa_classifier freesasa_protor_classifier;
 
extern const freesasa_classifier freesasa_naccess_classifier;
 
extern const freesasa_classifier freesasa_oons_classifier;
 
freesasa_result *
freesasa_calc_structure(const freesasa_structure *structure,
                        const freesasa_parameters *parameters);
 
freesasa_result *
freesasa_calc_coord(const double *xyz,
                    const double *radii,
                    int n,
                    const freesasa_parameters *parameters);
 
freesasa_node *
freesasa_calc_tree(const freesasa_structure *structure,
                   const freesasa_parameters *parameters,
                   const char *name);
 
freesasa_nodearea
freesasa_result_classes(const freesasa_structure *structure,
                        const freesasa_result *result);
 
void freesasa_result_free(freesasa_result *result);
 
freesasa_classifier *
freesasa_classifier_from_file(FILE *file);
 
void freesasa_classifier_free(freesasa_classifier *classifier);
 
double
freesasa_classifier_radius(const freesasa_classifier *classifier,
                           const char *res_name,
                           const char *atom_name);
 
freesasa_atom_class
freesasa_classifier_class(const freesasa_classifier *classifier,
                          const char *res_name,
                          const char *atom_name);
 
const char *
freesasa_classifier_class2str(freesasa_atom_class atom_class);
 
const char *
freesasa_classifier_name(const freesasa_classifier *classifier);
 
freesasa_selection *
freesasa_selection_new(const char *command,
                       const freesasa_structure *structure,
                       const freesasa_result *result);
 
void freesasa_selection_free(freesasa_selection *selection);
 
const char *
freesasa_selection_name(const freesasa_selection *selection);
 
const char *
freesasa_selection_command(const freesasa_selection *selection);
 
double
freesasa_selection_area(const freesasa_selection *selection);
 
int freesasa_selection_n_atoms(const freesasa_selection *selection);
 
int freesasa_set_verbosity(freesasa_verbosity v);
 
freesasa_verbosity
freesasa_get_verbosity(void);
 
void freesasa_set_err_out(FILE *err);
 
FILE *
freesasa_get_err_out(void);
 
freesasa_structure *
freesasa_structure_new(void);
 
void freesasa_structure_free(freesasa_structure *structure);
 
freesasa_structure *
freesasa_structure_from_pdb(FILE *pdb,
                            const freesasa_classifier *classifier,
                            int options);
 
freesasa_structure **
freesasa_structure_array(FILE *pdb,
                         int *n,
                         const freesasa_classifier *classifier,
                         int options);
 
int freesasa_structure_add_atom(freesasa_structure *structure,
                                const char *atom_name,
                                const char *residue_name,
                                const char *residue_number,
                                char chain_label,
                                double x, double y, double z);
int freesasa_structure_add_atom_wopt(freesasa_structure *structure,
                                     const char *atom_name,
                                     const char *residue_name,
                                     const char *residue_number,
                                     char chain_label,
                                     double x, double y, double z,
                                     const freesasa_classifier *classifier,
                                     int options);
int freesasa_structure_add_cif_atom(freesasa_structure *structure,
                                    freesasa_cif_atom *atom,
                                    const freesasa_classifier *classifier,
                                    int options);
freesasa_structure *
freesasa_structure_get_chains(const freesasa_structure *structure,
                              const char *chains,
                              const freesasa_classifier *classifier,
                              int options);
 
const char *
freesasa_structure_chain_labels(const freesasa_structure *structure);
 
int freesasa_structure_n(const freesasa_structure *structure);
 
int freesasa_structure_n_residues(const freesasa_structure *structure);
 
int freesasa_structure_n_chains(const freesasa_structure *structure);
 
const double *
freesasa_structure_radius(const freesasa_structure *structure);
 
void freesasa_structure_set_radius(freesasa_structure *structure,
                                   const double *radii);
 
const char *
freesasa_structure_atom_name(const freesasa_structure *structure,
                             int i);
 
const char *
freesasa_structure_atom_res_name(const freesasa_structure *structure,
                                 int i);
 
const char *
freesasa_structure_atom_res_number(const freesasa_structure *structure,
                                   int i);
 
char freesasa_structure_atom_chain(const freesasa_structure *structure,
                                   int i);
 
const char *
freesasa_structure_atom_symbol(const freesasa_structure *structure,
                               int i);
 
double
freesasa_structure_atom_radius(const freesasa_structure *structure,
                               int i);
void freesasa_structure_atom_set_radius(freesasa_structure *structure,
                                        int i,
                                        double radius);
 
const char *
freesasa_structure_residue_name(const freesasa_structure *structure,
                                int r_i);
 
const char *
freesasa_structure_residue_number(const freesasa_structure *structure,
                                  int r_i);
char freesasa_structure_residue_chain(const freesasa_structure *structure,
                                      int r_i);
 
int freesasa_structure_model(const freesasa_structure *structure);
 
const double *
freesasa_structure_coord_array(const freesasa_structure *structure);
 
int freesasa_structure_residue_atoms(const freesasa_structure *structure,
                                     int r_i,
                                     int *first,
                                     int *last);
 
int freesasa_structure_chain_atoms(const freesasa_structure *structure,
                                   char chain,
                                   int *first,
                                   int *last);
 
int freesasa_structure_chain_residues(const freesasa_structure *structure,
                                      char chain,
                                      int *first,
                                      int *last);
 
const char *
freesasa_structure_classifier_name(const freesasa_structure *structure);
 
freesasa_node *
freesasa_tree_new(void);
 
freesasa_node *
freesasa_tree_init(const freesasa_result *result,
                   const freesasa_structure *structure,
                   const char *name);
 
int freesasa_tree_add_result(freesasa_node *tree,
                             const freesasa_result *result,
                             const freesasa_structure *structure,
                             const char *name);
 
int freesasa_tree_join(freesasa_node *tree1,
                       freesasa_node **tree2);
 
int freesasa_tree_export(FILE *output,
                         freesasa_node *root,
                         int options);
 
int freesasa_node_free(freesasa_node *root);
 
const freesasa_nodearea *
freesasa_node_area(const freesasa_node *node);
 
freesasa_node *
freesasa_node_children(freesasa_node *node);
 
freesasa_node *
freesasa_node_next(freesasa_node *node);
 
freesasa_node *
freesasa_node_parent(freesasa_node *node);
 
freesasa_nodetype
freesasa_node_type(const freesasa_node *node);
 
const char *
freesasa_node_name(const freesasa_node *node);
 
const char *
freesasa_node_classified_by(const freesasa_node *node);
 
int freesasa_node_atom_is_polar(const freesasa_node *node);
 
int freesasa_node_atom_is_mainchain(const freesasa_node *node);
 
double
freesasa_node_atom_radius(const freesasa_node *node);
 
const char *
freesasa_node_atom_pdb_line(const freesasa_node *node);
 
const char *
freesasa_node_atom_residue_number(const freesasa_node *node);
 
const char *
freesasa_node_atom_residue_name(const freesasa_node *node);
 
char freesasa_node_atom_chain(const freesasa_node *node);
 
const char *
freesasa_node_residue_number(const freesasa_node *node);
 
int freesasa_node_residue_n_atoms(const freesasa_node *node);
 
const freesasa_nodearea *
freesasa_node_residue_reference(const freesasa_node *node);
 
int freesasa_node_chain_n_residues(const freesasa_node *node);
 
int freesasa_node_structure_n_chains(const freesasa_node *node);
 
int freesasa_node_structure_n_atoms(const freesasa_node *node);
 
const char *
freesasa_node_structure_chain_labels(const freesasa_node *node);
 
int freesasa_node_structure_model(const freesasa_node *node);
 
const freesasa_result *
freesasa_node_structure_result(const freesasa_node *node);
 
const freesasa_selection **
freesasa_node_structure_selections(const freesasa_node *node);
 
int freesasa_node_structure_add_selection(freesasa_node *node,
                                          const freesasa_selection *selection);
const freesasa_parameters *
freesasa_node_result_parameters(const freesasa_node *node);
 
/* Deprecated functions below, from 1.x API */
 
int freesasa_select_area(const char *command,
                         char *name,
                         double *area,
                         const freesasa_structure *structure,
                         const freesasa_result *result);
 
void freesasa_structure_set_model(freesasa_structure *structure,
                                  int model);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREESASA_H */