void doAbbaBaba() {
string line; // for reading the input files
std::istream* vcfFile = createReader(opt::vcfFile.c_str());
std::ifstream* setsFile = new std::ifstream(opt::setsFile.c_str());
string setsFileRoot = stripExtension(opt::setsFile);
std::ofstream* outFile = new std::ofstream(setsFileRoot+ "_" + opt::runName + "_abbaBaba.txt");
string windowStartEnd = "scaffold_0\t0";
// Get the sample sets
string outgroupString; std::vector<size_t> Opos; std::vector<string> outgroup;
if (!opt::bAaEqO) { getline(*setsFile, outgroupString); outgroup = split(outgroupString, ','); } else { outgroupString = "VCF AA field"; }
string P3string; getline(*setsFile, P3string); std::vector<string> P3 = split(P3string, ','); std::vector<size_t> P3pos;
string P2string; getline(*setsFile, P2string); std::vector<string> P2 = split(P2string, ','); std::vector<size_t> P2pos;
string P1string; getline(*setsFile, P1string); std::vector<string> P1 = split(P1string, ','); std::vector<size_t> P1pos;
if (!opt::bFrequency && (P1.size() > 1 || P2.size() > 1 || P3.size() > 1)) {
std::cerr << "There are more than one individual on some line of the SETS.txt file" << std::endl;
std::cerr << "Perhaps you want to use the -f option?" << std::endl;
exit(1);
}
// Now go through the vcf and calculate D
int totalVariantNumber = 0;
ABBA_BABA_Freq_allResults r;
int lastPrint = 0; int lastWindowVariant = 0;
std::vector<double> regionDs; std::vector<double> region_f_Gs; std::vector<double> region_f_Ds; std::vector<double> region_f_DMs;
std::vector<string> sampleNames;
while (getline(*vcfFile, line)) {
if (line[0] == '#' && line[1] == '#')
continue;
else if (line[0] == '#' && line[1] == 'C') {
std::vector<std::string> fields = split(line, '\t');
if (opt::sampleNameFile.empty()) {
for (std::vector<std::string>::size_type i = NUM_NON_GENOTYPE_COLUMNS; i != fields.size(); i++) {
sampleNames.push_back(fields[i]);
}
} else {
sampleNames = readSampleNamesFromTextFile(opt::sampleNameFile);
}
if (!opt::bAaEqO) { Opos = locateSet(sampleNames, outgroup); }
P3pos = locateSet(sampleNames, P3);
P2pos = locateSet(sampleNames, P2); P1pos = locateSet(sampleNames, P1);
if (!opt::bAaEqO) { std::cerr << "Outgroup: "; print_vector_stream(outgroup, std::cerr); } else { std::cerr << "Outgroup: " << outgroupString << std::endl; }
std::cerr << "P3: "; print_vector_stream(P3, std::cerr);
std::cerr << "P2: "; print_vector_stream(P2, std::cerr);
std::cerr << "P1: "; print_vector_stream(P1, std::cerr);
} else {
totalVariantNumber++;
std::vector<std::string> fields = split(line, '\t');
std::vector<std::string> info = split(fields[7], ';');
if (info[0] != "INDEL") {
if (!opt::bAaEqO) {
ThreeSetCounts c;
if (opt::bNoAaO) {
c = getThreeSetVariantCountsAA4(fields,P1pos,P2pos,P3pos,Opos);
if (opt::bFrequency) {
incrementDnumDdenomFrequency(c, r);
} else {
incrementDnumDdenomSingleSequence(c, r);
}
} else {
FourSetCounts c;
string AA = getAAfromInfo(info);
if (AA == fields[3]) {
c = getFourSetVariantCounts(fields,P1pos,P2pos,P3pos,Opos,"ref");
} else if (AA == fields[4]) {
c = getFourSetVariantCounts(fields,P1pos,P2pos,P3pos,Opos,"alt");
}
r.Dnumerator += ((1-c.set1daAF)*c.set2daAF*c.set3daAF*(1-c.set4daAF)) - (c.set1daAF*(1-c.set2daAF)*c.set3daAF*(1-c.set4daAF));
r.Ddenominator += ((1-c.set1daAF)*c.set2daAF*c.set3daAF*(1-c.set4daAF)) + (c.set1daAF*(1-c.set2daAF)*c.set3daAF*(1-c.set4daAF));
if (c.set2daAF > c.set3daAF) {
r.f_d_denominator += ((1-c.set1daAF)*c.set2daAF*c.set2daAF*(1-c.set4daAF)) - (c.set1daAF*(1-c.set2daAF)*c.set2daAF*(1-c.set4daAF));
} else {
r.f_d_denominator += ((1-c.set1daAF)*c.set3daAF*c.set3daAF*(1-c.set4daAF)) - (c.set1daAF*(1-c.set3daAF)*c.set3daAF*(1-c.set4daAF));
}
}
} else {
string AA = getAAfromInfo(info);
ThreeSetCounts c;
if (AA == fields[3]) {
c = getThreeSetVariantCounts(fields,P1pos,P2pos,P3pos,"ref");
} else if (AA == fields[4]) {
c = getThreeSetVariantCounts(fields,P1pos,P2pos,P3pos,"alt");
}
if (opt::bFrequency) {
incrementDnumDdenomFrequency(c, r);
} else {
incrementDnumDdenomSingleSequence(c, r);
}
}
// if (totalVariantNumber % 100000 == 0) { std::cerr << Dnumerator << std::endl; }
} else {
ABBABABAcounts::indels++;
}
if (ABBABABAcounts::usedVariantsCounter % opt::windowSize == 0 && ABBABABAcounts::usedVariantsCounter != lastWindowVariant) {
std::vector<string> s = split(windowStartEnd, '\t');
if (s[0] == fields[0]) {
windowStartEnd = windowStartEnd + "\t" + fields[1];
if ((double)r.windowDnum/r.window_f_dM_denominator > 1) {
std::cerr << "D num" << r.windowDnum << std::endl;
std::cerr << "f_dM denom" << r.window_f_dM_denominator << std::endl;
}
*outFile << windowStartEnd << "\t" << (double)r.windowDnum/r.windowDdenom << "\t" << (double)r.window_f_d_num/r.window_f_d_denominator << "\t" << (double)r.windowDnum/r.window_f_dM_denominator << std::endl;
windowStartEnd = fields[0] + "\t" + fields[1];
} else {
windowStartEnd = fields[0] + "\t0";
}
r.windowDnum = 0; r.windowDdenom = 0; r.window_f_d_num = 0; r.window_f_d_denominator = 0; r.window_f_dM_denominator = 0; lastWindowVariant = ABBABABAcounts::usedVariantsCounter;
}
if (ABBABABAcounts::usedVariantsCounter % opt::jackKniveWindowSize == 0 && ABBABABAcounts::usedVariantsCounter != lastPrint) {
//if (totalVariantNumber % 100000 == 0) {
if (opt::bFrequency)
assert(ABBABABAcounts::XXAA + ABBABABAcounts::AABA + ABBABABAcounts::BBBA + ABBABABAcounts::indels + ABBABABAcounts::noDafInfo + ABBABABAcounts::usedVariantsCounter + ABBABABAcounts::p1p2 == totalVariantNumber);
if (ABBABABAcounts::usedVariantsCounter > (6 * opt::jackKniveWindowSize)) {
double Dstd_err = jackknive_std_err(regionDs); double f_Gstd_err = jackknive_std_err(region_f_Gs);
double f_Dstd_err = jackknive_std_err(region_f_Ds); double f_DMstd_err = jackknive_std_err(region_f_DMs);
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tD=" << (double)r.Dnumerator/r.Ddenominator << " std_err=" << Dstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_G=" << (double)r.f_G_num/r.f_G_denom << " std_err=" << f_Gstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_d=" << (double)r.f_d_num/r.f_d_denominator << " std_err=" << f_Dstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_dM=" << (double)r.Dnumerator/r.f_dM_denominator << " std_err=" << f_DMstd_err << std::endl;
} else {
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tD=" << (double)r.Dnumerator/r.Ddenominator << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_G=" << (double)r.f_G_num/r.f_G_denom << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_d=" << (double)r.f_d_num/r.f_d_denominator << std::endl;
std::cerr << totalVariantNumber << " variants processed. " << ABBABABAcounts::usedVariantsCounter << " variants used. \tf_dM=" << (double)r.Dnumerator/r.f_dM_denominator << std::endl;
}
std::cerr << "Last used "<< opt::jackKniveWindowSize << " variants \t\t\t\tD=" << r.lastVarsDnum/r.lastVarsDdenom << std::endl;
// std::cerr << "AAAA=" << XXAA << "; AABA=" << AABA << "; BBBA=" << BBBA << std::endl;
regionDs.push_back(r.lastVarsDnum/r.lastVarsDdenom); region_f_Gs.push_back(r.lastVarsF_G_num/r.lastVarsF_G_denom);
region_f_Ds.push_back(r.lastVarsF_d_num/r.lastVarsF_d_denom); region_f_DMs.push_back(r.lastVarsDnum/r.lastVarsF_dM_denom);
r.lastVarsDnum = 0; r.lastVarsDdenom = 0; r.lastVarsF_d_num = 0; r.lastVarsF_d_denom = 0; r.lastVarsF_G_num = 0; r.lastVarsF_G_denom = 0; r.lastVarsF_dM_denom = 0;
lastPrint = ABBABABAcounts::usedVariantsCounter;
}
}
}
double Dstd_err = jackknive_std_err(regionDs); double f_Gstd_err = jackknive_std_err(region_f_Gs);
double f_Dstd_err = jackknive_std_err(region_f_Ds); double f_DMstd_err = jackknive_std_err(region_f_DMs);
std::cerr << std::endl;
std::cerr << totalVariantNumber << " variants processed. D=" << (double)r.Dnumerator/r.Ddenominator << " std_err=" << Dstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. f_G=" << (double)r.f_G_num/r.f_G_denom << " std_err=" << f_Gstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. f_d=" << (double)r.f_d_num/r.f_d_denominator << " std_err=" << f_Dstd_err << std::endl;
std::cerr << totalVariantNumber << " variants processed. f_dM=" << (double)r.Dnumerator/r.f_dM_denominator << " std_err=" << f_DMstd_err << std::endl;
}
int DminCombineMain(int argc, char** argv) {
parseDminCombineOptions(argc, argv);
string line; // for reading the input files
std::vector<std::istream*> dminstdErrFiles; std::vector<std::istream*> dminBBAAscoreFiles;
for (int i = 0; i < opt::dminFiles.size(); i++) {
std::istream* dminBBAAscoreFile;
if (file_exists(opt::dminFiles[i] + "_combine.txt")) {
dminBBAAscoreFile = createReader((opt::dminFiles[i] + "_combine.txt").c_str());
} else if(file_exists(opt::dminFiles[i] + "_combine.txt.gz")) {
dminBBAAscoreFile = createReader((opt::dminFiles[i] + "_combine.txt.gz").c_str());
} else {
std::cerr << "Can't fine the file: " << opt::dminFiles[i] + "_combine.txt" << " or " << opt::dminFiles[i] + "_combine.txt.gz" << std::endl;
}
dminBBAAscoreFiles.push_back(dminBBAAscoreFile);
std::istream* dminstdErrFile;
if (file_exists(opt::dminFiles[i] + "_combine_stderr.txt")) {
dminstdErrFile = createReader((opt::dminFiles[i] + "_combine_stderr.txt").c_str());
} else if(file_exists(opt::dminFiles[i] + "_combine_stderr.txt.gz")) {
dminstdErrFile = createReader((opt::dminFiles[i] + "_combine_stderr.txt.gz").c_str());
} else {
std::cerr << "Can't fine the file: " << opt::dminFiles[i] + "_combine_stderr.txt" << " or " << opt::dminFiles[i] + "_combine_stderr.txt.gz" << std::endl;
}
dminstdErrFiles.push_back(dminstdErrFile);
std::cerr << "Reading file " << opt::dminFiles[i] << std::endl;
}
// Now get the standard error values
std::ofstream* outFileBBAA = new std::ofstream(opt::runName + "_BBAA.txt"); std::ofstream* outFileDmin = new std::ofstream(opt::runName + "_Dmin.txt");
std::vector<double> BBAA_local_Ds; std::vector<double> ABBA_local_Ds; std::vector<double> BABA_local_Ds;
string s1; string s2; string s3;
double BBAAtotal = 0; double ABBAtotal = 0; double BABAtotal = 0;
bool allDone = false;
int processedTriosNumber = 0;
do {
processedTriosNumber++;
if (processedTriosNumber % 10000 == 0) {
//durationOverall = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
std::cerr << "Processed " << processedTriosNumber << " trios" << std::endl;
//std::cerr << "GettingCounts " << durationGettingCounts << " calculation " << durationCalculation << "secs" << std::endl;
}
if (opt::subsetStart != -1) {
if (processedTriosNumber < opt::subsetStart) {
for (int i = 0; i < dminBBAAscoreFiles.size(); i++) { getline(*dminBBAAscoreFiles[i], line); }
for (int i = 0; i < dminstdErrFiles.size(); i++) { getline(*dminstdErrFiles[i], line); }
continue;
}
if (processedTriosNumber > (opt::subsetStart+opt::subsetLength)) {
std::cerr << "DONE" << std::endl; break;
}
}
for (int i = 0; i < dminBBAAscoreFiles.size(); i++) {
if (getline(*dminBBAAscoreFiles[i], line)) {
std::vector<string> patternCounts = split(line, '\t');
assert(patternCounts.size() == 6);
if (i == 0) {
s1 = patternCounts[0];
s2 = patternCounts[1];
s3 = patternCounts[2];
} else {
assert(s1 == patternCounts[0]); assert(s2 == patternCounts[1]); assert(s3 == patternCounts[2]);
}
double BBAA = stringToDouble(patternCounts[3]);
double BABA = stringToDouble(patternCounts[4]);
double ABBA = stringToDouble(patternCounts[5]);
BBAAtotal += BBAA; ABBAtotal += ABBA; BABAtotal += BABA;
}
}
//std::cerr << "ABBAtotal = " << ABBAtotal << std::endl;
//std::cerr << "BABAtotal = " << BABAtotal << std::endl;
double Dnum1 = ABBAtotal - BABAtotal; // assert(Dnum1 == Dnums[i][0]);
double Dnum2 = ABBAtotal - BBAAtotal; // assert(Dnum2 == Dnums[i][1]);
double Dnum3 = BBAAtotal - BABAtotal; // assert(Dnum3 == Dnums[i][2]);
double Ddenom1 = ABBAtotal + BABAtotal; // assert(Ddenom1 == Ddenoms[i][0]);
double Ddenom2 = ABBAtotal + BBAAtotal; // assert(Ddenom2 == Ddenoms[i][1]);
double Ddenom3 = BBAAtotal + BABAtotal; // assert(Ddenom3 == Ddenoms[i][2]);
//std::cerr << "Dnum1 = " << Dnum1 << std::endl;
//std::cerr << "Ddenom1 = " << Ddenom1 << std::endl;
double D1 = Dnum1/Ddenom1; double D2 = Dnum2/Ddenom2; double D3 = Dnum3/Ddenom3;
//std::cerr << "D1 = " << D1 << std::endl;
for (int i = 0; i < dminstdErrFiles.size(); i++) {
if (getline(*dminstdErrFiles[i], line)) {
std::vector<string> localDs = split(line, '\t');
//assert(localDs.size() == 3 || localDs.size() == 0);
if (localDs.size() == 3) {
std::vector<string> BBAA_D_strings = split(localDs[0], ',');
std::vector<string> BABA_D_strings = split(localDs[1], ',');
std::vector<string> ABBA_D_strings = split(localDs[2], ',');
for (int j = 0; j < BBAA_D_strings.size(); j++) {
//std::cerr << "BBAA_D_strings[j] = " << BBAA_D_strings[j] << std::endl;
double thisBBAA_localD = stringToDouble(BBAA_D_strings[j]);
if (!std::isnan(thisBBAA_localD)) BBAA_local_Ds.push_back(thisBBAA_localD);
// std::cerr << "BABA_D_strings[j] = " << BABA_D_strings[j] << std::endl;
double thisBABA_localD = stringToDouble(BABA_D_strings[j]);
if (!std::isnan(thisBABA_localD)) BABA_local_Ds.push_back(thisBABA_localD);
//std::cerr << "ABBA_D_strings[j] = " << ABBA_D_strings[j] << std::endl;
double thisABBA_localD = stringToDouble(ABBA_D_strings[j]);
if (!std::isnan(thisABBA_localD)) ABBA_local_Ds.push_back(thisABBA_localD);
}
} else {
print_vector(localDs,std::cerr);
}
}
}
if (BBAA_local_Ds.size() == 0 || BABA_local_Ds.size() == 0 || ABBA_local_Ds.size() == 0) { // no info to estimate the standard error; probably all lines have been processed
allDone = true; break;
}
// std::cerr << "D1 = " << D1 << std::endl;
//print_vector(BBAA_local_Ds, std::cerr);
double BBAAstdErr = jackknive_std_err(BBAA_local_Ds);
//print_vector(BABA_local_Ds, std::cerr);
double BABAstdErr = jackknive_std_err(BABA_local_Ds);
//print_vector(ABBA_local_Ds, std::cerr);
//std::cerr << "D1 = " << D1 << std::endl;
double ABBAstdErr = jackknive_std_err(ABBA_local_Ds);
//std::cerr << "D1 = " << D1 << std::endl;
//std::cerr << "BBAAstdErr" << BBAAstdErr << std::endl;
double D1_Z = fabs(D1)/BBAAstdErr; double D2_Z = fabs(D2)/BABAstdErr;
double D3_Z = fabs(D3)/ABBAstdErr;
//std::cerr << "D1_Z = " << D1_Z << std::endl;
if (s1 == "Altcal" && s2 == "Altshe" && s3 == "Asplep") {
std::cerr << "D1_Z = " << D1_Z << std::endl;
std::cerr << "BBAAstdErr = " << BBAAstdErr << std::endl;
print_vector(BBAA_local_Ds, std::cerr);
std::cerr << "ABBAstdErr = " << ABBAstdErr << std::endl;
std::cerr << "BABAstdErr = " << BABAstdErr << std::endl;
std::cerr << "ABBAtotal = " << ABBAtotal << std::endl;
std::cerr << "BABAtotal = " << BABAtotal << std::endl;
std::cerr << "BBAAtotal = " << BBAAtotal << std::endl;
}
// Find which topology is in agreement with the counts of the BBAA, BABA, and ABBA patterns
if (BBAAtotal >= BABAtotal && BBAAtotal >= ABBAtotal) {
if (D1 >= 0)
*outFileBBAA << s1 << "\t" << s2 << "\t" << s3;
else
*outFileBBAA << s2 << "\t" << s1 << "\t" << s3;
*outFileBBAA << "\t" << fabs(D1) << "\t" << D1_Z << "\t";
*outFileBBAA << BBAAtotal << "\t" << BABAtotal << "\t" << ABBAtotal << std::endl;
} else if (BABAtotal >= BBAAtotal && BABAtotal >= ABBAtotal) {
if (D2 >= 0)
*outFileBBAA << s1 << "\t" << s3 << "\t" << s2;
else
*outFileBBAA << s3 << "\t" << s1 << "\t" << s2;
*outFileBBAA << "\t" << fabs(D2) << "\t" << D2_Z << "\t";
*outFileBBAA << BABAtotal << "\t" << BBAAtotal << "\t" << ABBAtotal << std::endl;
} else if (ABBAtotal >= BBAAtotal && ABBAtotal >= BABAtotal) {
if (D3 >= 0)
*outFileBBAA << s3 << "\t" << s2 << "\t" << s1;
else
*outFileBBAA << s2 << "\t" << s3 << "\t" << s1;
*outFileBBAA << "\t" << fabs(D3) << "\t" << D3_Z << "\t";
*outFileBBAA << ABBAtotal << "\t" << BABAtotal << "\t" << BBAAtotal << std::endl;
}
// Find Dmin:
if (fabs(D1) <= fabs(D2) && fabs(D1) <= fabs(D3)) { // (P3 == S3)
if (D1 >= 0)
*outFileDmin << s1 << "\t" << s2 << "\t" << s3 << "\t" << D1 << "\t" << D1_Z << "\t" << std::endl;
else
*outFileDmin << s1 << "\t" << s2 << "\t" << s3 << "\t" << fabs(D1) << "\t" << D1_Z << "\t"<< std::endl;
} else if (fabs(D2) <= fabs(D1) && fabs(D2) <= fabs(D3)) { // (P3 == S2)
if (D2 >= 0)
*outFileDmin << s1 << "\t" << s3 << "\t" << s2 << "\t" << D2 << "\t" << D2_Z << "\t"<< std::endl;
else
*outFileDmin << s3 << "\t" << s1 << "\t" << s2 << "\t" << fabs(D2) << "\t" << D2_Z << "\t"<< std::endl;
} else if (fabs(D3) <= fabs(D1) && fabs(D3) <= fabs(D2)) { // (P3 == S1)
if (D3 >= 0)
*outFileDmin << s3 << "\t" << s2 << "\t" << s1 << "\t" << D3 << "\t" << D3_Z << "\t"<< std::endl;
else
*outFileDmin << s2 << "\t" << s3 << "\t" << s1 << "\t" << fabs(D3) << "\t" << D3_Z << "\t" << std::endl;;
}
BBAA_local_Ds.clear(); ABBA_local_Ds.clear(); BABA_local_Ds.clear();
BBAAtotal = 0; ABBAtotal = 0; BABAtotal = 0;
} while(!allDone);
/*
for (int i = 0; i != trios.size(); i++) { //
// Get the standard error values:
double D1stdErr = jackknive_std_err(regionDs[i][0]); double D2stdErr = jackknive_std_err(regionDs[i][1]);
double D3stdErr = jackknive_std_err(regionDs[i][2]);
// Get the D values
//Dnums[i][0] = ABBAtotals[i] - BABAtotals[i]; Dnums[i][1] = ABBAtotals[i] - BBAAtotals[i]; Dnums[i][2] = BBAAtotals[i] - BABAtotals[i];
double Dnum1 = ABBAtotals[i] - BABAtotals[i]; // assert(Dnum1 == Dnums[i][0]);
double Dnum2 = ABBAtotals[i] - BBAAtotals[i]; // assert(Dnum2 == Dnums[i][1]);
double Dnum3 = BBAAtotals[i] - BABAtotals[i]; // assert(Dnum3 == Dnums[i][2]);
// Ddenoms[i][0] = ABBAtotals[i] + BABAtotals[i]; Ddenoms[i][1] = ABBAtotals[i] + BBAAtotals[i]; Ddenoms[i][2] = BBAAtotals[i] + BABAtotals[i];
double Ddenom1 = ABBAtotals[i] + BABAtotals[i]; // assert(Ddenom1 == Ddenoms[i][0]);
double Ddenom2 = ABBAtotals[i] + BBAAtotals[i]; // assert(Ddenom2 == Ddenoms[i][1]);
double Ddenom3 = BBAAtotals[i] + BABAtotals[i]; // assert(Ddenom3 == Ddenoms[i][2]);
double D1 = Dnum1/Ddenom1; double D2 = Dnum2/Ddenom2; double D3 = Dnum3/Ddenom3;
// Get the Z-scores
double D1_Z = abs(D1)/D1stdErr; double D2_Z = abs(D2)/D2stdErr;
double D3_Z = abs(D3)/D3stdErr;
// Find which topology is in agreement with the counts of the BBAA, BABA, and ABBA patterns
if (BBAAtotals[i] >= BABAtotals[i] && BBAAtotals[i] >= ABBAtotals[i]) {
if (D1 >= 0)
*outFileBBAA << trios[i][0] << "\t" << trios[i][1] << "\t" << trios[i][2];
else
*outFileBBAA << trios[i][1] << "\t" << trios[i][0] << "\t" << trios[i][2];
*outFileBBAA << "\t" << abs(D1) << "\t" << D1_Z << "\t";
*outFileBBAA << BBAAtotals[i] << "\t" << BABAtotals[i] << "\t" << ABBAtotals[i] << std::endl;
} else if (BABAtotals[i] >= BBAAtotals[i] && BABAtotals[i] >= ABBAtotals[i]) {
if (D2 >= 0)
*outFileBBAA << trios[i][0] << "\t" << trios[i][2] << "\t" << trios[i][1];
else
*outFileBBAA << trios[i][2] << "\t" << trios[i][0] << "\t" << trios[i][1];
*outFileBBAA << "\t" << abs(D2) << "\t" << D2_Z << "\t";
*outFileBBAA << BABAtotals[i] << "\t" << BBAAtotals[i] << "\t" << ABBAtotals[i] << std::endl;
} else if (ABBAtotals[i] >= BBAAtotals[i] && ABBAtotals[i] >= BABAtotals[i]) {
if (D3 >= 0)
*outFileBBAA << trios[i][2] << "\t" << trios[i][1] << "\t" << trios[i][0];
else
*outFileBBAA << trios[i][1] << "\t" << trios[i][2] << "\t" << trios[i][0];
*outFileBBAA << "\t" << abs(D3) << "\t" << D3_Z << "\t";
*outFileBBAA << ABBAtotals[i] << "\t" << BABAtotals[i] << "\t" << BBAAtotals[i] << std::endl;
}
// Find Dmin:
if (abs(D1) <= abs(D2) && abs(D1) <= abs(D3)) { // (P3 == S3)
if (D1 >= 0)
*outFileDmin << trios[i][0] << "\t" << trios[i][1] << "\t" << trios[i][2] << "\t" << D1 << "\t" << D1_Z << "\t" << std::endl;
else
*outFileDmin << trios[i][1] << "\t" << trios[i][0] << "\t" << trios[i][2] << "\t" << abs(D1) << "\t" << D1_Z << "\t"<< std::endl;
// if (BBAAtotals[i] < BABAtotals[i] || BBAAtotals[i] < ABBAtotals[i])
// std::cerr << "\t" << "WARNING: Dmin tree different from DAF tree" << std::endl;
} else if (abs(D2) <= abs(D1) && abs(D2) <= abs(D3)) { // (P3 == S2)
if (D2 >= 0)
*outFileDmin << trios[i][0] << "\t" << trios[i][2] << "\t" << trios[i][1] << "\t" << D2 << "\t" << D2_Z << "\t"<< std::endl;
else
*outFileDmin << trios[i][2] << "\t" << trios[i][0] << "\t" << trios[i][1] << "\t" << abs(D2) << "\t" << D2_Z << "\t"<< std::endl;
// if (BABAtotals[i] < BBAAtotals[i] || BABAtotals[i] < ABBAtotals[i])
// std::cerr << "\t" << "WARNING: Dmin tree different from DAF tree" << std::endl;
} else if (abs(D3) <= abs(D1) && abs(D3) <= abs(D2)) { // (P3 == S1)
if (D3 >= 0)
*outFileDmin << trios[i][2] << "\t" << trios[i][1] << "\t" << trios[i][0] << "\t" << D3 << "\t" << D3_Z << "\t"<< std::endl;
else
*outFileDmin << trios[i][1] << "\t" << trios[i][2] << "\t" << trios[i][0] << "\t" << abs(D3) << "\t" << D3_Z << "\t" << std::endl;;
// if (ABBAtotals[i] < BBAAtotals[i] || ABBAtotals[i] < BABAtotals[i])
// std::cerr << "\t" << "WARNING: Dmin tree different from DAF tree" << std::endl;
}
// Output a simple file that can be used for combining multiple local runs:
*outFileCombine << trios[i][0] << "\t" << trios[i][1] << "\t" << trios[i][2] << "\t" << BBAAtotals[i] << "\t" << BABAtotals[i] << "\t" << ABBAtotals[i] << std::endl;
print_vector(regionDs[i][0], *outFileCombineStdErr, ',', false); *outFileCombineStdErr << "\t"; print_vector(regionDs[i][1], *outFileCombineStdErr, ',', false); *outFileCombineStdErr << "\t";
print_vector(regionDs[i][2], *outFileCombineStdErr, ',',false); *outFileCombineStdErr << std::endl;
//std::cerr << trios[i][0] << "\t" << trios[i][1] << "\t" << trios[i][2] << "\t" << D1 << "\t" << D2 << "\t" << D3 << "\t" << BBAAtotals[i] << "\t" << BABAtotals[i] << "\t" << ABBAtotals[i] << std::endl;
}
*/
return 0;
}
