/*************************************************************************
* Read a motif database
*************************************************************************/
static MOTIF_DB_T* read_motifs(int id, char* motif_source, char* bg_source,
ARRAY_T** bg, double pseudocount, RBTREE_T *selected, ALPH_T alph) {
// vars
int read_motifs;
MOTIF_DB_T* motifdb;
MREAD_T *mread;
MOTIF_T *motif;
ARRAYLST_T *motifs;
// open the motif file for reading
mread = mread_create(motif_source, OPEN_MFILE);
mread_set_pseudocount(mread, pseudocount);
// determine background to use
if (*bg != NULL) mread_set_background(mread, *bg);
else mread_set_bg_source(mread, bg_source);
// load motifs
read_motifs = 0;
if (rbtree_size(selected) > 0) {
motifs = arraylst_create();
while(mread_has_motif(mread)) {
motif = mread_next_motif(mread);
read_motifs++;
if (rbtree_find(selected, get_motif_id(motif))) {
arraylst_add(motif, motifs);
} else {
DEBUG_FMT(NORMAL_VERBOSE, "Discarding motif %s in %s.\n",
get_motif_id(motif), motif_source);
destroy_motif(motif);
}
}
} else {
motifs = mread_load(mread, NULL);
read_motifs = arraylst_size(motifs);
}
arraylst_fit(motifs);
if (read_motifs > 0) {
// check the alphabet
if (mread_get_alphabet(mread) != alph) {
die("Expected %s alphabet motifs\n", alph_name(alph));
}
// get the background
if (*bg == NULL) *bg = mread_get_background(mread);
} else {
fprintf(stderr, "Warning: Motif file %s contains no motifs.\n", motif_source);
}
// clean up motif reader
mread_destroy(mread);
// create motif db
motifdb = mm_malloc(sizeof(MOTIF_DB_T));
memset(motifdb, 0, sizeof(MOTIF_DB_T));
motifdb->id = id;
motifdb->source = strdup(motif_source);
motifdb->motifs = motifs;
return motifdb;
}
/**************************************************************************
* Generate logos for all motifs in a file
**************************************************************************/
static void generate_file_logos(OPTIONS_T *options) {
STR_T *path;
MREAD_T *mread;
MOTIF_T *motif;
// file path buffer
path = str_create(100);
str_append(path, options->dir, strlen(options->dir));
if (str_char(path, -1) != '/') str_append(path, "/", 1);
// create output directory
if (create_output_directory(str_internal(path), TRUE, FALSE))
exit(EXIT_FAILURE);
// open motif file
mread = mread_create(options->motifs_file, OPEN_MFILE);
while (mread_has_motif(mread)) {
motif = mread_next_motif(mread);
generate_motif_logos(options, path, motif);
destroy_motif(motif);
}
mread_destroy(mread);
str_destroy(path, FALSE);
}
ARRAYLST_T* load_motifs(AMA_OPTIONS_T *opts) {
ARRAYLST_T *motifs;
ARRAY_T *pos_bg_freqs, *rev_bg_freqs;
MREAD_T *mread;
MOTIF_T *motif, *motif_rc;
double range;
PSSM_T *pos_pssm, *neg_pssm;
int total_motifs;
ALPH_T *alph;
//
// Read the motifs and background model.
//
//this reads any meme file, xml, txt and html
mread = mread_create(opts->motif_filename, OPEN_MFILE);
mread_set_bg_source(mread, opts->bg_filename);
mread_set_pseudocount(mread, opts->pseudocount);
// sanity check, since the rest of the code relies on the motifs being complementable
alph = alph_hold(mread_get_alphabet(mread));
if (alph == NULL) die("Unable to determine alphabet from motifs");
if (opts->scan_both_strands && !alph_has_complement(alph)) {
opts->scan_both_strands = false;
}
if (opts->num_gc_bins > 1 && alph_size_core(alph) != 4 && alph_size_pairs(alph) != 2) {
fprintf(stderr, "Warning: The motif alphabet does not have exactly 2 complementary pairs so \"GC binning\" will be disabled.\n");
opts->num_gc_bins = 1;
}
pos_bg_freqs = mread_get_background(mread);
rev_bg_freqs = NULL;
if (opts->scan_both_strands) {
rev_bg_freqs = allocate_array(get_array_length(pos_bg_freqs));
copy_array(pos_bg_freqs, rev_bg_freqs);
complement_swap_freqs(alph, rev_bg_freqs, rev_bg_freqs);
}
// allocate memory for motifs
motifs = arraylst_create();
//
// Convert motif matrices into log-odds matrices.
// Scale them.
// Compute the lookup tables for the PDF of scaled log-odds scores.
//
range = 300; // 100 is not very good; 1000 is great but too slow
neg_pssm = NULL;
total_motifs = 0;
while (mread_has_motif(mread)) {
motif = mread_next_motif(mread);
total_motifs++;
if (rbtree_size(opts->selected_motifs) == 0 || rbtree_find(opts->selected_motifs, get_motif_id(motif)) != NULL) {
if (verbosity >= HIGH_VERBOSE) {
fprintf(stderr, "Using motif %s of width %d.\n", get_motif_id(motif), get_motif_length(motif));
}
pos_pssm =
build_motif_pssm(
motif,
pos_bg_freqs,
pos_bg_freqs,
NULL, // Priors not used
0.0L, // alpha not used
range,
opts->num_gc_bins,
true
);
//
// Note: If scanning both strands, we complement the motif frequencies
// but not the background frequencies so the motif looks the same.
// However, the given frequencies are used in computing the p-values
// since they represent the frequencies on the negative strands.
// (If we instead were to complement the input sequence, keeping the
// the motif fixed, we would need to use the complemented frequencies
// in computing the p-values. Is that any clearer?)
//
if (opts->scan_both_strands) {
motif_rc = dup_rc_motif(motif);
neg_pssm =
build_motif_pssm(
motif_rc,
rev_bg_freqs,
pos_bg_freqs,
NULL, // Priors not used
0.0L, // alpha not used
range,
opts->num_gc_bins,
true
);
destroy_motif(motif_rc);
}
arraylst_add(motif_and_pssm_create(motif, pos_pssm, neg_pssm), motifs);
} else {
if (verbosity >= HIGH_VERBOSE) fprintf(stderr, "Skipping motif %s.\n",
get_motif_id(motif));
destroy_motif(motif);
}
}
mread_destroy(mread);
free_array(pos_bg_freqs);
free_array(rev_bg_freqs);
alph_release(alph);
if (verbosity >= NORMAL_VERBOSE) {
fprintf(stderr, "Loaded %d/%d motifs from %s.\n",
arraylst_size(motifs), total_motifs, opts->motif_filename);
}
return motifs;
}
/*************************************************************************
* Entry point for centrimo
*************************************************************************/
int main(int argc, char *argv[]) {
CENTRIMO_OPTIONS_T options;
SEQ_SITES_T seq_sites;
SITE_COUNTS_T counts;
int seqN, motifN, seqlen, db_i, motif_i, i;
double log_pvalue_thresh;
SEQ_T** sequences = NULL;
ARRAY_T* bg_freqs = NULL;
ARRAYLST_T *stats_list;
MOTIF_DB_T **dbs, *db;
MREAD_T *mread;
MOTIF_STATS_T *stats;
MOTIF_T *motif, *rev_motif;
PSSM_T *pos_pssm, *rev_pssm;
char *sites_path, *desc;
FILE *sites_file;
HTMLWR_T *html;
JSONWR_T *json;
// COMMAND LINE PROCESSING
process_command_line(argc, argv, &options);
// load the sequences
read_sequences(options.alphabet, options.seq_source, &sequences, &seqN);
seqlen = (seqN ? get_seq_length(sequences[0]) : 0);
// calculate a sequence background (unless other background is given)
if (!options.bg_source) {
bg_freqs = calc_bg_from_fastas(options.alphabet, seqN, sequences);
}
// load the motifs
motifN = 0;
dbs = mm_malloc(sizeof(MOTIF_DB_T*) * arraylst_size(options.motif_sources));
for (i = 0; i < arraylst_size(options.motif_sources); i++) {
char* db_source;
db_source = (char*)arraylst_get(i, options.motif_sources);
dbs[i] = read_motifs(i, db_source, options.bg_source, &bg_freqs,
options.pseudocount, options.selected_motifs, options.alphabet);
motifN += arraylst_size(dbs[i]->motifs);
}
log_pvalue_thresh = log(options.evalue_thresh) - log(motifN);
// Setup some things for double strand scanning
if (options.scan_both_strands == TRUE) {
// Set up hash tables for computing reverse complement
setup_hash_alph(DNAB);
setalph(0);
// Correct background by averaging on freq. for both strands.
average_freq_with_complement(options.alphabet, bg_freqs);
normalize_subarray(0, alph_size(options.alphabet, ALPH_SIZE), 0.0, bg_freqs);
calc_ambigs(options.alphabet, FALSE, bg_freqs);
}
// Create output directory
if (create_output_directory(options.output_dirname, options.allow_clobber,
(verbosity >= NORMAL_VERBOSE))) {
die("Couldn't create output directory %s.\n", options.output_dirname);
}
// open output files
sites_path = make_path_to_file(options.output_dirname, SITES_FILENAME);
sites_file = fopen(sites_path, "w");
free(sites_path);
// setup html monolith writer
json = NULL;
if ((html = htmlwr_create(get_meme_etc_dir(), TEMPLATE_FILENAME))) {
htmlwr_set_dest_name(html, options.output_dirname, HTML_FILENAME);
htmlwr_replace(html, "centrimo_data.js", "data");
json = htmlwr_output(html);
if (json == NULL) die("Template does not contain data section.\n");
} else {
DEBUG_MSG(QUIET_VERBOSE, "Failed to open html template file.\n");
}
if (json) {
// output some top level variables
jsonwr_str_prop(json, "version", VERSION);
jsonwr_str_prop(json, "revision", REVISION);
jsonwr_str_prop(json, "release", ARCHIVE_DATE);
jsonwr_str_array_prop(json, "cmd", argv, argc);
jsonwr_property(json, "options");
jsonwr_start_object_value(json);
jsonwr_dbl_prop(json, "motif-pseudo", options.pseudocount);
jsonwr_dbl_prop(json, "score", options.score_thresh);
jsonwr_dbl_prop(json, "ethresh", options.evalue_thresh);
jsonwr_lng_prop(json, "maxbin", options.max_window+1);
jsonwr_bool_prop(json, "norc", !options.scan_both_strands);
jsonwr_bool_prop(json, "noflip", options.no_flip);
jsonwr_end_object_value(json);
// output the description
desc = prepare_description(&options);
if (desc) {
jsonwr_str_prop(json, "job_description", desc);
free(desc);
}
// output size metrics
jsonwr_lng_prop(json, "seqlen", seqlen);
jsonwr_lng_prop(json, "tested", motifN);
// output the fasta db
jsonwr_property(json, "sequence_db");
jsonwr_start_object_value(json);
jsonwr_str_prop(json, "source", options.seq_source);
jsonwr_lng_prop(json, "count", seqN);
jsonwr_end_object_value(json);
// output the motif dbs
jsonwr_property(json, "motif_dbs");
jsonwr_start_array_value(json);
for (db_i = 0; db_i < arraylst_size(options.motif_sources); db_i++) {
db = dbs[db_i];
jsonwr_start_object_value(json);
jsonwr_str_prop(json, "source", db->source);
jsonwr_lng_prop(json, "count", arraylst_size(db->motifs));
jsonwr_end_object_value(json);
}
jsonwr_end_array_value(json);
// start the motif array
jsonwr_property(json, "motifs");
jsonwr_start_array_value(json);
}
/**************************************************************
* Tally the positions of the best sites for each of the
* selected motifs.
**************************************************************/
// prepare the sequence sites
memset(&seq_sites, 0, sizeof(SEQ_SITES_T));
// prepare the site counts
counts.allocated = ((2 * seqlen) - 1);
counts.sites = mm_malloc(sizeof(double) * counts.allocated);
// prepare the motifs stats list
stats_list = arraylst_create();
// prepare the other vars
motif = NULL; pos_pssm = NULL; rev_motif = NULL; rev_pssm = NULL;
for (db_i = 0; db_i < arraylst_size(options.motif_sources); db_i++) {
db = dbs[db_i];
for (motif_i = 0; motif_i < arraylst_size(db->motifs); motif_i++) {
motif = (MOTIF_T *) arraylst_get(motif_i, db->motifs);
DEBUG_FMT(NORMAL_VERBOSE, "Using motif %s of width %d.\n",
get_motif_id(motif), get_motif_length(motif));
// reset the counts
for (i = 0; i < counts.allocated; i++) counts.sites[i] = 0;
counts.total_sites = 0;
// create the pssm
pos_pssm = make_pssm(bg_freqs, motif);
// If required, do the same for the reverse complement motif.
if (options.scan_both_strands) {
rev_motif = dup_rc_motif(motif);
rev_pssm = make_pssm(bg_freqs, rev_motif);
}
// scan the sequences
for (i = 0; i < seqN; i++)
score_sequence(&options, sequences[i], pos_pssm, rev_pssm,
&seq_sites, &counts);
// DEBUG check that the sum of the sites is close to the site count
double sum_check = 0, sum_diff;
for (i = 0; i < counts.allocated; i++) sum_check += counts.sites[i];
sum_diff = counts.total_sites - sum_check;
if (sum_diff < 0) sum_diff = -sum_diff;
if (sum_diff > 0.1) {
fprintf(stderr, "Warning: site counts don't sum to accurate value! "
"%g != %ld", sum_check, counts.total_sites);
}
// output the plain text site counts
output_site_counts(sites_file, seqlen, db, motif, &counts);
// compute the best central window
stats = compute_stats(options.max_window, seqlen, db, motif, &counts);
// check if it passes the threshold
if (json && stats->log_adj_pvalue <= log_pvalue_thresh) {
output_motif_json(json, stats, &counts);
arraylst_add(stats, stats_list);
} else {
free(stats);
}
// Free memory associated with this motif.
free_pssm(pos_pssm);
free_pssm(rev_pssm);
destroy_motif(rev_motif);
}
}
if (json) jsonwr_end_array_value(json);
// finish writing sites
fclose(sites_file);
// finish writing html file
if (html) {
if (htmlwr_output(html) != NULL) {
die("Found another JSON replacement!\n");
}
htmlwr_destroy(html);
}
// write text file
output_centrimo_text(&options, motifN, stats_list);
// Clean up.
for (i = 0; i < seqN; ++i) {
free_seq(sequences[i]);
}
free(sequences);
for (i = 0; i < arraylst_size(options.motif_sources); i++) {
free_db(dbs[i]);
}
free(dbs);
free_array(bg_freqs);
free(counts.sites);
free(seq_sites.sites);
arraylst_destroy(free, stats_list);
cleanup_options(&options);
return 0;
}