void TestPSFQ()
{ int mssgType, i, j, time, runNum;
//ReadInputNetwork();
//run PSFQ and collect totalCounts
totalCandidateCounts = (int **)malloc(numNodes * sizeof(int *));
totalSelectionCounts = (int **)malloc(numNodes * sizeof(int *));
totalSuccMssgCounts = (int ***)malloc(numNodes * sizeof(int **));
for (i=0; i<numNodes; i++) {
totalCandidateCounts[i] = (int *)calloc(numMssgTypes, sizeof(int));
totalSelectionCounts[i] = (int *)calloc(numMssgTypes, sizeof(int));
totalSuccMssgCounts[i] = (int **)malloc(numMssgTypes * sizeof(int *));
for (mssgType=0; mssgType<numMssgTypes; mssgType++) totalSuccMssgCounts[i][mssgType] = (int *)calloc(degrees[i], sizeof(int));
}
for (runNum=1,numSuccRuns=totalTime=0; runNum<=numPSFQruns; runNum++) {
//printf("run number=%d out of %d\n", runNum, numPSFQruns); //printf("hit return to continue: "); scanf("%*c");
if ((time = PSFQ()) >= 0) { //keep it >= 0; = 0 needed for numPackets = 1
totalTime += time; //printf("totalTime=%d\n", totalTime);
numSuccRuns++;
for (i=0; i<numNodes; i++)
{ fprintf(FHpacketOrderOut,"%d:",i); // BDE..how do I take nodes that do not receive the message?
for (j=0;j<numPackets; j++) // or better yet, how do I know who has and has not gotten all packets to print?
fprintf(FHpacketOrderOut," %d ",nodeStates[i].orderPacketsReceived[j]);
fprintf(FHpacketOrderOut,"\n");
for (mssgType=0; mssgType<numMssgTypes; mssgType++) {
totalCandidateCounts[i][mssgType] += nodeStates[i].candidateCounts[mssgType];
totalSelectionCounts[i][mssgType] += nodeStates[i].selectionCounts[mssgType];
for (j=0; j<degrees[i]; j++)
totalSuccMssgCounts[i][mssgType][j] += nodeStates[i].succMssgCounts[mssgType][j];
}
}
}
}
PrintMultiRunStats(stdout);
finalizeOutput(); //puts header information at top of output file
}
int main(int argc, char *argv[])
{
if (!parseCommandLine(argc, argv))
return 1;
configHashTable();
/****************************************************
* INDEXING
***************************************************/
if (indexingMode)
{
int i;
/********************************
* Regulard Mode
********************************/
if (!bisulfiteMode)
{
configHashTable();
for (i = 0; i < fileCnt; i++)
{
generateHashTable(fileName[i][0], fileName[i][1]);
}
}
else
/********************************
* Bisulfite Mode
********************************/
{ // TODO
}
}
/****************************************************
* SEARCHING
***************************************************/
else
{
Read *seqList;
unsigned int seqListSize;
int fc;
int samplingLocsSize;
int *samplingLocs;
double totalLoadingTime = 0;
double totalMappingTime = 0;
double startTime;
double loadingTime;
double mappingTime;
double lstartTime;
double ppTime;
double tmpTime;;
char *prevGen = getMem(CONTIG_NAME_SIZE);
prevGen[0]='\0';
char *curGen;
int flag;
double maxMem=0;
char fname1[FILE_NAME_LENGTH];
char fname2[FILE_NAME_LENGTH];
char fname3[FILE_NAME_LENGTH];
char fname4[FILE_NAME_LENGTH];
char fname5[FILE_NAME_LENGTH];
// Loading Sequences & Sampling Locations
startTime = getTime();
if (bisulfiteMode && !pairedEndMode && seqFile1 == NULL)
{
//TODO
}
else
{
if (!readAllReads(seqFile1, seqFile2, seqCompressed, &seqFastq, pairedEndMode, &seqList, &seqListSize))
{
return 1;
}
}
//loadSamplingLocations(&samplingLocs, &samplingLocsSize);
totalLoadingTime += getTime()-startTime;
if (pairedEndMode)
{
//Switching to Inferred Size
minPairEndedDistance = minPairEndedDistance - SEQ_LENGTH + 2;
maxPairEndedDistance = maxPairEndedDistance - SEQ_LENGTH + 2;
if (pairedEndDiscordantMode)
{
maxPairEndedDiscordantDistance = maxPairEndedDiscordantDistance - SEQ_LENGTH + 2;
minPairEndedDiscordantDistance = minPairEndedDiscordantDistance - SEQ_LENGTH + 2;
}
/* The size between the ends;
minPairEndedDistance = minPairEndedDistance + SEQ_LENGTH + 1;
maxPairEndedDistance = maxPairEndedDistance + SEQ_LENGTH + 1;
if (pairedEndDiscordantMode)
{
maxPairEndedDiscordantDistance = maxPairEndedDiscordantDistance + SEQ_LENGTH + 1;
minPairEndedDiscordantDistance = minPairEndedDiscordantDistance + SEQ_LENGTH + 1;
}*/
sprintf(fname1, "%s__%s__1", mappingOutputPath, mappingOutput);
sprintf(fname2, "%s__%s__2", mappingOutputPath, mappingOutput);
sprintf(fname3, "%s__%s__disc", mappingOutputPath, mappingOutput);
sprintf(fname4, "%s__%s__oea1", mappingOutputPath, mappingOutput);
sprintf(fname5, "%s__%s__oea2", mappingOutputPath, mappingOutput);
unlink(fname1);
unlink(fname2);
unlink(fname3);
unlink(fname4);
unlink(fname5);
}
// Preparing output
initOutput(mappingOutput, outCompressed);
fprintf(stdout, "-----------------------------------------------------------------------------------------------------------\n");
fprintf(stdout, "| %15s | %15s | %15s | %15s | %15s %15s |\n","Genome Name","Loading Time", "Mapping Time", "Memory Usage(M)","Total Mappings","Mapped reads");
fprintf(stdout, "-----------------------------------------------------------------------------------------------------------\n");
/********************************
* Regular Mode
********************************/
if (!bisulfiteMode)
{
if (!pairedEndMode)
{
for (fc = 0; fc <fileCnt; fc++)
{
if (!initLoadingHashTable(fileName[fc][1]))
{
return 1;
}
loadSamplingLocations(&samplingLocs, &samplingLocsSize);
mappingTime = 0;
loadingTime = 0;
prevGen[0] = '\0';
flag = 1;
do
{
flag = loadHashTable ( &tmpTime ); // Reading a fragment
curGen = getRefGenomeName();
// First Time
if (flag && prevGen[0]== '\0')
{
sprintf(prevGen, "%s", curGen);
}
if ( !flag || strcmp(prevGen, curGen)!=0)
{
fprintf(stdout, "| %15s | %15.2f | %15.2f | %15.2f | %15lld %15lld |\n",
prevGen,loadingTime, mappingTime, maxMem, mappingCnt , mappedSeqCnt);
fflush(stdout);
totalMappingTime += mappingTime;
totalLoadingTime += loadingTime;
loadingTime = 0;
mappingTime = 0;
maxMem = 0;
if (!flag)
{
break;
}
}
else if (progressRep && mappingTime != 0)
{
fprintf(stdout, "| %15s | %15.2f | %15.2f | %15.2f | %15lld %15lld |\n",
prevGen,loadingTime, mappingTime, maxMem, mappingCnt , mappedSeqCnt);
fflush(stdout);
}
sprintf(prevGen, "%s", curGen);
loadingTime += tmpTime;
lstartTime = getTime();
initFAST(seqList, seqListSize, samplingLocs, samplingLocsSize, fileName[fc][0]);
mapSingleEndSeq();
mappingTime += getTime() - lstartTime;
if (maxMem < getMemUsage())
{
maxMem = getMemUsage();
}
} while (flag);
} // end for;
finalizeFAST();
finalizeLoadingHashTable();
}
// Pairedend Mapping Mode
else
{
for (fc = 0; fc <fileCnt; fc++)
{
if (!initLoadingHashTable(fileName[fc][1]))
{
return 1;
}
loadSamplingLocations(&samplingLocs, &samplingLocsSize);
mappingTime = 0;
loadingTime = 0;
prevGen[0] = '\0';
flag = 1;
do
{
flag = loadHashTable ( &tmpTime ); // Reading a fragment
curGen = getRefGenomeName();
// First Time
if (flag && prevGen[0]== '\0')
{
sprintf(prevGen, "%s", curGen);
}
if ( !flag || strcmp(prevGen, curGen)!=0)
{
// DISCORDANT
lstartTime = getTime();
outputPairedEnd();
mappingTime += getTime() - lstartTime;
//DISCORDANT
fprintf(stdout, "| %15s | %15.2f | %15.2f | %15.2f | %15lld %15lld |\n",
prevGen,loadingTime, mappingTime, maxMem, mappingCnt , mappedSeqCnt);
fflush(stdout);
totalMappingTime += mappingTime;
totalLoadingTime += loadingTime;
loadingTime = 0;
mappingTime = 0;
maxMem = 0;
if (!flag)
{
break;
}
}
else if (progressRep && mappingTime != 0)
{
fprintf(stdout, "| %15s | %15.2f | %15.2f | %15.2f | %15lld %15lld |\n",
prevGen,loadingTime, mappingTime, maxMem, mappingCnt , mappedSeqCnt);
fflush(stdout);
}
sprintf(prevGen, "%s", curGen);
loadingTime += tmpTime;
lstartTime = getTime();
initFAST(seqList, seqListSize, samplingLocs, samplingLocsSize, fileName[fc][0]);
mapPairedEndSeq();
mappingTime += getTime() - lstartTime;
if (maxMem < getMemUsage())
{
maxMem = getMemUsage();
}
} while (flag);
} // end for;
finalizeLoadingHashTable();
if (pairedEndDiscordantMode)
{
lstartTime = getTime();
outputPairedEndDiscPP();
ppTime = getTime() - lstartTime;
}
finalizeFAST();
}
}
/********************************
* Bisulfite Mode
********************************/
{
//TODO
}
finalizeOutput();
fprintf(stdout, "-----------------------------------------------------------------------------------------------------------\n");
fprintf(stdout, "%19s%16.2f%18.2f\n\n", "Total:",totalLoadingTime, totalMappingTime);
if (pairedEndDiscordantMode)
fprintf(stdout, "Post Processing Time: %18.2f \n", ppTime);
fprintf(stdout, "%-30s%10.2f\n","Total Time:", totalMappingTime+totalLoadingTime);
fprintf(stdout, "%-30s%10d\n","Total No. of Reads:", seqListSize);
fprintf(stdout, "%-30s%10lld\n","Total No. of Mappings:", mappingCnt);
fprintf(stdout, "%-30s%10.0f\n\n","Avg No. of locations verified:", ceil((float)verificationCnt/seqListSize));
int cof = (pairedEndMode)?2:1;
if (progressRep && maxHits != 0)
{
int frequency[maxHits+1];
int i;
for ( i=0 ; i <= maxHits; i++)
{
frequency[i] = 0;
}
for (fc = 0; fc < seqListSize; fc++)
{
frequency[*(seqList[fc*cof].hits)]++;
}
frequency[maxHits] = completedSeqCnt;
for ( i=0 ; i <= maxHits; i++)
{
fprintf(stdout, "%-30s%10d%10d%10.2f%%\n","Reads Mapped to ", i, frequency[i], 100*(float)frequency[i]/(float)seqListSize);
}
}
if (strcmp(unmappedOutput, "") == 0)
{
char fn[strlen(mappingOutputPath) + strlen(mappingOutput) + 6 ];
sprintf(fn, "%s%s.nohit", mappingOutputPath, mappingOutput );
finalizeReads(fn);
}
else
{
finalizeReads(unmappedOutput);
}
freeMem(prevGen, CONTIG_NAME_SIZE);
}
return 0;
}
int main(int argc, char *argv[])
{
parseCommandLineOptions(argc, argv);
initializeRandomNumberGeneratorTo(rng_seed);
initializeOutput();
setInitialConditions();
if (graphicsModeEnabled()) initializeDisplay();
perturbation_length=fixed_perturbation_length;
for(monte_carlo_steps=start_mcs; monte_carlo_steps<=end_mcs; monte_carlo_steps++)
{
updatePairList();
generateOutput();
attempted_moves = 0;
accepted_moves = 0;
for (monte_carlo_step_counter=0; monte_carlo_step_counter<number_of_molecules; monte_carlo_step_counter++)
{
double boltzmann_factor;
double the_exponential;
delta_energy = 0;
attemptMove();
attempted_moves++;
if (delta_energy < 0)
{
change_flag = 1;
accepted_moves++;
continue; /* move accepted */
}
// the following uses reduced temperature
the_exponential = 0.0 - delta_energy/temperature;
/* evaluate exponential, unless it's arbitrarily small */
if (the_exponential > -25)
{
boltzmann_factor = exp(the_exponential);
if (boltzmann_factor > rnd())
{
change_flag = 1;
accepted_moves++;
continue; /* move accepted */
}
}
// revert move
x[particle_number] -= dx;
y[particle_number] -= dy;
z[particle_number] -= dz;
}
if (monte_carlo_steps < relaxation_allowance)
{
acceptance_ratio = (0.0 + accepted_moves)/(0.0 + attempted_moves);
if (acceptance_ratio < target_acceptance_ratio) perturbation_length *= .9;
else if (perturbation_length*perturbation_length*perturbation_length*16 < box_x*box_y*box_z) perturbation_length *=1.1;
}
else perturbation_length = fixed_perturbation_length;
if (graphicsModeEnabled() && changeFlagIsSet()) drawGraphicalRepresentation();
}
finalizeOutput();
return 0;
} /* end main */
