double run() {
Setup(lattice).setup();
Solver solver(lattice);
TimeTracker tt;
tt.start();
solver.run();
tt.stop();
return tt.elapsedSeconds();
}
// Very simple
void greedy() {
TimeTracker tt;
tt.start();
// Could be optimized a LOT
bool changed;
do{
changed = false;
for(node_ptr n = lattice.begin(); n != lattice.end(); ++n) {
if(n->gain > 0) {
flipNode<3>(n);
changed = true;
}
}
}while(changed);
tt.stop();
cout << "Greedy finished in " << tt.asString() << "." << endl;
}
template <int nd, typename Kernel> void run_benchmark(char mode, size_t edge_size, size_t random_seed) {
typedef typename Indexer<nd>::index_vect index_vect;
vector<dtype> X;
ImageOptions opt;
construct_random_bitmap<nd>(X, edge_size, opt, 10000 + random_seed);
index_vect dimensions(edge_size);
// Now run it...
TimeTracker tt;
tt.start();
_LatticeEnergy<nd, Kernel, dtype> le_qbp(dimensions);
GraphCutEnergyWrapper<nd> le_gc(dimensions);
make<nd>(&le_qbp, &le_gc, mode, opt, X, edge_size);
tt.stop();
cout << "Time taken in setup = " << tt.asString() << "." << endl;
cout << "Starting LatticeEnergy version." << endl;
tt.reset();
tt.start();
le_qbp.run();
tt.stop();
cout << "Time taken in QBP optimization = " << tt.asString() << "." << endl;
cout << "Starting GraphCuts version." << endl;
tt.reset();
tt.start();
le_gc.run();
tt.stop();
cout << "Time taken in GC optimization = " << tt.asString() << "." << endl;
size_t n_pos = 0;
size_t n_neg = 0;
size_t fpos_mismatch_count = 0;
size_t fneg_mismatch_count = 0;
for(IndexIterator<nd> idxit(dimensions); !idxit.done(); ++idxit) {
bool q_on = le_qbp.on(idxit.coords());
bool gc_on = le_gc.on(idxit.coords());
if(!q_on && gc_on)
++fneg_mismatch_count;
if(q_on && !gc_on)
++fpos_mismatch_count;
++(q_on ? n_pos : n_neg);
}
if( (fneg_mismatch_count + fpos_mismatch_count) != 0) {
cout << "WARNING: mismatch count between QBP and GC is "
<< (fneg_mismatch_count + fpos_mismatch_count)
<< " (false negatives = " << fneg_mismatch_count
<< ", false positives = " << fpos_mismatch_count
<< ", total negatives = " << n_neg
<< ", total positives = " << n_pos
<< ")"
<< "!" << endl;
} else {
cout << "Solutions exactly match." << endl;
}
}
static
void
runESL(const ESLOptions& opt)
{
TimeTracker timer;
timer.resume();
{
// early test that we have permission to write to output file
OutStream outs(opt.outputFilename);
}
typedef std::shared_ptr<bam_streamer> stream_ptr;
std::vector<stream_ptr> bamStreams;
// setup all data for main alignment loop:
for (const std::string& afile : opt.alignFileOpt.alignmentFilename)
{
stream_ptr tmp(new bam_streamer(afile.c_str(),
(opt.region.empty()
? NULL
: opt.region.c_str())));
bamStreams.push_back(tmp);
}
const unsigned bamCount(bamStreams.size());
assert(0 != bamCount);
// check bam header compatibility:
if (bamCount > 1)
{
/// TODO: provide a better error exception for failed bam header check:
const bam_header_t* compareHeader(bamStreams[0]->get_header());
for (unsigned bamIndex(1); bamIndex<bamCount; ++bamIndex)
{
const bam_header_t* indexHeader(bamStreams[bamIndex]->get_header());
if (! check_header_compatibility(compareHeader,indexHeader))
{
log_os << "ERROR: incompatible bam headers between files:\n"
<< "\t" << opt.alignFileOpt.alignmentFilename[0] << "\n"
<< "\t" << opt.alignFileOpt.alignmentFilename[bamIndex] << "\n";
exit(EXIT_FAILURE);
}
}
}
// assume headers compatible after this point....
const bam_header_t& header(*(bamStreams[0]->get_header()));
const bam_header_info bamHeader(header);
int32_t tid(0), beginPos(0), endPos(0);
parse_bam_region(bamHeader,opt.region,tid,beginPos,endPos);
const GenomeInterval scanRegion(tid,beginPos,endPos);
#ifdef DEBUG_ESL
static const std::string log_tag("EstimateSVLoci");
log_os << log_tag << " scanRegion= " << scanRegion << "\n";
#endif
// grab the reference for segment we're estimating plus a buffer around the segment edges:
static const unsigned refEdgeBufferSize(500);
reference_contig_segment refSegment;
getIntervalReferenceSegment(opt.referenceFilename, bamHeader, refEdgeBufferSize, scanRegion, refSegment);
SVLocusSetFinder locusFinder(opt, scanRegion, bamHeader, refSegment);
input_stream_data sdata;
for (unsigned bamIndex(0); bamIndex<bamCount; ++bamIndex)
{
sdata.register_reads(*bamStreams[bamIndex],bamIndex);
}
// loop through alignments:
input_stream_handler sinput(sdata);
while (sinput.next())
{
const input_record_info current(sinput.get_current());
if (current.itype != INPUT_TYPE::READ)
{
log_os << "ERROR: invalid input condition.\n";
exit(EXIT_FAILURE);
}
const bam_streamer& readStream(*bamStreams[current.sample_no]);
const bam_record& read(*(readStream.get_record_ptr()));
locusFinder.update(read, current.sample_no);
}
// finished updating:
locusFinder.flush();
timer.stop();
const CpuTimes totalTimes(timer.getTimes());
#ifdef DEBUG_ESL
log_os << log_tag << " found " << locusFinder.getLocusSet().size() << " loci. \n";
log_os << log_tag << " totalTime: ";
totalTimes.reportHr(log_os);
log_os << "\n";
#endif
locusFinder.setBuildTime(totalTimes);
locusFinder.getLocusSet().save(opt.outputFilename.c_str());
}