/*************************************************
Function:
call_heavygraph
Description:
The main function for contig step . its processes are as below:
1. Solve repeat
2. Merge bubble(clean bubble is optional for multikmer)
3. Remove weak edge and low coverage edge
4. Cut tips
5. Iterate multikmer(optional)
Input:
@see display_contig_usage ()
Output:
The files below:
1. *.contig
2. *.ContigIndex
3. *.update.edge
4. *.Arc
5. *.read [optional]
6. *.preGraphBasic [optional]
Return:
None.
*************************************************/
int call_heavygraph ( int argc, char ** argv )
{
time_t start_t, stop_t, time_bef, time_aft;
time ( &start_t );
boolean ret;
fprintf ( stderr, "\n********************\n" );
fprintf ( stderr, "Contig\n" );
fprintf ( stderr, "********************\n\n" );
initenv ( argc, argv );
loadVertex ( graphfile );
loadEdge ( graphfile );
if ( repeatSolve )
{
ret = loadPathBin ( graphfile );
}
swapedge();
sortedge();
freshArc();
if ( repeatSolve )
{
time ( &time_bef );
// ret = loadPathBin (graphfile);
if ( ret )
{
solveReps ();
}
else
{
fprintf ( stderr, "Repeat solving can't be done...\n" );
}
time ( &time_aft );
fprintf ( stderr, "Time spent on solving repeat: %ds.\n", ( int ) ( time_aft - time_bef ) );
}
//edgecvg_bar(edge_array,num_ed,graphfile,100);
if ( !iter && M > 0 )
{
time ( &time_bef );
bubblePinch ( 0.90, graphfile, M, 0, 1 );
time ( &time_aft );
fprintf ( stderr, "Time spent on pinching bubbles: %ds.\n", ( int ) ( time_aft - time_bef ) );
}
if ( iter && cleanBubble && M > 0 )
{
time ( &time_bef );
clean = 1;
long long oldpinCounter = 0;
long long min = 10;
int times = 0;
while ( min >= 10 )
{
times++;
if ( times >= 4 ) { break; }
bubblePinch ( 0.90, graphfile, M, 1, 0 );
min = pinCounter;
fprintf ( stderr, "%lld clean bubbles merged.\n", pinCounter );
}
time ( &time_aft );
fprintf ( stderr, "Time spent on pinching clean bubbles: %ds.\n", ( int ) ( time_aft - time_bef ) );
clean = 0;
}
if ( deLowEdge )
{
removeWeakEdges ( 2 * overlaplen, 1 );
removeLowCovEdges ( 2 * overlaplen, deLowEdge, !iter );
}
cutTipsInGraph ( 0, 0, !iter );
if ( iter )
{
Iterate ( shortrdsfile, graphfile, maxk, M ); //keepReadFile,
if ( M > 0 )
{
time ( &time_bef );
bubblePinch ( 0.90, graphfile, M, 1, 0 );
time ( &time_aft );
fprintf ( stderr, "Time spent on pinching bubbles: %ds.\n", ( int ) ( time_aft - time_bef ) );
}
freshpreGraphBasic ( iter, maxk, graphfile );
}
//output_graph(graphfile);
output_contig ( edge_array, num_ed, graphfile, overlaplen + 1 );
output_updated_edges ( graphfile );
output_heavyArcs ( graphfile );
if ( vt_array )
{
free ( ( void * ) vt_array );
vt_array = NULL;
}
if ( edge_array )
{
free_edge_array ( edge_array, num_ed_limit );
edge_array = NULL;
}
destroyArcMem ();
time ( &stop_t );
fprintf ( stderr, "\nTime spent on constructing contig: %dm.\n\n", ( int ) ( stop_t - start_t ) / 60 );
return 0;
}
void routerFinder::advGreedySoluation(int vertexNum,int edgeNum,int (*edgeData)[4],
int setSizeRec,int *includeSet,
int& total_cost,std::vector<int>& final_path)
{
int (*reverse_edge)[4] = new int[edgeNum][4];
for (int i = 0; i < edgeNum; ++i) {
reverse_edge[i][0] = edgeData[i][0];
reverse_edge[i][1] = edgeData[i][2];
reverse_edge[i][2] = edgeData[i][1];
reverse_edge[i][3] = edgeData[i][3];
}
std::vector<vertex> verteix = loadVerterix(vertexNum);
loadEdge(edgeData, edgeNum, verteix);
std::vector<vertex> reverse_verteix = loadVerterix(vertexNum);
loadEdge(reverse_edge, edgeNum, reverse_verteix);
bool visited[600];
bool reverse_visited[600];
int parent[20];
int reverse_parent[20];
for (int i = 0; i < vertexNum; ++i) {
visited[i] = false;
reverse_visited[i] = false;
parent[i] = -1;
reverse_parent[i] = -1;
}
int setSize = setSizeRec;
int sourceID = includeSet[0];
int meetID = includeSet[setSizeRec-1];
node* distance;
node* reverse_dist;
float judge[52] = {0};
int maxIndex = 0;
int selectIndex = 0;
float maxRec = INF;
float k_value = 0.6;
std::vector<int> temp_path;
for (;setSize > 1; --setSize) {
distance = dijkstra(sourceID,verteix,includeSet,setSize,visited,parent);
reverse_dist = dijkstra(meetID,reverse_verteix,includeSet,setSize,reverse_visited,reverse_parent);
if (setSize == 2) {
selectIndex = meetID;
}else{
for (int i = 1; i < setSize-1; ++i) {
judge[i] = k_value*distance[includeSet[i]].w+(1-k_value)*reverse_dist[includeSet[i]].w;
if (maxRec > judge[i]) {
maxRec = judge[i];
maxIndex = i;
selectIndex = includeSet[i];
}
}
}
//把选中的点交换到末尾去，includeSet的逆顺就是 需要通过的点的通过顺序
int tempx = includeSet[setSize-2];
includeSet[setSize-2] = includeSet[maxIndex];
includeSet[maxIndex] = tempx;
tempx = includeSet[setSize-1];
includeSet[setSize-1] = includeSet[setSize-2];
includeSet[setSize-2] = tempx;
for (int i = 0; i < setSizeRec; ++i) {
std::cout << includeSet[i] << "|";
}
std::cout << std::endl;
int tempIndex = selectIndex;
//update isSelected
while (tempIndex != -1) {
//到达某个选中的点可能回通过另外选中的点
int pindex = isInclude(parent[tempIndex],includeSet,setSize);
if( pindex != 0 ){
int tempx = includeSet[setSize-3];
includeSet[setSize-3] = includeSet[pindex];
includeSet[pindex] = tempx;
tempx = includeSet[setSize-2];
includeSet[setSize-2] = includeSet[setSize-3];
includeSet[setSize-3] = tempx;
--setSize;
}
verteix[tempIndex].isSelected = true;
reverse_verteix[tempIndex].isSelected = true;
//纪录结果
temp_path.push_back(tempIndex);
tempIndex = parent[tempIndex];
}
int tempPathSize = temp_path.size();
for (int i = temp_path.size()-1; i > 0; --i) {
final_path.push_back(temp_path[i]);
}
if (setSize == 2) {
final_path.push_back(temp_path[0]);
}
temp_path.clear();
//重置visited parent maxRec
for (int i = 0; i < vertexNum; ++i) {
visited[i] = false;
reverse_visited[i] = false;
parent[i] = -1;
reverse_parent[i] = -1;
}
total_cost += distance[selectIndex].w;
//无解处理
if (total_cost >= INF) {
}
maxRec = INF;
//更改起点再计算
sourceID = selectIndex;
}
// for (int i = setSizeRec-1; i >= 0; --i) {
// cout << includeSet[i] << "|";
// }
std:: cout << std::endl;
for (int i = 0; i < final_path.size(); ++i) {
std::cout << final_path[i] << "|";
}
std::cout << std::endl;
std::cout << total_cost;
}
