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; }