bool Tags::getTagValueBool(string key, int value_index, bool default_value) {
string value = getTagValue(key, value_index);
if (value.size()) {
if ((value[0] == '1') || (value[0] == 't') || (value[0] == 'T') || (value[0] == 'y') || (value[0] == 'Y')) {
return true;
}
}
return default_value;
}
float Tags::getTagValueFloat(string key, int value_index, float default_value) {
string value = getTagValue(key, value_index);
if (value.size()) {
float value_f = 0.0f;
FromString<float>(value_f, value, std::dec);
return value_f;
}
return default_value;
}
int Tags::getTagValueInt(string key, int value_index, int default_value) {
string value = getTagValue(key, value_index);
if (value.size()) {
int value_i = 0;
FromString<int>(value_i, value, std::dec);
return value_i;
}
return default_value;
}
int main(){
char * data = "TagOne: one1\r\nTagTwo: two2\r\nTagThree: three3\r\n\r\n";
char * tag = "TagTwo";
printf( "data:\n%s\ntag: %s\n", data, tag );
char * value = getTagValue( data, tag );
printf( "value: %s\n", value );
free( value );
char * firstWord = getFirstWord( data );
printf( "firstWord: %s\n", firstWord );
free( firstWord );
return EXIT_SUCCESS;
}
void MarkupReader::describeValue( long double& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue( unsigned long& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue( short& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue( signed char& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue( Pointer ref)
{
unsigned int id;
getTagValue(id);
ref = Describer::getSerializedObjectForId(id);
}
void MarkupReader::describeValue(bool& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue(float& ref)
{
getTagValue(ref);
}
void MarkupReader::describeValue(String& ref)
{
getTagValue(ref);
}
//
// Main
//
int somaticVariantFiltersMain(int argc, char** argv)
{
parseSomaticVariantFiltersOptions(argc, argv);
Timer* pTimer = new Timer(PROGRAM_IDENT);
// Load Reference
ReadTable refTable(opt::referenceFile, SRF_NO_VALIDATION);
refTable.indexReadsByID();
// Load BAMs
BamTools::BamReader* pTumorBamReader = new BamTools::BamReader;
pTumorBamReader->Open(opt::tumorBamFile);
pTumorBamReader->LocateIndex();
assert(pTumorBamReader->HasIndex());
BamTools::BamReader* pNormalBamReader = new BamTools::BamReader;
pNormalBamReader->Open(opt::normalBamFile);
pNormalBamReader->LocateIndex();
assert(pNormalBamReader->HasIndex());
// Track duplicated variants
HashSet<std::string> duplicateHash;
std::ifstream input(opt::vcfFile.c_str());
std::string line;
while(getline(input, line))
{
if(line.empty())
continue;
if(line[0] == '#')
{
std::cout << line << "\n";
continue;
}
// parse record
VCFRecord record(line);
if(record.isMultiAllelic())
{
std::cerr << "Error: multi-allelic VCF found, please run vcfbreakmulti\n";
exit(EXIT_FAILURE);
}
// Check if we've seen this variant already
std::string key = makeVariantKey(record);
if(duplicateHash.find(key) != duplicateHash.end())
continue;
else
duplicateHash.insert(key);
if(opt::verbose > 0)
{
std::stringstream ss;
ss << "Variant: " << record << "\n";
fprintf(stderr, "===============================================\n%s", ss.str().c_str());
}
StringStringHash tagHash;
makeTagHash(record, tagHash);
StringVector fail_reasons;
int hplen = 0;
if(!getTagValue(tagHash, "HPLen", hplen))
hplen = calculateHomopolymerLength(record, &refTable);
if(hplen > opt::maxHPLen)
fail_reasons.push_back("Homopolymer");
double dust = 0.0f;
if(!getTagValue(tagHash, "Dust", dust))
dust = HapgenUtil::calculateDustScoreAtPosition(record.refName,
record.refPosition,
&refTable);
if(dust > opt::maxDust)
fail_reasons.push_back("LowComplexity");
double af;
if(getTagValue(tagHash, "AF", af) && af < opt::minAF)
fail_reasons.push_back("LowAlleleFrequency");
int varDP;
if(getTagValue(tagHash, "VarDP", varDP) && varDP < opt::minVarDP)
fail_reasons.push_back("LowVarDP");
double strandBias;
if(getTagValue(tagHash, "SB", strandBias) && strandBias >= opt::maxStrandBias)
fail_reasons.push_back("StrandBias");
CoverageStats tumor_stats = getVariantCoverage(pTumorBamReader, record, &refTable);
CoverageStats normal_stats = getVariantCoverage(pNormalBamReader, record, &refTable);
if(opt::verbose > 0)
{
fprintf(stderr, "Tumor: [%zu %zu]\n", tumor_stats.n_total_reads, tumor_stats.n_evidence_reads);
fprintf(stderr, "Normal: [%zu %zu]\n", normal_stats.n_total_reads, normal_stats.n_evidence_reads);
}
if(normal_stats.n_evidence_reads > opt::maxNormalReads)
fail_reasons.push_back("NormalEvidence");
if(normal_stats.n_total_reads < opt::minNormalDepth)
fail_reasons.push_back("LowNormalDepth");
if(!tumor_stats.snv_evidence_quals.empty())
{
double median_quality = median(tumor_stats.snv_evidence_quals);
if(median_quality < opt::minMedianQuality)
fail_reasons.push_back("LowQuality");
}
if(tumor_stats.median_mapping_quality < opt::minMedianQuality)
fail_reasons.push_back("LowMappingQuality");
if(!fail_reasons.empty())
{
if(record.passStr != "PASS" && record.passStr != ".")
fail_reasons.insert(fail_reasons.begin(), record.passStr);
std::stringstream strss;
std::copy(fail_reasons.begin(), fail_reasons.end(), std::ostream_iterator<std::string>(strss, ";"));
record.passStr = strss.str();
record.passStr.erase(record.passStr.size() - 1); // erase trailing ;
}
std::cout << record << "\n";
}
// Cleanup
delete pTumorBamReader;
delete pNormalBamReader;
delete pTimer;
return 0;
}
const char* SamHeaderHD::getSortOrder()
{
return(getTagValue("SO"));
}
int main(int Count, char *Strings[])
{
setupMotors();
int sockfd;
struct sockaddr_in self;
char buffer[MAXBUF];
/*---Create streaming socket---*/
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
perror("Socket");
return(errno);
}
/*---Initialize address/port structure---*/
bzero(&self, sizeof(self));
self.sin_family = AF_INET;
self.sin_port = htons(MY_PORT);
self.sin_addr.s_addr = INADDR_ANY;
/*---Assign a port number to the socket---*/
if ( bind(sockfd, (struct sockaddr*)&self, sizeof(self)) != 0 )
{
perror("socket--bind");
return(errno);
}
/*---Make it a "listening socket"---*/
if ( listen(sockfd, 20) != 0 )
{
perror("socket--listen");
return(errno);
}
/*---Forever... ---*/
while (1)
{
int clientfd;
struct sockaddr_in client_addr;
unsigned int addrlen = sizeof(client_addr);
/*---accept a connection (creating a data pipe)---*/
clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &addrlen);
printf("%s:%d connected\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
while (1) {
ssize_t count = recv(clientfd, buffer, MAXBUF, 0);
buffer[count]=0;
printf(">>> %s\n", buffer);
char* left = getTagValue(buffer, "left");
char* right = getTagValue(buffer, "right");
int l = atoi(left);
int r = atoi(right);
free(left);
free(right);
doMotorStuff(motor1, l);
doMotorStuff(motor2, r);
}
/*---Close data connection---*/
close(clientfd);
}
/*---Clean up (should never get here!)---*/
close(sockfd);
return 0;
}
