//********************************************************************************************************************** SRACommand::SRACommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { //valid paramters for this command vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; map<string,string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } vector<string> tempOutNames; outputTypes["xml"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("sff"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["sff"] = inputDir + it->second; } } it = parameters.find("fastq"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["fastq"] = inputDir + it->second; } } it = parameters.find("file"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["file"] = inputDir + it->second; } } it = parameters.find("group"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["group"] = inputDir + it->second; } } it = parameters.find("oligos"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["oligos"] = inputDir + it->second; } } } //check for parameters fastqfile = validParameter.validFile(parameters, "fastq", true); if (fastqfile == "not open") { fastqfile = ""; abort = true; } else if (fastqfile == "not found") { fastqfile = ""; } sfffile = validParameter.validFile(parameters, "sff", true); if (sfffile == "not open") { sfffile = ""; abort = true; } else if (sfffile == "not found") { sfffile = ""; } file = validParameter.validFile(parameters, "file", true); if (file == "not open") { file = ""; abort = true; } else if (file == "not found") { file = ""; } groupfile = validParameter.validFile(parameters, "group", true); if (groupfile == "not open") { groupfile = ""; abort = true; } else if (groupfile == "not found") { groupfile = ""; } else { m->setGroupFile(groupfile); } oligosfile = validParameter.validFile(parameters, "oligos", true); if (oligosfile == "not found") { oligosfile = ""; } else if(oligosfile == "not open") { abort = true; } else { m->setOligosFile(oligosfile); } file = validParameter.validFile(parameters, "file", true); if (file == "not open") { file = ""; abort = true; } else if (file == "not found") { file = ""; } if ((fastqfile == "") && (sfffile == "") && (sfffile == "")) { m->mothurOut("[ERROR]: You must provide a file, sff file or fastq file before you can use the sra command."); m->mothurOutEndLine(); abort = true; } if ((groupfile != "") && (oligosfile != "")) { m->mothurOut("[ERROR]: You may not use a group file and an oligos file, only one."); m->mothurOutEndLine(); abort = true; } if ((fastqfile != "") || (sfffile != "")) { if ((groupfile == "") && (oligosfile == "")) { oligosfile = m->getOligosFile(); if (oligosfile != "") { m->mothurOut("Using " + oligosfile + " as input file for the oligos parameter."); m->mothurOutEndLine(); } else { groupfile = m->getGroupFile(); if (groupfile != "") { m->mothurOut("Using " + groupfile + " as input file for the group parameter."); m->mothurOutEndLine(); } else { m->mothurOut("[ERROR]: You must provide groupfile or oligos file if splitting a fastq or sff file."); m->mothurOutEndLine(); abort = true; } } } } //use only one Mutliple type platform = validParameter.validFile(parameters, "platform", false); if (platform == "not found") { platform = "454"; } if ((platform == "454") || (platform == "????") || (platform == "????") || (platform == "????")) { } else { m->mothurOut("Not a valid platform option. Valid platform options are 454, ...."); m->mothurOutEndLine(); abort = true; } string temp = validParameter.validFile(parameters, "bdiffs", false); if (temp == "not found"){ temp = "0"; } m->mothurConvert(temp, bdiffs); temp = validParameter.validFile(parameters, "pdiffs", false); if (temp == "not found"){ temp = "0"; } m->mothurConvert(temp, pdiffs); temp = validParameter.validFile(parameters, "ldiffs", false); if (temp == "not found") { temp = "0"; } m->mothurConvert(temp, ldiffs); temp = validParameter.validFile(parameters, "sdiffs", false); if (temp == "not found") { temp = "0"; } m->mothurConvert(temp, sdiffs); temp = validParameter.validFile(parameters, "tdiffs", false); if (temp == "not found") { int tempTotal = pdiffs + bdiffs + ldiffs + sdiffs; temp = toString(tempTotal); } m->mothurConvert(temp, tdiffs); if(tdiffs == 0){ tdiffs = bdiffs + pdiffs + ldiffs + sdiffs; } } } catch(exception& e) { m->errorOut(e, "SRACommand", "SRACommand"); exit(1); } }
status_t BnMediaPlayer::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case DISCONNECT: { CHECK_INTERFACE(IMediaPlayer, data, reply); disconnect(); return NO_ERROR; } break; case SET_VIDEO_SURFACE: { CHECK_INTERFACE(IMediaPlayer, data, reply); sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder()); reply->writeInt32(setVideoSurface(surface)); return NO_ERROR; } break; case PREPARE_ASYNC: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(prepareAsync()); return NO_ERROR; } break; case START: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(start()); return NO_ERROR; } break; case STOP: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(stop()); return NO_ERROR; } break; case IS_PLAYING: { CHECK_INTERFACE(IMediaPlayer, data, reply); bool state; status_t ret = isPlaying(&state); reply->writeInt32(state); reply->writeInt32(ret); return NO_ERROR; } break; case PAUSE: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(pause()); return NO_ERROR; } break; case SEEK_TO: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(seekTo(data.readInt32())); return NO_ERROR; } break; case GET_CURRENT_POSITION: { CHECK_INTERFACE(IMediaPlayer, data, reply); int msec; status_t ret = getCurrentPosition(&msec); reply->writeInt32(msec); reply->writeInt32(ret); return NO_ERROR; } break; case GET_DURATION: { CHECK_INTERFACE(IMediaPlayer, data, reply); int msec; status_t ret = getDuration(&msec); reply->writeInt32(msec); reply->writeInt32(ret); return NO_ERROR; } break; case RESET: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(reset()); return NO_ERROR; } break; case SET_AUDIO_STREAM_TYPE: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setAudioStreamType(data.readInt32())); return NO_ERROR; } break; case SET_LOOPING: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setLooping(data.readInt32())); return NO_ERROR; } break; case SET_VOLUME: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setVolume(data.readFloat(), data.readFloat())); return NO_ERROR; } break; case INVOKE: { CHECK_INTERFACE(IMediaPlayer, data, reply); invoke(data, reply); return NO_ERROR; } break; case SET_METADATA_FILTER: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setMetadataFilter(data)); return NO_ERROR; } break; case SUSPEND: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(suspend()); return NO_ERROR; } break; case RESUME: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(resume()); return NO_ERROR; } break; case GET_METADATA: { CHECK_INTERFACE(IMediaPlayer, data, reply); const status_t retcode = getMetadata(data.readInt32(), data.readInt32(), reply); reply->setDataPosition(0); reply->writeInt32(retcode); reply->setDataPosition(0); return NO_ERROR; } break; case SET_AUX_EFFECT_SEND_LEVEL: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setAuxEffectSendLevel(data.readFloat())); return NO_ERROR; } break; case ATTACH_AUX_EFFECT: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(attachAuxEffect(data.readInt32())); return NO_ERROR; }break; case SET_PARAMETERS: { CHECK_INTERFACE(IMediaPlayer, data, reply); reply->writeInt32(setParameters(data.readString8())); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
PCOACommand::PCOACommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string, string> parameters = parser. getParameters(); ValidParameters validParameter; map<string, string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; } } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.valid(parameters, "inputdir"); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("phylip"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["phylip"] = inputDir + it->second; } } } //initialize outputTypes vector<string> tempOutNames; outputTypes["pcoa"] = tempOutNames; outputTypes["loadings"] = tempOutNames; //required parameters phylipfile = validParameter.validFile(parameters, "phylip"); if (phylipfile == "not open") { abort = true; } else if (phylipfile == "not found") { //if there is a current phylip file, use it phylipfile = current->getPhylipFile(); if (phylipfile != "") { m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current phylip file and the phylip parameter is required."); m->mothurOutEndLine(); abort = true; } }else { current->setPhylipFile(phylipfile); } filename = phylipfile; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; outputDir += util.hasPath(phylipfile); //if user entered a file with a path then preserve it } string temp = validParameter.valid(parameters, "metric"); if (temp == "not found"){ temp = "T"; } metric = util.isTrue(temp); } } catch(exception& e) { m->errorOut(e, "PCOACommand", "PCOACommand"); exit(1); } }
//********************************************************************************************************************** AlignCommand::AlignCommand(string option) { try { abort = false; calledHelp = false; ReferenceDB* rdb = ReferenceDB::getInstance(); //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true;} else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string, string> parameters = parser.getParameters(); ValidParameters validParameter("align.seqs"); map<string, string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["fasta"] = tempOutNames; outputTypes["alignreport"] = tempOutNames; outputTypes["accnos"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("reference"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["reference"] = inputDir + it->second; } } } candidateFileName = validParameter.validFile(parameters, "fasta", false); if (candidateFileName == "not found") { //if there is a current fasta file, use it string filename = m->getFastaFile(); if (filename != "") { candidateFileNames.push_back(filename); m->mothurOut("Using " + filename + " as input file for the fasta parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current fastafile and the candidate parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->splitAtDash(candidateFileName, candidateFileNames); //go through files and make sure they are good, if not, then disregard them for (int i = 0; i < candidateFileNames.size(); i++) { //candidateFileNames[i] = m->getFullPathName(candidateFileNames[i]); bool ignore = false; if (candidateFileNames[i] == "current") { candidateFileNames[i] = m->getFastaFile(); if (candidateFileNames[i] != "") { m->mothurOut("Using " + candidateFileNames[i] + " as input file for the fasta parameter where you had given current."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current fastafile, ignoring current."); m->mothurOutEndLine(); ignore=true; //erase from file list candidateFileNames.erase(candidateFileNames.begin()+i); i--; } } if (!ignore) { if (inputDir != "") { string path = m->hasPath(candidateFileNames[i]); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { candidateFileNames[i] = inputDir + candidateFileNames[i]; } } int ableToOpen; ifstream in; ableToOpen = m->openInputFile(candidateFileNames[i], in, "noerror"); in.close(); //if you can't open it, try default location if (ableToOpen == 1) { if (m->getDefaultPath() != "") { //default path is set string tryPath = m->getDefaultPath() + m->getSimpleName(candidateFileNames[i]); m->mothurOut("Unable to open " + candidateFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); ifstream in2; ableToOpen = m->openInputFile(tryPath, in2, "noerror"); in2.close(); candidateFileNames[i] = tryPath; } } //if you can't open it, try output location if (ableToOpen == 1) { if (m->getOutputDir() != "") { //default path is set string tryPath = m->getOutputDir() + m->getSimpleName(candidateFileNames[i]); m->mothurOut("Unable to open " + candidateFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); ifstream in2; ableToOpen = m->openInputFile(tryPath, in2, "noerror"); in2.close(); candidateFileNames[i] = tryPath; } } if (ableToOpen == 1) { m->mothurOut("Unable to open " + candidateFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); //erase from file list candidateFileNames.erase(candidateFileNames.begin()+i); i--; }else { m->setFastaFile(candidateFileNames[i]); } } } //make sure there is at least one valid file left if (candidateFileNames.size() == 0) { m->mothurOut("no valid files."); m->mothurOutEndLine(); abort = true; } } //check for optional parameter and set defaults // ...at some point should added some additional type checking... string temp; temp = validParameter.validFile(parameters, "ksize", false); if (temp == "not found"){ temp = "8"; } m->mothurConvert(temp, kmerSize); temp = validParameter.validFile(parameters, "match", false); if (temp == "not found"){ temp = "1.0"; } m->mothurConvert(temp, match); temp = validParameter.validFile(parameters, "mismatch", false); if (temp == "not found"){ temp = "-1.0"; } m->mothurConvert(temp, misMatch); temp = validParameter.validFile(parameters, "gapopen", false); if (temp == "not found"){ temp = "-2.0"; } m->mothurConvert(temp, gapOpen); temp = validParameter.validFile(parameters, "gapextend", false); if (temp == "not found"){ temp = "-1.0"; } m->mothurConvert(temp, gapExtend); temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); } m->setProcessors(temp); m->mothurConvert(temp, processors); temp = validParameter.validFile(parameters, "flip", false); if (temp == "not found"){ temp = "f"; } flip = m->isTrue(temp); temp = validParameter.validFile(parameters, "save", false); if (temp == "not found"){ temp = "f"; } save = m->isTrue(temp); rdb->save = save; if (save) { //clear out old references rdb->clearMemory(); } //this has to go after save so that if the user sets save=t and provides no reference we abort templateFileName = validParameter.validFile(parameters, "reference", true); if (templateFileName == "not found") { //check for saved reference sequences if (rdb->referenceSeqs.size() != 0) { templateFileName = "saved"; }else { m->mothurOut("[ERROR]: You don't have any saved reference sequences and the reference parameter is a required for the align.seqs command."); m->mothurOutEndLine(); abort = true; } }else if (templateFileName == "not open") { abort = true; } else { if (save) { rdb->setSavedReference(templateFileName); } } temp = validParameter.validFile(parameters, "threshold", false); if (temp == "not found"){ temp = "0.50"; } m->mothurConvert(temp, threshold); search = validParameter.validFile(parameters, "search", false); if (search == "not found"){ search = "kmer"; } if ((search != "suffix") && (search != "kmer") && (search != "blast")) { m->mothurOut("invalid search option: choices are kmer, suffix or blast."); m->mothurOutEndLine(); abort=true; } align = validParameter.validFile(parameters, "align", false); if (align == "not found"){ align = "needleman"; } if ((align != "needleman") && (align != "gotoh") && (align != "blast") && (align != "noalign")) { m->mothurOut("invalid align option: choices are needleman, gotoh, blast or noalign."); m->mothurOutEndLine(); abort=true; } } } catch(exception& e) { m->errorOut(e, "AlignCommand", "AlignCommand"); exit(1); } }
ReturnType TFQMRSolMgr<ScalarType,MV,OP>::solve() { // Set the current parameters if they were not set before. // NOTE: This may occur if the user generated the solver manager with the default constructor and // then didn't set any parameters using setParameters(). if (!isSet_) { setParameters(Teuchos::parameterList(*getValidParameters())); } Teuchos::BLAS<int,ScalarType> blas; Teuchos::LAPACK<int,ScalarType> lapack; TEST_FOR_EXCEPTION(problem_ == Teuchos::null,TFQMRSolMgrLinearProblemFailure, "Belos::TFQMRSolMgr::solve(): Linear problem is not a valid object."); TEST_FOR_EXCEPTION(!problem_->isProblemSet(),TFQMRSolMgrLinearProblemFailure, "Belos::TFQMRSolMgr::solve(): Linear problem is not ready, setProblem() has not been called."); if (!isSTSet_) { TEST_FOR_EXCEPTION( checkStatusTest(),TFQMRSolMgrLinearProblemFailure, "Belos::TFQMRSolMgr::solve(): Linear problem and requested status tests are incompatible."); } // Create indices for the linear systems to be solved. int startPtr = 0; int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) ); int numCurrRHS = blockSize_; std::vector<int> currIdx, currIdx2; // The index set is generated that informs the linear problem that some linear systems are augmented. currIdx.resize( blockSize_ ); currIdx2.resize( blockSize_ ); for (int i=0; i<numCurrRHS; ++i) { currIdx[i] = startPtr+i; currIdx2[i]=i; } // Inform the linear problem of the current linear system to solve. problem_->setLSIndex( currIdx ); ////////////////////////////////////////////////////////////////////////////////////// // Parameter list Teuchos::ParameterList plist; plist.set("Block Size",blockSize_); // Reset the status test. outputTest_->reset(); // Assume convergence is achieved, then let any failed convergence set this to false. bool isConverged = true; ////////////////////////////////////////////////////////////////////////////////////// // TFQMR solver Teuchos::RCP<TFQMRIter<ScalarType,MV,OP> > tfqmr_iter = Teuchos::rcp( new TFQMRIter<ScalarType,MV,OP>(problem_,printer_,outputTest_,plist) ); // Enter solve() iterations { Teuchos::TimeMonitor slvtimer(*timerSolve_); while ( numRHS2Solve > 0 ) { // // Reset the active / converged vectors from this block std::vector<int> convRHSIdx; std::vector<int> currRHSIdx( currIdx ); currRHSIdx.resize(numCurrRHS); // Reset the number of iterations. tfqmr_iter->resetNumIters(); // Reset the number of calls that the status test output knows about. outputTest_->resetNumCalls(); // Get the current residual for this block of linear systems. Teuchos::RCP<MV> R_0 = MVT::CloneViewNonConst( *(Teuchos::rcp_const_cast<MV>(problem_->getInitPrecResVec())), currIdx ); // Set the new state and initialize the solver. TFQMRIterState<ScalarType,MV> newstate; newstate.R = R_0; tfqmr_iter->initializeTFQMR(newstate); while(1) { // tell tfqmr_iter to iterate try { tfqmr_iter->iterate(); //////////////////////////////////////////////////////////////////////////////////// // // check convergence first // //////////////////////////////////////////////////////////////////////////////////// if ( convTest_->getStatus() == Passed ) { // We have convergence of the linear system. break; // break from while(1){tfqmr_iter->iterate()} } //////////////////////////////////////////////////////////////////////////////////// // // check for maximum iterations // //////////////////////////////////////////////////////////////////////////////////// else if ( maxIterTest_->getStatus() == Passed ) { // we don't have convergence isConverged = false; break; // break from while(1){tfqmr_iter->iterate()} } //////////////////////////////////////////////////////////////////////////////////// // // we returned from iterate(), but none of our status tests Passed. // something is wrong, and it is probably our fault. // //////////////////////////////////////////////////////////////////////////////////// else { TEST_FOR_EXCEPTION(true,std::logic_error, "Belos::TFQMRSolMgr::solve(): Invalid return from TFQMRIter::iterate()."); } } catch (const std::exception &e) { printer_->stream(Errors) << "Error! Caught std::exception in TFQMRIter::iterate() at iteration " << tfqmr_iter->getNumIters() << std::endl << e.what() << std::endl; throw; } } // Inform the linear problem that we are finished with this block linear system. problem_->setCurrLS(); // Update indices for the linear systems to be solved. startPtr += numCurrRHS; numRHS2Solve -= numCurrRHS; if ( numRHS2Solve > 0 ) { numCurrRHS = blockSize_; currIdx.resize( blockSize_ ); currIdx2.resize( blockSize_ ); for (int i=0; i<numCurrRHS; ++i) { currIdx[i] = startPtr+i; currIdx2[i] = i; } // Set the next indices. problem_->setLSIndex( currIdx ); // Set the new blocksize for the solver. tfqmr_iter->setBlockSize( blockSize_ ); } else { currIdx.resize( numRHS2Solve ); } }// while ( numRHS2Solve > 0 ) } // print final summary sTest_->print( printer_->stream(FinalSummary) ); // print timing information Teuchos::TimeMonitor::summarize( printer_->stream(TimingDetails) ); // get iteration information for this solve numIters_ = maxIterTest_->getNumIters(); if (!isConverged) { return Unconverged; // return from TFQMRSolMgr::solve() } return Converged; // return from TFQMRSolMgr::solve() }
QuantileQuadrangle(Real prob, Real lam, Real eps, Teuchos::RCP<PlusFunction<Real> > &pf ) : ExpectationQuad<Real>(), prob_(prob), lam_(lam), eps_(eps), pf_(pf) { checkInputs(); setParameters(); }
void ParameterXML::slotSetParameters() { setParameters(); }
void BackgroundFilterParametersControlWidget::loadParamWidget(WidgetLoader &loader) { std::unique_ptr<BackgroundFilterParameters> params(createParameters()); loader.loadParameters(*params, rootPath); setParameters(*params); }
void BackgroundFilterParametersControlWidget::setParametersVirtual(void *input) { // Modify widget parameters from outside BackgroundFilterParameters *inputCasted = static_cast<BackgroundFilterParameters *>(input); setParameters(*inputCasted); }
//********************************************************************************************************************** AlignCommand::AlignCommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true;} else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string, string> parameters = parser.getParameters(); ValidParameters validParameter("align.seqs"); map<string, string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["fasta"] = tempOutNames; outputTypes["alignreport"] = tempOutNames; outputTypes["accnos"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.valid(parameters, "inputdir"); if (inputDir == "not found"){ inputDir = ""; } else { string path; //user has given a template file it = parameters.find("reference"); if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["reference"] = inputDir + it->second; } } it = parameters.find("fasta"); if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["fasta"] = inputDir + it->second; } } } templateFileName = validParameter.validFile(parameters, "reference"); if (templateFileName == "not found") { m->mothurOut("[ERROR]: The reference parameter is a required for the align.seqs command, aborting.\n"); abort = true; }else if (templateFileName == "not open") { abort = true; } fastafile = validParameter.validFile(parameters, "fasta"); if (fastafile == "not found") { fastafile = current->getFastaFile(); if (fastafile != "") { m->mothurOut("Using " + fastafile + " as input file for the fasta parameter.\n"); } else { m->mothurOut("[ERROR]: You have no current fasta file and the fasta parameter is required.\n"); abort = true; } } else if (fastafile == "not open") { abort = true; } else { current->setFastaFile(fastafile); } //check for optional parameter and set defaults // ...at some point should added some additional type checking... string temp; temp = validParameter.valid(parameters, "ksize"); if (temp == "not found"){ temp = "8"; } util.mothurConvert(temp, kmerSize); temp = validParameter.valid(parameters, "match"); if (temp == "not found"){ temp = "1.0"; } util.mothurConvert(temp, match); temp = validParameter.valid(parameters, "mismatch"); if (temp == "not found"){ temp = "-1.0"; } util.mothurConvert(temp, misMatch); temp = validParameter.valid(parameters, "gapopen"); if (temp == "not found"){ temp = "-5.0"; } util.mothurConvert(temp, gapOpen); temp = validParameter.valid(parameters, "gapextend"); if (temp == "not found"){ temp = "-2.0"; } util.mothurConvert(temp, gapExtend); temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); } processors = current->setProcessors(temp); temp = validParameter.valid(parameters, "flip"); if (temp == "not found"){ temp = "t"; } flip = util.isTrue(temp); temp = validParameter.valid(parameters, "threshold"); if (temp == "not found"){ temp = "0.50"; } util.mothurConvert(temp, threshold); search = validParameter.valid(parameters, "search"); if (search == "not found"){ search = "kmer"; } if ((search != "suffix") && (search != "kmer") && (search != "blast")) { m->mothurOut("invalid search option: choices are kmer, suffix or blast."); m->mothurOutEndLine(); abort=true; } align = validParameter.valid(parameters, "align"); if (align == "not found"){ align = "needleman"; } if ((align != "needleman") && (align != "gotoh") && (align != "blast") && (align != "noalign")) { m->mothurOut("invalid align option: choices are needleman, gotoh, blast or noalign."); m->mothurOutEndLine(); abort=true; } } } catch(exception& e) { m->errorOut(e, "AlignCommand", "AlignCommand"); exit(1); } }
ROIPass::ROIPass(int xOffset, int yOffset, int width, int height) { setParameters(xOffset, yOffset, width, height); }
status_t BnMediaRecorder::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case RELEASE: { LOGV("RELEASE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(release()); return NO_ERROR; } break; case INIT: { LOGV("INIT"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(init()); return NO_ERROR; } break; case CLOSE: { LOGV("CLOSE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(close()); return NO_ERROR; } break; case RESET: { LOGV("RESET"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(reset()); return NO_ERROR; } break; case PAUSE: { LOGV("PAUSE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(pause()); return NO_ERROR; } break; case STOP: { LOGV("STOP"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(stop()); return NO_ERROR; } break; case START: { LOGV("START"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(start()); return NO_ERROR; } break; case PREPARE: { LOGV("PREPARE"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(prepare()); return NO_ERROR; } break; case GET_MAX_AMPLITUDE: { LOGV("GET_MAX_AMPLITUDE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int max = 0; status_t ret = getMaxAmplitude(&max); reply->writeInt32(max); reply->writeInt32(ret); return NO_ERROR; } break; case SET_VIDEO_SOURCE: { LOGV("SET_VIDEO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int vs = data.readInt32(); reply->writeInt32(setVideoSource(vs)); return NO_ERROR; } break; case SET_AUDIO_SOURCE: { LOGV("SET_AUDIO_SOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int as = data.readInt32(); reply->writeInt32(setAudioSource(as)); return NO_ERROR; } break; case SET_OUTPUT_FORMAT: { LOGV("SET_OUTPUT_FORMAT"); CHECK_INTERFACE(IMediaRecorder, data, reply); int of = data.readInt32(); reply->writeInt32(setOutputFormat(of)); return NO_ERROR; } break; case SET_VIDEO_ENCODER: { LOGV("SET_VIDEO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ve = data.readInt32(); reply->writeInt32(setVideoEncoder(ve)); return NO_ERROR; } break; case SET_AUDIO_ENCODER: { LOGV("SET_AUDIO_ENCODER"); CHECK_INTERFACE(IMediaRecorder, data, reply); int ae = data.readInt32(); reply->writeInt32(setAudioEncoder(ae)); return NO_ERROR; } break; case SET_OUTPUT_FILE_PATH: { LOGV("SET_OUTPUT_FILE_PATH"); CHECK_INTERFACE(IMediaRecorder, data, reply); const char* path = data.readCString(); reply->writeInt32(setOutputFile(path)); return NO_ERROR; } break; case SET_OUTPUT_FILE_FD: { LOGV("SET_OUTPUT_FILE_FD"); CHECK_INTERFACE(IMediaRecorder, data, reply); int fd = dup(data.readFileDescriptor()); int64_t offset = data.readInt64(); int64_t length = data.readInt64(); reply->writeInt32(setOutputFile(fd, offset, length)); ::close(fd); return NO_ERROR; } break; case SET_VIDEO_SIZE: { LOGV("SET_VIDEO_SIZE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int width = data.readInt32(); int height = data.readInt32(); reply->writeInt32(setVideoSize(width, height)); return NO_ERROR; } break; case SET_VIDEO_FRAMERATE: { LOGV("SET_VIDEO_FRAMERATE"); CHECK_INTERFACE(IMediaRecorder, data, reply); int frames_per_second = data.readInt32(); reply->writeInt32(setVideoFrameRate(frames_per_second)); return NO_ERROR; } break; case SET_PARAMETERS: { LOGV("SET_PARAMETER"); CHECK_INTERFACE(IMediaRecorder, data, reply); reply->writeInt32(setParameters(data.readString8())); return NO_ERROR; } break; case SET_LISTENER: { LOGV("SET_LISTENER"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<IMediaRecorderClient> listener = interface_cast<IMediaRecorderClient>(data.readStrongBinder()); reply->writeInt32(setListener(listener)); return NO_ERROR; } break; case SET_PREVIEW_SURFACE: { LOGV("SET_PREVIEW_SURFACE"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<Surface> surface = Surface::readFromParcel(data); reply->writeInt32(setPreviewSurface(surface)); return NO_ERROR; } break; case SET_CAMERA: { LOGV("SET_CAMERA"); CHECK_INTERFACE(IMediaRecorder, data, reply); sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder()); sp<ICameraRecordingProxy> proxy = interface_cast<ICameraRecordingProxy>(data.readStrongBinder()); reply->writeInt32(setCamera(camera, proxy)); return NO_ERROR; } break; case QUERY_SURFACE_MEDIASOURCE: { LOGV("QUERY_SURFACE_MEDIASOURCE"); CHECK_INTERFACE(IMediaRecorder, data, reply); // call the mediaserver side to create // a surfacemediasource sp<ISurfaceTexture> surfaceMediaSource = querySurfaceMediaSource(); // The mediaserver might have failed to create a source int returnedNull= (surfaceMediaSource == NULL) ? 1 : 0 ; reply->writeInt32(returnedNull); if (!returnedNull) { reply->writeStrongBinder(surfaceMediaSource->asBinder()); } return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
//********************************************************************************************************************** GetRelAbundCommand::GetRelAbundCommand(string option) { try { abort = false; calledHelp = false; allLines = 1; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); map<string,string>::iterator it; ValidParameters validParameter; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["relabund"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("shared"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["shared"] = inputDir + it->second; } } } //get shared file sharedfile = validParameter.validFile(parameters, "shared", true); if (sharedfile == "not open") { sharedfile = ""; abort = true; } else if (sharedfile == "not found") { //if there is a current shared file, use it sharedfile = m->getSharedFile(); if (sharedfile != "") { m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current sharedfile and the shared parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setSharedFile(sharedfile); } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = m->hasPath(sharedfile); } //check for optional parameter and set defaults // ...at some point should added some additional type checking... label = validParameter.validFile(parameters, "label", false); if (label == "not found") { label = ""; } else { if(label != "all") { m->splitAtDash(label, labels); allLines = 0; } else { allLines = 1; } } groups = validParameter.validFile(parameters, "groups", false); if (groups == "not found") { groups = ""; pickedGroups = false; } else { pickedGroups = true; m->splitAtDash(groups, Groups); m->setGroups(Groups); } scale = validParameter.validFile(parameters, "scale", false); if (scale == "not found") { scale = "totalgroup"; } if ((scale != "totalgroup") && (scale != "totalotu") && (scale != "averagegroup") && (scale != "averageotu")) { m->mothurOut(scale + " is not a valid scaling option for the get.relabund command. Choices are totalgroup, totalotu, averagegroup, averageotu."); m->mothurOutEndLine(); abort = true; } } } catch(exception& e) { m->errorOut(e, "GetRelAbundCommand", "GetRelAbundCommand"); exit(1); } }
cMaterial::cMaterial(int _id, const cParameterContainer *materialParam, bool quiet) { setParameters(_id, materialParam, quiet); }
void RecorderControlWidget::setParametersVirtual(void *input) { // Modify widget parameters from outside Recorder *inputCasted = static_cast<Recorder *>(input); setParameters(*inputCasted); }
/** * TODO: * * find the parameter values to minimize the objective function */ void SCGModelTrainer::Train(int numIterations) { double sigma0 = 1.0e-4; double beta = 1.0; double betaMin = 1.0e-15; double betaMax = 1.0e100; double kappa = 0.0; double mu = 0.0; double sigma; double theta = 0.0; double delta; // check delta and Delta double alpha, fOld, fNew, fNow; double Delta; double EPS = arma::math::eps(); vec direction, gradNew, gradOld, gPlus, xPlus, xNew; vec x = getParameters(); int numParams, numSuccess; bool success; fOld = errorFunction(x); fNow = fOld; gradNew = errorGradients(x); gradOld = gradNew; direction = -gradNew; numParams = gradNew.size(); success = true; numSuccess = 0; if(gradientCheck) { checkGradient(); } // Main loop for (int j = 1; j <= numIterations; j++ ) { if (success) { mu = dot(direction, gradNew); if ( mu >= 0.0 ) { direction = -gradNew; mu = dot(direction, gradNew); } kappa = dot(direction, direction); // eps exists in ITPP? remember to check this! if(kappa < EPS) { functionValue = fNow; setParameters(x); return; } sigma = sigma0 / sqrt(kappa); xPlus = x + (sigma * direction); gPlus = errorGradients(xPlus); theta = dot(direction, gPlus - gradNew) / sigma; } delta = theta + (beta * kappa); if ( delta <= 0.0 ) { delta = beta * kappa; beta = beta - ( theta / kappa ); //double olddelta = delta; //double oldbeta = beta; //beta = 2.0*(oldbeta - olddelta/kappa); //delta = oldbeta*kappa - olddelta; } alpha = - ( mu / delta ); xNew = x + (alpha * direction); fNew = errorFunction(xNew); Delta = 2.0 * ( fNew - fOld ) / (alpha * mu); if ( Delta >= 0.0 ) { success = true; numSuccess++; x = xNew; // RB: Do we need to set parameters here? setParameters(x); fNow = fNew; } else { success = false; fNow = fOld; } if(display) { Rprintf("Cycle %d Error %f Scale %f\n", j, fNow, beta); } if(success) { if ((max(alpha * direction) < parameterTolerance) && (abs( fNew - fOld )) < errorTolerance ) { functionValue = fNew; // setParameters(x); return; } else { fOld = fNew; gradOld = gradNew; gradNew = errorGradients(x); if(dot(gradNew, gradNew) < 1e-16) { functionValue = fNew; // setParameters(x); return; } } } if ( Delta < 0.25 ) { beta = min( 4.0 * beta, betaMax ); } if ( Delta > 0.75 ) { beta = max( 0.5 * beta, betaMin ); } if ( numSuccess == numParams ) { direction = -gradNew; numSuccess = 0; } else { if (success) { double gamma = dot(gradOld - gradNew, (gradNew / mu)); direction = (gamma * direction) - gradNew; } } } if(display) { Rprintf("Warning: Maximum number of iterations has been exceeded\n"); } functionValue = fOld; // setParameters(x); // Check last gradient (to make sure everything went fine if (gradientCheck) checkGradient(); return; }
MetaStatsCommand::MetaStatsCommand(string option) { try { abort = false; calledHelp = false; allLines = 1; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; //check to make sure all parameters are valid for command map<string,string>::iterator it; for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["metastats"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("design"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["design"] = inputDir + it->second; } } it = parameters.find("shared"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["shared"] = inputDir + it->second; } } } //check for required parameters sharedfile = validParameter.validFile(parameters, "shared", true); if (sharedfile == "not open") { abort = true; } else if (sharedfile == "not found") { //if there is a current shared file, use it sharedfile = m->getSharedFile(); if (sharedfile != "") { m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current sharedfile and the shared parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setSharedFile(sharedfile); } //check for required parameters designfile = validParameter.validFile(parameters, "design", true); if (designfile == "not open") { abort = true; } else if (designfile == "not found") { //if there is a current design file, use it designfile = m->getDesignFile(); if (designfile != "") { m->mothurOut("Using " + designfile + " as input file for the design parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current designfile and the design parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setDesignFile(designfile); } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; outputDir += m->hasPath(sharedfile); //if user entered a file with a path then preserve it } //check for optional parameter and set defaults // ...at some point should added some additional type checking... label = validParameter.validFile(parameters, "label", false); if (label == "not found") { label = ""; } else { if(label != "all") { m->splitAtDash(label, labels); allLines = 0; } else { allLines = 1; } } groups = validParameter.validFile(parameters, "groups", false); if (groups == "not found") { groups = ""; pickedGroups = false; } else { pickedGroups = true; m->splitAtDash(groups, Groups); m->setGroups(Groups); } sets = validParameter.validFile(parameters, "sets", false); if (sets == "not found") { sets = ""; } else { m->splitAtDash(sets, Sets); } string temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; } m->mothurConvert(temp, iters); temp = validParameter.validFile(parameters, "threshold", false); if (temp == "not found") { temp = "0.05"; } m->mothurConvert(temp, threshold); temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); } m->setProcessors(temp); m->mothurConvert(temp, processors); } } catch(exception& e) { m->errorOut(e, "MetaStatsCommand", "MetaStatsCommand"); exit(1); } }
//********************************************************************************************************************** KruskalWallisCommand::KruskalWallisCommand(string option) { try { abort = false; calledHelp = false; allLines = 1; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { //valid paramters for this command vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; map<string,string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; } } vector<string> tempOutNames; outputTypes["kruskall-wallis"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.valid(parameters, "inputdir"); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("design"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["desing"] = inputDir + it->second; } } it = parameters.find("shared"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["shared"] = inputDir + it->second; } } } //get shared file, it is required sharedfile = validParameter.validFile(parameters, "shared"); if (sharedfile == "not open") { sharedfile = ""; abort = true; } else if (sharedfile == "not found") { //if there is a current shared file, use it sharedfile = current->getSharedFile(); if (sharedfile != "") { m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current sharedfile and the shared parameter is required."); m->mothurOutEndLine(); abort = true; } }else { current->setSharedFile(sharedfile); } //get shared file, it is required designfile = validParameter.validFile(parameters, "design"); if (designfile == "not open") { designfile = ""; abort = true; } else if (designfile == "not found") { //if there is a current shared file, use it designfile = current->getDesignFile(); if (designfile != "") { m->mothurOut("Using " + designfile + " as input file for the design parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current design file and the design parameter is required."); m->mothurOutEndLine(); abort = true; } }else { current->setDesignFile(designfile); } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = util.hasPath(sharedfile); //if user entered a file with a path then preserve it } string label = validParameter.valid(parameters, "label"); if (label == "not found") { label = ""; } else { if(label != "all") { util.splitAtDash(label, labels); allLines = 0; } else { allLines = 1; } } mclass = validParameter.valid(parameters, "class"); if (mclass == "not found") { mclass = ""; } } } catch(exception& e) { m->errorOut(e, "KruskalWallisCommand", "KruskalWallisCommand"); exit(1); } }
Fitter1D::Fitter1D(const Fitter1D& source) : DefaultParamHandler(source) { setParameters(source.getParameters()); updateMembers_(); }
AnosimCommand::AnosimCommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; //check to make sure all parameters are valid for command map<string,string>::iterator it; for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["anosim"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("design"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["design"] = inputDir + it->second; } } it = parameters.find("phylip"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["phylip"] = inputDir + it->second; } } } phylipFileName = validParameter.validFile(parameters, "phylip", true); if (phylipFileName == "not open") { phylipFileName = ""; abort = true; } else if (phylipFileName == "not found") { //if there is a current phylip file, use it phylipFileName = m->getPhylipFile(); if (phylipFileName != "") { m->mothurOut("Using " + phylipFileName + " as input file for the phylip parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current phylip file and the phylip parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setPhylipFile(phylipFileName); } //check for required parameters designFileName = validParameter.validFile(parameters, "design", true); if (designFileName == "not open") { designFileName = ""; abort = true; } else if (designFileName == "not found") { //if there is a current design file, use it designFileName = m->getDesignFile(); if (designFileName != "") { m->mothurOut("Using " + designFileName + " as input file for the design parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current design file and the design parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setDesignFile(designFileName); } string temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; } m->mothurConvert(temp, iters); temp = validParameter.validFile(parameters, "alpha", false); if (temp == "not found") { temp = "0.05"; } m->mothurConvert(temp, experimentwiseAlpha); } } catch(exception& e) { m->errorOut(e, "AnosimCommand", "AnosimCommand"); exit(1); } }
ExtendedIsotopeModel::ExtendedIsotopeModel(const ExtendedIsotopeModel & source) : InterpolationModel(source) { setParameters(source.getParameters()); updateMembers_(); }
void CannyParametersControlWidget::setParametersVirtual(void *input) { // Modify widget parameters from outside CannyParameters *inputCasted = static_cast<CannyParameters *>(input); setParameters(*inputCasted); }
status_t BnCameraRecordingProxy::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case START_RECORDING: { ALOGV("START_RECORDING"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); unsigned int id = data.readInt32(); sp<ICameraRecordingProxyListener> listener = interface_cast<ICameraRecordingProxyListener>(data.readStrongBinder()); reply->writeInt32(startRecording(listener, id)); return NO_ERROR; } break; case STOP_RECORDING: { ALOGV("STOP_RECORDING"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); unsigned int id = data.readInt32(); stopRecording(id); return NO_ERROR; } break; case RELEASE_RECORDING_FRAME: { ALOGV("RELEASE_RECORDING_FRAME"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); int index = data.readInt32(); sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder()); releaseRecordingFrame(mem, index); return NO_ERROR; } break; case SET_PREVIEW_DISPLAY: { ALOGV("SET_PREVIEW_DISPLAY"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); int hlay = data.readInt32(); reply->writeInt32(setPreviewDisplay(hlay)); return NO_ERROR; } break; case SEND_COMMAND: { ALOGV("SEND_COMMAND"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); int32_t cmd = data.readInt32(); int32_t arg1 = data.readInt32(); int32_t arg2 = data.readInt32(); reply->writeInt32(sendCommand(cmd, arg1, arg2)); return NO_ERROR; } break; case LOCK: { ALOGV("LOCK"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); reply->writeInt32(lock()); return NO_ERROR; } break; case UNLOCK: { ALOGV("UNLOCK"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); reply->writeInt32(unlock()); return NO_ERROR; } break; case GET_PARAMETERS: { ALOGV("GET_PARAMETERS"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); reply->writeString8(getParameters()); return NO_ERROR; } break; case SET_PARAMETERS: { ALOGV("SET_PARAMETERS"); CHECK_INTERFACE(ICameraRecordingProxy, data, reply); String8 params(data.readString8()); reply->writeInt32(setParameters(params)); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
//********************************************************************************************************************** GetSeqsCommand::GetSeqsCommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; map<string,string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["fasta"] = tempOutNames; outputTypes["taxonomy"] = tempOutNames; outputTypes["name"] = tempOutNames; outputTypes["group"] = tempOutNames; outputTypes["alignreport"] = tempOutNames; outputTypes["list"] = tempOutNames; outputTypes["qfile"] = tempOutNames; outputTypes["accnosreport"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("alignreport"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["alignreport"] = inputDir + it->second; } } it = parameters.find("fasta"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["fasta"] = inputDir + it->second; } } it = parameters.find("accnos"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["accnos"] = inputDir + it->second; } } it = parameters.find("accnos2"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["accnos2"] = inputDir + it->second; } } it = parameters.find("list"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["list"] = inputDir + it->second; } } it = parameters.find("name"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["name"] = inputDir + it->second; } } it = parameters.find("group"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["group"] = inputDir + it->second; } } it = parameters.find("taxonomy"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["taxonomy"] = inputDir + it->second; } } it = parameters.find("qfile"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["qfile"] = inputDir + it->second; } } } //check for required parameters accnosfile = validParameter.validFile(parameters, "accnos", true); if (accnosfile == "not open") { abort = true; } else if (accnosfile == "not found") { accnosfile = m->getAccnosFile(); if (accnosfile != "") { m->mothurOut("Using " + accnosfile + " as input file for the accnos parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no valid accnos file and accnos is required."); m->mothurOutEndLine(); abort = true; } }else { m->setAccnosFile(accnosfile); } if (accnosfile2 == "not found") { accnosfile2 = ""; } fastafile = validParameter.validFile(parameters, "fasta", true); if (fastafile == "not open") { fastafile = ""; abort = true; } else if (fastafile == "not found") { fastafile = ""; } else { m->setFastaFile(fastafile); } namefile = validParameter.validFile(parameters, "name", true); if (namefile == "not open") { namefile = ""; abort = true; } else if (namefile == "not found") { namefile = ""; } else { m->setNameFile(namefile); } groupfile = validParameter.validFile(parameters, "group", true); if (groupfile == "not open") { abort = true; } else if (groupfile == "not found") { groupfile = ""; } else { m->setGroupFile(groupfile); } alignfile = validParameter.validFile(parameters, "alignreport", true); if (alignfile == "not open") { abort = true; } else if (alignfile == "not found") { alignfile = ""; } listfile = validParameter.validFile(parameters, "list", true); if (listfile == "not open") { abort = true; } else if (listfile == "not found") { listfile = ""; } else { m->setListFile(listfile); } taxfile = validParameter.validFile(parameters, "taxonomy", true); if (taxfile == "not open") { taxfile = ""; abort = true; } else if (taxfile == "not found") { taxfile = ""; } else { m->setTaxonomyFile(taxfile); } qualfile = validParameter.validFile(parameters, "qfile", true); if (qualfile == "not open") { abort = true; } else if (qualfile == "not found") { qualfile = ""; } else { m->setQualFile(qualfile); } accnosfile2 = validParameter.validFile(parameters, "accnos2", true); if (accnosfile2 == "not open") { abort = true; } else if (accnosfile2 == "not found") { accnosfile2 = ""; } string usedDups = "true"; string temp = validParameter.validFile(parameters, "dups", false); if (temp == "not found") { temp = "true"; usedDups = ""; } dups = m->isTrue(temp); if ((fastafile == "") && (namefile == "") && (groupfile == "") && (alignfile == "") && (listfile == "") && (taxfile == "") && (qualfile == "") && (accnosfile2 == "")) { m->mothurOut("You must provide one of the following: fasta, name, group, alignreport, taxonomy, quality or listfile."); m->mothurOutEndLine(); abort = true; } if ((namefile == "") && ((fastafile != "") || (taxfile != ""))){ vector<string> files; files.push_back(fastafile); files.push_back(taxfile); parser.getNameFile(files); } } } catch(exception& e) { m->errorOut(e, "GetSeqsCommand", "GetSeqsCommand"); exit(1); } }
//********************************************************************************************************************** //This function checks to make sure the cluster command has no errors and then clusters based on the method chosen. ClusterCommand::ClusterCommand(string option) { try{ abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); map<string,string>::iterator it; ValidParameters validParameter; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["list"] = tempOutNames; outputTypes["rabund"] = tempOutNames; outputTypes["sabund"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("phylip"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["phylip"] = inputDir + it->second; } } it = parameters.find("column"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["column"] = inputDir + it->second; } } it = parameters.find("name"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["name"] = inputDir + it->second; } } it = parameters.find("count"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["count"] = inputDir + it->second; } } } //check for required parameters phylipfile = validParameter.validFile(parameters, "phylip", true); if (phylipfile == "not open") { phylipfile = ""; abort = true; } else if (phylipfile == "not found") { phylipfile = ""; } else { distfile = phylipfile; format = "phylip"; m->setPhylipFile(phylipfile); } columnfile = validParameter.validFile(parameters, "column", true); if (columnfile == "not open") { columnfile = ""; abort = true; } else if (columnfile == "not found") { columnfile = ""; } else { distfile = columnfile; format = "column"; m->setColumnFile(columnfile); } namefile = validParameter.validFile(parameters, "name", true); if (namefile == "not open") { abort = true; } else if (namefile == "not found") { namefile = ""; } else { m->setNameFile(namefile); } countfile = validParameter.validFile(parameters, "count", true); if (countfile == "not open") { abort = true; countfile = ""; } else if (countfile == "not found") { countfile = ""; } else { m->setCountTableFile(countfile); } if ((phylipfile == "") && (columnfile == "")) { //is there are current file available for either of these? //give priority to column, then phylip columnfile = m->getColumnFile(); if (columnfile != "") { distfile = columnfile; format = "column"; m->mothurOut("Using " + columnfile + " as input file for the column parameter."); m->mothurOutEndLine(); } else { phylipfile = m->getPhylipFile(); if (phylipfile != "") { distfile = phylipfile; format = "phylip"; m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); } else { m->mothurOut("No valid current files. You must provide a phylip or column file before you can use the cluster command."); m->mothurOutEndLine(); abort = true; } } } else if ((phylipfile != "") && (columnfile != "")) { m->mothurOut("When executing a cluster command you must enter ONLY ONE of the following: phylip or column."); m->mothurOutEndLine(); abort = true; } if (columnfile != "") { if ((namefile == "") && (countfile == "")){ namefile = m->getNameFile(); if (namefile != "") { m->mothurOut("Using " + namefile + " as input file for the name parameter."); m->mothurOutEndLine(); } else { countfile = m->getCountTableFile(); if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You need to provide a namefile or countfile if you are going to use the column format."); m->mothurOutEndLine(); abort = true; } } } } if ((countfile != "") && (namefile != "")) { m->mothurOut("When executing a cluster command you must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; } //check for optional parameter and set defaults // ...at some point should added some additional type checking... //get user cutoff and precision or use defaults string temp; temp = validParameter.validFile(parameters, "precision", false); if (temp == "not found") { temp = "100"; } //saves precision legnth for formatting below length = temp.length(); m->mothurConvert(temp, precision); temp = validParameter.validFile(parameters, "hard", false); if (temp == "not found") { temp = "T"; } hard = m->isTrue(temp); temp = validParameter.validFile(parameters, "sim", false); if (temp == "not found") { temp = "F"; } sim = m->isTrue(temp); //bool cutoffSet = false; temp = validParameter.validFile(parameters, "cutoff", false); if (temp == "not found") { temp = "10"; } //else { cutoffSet = true; } m->mothurConvert(temp, cutoff); cutoff += (5 / (precision * 10.0)); //temp = validParameter.validFile(parameters, "adjust", false); if (temp == "not found") { temp = "F"; } //if (m->isNumeric1(temp)) { m->mothurConvert(temp, adjust); } //else if (m->isTrue(temp)) { adjust = 1.0; } //else { adjust = -1.0; } adjust=-1.0; method = validParameter.validFile(parameters, "method", false); if (method == "not found") { method = "average"; } if ((method == "furthest") || (method == "nearest") || (method == "average") || (method == "weighted")) { } else { m->mothurOut("Not a valid clustering method. Valid clustering algorithms are furthest, nearest, average, and weighted."); m->mothurOutEndLine(); abort = true; } showabund = validParameter.validFile(parameters, "showabund", false); if (showabund == "not found") { showabund = "T"; } timing = validParameter.validFile(parameters, "timing", false); if (timing == "not found") { timing = "F"; } } } catch(exception& e) { m->errorOut(e, "ClusterCommand", "ClusterCommand"); exit(1); } }
//********************************************************************************************************************** ClassifySeqsCommand::ClassifySeqsCommand(string option) { try { abort = false; calledHelp = false; hasName = false; hasCount=false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string, string> parameters = parser.getParameters(); ValidParameters validParameter("classify.seqs"); map<string, string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["taxonomy"] = tempOutNames; outputTypes["taxsummary"] = tempOutNames; outputTypes["matchdist"] = tempOutNames; outputTypes["accnos"] = tempOutNames; //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; } //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.valid(parameters, "inputdir"); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("reference"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["reference"] = inputDir + it->second; } } it = parameters.find("taxonomy"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["taxonomy"] = inputDir + it->second; } } it = parameters.find("count"); //user has given a template file if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["count"] = inputDir + it->second; } } it = parameters.find("fasta"); if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["fasta"] = inputDir + it->second; } } it = parameters.find("name"); if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["name"] = inputDir + it->second; } } it = parameters.find("group"); if(it != parameters.end()){ path = util.hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["group"] = inputDir + it->second; } } } fastafile = validParameter.validFile(parameters, "fasta"); if (fastafile == "not found") { fastafile = current->getFastaFile(); if (fastafile != "") { m->mothurOut("Using " + fastafile + " as input file for the fasta parameter.\n"); } else { m->mothurOut("[ERROR]: You have no current fasta file and the fasta parameter is required.\n"); abort = true; } } else if (fastafile == "not open") { abort = true; } else { current->setFastaFile(fastafile); } namefile = validParameter.validFile(parameters, "name"); if (namefile == "not open") { namefile = ""; abort = true; } else if (namefile == "not found") { namefile = ""; } else { current->setNameFile(namefile); } if (namefile != "") { hasName = true; } //check for required parameters countfile = validParameter.validFile(parameters, "count"); if (countfile == "not open") { countfile = ""; abort = true; } else if (countfile == "not found") { countfile = ""; } else { current->setCountFile(countfile); } if (countfile != "") { hasCount = true; } //make sure there is at least one valid file left if (hasName && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or name.\n"); abort = true; } bool hasGroup = false; groupfile = validParameter.validFile(parameters, "group"); if (groupfile == "not open") { abort = true; } else if (groupfile == "not found") { groupfile = ""; } else { current->setGroupFile(groupfile); hasGroup = true; } if (hasGroup && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or group.\n"); abort = true; } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; } //check for optional parameter and set defaults // ...at some point should added some additional type checking... string temp; temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); } processors = current->setProcessors(temp); //this has to go after save so that if the user sets save=t and provides no reference we abort templateFileName = validParameter.validFile(parameters, "reference"); if (templateFileName == "not found") { m->mothurOut("[ERROR]: The reference parameter is a required for the classify.seqs command.\n"); abort = true; }else if (templateFileName == "not open") { abort = true; } //this has to go after save so that if the user sets save=t and provides no reference we abort taxonomyFileName = validParameter.validFile(parameters, "taxonomy"); if (taxonomyFileName == "not found") { m->mothurOut("[ERROR]: The taxonomy parameter is a required for the classify.seqs command.\n"); abort = true; }else if (taxonomyFileName == "not open") { abort = true; } search = validParameter.valid(parameters, "search"); if (search == "not found"){ search = "kmer"; } method = validParameter.valid(parameters, "method"); if (method == "not found"){ method = "wang"; } temp = validParameter.valid(parameters, "ksize"); if (temp == "not found"){ temp = "8"; if (method == "zap") { temp = "7"; } } util.mothurConvert(temp, kmerSize); temp = validParameter.valid(parameters, "match"); if (temp == "not found"){ temp = "1.0"; } util.mothurConvert(temp, match); temp = validParameter.valid(parameters, "printlevel"); if (temp == "not found"){ temp = "-1"; } util.mothurConvert(temp, printlevel); temp = validParameter.valid(parameters, "mismatch"); if (temp == "not found"){ temp = "-1.0"; } util.mothurConvert(temp, misMatch); temp = validParameter.valid(parameters, "gapopen"); if (temp == "not found"){ temp = "-2.0"; } util.mothurConvert(temp, gapOpen); temp = validParameter.valid(parameters, "gapextend"); if (temp == "not found"){ temp = "-1.0"; } util.mothurConvert(temp, gapExtend); temp = validParameter.valid(parameters, "numwanted"); if (temp == "not found"){ temp = "10"; } util.mothurConvert(temp, numWanted); temp = validParameter.valid(parameters, "cutoff"); if (temp == "not found"){ temp = "80"; } util.mothurConvert(temp, cutoff); temp = validParameter.valid(parameters, "probs"); if (temp == "not found"){ temp = "true"; } probs = util.isTrue(temp); temp = validParameter.valid(parameters, "relabund"); if (temp == "not found"){ temp = "false"; } relabund = util.isTrue(temp); temp = validParameter.valid(parameters, "shortcuts"); if (temp == "not found"){ temp = "true"; } writeShortcuts = util.isTrue(temp); flip = true; temp = validParameter.valid(parameters, "iters"); if (temp == "not found") { temp = "100"; } util.mothurConvert(temp, iters); output = validParameter.valid(parameters, "output"); if(output == "not found"){ output = "detail"; } if ((output != "simple") && (output != "detail")) { m->mothurOut(output + " is not a valid output form. Options are simple and detail. I will use detail."); m->mothurOutEndLine(); output = "detail"; } if ((method == "wang") && (search != "kmer")) { m->mothurOut("The wang method requires the kmer search. " + search + " will be disregarded, and kmer will be used." ); m->mothurOutEndLine(); search = "kmer"; } if ((method == "zap") && ((search != "kmer") && (search != "align"))) { m->mothurOut("The zap method requires the kmer or align search. " + search + " will be disregarded, and kmer will be used." ); m->mothurOutEndLine(); search = "kmer"; } if (!abort) { if (!hasCount) { if (namefile == ""){ if (fastafile != "") { vector<string> files; files.push_back(fastafile); if (!current->getMothurCalling()) { parser.getNameFile(files); } } } } } } } catch(exception& e) { m->errorOut(e, "ClassifySeqsCommand", "ClassifySeqsCommand"); exit(1); } }
DeconvoluteCommand::DeconvoluteCommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter; map<string, string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["fasta"] = tempOutNames; outputTypes["name"] = tempOutNames; outputTypes["count"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("fasta"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["fasta"] = inputDir + it->second; } } it = parameters.find("name"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["name"] = inputDir + it->second; } } it = parameters.find("count"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["count"] = inputDir + it->second; } } } //check for required parameters inFastaName = validParameter.validFile(parameters, "fasta", true); if (inFastaName == "not open") { abort = true; } else if (inFastaName == "not found") { inFastaName = m->getFastaFile(); if (inFastaName != "") { m->mothurOut("Using " + inFastaName + " as input file for the fasta parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current fastafile and the fasta parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setFastaFile(inFastaName); } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; outputDir += m->hasPath(inFastaName); //if user entered a file with a path then preserve it } oldNameMapFName = validParameter.validFile(parameters, "name", true); if (oldNameMapFName == "not open") { oldNameMapFName = ""; abort = true; } else if (oldNameMapFName == "not found"){ oldNameMapFName = ""; } else { m->setNameFile(oldNameMapFName); } countfile = validParameter.validFile(parameters, "count", true); if (countfile == "not open") { abort = true; countfile = ""; } else if (countfile == "not found") { countfile = ""; } else { m->setCountTableFile(countfile); } if ((countfile != "") && (oldNameMapFName != "")) { m->mothurOut("When executing a unique.seqs command you must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; } if (countfile == "") { if (oldNameMapFName == "") { vector<string> files; files.push_back(inFastaName); parser.getNameFile(files); } } } } catch(exception& e) { m->errorOut(e, "DeconvoluteCommand", "DeconvoluteCommand"); exit(1); } }
ParsimonyCommand::ParsimonyCommand(string option) { try { abort = false; calledHelp = false; Groups.clear(); //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string, string> parameters = parser.getParameters(); map<string,string>::iterator it; ValidParameters validParameter; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["parsimony"] = tempOutNames; outputTypes["psummary"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("tree"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["tree"] = inputDir + it->second; } } it = parameters.find("group"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["group"] = inputDir + it->second; } } it = parameters.find("name"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["name"] = inputDir + it->second; } } it = parameters.find("count"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["count"] = inputDir + it->second; } } } outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } randomtree = validParameter.validFile(parameters, "random", false); if (randomtree == "not found") { randomtree = ""; } //are you trying to use parsimony without reading a tree or saying you want random distribution if (randomtree == "") { //check for required parameters treefile = validParameter.validFile(parameters, "tree", true); if (treefile == "not open") { treefile = ""; abort = true; } else if (treefile == "not found") { //if there is a current design file, use it treefile = m->getTreeFile(); if (treefile != "") { m->mothurOut("Using " + treefile + " as input file for the tree parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current tree file and the tree parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->setTreeFile(treefile); } //check for required parameters groupfile = validParameter.validFile(parameters, "group", true); if (groupfile == "not open") { abort = true; } else if (groupfile == "not found") { groupfile = ""; } else { m->setGroupFile(groupfile); } namefile = validParameter.validFile(parameters, "name", true); if (namefile == "not open") { namefile = ""; abort = true; } else if (namefile == "not found") { namefile = ""; } else { m->setNameFile(namefile); } countfile = validParameter.validFile(parameters, "count", true); if (countfile == "not open") { countfile = ""; abort = true; } else if (countfile == "not found") { countfile = ""; } else { m->setCountTableFile(countfile); } if ((namefile != "") && (countfile != "")) { m->mothurOut("[ERROR]: you may only use one of the following: name or count."); m->mothurOutEndLine(); abort = true; } if ((groupfile != "") && (countfile != "")) { m->mothurOut("[ERROR]: you may only use one of the following: group or count."); m->mothurOutEndLine(); abort=true; } } //if the user changes the output directory command factory will send this info to us in the output parameter string outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; if (randomtree == "") { outputDir += m->hasPath(treefile); } } //check for optional parameter and set defaults // ...at some point should added some additional type checking... groups = validParameter.validFile(parameters, "groups", false); if (groups == "not found") { groups = ""; m->clearGroups(); } else { m->splitAtDash(groups, Groups); m->setGroups(Groups); } itersString = validParameter.validFile(parameters, "iters", false); if (itersString == "not found") { itersString = "1000"; } m->mothurConvert(itersString, iters); string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); } m->setProcessors(temp); m->mothurConvert(temp, processors); if (countfile=="") { if (namefile == "") { vector<string> files; files.push_back(treefile); parser.getNameFile(files); } } } } catch(exception& e) { m->errorOut(e, "ParsimonyCommand", "ParsimonyCommand"); exit(1); } }
//*************************************************************************************************************** ChimeraBellerophonCommand::ChimeraBellerophonCommand(string option) { try { abort = false; calledHelp = false; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); ValidParameters validParameter("chimera.bellerophon"); map<string,string>::iterator it; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["chimera"] = tempOutNames; outputTypes["accnos"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } fastafile = validParameter.validFile(parameters, "fasta", false); if (fastafile == "not found") { //if there is a current fasta file, use it string filename = m->getFastaFile(); if (filename != "") { fastaFileNames.push_back(filename); m->mothurOut("Using " + filename + " as input file for the fasta parameter."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current fastafile and the fasta parameter is required."); m->mothurOutEndLine(); abort = true; } }else { m->splitAtDash(fastafile, fastaFileNames); //go through files and make sure they are good, if not, then disregard them for (int i = 0; i < fastaFileNames.size(); i++) { bool ignore = false; if (fastaFileNames[i] == "current") { fastaFileNames[i] = m->getFastaFile(); if (fastaFileNames[i] != "") { m->mothurOut("Using " + fastaFileNames[i] + " as input file for the fasta parameter where you had given current."); m->mothurOutEndLine(); } else { m->mothurOut("You have no current fastafile, ignoring current."); m->mothurOutEndLine(); ignore=true; //erase from file list fastaFileNames.erase(fastaFileNames.begin()+i); i--; } } if (!ignore) { if (inputDir != "") { string path = m->hasPath(fastaFileNames[i]); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { fastaFileNames[i] = inputDir + fastaFileNames[i]; } } int ableToOpen; ifstream in; ableToOpen = m->openInputFile(fastaFileNames[i], in, "noerror"); //if you can't open it, try default location if (ableToOpen == 1) { if (m->getDefaultPath() != "") { //default path is set string tryPath = m->getDefaultPath() + m->getSimpleName(fastaFileNames[i]); m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); ifstream in2; ableToOpen = m->openInputFile(tryPath, in2, "noerror"); in2.close(); fastaFileNames[i] = tryPath; } } //if you can't open it, try default location if (ableToOpen == 1) { if (m->getOutputDir() != "") { //default path is set string tryPath = m->getOutputDir() + m->getSimpleName(fastaFileNames[i]); m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); ifstream in2; ableToOpen = m->openInputFile(tryPath, in2, "noerror"); in2.close(); fastaFileNames[i] = tryPath; } } in.close(); if (ableToOpen == 1) { m->mothurOut("Unable to open " + fastaFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); //erase from file list fastaFileNames.erase(fastaFileNames.begin()+i); i--; }else { m->setFastaFile(fastaFileNames[i]); } } } //make sure there is at least one valid file left if (fastaFileNames.size() == 0) { m->mothurOut("no valid files."); m->mothurOutEndLine(); abort = true; } } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } string temp; temp = validParameter.validFile(parameters, "filter", false); if (temp == "not found") { temp = "F"; } filter = m->isTrue(temp); temp = validParameter.validFile(parameters, "correction", false); if (temp == "not found") { temp = "T"; } correction = m->isTrue(temp); temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); } m->setProcessors(temp); m->mothurConvert(temp, processors); temp = validParameter.validFile(parameters, "window", false); if (temp == "not found") { temp = "0"; } m->mothurConvert(temp, window); temp = validParameter.validFile(parameters, "increment", false); if (temp == "not found") { temp = "25"; } m->mothurConvert(temp, increment); } } catch(exception& e) { m->errorOut(e, "ChimeraBellerophonCommand", "ChimeraBellerophonCommand"); exit(1); } }
//********************************************************************************************************************** GetRAbundCommand::GetRAbundCommand(string option) { try { abort = false; calledHelp = false; allLines = 1; //allow user to run help if(option == "help") { help(); abort = true; calledHelp = true; } else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { vector<string> myArray = setParameters(); OptionParser parser(option); map<string,string> parameters = parser.getParameters(); map<string,string>::iterator it; ValidParameters validParameter; //check to make sure all parameters are valid for command for (it = parameters.begin(); it != parameters.end(); it++) { if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } //initialize outputTypes vector<string> tempOutNames; outputTypes["rabund"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); if (inputDir == "not found"){ inputDir = ""; } else { string path; it = parameters.find("list"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["list"] = inputDir + it->second; } } it = parameters.find("sabund"); //user has given a template file if(it != parameters.end()){ path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["sabund"] = inputDir + it->second; } } } //check for required parameters listfile = validParameter.validFile(parameters, "list", true); if (listfile == "not open") { listfile = ""; abort = true; } else if (listfile == "not found") { listfile = ""; } else { format = "list"; inputfile = listfile; m->setListFile(listfile); } sabundfile = validParameter.validFile(parameters, "sabund", true); if (sabundfile == "not open") { sabundfile = ""; abort = true; } else if (sabundfile == "not found") { sabundfile = ""; } else { format = "sabund"; inputfile = sabundfile; m->setSabundFile(sabundfile); } //check for optional parameter and set defaults // ...at some point should added some additional type checking... string temp; temp = validParameter.validFile(parameters, "sorted", false); if (temp == "not found") { temp = "T"; } sorted = m->isTrue(temp); label = validParameter.validFile(parameters, "label", false); if (label == "not found") { label = ""; } else { if(label != "all") { m->splitAtDash(label, labels); allLines = 0; } else { allLines = 1; } } if ((listfile == "") && (sabundfile == "")) { //is there are current file available for any of these? //give priority to shared, then list, then rabund, then sabund //if there is a current shared file, use it listfile = m->getListFile(); if (listfile != "") { inputfile = listfile; format = "list"; m->mothurOut("Using " + listfile + " as input file for the list parameter."); m->mothurOutEndLine(); } else { sabundfile = m->getSabundFile(); if (sabundfile != "") { inputfile = sabundfile; format = "sabund"; m->mothurOut("Using " + sabundfile + " as input file for the sabund parameter."); m->mothurOutEndLine(); } else { m->mothurOut("No valid current files. You must provide a list or sabund file."); m->mothurOutEndLine(); abort = true; } } } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = m->hasPath(inputfile); } } } catch(exception& e) { m->errorOut(e, "GetRAbundCommand", "GetRAbundCommand"); exit(1); } }