static int feature_index_lua_get_features_for_range(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtRange *range;
GtError *err;
bool has_seqid;
GtArray *features;
GT_UNUSED int had_err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature_index does not contain seqid");
range = check_range(L, 3);
features = gt_array_new(sizeof (GtGenomeNode*));
err = gt_error_new();
had_err = gt_feature_index_get_features_for_range(*feature_index, features,
seqid, range, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
static int feature_index_lua_get_features_for_range(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtRange *range;
GtArray *features;
int had_err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
luaL_argcheck(L, gt_feature_index_has_seqid(*feature_index, seqid), 2,
"feature_index does not contain seqid");
range = check_range(L, 3);
features = gt_array_new(sizeof (GtGenomeNode*));
had_err = gt_feature_index_get_features_for_range(*feature_index, features,
seqid, range, NULL);
gt_assert(!had_err); /* it was checked before that the feature_index contains
the given sequence id*/
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
static double gaeval_visitor_calculate_coverage(AgnGaevalVisitor *v,
GtFeatureNode *genemodel,
GtError *error)
{
agn_assert(v && genemodel);
GtStr *seqid = gt_genome_node_get_seqid((GtGenomeNode *)genemodel);
GtRange mrna_range = gt_genome_node_get_range((GtGenomeNode *)genemodel);
GtArray *overlapping = gt_array_new( sizeof(GtFeatureNode *) );
bool hasseqid;
gt_feature_index_has_seqid(v->alignments, &hasseqid, gt_str_get(seqid),error);
if(hasseqid)
{
gt_feature_index_get_features_for_range(v->alignments, overlapping,
gt_str_get(seqid), &mrna_range,
error);
}
GtArray *exon_coverage = gt_array_new( sizeof(GtRange) );
GtUword i;
for(i = 0; i < gt_array_size(overlapping); i++)
{
GtFeatureNode *alignment = *(GtFeatureNode **)gt_array_get(overlapping, i);
GtArray *covered_parts = gaeval_visitor_intersect((GtGenomeNode*)genemodel,
(GtGenomeNode*)alignment);
if(covered_parts != NULL)
{
GtArray *temp = gaeval_visitor_union(exon_coverage, covered_parts);
gt_array_delete(covered_parts);
gt_array_delete(exon_coverage);
exon_coverage = temp;
}
}
double coverage = gaeval_visitor_coverage_resolve(genemodel, exon_coverage);
gt_array_delete(exon_coverage);
gt_array_delete(overlapping);
return coverage;
}
GtDiagram* gt_diagram_new(GtFeatureIndex *feature_index, const char *seqid,
const GtRange *range, GtStyle *style,
GtError *err)
{
GtDiagram *diagram;
int had_err = 0;
GtArray *features = NULL;
gt_assert(seqid && range && style);
if (range->start == range->end)
{
gt_error_set(err, "range start must not be equal to range end");
return NULL;
}
features = gt_array_new(sizeof (GtGenomeNode*));
had_err = gt_feature_index_get_features_for_range(feature_index, features,
seqid, range, err);
if (had_err)
{
gt_array_delete(features);
return NULL;
}
diagram = gt_diagram_new_generic(features, range, style, false);
return diagram;
}
static double gaeval_visitor_calculate_integrity(AgnGaevalVisitor *v,
GtFeatureNode *genemodel,
double coverage,
double *components,
GtError *error)
{
agn_assert(v && genemodel);
GtStr *seqid = gt_genome_node_get_seqid((GtGenomeNode *)genemodel);
GtRange mrna_range = gt_genome_node_get_range((GtGenomeNode *)genemodel);
GtArray *overlapping = gt_array_new( sizeof(GtFeatureNode *) );
bool hasseqid;
gt_feature_index_has_seqid(v->alignments, &hasseqid, gt_str_get(seqid),error);
if(hasseqid)
{
gt_feature_index_get_features_for_range(v->alignments, overlapping,
gt_str_get(seqid), &mrna_range,
error);
}
GtArray *gaps = gt_array_new( sizeof(GtFeatureNode *) );
while(gt_array_size(overlapping) > 0)
{
GtFeatureNode *alignment = *(GtFeatureNode **)gt_array_pop(overlapping);
GtArray *agaps = agn_typecheck_select(alignment,
gaeval_visitor_typecheck_gap);
gt_array_add_array(gaps, agaps);
gt_array_delete(agaps);
}
gt_array_delete(overlapping);
GtUword utr5p_len = agn_mrna_5putr_length(genemodel);
double utr5p_score = 0.0;
if(utr5p_len >= v->params.exp_5putr_len)
utr5p_score = 1.0;
else
utr5p_score = (double)utr5p_len / (double)v->params.exp_5putr_len;
GtUword utr3p_len = agn_mrna_3putr_length(genemodel);
double utr3p_score = 0.0;
if(utr3p_len >= v->params.exp_3putr_len)
utr3p_score = 1.0;
else
utr3p_score = (double)utr3p_len / (double)v->params.exp_3putr_len;
GtArray *introns = agn_typecheck_select(genemodel, agn_typecheck_intron);
GtUword exoncount = agn_typecheck_count(genemodel, agn_typecheck_exon);
agn_assert(gt_array_size(introns) == exoncount - 1);
double structure_score = 0.0;
if(gt_array_size(introns) == 0)
{
GtUword cdslen = agn_mrna_cds_length(genemodel);
if(cdslen >= v->params.exp_cds_len)
structure_score = 1.0;
else
structure_score = (double)cdslen / (double)v->params.exp_cds_len;
}
else
{
structure_score = gaeval_visitor_introns_confirmed(introns, gaps);
}
gt_array_delete(gaps);
gt_array_delete(introns);
double integrity = (v->params.alpha * structure_score) +
(v->params.beta * coverage) +
(v->params.gamma * utr5p_score) +
(v->params.epsilon * utr3p_score);
if(components != NULL)
{
components[0] = structure_score;
components[1] = coverage;
components[2] = utr5p_score;
components[3] = utr3p_score;
}
return integrity;
}
static void* gt_feature_index_unit_test_query(void *data)
{
GtFeatureIndexTestShared *shm = (GtFeatureIndexTestShared*) data;
GtRange rng;
GtError *err = shm->err;
GtUword i;
int had_err = 0;
GtArray *arr, *arr_ref;
gt_mutex_lock(shm->mutex);
if (gt_error_is_set(shm->err)) {
gt_mutex_unlock(shm->mutex);
return NULL;
}
gt_mutex_unlock(shm->mutex);
arr = gt_array_new(sizeof (GtFeatureNode*));
arr_ref = gt_array_new(sizeof (GtFeatureNode*));
rng.start = random() % (GT_FI_TEST_END - GT_FI_TEST_QUERY_WIDTH);
rng.end = rng.start + random() % (GT_FI_TEST_QUERY_WIDTH);
/* get reference set by linear search */
gt_mutex_lock(shm->mutex);
for (i=0; i<GT_FI_TEST_FEATURES_PER_THREAD * gt_jobs; i++) {
GtRange rng2;
GtFeatureNode *fn;
fn = *(GtFeatureNode**) gt_array_get(shm->nodes, i);
rng2 = gt_genome_node_get_range((GtGenomeNode*) fn);
if (gt_range_overlap(&rng, &rng2)) {
gt_array_add(arr_ref, fn);
}
}
gt_mutex_unlock(shm->mutex);
/* query feature index */
gt_feature_index_get_features_for_range(shm->fi, arr, GT_FI_TEST_SEQID, &rng,
err);
/* result size must be equal */
if (gt_array_size(arr) != gt_array_size(arr_ref))
had_err = -1;
/* nodes must be the same (note that we should not rely on ptr equality) */
if (!had_err) {
gt_array_sort(arr_ref, cmp_range_start);
gt_array_sort(arr , cmp_range_start);
for (i=0;i<gt_array_size(arr);i++) {
if (had_err)
break;
if (!gt_feature_node_is_similar(*(GtFeatureNode**) gt_array_get(arr, i),
*(GtFeatureNode**)
gt_array_get(arr_ref, i))) {
had_err = -1;
}
}
}
if (had_err) {
gt_mutex_lock(shm->mutex);
shm->error_count++;
gt_mutex_unlock(shm->mutex);
}
gt_array_delete(arr);
gt_array_delete(arr_ref);
return NULL;
}
