freesasa.h

Go to the documentation of this file.

#ifndef FREESASA_H
#define FREESASA_H

#include <stdio.h>

#ifdef __cplusplus
extern "C"{
#endif

typedef enum {
    FREESASA_LEE_RICHARDS, 
    FREESASA_SHRAKE_RUPLEY 
} freesasa_algorithm;

typedef enum {
    FREESASA_V_NORMAL, 
    FREESASA_V_NOWARNINGS, 
    FREESASA_V_SILENT, 
    FREESASA_V_DEBUG, 
} freesasa_verbosity;

// 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_default_rsa freesasa_protor_rsa

const extern int FREESASA_DEF_NUMBER_THREADS; 

enum freesasa_error_codes {
    FREESASA_SUCCESS=0, 
    FREESASA_FAIL=-1, 
    FREESASA_WARN=-2, 
};

enum freesasa_structure_options {
    FREESASA_INCLUDE_HETATM=1, 
    FREESASA_INCLUDE_HYDROGEN=2, 
    FREESASA_SEPARATE_MODELS=4, 
    FREESASA_SEPARATE_CHAINS=8, 
    FREESASA_JOIN_MODELS=16, 
    FREESASA_HALT_AT_UNKNOWN=32, 
    FREESASA_SKIP_UNKNOWN=64, 
    FREESASA_RADIUS_FROM_OCCUPANCY=128, 
};

#define FREESASA_MAX_SELECTION_NAME 50

typedef struct {
    freesasa_algorithm alg;       
    double probe_radius;          
    int shrake_rupley_n_points;   
    int lee_richards_n_slices;    
    int n_threads;                
} freesasa_parameters;

extern const freesasa_parameters freesasa_default_parameters;

typedef struct {
    double total; 
    double *sasa; 
    int n_atoms;  
} freesasa_result;

typedef struct {
    const char *name;  
    double total;      
    double main_chain; 
    double side_chain; 
    double polar;      
    double apolar;     
} freesasa_residue_sasa;

typedef struct freesasa_structure freesasa_structure;

typedef struct {
    double *value; 
    char **string; 
    int n;         
} freesasa_strvp;

typedef struct freesasa_classifier {
    int n_classes; 
    void *config;  

    double (*radius)(const char* res_name,
                     const char* atom_name,
                     const struct freesasa_classifier*);

    int (*sasa_class)(const char* res_name,
                      const char* atom_name,
                      const struct freesasa_classifier*);

    const char* (*class2str)(int the_class,
                             const struct freesasa_classifier*);

    void (*free_config)(void*);
} freesasa_classifier;

extern const freesasa_classifier freesasa_protor_classifier;

extern const freesasa_classifier freesasa_naccess_classifier;

extern const freesasa_classifier freesasa_oons_classifier;

typedef struct {
    char *name;

    const freesasa_residue_sasa *max;

    const freesasa_classifier *polar_classifier;
    
    const freesasa_classifier *bb_classifier;
} freesasa_rsa_reference;

extern const freesasa_rsa_reference freesasa_protor_rsa;

extern const freesasa_rsa_reference freesasa_naccess_rsa;

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);

void
freesasa_result_free(freesasa_result *result);

freesasa_classifier*
freesasa_classifier_from_file(FILE *file);

void
freesasa_classifier_free(freesasa_classifier *classifier);

freesasa_strvp*
freesasa_result_classify(const freesasa_result *result,
                         const freesasa_structure *structure,
                         const freesasa_classifier *classifier);


int
freesasa_select_area(const char *command,
                     char *name,
                     double *area,
                     const freesasa_structure *structure,
                     const freesasa_result *result);

void
freesasa_strvp_free(freesasa_strvp *strvp);

int
freesasa_write_pdb(FILE *output, 
                   freesasa_result *result,
                   const freesasa_structure *structure);

int
freesasa_per_chain(FILE *output,
                   freesasa_result *result,
                   const freesasa_structure *structure);

int
freesasa_per_residue_type(FILE *output,
                          freesasa_result *result,
                          const freesasa_structure *structure);

int
freesasa_per_residue(FILE *output,
                     freesasa_result *result,
                     const freesasa_structure *structure);

int
freesasa_log(FILE *log,
             freesasa_result *result,
             const char *name,
             const freesasa_parameters *parameters,
             const freesasa_strvp* class_sasa);
int
freesasa_write_result(FILE *log,
                      freesasa_result *result,
                      const char *name,
                      const char *chains,
                      const freesasa_strvp* class_sasa);
int freesasa_write_parameters(FILE *log,
                              const freesasa_parameters *parameters);

int
freesasa_write_rsa(FILE *output,
                   const freesasa_result *result,
                   const freesasa_structure *structure,
                   const char *name,
                   const freesasa_rsa_reference *reference);
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();

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);

freesasa_structure*
freesasa_structure_get_chains(const freesasa_structure *structure, 
                              const char* chains);

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 *s);

int
freesasa_structure_n_chains(const freesasa_structure *s);

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);

const char*
freesasa_structure_residue_name(const freesasa_structure *s,
                                int r_i);

const char*
freesasa_structure_residue_number(const freesasa_structure *s,
                                  int r_i);
char
freesasa_structure_residue_chain(const freesasa_structure *s,
                                 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 *s,
                                 int r_i, 
                                 int *first,
                                 int *last);

int
freesasa_structure_chain_atoms(const freesasa_structure *s,
                                 char chain,
                                 int *first,
                                 int *last);


#ifdef __cplusplus
}
#endif

#endif /* FREESASA_H */