void testEnd_getInstanceNumber(CuTest* testCase) {
cactusEndTestSetup();
End *end2 = end_construct(0, flower);
CuAssertTrue(testCase, end_getInstanceNumber(end2) == 0);
CuAssertTrue(testCase, end_getInstanceNumber(end) == 4);
cactusEndTestTeardown();
}
int main(int argc, char *argv[]) {
st_setLogLevelFromString(argv[1]);
st_logDebug("Set up logging\n");
stKVDatabaseConf *kvDatabaseConf = stKVDatabaseConf_constructFromString(argv[2]);
CactusDisk *cactusDisk = cactusDisk_construct(kvDatabaseConf, 0);
stKVDatabaseConf_destruct(kvDatabaseConf);
st_logDebug("Set up the flower disk\n");
Name flowerName = cactusMisc_stringToName(argv[3]);
Flower *flower = cactusDisk_getFlower(cactusDisk, flowerName);
int64_t totalBases = flower_getTotalBaseLength(flower);
int64_t totalEnds = flower_getEndNumber(flower);
int64_t totalFreeEnds = flower_getFreeStubEndNumber(flower);
int64_t totalAttachedEnds = flower_getAttachedStubEndNumber(flower);
int64_t totalCaps = flower_getCapNumber(flower);
int64_t totalBlocks = flower_getBlockNumber(flower);
int64_t totalGroups = flower_getGroupNumber(flower);
int64_t totalChains = flower_getChainNumber(flower);
int64_t totalLinkGroups = 0;
int64_t maxEndDegree = 0;
int64_t maxAdjacencyLength = 0;
int64_t totalEdges = 0;
Flower_EndIterator *endIt = flower_getEndIterator(flower);
End *end;
while((end = flower_getNextEnd(endIt)) != NULL) {
assert(end_getOrientation(end));
if(end_getInstanceNumber(end) > maxEndDegree) {
maxEndDegree = end_getInstanceNumber(end);
}
stSortedSet *ends = stSortedSet_construct();
End_InstanceIterator *capIt = end_getInstanceIterator(end);
Cap *cap;
while((cap = end_getNext(capIt)) != NULL) {
if(cap_getSequence(cap) != NULL) {
Cap *adjacentCap = cap_getAdjacency(cap);
assert(adjacentCap != NULL);
End *adjacentEnd = end_getPositiveOrientation(cap_getEnd(adjacentCap));
stSortedSet_insert(ends, adjacentEnd);
int64_t adjacencyLength = cap_getCoordinate(cap) - cap_getCoordinate(adjacentCap);
if(adjacencyLength < 0) {
adjacencyLength *= -1;
}
assert(adjacencyLength >= 1);
if(adjacencyLength >= maxAdjacencyLength) {
maxAdjacencyLength = adjacencyLength;
}
}
}
end_destructInstanceIterator(capIt);
totalEdges += stSortedSet_size(ends);
if(stSortedSet_search(ends, end) != NULL) { //This ensures we count self edges twice, so that the division works.
totalEdges += 1;
}
stSortedSet_destruct(ends);
}
assert(totalEdges % 2 == 0);
flower_destructEndIterator(endIt);
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while((group = flower_getNextGroup(groupIt)) != NULL) {
if(group_getLink(group) != NULL) {
totalLinkGroups++;
}
}
flower_destructGroupIterator(groupIt);
printf("flower name: %" PRIi64 " total bases: %" PRIi64 " total-ends: %" PRIi64 " total-caps: %" PRIi64 " max-end-degree: %" PRIi64 " max-adjacency-length: %" PRIi64 " total-blocks: %" PRIi64 " total-groups: %" PRIi64 " total-edges: %" PRIi64 " total-free-ends: %" PRIi64 " total-attached-ends: %" PRIi64 " total-chains: %" PRIi64 " total-link groups: %" PRIi64 "\n",
flower_getName(flower), totalBases, totalEnds, totalCaps, maxEndDegree, maxAdjacencyLength, totalBlocks, totalGroups, totalEdges/2, totalFreeEnds, totalAttachedEnds, totalChains, totalLinkGroups);
return 0;
}
int main(int argc, char *argv[]) {
char * logLevelString = NULL;
char * cactusDiskDatabaseString = NULL;
int64_t i, j;
int64_t spanningTrees = 10;
int64_t maximumLength = 1500;
bool useProgressiveMerging = 0;
float matchGamma = 0.5;
bool useBanding = 0;
int64_t k;
stList *listOfEndAlignmentFiles = NULL;
char *endAlignmentsToPrecomputeOutputFile = NULL;
bool calculateWhichEndsToComputeSeparately = 0;
int64_t largeEndSize = 1000000;
int64_t chainLengthForBigFlower = 1000000;
int64_t longChain = 2;
char *ingroupCoverageFilePath = NULL;
int64_t minimumSizeToRescue = 1;
double minimumCoverageToRescue = 0.0;
PairwiseAlignmentParameters *pairwiseAlignmentBandingParameters = pairwiseAlignmentBandingParameters_construct();
/*
* Setup the input parameters for cactus core.
*/
bool pruneOutStubAlignments = 0;
/*
* Parse the options.
*/
while (1) {
static struct option long_options[] = { { "logLevel", required_argument, 0, 'a' }, { "cactusDisk", required_argument, 0, 'b' }, {
"help", no_argument, 0, 'h' }, { "spanningTrees", required_argument, 0, 'i' },
{ "maximumLength", required_argument, 0, 'j' }, { "useBanding", no_argument, 0, 'k' },
{ "gapGamma", required_argument, 0, 'l' }, { "matchGamma", required_argument, 0, 'L' },
{ "splitMatrixBiggerThanThis", required_argument, 0, 'o' }, { "anchorMatrixBiggerThanThis",
required_argument, 0, 'p' }, { "repeatMaskMatrixBiggerThanThis", required_argument, 0, 'q' }, {
"diagonalExpansion", required_argument, 0, 'r' }, { "constraintDiagonalTrim", required_argument, 0, 't' }, {
"minimumDegree", required_argument, 0, 'u' }, { "alignAmbiguityCharacters", no_argument, 0, 'w' }, {
"pruneOutStubAlignments", no_argument, 0, 'y' }, {
"minimumIngroupDegree", required_argument, 0, 'A' }, { "minimumOutgroupDegree", required_argument, 0, 'B' },
{ "precomputedAlignments", required_argument, 0, 'D' }, {
"endAlignmentsToPrecomputeOutputFile", required_argument, 0, 'E' }, { "useProgressiveMerging",
no_argument, 0, 'F' }, { "calculateWhichEndsToComputeSeparately", no_argument, 0, 'G' }, { "largeEndSize",
required_argument, 0, 'I' },
{"ingroupCoverageFile", required_argument, 0, 'J'},
{"minimumSizeToRescue", required_argument, 0, 'K'},
{"minimumCoverageToRescue", required_argument, 0, 'M'},
{ "minimumNumberOfSpecies", required_argument, 0, 'N' },
{ 0, 0, 0, 0 } };
int option_index = 0;
int key = getopt_long(argc, argv, "a:b:hi:j:kl:o:p:q:r:t:u:wy:A:B:D:E:FGI:J:K:L:M:N:", long_options, &option_index);
if (key == -1) {
break;
}
switch (key) {
case 'a':
logLevelString = stString_copy(optarg);
st_setLogLevelFromString(logLevelString);
break;
case 'b':
cactusDiskDatabaseString = stString_copy(optarg);
break;
case 'h':
usage();
return 0;
case 'i':
i = sscanf(optarg, "%" PRIi64 "", &spanningTrees);
(void) i;
assert(i == 1);
assert(spanningTrees >= 0);
break;
case 'j':
i = sscanf(optarg, "%" PRIi64 "", &maximumLength);
assert(i == 1);
assert(maximumLength >= 0);
break;
case 'k':
useBanding = !useBanding;
break;
case 'l':
i = sscanf(optarg, "%f", &pairwiseAlignmentBandingParameters->gapGamma);
assert(i == 1);
assert(pairwiseAlignmentBandingParameters->gapGamma >= 0.0);
break;
case 'L':
i = sscanf(optarg, "%f", &matchGamma);
assert(i == 1);
assert(matchGamma >= 0.0);
break;
case 'o':
i = sscanf(optarg, "%" PRIi64 "", &k);
assert(i == 1);
assert(k >= 0);
pairwiseAlignmentBandingParameters->splitMatrixBiggerThanThis = (int64_t) k * k;
break;
case 'p':
i = sscanf(optarg, "%" PRIi64 "", &k);
assert(i == 1);
assert(k >= 0);
pairwiseAlignmentBandingParameters->anchorMatrixBiggerThanThis = (int64_t) k * k;
break;
case 'q':
i = sscanf(optarg, "%" PRIi64 "", &k);
assert(i == 1);
assert(k >= 0);
pairwiseAlignmentBandingParameters->repeatMaskMatrixBiggerThanThis = (int64_t) k * k;
break;
case 'r':
i = sscanf(optarg, "%" PRIi64 "", &pairwiseAlignmentBandingParameters->diagonalExpansion);
assert(i == 1);
assert(pairwiseAlignmentBandingParameters->diagonalExpansion >= 0);
assert(pairwiseAlignmentBandingParameters->diagonalExpansion % 2 == 0);
break;
case 't':
i = sscanf(optarg, "%" PRIi64 "", &pairwiseAlignmentBandingParameters->constraintDiagonalTrim);
assert(i == 1);
assert(pairwiseAlignmentBandingParameters->constraintDiagonalTrim >= 0);
break;
case 'u':
i = sscanf(optarg, "%" PRIi64 "", &minimumDegree);
assert(i == 1);
break;
case 'w':
pairwiseAlignmentBandingParameters->alignAmbiguityCharacters = 1;
break;
case 'y':
pruneOutStubAlignments = 1;
break;
case 'A':
i = sscanf(optarg, "%" PRIi64 "", &minimumIngroupDegree);
assert(i == 1);
break;
case 'B':
i = sscanf(optarg, "%" PRIi64 "", &minimumOutgroupDegree);
assert(i == 1);
break;
case 'D':
listOfEndAlignmentFiles = stString_split(optarg);
break;
case 'E':
endAlignmentsToPrecomputeOutputFile = stString_copy(optarg);
break;
case 'F':
useProgressiveMerging = 1;
break;
case 'G':
calculateWhichEndsToComputeSeparately = 1;
break;
case 'I':
i = sscanf(optarg, "%" PRIi64 "", &largeEndSize);
assert(i == 1);
break;
case 'J':
ingroupCoverageFilePath = stString_copy(optarg);
break;
case 'K':
i = sscanf(optarg, "%" PRIi64, &minimumSizeToRescue);
assert(i == 1);
break;
case 'M':
i = sscanf(optarg, "%lf", &minimumCoverageToRescue);
assert(i == 1);
break;
case 'N':
i = sscanf(optarg, "%" PRIi64, &minimumNumberOfSpecies);
if (i != 1) {
st_errAbort("Error parsing minimumNumberOfSpecies parameter");
}
break;
default:
usage();
return 1;
}
}
st_setLogLevelFromString(logLevelString);
/*
* Load the flowerdisk
*/
stKVDatabaseConf *kvDatabaseConf = stKVDatabaseConf_constructFromString(cactusDiskDatabaseString);
CactusDisk *cactusDisk = cactusDisk_construct(kvDatabaseConf, 0); //We precache the sequences
st_logInfo("Set up the flower disk\n");
/*
* Load the hmm
*/
StateMachine *sM = stateMachine5_construct(fiveState);
/*
* For each flower.
*/
if (calculateWhichEndsToComputeSeparately) {
stList *flowers = flowerWriter_parseFlowersFromStdin(cactusDisk);
if (stList_length(flowers) != 1) {
st_errAbort("We are breaking up a flower's end alignments for precomputation but we have %" PRIi64 " flowers.\n", stList_length(flowers));
}
stSortedSet *endsToAlignSeparately = getEndsToAlignSeparately(stList_get(flowers, 0), maximumLength, largeEndSize);
assert(stSortedSet_size(endsToAlignSeparately) != 1);
stSortedSetIterator *it = stSortedSet_getIterator(endsToAlignSeparately);
End *end;
while ((end = stSortedSet_getNext(it)) != NULL) {
fprintf(stdout, "%s\t%" PRIi64 "\t%" PRIi64 "\n", cactusMisc_nameToStringStatic(end_getName(end)), end_getInstanceNumber(end), getTotalAdjacencyLength(end));
}
return 0; //avoid cleanup costs
stSortedSet_destructIterator(it);
stSortedSet_destruct(endsToAlignSeparately);
} else if (endAlignmentsToPrecomputeOutputFile != NULL) {
/*
* In this case we will align a set of end and save the alignments in a file.
*/
stList *names = flowerWriter_parseNames(stdin);
Flower *flower = cactusDisk_getFlower(cactusDisk, *((Name *)stList_get(names, 0)));
FILE *fileHandle = fopen(endAlignmentsToPrecomputeOutputFile, "w");
for(int64_t i=1; i<stList_length(names); i++) {
End *end = flower_getEnd(flower, *((Name *)stList_get(names, i)));
if (end == NULL) {
st_errAbort("The end %" PRIi64 " was not found in the flower\n", *((Name *)stList_get(names, i)));
}
stSortedSet *endAlignment = makeEndAlignment(sM, end, spanningTrees, maximumLength, useProgressiveMerging,
matchGamma, pairwiseAlignmentBandingParameters);
writeEndAlignmentToDisk(end, endAlignment, fileHandle);
stSortedSet_destruct(endAlignment);
}
fclose(fileHandle);
return 0; //avoid cleanup costs
stList_destruct(names);
st_logInfo("Finished precomputing end alignments\n");
} else {
/*
* Compute complete flower alignments, possibly loading some precomputed alignments.
*/
bedRegion *bedRegions = NULL;
size_t numBeds = 0;
if (ingroupCoverageFilePath != NULL) {
// Pre-load the mmap for the coverage file.
FILE *coverageFile = fopen(ingroupCoverageFilePath, "rb");
if (coverageFile == NULL) {
st_errnoAbort("Opening coverage file %s failed",
ingroupCoverageFilePath);
}
fseek(coverageFile, 0, SEEK_END);
int64_t coverageFileLen = ftell(coverageFile);
assert(coverageFileLen >= 0);
assert(coverageFileLen % sizeof(bedRegion) == 0);
if (coverageFileLen == 0) {
// mmap doesn't like length-0 mappings, for obvious
// reasons. Pretend that the coverage file doesn't
// exist in this case, since it contains no data.
ingroupCoverageFilePath = NULL;
} else {
// Establish a memory mapping for the file.
bedRegions = mmap(NULL, coverageFileLen, PROT_READ, MAP_SHARED,
fileno(coverageFile), 0);
if (bedRegions == MAP_FAILED) {
st_errnoAbort("Failure mapping coverage file");
}
numBeds = coverageFileLen / sizeof(bedRegion);
}
fclose(coverageFile);
}
stList *flowers = flowerWriter_parseFlowersFromStdin(cactusDisk);
if (listOfEndAlignmentFiles != NULL && stList_length(flowers) != 1) {
st_errAbort("We have precomputed alignments but %" PRIi64 " flowers to align.\n", stList_length(flowers));
}
cactusDisk_preCacheStrings(cactusDisk, flowers);
for (j = 0; j < stList_length(flowers); j++) {
flower = stList_get(flowers, j);
st_logInfo("Processing a flower\n");
stSortedSet *alignedPairs = makeFlowerAlignment3(sM, flower, listOfEndAlignmentFiles, spanningTrees, maximumLength,
useProgressiveMerging, matchGamma, pairwiseAlignmentBandingParameters, pruneOutStubAlignments);
st_logInfo("Created the alignment: %" PRIi64 " pairs\n", stSortedSet_size(alignedPairs));
stPinchIterator *pinchIterator = stPinchIterator_constructFromAlignedPairs(alignedPairs, getNextAlignedPairAlignment);
/*
* Run the cactus caf functions to build cactus.
*/
stPinchThreadSet *threadSet = stCaf_setup(flower);
stCaf_anneal(threadSet, pinchIterator, NULL);
if (minimumDegree < 2) {
stCaf_makeDegreeOneBlocks(threadSet);
}
if (minimumIngroupDegree > 0 || minimumOutgroupDegree > 0 || minimumDegree > 1) {
stCaf_melt(flower, threadSet, blockFilterFn, 0, 0, 0, INT64_MAX);
}
if (ingroupCoverageFilePath != NULL) {
// Rescue any sequence that is covered by outgroups
// but currently unaligned into single-degree blocks.
stPinchThreadSetIt pinchIt = stPinchThreadSet_getIt(threadSet);
stPinchThread *thread;
while ((thread = stPinchThreadSetIt_getNext(&pinchIt)) != NULL) {
Cap *cap = flower_getCap(flower,
stPinchThread_getName(thread));
assert(cap != NULL);
Sequence *sequence = cap_getSequence(cap);
assert(sequence != NULL);
rescueCoveredRegions(thread, bedRegions, numBeds,
sequence_getName(sequence),
minimumSizeToRescue,
minimumCoverageToRescue);
}
stCaf_joinTrivialBoundaries(threadSet);
}
stCaf_finish(flower, threadSet, chainLengthForBigFlower, longChain, INT64_MAX, INT64_MAX); //Flower now destroyed.
stPinchThreadSet_destruct(threadSet);
st_logInfo("Ran the cactus core script.\n");
/*
* Cleanup
*/
//Clean up the sorted set after cleaning up the iterator
stPinchIterator_destruct(pinchIterator);
stSortedSet_destruct(alignedPairs);
st_logInfo("Finished filling in the alignments for the flower\n");
}
stList_destruct(flowers);
//st_errAbort("Done\n");
/*
* Write and close the cactusdisk.
*/
cactusDisk_write(cactusDisk);
return 0; //Exit without clean up is quicker, enable cleanup when doing memory leak detection.
if (bedRegions != NULL) {
// Clean up our mapping.
munmap(bedRegions, numBeds * sizeof(bedRegion));
}
}
///////////////////////////////////////////////////////////////////////////
// Cleanup
///////////////////////////////////////////////////////////////////////////
stateMachine_destruct(sM);
cactusDisk_destruct(cactusDisk);
stKVDatabaseConf_destruct(kvDatabaseConf);
//destructCactusCoreInputParameters(cCIP);
free(cactusDiskDatabaseString);
if (listOfEndAlignmentFiles != NULL) {
stList_destruct(listOfEndAlignmentFiles);
}
if (logLevelString != NULL) {
free(logLevelString);
}
st_logInfo("Finished with the flower disk for this flower.\n");
//while(1);
return 0;
}
