QString XmlValidatorJob::errorString() const
{
QString ret = errors().join("\n");
if(warnings().size() > 0)
ret += "\nWarnings:\n" + warnings().join("\n");
return ret;
}
void
Scheduler::initialise()
{
//Now, the scheduler is used to test the state of the system.
dout << "Checking the simulation configuration for any errors" << std::endl;
size_t warnings(0);
for (const auto& interaction_ptr : Sim->interactions)
{
dout << "Checking Interaction \"" << interaction_ptr->getName() << "\" for invalid states" << std::endl;
warnings += interaction_ptr->validateState(warnings < 101, 101 - warnings);
}
for (size_t id1(0); id1 < Sim->particles.size(); ++id1)
{
std::unique_ptr<IDRange> ids(getParticleNeighbours(Sim->particles[id1]));
for (const size_t id2 : *ids)
if (id2 > id1)
if (Sim->getInteraction(Sim->particles[id1], Sim->particles[id2])
->validateState(Sim->particles[id1], Sim->particles[id2], (warnings < 101)))
++warnings;
}
for(const Particle& part : Sim->particles)
for (const shared_ptr<Local>& lcl : Sim->locals)
if (lcl->isInteraction(part))
if (lcl->validateState(part, (warnings < 101)))
++warnings;
if (warnings > 100)
derr << "Over 100 warnings of invalid states, further output was suppressed (total of " << warnings << " warnings detected)" << std::endl;
dout << "Building all events on collision " << Sim->eventCount << std::endl;
rebuildList();
}
char * get_col_tsv(struct beds_anno_tsv *tsv, int icol)
{
if (icol > tsv->nfields) {
warnings("outof columns");
return NULL;
}
return tsv->string.s + tsv->fields[icol];
}
///////////////////////////
// Fatal error from the server
void IRCClient::parseError(const IRCClient::IRCCommand &cmd)
{
if (cmd.params.size() > 0) {
warnings("IRC server error: " + cmd.params[0] + "\n");
addChatMessage("Server error: " + cmd.params[0], IRC_TEXT_NOTICE);
disconnect();
}
}
int PMSerializer::errorFlags( ) const
{
int result = 0;
if( errors( ) )
result |= PMEError;
if( warnings( ) )
result |= PMEWarning;
if( fatal( ) )
result |= PMEFatal;
return result;
}
int trimBed(int argc, char *argv[])
{
int help = 0;
int n;
int i;
char *out = 0;
int trim1 = 0;
int trim2 = 0;
while ((n = getopt(argc, argv, "o:r:l:h")) >= 0)
{
switch(n)
{
case 'o' : out = optarg; break;
case 'l' : trim1 = atoi(optarg); break;
case 'r' : trim2 = atoi(optarg); break;
case 'h' : help = 1; break;
default :
errabort("%c : unknown option!", (char)n);
break;
}
if (help) trimHelp();
}
if (trim1 == 0 && trim2 == 0) errabort("You must set a trim size!");
if (trim1 < 0 || trim2 < 0) errabort("Trim size must be a postive int!");
n = argc - optind;
if (n < 1) errabort("Sucker! Set the bed file(s)!");
regHash_t *rghsh = kh_init(reg);
int ret = 0;
for (i = 0; i < n; ++i)
{
bedHand->read(argv[optind+i], rghsh, 0, 0, &ret);
}
bedHand->merge(rghsh);
if (ret)
{
warnings("the input bed file might not be standard bed format 0-based, please make sure the input files is in same base system"
"you can use '1to0' to trans the base systems first");
}
inf_t *itmp = bedHand->stat(rghsh);
bedHand->trim(rghsh, trim1, trim2);
inf_t *inf = bedHand->stat(rghsh);
if (out) bedHand->save(out, rghsh);
unsigned trim_length = itmp->length - inf->length;
writeout("Trimmed %d bp\n"
"The length of whole regions is %d bp\n"
,trim_length, inf->length);
freemem(itmp);
freemem(inf);
bedHand->destroy(rghsh, destroy_void);
return 1;
}
void ResultProcessor::checkErrorsProcess(const std::vector<std::string> & logPaths , FileLogger * dirLogger) {
int errorCount = 0;
int wrnCount = 0;
bool validity;
std::regex errPatt ("\\[\\d\\d:\\d\\d:\\d\\d\\] error: .*");
std::regex wrnPatt ("\\[\\d\\d:\\d\\d:\\d\\d\\] warning: .*");
std::sregex_token_iterator endExpr;
std::string logFile;
std::string wuDirectory;
for(unsigned i = 0 ; i < logPaths.size() ; i++) {
errorCount = 0;
wrnCount = 0;
validity = true;
logFile = Utils::readFileToString(logPaths[i]);
wuDirectory = Utils::getPathWithoutLastItem(logPaths[i]);
std::sregex_token_iterator errors(logFile.begin() , logFile.end() , errPatt , 0);
std::sregex_token_iterator warnings(logFile.begin() , logFile.end() , wrnPatt , 0);
for(; errors != endExpr ; errors++) {
errorCount++;
*dirLogger << FileLogger::LOG_WARNING << "error in log file: " << Utils::getLastItemInPath(logPaths[i]) << " == " << *errors << "\n";
oneclickLogger << FileLogger::LOG_WARNING << "error in log file: " << Utils::getLastItemInPath(logPaths[i]) << " == " << *errors << "\n";
}
for(; warnings != endExpr ; warnings++) {
wrnCount++;
*dirLogger << FileLogger::LOG_WARNING << "warning in log file: " << Utils::getLastItemInPath(logPaths[i]) << " == " << *warnings << "\n";
oneclickLogger << FileLogger::LOG_WARNING << "warning in log file: " << Utils::getLastItemInPath(logPaths[i]) << " == " << *warnings << "\n";
}
if(errorCount == 0) {
validity = pprocessor->process(wuDirectory);
if(validity == false) {
oneclickLogger << FileLogger::LOG_WARNING << "directory " << wuDirectory << " contains no valid results for processing\n";
*dirLogger << FileLogger::LOG_WARNING << "directory " << wuDirectory << " contains no valid results for processing\n";
}
} else {
*dirLogger << FileLogger::LOG_WARNING << Utils::getLastItemInPath(logPaths[i]) << " contains errors. Ignoring file.\n";
oneclickLogger << FileLogger::LOG_WARNING << Utils::getLastItemInPath(logPaths[i]) << " contains errors. Ignoring file.\n";
}
if(errorCount != 0 || wrnCount != 0) {
*dirLogger << FileLogger::LOG_INFO << Utils::getLastItemInPath(logPaths[i]) << " has " << Utils::itostr(wrnCount) << " warnings and " << Utils::itostr(errorCount) << " errors.\n";
oneclickLogger << FileLogger::LOG_INFO << Utils::getLastItemInPath(logPaths[i]) << " has " << Utils::itostr(wrnCount) << " warnings and " << Utils::itostr(errorCount) << " errors.\n";
}
logFile.erase();
}
}
int mergeBed(int argc, char * argv[])
{
int help = 0;
int n, i;
char *out = 0;
int add1 = 0, add2 = 0;
while ((n = getopt(argc, argv, "o:hr:l:1")) >= 0)
{
switch(n)
{
case 'o': out = optarg; break;
case 'h': help = 1; break;
case 'r': add1 = atoi(optarg); break;
case 'l': add2 = atoi(optarg); break;
case '1': one_based = TRUE; break;
}
}
if(help) return mergeHelp();
assert(add1 >= 0 && add2 >= 0);
n = argc - optind;
int ret = 0;
regHash_t * reghash;
reghash = kh_init(reg);
for (i = 0; i < n; ++i)
{
bedHand->read(argv[optind+i], reghash, add1, add2, &ret);
}
if (one_based) bedHand->base1to0(reghash);
if (!one_based && ret)
{
warnings("This region might not not a standard bed format."
"Please use parameter \"-1\" if your bed file is 1-based!");
}
inf_t *itmp = bedHand->stat(reghash);
bedHand->merge(reghash);
inf_t *inf = bedHand->stat(reghash);
inf->region = itmp->total - inf->total;
if (out) bedHand->save(out, reghash);
writeout("Merged %u regions.\n"
"Total regions is %u.\n"
"The length of the regions is %u bp.\n",
inf->region, inf->total, inf->length);
bedHand->destroy(reghash, destroy_void);
freemem(itmp);
freemem(inf);
return 1;
}
void tGauge::ChangeDataType( const tDataId& dataId )
{
m_SaveLimits = false;
if( dataId == DATA_TYPE_INVALID )
{
return;
}
//clear existing indicators
m_Indicators.clear();
m_Indicators << tIndicator( dataId );
//set captions and limits
tDigitalData pData( dataId );
AbsoluteLimits = pData.AbsoluteLimitsConverted();
tFloatLimits limits( pData.MinConverted(), pData.MaxConverted() );
tFloatLimits warnings( pData.WarningLowConverted(), pData.WarningHighConverted() );
m_UnitsType = pData.Units();
m_UnitsValue = tUnitsSettings::Instance()->Units( m_UnitsType );
//set update timer and update immediately
UpdateValues();
//autoconfigure if applicable
if( CanAutoConfigure() && AutoConfigure() )
{
DoAutoConfigure();
}
SetLimits( limits, warnings );
SetCaptions();
//does any type specific config
ReconfigureGauge();
m_BackIsCached = false;
m_ForeIsCached = false;
update();
m_Modified = true;
if( m_UnitsType != UNITS_ECONOMY )
{
// m_SaveLimits = true;
}
}
int diffBed(int argc, char * argv[])
{
int help = 0;
char *out = 0;
int n, i;
while ((n = getopt(argc, argv, "o:h")) >= 0)
{
switch(n)
{
case 'o': out = optarg; break;
case 'h': help = 1; break;
default: diffHelp();
}
if (help) diffHelp();
}
n = argc - optind;
if(n < 2) errabort("At least 2 files!");
regHash_t * reghash, * reghash1;
reghash = kh_init(reg);
reghash1 = kh_init(reg);
int ret = 0;
bedHand->read(argv[optind], (void *)reghash, 0, 0, &ret);
bedHand->merge(reghash);
for (i = 1; i < n; ++i)
{
bedHand->read(argv[optind+i], (void *)reghash1, 0, 0, &ret);
}
bedHand->merge(reghash1);
bedHand->diff(reghash, reghash1);
inf_t * inf = bedHand->stat(reghash);
if (ret)
{
warnings("the input bed file might not be standard bed format 0-based, please make sure the input files is in same base system"
"you can use '1to0' to trans the base systems first");
}
writeout("There are %d bp in the first file but not in others.\n", inf->length);
freemem(inf);
bedHand->destroy(reghash1, destroy_void);
if (out) bedHand->save(out, reghash);
bedHand->destroy(reghash, destroy_void);
return 1;
}
int check_filename(char *fn)
{
char *ss = fn;
int length = strlen(ss);
if ( length < 5 ) {
warnings("unrecongnized file format name, only support vcf and vcf.gz till now. %s", fn);
return 1;
}
if ( length > 4 && !strcmp(ss+length - 4, ".vcf") ) {
mode = "w";
return 0;
} else if ( length > 7 && !strcmp(ss+length - 7, ".vcf.gz") ) {
mode = "zw";
return 0;
} else {
fn = (char*)realloc(fn, (length+8) *sizeof(char));
memcpy(fn + length, ".vcf.gz", 7*sizeof(char));
fn[length+7] = '\0';
return 0;
}
return 1;
}
//////////////////////////////
// Parse an IRC command (private)
void IRCClient::parseCommand(const IRCClient::IRCCommand &cmd)
{
/*printf("IRC: sender '%s' cmd '%s'", cmd.sender.c_str(), cmd.cmd.c_str() );
for( size_t i=0; i<cmd.params.size(); i++ )
printf(" param %i '%s'", i, cmd.params[i].c_str());
printf("\n");*/
// Process depending on the command
bool fail = false;
int num_command = from_string<int>(cmd.cmd, fail);
// String commands
if (fail) {
if (cmd.cmd == "PING")
parsePing(cmd);
else if (cmd.cmd == "MODE")
parseMode(cmd);
else if (cmd.cmd == "PRIVMSG")
parsePrivmsg(cmd);
else if (cmd.cmd == "KICK")
parseKicked(cmd);
else if (cmd.cmd == "PART" || cmd.cmd == "QUIT")
parseDropped(cmd);
else if (cmd.cmd == "JOIN")
parseJoin(cmd);
else if (cmd.cmd == "NICK")
parseNick(cmd);
else if (cmd.cmd == "NOTICE")
parseNotice(cmd);
else if (cmd.cmd == "ERROR")
parseError(cmd);
else
warnings("IRC: unknown command " + cmd.cmd + "\n");
// Numeric commands
} else {
switch (num_command) {
// Nick in use
case LIBIRC_RFC_ERR_NICKNAMEINUSE:
parseNickInUse(cmd);
break;
// List of names
case LIBIRC_RFC_RPL_NAMREPLY:
parseNameReply(cmd);
break;
// End of name list
case LIBIRC_RFC_RPL_ENDOFNAMES:
parseEndOfNames(cmd);
break;
case LIBIRC_RFC_RPL_AWAY:
parseAway(cmd);
break;
case LIBIRC_RFC_RPL_WHOISUSER:
parseWhois(cmd);
break;
case LIBIRC_RFC_RPL_ENDOFWHOIS:
parseEndOfWhois(cmd);
break;
case LIBIRC_RFC_RPL_TOPIC:
parseTopic(cmd);
break;
// Message of the day
case LIBIRC_RFC_RPL_MOTDSTART:
case LIBIRC_RFC_RPL_MOTD:
case LIBIRC_RFC_RPL_ENDOFMOTD:
// Message of the day (ignored currently)
break;
// Messages sent upon a successful join
case LIBIRC_RFC_RPL_WELCOME:
case LIBIRC_RFC_RPL_YOURHOST:
case LIBIRC_RFC_RPL_CREATED:
case LIBIRC_RFC_RPL_MYINFO:
// Quite useless stuff...
break;
default: {}
// Just ignore, there are many "pro" commands that we don't need
}
}
}
// only if annotation database is VCF/BCF file, header_in has values or else header_in == NULL
anno_col_t *init_columns(const char *rules, bcf_hdr_t *header_in, bcf_hdr_t *header_out, int *ncols, enum anno_type type)
{
assert(rules != NULL);
if (type == anno_is_vcf && header_in == NULL) {
error("Inconsistent file type!");
}
char *ss = (char*)rules, *se = ss;
int nc = 0;
anno_col_t *cols = NULL;
kstring_t tmp = KSTRING_INIT;
kstring_t str = KSTRING_INIT;
int i = -1;
while (*ss) {
if ( *se && *se!=',' ) {
se++;
continue;
}
int replace = REPLACE_ALL;
if ( *ss=='+') {
replace = REPLACE_MISSING;
ss++;
} else if (*ss=='-') {
replace = REPLACE_EXISTING;
ss++;
}
i++;
str.l = 0;
kputsn(ss, se-ss, &str);
if ( !str.s[0] ) {
warnings("Empty tag in %s", rules);
} else if ( !strcasecmp("CHROM", str.s) || !strcasecmp("POS", str.s) || !strcasecmp("FROM", str.s) || !strcasecmp("TO", str.s) || !strcasecmp("REF", str.s) || !strcasecmp("ALT", str.s) || !strcasecmp("FILTER", str.s) || !strcasecmp("QUAL", str.s)) {
warnings("Skip tag %s", str.s);
} else if ( !strcasecmp("ID", str.s) ) {
nc++;
cols = (struct anno_col*) realloc(cols, sizeof(struct anno_col)* (nc));
struct anno_col *col = &cols[nc-1];
col->icol = i;
col->replace = replace;
col->setter = type == anno_is_vcf ? vcf_setter_id : setter_id;
col->hdr_key = strdup(str.s);
} else if (!strcasecmp("INFO", str.s) || !strcasecmp("FORMAT", str.s) ) {
error("do not support annotate all INFO,FORMAT fields. todo INFO/TAG instead\n");
} else if (!strncasecmp("FORMAT/", str.s, 7) || !strncasecmp("FMT/", str.s, 4)) {
char *key = str.s + (!strncasecmp("FMT", str.s, 4) ? 4 : 7);
if (!strcasecmp("GT", key))
error("It is not allowed to change GT tag.");
int hdr_id = bcf_hdr_id2int(header_out, BCF_DT_ID, str.s);
if ( !bcf_hdr_idinfo_exists(header_out, BCF_HL_FMT, hdr_id) ) {
if ( type == anno_is_vcf ) {
bcf_hrec_t *hrec = bcf_hdr_get_hrec(header_in, BCF_HL_FMT, "ID", str.s, NULL);
if ( !hrec )
error("The tag \"%s\" is not defined in header: %s\n", str.s, rules);
tmp.l = 0;
bcf_hrec_format(hrec, &tmp);
bcf_hdr_append(header_out, tmp.s);
bcf_hdr_sync(header_out);
hdr_id = bcf_hdr_id2int(header_out, BCF_DT_ID, str.s);
assert( bcf_hdr_idinfo_exists(header_out, BCF_HL_FMT, hdr_id) );
} else {
error("The tag \"%s\" is not defined in header: %s\n", str.s, rules);
}
}
//int hdr_id = bcf_hdr_id2int(header_out, BCF_DT_ID, key);
nc++;
cols = (struct anno_col*) realloc(cols, sizeof(struct anno_col)*(nc));
struct anno_col *col = &cols[nc-1];
col->icol = -1;
col->replace = replace;
col->hdr_key = strdup(key);
switch ( bcf_hdr_id2type(header_out, BCF_HL_FMT, hdr_id) ) {
case BCF_HT_INT:
col->setter = type == anno_is_vcf ? vcf_setter_format_int : setter_format_int;
break;
case BCF_HT_REAL:
col->setter = type == anno_is_vcf ? vcf_setter_format_real : setter_format_real;
break;
case BCF_HT_STR:
col->setter = type == anno_is_vcf ? vcf_setter_format_str : setter_format_str;
break;
default :
error("The type of %s not recognised (%d)\n", str.s, bcf_hdr_id2type(header_out, BCF_HL_FMT, hdr_id));
}
} else if ( !strncasecmp("INFO/", str.s, 5) ) {
memmove(str.s, str.s+5, str.l-4);
str.l -= 4;
int hdr_id = bcf_hdr_id2int(header_out, BCF_DT_ID, str.s);
if ( !bcf_hdr_idinfo_exists(header_out, BCF_HL_INFO, hdr_id) ) {
if ( type == anno_is_vcf ) {
bcf_hrec_t *hrec = bcf_hdr_get_hrec(header_in, BCF_HL_INFO, "ID", str.s, NULL);
if ( !hrec )
error("The tag \"%s\" is not defined in header: %s\n", str.s, rules);
tmp.l = 0;
bcf_hrec_format(hrec, &tmp);
bcf_hdr_append(header_out, tmp.s);
bcf_hdr_sync(header_out);
hdr_id = bcf_hdr_id2int(header_out, BCF_DT_ID, str.s);
assert( bcf_hdr_idinfo_exists(header_out, BCF_HL_INFO, hdr_id) );
} else {
error("The tag \"%s\" is not defined in header: %s\n", str.s, rules);
}
}
nc++;
cols = (struct anno_col*) realloc(cols, sizeof(struct anno_col)*(nc));
struct anno_col *col = &cols[nc-1];
col->icol = i;
col->replace = replace;
col->hdr_key = strdup(str.s);
col->number = bcf_hdr_id2length(header_out, BCF_HL_INFO, hdr_id);
switch ( bcf_hdr_id2type(header_out, BCF_HL_INFO, hdr_id) ) {
case BCF_HT_FLAG:
col->setter = type == anno_is_vcf ? vcf_setter_info_flag : setter_info_flag;
break;
case BCF_HT_INT:
col->setter = type == anno_is_vcf ? vcf_setter_info_int : setter_info_int;
break;
case BCF_HT_REAL:
col->setter = type == anno_is_vcf ? vcf_setter_info_real : setter_info_real;
break;
case BCF_HT_STR:
col->setter = type == anno_is_vcf ? vcf_setter_info_str : setter_info_str;
break;
default:
error("The type of %s not recognised (%d)\n", str.s, bcf_hdr_id2type(header_out, BCF_HL_INFO, hdr_id));
}
}
if ( !*se ) break;
ss = ++se;
}
*ncols = nc;
if (str.m) free(str.s);
if (tmp.m) free(tmp.s);
return cols;
}
int beds_fill_buffer(struct beds_anno_file *file, bcf_hdr_t *hdr_out, bcf1_t *line)
{
assert(file->idx);
int tid = tbx_name2id(file->idx, bcf_seqname(hdr_out, line));
// if cached this region already, just skip refill. this is different from vcfs_fill_buffer()
if ( tid == file->last_id && file->last_start <= line->pos + 1 && file->last_end > line->pos)
return -1;
if ( tid == -1 ) {
if ( file->no_such_chrom == 0 ) {
warnings("no chromosome %s found in databases %s.", bcf_seqname(hdr_out, line), file->fname);
file->no_such_chrom = 1;
}
return 1;
} else {
file->no_such_chrom = 0;
}
// empty cache
file->cached = 0;
int i;
hts_itr_t *itr = tbx_itr_queryi(file->idx, tid, line->pos, line->pos + line->rlen);
if ( itr == NULL )
return 1;
// if buffer refilled, init last start and end
file->last_id = tid;
file->last_start = -1;
file->last_end = -1;
while (1) {
if ( file->cached == file->max ) {
file->max += 8;
file->buffer = (struct beds_anno_tsv**)realloc(file->buffer, sizeof(struct beds_anno_tsv*)*file->max);
for (i = 8; i > 0; --i)
file->buffer[file->max - i] = beds_anno_tsv_init();
}
if ( tbx_itr_next(file->fp, file->idx, itr, &file->buffer[file->cached]->string) < 0)
break;
struct beds_anno_tsv *tsv = file->buffer[file->cached];
convert_string_tsv(tsv);
// Skip if variant located outside of region.
if (line->pos < tsv->start || line->pos >= tsv->end)
continue;
if (tsv->end - tsv->start == 1 && line->pos != tsv->start)
continue;
file->cached++;
if ( file->last_end == -1 ) {
file->last_end = tsv->end;
file->last_start = tsv->start;
continue;
}
if ( file->last_end < tsv->end )
file->last_end = tsv->end;
if ( file->last_start > tsv->start )
file->last_start = tsv->start;
}
// if buffer is filled return 0, else return 1
return file->cached ? 0 : 1;
}
int beds_database_add(struct beds_options *opts, const char *fname, char *columns)
{
if ( opts->n_files == opts->m_files ) {
opts->m_files = opts->m_files == 0 ? 2 : opts->m_files +2;
opts->files = (struct beds_anno_file*)realloc(opts->files, opts->m_files*sizeof(struct beds_anno_file));
}
struct beds_anno_file *file = &opts->files[opts->n_files];
memset(file, 0, sizeof(struct beds_anno_file));
file->id = opts->n_files;
file->fname = strdup(fname);
file->fp = hts_open(fname, "r");
if (file->fp == NULL)
error("Failed to open %s : %s", fname, strerror(errno));
// int n;
file->idx = tbx_index_load(fname);
if ( file->idx == NULL)
error("Failed to load index of %s.", fname);
opts->n_files++;
file->last_id = -1;
file->last_start = -1;
file->last_end = -1;
kstring_t string = KSTRING_INIT;
int no_columns = 0;
int i;
if ( columns == NULL && file->no_such_chrom == 0) {
warnings("No columns string specified for %s. Will annotate all tags in this data.", fname);
file->no_such_chrom = 1;
no_columns = 1;
} else {
int *splits = NULL;
kputs(columns, &string);
int nfields;
splits = ksplit(&string, ',', &nfields);
file->m_cols = nfields;
file->cols = (struct anno_col*)malloc(sizeof(struct anno_col) * file->m_cols);
for ( i = 0; i < nfields; ++i ) {
char *ss = string.s + splits[i];
struct anno_col *col = &file->cols[file->n_cols];
col->icol = i;
col->replace = REPLACE_MISSING;
if (*ss == '+') {
col->replace = REPLACE_MISSING;
ss++;
} else if ( *ss == '-' ) {
col->replace = REPLACE_EXISTING;
ss++;
}
if (ss[0] == '\0')
continue;
if ( strncmp(ss, "INFO/", 5) == 0)
ss += 5;
col->hdr_key = strdup(ss);
col->icol = -1;
// debug_print("%s, %d", col->hdr_key, file->n_cols);
file->n_cols++;
}
string.l = 0;
}
while (1) {
string.l =0;
if ( hts_getline(file->fp, KS_SEP_LINE, &string) < 0 )
break;
// only accept header line in the beginning for file
if ( string.s[0] != '#' )
break;
if ( strncmp(string.s, "##INFO=", 7) == 0) {
char *ss = string.s + 11;
char *se = ss;
while (se && *se != ',') se++;
struct anno_col *col = NULL;
// if no column string specified, init all header lines
if ( no_columns ) {
if ( file->n_cols == file->m_cols ) {
file->m_cols = file->m_cols == 0 ? 2 : file->m_cols + 2;
file->cols = (struct anno_col *) realloc(file->cols, file->m_cols*sizeof(struct anno_col));
}
col = &file->cols[file->n_cols++];
col->icol = -1;
col->hdr_key = strndup(ss, se-ss+1);
col->hdr_key[se-ss] = '\0';
} else {
for ( i = 0; i < file->n_cols; ++i ) {
if ( strncmp(file->cols[i].hdr_key, ss, se-ss) == 0)
break;
}
// if header line is not set in the column string, skip
if ( i == file->n_cols )
continue;
col = &file->cols[i];
}
// specify setter functions here
col->setter.bed = beds_setter_info_string;
bcf_hdr_append(opts->hdr_out, string.s);
bcf_hdr_sync(opts->hdr_out);
int hdr_id = bcf_hdr_id2int(opts->hdr_out, BCF_DT_ID,col->hdr_key);
assert ( bcf_hdr_idinfo_exists(opts->hdr_out, BCF_HL_INFO, hdr_id) );
}
string.l = 0;
// set column number for each col
if ( strncasecmp(string.s, "#chr", 4) == 0) {
int nfields;
int *splits = ksplit(&string, '\t', &nfields);
if (nfields < 4) {
fprintf(stderr, "[error] Bad header of bed database : %s. n_fields : %d, %s", fname, nfields, string.s);
fprintf(stderr, "[notice] this error usually happened because the header line is seperated by spaces but not tab!");
exit(1);
}
int k;
for ( k = 3; k < nfields; ++k ) {
char *ss = string.s + splits[k];
for (i = 0; i < file->n_cols; ++i ) {
struct anno_col *col = &file->cols[i];
if ( strcmp(col->hdr_key, ss) == 0)
break;
}
// if name line specify more names than column string or header, skip
if ( i == file->n_cols )
continue;
struct anno_col *col = &file->cols[i];
col->icol = k;
}
}
}
for ( i = 0; i < file->n_cols; ++i ) {
struct anno_col *col = &file->cols[i];
if ( col->hdr_key && col->icol == -1 )
error("No column %s found in bed database : %s", col->hdr_key, fname);
int hdr_id = bcf_hdr_id2int(opts->hdr_out, BCF_DT_ID, col->hdr_key);
assert(hdr_id>-1);
col->number = bcf_hdr_id2length(opts->hdr_out, BCF_HL_INFO, hdr_id);
if ( col->number == BCF_VL_A || col->number == BCF_VL_R || col->number == BCF_VL_G)
error("Only support fixed INFO number for bed database. %s", col->hdr_key);
col->ifile = file->id;
}
if ( string.m )
free(string.s);
if ( opts->beds_is_inited == 0 )
opts->beds_is_inited = 1;
return 0;
}
int main(int argc, char **argv)
{
int i, n;
static struct option const long_opts[] =
{
{"out", required_argument, NULL, 1},
{"report", required_argument, NULL, 2},
{"dotasref", no_argument, NULL, 3},
{"help", no_argument, NULL, 0},
{"version", no_argument, NULL, 4},
{"export_uncov", no_argument, NULL, 5}
};
bool help = FALSE;
bool report_version = FALSE;
while ((n = getopt_long(argc, argv, "1:2:304", long_opts, NULL)) >= 0)
{
switch (n)
{
case 1 : outfile = strdup(optarg); break;
case 2 : report = strdup(optarg); break;
case 3 : dotasref = TRUE; break;
case 0 : help = TRUE; break;
case 4 : report_version = TRUE; break;
case 5 : export_uncover = TRUE; break;
default : return 1;
}
if ( help ) return usage();
if ( report_version ) return show_version();
}
n = argc - optind;
if ( n > 1 ) errabort("only accept one input vcf");
if ( export_uncover == TRUE && outfile == FALSE) {
warnings("export uncove region only used with option --out");
export_uncover = FALSE;
}
char * input;
if ( n == 0 ) input = strdup("-");
else input = strdup(argv[optind]);
htsFile * fp = read_vcf_file(input);
enum htsExactFormat fmt = hts_get_format(fp)->format;
if ( fmt != vcf && fmt != bcf ) errabort("This is not a VCF/BCF file : %s", input);
bcf_hdr_t * hdr = bcf_hdr_read(fp);
int n_samples = bcf_hdr_nsamples(hdr);
if ( n_samples != 2 ) errabort("the input VCF/BCF file must contain only two samples! %d", n_samples);
LOG("Using sample %s as ref ...", hdr->samples[0]);
LOG("Using sample %s as test ...", hdr->samples[1]);
uint32_t matrix[4][4] = { {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} };
bcf1_t * v = bcf_init1();
kstring_t str = { 0, 0, 0 };
uint32_t line = 0;
htsFile *out = NULL;
if ( outfile && !check_filename(outfile) ) out = hts_open(outfile, mode);
if ( out != NULL ) bcf_hdr_write(out, hdr);
while ( bcf_read1(fp, hdr, v) >= 0 )
{
bcf_unpack(v, BCF_UN_STR|BCF_UN_FMT);
int k;
str.l = 0;
int tag_id = bcf_hdr_id2int(hdr, BCF_DT_ID, "GT");
if ( !bcf_hdr_idinfo_exists(hdr, BCF_HL_FMT, tag_id) ) warnings("There is no 'GT' in the header!");
for ( i = 0; i < v->n_fmt; ++i )
if ( v->d.fmt[i].id == tag_id ) break;
if ( i == v->n_fmt ) {
vcf_format1(hdr, v, &str);
LOG("There is no tag GT in this line : %s", str.s);
continue;
}
corr_t xy[2] = { {-1, -2, -2}, {-1, -2, -2} };
bcf_fmt_t * fmt = &v->d.fmt[i];
for ( i = 0; i < 2; ++i )
{
int corr = i;
if ( fmt == NULL ) {
if ( dotasref == TRUE ) xy[corr].alt = ALT_IS_REF;
else xy[corr].alt = ALT_IS_UNC;
continue;
}
int last = -2;
uint8_t *d = (uint8_t*)((char*)fmt->p + fmt->size*i);
for ( k = 0; k < fmt->n && d[k] != (uint8_t)bcf_int8_vector_end; ++k )
{
int curr = d[k]>>1;
if ( last != curr ) {
if ( curr ) {
if ( last == -2 ) xy[corr].alt = curr > 1 ? ALT_IS_HOM : ALT_IS_REF;
else xy[corr].alt = ALT_IS_HET;
} else {
xy[corr].alt = dotasref == TRUE ? ALT_IS_REF : ALT_IS_UNC;
}
} else {
if ( curr ) {
xy[corr].alt = curr > 1 ? ALT_IS_HOM : ALT_IS_REF;
} else {
xy[corr].alt = dotasref == TRUE ? ALT_IS_REF : ALT_IS_UNC;
}
}
if (last == -2 ) {
xy[corr].min = xy[corr].max = curr;
} else {
if ( curr < xy[corr].min ) xy[corr].min = curr;
else if ( curr > xy[corr].max ) xy[corr].max = curr;
}
last = curr;
}
}
matrix[xy[0].alt][xy[1].alt]++;
if ( xy[0].alt != xy[1].alt && out != NULL) {
if ( xy[0].alt == ALT_IS_UNC || xy[1].alt == ALT_IS_UNC ) {
if ( export_uncover == TRUE ) {
str.l = 0;
vcf_format1(hdr, v, &str);
vcf_write(out, hdr, v);
}
} else {
str.l = 0;
vcf_format1(hdr, v, &str);
vcf_write(out, hdr, v);
}
}
if ( xy[0].alt == ALT_IS_HET && xy[1].alt == ALT_IS_HET && (xy[0].min != xy[1].min || xy[0].max != xy[1].max ) ) {
bias++;
matrix[ALT_IS_HET][ALT_IS_HET]--;
if ( out != NULL ) {
str.l = 0;
vcf_format1(hdr, v, &str);
vcf_write(out, hdr, v);
}
}
line++;
}
if ( out ) hts_close(out);
if ( str.m ) free(str.s);
write_report(matrix, hdr);
bcf_hdr_destroy(hdr);
free(input);
bcf_destroy1(v);
if ( outfile ) free(outfile);
if ( report ) free(report);
if ( hts_close(fp) ) warnings("hts_close returned non-zero status: %s", input);
return 0;
}
int test_main(int /* argc */, char * /* argv */[]){
warnings();
return EXIT_SUCCESS;
}
void
lanczos_FO (
struct vtx_data **A, /* graph data structure */
int n, /* number of rows/colums in matrix */
int d, /* problem dimension = # evecs to find */
double **y, /* columns of y are eigenvectors of A */
double *lambda, /* ritz approximation to eigenvals of A */
double *bound, /* on ritz pair approximations to eig pairs of A */
double eigtol, /* tolerance on eigenvectors */
double *vwsqrt, /* square root of vertex weights */
double maxdeg, /* maximum degree of graph */
int version /* 1 = standard mode, 2 = inverse operator mode */
)
{
extern FILE *Output_File; /* output file or NULL */
extern int DEBUG_EVECS; /* print debugging output? */
extern int DEBUG_TRACE; /* trace main execution path */
extern int WARNING_EVECS; /* print warning messages? */
extern int LANCZOS_MAXITNS; /* maximum Lanczos iterations allowed */
extern double BISECTION_SAFETY; /* safety factor for bisection algorithm */
extern double SRESTOL; /* resid tol for T evec comp */
extern double DOUBLE_MAX; /* Warning on inaccurate computation of evec of T */
extern double splarax_time; /* time matvecs */
extern double orthog_time; /* time orthogonalization work */
extern double tevec_time; /* time tridiagonal eigvec work */
extern double evec_time; /* time to generate eigenvectors */
extern double ql_time; /* time tridiagonal eigval work */
extern double blas_time; /* time for blas (not assembly coded) */
extern double init_time; /* time for allocating memory, etc. */
extern double scan_time; /* time for scanning bounds list */
extern double debug_time; /* time for debug computations and output */
int i, j; /* indicies */
int maxj; /* maximum number of Lanczos iterations */
double *u, *r; /* Lanczos vectors */
double *Aq; /* sparse matrix-vector product vector */
double *alpha, *beta; /* the Lanczos scalars from each step */
double *ritz; /* copy of alpha for tqli */
double *workj; /* work vector (eg. for tqli) */
double *workn; /* work vector (eg. for checkeig) */
double *s; /* eigenvector of T */
double **q; /* columns of q = Lanczos basis vectors */
double *bj; /* beta(j)*(last element of evecs of T) */
double bis_safety; /* real safety factor for bisection algorithm */
double Sres; /* how well Tevec calculated eigvecs */
double Sres_max; /* Maximum value of Sres */
int inc_bis_safety; /* need to increase bisection safety */
double *Ares; /* how well Lanczos calculated each eigpair */
double *inv_lambda; /* eigenvalues of inverse operator */
int *index; /* the Ritz index of an eigenpair */
struct orthlink *orthlist = NULL; /* vectors to orthogonalize against in Lanczos */
struct orthlink *orthlist2 = NULL; /* vectors to orthogonalize against in Symmlq */
struct orthlink *temp; /* for expanding orthogonalization list */
double *ritzvec=NULL; /* ritz vector for current iteration */
double *zeros=NULL; /* vector of all zeros */
double *ones=NULL; /* vector of all ones */
struct scanlink *scanlist; /* list of fields for min ritz vals */
struct scanlink *curlnk; /* for traversing the scanlist */
double bji_tol; /* tol on bji estimate of A e-residual */
int converged; /* has the iteration converged? */
double time; /* current clock time */
double shift, rtol; /* symmlq input */
long precon, goodb, nout; /* symmlq input */
long checka, intlim; /* symmlq input */
double anorm, acond; /* symmlq output */
double rnorm, ynorm; /* symmlq output */
long istop, itn; /* symmlq output */
double macheps; /* machine precision calculated by symmlq */
double normxlim; /* a stopping criteria for symmlq */
long itnmin; /* enforce minimum number of iterations */
int symmlqitns; /* # symmlq itns */
double *wv1=NULL, *wv2=NULL, *wv3=NULL; /* Symmlq work space */
double *wv4=NULL, *wv5=NULL, *wv6=NULL; /* Symmlq work space */
long long_n; /* long int copy of n for symmlq */
int ritzval_flag = 0; /* status flag for ql() */
double Anorm; /* Norm estimate of the Laplacian matrix */
int left, right; /* ranges on the search for ritzvals */
int memory_ok; /* TRUE as long as don't run out of memory */
double *mkvec(); /* allocates space for a vector */
double *mkvec_ret(); /* mkvec() which returns error code */
double dot(); /* standard dot product routine */
struct orthlink *makeorthlnk(); /* make space for entry in orthog. set */
double ch_norm(); /* vector norm */
double Tevec(); /* calc evec of T by linear recurrence */
struct scanlink *mkscanlist(); /* make scan list for min ritz vecs */
double lanc_seconds(); /* current clock timer */
int symmlq_(), get_ritzvals();
void setvec(), vecscale(), update(), vecran(), strout();
void splarax(), scanmin(), scanmax(), frvec(), orthogonalize();
void orthog1(), orthogvec(), bail(), warnings(), mkeigvecs();
if (DEBUG_TRACE > 0) {
printf("<Entering lanczos_FO>\n");
}
if (DEBUG_EVECS > 0) {
if (version == 1) {
printf("Full orthogonalization Lanczos, matrix size = %d\n", n);
}
else {
printf("Full orthogonalization Lanczos, inverted operator, matrix size = %d\n", n);
}
}
/* Initialize time. */
time = lanc_seconds();
if (n < d + 1) {
bail("ERROR: System too small for number of eigenvalues requested.",1);
/* d+1 since don't use zero eigenvalue pair */
}
/* Allocate Lanczos space. */
maxj = LANCZOS_MAXITNS;
u = mkvec(1, n);
r = mkvec(1, n);
Aq = mkvec(1, n);
ritzvec = mkvec(1, n);
zeros = mkvec(1, n);
setvec(zeros, 1, n, 0.0);
workn = mkvec(1, n);
Ares = mkvec(1, d);
inv_lambda = mkvec(1, d);
index = smalloc((d + 1) * sizeof(int));
alpha = mkvec(1, maxj);
beta = mkvec(1, maxj + 1);
ritz = mkvec(1, maxj);
s = mkvec(1, maxj);
bj = mkvec(1, maxj);
workj = mkvec(1, maxj + 1);
q = smalloc((maxj + 1) * sizeof(double *));
scanlist = mkscanlist(d);
if (version == 2) {
/* Allocate Symmlq space all in one chunk. */
wv1 = smalloc(6 * (n + 1) * sizeof(double));
wv2 = &wv1[(n + 1)];
wv3 = &wv1[2 * (n + 1)];
wv4 = &wv1[3 * (n + 1)];
wv5 = &wv1[4 * (n + 1)];
wv6 = &wv1[5 * (n + 1)];
/* Set invariant symmlq parameters */
precon = FALSE; /* FALSE until we figure out a good way */
goodb = FALSE; /* should be FALSE for this application */
checka = FALSE; /* if don't know by now, too bad */
intlim = n; /* set to enforce a maximum number of Symmlq itns */
itnmin = 0; /* set to enforce a minimum number of Symmlq itns */
shift = 0.0; /* since just solving rather than doing RQI */
symmlqitns = 0; /* total number of Symmlq iterations */
nout = 0; /* Effectively disabled - see notes in symmlq.f */
rtol = 1.0e-5; /* requested residual tolerance */
normxlim = DOUBLE_MAX; /* Effectively disables ||x|| termination criterion */
long_n = n; /* copy to long for linting */
}
/* Initialize. */
vecran(r, 1, n);
if (vwsqrt == NULL) {
/* whack one's direction from initial vector */
orthog1(r, 1, n);
/* list the ones direction for later use in Symmlq */
if (version == 2) {
orthlist2 = makeorthlnk();
ones = mkvec(1, n);
setvec(ones, 1, n, 1.0);
orthlist2->vec = ones;
orthlist2->pntr = NULL;
}
}
else {
/* whack vwsqrt direction from initial vector */
orthogvec(r, 1, n, vwsqrt);
if (version == 2) {
/* list the vwsqrt direction for later use in Symmlq */
orthlist2 = makeorthlnk();
orthlist2->vec = vwsqrt;
orthlist2->pntr = NULL;
}
}
beta[1] = ch_norm(r, 1, n);
q[0] = zeros;
bji_tol = eigtol;
orthlist = NULL;
Sres_max = 0.0;
Anorm = 2 * maxdeg; /* Gershgorin estimate for ||A|| */
bis_safety = BISECTION_SAFETY;
inc_bis_safety = FALSE;
init_time += lanc_seconds() - time;
/* Main Lanczos loop. */
j = 1;
converged = FALSE;
memory_ok = TRUE;
while ((j <= maxj) && (converged == FALSE) && memory_ok) {
time = lanc_seconds();
/* Allocate next Lanczos vector. If fail, back up one step and compute approx. eigvec. */
q[j] = mkvec_ret(1, n);
if (q[j] == NULL) {
memory_ok = FALSE;
if (DEBUG_EVECS > 0 || WARNING_EVECS > 0) {
strout("WARNING: Lanczos out of memory; computing best approximation available.\n");
}
if (j <= 2) {
bail("ERROR: Sorry, can't salvage Lanczos.",1);
/* ... save yourselves, men. */
}
j--;
}
vecscale(q[j], 1, n, 1.0 / beta[j], r);
blas_time += lanc_seconds() - time;
time = lanc_seconds();
if (version == 1) {
splarax(Aq, A, n, q[j], vwsqrt, workn);
}
else {
symmlq_(&long_n, &(q[j][1]), &wv1[1], &wv2[1], &wv3[1], &wv4[1], &Aq[1], &wv5[1],
&wv6[1], &checka, &goodb, &precon, &shift, &nout,
&intlim, &rtol, &istop, &itn, &anorm, &acond,
&rnorm, &ynorm, (double *) A, vwsqrt, (double *) orthlist2,
&macheps, &normxlim, &itnmin);
symmlqitns += itn;
if (DEBUG_EVECS > 2) {
printf("Symmlq report: rtol %g\n", rtol);
printf(" system norm %g, solution norm %g\n", anorm, ynorm);
printf(" system condition %g, residual %g\n", acond, rnorm);
printf(" termination condition %2ld, iterations %3ld\n", istop, itn);
}
}
splarax_time += lanc_seconds() - time;
time = lanc_seconds();
update(u, 1, n, Aq, -beta[j], q[j - 1]);
alpha[j] = dot(u, 1, n, q[j]);
update(r, 1, n, u, -alpha[j], q[j]);
blas_time += lanc_seconds() - time;
time = lanc_seconds();
if (vwsqrt == NULL) {
orthog1(r, 1, n);
}
else {
orthogvec(r, 1, n, vwsqrt);
}
orthogonalize(r, n, orthlist);
temp = orthlist;
orthlist = makeorthlnk();
orthlist->vec = q[j];
orthlist->pntr = temp;
beta[j + 1] = ch_norm(r, 1, n);
orthog_time += lanc_seconds() - time;
time = lanc_seconds();
left = j/2;
right = j - left + 1;
if (inc_bis_safety) {
bis_safety *= 10;
inc_bis_safety = FALSE;
}
ritzval_flag = get_ritzvals(alpha, beta+1, j, Anorm, workj+1,
ritz, d, left, right, eigtol, bis_safety);
/* ... have to off-set beta and workj since full orthogonalization
indexes these from 1 to maxj+1 whereas selective orthog.
indexes them from 0 to maxj */
if (ritzval_flag != 0) {
bail("ERROR: Both Sturm bisection and QL failed.",1);
/* ... give up. */
}
ql_time += lanc_seconds() - time;
/* Convergence check using Paige bji estimates. */
time = lanc_seconds();
for (i = 1; i <= j; i++) {
Sres = Tevec(alpha, beta, j, ritz[i], s);
if (Sres > Sres_max) {
Sres_max = Sres;
}
if (Sres > SRESTOL) {
inc_bis_safety = TRUE;
}
bj[i] = s[j] * beta[j + 1];
}
tevec_time += lanc_seconds() - time;
time = lanc_seconds();
if (version == 1) {
scanmin(ritz, 1, j, &scanlist);
}
else {
scanmax(ritz, 1, j, &scanlist);
}
converged = TRUE;
if (j < d)
converged = FALSE;
else {
curlnk = scanlist;
while (curlnk != NULL) {
if (bj[curlnk->indx] > bji_tol) {
converged = FALSE;
}
curlnk = curlnk->pntr;
}
}
scan_time += lanc_seconds() - time;
j++;
}
j--;
/* Collect eigenvalue and bound information. */
time = lanc_seconds();
mkeigvecs(scanlist,lambda,bound,index,bj,d,&Sres_max,alpha,beta+1,j,s,y,n,q);
evec_time += lanc_seconds() - time;
/* Analyze computation for and report additional problems */
time = lanc_seconds();
if (DEBUG_EVECS>0 && version == 2) {
printf("\nTotal Symmlq iterations %3d\n", symmlqitns);
}
if (version == 2) {
for (i = 1; i <= d; i++) {
lambda[i] = 1.0/lambda[i];
}
}
warnings(workn, A, y, n, lambda, vwsqrt, Ares, bound, index,
d, j, maxj, Sres_max, eigtol, u, Anorm, Output_File);
debug_time += lanc_seconds() - time;
/* Free any memory allocated in this routine. */
time = lanc_seconds();
frvec(u, 1);
frvec(r, 1);
frvec(Aq, 1);
frvec(ritzvec, 1);
frvec(zeros, 1);
if (vwsqrt == NULL && version == 2) {
frvec(ones, 1);
}
frvec(workn, 1);
frvec(Ares, 1);
frvec(inv_lambda, 1);
sfree(index);
frvec(alpha, 1);
frvec(beta, 1);
frvec(ritz, 1);
frvec(s, 1);
frvec(bj, 1);
frvec(workj, 1);
if (version == 2) {
frvec(wv1, 0);
}
while (scanlist != NULL) {
curlnk = scanlist->pntr;
sfree(scanlist);
scanlist = curlnk;
}
for (i = 1; i <= j; i++) {
frvec(q[i], 1);
}
while (orthlist != NULL) {
temp = orthlist->pntr;
sfree(orthlist);
orthlist = temp;
}
while (version == 2 && orthlist2 != NULL) {
temp = orthlist2->pntr;
sfree(orthlist2);
orthlist2 = temp;
}
sfree(q);
init_time += lanc_seconds() - time;
}
