int mg_curl(ParseStruct *parsestruct_ptr,
GtUword hit_counter, GtError * err)
{
int had_err = 0,
curl_errornr = 0;
/* Laenge der aus dem XML-File stammenden Hit-DNA-Sequenz */
GtUword seq_len;
GtWord numb_from = 0, numb_to = 0, numb_diff = 0;
GtStr *seq_var,
*http_adr;
MemoryStruct memorystruct;
/* char-Zeiger auf die HTTP-Adresse des cgi-Skriptes efetch von NCBI */
char *http_adr_ptr,
*seq_pos; /* char-Zeiger, wird benutzt zum
Auslesen der Sequenzinformation
aus dem XML-File, welche
Ergebnis der efetch-Anfrage ist */
const char *curlerror;
/* Curl-Handle */
CURL *curl_handle;
/* char-Zeiger auf die Daten ist NULL */
memorystruct.memory = NULL;
/* noch keine Daten eingetragen bzw. abgespeichert */
memorystruct.size = 0;
/* Zwischenspeicher fuer die Sequnezinformation, da die GtStrArray-Klasse
keine Funktion zum begrenzten Einfuegen eines Strings zur Verfuegung
stellt; setzen des ersten Teils der HTTP-Adresse */
seq_var = gt_str_new();
http_adr =
gt_str_new_cstr
("http://www.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=");
/* Check der Umgebungsvariablen */
gt_error_check(err);
curl_global_init(CURL_GLOBAL_ALL);
/* initialisieren der curl-session */
curl_handle = curl_easy_init();
/* Zusammensetzen der http-Adresse durch Anhaengen der query-GI-Nummer,
des Hit-from, des Hit-to Wertes und des Rueckgabetyps an den ersten
Teil der HTTP-Adresse */
gt_str_append_str(http_adr, ARGUMENTSSTRUCT(curl_fcgi_db));
gt_str_append_cstr(http_adr, "&id=gi|");
gt_str_append_str(http_adr, parsestruct_ptr->hit_gi_nr_tmp);
gt_str_append_cstr(http_adr, "&seq_start=");
gt_str_append_cstr(http_adr,
gt_str_array_get(MATRIXSTRUCT(hit_from), hit_counter));
gt_str_append_cstr(http_adr, "&seq_stop=");
gt_str_append_cstr(http_adr,
gt_str_array_get(MATRIXSTRUCT(hit_to), hit_counter));
gt_str_append_cstr(http_adr, "&retmode=xml");
/* char-Zeiger wird benoetigt, da curl_easy_setopt als 3. Parameter
einen char-Zeiger erwartet */
http_adr_ptr = gt_str_get(http_adr);
/* festlegen, welche HTTP-Adresse aufgerufen werden soll */
curl_easy_setopt(curl_handle, CURLOPT_URL, http_adr_ptr);
/* die empfangenen Daten werden an die Funktion WriteMemoryCallback
gesendet, wo Speicherplatz reserviert und die Daten in diesen
Speicherbereich kopiert werden */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION,
WriteMemoryCallback);
/* Die Daten werden in die Struktur eingetragen */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) &memorystruct);
/* setzen des user-agent field, da einige Server diesen voraussetzen */
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
/* Anfrage wird ausgefuehrt */
curl_errornr = curl_easy_perform(curl_handle);
curlerror = curl_easy_strerror(curl_errornr);
if (curl_errornr)
{
gt_error_set(err,
"an error occurred during curl-processing (error-code %d):\
\"%s\"", curl_errornr, curlerror);
had_err = -1;
}
if (!had_err)
{
/* Die Hit-DNA steht zwischen dem <GBSeq_sequence> und dem
</GBSeq_sequence> XML-Tag, Zeiger auf das < Zeichen von
<GBSeq_sequence> */
seq_pos = strstr(memorystruct.memory, "<GBSeq_sequence>");
if (!seq_pos)
{
gt_error_set(err,
"an error occurred while retrieving sequence-information\
with the following request: \"%s\"", http_adr_ptr);
had_err = -1;
}
int mg_computepath(CombinedScoreMatrixEntry **combinedscore_matrix,
HitInformation *hit_information,
unsigned long rows,
unsigned long contig_len,
ParseStruct *parsestruct_ptr, GtError * err)
{
int had_err = 0;
/* Initialisieren der Matrix fuer die Pfadberechnung */
PathMatrixEntry **path_matrix;
/* i: Zaehlvariable fuer die Matrix-Zeilen; k: Zaehlvariable Precursors
(von 0 bis max 2) maxpath_frame: Speichern des vorherigen Frames von
dem der max-Wert berechnet wird */
unsigned short row_index = 0,
precursor_index = 0,
precursors_row = 0,
maxpath_frame = 0;
/* Position in der Query-DNA */
unsigned long column_index = 0;
/* Variablen fuer den aktuellen Frame, den vorherigen Frame(speichert
einen Wert aus precursors[], die Zeile des vorherigen Frames, GtArray
mit den Precursors-Frames */
short current_frame = 0,
precursors_frame = 0,
precursors[NUM_PRECURSORS];
/* q ist der Wert, der bei Aus- oder Eintreten in ein Gen auf dem
Forward- bzw. Reverse-Strang berechnet wird */
double q = ARGUMENTSSTRUCT(leavegene_value),
max_new = 1,
max_old = 1;
/* Speicherreservierung fuer die Path-Matrix - Groesse entsprechend der
CombinedScore-Matrix */
gt_array2dim_calloc(path_matrix, 7, contig_len);
gt_error_check(err);
/* fuer die erste Spalte der Path-Matrix wird die erste Spalte der
CombinedScore-Matrix uebernommen */
for (row_index = 0; row_index < rows; row_index++)
{
path_matrix[row_index][0].score =
combinedscore_matrix[row_index][0].matrix_score;
path_matrix[row_index][0].path_frame = row_index;
}
/* Spaltenweise Berechnung des opt. Pfades */
for (column_index = 1; column_index < contig_len; column_index++)
{
for (row_index = 0; row_index < rows; row_index++)
{
/* Zaehlvariable fuer die Zeile wird umgerechnet in den entsprechenden
Leserahmen */
current_frame = get_current_frame(row_index);
/* Aufruf der Methode zum Berechnen der moeglichen Leserahmen anhand von
aktuellem Leserahmen und der Query-DNA-Sequenz */
compute_precursors(current_frame,
column_index,
precursors);
/* der max-Wert der moeglichen Vorgaenger wird berechnet */
for (precursor_index = 0;
precursor_index < NUM_PRECURSORS
&& (precursors[precursor_index] != UNDEFINED);
++precursor_index)
{
/* aktueller Vorgaengerleserahmen - es gibt max. 3 moegliche
Vorgaenger */
precursors_frame = precursors[precursor_index];
/* Vorgaengerleserahmen wird umgerechnet in die entsprechende
Matrix-Zeile */
precursors_row = get_matrix_row(precursors_frame);
/* der DP-Algo umfasst 3 moegliche Faelle
1. Fall: Wechsel vom Reversen- auf den Forward-Strang bzw.
umgekehrt */
if ((current_frame < 0 && precursors_frame > 0) ||
(current_frame > 0 && precursors_frame < 0))
{
max_new = path_matrix[precursors_row][column_index-1].score +
combinedscore_matrix[row_index][column_index].matrix_score
+ 2*q;
}
/* 2. Fall: Einfacher Wechsel des Leserahmens, also von + zu +
bzw.- zu - */
else if (current_frame != 0 && precursors_frame != current_frame)
{
max_new = path_matrix[precursors_row][column_index-1].score +
combinedscore_matrix[row_index][column_index].matrix_score
+ q;
}
/* 3. Fall: Leserahmen wird beibehalten bzw. Wechsel von kodierend zu
nicht-kodierend oder umgekehrt */
else
{
max_new = path_matrix[precursors_row][column_index-1].score +
combinedscore_matrix[row_index][column_index]
.matrix_score;
}
/* Bestimmen des Max-Wertes der max. 3 Moeglichkeiten und Speichern der
Zeile, von der der Max-Wert stammt */
if (gt_double_compare(max_new, max_old) > 0)
{
max_old = max_new;
maxpath_frame = precursors_row;
}
}
/* Speichern des Max-Wertes und der "Vorgaenger"-Zeile;
zuruecksetzen der Variablen */
path_matrix[row_index][column_index].score = max_old;
path_matrix[row_index][column_index].path_frame = maxpath_frame;
max_new = DBL_MIN;
max_old = DBL_MIN;
maxpath_frame = 0;
}
}
/* Aufruf der Methode zur Genvorhersage */
had_err = mg_compute_gene_prediction(combinedscore_matrix,
path_matrix,
contig_len,
hit_information,
parsestruct_ptr, err);
gt_array2dim_delete(path_matrix);
return had_err;
}
