TraversalKind getTraversalKind (int argc, char* argv[])
{
const char* STR_TRAVERSAL_MODE = "-traversal";
TraversalKind result;
// We create a command line parser.
OptionsParser parser ("Traversal");
parser.push_back (new OptionOneParam (STR_TRAVERSAL_MODE, "traversal mode ('unitig' or 'contig'", true));
// We retrieve the traversal kind.
try
{
IProperties* props = parser.parse (argc, argv);
parse (props->getStr(STR_TRAVERSAL_MODE), result);
}
catch (OptionFailure& e)
{
e.displayErrors (std::cout);
exit (EXIT_FAILURE);
}
catch (Exception& e)
{
cout << e.getMessage() << endl;
exit (EXIT_FAILURE);
}
return result;
}
int main(int argc, const char **argv) {
OptionsParser parser;
if (parser.ParseOptions(argc, argv) < 0 || parser.m_Help) {
parser.Usage(argv[0]);
return -1;
}
Sid::SkypePCMInterfaceServer *pcmif_server = new Sid::SkypePCMInterfaceServer();
Sid::SkypePCMCallbackInterfaceClient *pcmif_cb_client = new Sid::SkypePCMCallbackInterfaceClient();
SkypePCMInterface* pcmif = SkypePCMInterfaceGet(pcmif_cb_client);
pcmif_server->set_if(pcmif);
Sid::String fromskypekitkey;
Sid::String toskypekitkey;
fromskypekitkey.Format( "%spcm_from_skypekit_key", parser.m_IpcPrefix);
toskypekitkey.Format( "%spcm_to_skypekit_key", parser.m_IpcPrefix);
pcmif_server->Connect(fromskypekitkey.data(), 0);
pcmif_cb_client->Connect(toskypekitkey.data(), 500);
if(parser.m_OutFile)
{
Sid::String cmd;
Sid::String response;
cmd.Format("OUT:%s",parser.m_OutFile);
pcmif->CustomCommand(cmd, response);
}
if(parser.m_InFile)
{
Sid::String cmd;
Sid::String response;
cmd.Format("IN:%s",parser.m_InFile);
pcmif->CustomCommand(cmd,response);
}
if(parser.m_Loop)
{
Sid::String cmd = "LOOP:1";
Sid::String response;
pcmif->CustomCommand("LOOP:1", response);
}
Sid::Protocol::Status status;
do {
status =pcmif_server->ProcessCommands();
} while (status == Sid::Protocol::OK);
SkypePCMInterfaceRelease(pcmif);
pcmif_server->Disconnect();
pcmif_cb_client->Disconnect();
delete pcmif_server;
delete pcmif_cb_client;
printf("PCMServerTransport disconnected, exiting from pcmtesthost\n");
}
/*********************************************************************
** METHOD :
** PURPOSE :
** INPUT :
** OUTPUT :
** RETURN :
** REMARKS :
*********************************************************************/
void VisibilityOptionsVisitor::visitOptionsParser (OptionsParser& object, size_t depth)
{
if (_names.find(object.getName()) != _names.end()) { object.setVisible(_visibility); }
for (std::list<IOptionsParser*>::const_iterator it = object.getParsers().begin(); it != object.getParsers().end(); ++it)
{
(*it)->accept (*this, depth+1);
}
}
int main (int argc, char* argv[])
{
// We create a command line parser.
OptionsParser parser ("SortingCount");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "sorting count input", true));
try
{
// Shortcuts.
typedef Kmer<>::Count Count;
typedef Kmer<>::Type Type;
// We parse the user options.
IProperties* options = parser.parse (argc, argv);
// We load the object storing the couples [kmer,abundance]
Storage* storage = StorageFactory(STORAGE_HDF5).load (options->getStr(STR_URI_INPUT)); LOCAL (storage);
// We get the group inside the storage object
Group& dskGroup = storage->getGroup("dsk");
// We retrieve the partition holding the couples [kmer,abundance]
Partition<Count>& solidKmers = dskGroup.getPartition<Count> ("solid");
// Now, we read the couples in two ways, computing a checksum in each case.
Type checksum1, checksum2;
// CASE 1: we read the couples [kmer,abundance] with an iterator over the whole partition
Iterator<Count>* it = solidKmers.iterator(); LOCAL (it);
for (it->first(); !it->isDone(); it->next()) { checksum1 = checksum1 + it->item().value; }
// CASE 2: we read the couples [kmer,abundance] with an iterator over each collection of the partition
for (size_t i=0; i<solidKmers.size(); i++)
{
// We get the current collection inside the partition
Collection<Count>& collection = solidKmers [i];
Iterator<Count>* it = collection.iterator(); LOCAL (it);
for (it->first(); !it->isDone(); it->next()) { checksum2 = checksum2 + it->item().value; }
}
// We check that we got the same checksum
cout << "checksum1=" << checksum1 << endl;
cout << "checksum2=" << checksum1 << endl;
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
return EXIT_SUCCESS;
}
int main(int argc, const char** argv)
{
string inFile = "";
string tileDir = "/class/cs225/mp6_bmps/";
string numTilesStr = "100";
string pixelsPerTileStr = "50";
string outFile = "mosaic.png";
OptionsParser optsparse;
optsparse.addArg(inFile);
optsparse.addArg(tileDir);
optsparse.addArg(numTilesStr);
optsparse.addArg(pixelsPerTileStr);
optsparse.addArg(outFile);
optsparse.addOption("help", opts::help);
optsparse.addOption("h", opts::help);
optsparse.parse(argc, argv);
if (opts::help)
{
cout << "Usage: " << argv[0] << " background_image.png tile_directory/ [number of tiles] [pixels per tile] [output_image.png]" << endl;
return 0;
}
if (inFile == "")
{
cout << "Usage: " << argv[0] << " background_image.png tile_directory/ [number of tiles] [pixels per tile] [output_image.png]" << endl;
return 1;
}
makePhotoMosaic(inFile, tileDir, lexical_cast<int>(numTilesStr), lexical_cast<int>(pixelsPerTileStr), outFile);
return 0;
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankFilter");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank reference", true));
parser.push_back (new OptionOneParam (STR_URI_SEQ_IDS, "file holding indexes of bank", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
/** We read the list of indexes. */
set<size_t> indexes;
FILE* file = fopen (options->getStr(STR_URI_SEQ_IDS).c_str(), "r");
if (file != 0)
{
char buffer[128];
while (fgets (buffer, sizeof(buffer), file)) { indexes.insert (atoi(buffer)); }
fclose (file);
}
cout << "found " << indexes.size() << " indexes" << endl;
/** We open the output bank. */
string outputBankUri = options->getStr(STR_URI_INPUT) + "_" + System::file().getBaseName (options->getStr(STR_URI_SEQ_IDS));
IBank* outputBank = Bank::open (outputBankUri);
LOCAL (outputBank);
/** We loop the input bank. */
IBank* inputBank = Bank::open (options->getStr(STR_URI_INPUT));
LOCAL (inputBank);
/** We use another iterator for filtering out some sequences. */
FilterIterator<Sequence,FilterFunctor> itSeq (inputBank->iterator(), FilterFunctor(indexes));
/** We loop the sequences. */
for (itSeq.first(); !itSeq.isDone(); itSeq.next())
{
outputBank->insert (itSeq.item());
}
/** We flush the output bank. */
outputBank->flush();
}
catch (OptionFailure& e)
{
return e.displayErrors (cout);
}
catch (Exception& e)
{
cerr << "EXCEPTION: " << e.getMessage() << endl;
}
}
MONGO_STARTUP_OPTIONS_PARSE(StartupOptions)(InitializerContext* context) {
OptionsParser parser;
Status ret = parser.run(startupOptions, context->args(), context->env(),
&startupOptionsParsed);
if (!ret.isOK()) {
std::cerr << ret.reason() << std::endl;
// TODO: Figure out if there's a use case for this help message ever being different
std::cerr << "try '" << context->args()[0]
<< " --help' for more information" << std::endl;
::_exit(EXIT_BADOPTIONS);
}
return Status::OK();
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankFilter");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
parser.push_back (new OptionOneParam (STR_FILTER_RATIO, "skip a sequence if 'good letters number / seq.len > X'", false, "0.8"));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
/** Shortcuts. */
double percentThreshold = options->getDouble(STR_FILTER_RATIO);
/** We open the input bank. */
IBank* inBank = Bank::open (options->getStr(STR_URI_INPUT));
LOCAL (inBank);
/** We create the output inBank. */
IBank* outBank = new BankFasta (options->getStr(STR_URI_INPUT) + "_filtered");
LOCAL (outBank);
/** We iterate the inBank. NOTE: WE USE A LAMBDA EXPRESSION HERE. */
inBank->iterate ([&] (Sequence& s)
{
/** Shortcut. */
char* data = s.getDataBuffer();
size_t nbOK = 0;
for (size_t i=0; i<s.getDataSize(); i++)
{
if (data[i]=='A' || data[i]=='C' || data[i]=='G' || data[i]=='T') { nbOK++; }
}
if ((double)nbOK / (double)s.getDataSize() > percentThreshold) { outBank->insert (s); }
});
/** We flush the output bank. */
outBank->flush();
}
catch (OptionFailure& e)
{
return e.displayErrors (cout);
}
catch (Exception& e)
{
cerr << "EXCEPTION: " << e.getMessage() << endl;
}
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankStats");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
std::string filename = options->getStr(STR_URI_INPUT);
//! [snippet16_bank]
// We get an instance of IBank from the URI.
IBank* bank = Bank::open (filename);
//! [snippet16_seq]
// We create an iterator on the bank
Iterator<Sequence>* it = bank->iterator();
// We iterate the sequences of the bank
for (it->first(); !it->isDone(); it->next())
{
// We get a shortcut on the current sequence and its data
Sequence& seq = it->item();
Data& data = seq.getData();
// We dump some information about the sequence.
std::cout << "comment " << seq.getComment() << std::endl;
// We dump each nucleotide. NOTE: the output depends on the data encoding
for (size_t i=0; i<data.size(); i++) { std::cout << data[i]; } std::cout << std::endl;
}
//! [snippet16_seq]
// The bank and the iterator have been allocated on the heap, so we have to delete them
delete it;
delete bank;
//! [snippet16_bank]
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
}
/*********************************************************************
** METHOD :
** PURPOSE :
** INPUT :
** OUTPUT :
** RETURN :
** REMARKS :
*********************************************************************/
void HierarchyParserVisitor::visitOptionsParser (OptionsParser& object, size_t depth)
{
for (std::list<IOptionsParser*>::const_iterator it = object.getParsers().begin(); it != object.getParsers().end(); ++it)
{
(*it)->accept (*this, depth+1);
}
}
int main(int argc, const char * argv[])
{
OptionsParser parser;
if (parser.ParseOptions(argc, argv) < 0 || parser.m_Help) {
parser.Usage(argv[0]);
return -1;
}
if (parser.m_List) {
CPPUNIT_NS::Test *test = CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest();
for (int i = 0; i < test->getChildTestCount(); i++) {
printf("test %s\n", test->getChildTestAt(i)->getName().c_str());
for (int j = 0; j < test->getChildTestAt(i)->getChildTestCount(); j++) {
printf("test %s\n", test->getChildTestAt(i)->getChildTestAt(j)->getName().c_str());
}
}
return 0;
}
CPPUNIT_NS::TestResult controller;
// Add a listener that colllects test result
CPPUNIT_NS::TestResultCollector result;
controller.addListener( &result );
// Add a listener that print dots as test run.
CPPUNIT_NS::BriefTestProgressListener progress;
controller.addListener( &progress );
CPPUNIT_NS::TestRunner runner;
// Add the single test to the test runner
if (parser.m_RunSingle) {
runner.addTest(
CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest()->findTest(parser.m_TestName));
// Add the top suite to the test runner
} else {
runner.addTest(CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest());
}
runner.run( controller );
// Print test in a compiler compatible format.
CPPUNIT_NS::CompilerOutputter outputter( &result, CPPUNIT_NS::stdCOut() );
outputter.write();
return result.wasSuccessful() ? 0 : 1;
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankStats");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
// We get information about the bank.
u_int64_t nbSequences=0, dataSize=0, seqMaxSize=0, seqMinSize=~0;
// We declare an input Bank and use it locally
IBank* inputBank = Bank::open (options->getStr(STR_URI_INPUT));
LOCAL (inputBank);
ProgressIterator<Sequence> it (*inputBank, "iterate");
for (it.first(); !it.isDone(); it.next())
{
Data& data = it.item().getData();
nbSequences ++;
if (data.size() > seqMaxSize) { seqMaxSize = data.size(); }
if (data.size() < seqMinSize) { seqMinSize = data.size(); }
dataSize += data.size ();
}
std::cout << "data size : " << dataSize << std::endl;
std::cout << "sequence number : " << nbSequences << std::endl;
std::cout << "sequence max size : " << seqMaxSize << std::endl;
std::cout << "sequence min size : " << seqMinSize << std::endl;
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
}
/*********************************************************************
** METHOD :
** PURPOSE :
** INPUT :
** OUTPUT :
** RETURN :
** REMARKS :
*********************************************************************/
void OptionsHelpVisitor::visitOptionsParser (OptionsParser& object, size_t depth)
{
if (object.isVisible() == true)
{
/** We first look for the longest option name. */
nameMaxLen=0;
for (list<IOptionsParser*>::const_iterator it = object.getParsers().begin(); it != object.getParsers().end(); ++it)
{
if (!(*it)->getName().empty()) { nameMaxLen = std::max (nameMaxLen, (*it)->getName().size()); }
}
os << endl;
indent(os,depth) << "[" << object.getName() << " options]" << endl;
/** We loop over each known parser. */
for (list<IOptionsParser*>::const_iterator it = object.getParsers().begin(); it != object.getParsers().end(); ++it)
{
if ((*it)->isVisible()) { (*it)->accept (*this, depth+1); }
}
}
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankDump");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
/** We dump the bank hierarchy. */
dump (Bank::open (options->getStr(STR_URI_INPUT)));
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("bankgen");
const char* OUTPUT_PREFIX = "-out";
const char* SEQ_LEN = "-seq-len";
const char* READ_LEN = "-read-len";
const char* OVERLAP_LEN = "-overlap-len";
const char* COVERAGE = "-coverage";
parser.push_back (new OptionOneParam (OUTPUT_PREFIX, "output prefix", true));
parser.push_back (new OptionOneParam (SEQ_LEN, "sequence length", false, "1000000"));
parser.push_back (new OptionOneParam (READ_LEN, "read length", false, "150" ));
parser.push_back (new OptionOneParam (OVERLAP_LEN, "overlap between two reads", false, "50" ));
parser.push_back (new OptionOneParam (COVERAGE, "coverage", false, "3" ));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
/** We create the random sequence. */
IBank* randomBank = new BankRandom (1, options->getInt(SEQ_LEN));
LOCAL (randomBank);
/** We create the reads bank. */
IBank* readsBank = new BankSplitter (
randomBank,
options->getInt(READ_LEN),
options->getInt(OVERLAP_LEN),
options->getInt(COVERAGE)
);
LOCAL (readsBank);
/** We save the random bank. */
SaveAsFasta (randomBank, options->getStr(OUTPUT_PREFIX) + "_sequence.fa");
/** We save the reads bank. */
SaveAsFasta (readsBank, options->getStr(OUTPUT_PREFIX) + "_reads.fa");
}
catch (OptionFailure& e)
{
e.getParser().displayErrors (stdout);
e.getParser().displayHelp (stdout);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
OptionsParser options;
options.ReadArgs(argc, argv);
int result = options.HandleArgs();
if (result != OPTIONS_ERROR && result != OPTIONS_HELP)
{
EnigmaPlugin plugin;
plugin.Init();
plugin.LogMakeToConsole();
plugin.SetDefinitions(options.APIyaml().c_str());
Game game;
GameMode mode;
std::string _mode = options.GetOption("mode").as<std::string>();
if (_mode == "Compile")
mode = emode_compile;
else if (_mode == "Run")
mode = emode_run;
else if (_mode == "Debug")
mode = emode_debug;
else if (_mode == "Design")
mode = emode_design;
else if (_mode == "Rebuild")
mode = emode_rebuild;
bool _run = options.GetOption("run").as<bool>();
if (!_run) plugin.HandleGameLaunch();
return plugin.BuildGame(game.ConstructGame(), mode, options.GetOption("output").as<std::string>().c_str());
}
return result;
}
int main (int argc, char* argv[])
{
const size_t SPAN = KMER_SPAN(1);
/** Shortcuts. */
typedef Kmer<SPAN>::Type Type;
typedef Kmer<SPAN>::Count Count;
typedef Kmer<SPAN>::ModelCanonical ModelCanon;
typedef Kmer<SPAN>::ModelMinimizer <ModelCanon> Model;
size_t kmerSize = 33;
size_t mmerSize = 11;
/** We create a command line parser. */
OptionsParser parser ("GraphStats");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
string filename = options->getStr (STR_URI_INPUT);
/** We create the solid kmers. */
Graph graph = Graph::create ("-in %s -kmer-size %d -bloom none -out toto.h5 -abundance-min 1", filename.c_str(), kmerSize);
/** We get the information of the solid kmers from the HDF5 file. */
Storage* storage = StorageFactory(STORAGE_HDF5).load ("toto.h5"); LOCAL (storage);
Group& dskGroup = storage->getGroup("dsk");
/** We get the solid kmers partition. */
Partition<Count>& partition = dskGroup.getPartition<Count> ("solid");
/** We create two kmers models. */
Model model (kmerSize, mmerSize);
Model modelK1 (kmerSize-1, mmerSize);
// We declare an output Bank
BankBinary outputBank (System::file().getBaseName(filename) + ".bin");
/** We create a sequence with BINARY encoding. */
Sequence seq (Data::ASCII);
/** We get an iterator over the [kmer,abundance] of solid kmers. */
Iterator<Count>* it = partition.iterator(); LOCAL (it);
/** We iterate the solid kmers. */
for (it->first(); !it->isDone(); it->next())
{
Type current = it->item().value;
cout << "kmer=" << it->item().value << " minimizer=" << model.getMinimizerValue(current)
<< " abundance=" << it->item().abundance << endl;
/** We interpret the kmer value as a Data object. */
Data data (Data::BINARY);
data.setRef ((char*) ¤t, model.getKmerSize());
modelK1.iterate (data, [&] (const Model::Kmer& k, size_t idx)
{
/** Shortcut. */
Type miniminizerCurrent = k.minimizer().value();
cout << "-> " << k.value()
<< " minimizer=" << miniminizerCurrent << " "
<< modelK1.getMmersModel().toString (miniminizerCurrent)
<< endl;
string tmp = modelK1.getMmersModel().toString (miniminizerCurrent);
/** We interpret the minimizer value as a Data object. */
seq.getData().setRef ((char*)tmp.c_str(), modelK1.getMmersModel().getKmerSize());
/** We insert the sequence into the binary bank. */
outputBank.insert (seq);
});
}
/** We flush the output bank. */
outputBank.flush();
/** We iterate the output bank. */
outputBank.iterate ([&] (const Sequence& s)
{
/** We get the kmer corresponding to the current sequence. */
ModelCanon::Kmer mini = modelK1.getMmersModel().codeSeed (s.getDataBuffer(), Data::BINARY);
cout << "mini=" << mini.value() << " " << modelK1.getMmersModel().toString (mini.value()) << endl;
});
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser;
parser.push_back (new OptionOneParam (STR_URI_INPUT, "graph file", true));
IProperties* params = 0;
try {
/** We parse the user options. */
params = parser.parse (argc, argv);
}
catch (OptionFailure& e)
{
e.getParser().displayErrors (stdout);
e.getParser().displayHelp (stdout);
return EXIT_FAILURE;
}
// We create the graph with the bank and other options
Graph graph = Graph::load (params->getStr(STR_URI_INPUT));
// We create a graph marker.
GraphMarker<BranchingNode> marker (graph);
// We create an object for Breadth First Search for the de Bruijn graph.
BFS<BranchingNode> bfs (graph);
// We want to compute the distribution of connected components of the branching nodes.
// - key is a connected component class (for a given number of branching nodes for this component)
// - value is the number of times this component class occurs in the branching sub graph
map<size_t,Entry> distrib;
// We get an iterator for all nodes of the graph. We use a progress iterator to get some progress feedback
ProgressGraphIterator<BranchingNode,ProgressTimer> itBranching (graph.iterator<BranchingNode>(), "statistics");
// We want to know the number of connected components
size_t nbConnectedComponents = 0;
// We define some kind of unique identifier for a couple (indegree,outdegree)
map <InOut_t, size_t> topology;
size_t simplePathSizeMin = ~0;
size_t simplePathSizeMax = 0;
// We want time duration of the iteration
TimeInfo ti;
ti.start ("compute");
// We loop the branching nodes
for (itBranching.first(); !itBranching.isDone(); itBranching.next())
{
// We get branching nodes neighbors for the current branching node.
Graph::Vector<BranchingEdge> successors = graph.successors <BranchingEdge> (*itBranching);
Graph::Vector<BranchingEdge> predecessors = graph.predecessors<BranchingEdge> (*itBranching);
// We increase the occurrences number for the current couple (in/out) neighbors
topology [make_pair(predecessors.size(), successors.size())] ++;
// We loop the in/out neighbors and update min/max simple path size
for (size_t i=0; i<successors.size(); i++)
{
simplePathSizeMax = std::max (simplePathSizeMax, successors[i].distance);
simplePathSizeMin = std::min (simplePathSizeMin, successors[i].distance);
}
for (size_t i=0; i<predecessors.size(); i++)
{
simplePathSizeMax = std::max (simplePathSizeMax, predecessors[i].distance);
simplePathSizeMin = std::min (simplePathSizeMin, predecessors[i].distance);
}
// We skip already visited nodes.
if (marker.isMarked (*itBranching)) {
continue;
}
// We launch the breadth first search; we get as a result the set of branching nodes in this component
const set<BranchingNode>& component = bfs.run (*itBranching);
// We mark the nodes for this connected component
marker.mark (component);
// We update our distribution
distrib[component.size()].nbOccurs += 1;
// We update the number of connected components.
nbConnectedComponents++;
}
ti.stop ("compute");
// We compute the total number of branching nodes in all connected components.
size_t sumOccurs = 0;
size_t sumKmers = 0;
for (map<size_t,Entry>::iterator it = distrib.begin(); it != distrib.end(); it++)
{
sumOccurs += it->first*it->second.nbOccurs;
sumKmers += it->second.nbKmers;
}
// We sort the statistics by decreasing occurrence numbers. Since map have its own ordering, we need to put all
// the data into a vector and sort it with our own sorting criteria.
vector < pair<InOut_t,size_t> > stats;
for (map <InOut_t, size_t>::iterator it = topology.begin(); it != topology.end(); it++) {
stats.push_back (*it);
}
sort (stats.begin(), stats.end(), CompareFct);
// Note: it must be equal to the number of branching nodes of the graph
assert (sumOccurs == itBranching.size());
// We aggregate the computed information
Properties props ("topology");
props.add (1, "graph");
props.add (2, "name", "%s", graph.getName().c_str());
props.add (2, "db_input", "%s", graph.getInfo().getStr("input").c_str());
props.add (2, "db_nb_seq", "%d", graph.getInfo().getInt("sequences_number"));
props.add (2, "db_size", "%d", graph.getInfo().getInt("sequences_size"));
props.add (2, "kmer_size", "%d", graph.getInfo().getInt("kmer_size"));
props.add (2, "kmer_nks", "%d", graph.getInfo().getInt("nks"));
props.add (2, "nb_nodes", "%d", graph.getInfo().getInt("kmers_nb_solid"));
props.add (2, "nb_branching_nodes", "%d", graph.getInfo().getInt("nb_branching"));
props.add (2, "percent_branching_nodes", "%.1f",
graph.getInfo().getInt("kmers_nb_solid") > 0 ?
100.0 * (float)graph.getInfo().getInt("nb_branching") / (float) graph.getInfo().getInt("kmers_nb_solid") : 0
);
props.add (1, "branching_nodes");
props.add (2, "simple_path");
props.add (3, "size_min", "%d", simplePathSizeMin);
props.add (3, "size_max", "%d", simplePathSizeMax);
props.add (2, "neighborhoods");
for (size_t i=0; i<stats.size(); i++)
{
props.add (3, "neighborhood", "in=%d out=%d", stats[i].first.first, stats[i].first.second);
props.add (4, "nb_bnodes", "%d", stats[i].second);
props.add (4, "percentage", "%5.2f", itBranching.size() > 0 ?
100.0*(float)stats[i].second / (float)itBranching.size() : 0
);
}
props.add (2, "connected_components");
props.add (3, "nb_classes", "%d", distrib.size());
props.add (3, "nb_components", "%d", nbConnectedComponents);
for (map<size_t,Entry>::iterator it = distrib.begin(); it!=distrib.end(); it++)
{
props.add (3, "component_class");
props.add (4, "nb_occurs", "%d", it->second.nbOccurs);
props.add (4, "nb_bnodes", "%d", it->first);
props.add (4, "freq_bnodes", "%f", sumOccurs > 0 ?
100.0*(float)(it->first*it->second.nbOccurs) / (float)sumOccurs : 0
);
}
props.add (1, ti.getProperties("time"));
// We dump the results in a XML file in the current directory
XmlDumpPropertiesVisitor v (graph.getName() + ".xml", false);
props.accept (&v);
return EXIT_SUCCESS;
}
int
SwitchWContexts::init_from_command_line_options(int argc, char *argv[],
TargetParserIface *tp) {
OptionsParser parser;
parser.parse(argc, argv, tp);
notifications_addr = parser.notifications_addr;
auto transport = std::shared_ptr<TransportIface>(
TransportIface::make_nanomsg(notifications_addr));
transport->open();
#ifdef BMDEBUG_ON
// has to be before init_objects because forces arith
if (parser.debugger) {
for (Context &c : contexts)
c.set_force_arith(true);
Debugger::init_debugger(parser.debugger_addr);
}
#endif
event_logger_addr = parser.event_logger_addr;
if (parser.console_logging)
Logger::set_logger_console();
if (parser.file_logger != "")
Logger::set_logger_file(parser.file_logger, parser.log_flush);
Logger::set_log_level(parser.log_level);
int status = init_objects(parser.config_file_path, parser.device_id,
transport);
if (status != 0) return status;
if (parser.use_files)
set_dev_mgr_files(parser.wait_time);
else if (parser.packet_in)
set_dev_mgr_packet_in(device_id, parser.packet_in_addr, transport);
else
set_dev_mgr_bmi(device_id, transport);
for (const auto &iface : parser.ifaces) {
std::cout << "Adding interface " << iface.second
<< " as port " << iface.first
<< (parser.use_files ? " (files)" : "")
<< std::endl;
const char* inFileName = NULL;
const char* outFileName = NULL;
std::string inFile;
std::string outFile;
if (parser.use_files) {
inFile = iface.second + "_in.pcap";
inFileName = inFile.c_str();
outFile = iface.second + "_out.pcap";
outFileName = outFile.c_str();
} else if (parser.pcap) {
inFile = iface.second + ".pcap";
inFileName = inFile.c_str();
outFileName = inFileName;
}
port_add(iface.second, iface.first, inFileName, outFileName);
}
thrift_port = parser.thrift_port;
if (parser.state_file_path != "") {
status = deserialize_from_file(parser.state_file_path);
if (status != 0) return status;
}
// TODO(unknown): is this the right place to do this?
set_packet_handler(packet_handler, static_cast<void *>(this));
start();
return status;
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("GraphStats");
parser.push_back (new OptionOneParam (STR_URI_GRAPH, "graph input", true));
parser.push_back (new OptionOneParam (STR_NB_CORES, "nb cores", false, "0"));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
// We load the graph
Graph graph = Graph::load (options->getStr(STR_URI_GRAPH));
// We set the number of cores to be used. Use all available cores if set to 0.
size_t nbCores = options->getInt(STR_NB_CORES);
// We get an iterator for branching nodes of the graph.
// We use a progress iterator to get some progress feedback
ProgressGraphIterator<BranchingNode,ProgressTimer> itBranching (graph.iterator<BranchingNode>(), "statistics");
// We define some kind of unique identifier for a couple (indegree,outdegree)
typedef pair<size_t,size_t> InOut_t;
// We want to gather some statistics during the iteration.
// Note the use of ThreadObject: this object will be cloned N times (one object per thread) and each clone will
// be reachable within the iteration block through ThreadObject::operator()
ThreadObject <map <InOut_t, size_t> > topology;
// We dispatch the iteration on several cores. Note the usage of lambda expression here.
IDispatcher::Status status = Dispatcher(nbCores).iterate (itBranching, [&] (const BranchingNode& node)
{
// We retrieve the current instance of map <InOut_t,size_t> for the current running thread.
map <InOut_t,size_t>& localTopology = topology();
// We get branching nodes neighbors for the current branching node.
Graph::Vector<BranchingEdge> successors = graph.successors <BranchingEdge> (node);
Graph::Vector<BranchingEdge> predecessors = graph.predecessors<BranchingEdge> (node);
// We increase the occurrences number for the current couple (in/out) neighbors
localTopology [make_pair(predecessors.size(), successors.size())] ++;
});
// Now, the parallel processing is done. We want now to aggregate the information retrieved
// in each thread in a single map.
// We get each map<InOut_t,size_t> object filled in each thread, and we add its data into the "global" map.
// The global map is reachable through the ThreadObject::operator*. The "topology.foreach" will loop over
// all cloned object used in the threads.
topology.foreach ([&] (const map <InOut_t, size_t>& t)
{
// We update the occurrence of the current couple (in/out)
for_each (t.begin(), t.end(), [&] (const pair<InOut_t, size_t>& p) { (*topology)[p.first] += p.second; });
});
// We sort the statistics by decreasing occurrence numbers. Since map have its own ordering, we need to put all
// the data into a vector and sort it with our own sorting criteria.
vector < pair<InOut_t,size_t> > stats;
for (auto it = topology->begin(); it != topology->end(); it++) { stats.push_back (*it); }
sort (stats.begin(), stats.end(), [=] (const pair<InOut_t,size_t>& a, const pair<InOut_t,size_t>& b) { return a.second > b.second; });
printf ("\nThere are %d branching nodes with the following distribution: \n", itBranching.size());
size_t sum=0;
for (size_t i=0; i<stats.size(); i++)
{
sum += stats[i].second;
printf (" [in=%d out=%d] nb=%7d percent=%5.2f distrib=%5.2f\n",
stats[i].first.first,
stats[i].first.second,
stats[i].second,
100.0*(float)stats[i].second / (float)itBranching.size(),
100.0*(float)sum / (float)itBranching.size()
);
}
printf ("\nDone on %d cores in %.2f sec\n\n", status.nbCores, (float)status.time/1000.0);
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
return EXIT_SUCCESS;
}
void monad::processArgs(int argc, const char * const * argv)
{
// Create OptionsMap for options and vector for positional arguments:
OptionsParser options;
// Add our possible options to our map
options.addOption("solution", opts::solution);
options.addOption("newtests", opts::newtests);
options.addOption("provided", opts::provided);
options.addOption("clean", opts::clean);
options.addOption("update", opts::update);
options.addOption("staff", opts::staff);
options.addOption("optimize", opts::optimize);
options.addOption("verbose", opts::verbose);
options.addOption("buffer", opts::buffer);
options.addOption("valgrind", opts::valgrind);
options.addOption("parallel", opts::parallel);
options.addOption("help", opts::help);
options.addOption("h", opts::help);
options.addOption("info", opts::info);
options.addOption("version", opts::info);
options.addOption("v", opts::info);
options.addOption("license", opts::license);
// Add arguments
string assignment = "";
options.addArg(assignment);
// Read in options and arguments
vector<string> posargs = options.parse(argc, argv);
// Help
if (opts::help || toLower(assignment) == "help")
{
if (toLower(assignment) == "config")
printHelpConfig();
else if (toLower(assignment) == "tests")
printHelpTests();
else
printHelp();
exit(0);
}
// Info
if (opts::info)
{
printInfo();
exit(0);
}
// License
if (opts::license)
{
printLicense();
exit(0);
}
// Clean
if (toLower(assignment) == "clean")
{
system("/bin/rm -rf *_grade/ *_tests/ *_newtests/ *_providedtests *_solution/");
exit(0);
}
// Check argument list length
if (assignment == "")
{
cout << "Usage: " << argv[0] << " mp1" << endl;
cout << "Run \'" << argv[0] << " --help\' for more information" << endl;
exit(0);
}
// Find mp/lab name and tests folder
vector<string> splitname = tokenize(assignment, '.');
assignment_base = splitname[0];
if (splitname.size() == 1)
mp_part = no_mp_part;
else
mp_part = lexical_cast<int>(splitname[1].c_str());
gradeFolder = "./" + assignment_base + "_grade/";
if (!exists(gradeFolder)) opts::clean = true;
if (opts::clean)
tempFolder = "";
else
tempFolder = "./" + assignment_base + "_temp/";
// Find source folder (i.e. ../mp1)
if (opts::solution)
sourceFolder = updateFolder(assignment_base + "_solution/", false);
else
sourceFolder = getFolder(assignment_base + '/', false);
// tests folder
if (opts::provided)
testsFolder = updateFolder(assignment_base + "_provided/", false);
else if (opts::newtests)
testsFolder = updateFolder(assignment_base + "_newtests/", false);
else
testsFolder = updateFolder(assignment_base + "_tests/", false);
}
void monad::processArgs(int argc, const char* const* argv)
{
// Create OptionsMap for options and vector for positional arguments:
OptionsParser options;
// Add our possible options to our map
options.addOption("solution", opts::solution);
options.addOption("newtests", opts::newtests);
options.addOption("provided", opts::provided);
options.addOption("clean", opts::clean);
options.addOption("update", opts::update);
options.addOption("staff", opts::staff);
options.addOption("optimize", opts::optimize);
options.addOption("detailed", opts::detailed);
options.addOption("verbose", opts::verbose);
options.addOption("buffer", opts::buffer);
options.addOption("asan", opts::asan);
options.addOption("parallel", opts::parallel);
options.addOption("help", opts::help);
options.addOption("h", opts::help);
options.addOption("info", opts::info);
options.addOption("version", opts::info);
options.addOption("v", opts::info);
options.addOption("license", opts::license);
// Add arguments
string assignment = "";
options.addArg(assignment);
// Read in options and arguments
vector<string> posargs = options.parse(argc, argv);
// Help
if (opts::help || toLower(assignment) == "help")
{
if (toLower(assignment) == "config")
printHelpConfig();
else if (toLower(assignment) == "tests")
printHelpTests();
else
printHelp();
exit(0);
}
// Info
if (opts::info)
{
printInfo();
exit(0);
}
// License
if (opts::license)
{
printLicense();
exit(0);
}
// Clean
if (toLower(assignment) == "clean")
{
system("/bin/rm -rf *_grade/ *_tests/ *_newtests/ *_provided/ "
"*_solution/");
exit(0);
}
// Check argument list length
if (assignment == "")
{
cout << "Usage: " << argv[0] << " mp1" << endl;
cout << "Run \'" << argv[0] << " --help\' for more information" << endl;
exit(0);
}
// Find mp/lab name and tests folder
if (assignment[assignment.length() - 1] == '/')
assignment = assignment.substr(0, assignment.length() - 1);
size_t slash_i = assignment.find_last_of('/');
string assignment_name =
(slash_i == string::npos) ? assignment : assignment.substr(slash_i + 1);
string assignment_dir =
(slash_i == string::npos) ? "" : assignment.substr(0, slash_i);
// TODO (toole1): All this stuff is ugly!
vector<string> splitname = tokenize(assignment_name, '.');
assignment_base = splitname[0];
if (splitname.size() == 1)
mp_part = no_mp_part;
else
mp_part = lexical_cast<int>(splitname[1].c_str());
gradeFolder = "./" + assignment_base + "_grade/";
if (!exists(gradeFolder))
opts::clean = true;
if (opts::clean)
tempFolder = "";
else
tempFolder = "./" + assignment_base + "_temp/";
// Find source folder (i.e. ../mp1)
// TODO (toole1): I'm not sure if we should really use updateFolder
// vs getFolder here, and I've forgotten if the original reasoning
// was deeper than I have the _solution in ../
if (opts::solution)
sourceFolder = updateFolder(assignment_base + "_solution/", false);
else
sourceFolder = getFolder(assignment_base + '/', assignment_dir, false);
// tests folder
if (opts::provided)
testsFolder = updateFolder(assignment_base + "_provided/", false);
else if (opts::newtests)
testsFolder = updateFolder(assignment_base + "_newtests/", false);
else
testsFolder = updateFolder(assignment_base + "_tests/", false);
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("BankSplitter");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank reference", true));
parser.push_back (new OptionOneParam (STR_MAX_INPUT_SIZE, "average db size per split", true));
parser.push_back (new OptionOneParam (STR_URI_OUTPUT_DIR, "output directory", false, "."));
parser.push_back (new OptionNoParam (STR_OUTPUT_FASTQ, "fastq output", false));
parser.push_back (new OptionNoParam (STR_OUTPUT_GZ, "gzip output", false));
// We define a try/catch block in case some method fails (bad filename for instance)
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
/** Shortcuts. */
u_int64_t maxDbSize = options->getInt(STR_MAX_INPUT_SIZE);
// We declare an input Bank
IBank* inputBank = Bank::open (options->getStr(STR_URI_INPUT));
LOCAL (inputBank);
// We get the basename of the input bank.
string inputBasename = System::file().getBaseName (options->getStr(STR_URI_INPUT));
/** We set the name of the output directory. */
stringstream ss; ss << inputBasename << "_S" << maxDbSize;
string outputDirName = ss.str();
/** We create the output directory. */
string outputDir = options->getStr(STR_URI_OUTPUT_DIR) + "/" + outputDirName;
System::file().mkdir (outputDir, S_IRWXU);
// We create the album bank.
BankAlbum album (outputDir + "/album.txt");
/** We get estimations about the bank. */
u_int64_t number, totalSize, maxSize;
inputBank->estimate (number, totalSize, maxSize);
u_int64_t estimationNbSeqToIterate = number;
// We create an iterator over the input bank
ProgressIterator<Sequence> itSeq (*inputBank, "split");
// We loop over sequences to get the exact number of sequences.
int64_t nbBanksOutput = -1;
u_int64_t nbSequences = 0;
u_int64_t dbSize = ~0;
bool isFastq = options->get(STR_OUTPUT_FASTQ) != 0;
bool isGzipped = options->get(STR_OUTPUT_GZ) != 0;
IBank* currentBank = 0;
for (itSeq.first(); !itSeq.isDone(); itSeq.next())
{
if (dbSize > maxDbSize)
{
if (currentBank != 0) { currentBank->flush(); currentBank->finalize(); }
nbBanksOutput ++;
/** We build the uri of the current bank. */
stringstream ss; ss << inputBasename << "_" << nbBanksOutput << (isFastq ? ".fastq" : ".fasta");
if (isGzipped) { ss << ".gz"; }
/** We create a new bank and put it in the album. */
currentBank = album.addBank (outputDir, ss.str(), isFastq, isGzipped);
/** We reinit the db size counter. */
dbSize = 0;
}
dbSize += itSeq->getDataSize();
/** We insert the sequence into the current output bank. */
currentBank->insert (*itSeq);
}
if (currentBank != 0) { currentBank->flush(); }
}
catch (OptionFailure& e)
{
return e.displayErrors (cout);
}
catch (Exception& e)
{
cerr << "EXCEPTION: " << e.getMessage() << endl;
}
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("GraphStats");
parser.push_back (new OptionOneParam (STR_URI_GRAPH, "graph input", true));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
// We load the graph
Graph graph = Graph::load (options->getStr(STR_URI_GRAPH));
// We create a graph marker.
GraphMarker marker (graph);
// We create an object for Breadth First Search for the de Bruijn graph.
BFS bfs (graph);
// We want to compute the distribution of connected components of the branching nodes.
// - key is a connected component class (for a given number of branching nodes for this component)
// - value is the number of times this component class occurs in the branching sub graph
map<size_t,size_t> distrib;
// We get an iterator for all nodes of the graph. We use a progress iterator to get some progress feedback
ProgressGraphIterator<BranchingNode,ProgressTimer> itBranching (graph.iteratorBranching(), "statistics");
// We want time duration of the iteration
TimeInfo ti;
ti.start ("compute");
// We need to keep each connected component.
list<set<BranchingNode> > components;
// We loop the branching nodes
for (itBranching.first(); !itBranching.isDone(); itBranching.next())
{
// We skip already visited nodes.
if (marker.isMarked (*itBranching)) { continue; }
// We launch the breadth first search; we get as a result the set of branching nodes in this component
const set<BranchingNode>& component = bfs.run (*itBranching);
// We memorize the component
components.push_back (component);
// We mark the nodes for this connected component
marker.mark (component);
// We update our distribution
distrib[component.size()] ++;
}
ti.stop ("compute");
// We compute the total number of branching nodes in all connected components.
size_t sum = 0; for (map<size_t,size_t>::iterator it = distrib.begin(); it != distrib.end(); it++) { sum += it->first*it->second; }
// Note: it must be equal to the number of branching nodes of the graph
assert (sum == itBranching.size());
size_t idx1=0;
size_t cc=0;
// We check that each component has no intersection with all other components.
// Note: this check may take a long time since we have N^2 intersections to compute.
for (list<set<BranchingNode> >::iterator it1 = components.begin(); it1 != components.end(); it1++, idx1++)
{
size_t idx2=0;
for (list<set<BranchingNode> >::iterator it2 = components.begin(); it2 != components.end(); it2++, idx2++)
{
if (it1 != it2)
{
set<BranchingNode> inter;
set_intersection (it1->begin(),it1->end(),it2->begin(),it2->end(), std::inserter(inter,inter.begin()));
if (inter.size()!=0) { printf ("ERROR, intersection should be empty...\n"); exit(EXIT_FAILURE); }
}
if (++cc % 50 == 0)
{
cc = 0;
printf ("[check] %.1f %.1f\r", 100.0*(float)idx1/(float)components.size(), 100.0*(float)idx2/(float)components.size());
fflush (stdout);
}
}
}
printf ("\n");
// We aggregate the computed information
Properties props ("connected_components");
props.add (1, "graph_name", "%s", graph.getName().c_str());
props.add (1, "nb_branching_nodes", "%d", sum);
props.add (1, "nb_connected_components", "%d", distrib.size());
for (map<size_t,size_t>::iterator it = distrib.begin(); it!=distrib.end(); it++)
{
props.add (2, "component");
props.add (3, "nb_nodes", "%d", it->first);
props.add (3, "nb_occurs", "%d", it->second);
props.add (3, "freq_nodes", "%f", 100.0*(float)(it->first*it->second) / (float)sum);
props.add (3, "freq_occurs", "%f", 100.0*(float)it->second / (float)sum);
}
props.add (1, ti.getProperties("time"));
// We dump the results in a XML file in the current directory
XmlDumpPropertiesVisitor v (graph.getName() + ".xml", false);
props.accept (&v);
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
return EXIT_SUCCESS;
}
// ==================================================================================================================
// BEGIN: main
// ==================================================================================================================
int main(int argc, char *argv[])
{
OptionsParser op;
if (!op.ParseOptions(argc, argv))
return -1;
std::string outputDir = utils::GetParentDirectory(op.outputFilename);
communicator_type com;
com.allocateGPU();
agile::GPUTimer timer;
timer.start();
agile::GPUEnvironment::printInformation(std::cout);
std::cout << std::endl;
// kdata
CVector kdata;
// kspace mask/trajectory
RVector mask;
// density compensation in case of nonuniform data
RVector w(0);
// get data dimensions
std::string extension = utils::GetFileExtension(op.kdataFilename);
std::cout << "Extension:" << extension << std::endl;
Dimension dims; // = op.dims;
if (extension.compare(".bin") == 0)
dims = op.dims;
else if (extension.compare(".cfl") == 0)
{
long dimensions[4];
utils::ReadCflHeader(op.kdataFilename, dimensions);
dims.width=dimensions[0];
dims.height=dimensions[1];
dims.depth=dimensions[2];
dims.readouts=dimensions[0];
dims.encodings=dimensions[1];
dims.encodings2=dimensions[2];
dims.coils=dimensions[3];
dims.frames=dimensions[3];
std::cout << "DIMS main; nx: " << dims.width << " / ny:" << dims.height << " / nz:" << dims.depth << " / nc:" << dims.coils << std::endl;
std::cout << "DIMS main; nRO: " << dims.readouts << " / nENC1:" << dims.encodings << " / nENC2:" << dims.encodings2 << " / nframes:" << dims.frames << std::endl;
}
if (op.rawdata)
{
PerformRawDataPreparation(dims, op, kdata, mask, w);
}
else
{
std::cout << "Binary files defined...." << std::endl;
if (!LoadGPUVectorFromFile(op.kdataFilename, kdata))
return -1;
else
std::cout << "Data File " << op.kdataFilename << " successfully loaded." << std::endl;
if (!LoadGPUVectorFromFile(op.maskFilename, mask))
return -1;
else
std::cout << "Mask File " << op.maskFilename << " successfully loaded." << std::endl;
// set values in data-array to zero according to mask
if (!op.nonuniform)
{
if (op.method==TGV2_3D)
{
for (unsigned coil = 0; coil < dims.coils; coil++)
{
unsigned offset = dims.width * dims.height * dims.depth * coil;
agile::lowlevel::multiplyElementwise(
kdata.data() + offset, mask.data(),
kdata.data() + offset, dims.width * dims.height * dims.depth);
}
}
else
{
for (unsigned frame = 0; frame < dims.frames; frame++)
{
unsigned offset = dims.width * dims.height * dims.coils * frame;
for (unsigned coil = 0; coil < dims.coils; coil++)
{
unsigned int x_offset = offset + coil * dims.width * dims.height;
agile::lowlevel::multiplyElementwise(
kdata.data() + x_offset, mask.data() + dims.width * dims.height * frame,
kdata.data() + x_offset, dims.width * dims.height);
}
}
}
}
}
BaseOperator *baseOp = NULL;
unsigned N;
if (op.method==TGV2_3D)
N = dims.width * dims.height * dims.depth;
else
N = dims.width * dims.height;
CVector b1, u0;
// init b1 and u0
b1 = CVector(N * dims.coils);
b1.assign(N * dims.coils, 1.0);
u0 = CVector(N);
u0.assign(N, 0.0);
// check if b1 and u0 data is provided
if (LoadGPUVectorFromFile(op.sensitivitiesFilename, b1))
{
std::cout << "B1 File " << op.sensitivitiesFilename
<< " successfully loaded." << std::endl;
if (LoadGPUVectorFromFile(op.u0Filename, u0))
{
std::cout << " initial solution (u0) file " << op.u0Filename
<< " successfully loaded." << std::endl;
}
else
{
std::cout << "no initial solution (u0) data provided!" << std::endl;
}
}
else
{
if (op.method==TGV2_3D)
{
std::cerr << "Coil Construction for 3D reconstruction not implemented! Provide b1 seperately!"
<< std::endl;
return -1;
}
std::cout << "Performing Coil Construction!" << std::endl;
CVector u(N * dims.coils);
u.assign(N * dims.coils, 0.0);
if (op.nonuniform)
{
PerformNonCartesianCoilConstruction(dims, op, kdata, u, b1, mask, w, com);
}
else
{
PerformCartesianCoilConstruction(dims, op, kdata, u, b1, mask, com);
}
utils::GetSubVector(u, u0, dims.coils - 1, N);
ExportAdditionalResultsToMatlabBin(outputDir.c_str(),
"b1_reconstructed.bin", b1);
ExportAdditionalResultsToMatlabBin(outputDir.c_str(),
"u0_reconstructed.bin", u0);
}
if (op.nonuniform)
{
unsigned nFE = dims.readouts;
unsigned spokesPerFrame = dims.encodings;
std::cout << "Init NonCartesian Operator using kernelWidth:"
<< op.gpuNUFFTParams.kernelWidth
<< " sectorWidth:" << op.gpuNUFFTParams.sectorWidth
<< " OSF:" << op.gpuNUFFTParams.osf << std::endl;
// Create 2d-t MR Operator
baseOp = new NoncartesianOperator(
dims.width, dims.height, dims.coils, dims.frames,
spokesPerFrame * dims.frames, nFE, spokesPerFrame, mask, w, b1,
op.gpuNUFFTParams.kernelWidth, op.gpuNUFFTParams.sectorWidth,
op.gpuNUFFTParams.osf);
}
else
{
// Create 3d MR Operator
if (op.method==TGV2_3D)
{
baseOp = new CartesianOperator3D(dims.width, dims.height, dims.depth,
dims.coils, mask, false);
}
else
{
baseOp = new CartesianOperator(dims.width, dims.height, dims.coils,
dims.frames, mask, false);
}
}
// ==================================================================================================================
// BEGIN: Perform iterative (TV, TGV2, TGV_3D, ICTGV2) reconstruction
// ==================================================================================================================
PDRecon *recon = NULL;
GenerateReconOperator(&recon, op, baseOp);
CVector x(0); // resize at runtime
if (op.method==TGV2_3D)
{
x.resize(N, 0.0);
agile::copy(u0, x);
}
else
{
x.resize(N * dims.frames, 0.0);
for (unsigned frame = 0; frame < dims.frames; frame++)
{
utils::SetSubVector(u0, x, frame, N);
}
}
std::cout << "Initialization time: " << timer.stop() / 1000 << "s"
<< std::endl;
timer.start();
// run reconstruction
recon->IterativeReconstruction(kdata, x, b1);
std::cout << "Execution time: " << timer.stop() / 1000 << "s" << std::endl;
// ==================================================================================================================
// END: Perform iterative (TV, TGV2, TGV_3D, ICTGV2) reconstruction
// ==================================================================================================================
// ==================================================================================================================
// BEGIN: Define output
// ==================================================================================================================
std::string extension_out = utils::GetFileExtension(op.outputFilename);
std::vector<CType> xHost;
x.copyToHost(xHost);
// write reconstruction to bin file
if (extension_out.compare(".bin") == 0)
{
std::cout << "writing output file to: " << op.outputFilename << std::endl;
agile::writeVectorFile(op.outputFilename.c_str(), xHost);
}
// write reconstruction to h5 file
else if (extension_out.compare(".h5") == 0)
{
std::vector<size_t> dimVec;
dimVec.push_back(dims.width);
dimVec.push_back(dims.height);
dimVec.push_back(dims.frames);
utils::WriteH5File(op.outputFilename, "recon", dimVec, xHost);
}
// write reconstruction to dicom file
else if (extension_out.compare(".dcm") == 0)
{
agile::DICOM dicomfile;
std::string filenamewoe = utils::GetFilename(op.outputFilename);
std::ostringstream ss;
for (unsigned frame = 0; frame < dims.frames; frame++)
{
std::vector<float> xoutmag;
std::vector<float> xoutphs;
for( unsigned i = N*frame; i < N*(frame+1); i++ )
{
xoutmag.push_back( (float)std::sqrt( pow(real(xHost[i]),2) + pow(std::imag(xHost[i]),2) ) ) ;
xoutphs.push_back( (float)std::atan2( real(xHost[i]),std::imag(xHost[i]) ) );
}
ss << std::setw(3) << std::setfill('0') << frame;
// magnitude
const std::string str = ss.str();
std::string outputPath1 = boost::lexical_cast<std::string>(outputDir) + "/" + filenamewoe + "_magframe" + ss.str() + ".dcm";
std::cout << "writing dicom file to: " << outputPath1 << std::endl;
//dicomfile.set_dicominfo(_in_dicomfile.get_dicominfo());
dicomfile.gendicom(outputPath1.c_str(), xoutmag, dims.height, dims.width);
// phase
std::string outputPath2 = boost::lexical_cast<std::string>(outputDir) + "/" + filenamewoe + "_phsframe" + ss.str() + ".dcm";
std::cout << "writing dicom file to: " << outputPath2 << std::endl;
//dicomfile.set_dicominfo(_in_dicomfile.get_dicominfo());
dicomfile.gendicom(outputPath2.c_str(), xoutphs, dims.height, dims.width);
ss.str("");
}
}
else
{
// write reconstruction to binary file
agile::writeVectorFile(op.outputFilename.c_str(), xHost);
}
// export additional information (pdgap, ictgv-component)
if (op.extradata)
recon->ExportAdditionalResults(outputDir.c_str(),
&ExportAdditionalResultsToMatlabBin);
// ==================================================================================================================
// END: Define output
// ==================================================================================================================
delete recon;
delete baseOp;
}
int main (int argc, char* argv[])
{
/** We create a command line parser. */
OptionsParser parser ("KmerTest");
parser.push_back (new OptionOneParam (STR_URI_INPUT, "bank input", true));
parser.push_back (new OptionOneParam (STR_KMER_SIZE, "kmer size", true));
parser.push_back (new OptionOneParam (STR_MINIMIZER_SIZE, "minimizer size", true));
parser.push_back (new OptionNoParam (STR_VERBOSE, "display kmers", false));
try
{
/** We parse the user options. */
IProperties* options = parser.parse (argc, argv);
// We get the kmer and minimizer sizes.
size_t kmerSize = options->getInt(STR_KMER_SIZE);
size_t mmerSize = options->getInt(STR_MINIMIZER_SIZE);
// We define a try/catch block in case some method fails (bad filename for instance)
u_int64_t nbKmers = 0;
bool display = options->get(STR_VERBOSE) != 0;
// We declare a Bank instance defined by a list of filenames
IBank* bank = Bank::open (options->getStr(STR_URI_INPUT));
LOCAL (bank);
// We declare a kmer model and a minimizer model
Model model (kmerSize, mmerSize);
// We get a reference on the minimizer model, which will be useful for dumping
const ModelMinimizer::Model& modelMinimizer = model.getMmersModel();
Kmer<span>::Type checksum;
size_t nbChanged = 0;
size_t nbInvalid = 0;
// We define an iterator that encapsulates the sequences iterator with progress feedback
ProgressIterator<Sequence> iter (*bank, "iterate bank");
// We loop over sequences.
for (iter.first(); !iter.isDone(); iter.next())
{
// Shortcut
Sequence& seq = iter.item();
//! [snippet1_iterate]
// We iterate the kmers (and minimizers) of the current sequence.
model.iterate (seq.getData(), [&] (const Model::Kmer& kmer, size_t idx)
{
nbKmers ++;
if (kmer.hasChanged() == true) { nbChanged++; }
if (kmer.isValid() == false) { nbInvalid++; }
checksum += kmer.minimizer().value();
});
//! [snippet1_iterate]
}
cout << "nbKmers : " << nbKmers << endl;
cout << "nbInvalid : " << nbInvalid << endl;
cout << "nbChanged : " << nbChanged << endl;
cout << "ratio : " << (nbChanged > 0 ? (double)nbKmers / (double)nbChanged : 0) << endl;
cout << "checksum : " << checksum << endl;
}
catch (OptionFailure& e)
{
return e.displayErrors (std::cout);
}
catch (Exception& e)
{
std::cerr << "EXCEPTION: " << e.getMessage() << std::endl;
}
return EXIT_SUCCESS;
}
