Event *eventTree_getCommonAncestor(Event *event, Event *event2) {
Event *ancestorEvent;
struct List *list;
assert(event != NULL);
assert(event2 != NULL);
assert(event_getEventTree(event) == event_getEventTree(event2));
list = constructEmptyList(0, NULL);
ancestorEvent = event;
while(ancestorEvent != NULL) {
if(ancestorEvent == event2) {
destructList(list);
return event2;
}
listAppend(list, ancestorEvent);
ancestorEvent = event_getParent(ancestorEvent);
}
ancestorEvent = event2;
while((ancestorEvent = event_getParent(ancestorEvent)) != NULL) {
if(listContains(list, ancestorEvent)) {
destructList(list);
return ancestorEvent;
}
}
destructList(list);
assert(FALSE);
return NULL;
}
// Returns a hash mapping from sequence header to sequence data.
static stHash *readFastaFile(char *filename) {
FILE *fasta = fopen(filename, "r");
if (fasta == NULL) {
st_errnoAbort("Could not open fasta file %s", filename);
}
stHash *headerToData = stHash_construct3(stHash_stringKey,
stHash_stringEqualKey,
free,
free);
struct List *seqs = constructEmptyList(0, NULL);
struct List *seqLengths = constructEmptyList(0, free);
struct List *headers = constructEmptyList(0, free);
fastaRead(fasta, seqs, seqLengths, headers);
for (int64_t i = 0; i < seqs->length; i++) {
char *fullHeader = headers->list[i];
stList *headerTokens = stString_splitByString(fullHeader, " ");
char *usableHeader = stString_copy(stList_get(headerTokens, 0));
stHash_insert(headerToData, usableHeader, seqs->list[i]);
stList_destruct(headerTokens);
}
destructList(seqs);
destructList(seqLengths);
destructList(headers);
return headerToData;
}
int main(void){
FILE *in;
int i;
/* Create file handle */
if((in = fopen(FILENAME, "r")) == NULL){
printf("Unable to open file '%s'\n", FILENAME);
return 1;
}
/* Construct sum and current number lists */
list *sum = malloc(sizeof(list));
constructList(sum, LENGTH);
list *currNum = malloc(sizeof(list));
constructList(currNum, LENGTH);
/* Compute the large number by repetitively loading the numbers from file and adding to sum */
loadNumber(in, sum);
for (i = 1; i < NUMBERS; i++) {
loadNumber(in, currNum);
addNumber(sum, currNum);
}
/* Print the first 10 digits of sum */
printNumber(sum);
/* Deconstruct all constructs */
fclose(in);
destructList(sum);
free(sum);
free(currNum);
return 0;
}
int main(int argc, char *argv[])
{
struct node node_1 = {'a', NULL};
struct node node_2 = {'b', NULL};
struct node node_3 = {'c', NULL};
struct node node_4 = {'d', NULL};
struct node node_5 = {'e', NULL};
struct node* temporaryNode = NULL;
struct node* iteratorNode = NULL;
int count = 1;
struct node* dynamicNode = NULL;
printf("Static Linked List funcitons\n");
insertNode(&node_1, &node_2);
insertNode(&node_1, &node_3);
insertNode(&node_1, &node_4);
insertNode(&node_1, &node_5);
iteratorNode = &node_1;
do {
temporaryNode = iteratorNode;
iteratorNode = nextNode(temporaryNode);
printf("node[%d].value = %c\n", count, temporaryNode->value);
count++;
} while(temporaryNode != iteratorNode);
printf("Dynamic Linked List functions\n");
dynamicNode = createNode('1');
printf("dynamicList at %p\n", dynamicNode);
printf("dynamicNode.value: %c\n", dynamicNode->value);
dynamicNode->next = createNode('2');
temporaryNode = getLastNode(dynamicNode);
printf("temporaryNode at %p\n", temporaryNode);
printf("lastNode.value: %c\n", temporaryNode->value);
temporaryNode->next = createNode('3');
temporaryNode = getLastNode(dynamicNode);
printf("temporaryNode at %p\n", temporaryNode);
printf("lastNode.value: %c\n", temporaryNode->value);
temporaryNode->next = createNode('4');
temporaryNode = getLastNode(dynamicNode);
printf("temporaryNode at %p\n", temporaryNode);
printf("lastNode.value: %c\n", temporaryNode->value);
destructLastNode(dynamicNode);
temporaryNode = getLastNode(dynamicNode);
printf("temporaryNode at %p\n", temporaryNode);
printf("lastNode.value: %c\n", temporaryNode->value);
printf("total of nodes %d\n", allocatedNodes.count);
destructList(dynamicNode); //frees the linked list
printf("total of nodes %d\n", allocatedNodes.count);
forceUnregisterAllNodes();//frees all the nodes allocated
}
void event_destruct(Event *event) {
int64_t i;
Event *childEvent;
Event *parentEvent = event_getParent(event);
if (parentEvent != NULL) {
listRemove(parentEvent->children, event);
}
eventTree_removeEvent(event_getEventTree(event), event);
for (i = 0; i < event->children->length; i++) {
childEvent = event->children->list[i];
childEvent->parent = parentEvent;
if (parentEvent != NULL) {
listAppend(parentEvent->children, childEvent);
}
}
destructList(event->children);
free(event->header);
free(event);
}
int main(int argc, char *argv[]) {
/*
* Arguments/options
*/
char * logLevelString = NULL;
char * mAFFile1 = NULL;
char * mAFFile2 = NULL;
char * outputFile = NULL;
int32_t sampleNumber = 1000000; // by default do a million samples per pair.
char * trioFile = NULL;
///////////////////////////////////////////////////////////////////////////
// (0) Parse the inputs handed by genomeCactus.py / setup stuff.
///////////////////////////////////////////////////////////////////////////
while(1) {
static struct option long_options[] = {
{ "logLevel", required_argument, 0, 'a' },
{ "mAFFile1", required_argument, 0, 'b' },
{ "mAFFile2", required_argument, 0, 'c' },
{ "outputFile", required_argument, 0, 'd' },
{ "sampleNumber", required_argument, 0, 'e' },
{ "trioFile", required_argument, 0, 'f' },
{ "help", no_argument, 0, 'h' },
{ 0, 0, 0, 0 }
};
int option_index = 0;
int key = getopt_long(argc, argv, "a:b:c:d:e:f:h", long_options, &option_index);
if(key == -1) {
break;
}
switch(key) {
case 'a':
logLevelString = stString_copy(optarg);
break;
case 'b':
mAFFile1 = stString_copy(optarg);
break;
case 'c':
mAFFile2 = stString_copy(optarg);
break;
case 'd':
outputFile = stString_copy(optarg);
break;
case 'e':
assert(sscanf(optarg, "%i", &sampleNumber) == 1);
break;
case 'f':
trioFile = stString_copy(optarg);
break;
case 'h':
usage();
return 0;
default:
usage();
return 1;
}
}
///////////////////////////////////////////////////////////////////////////
// (0) Check the inputs.
///////////////////////////////////////////////////////////////////////////
if (argc == 1) {
usage();
return 1;
}
assert(mAFFile1 != NULL);
assert(mAFFile2 != NULL);
assert(outputFile != NULL);
assert(trioFile != NULL);
FILE *fileHandle = fopen(mAFFile1, "r");
if (fileHandle == NULL) {
fprintf(stderr, "ERROR, unable to open `%s', is path correct?\n", mAFFile1);
exit(1);
}
fclose(fileHandle);
fileHandle = fopen(mAFFile2, "r");
if (fileHandle == NULL) {
fprintf(stderr, "ERROR, unable to open `%s', is path correct?\n", mAFFile2);
exit(1);
}
fclose(fileHandle);
fileHandle = fopen(trioFile, "r");
if (fileHandle == NULL) {
fprintf(stderr, "ERROR, unable to open `%s', is path correct?\n", trioFile);
exit(1);
}
fclose(fileHandle);
//////////////////////////////////////////////
//Set up logging
//////////////////////////////////////////////
st_setLogLevelFromString(logLevelString);
//////////////////////////////////////////////
//Log (some of) the inputs
//////////////////////////////////////////////
st_logInfo("MAF file 1 name : %s\n", mAFFile1);
st_logInfo("MAF file 2 name : %s\n", mAFFile2);
st_logInfo("Trio species name : %s\n", trioFile);
st_logInfo("Output stats file : %s\n", outputFile);
/* Parse the trioFile triples into a list */
struct List *speciesList = parseTrioFile(trioFile);
//////////////////////////////////////////////
// Create hashtable for the first MAF file.
//////////////////////////////////////////////
struct hashtable *seqNameHash;
seqNameHash = create_hashtable(256, hashtable_stringHashKey, hashtable_stringEqualKey, free, free);
populateNameHash(mAFFile1, seqNameHash);
// TODO: Check if query species are in maf file
//////////////////////////////////////////////
//Do comparisons.
//////////////////////////////////////////////
struct avl_table *results_12 = compareMAFs_AB_Trio(mAFFile1, mAFFile2, sampleNumber, seqNameHash, speciesList);
struct avl_table *results_21 = compareMAFs_AB_Trio(mAFFile2, mAFFile1, sampleNumber, seqNameHash, speciesList);
fileHandle = fopen(outputFile, "w");
if (fileHandle == NULL) {
fprintf(stderr, "ERROR, unable to open `%s' for writing.\n", outputFile);
exit(1);
}
fprintf(fileHandle, "<trio_comparisons sampleNumber=\"%i\">\n", sampleNumber);
reportResultsTrio(results_12, mAFFile1, mAFFile2, fileHandle);
reportResultsTrio(results_21, mAFFile2, mAFFile1, fileHandle);
fprintf(fileHandle, "</trio_comparisons>\n");
fclose(fileHandle);
///////////////////////////////////////////////////////////////////////////
// Clean up.
///////////////////////////////////////////////////////////////////////////
free(mAFFile1);
free(mAFFile2);
free(outputFile);
free(trioFile);
free(logLevelString);
hashtable_destroy(seqNameHash, 1, 1);
avl_destroy(results_12, (void (*)(void *, void *))aTrio_destruct);
avl_destroy(results_21, (void (*)(void *, void *))aTrio_destruct);
destructList(speciesList);
return 0;
}
int main(int argc, char *argv[]) {
/*
* Arguments/options
*/
char *logLevelString = NULL;
char *mfaFile = NULL;
char *outputFile = NULL;
char *treeFile = NULL;
///////////////////////////////////////////////////////////////////////////
// (0) Parse the inputs handed by genomeCactus.py / setup stuff.
///////////////////////////////////////////////////////////////////////////
while (1) {
static struct option long_options[] = {
{ "logLevel", required_argument, 0, 'a' },
{ "mfaFile", required_argument, 0, 'b' },
{ "outputFile", required_argument, 0, 'd' },
{ "treeFile", optional_argument, 0, 't' },
{ "help", no_argument, 0, 'h' },
{ 0, 0, 0, 0 }
};
int option_index = 0;
int key = getopt_long(argc, argv, "a:b:d:t:h", long_options, &option_index);
if (key == -1) {
break;
}
switch (key) {
case 'a':
logLevelString = stString_copy(optarg);
break;
case 'b':
mfaFile = stString_copy(optarg);
break;
case 'd':
outputFile = stString_copy(optarg);
break;
case 't':
treeFile = stString_copy(optarg);
break;
case 'h':
usage();
return 0;
default:
usage();
return 1;
}
}
///////////////////////////////////////////////////////////////////////////
// (0) Check the inputs.
///////////////////////////////////////////////////////////////////////////
if (argc == 1) {
usage();
exit(1);
}
assert(mfaFile != NULL);
assert(outputFile != NULL);
//////////////////////////////////////////////
//Set up logging
//////////////////////////////////////////////
st_setLogLevelFromString(logLevelString);
//////////////////////////////////////////////
//Log (some of) the inputs
//////////////////////////////////////////////
st_logInfo("MFA file name : %s\n", mfaFile);
st_logInfo("Output MAF file : %s\n", outputFile);
st_logInfo("Tree file name: %s\n", treeFile == NULL ? "null" : treeFile);
//////////////////////////////////////////////
//Get the MFA alignment
//////////////////////////////////////////////
//get the alignment
struct List *sequences = constructEmptyList(0, free);
struct List *seqLengths = constructEmptyList(0, (void (*)(void *))destructInt);
struct List *fastaNames = constructEmptyList(0, free);
FILE *fileHandle = fopen(mfaFile, "r");
if (fileHandle == NULL) {
usage();
exit(1);
}
fastaRead(fileHandle, sequences, seqLengths, fastaNames);
fclose(fileHandle);
//////////////////////////////////////////////
//Get the tree alignment
//////////////////////////////////////////////
stTree *tree = NULL;
LeafPtrArray *leafArray = NULL;
int32_t leafCount = 0;
if (treeFile != NULL) {
tree = eTreeX_getTreeFromFile(treeFile);
eTreeX_postOrderTraversal(tree, eTreeX_countLeaves, &leafCount);
leafArray = eTreeX_constructLeafPtrArray(leafCount);
eTreeX_postOrderTraversal(tree, eTreeX_getLeafArray, (void *) leafArray);
}
//////////////////////////////////////////////
//Write the MFA alignment.
//////////////////////////////////////////////
fileHandle = fopen(outputFile, "w");
//write the header.
fprintf(fileHandle, "##maf version=1 scoring=NULL\n");
fprintf(fileHandle, "# converted_from_MFA\n\n");
//write the score line
char *treeString = NULL;
if (treeFile != NULL) {
treeString = stTree_getNewickTreeString(tree);
fprintf(fileHandle, "a score=0 tree=\"%s\"\n", treeString);
}
else {
fprintf(fileHandle, "a score=0\n");
leafCount = sequences->length;
}
//write the alignment
int32_t i, j;
int32_t ii;
const char *label;
for (ii=0; ii<leafCount; ii++) {
if (treeFile != NULL) {
label = stTree_getLabel((stTree *) leafArray->ptrArray[ii]);
/* Do a brute force search to find the appropriate sequence that matches "label" */
for (i=0; i<sequences->length; i++) {
char *fastaHeader = fastaNames->list[i];
char *sequenceName = st_malloc(sizeof(char) *(1 + strlen(fastaHeader)));
sscanf(fastaHeader, "%s", sequenceName); //take the sequence name to be the first word of the sequence.
if (strcmp(label, sequenceName) == 0) {
free(sequenceName);
break;
}
free(sequenceName);
}
}
else {
i = ii;
}
char *sequence = sequences->list[i];
int32_t seqLength = *((int32_t *)seqLengths->list[i]);
assert(seqLength == (int32_t)strlen(sequence));
char *fastaHeader = fastaNames->list[i];
char *sequenceName = st_malloc(sizeof(char) *(1 + strlen(fastaHeader)));
sscanf(fastaHeader, "%s", sequenceName); //take the sequence name to be the first word of the sequence.
int32_t length = 0;
for (j=0; j<(int32_t)strlen(sequence); j++) {
if (sequence[j] != '-') {
length++;
}
}
fprintf(fileHandle, "s\t%s\t%i\t%i\t%s\t%i\t%s\n", sequenceName, 0, length, "+", length, sequence);
free(sequenceName);
}
fclose(fileHandle);
//////////////////////////////////////////////
//Clean up.
//////////////////////////////////////////////
free(mfaFile);
free(outputFile);
free(treeFile);
if (treeFile != NULL) {
stTree_destruct(tree);
free(treeString);
eTreeX_destructLeafPtrArray(leafArray);
}
destructList(sequences);
destructList(seqLengths);
destructList(fastaNames);
return 0;
}
