int attach1PE (unsigned int e1, int pre_pos, unsigned int bal_e2, int pos, int insert_size)
{
int gap, realpeSize;
unsigned int bal_e1, e2;
if (e1 == bal_e2)
{
ignorePE1++;
return -1; //orientation wrong
}
bal_e1 = getTwinCtg (e1);
e2 = getTwinCtg (bal_e2);
if (e1 == e2)
{
realpeSize = contig_array[e1].length + overlaplen - pre_pos - pos;
if (realpeSize > 0)
{
peSUM += realpeSize;
onsameCtgPE++;
if ((int) contig_array[e1].length > insert_size)
{
int *item = (int *) stackPush (isStack);
(*item) = realpeSize;
}
}
return 2;
}
gap = insert_size - overlaplen + pre_pos + pos - contig_array[e1].length - contig_array[e2].length;
if (gap < -(insert_size / 10))
{
ignorePE2++;
return 0;
}
if (gap > insert_size)
{
ignorePE3++;
return 0;
}
add1Connect (e1, e2, gap, 1, 0);
add1Connect (bal_e2, bal_e1, gap, 1, 0);
return 1;
}
static int maskRepeatByArc ( unsigned avg_weight )
{
unsigned int i, bal_i;
int counter = 0;
int arc_num;
unsigned int arc_weight1, arc_weight2;
preARC * arc;
for ( i = 1; i <= num_ctg; ++i )
{
if ( contig_array[i].mask == 1 )
{
if ( isSmallerThanTwin ( i ) )
{
++i;
}
continue;
}
bal_i = getTwinCtg ( i );
arc = contig_array[bal_i].arcs;
arc_weight1 = maxArcWeight ( arc );
arc = contig_array[i].arcs;
arc_weight2 = maxArcWeight ( arc );
if ( arc_weight1 + arc_weight2 >= 4 * avg_weight )
{
contig_array[i].mask = 1;
contig_array[bal_i].mask = 1;
if ( i == bal_i ) { counter += 1; }
else { counter += 2; }
}
if ( isSmallerThanTwin ( i ) )
{
++i;
}
}
return counter;
}
CONNECT * add1Connect ( unsigned int e1, unsigned int e2, int gap, int weight, boolean inherit )
{
if ( e1 == e2 || e1 == getTwinCtg ( e2 ) )
{ return NULL; }
CONNECT * connect = NULL;
long long sum;
if ( weight > 255 )
{ weight = 255; }
connect = getCntBetween ( e1, e2 );
if ( connect )
{
if ( !weight )
{ return connect; }
existCounter++;
if ( !inherit )
{
sum = connect->weightNotInherit * connect->gapLen + gap * weight;
connect->gapLen = sum / ( connect->weightNotInherit + weight );
if ( connect->weightNotInherit + weight <= 255 )
{ connect->weightNotInherit += weight; }
else if ( connect->weightNotInherit < 255 )
{ connect->weightNotInherit = 255; }
}
else
{
sum = connect->weight * connect->gapLen + gap * weight;
connect->gapLen = sum / ( connect->weight + weight );
if ( !connect->inherit )
{
connect->maxSingleWeight = connect->weightNotInherit;
}
connect->inherit = 1;
connect->maxSingleWeight = connect->maxSingleWeight > weight ?
connect->maxSingleWeight : weight;
}
if ( connect->weight + weight <= 255 )
{
connect->weight += weight;
}
else if ( connect->weight < 255 )
{
connect->weight = 255;
}
}
else
{
newCntCounter++;
connect = allocateCN ( e2, gap );
if ( cntLookupTable )
{ putCnt2LookupTable ( e1, connect ); }
connect->weight = weight;
if ( contig_array[e1].mask || contig_array[e2].mask )
{
connect->mask = 1;
}
connect->next = contig_array[e1].downwardConnect;
contig_array[e1].downwardConnect = connect;
if ( !inherit )
{
connect->weightNotInherit = weight;
}
else
{
connect->weightNotInherit = 0;
connect->inherit = 1;
connect->maxSingleWeight = weight;
}
}
return connect;
}
/*************************************************
Function:
loadUpdatedEdges
Description:
Loads contig information and masks some contigs according to setting.
Input:
1. graphfile: prefix of graph file
Output:
None.
Return:
None.
*************************************************/
void loadUpdatedEdges ( char * graphfile )
{
char c, name[256], line[1024];
int bal_ed, cvg;
FILE * fp, *out_fp;
Kmer from_kmer, to_kmer;
unsigned int num_ctgge, length, index = 0, num_kmer;
unsigned int i = 0, j;
int newIndex;
unsigned int * length_array, *flag_array, diff_len;
char * outfile = graphfile;
long long cvgSum = 0;
long long counter = 0;
unsigned int avg_arc_wt;
int ctg_short_cutoff;
float high_cvg_cutoff1, high_cvg_cutoff2, low_cvg_cutoff;
int cut_len;
//get overlaplen from *.preGraphBasic
sprintf ( name, "%s.preGraphBasic", graphfile );
fp = ckopen ( name, "r" );
while ( fgets ( line, sizeof ( line ), fp ) != NULL )
{
if ( line[0] == 'V' )
{
sscanf ( line + 6, "%d %c %d", &num_kmer, &c, &overlaplen );
fprintf ( stderr, "Kmer size: %d\n", overlaplen );
break;
}
}
cut_len = COMPATIBLE_MODE == 0 ? overlaplen : 0;
if ( ctg_short == 0 )
{
ctg_short = overlaplen + 2;
}
ctg_short_cutoff = 2 * overlaplen + 2 < 100 ? 100 : 0;
fclose ( fp );
sprintf ( name, "%s.updated.edge", graphfile );
fp = ckopen ( name, "r" );
sprintf ( name, "%s.newContigIndex", outfile );
out_fp = ckopen ( name, "w" );
while ( fgets ( line, sizeof ( line ), fp ) != NULL )
{
if ( line[0] == 'E' )
{
sscanf ( line + 5, "%d", &num_ctgge );
fprintf ( stderr, "There are %d edge(s) in edge file.\n", num_ctgge );
break;
}
}
index_array = ( unsigned int * ) ckalloc ( ( num_ctgge + 1 ) * sizeof ( unsigned int ) );
length_array = ( unsigned int * ) ckalloc ( ( num_ctgge + 1 ) * sizeof ( unsigned int ) );
flag_array = ( unsigned int * ) ckalloc ( ( num_ctgge + 1 ) * sizeof ( unsigned int ) );
while ( fgets ( line, sizeof ( line ), fp ) != NULL )
{
if ( line[0] == '>' )
{
sscanf ( line + 7, "%d", &length );
index_array[++index] = length;
length_array[++i] = length;
}
}
num_ctg = index;
orig2new = 1;
qsort ( & ( length_array[1] ), num_ctg, sizeof ( length_array[0] ), cmp_int );
//extract unique length
diff_len = 0;
for ( i = 1; i <= num_ctg; i++ )
{
for ( j = i + 1; j <= num_ctg; j++ )
if ( length_array[j] != length_array[i] )
{
break;
}
length_array[++diff_len] = length_array[i];
flag_array[diff_len] = i;
i = j - 1;
}
contig_array = ( CONTIG * ) ckalloc ( ( num_ctg + 1 ) * sizeof ( CONTIG ) );
//load edges
index = 0;
rewind ( fp );
while ( fgets ( line, sizeof ( line ), fp ) != NULL )
{
if ( line[0] == '>' )
{
sscanf ( line, ">length %u,%d,%d", &length, &bal_ed, &cvg );
newIndex = uniqueLenSearch ( length_array, flag_array, diff_len, length );
index_array[++index] = newIndex;
if ( length != 0 ) { contig_array[newIndex].length = length - cut_len; }
else { contig_array[newIndex].length = 0; }
contig_array[newIndex].bal_edge = bal_ed + 1;
contig_array[newIndex].downwardConnect = NULL;
contig_array[newIndex].mask = 0;
contig_array[newIndex].flag = 0;
contig_array[newIndex].arcs = NULL;
contig_array[newIndex].seq = NULL;
contig_array[newIndex].multi = 0;
contig_array[newIndex].inSubGraph = 0;
contig_array[newIndex].bubbleInScaff = 0;
contig_array[newIndex].cvg = cvg / 10;
if ( cvg && length > 100 )
{
counter += length - cut_len;
cvgSum += cvg * ( length - cut_len );
}
fprintf ( out_fp, "%d %d %d\n", index, newIndex, contig_array[newIndex].bal_edge );
}
}
if ( counter )
{
cvgAvg = cvgSum / counter / 10 > 2 ? cvgSum / counter / 10 : 3;
}
//mark repeats
int bal_i;
if ( maskRep )
{
high_cvg_cutoff1 = cvg_high * cvgAvg;
high_cvg_cutoff2 = cvg_high * cvgAvg * 0.8;
low_cvg_cutoff = cvg_low * cvgAvg;
counter = 0;
fprintf ( stderr, "Mask contigs with coverage lower than %.1f or higher than %.1f, and strict length %d.\n", low_cvg_cutoff, high_cvg_cutoff1, ctg_short_cutoff );
for ( i = 1; i <= num_ctg; i++ )
{
bal_i = getTwinCtg ( i );
if ( ( contig_array[i].cvg + contig_array[bal_i].cvg ) > 2 * high_cvg_cutoff1 )
{
contig_array[i].mask = 1;
contig_array[bal_i].mask = 1;
if ( i == bal_i ) { counter += 1; }
else { counter += 2; }
}
else if ( contig_array[i].length < ctg_short_cutoff && ( contig_array[i].cvg > high_cvg_cutoff2 || contig_array[bal_i].cvg > high_cvg_cutoff2 || ( contig_array[i].cvg < low_cvg_cutoff && contig_array[bal_i].cvg < low_cvg_cutoff ) ) )
{
contig_array[i].mask = 1;
contig_array[bal_i].mask = 1;
if ( i == bal_i ) { counter += 1; }
else { counter += 2; }
}
else if ( cvgAvg < 50 && ( contig_array[i].cvg >= 63 || contig_array[bal_i].cvg >= 63 ) )
{
contig_array[i].mask = 1;
contig_array[bal_i].mask = 1;
if ( i == bal_i ) { counter += 1; }
else { counter += 2; }
}
if ( isSmallerThanTwin ( i ) )
{
i++;
}
}
fprintf ( stderr, "Average contig coverage is %d, %lld contig(s) masked.\n", cvgAvg, counter );
}
counter = 0;
for ( i = 1; i <= num_ctg; i++ )
{
if ( contig_array[i].mask )
{
continue;
}
bal_i = getTwinCtg ( i );
if ( contig_array[i].length < ctg_short )
{
contig_array[i].mask = 1;
contig_array[bal_i].mask = 1;
if ( i == bal_i ) { counter += 1; }
else { counter += 2; }
}
if ( isSmallerThanTwin ( i ) )
{
i++;
}
}
fprintf ( stderr, "Mask contigs shorter than %d, %lld contig(s) masked.\n", ctg_short, counter );
avg_arc_wt = loadArcs ( graphfile );
counter = 0;
//counter = maskRepeatByArc(avg_arc_wt);
//printf ("Mask contigs with multi arcs, %d contig masked\n", counter);
//tipsCount();
loadContig ( graphfile );
fprintf ( stderr, "Done loading updated edges.\n" );
free ( ( void * ) length_array );
free ( ( void * ) flag_array );
fclose ( fp );
fclose ( out_fp );
}
