BGI/SOAPdenovo2/standardPregraph/loadPreGraph.c

   1 /*
   2  * loadPreGraph.c
   3  *
   4  * Copyright (c) 2008-2012 BGI-Shenzhen <soap at genomics dot org dot cn>.
   5  *
   6  * This file is part of SOAPdenovo.
   7  *
   8  * SOAPdenovo is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * SOAPdenovo is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with SOAPdenovo.  If not, see <http://www.gnu.org/licenses/>.
  20  *
  21  */
  22
  23 #include "stdinc.h"
  24 #include "newhash.h"
  25 #include "kmerhash.h"
  26 #include "extfunc.h"
  27 #include "extvab.h"
  28 #include "zlib.h"
  29
  30 static void loadPreArcs ( char * graphfile );
  31
  32 int cmp_vertex ( const void * a, const void * b )
  33 {
  34         VERTEX * A, *B;
  35         A = ( VERTEX * ) a;
  36         B = ( VERTEX * ) b;
  37
  38         if ( KmerLarger ( A->kmer, B->kmer ) )
  39         {
  40                 return 1;
  41         }
  42         else if ( KmerEqual ( A->kmer, B->kmer ) )
  43         {
  44                 return 0;
  45         }
  46         else
  47         {
  48                 return -1;
  49         }
  50 }
  51
  52 /*************************************************
  53 Function:
  54     loadVertex
  55 Description:
  56     1. Loads first kmer and the last kmer of the edge.
  57     2. Sorts kmers.
  58 Input:
  59     1. graphfile:       the input prefix
  60 Output:
  61     None.
  62 Return:
  63     None.
  64 *************************************************/
  65 void loadVertex ( char * graphfile )
  66 {
  67         char name[256], line[256];
  68         FILE * fp;
  69         Kmer word, bal_word, temp;
  70         int num_kmer, i;
  71         char ch;
  72         sprintf ( name, "%s.preGraphBasic", graphfile );
  73         fp = ckopen ( name, "r" );
  74
  75         while ( fgets ( line, sizeof ( line ), fp ) != NULL )
  76         {
  77                 if ( line[0] == 'V' )
  78                 {
  79                         sscanf ( line + 6, "%d %c %d", &num_kmer, &ch, &overlaplen );
  80                         fprintf ( stderr, "There are %d kmer(s) in vertex file.\n", num_kmer );
  81                 }
  82                 else if ( line[0] == 'E' )
  83                 {
  84                         sscanf ( line + 5, "%d", &num_ed );
  85                         fprintf ( stderr, "There are %d edge(s) in edge file.\n", num_ed );
  86                 }
  87                 else if ( line[0] == 'M' )
  88                 {
  89                         sscanf ( line, "MaxReadLen %d MinReadLen %d MaxNameLen %d", &maxReadLen, &minReadLen, &maxNameLen );
  90                 }
  91                 else if ( line[0] == 'B' )
  92                 {
  93                         if ( line[7] == 'V' )
  94                         {
  95                                 sscanf ( line, "Backup VERTEX %d %c %d", &num_kmer, &ch, &overlaplen );
  96                                 fprintf ( stderr, "Backup there are %d kmer(s) in vertex file.\n", num_kmer );
  97                         }
  98                         else if ( line[7] == 'E' )
  99                         {
 100                                 sscanf ( line, "Backup EDGEs %d", &num_ed );
 101                                 fprintf ( stderr, "Backup there are %d edge(s) in edge file.\n", num_ed );
 102                         }
 103                         else if ( line[7] == 'M' )
 104                         {
 105                                 sscanf ( line, "Backup MaxReadLen %d MinReadLen %d MaxNameLen %d", &maxReadLen, &minReadLen, &maxNameLen );
 106                         }
 107                 }
 108         }
 109
 110         fclose ( fp );
 111         vt_array = ( VERTEX * ) ckalloc ( ( 4 * num_kmer ) * sizeof ( VERTEX ) );
 112         num_kmer_limit = 4 * num_kmer;
 113         sprintf ( name, "%s.vertex", graphfile );
 114         fp = ckopen ( name, "r" );
 115
 116         for ( i = 0; i < num_kmer; i++ )
 117         {
 118 #ifdef MER127
 119                 fscanf ( fp, "%llx %llx %llx %llx", & ( word.high1 ), & ( word.low1 ), & ( word.high2 ), & ( word.low2 ) );
 120 #else
 121                 fscanf ( fp, "%llx %llx", & ( word.high ), & ( word.low ) );
 122 #endif
 123                 bal_word = reverseComplement ( word, overlaplen );
 124
 125                 if ( KmerSmaller ( word, bal_word ) )
 126                 {
 127                         vt_array[i].kmer = word;
 128                 }
 129                 else
 130                 {
 131                         vt_array[i].kmer = bal_word;
 132                 }
 133         }
 134
 135         temp = vt_array[num_kmer - 1].kmer;
 136         qsort ( &vt_array[0], num_kmer, sizeof ( vt_array[0] ), cmp_vertex );
 137         fprintf ( stderr, "Kmers sorted.\n" );
 138         fclose ( fp );
 139
 140         for ( i = 0; i < num_kmer; i++ )
 141         {
 142                 bal_word = reverseComplement ( vt_array[i].kmer, overlaplen );
 143                 vt_array[i + num_kmer].kmer = bal_word;
 144         }
 145
 146         num_vt = num_kmer;
 147 }
 148
 149 /*************************************************
 150 Function:
 151     bisearch
 152 Description:
 153     Uses binary search to get the index of a kmer in array.
 154 Input:
 155     1. vts:     the array of the kmer
 156     2. num:     the count of the total kmers
 157     3. target:      the kmer to search
 158 Output:
 159     None.
 160 Return:
 161     The kmer's index in array.
 162 *************************************************/
 163 int bisearch ( VERTEX * vts, int num, Kmer target )
 164 {
 165         int mid, low, high;
 166         low = 0;
 167         high = num - 1;
 168
 169         while ( low <= high )
 170         {
 171                 mid = ( low + high ) / 2;
 172
 173                 if ( KmerEqual ( vts[mid].kmer, target ) )
 174                 {
 175                         break;
 176                 }
 177                 else if ( KmerLarger ( target, vts[mid].kmer ) )
 178                 {
 179                         low = mid + 1;
 180                 }
 181                 else
 182                 {
 183                         high = mid - 1;
 184                 }
 185         }
 186
 187         if ( low <= high )
 188         {
 189                 return mid;
 190         }
 191         else
 192         {
 193                 return -1;
 194         }
 195 }
 196
 197 /*************************************************
 198 Function:
 199     kmer2vt
 200 Description:
 201     Searchs the index of a kmer in array.
 202 Input:
 203     1. kmer:        the kmer
 204 Output:
 205     None.
 206 Return:
 207     The index of the kmer in the array.
 208 *************************************************/
 209 int kmer2vt ( Kmer kmer )
 210 {
 211         Kmer bal_word;
 212         int vt_id;
 213         bal_word = reverseComplement ( kmer, overlaplen );
 214
 215         if ( KmerSmaller ( kmer, bal_word ) )
 216         {
 217                 vt_id = bisearch ( &vt_array[0], num_vt, kmer );
 218
 219                 if ( vt_id < 0 )
 220                 {
 221                         fprintf ( stderr, "There is no vertex for kmer " );
 222                         PrintKmer ( stderr, kmer );
 223                         fprintf ( stderr, " .\n" );
 224                         /*
 225                         #ifdef MER127
 226                         fprintf (stderr,"There is not the vertex for kmer %llx %llx %llx %llx.\n", kmer.high1, kmer.low1, kmer.high2, kmer.low2);
 227                         #else
 228                         fprintf (stderr,"There is not the vertex for kmer %llx %llx.\n", kmer.high, kmer.low);
 229                         #endif
 230                         */
 231                 }
 232
 233                 return vt_id;
 234         }
 235         else
 236         {
 237                 vt_id = bisearch ( &vt_array[0], num_vt, bal_word );
 238
 239                 if ( vt_id >= 0 )
 240                 {
 241                         vt_id += num_vt;
 242                 }
 243                 else
 244                 {
 245                         fprintf ( stderr, "There is no vertex for kmer " );
 246                         PrintKmer ( stderr, kmer );
 247                         fprintf ( stderr, " .\n" );
 248                         /*
 249                         #ifdef MER127
 250                         fprintf (stderr,"There is not the vertex for kmer %llx %llx %llx %llx.\n", kmer.high1, kmer.low1, kmer.high2, kmer.low2);
 251                         #else
 252                         fprintf (stderr,"There is not the vertex for kmer %llx %llx.\n", kmer.high, kmer.low);
 253                         #endif
 254                         */
 255                 }
 256
 257                 return vt_id;
 258         }
 259 }
 260
 261 /*************************************************
 262 Function:
 263     buildReverseComplementEdge
 264 Description:
 265     Creates  reverse complementary edge of a edge.
 266 Input:
 267     1. edgeno:      the edge index
 268 Output:
 269     None.
 270 Return:
 271     None.
 272 *************************************************/
 273 #ifdef MER127
 274 static void buildReverseComplementEdge ( unsigned int edgeno )
 275 {
 276         int length = edge_array[edgeno].length;
 277         int i, index = 0;
 278         char * sequence, ch, *tightSeq;
 279         Kmer kmer = vt_array[edge_array[edgeno].from_vt].kmer;
 280         sequence = ( char * ) ckalloc ( ( overlaplen + length ) * sizeof ( char ) );
 281         int bit1, bit2, bit3, bit4;
 282
 283         if ( overlaplen < 32 )
 284         {
 285                 bit4 = overlaplen;
 286                 bit3 = 0;
 287                 bit2 = 0;
 288                 bit1 = 0;
 289         }
 290
 291         if ( overlaplen >= 32 && overlaplen < 64 )
 292         {
 293                 bit4 = 32;
 294                 bit3 = overlaplen - 32;
 295                 bit2 = 0;
 296                 bit1 = 0;
 297         }
 298
 299         if ( overlaplen >= 64 && overlaplen < 96 )
 300         {
 301                 bit4 = 32;
 302                 bit3 = 32;
 303                 bit2 = overlaplen - 64;
 304                 bit1 = 0;
 305         }
 306
 307         if ( overlaplen >= 96 && overlaplen < 128 )
 308         {
 309                 bit4 = 32;
 310                 bit3 = 32;
 311                 bit2 = 32;
 312                 bit1 = overlaplen - 96;
 313         }
 314
 315         for ( i = bit1 - 1; i >= 0; i-- )
 316         {
 317                 ch = kmer.high1 & 0x3;
 318                 kmer.high1 >>= 2;
 319                 sequence[i] = ch;
 320         }
 321
 322         for ( i = bit2 - 1; i >= 0; i-- )
 323         {
 324                 ch = kmer.low1 & 0x3;
 325                 kmer.low1 >>= 2;
 326                 sequence[i + bit1] = ch;
 327         }
 328
 329         for ( i = bit3 - 1; i >= 0; i-- )
 330         {
 331                 ch = kmer.high2 & 0x3;
 332                 kmer.high2 >>= 2;
 333                 sequence[i + bit1 + bit2] = ch;
 334         }
 335
 336         for ( i = bit4 - 1; i >= 0; i-- )
 337         {
 338                 ch = kmer.low2 & 0x3;
 339                 kmer.low2 >>= 2;
 340                 sequence[i + bit1 + bit2 + bit3] = ch;
 341         }
 342
 343         for ( i = 0; i < length; i++ )
 344         {
 345                 sequence[i + overlaplen] = getCharInTightString ( edge_array[edgeno].seq, i );
 346         }
 347
 348         tightSeq = ( char * ) ckalloc ( ( length / 4 + 1 ) * sizeof ( char ) );
 349
 350         for ( i = length - 1; i >= 0; i-- )
 351         {
 352                 writeChar2tightString ( int_comp ( sequence[i] ), tightSeq, index++ );
 353         }
 354
 355         edge_array[edgeno + 1].length = length;
 356         edge_array[edgeno + 1].cvg = edge_array[edgeno].cvg;
 357         kmer = vt_array[edge_array[edgeno].from_vt].kmer;
 358         edge_array[edgeno + 1].to_vt = kmer2vt ( reverseComplement ( kmer, overlaplen ) );
 359         kmer = vt_array[edge_array[edgeno].to_vt].kmer;
 360         edge_array[edgeno + 1].from_vt = kmer2vt ( reverseComplement ( kmer, overlaplen ) );
 361         edge_array[edgeno + 1].seq = tightSeq;
 362         edge_array[edgeno + 1].bal_edge = 0;
 363         edge_array[edgeno + 1].rv = NULL;
 364         edge_array[edgeno + 1].arcs = NULL;
 365         edge_array[edgeno + 1].flag = 0;
 366         edge_array[edgeno + 1].deleted = 0;
 367         free ( ( void * ) sequence );
 368 }
 369 #else
 370
 371 /*************************************************
 372 Function:
 373     buildReverseComplementEdge
 374 Description:
 375     Creates reverse complementary edge of a edge.
 376 Input:
 377     1. edgeno:      the edge index
 378 Output:
 379     None.
 380 Return:
 381     None.
 382 *************************************************/
 383 static void buildReverseComplementEdge ( unsigned int edgeno )
 384 {
 385         int length = edge_array[edgeno].length;
 386         int i, index = 0;
 387         char * sequence, ch, *tightSeq;
 388         Kmer kmer = vt_array[edge_array[edgeno].from_vt].kmer;
 389         sequence = ( char * ) ckalloc ( ( overlaplen + length ) * sizeof ( char ) );
 390         int bit2 = overlaplen > 32 ? 32 : overlaplen;
 391         int bit1 = overlaplen > 32 ? overlaplen - 32 : 0;
 392
 393         for ( i = bit1 - 1; i >= 0; i-- )
 394         {
 395                 ch = kmer.high & 0x3;
 396                 kmer.high >>= 2;
 397                 sequence[i] = ch;
 398         }
 399
 400         for ( i = bit2 - 1; i >= 0; i-- )
 401         {
 402                 ch = kmer.low & 0x3;
 403                 kmer.low >>= 2;
 404                 sequence[i + bit1] = ch;
 405         }
 406
 407         for ( i = 0; i < length; i++ )
 408         {
 409                 sequence[i + overlaplen] = getCharInTightString ( edge_array[edgeno].seq, i );
 410         }
 411
 412         tightSeq = ( char * ) ckalloc ( ( length / 4 + 1 ) * sizeof ( char ) );
 413
 414         for ( i = length - 1; i >= 0; i-- )
 415         {
 416                 writeChar2tightString ( int_comp ( sequence[i] ), tightSeq, index++ );
 417         }
 418
 419         edge_array[edgeno + 1].length = length;
 420         edge_array[edgeno + 1].cvg = edge_array[edgeno].cvg;
 421         kmer = vt_array[edge_array[edgeno].from_vt].kmer;
 422         edge_array[edgeno + 1].to_vt = kmer2vt ( reverseComplement ( kmer, overlaplen ) );
 423         kmer = vt_array[edge_array[edgeno].to_vt].kmer;
 424         edge_array[edgeno + 1].from_vt = kmer2vt ( reverseComplement ( kmer, overlaplen ) );
 425         edge_array[edgeno + 1].seq = tightSeq;
 426         edge_array[edgeno + 1].bal_edge = 0;
 427         edge_array[edgeno + 1].rv = NULL;
 428         edge_array[edgeno + 1].arcs = NULL;
 429         edge_array[edgeno + 1].flag = 0;
 430         edge_array[edgeno + 1].deleted = 0;
 431         free ( ( void * ) sequence );
 432 }
 433 #endif
 434
 435 /*************************************************
 436 Function:
 437     loadEdge
 438 Description:
 439     1. Loads the info of the edges.
 440     2. Loads the links between the edges.
 441 Input:
 442     1. graphfile:       the input prefix
 443 Output:
 444     None.
 445 Return:
 446     None.
 447 *************************************************/
 448 void loadEdge ( char * graphfile )
 449 {
 450         char c, name[256], line[1024], str[32];
 451         char * tightSeq = NULL;
 452         gzFile * fp;
 453         Kmer from_kmer, to_kmer;
 454         int n = 0, i, length, cvg, index = -1, bal_ed, edgeno;
 455         int linelen;
 456         unsigned int j;
 457         sprintf ( name, "%s.edge.gz", graphfile );
 458         fp = gzopen ( name, "r" );
 459         num_ed_limit = 1.2 * num_ed;
 460         edge_array = ( EDGE * ) ckalloc ( ( num_ed_limit + 1 ) * sizeof ( EDGE ) );
 461
 462         for ( j = num_ed + 1; j <= num_ed_limit; j++ )
 463         {
 464                 edge_array[j].seq = NULL;
 465         }
 466
 467         while ( gzgets ( fp, line, sizeof ( line ) ) != NULL )
 468         {
 469                 if ( line[0] == '>' )
 470                 {
 471                         if ( index >= 0 )
 472                         {
 473                                 edgeno = index + 1;
 474                                 edge_array[edgeno].length = length;
 475                                 edge_array[edgeno].cvg = cvg;
 476                                 edge_array[edgeno].from_vt = kmer2vt ( from_kmer );
 477                                 edge_array[edgeno].to_vt = kmer2vt ( to_kmer );
 478                                 edge_array[edgeno].seq = tightSeq;
 479                                 edge_array[edgeno].bal_edge = bal_ed + 1;
 480                                 edge_array[edgeno].rv = NULL;
 481                                 edge_array[edgeno].arcs = NULL;
 482                                 edge_array[edgeno].flag = 0;
 483                                 edge_array[edgeno].deleted = 0;
 484
 485                                 if ( bal_ed )
 486                                 {
 487                                         buildReverseComplementEdge ( edgeno );
 488                                         index++;
 489                                 }
 490                         }
 491
 492                         n = 0;
 493                         index++;
 494 #ifdef MER127
 495                         sscanf ( line + 7, "%d,%llx %llx %llx %llx,%llx %llx %llx %llx,%s %d,%d",
 496                                  &length, & ( from_kmer.high1 ), & ( from_kmer.low1 ), & ( from_kmer.high2 ), & ( from_kmer.low2 ), & ( to_kmer.high1 ), & ( to_kmer.low1 ),
 497                                  & ( to_kmer.high2 ), & ( to_kmer.low2 ), str, &cvg, &bal_ed );
 498 #else
 499                         sscanf ( line + 7, "%d,%llx %llx,%llx %llx,%s %d,%d", &length, & ( from_kmer.high ), & ( from_kmer.low ), & ( to_kmer.high ), & ( to_kmer.low ), str, &cvg, &bal_ed );
 500 #endif
 501                         tightSeq = ( char * ) ckalloc ( ( length / 4 + 1 ) * sizeof ( char ) );
 502                 }
 503                 else
 504                 {
 505                         linelen = strlen ( line );
 506
 507                         for ( i = 0; i < linelen; i++ )
 508                         {
 509                                 if ( line[i] >= 'a' && line[i] <= 'z' )
 510                                 {
 511                                         c = base2int ( line[i] - 'a' + 'A' );
 512                                         writeChar2tightString ( c, tightSeq, n++ );
 513                                 }
 514                                 else if ( line[i] >= 'A' && line[i] <= 'Z' )
 515                                 {
 516                                         c = base2int ( line[i] );
 517                                         writeChar2tightString ( c, tightSeq, n++ );
 518                                 }
 519                         }
 520                 }
 521         }
 522
 523         if ( index >= 0 )
 524         {
 525                 edgeno = index + 1;
 526                 edge_array[edgeno].length = length;
 527                 edge_array[edgeno].cvg = cvg;
 528                 edge_array[edgeno].from_vt = kmer2vt ( from_kmer );
 529                 edge_array[edgeno].to_vt = kmer2vt ( to_kmer );
 530                 edge_array[edgeno].seq = tightSeq;
 531                 edge_array[edgeno].bal_edge = bal_ed + 1;
 532
 533                 if ( bal_ed )
 534                 {
 535                         buildReverseComplementEdge ( edgeno );
 536                         index++;
 537                 }
 538         }
 539
 540         fprintf ( stderr, "%d edge(s) input.\n", index + 1 );
 541         gzclose ( fp );
 542         createArcMemo ();
 543         loadPreArcs ( graphfile );
 544 }
 545
 546 unsigned int getTwinEdge ( unsigned int edgeno )
 547 {
 548         return edgeno + edge_array[edgeno].bal_edge - 1;
 549 }
 550
 551 boolean EdSmallerThanTwin ( unsigned int edgeno )
 552 {
 553         return edge_array[edgeno].bal_edge > 1;
 554 }
 555
 556 boolean EdLargerThanTwin ( unsigned int edgeno )
 557 {
 558         return edge_array[edgeno].bal_edge < 1;
 559 }
 560
 561 boolean EdSameAsTwin ( unsigned int edgeno )
 562 {
 563         return edge_array[edgeno].bal_edge == 1;
 564 }
 565
 566 /*************************************************
 567 Function:
 568     add1Arc
 569 Description:
 570     Updates the arc information between two edges.
 571 Input:
 572     1. from_ed:     the first edge
 573     2. to_ed:           the second edge
 574     3. weight:      the weight of the arc to add
 575 Output:
 576     None.
 577 Return:
 578     None.
 579 *************************************************/
 580 static void add1Arc ( unsigned int from_ed, unsigned int to_ed, unsigned int weight )
 581 {
 582         if ( edge_array[from_ed].to_vt != edge_array[to_ed].from_vt )
 583         {
 584                 //fprintf(stderr,"add1Arc: inconsistant joins\n");
 585                 return;
 586         }
 587
 588         unsigned int bal_fe = getTwinEdge ( from_ed );
 589         unsigned int bal_te = getTwinEdge ( to_ed );
 590
 591         if ( from_ed > num_ed || to_ed > num_ed || bal_fe > num_ed || bal_te > num_ed )
 592         {
 593                 return;
 594         }
 595
 596         ARC * parc, *bal_parc;
 597         //both arcs already exist
 598         parc = getArcBetween ( from_ed, to_ed );
 599
 600         if ( parc )
 601         {
 602                 bal_parc = parc->bal_arc;
 603                 parc->multiplicity += weight;
 604                 bal_parc->multiplicity += weight;
 605                 return;
 606         }
 607
 608         //create new arcs
 609         parc = allocateArc ( to_ed );
 610         parc->multiplicity = weight;
 611         parc->prev = NULL;
 612
 613         if ( edge_array[from_ed].arcs )
 614         {
 615                 edge_array[from_ed].arcs->prev = parc;
 616         }
 617
 618         parc->next = edge_array[from_ed].arcs;
 619         edge_array[from_ed].arcs = parc;
 620
 621         // A->A'
 622         if ( bal_te == from_ed )
 623         {
 624                 //printf("preArc from A to A'\n");
 625                 parc->bal_arc = parc;
 626                 parc->multiplicity += weight;
 627                 return;
 628         }
 629
 630         bal_parc = allocateArc ( bal_fe );
 631         bal_parc->multiplicity = weight;
 632         bal_parc->prev = NULL;
 633
 634         if ( edge_array[bal_te].arcs )
 635         {
 636                 edge_array[bal_te].arcs->prev = bal_parc;
 637         }
 638
 639         bal_parc->next = edge_array[bal_te].arcs;
 640         edge_array[bal_te].arcs = bal_parc;
 641         //link them to each other
 642         parc->bal_arc = bal_parc;
 643         bal_parc->bal_arc = parc;
 644 }
 645
 646 /*************************************************
 647 Function:
 648     loadPreArcs
 649 Description:
 650     Loads the info of pre-arcs.
 651 Input:
 652     1. graphfile:       the input prefix
 653 Output:
 654     None.
 655 Return:
 656     None.
 657 *************************************************/
 658 void loadPreArcs ( char * graphfile )
 659 {
 660         FILE * fp;
 661         char name[256], line[1024];
 662         unsigned int target, weight;
 663         unsigned int from_ed;
 664         char * seg;
 665         sprintf ( name, "%s.preArc", graphfile );
 666         fp = ckopen ( name, "r" );
 667         arcCounter = 0;
 668
 669         while ( fgets ( line, sizeof ( line ), fp ) != NULL )
 670         {
 671                 seg = strtok ( line, " " );
 672                 from_ed = atoi ( seg );
 673
 674                 while ( ( seg = strtok ( NULL, " " ) ) != NULL )
 675                 {
 676                         target = atoi ( seg );
 677                         seg = strtok ( NULL, " " );
 678                         weight = atoi ( seg );
 679                         add1Arc ( from_ed, target, weight );
 680                 }
 681         }
 682
 683         fprintf ( stderr, "%lli pre-arcs loaded.\n", arcCounter );
 684         fclose ( fp );
 685 }
 686
 687 void free_edge_array ( EDGE * ed_array, int ed_num )
 688 {
 689         int i;
 690
 691         for ( i = 1; i <= ed_num; i++ )
 692                 if ( ed_array[i].seq )
 693                 {
 694                         free ( ( void * ) ed_array[i].seq );
 695                 }
 696
 697         free ( ( void * ) ed_array );
 698 }