static void CountSSMLeave(const address &group, const address &source) {
address source_addr;
char tmp[64], tmp2[64];
GroupMap::iterator g = groupMap.find(group);
assert(g != groupMap.end());
source_addr.set_family(source.family());
source_addr.copy_address(source);
source_addr.set_port(0);
SourceMap::iterator s = g->second.find(source_addr);
assert(s != g->second.end());
SourceSet::iterator ss = s->second.find(source);
if (ss == s->second.end()) {
return;
}
if (verbose)
info("Removing beacon %s from (%s, %s)", source.to_string(tmp, sizeof(tmp)),
source_addr.to_string(tmp2, sizeof(tmp2)),
group.to_string(tmp2, sizeof(tmp2)));
s->second.erase(ss);
if (s->second.empty()) {
if (verbose)
info("No more beacons for (%s, %s), leaving group",
source_addr.to_string(tmp, sizeof(tmp)),
group.to_string(tmp2, sizeof(tmp2)));
SSMLeave(ssmMcastSock,group, source_addr);
g->second.erase(s);
}
if (g->second.empty()) {
if (verbose)
info("No more sources, unregistering group %s, ", group.to_string(tmp, sizeof(tmp)));
groupMap.erase(g);
}
}
static void CountSSMJoin(const address &group, const address &source) {
address source_addr;
char tmp[64], tmp2[64], tmp3[64];
source_addr.set_family(source.family());
source_addr.copy_address(source);
source_addr.set_port(0);
GroupMap::iterator g = groupMap.find(group);
if (g == groupMap.end()) {
if (verbose)
info("Registering SSM group %s", group.to_string(tmp, sizeof(tmp)));
g = groupMap.insert(std::make_pair(group, SourceMap())).first;
}
SourceMap::iterator s = g->second.find(source_addr);
if (s == g->second.end()) {
if (verbose)
info("Joining (%s, %s)", source_addr.to_string(tmp, sizeof(tmp)),
group.to_string(tmp2, sizeof(tmp2)));
if (SSMJoin(ssmMcastSock, group, source_addr) < 0) {
if (verbose)
info("Join failed, reason: %s", strerror(errno));
return;
} else {
s = g->second.insert(std::make_pair(source_addr, SourceSet())).first;
}
}
SourceSet::iterator ss = s->second.find(source);
if (ss == s->second.end()) {
if (verbose)
info("Adding beacon %s to (%s, %s)", source.to_string(tmp, sizeof(tmp)),
source_addr.to_string(tmp2, sizeof(tmp2)),
group.to_string(tmp3, sizeof(tmp3)));
s->second.insert(source);
}
}
void NetworkClient::GetGroups()
{
rMessage->Reset();
peer->RPC("ServerPeer::GetGroups", NULL , NULL, HIGH_PRIORITY, RELIABLE, 0, UNASSIGNED_SYSTEM_ADDRESS, true, 0, UNASSIGNED_NETWORK_ID,rMessage);
if( (rMessage->GetNumberOfUnreadBits()) > 0)
{
int count, groupId, len = 0;
char* groupName = "";
GroupMap g;
g.clear();
rMessage->Read(count);
for(int j = 0;j<count;j++)
{
rMessage->Read(groupId);
rMessage->Read(len);
groupName = new char[len+1];
groupName[len] = 0;
rMessage->Read(groupName, len);
g.insert(GroupMap::value_type(groupId, groupName));
}
if(!g.empty())
{
dataMan->setGroups(g);
}
}
}
void ResultsTree::GroupSortProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
{
QAbstractProxyModel::setSourceModel(sourceModel);
groupItems.clear();
if (sourceModel)
{
// Create group items
typedef std::map< QVariant, int, QVariantCompare > GroupMap;
GroupMap groupMap;
int numRows = sourceModel->rowCount();
for (int i = 0; i < numRows; ++i)
{
QModelIndex ind = sourceModel->index(i, groupByCol, QModelIndex());
QVariant v = sourceModel->data(ind, Qt::DisplayRole);
GroupMap::iterator it = groupMap.find(v);
if (it == groupMap.end())
{
it = groupMap.insert(GroupMap::value_type(v, groupItems.size())).first;
groupItems.push_back(GroupItem(v));
}
groupItems[it->second].children.push_back(ind);
}
}
}
//**********************************************************************************************************************
// This static function is intended to read all the necessary information from
// a pair of shared and design files needed for SVM classification. This information
// is used to build a LabeledObservationVector. Each element of the LabeledObservationVector
// looks like this:
// LabeledObservationVector[0] = pair("label 0", &vector[10.0, 21.0, 13.0])
// where the vector in the second position of the pair records OTU abundances.
void ClassifySvmSharedCommand::readSharedAndDesignFiles(const std::string& sharedFilePath, const std::string& designFilePath, LabeledObservationVector& labeledObservationVector, FeatureVector& featureVector) {
InputData input(sharedFilePath, "sharedfile");
vector<SharedRAbundVector*> lookup = input.getSharedRAbundVectors();
GroupMap designMap;
designMap.readDesignMap(designFilePath);
while ( lookup[0] != NULL ) {
readSharedRAbundVectors(lookup, designMap, labeledObservationVector, featureVector);
lookup = input.getSharedRAbundVectors();
}
}
//-----------------------------------------------------------------------------------------
void process_message_group_ordering(const GroupMap& gm)
{
for (GroupMap::const_iterator gitr(gm.begin()); gitr != gm.end(); ++gitr)
{
FieldTraitOrder go;
for (Presence::const_iterator flitr(gitr->second._fields.get_presence().begin());
flitr != gitr->second._fields.get_presence().end(); ++flitr)
go.insert(FieldTraitOrder::value_type(&*flitr));
unsigned gcnt(0);
for (FieldTraitOrder::iterator fto(go.begin()); fto != go.end(); ++fto)
(*fto)->_pos = ++gcnt;
if (!gitr->second._groups.empty())
process_message_group_ordering(gitr->second._groups);
}
}
MojErr MojDbSearchCursor::loadIds(ObjectSet& idsOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojUInt32 groupNum = 0;
bool found = false;
MojSharedPtr<ObjectSet> group;
GroupMap groupMap;
for(;;) {
// get current id
MojObject id;
MojUInt32 idGroupNum = 0;
MojErr err = m_storageQuery->getId(id, idGroupNum, found);
MojErrCheck(err);
if (!found)
break;
// if it is in a new group, create a new set
if (!group.get() || idGroupNum != groupNum) {
// find/create new group
GroupMap::Iterator iter;
err = groupMap.find(idGroupNum, iter);
MojErrCheck(err);
if (iter != groupMap.end()) {
group = iter.value();
} else {
err = group.resetChecked(new ObjectSet);
MojErrCheck(err);
err = groupMap.put(idGroupNum, group);
MojErrCheck(err);
}
groupNum = idGroupNum;
}
// add id to current set
err = group->put(id);
MojErrCheck(err);
}
// no matches unless all groups are accounted for
MojUInt32 groupCount = m_storageQuery->groupCount();
for (MojUInt32 i = 0; i < groupCount; ++i) {
if (!groupMap.contains(i))
return MojErrNone;
}
// find intersection of all groups
GroupMap::ConstIterator begin = groupMap.begin();
for (GroupMap::ConstIterator i = begin; i != groupMap.end(); ++i) {
if (i == begin) {
// special handling for first group
idsOut = *(i.value());
} else {
MojErr err = idsOut.intersect(*(i.value()));
MojErrCheck(err);
}
}
return MojErrNone;
}
void parseSubGroup(filesystem::InputStream &stream, const std::string &string, int flags)
{
std::string groupName = string;
std::string superName;
splitString(string, groupName, superName, ':');
std::shared_ptr<ParserGroup> group(parserGroupFactory());
group->setFlags(flags);
if(!superName.empty())
{
GroupMap::iterator it = groups.find(superName);
if(it != groups.end())
*group.get() = *(*it).second;
}
stream >> *group;
groups[groupName] = group;
}
void ModelGrouper::group( GroupMap & grouped )
{
QList<QPersistentModelIndex> persistentGroupIndexes;
// If we are already grouped, we need to insert items into existing groups before creating new ones
if( mIsGrouped ) {
// Get persistent indexes for each group item, because regular ones may be invalidated by
// the move call in the loop
for( ModelIter it(model()); it.isValid(); ++it )
if( model()->translator(*it) == groupedItemTranslator() )
persistentGroupIndexes.append( *it );
foreach( QPersistentModelIndex idx, persistentGroupIndexes ) {
bool isEmptyGroup = model()->rowCount(idx) == 0;
QString groupVal = idx.sibling( idx.row(), mGroupColumn ).data( Qt::DisplayRole ).toString();
GroupMap::Iterator mapIt = grouped.find( groupVal );
if( mapIt != grouped.end() ) {
QModelIndexList toMove(fromPersist(mapIt.value()));
//LOG_5( QString("Moving indexes %1 to existing group item at index %2").arg(indexListToStr(toMove)).arg(indexToStr(idx)) );
model()->move( toMove, idx );
if( isEmptyGroup )
emit groupPopulated( idx );
if( mUpdateScheduled ) {
if( !mGroupItemsToUpdate.contains( idx ) )
mGroupItemsToUpdate.append(idx);
} else
// Tell the group item to update itself based on the added children
model()->setData( idx, QVariant(), GroupingUpdate );
grouped.erase( mapIt );
}
}
// Deal with any now-empty groups
for( QList<QPersistentModelIndex>::Iterator it = persistentGroupIndexes.begin(); it != persistentGroupIndexes.end(); )
if( model()->translator(*it) == groupedItemTranslator() && model()->rowCount(*it) == 0 ) {
emit groupEmptied(*it);
++it;
} else
it = persistentGroupIndexes.erase( it );
if( emptyGroupPolicy() == RemoveEmptyGroups )
model()->remove( fromPersist( persistentGroupIndexes ) );
}
void copy(ParserGroupData &rhs)
{
values = rhs.values;
lines = rhs.lines;
groups.clear();
for(GroupMap::iterator it = rhs.groups.begin(); it != rhs.groups.end(); ++it)
{
boost::shared_ptr<ParserGroup> g(parserGroupFactory());
*g.get() = *(*it).second.get();
groups[(*it).first] = g;
}
}
void writeStream(std::ostream &stream, int tabCount)
{
for(ValueMap::iterator vi = values.begin(); vi != values.end(); ++vi)
{
writeTabs(stream, tabCount);
stream << (*vi).first << " = " << (*vi).second.first << std::endl;
}
for(GroupMap::iterator gi = groups.begin(); gi != groups.end(); ++gi)
{
if((gi != groups.begin()) || (!values.empty()))
stream << std::endl;
writeTabs(stream, tabCount);
stream << (*gi).first << std::endl;
writeTabs(stream, tabCount);
stream << "{" << std::endl;
(*gi).second->writeStream(stream, tabCount + 1),
writeTabs(stream, tabCount);
stream << "}" << std::endl;
}
if(!lines.empty() && ((!groups.empty() || !values.empty())))
stream << std::endl;
for(LineList::iterator li = lines.begin(); li != lines.end(); ++li)
{
writeTabs(stream, tabCount);
std::string &f = (*li);
stream << (*li) << std::endl;
}
}
void ClassifySvmSharedCommand::readSharedRAbundVectors(vector<SharedRAbundVector*>& lookup, GroupMap& designMap, LabeledObservationVector& labeledObservationVector, FeatureVector& featureVector) {
for ( int j = 0; j < lookup.size(); j++ ) {
//i++;
vector<individual> data = lookup[j]->getData();
Observation* observation = new Observation(data.size(), 0.0);
string sharedGroupName = lookup[j]->getGroup();
string treatmentName = designMap.getGroup(sharedGroupName);
//std::cout << "shared group name: " << sharedGroupName << " treatment name: " << treatmentName << std::endl;
//labeledObservationVector.push_back(std::make_pair(treatmentName, observation));
labeledObservationVector.push_back(LabeledObservation(j, treatmentName, observation));
//std::cout << " j=" << j << " label : " << lookup[j]->getLabel() << " group: " << lookup[j]->getGroup();
for (int k = 0; k < data.size(); k++) {
//std::cout << " abundance " << data[k].abundance;
observation->at(k) = double(data[k].abundance);
if ( j == 0) {
featureVector.push_back(Feature(k, m->currentSharedBinLabels[k]));
}
}
//std::cout << std::endl;
// let this happen later?
//delete lookup[j];
}
}
// The following is common part for 'cilk vector functions' and
// 'omp declare simd' functions metadata generation.
//
void CodeGenModule::EmitVectorVariantsMetadata(const CGFunctionInfo &FnInfo,
const FunctionDecl *FD,
llvm::Function *Fn,
GroupMap &Groups) {
// Do not emit any vector variant if there is an unsupported feature.
bool HasImplicitThis = false;
if (!CheckElementalArguments(*this, FD, Fn, HasImplicitThis))
return;
llvm::LLVMContext &Context = getLLVMContext();
ASTContext &C = getContext();
// Common metadata nodes.
llvm::NamedMDNode *CilkElementalMetadata =
getModule().getOrInsertNamedMetadata("cilk.functions");
llvm::Metadata *ElementalMDArgs[] = {
llvm::MDString::get(Context, "elemental")
};
llvm::MDNode *ElementalNode = llvm::MDNode::get(Context, ElementalMDArgs);
llvm::Metadata *MaskMDArgs[] = {
llvm::MDString::get(Context, "mask"),
llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
llvm::IntegerType::getInt1Ty(Context), 1))
};
llvm::MDNode *MaskNode = llvm::MDNode::get(Context, MaskMDArgs);
MaskMDArgs[1] = llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
llvm::IntegerType::getInt1Ty(Context), 0));
llvm::MDNode *NoMaskNode = llvm::MDNode::get(Context, MaskMDArgs);
SmallVector<llvm::Metadata*, 8> ParameterNameArgs;
ParameterNameArgs.push_back(llvm::MDString::get(Context, "arg_name"));
llvm::MDNode *ParameterNameNode = 0;
// // Vector variant metadata.
// llvm::Value *VariantMDArgs[] = {
// llvm::MDString::get(Context, "variant"),
// llvm::UndefValue::get(llvm::Type::getVoidTy(Context))
// };
// llvm::MDNode *VariantNode = llvm::MDNode::get(Context, VariantMDArgs);
for (GroupMap::iterator GI = Groups.begin(), GE = Groups.end();
GI != GE;
++GI) {
CilkElementalGroup &G = GI->second;
// Parameter information.
QualType FirstNonStepParmType;
SmallVector<llvm::Metadata *, 8> AligArgs;
SmallVector<llvm::Metadata *, 8> StepArgs;
AligArgs.push_back(llvm::MDString::get(Context, "arg_alig"));
StepArgs.push_back(llvm::MDString::get(Context, "arg_step"));
// Handle implicit 'this' parameter if necessary.
if (HasImplicitThis) {
ParameterNameArgs.push_back(llvm::MDString::get(Context, "this"));
bool IsNonStepParm = handleParameter(*this, G, "this",
StepArgs, AligArgs);
if (IsNonStepParm)
FirstNonStepParmType = cast<CXXMethodDecl>(FD)->getThisType(C);
}
// Handle explicit paramenters.
for (unsigned I = 0; I != FD->getNumParams(); ++I) {
const ParmVarDecl *Parm = FD->getParamDecl(I);
StringRef ParmName = Parm->getName();
if (!ParameterNameNode)
ParameterNameArgs.push_back(llvm::MDString::get(Context, ParmName));
bool IsNonStepParm = handleParameter(*this, G, ParmName,
StepArgs, AligArgs);
if (IsNonStepParm && FirstNonStepParmType.isNull())
FirstNonStepParmType = Parm->getType();
}
llvm::MDNode *StepNode = llvm::MDNode::get(Context, StepArgs);
llvm::MDNode *AligNode = llvm::MDNode::get(Context, AligArgs);
if (!ParameterNameNode)
ParameterNameNode = llvm::MDNode::get(Context, ParameterNameArgs);
// If there is no vectorlengthfor() in this group, determine the
// characteristic type. This can depend on the linear/uniform attributes,
// so it can differ between groups.
//
// The rules for computing the characteristic type are:
//
// a) For a non-void function, the characteristic data type is the
// return type.
//
// b) If the function has any non-uniform, non-linear parameters, the
// the characteristic data type is the type of the first such parameter.
//
// c) If the characteristic data type determined by a) or b) above is
// struct, union, or class type which is pass-by-value (except fo
// the type that maps to the built-in complex data type)
// the characteristic data type is int.
//
// d) If none of the above three cases is applicable,
// the characteristic data type is int.
//
// e) For Intel Xeon Phi native and offload compilation, if the resulting
// characteristic data type is 8-bit or 16-bit integer data type
// the characteristic data type is int.
//
// These rules missed the reference types and we use their pointer types.
//
if (G.VecLengthFor.empty()) {
QualType FnRetTy = FD->getReturnType();
QualType CharacteristicType;
if (!FnRetTy->isVoidType())
CharacteristicType = FnRetTy;
else if (!FirstNonStepParmType.isNull())
CharacteristicType = FirstNonStepParmType.getCanonicalType();
else
CharacteristicType = C.IntTy;
if (CharacteristicType->isReferenceType()) {
QualType BaseTy = CharacteristicType.getNonReferenceType();
CharacteristicType = C.getPointerType(BaseTy);
} else if (CharacteristicType->isAggregateType())
CharacteristicType = C.IntTy;
// FIXME: handle Xeon Phi targets.
G.VecLengthFor.push_back(CharacteristicType);
}
// // If no mask variants are specified, generate both.
// if (G.Mask.empty()) {
// G.Mask.push_back(1);
// G.Mask.push_back(0);
// }
// If no vector length is specified, push a dummy value to iterate over.
if (G.VecLength.empty())
G.VecLength.push_back(0);
for (CilkElementalGroup::VecLengthForVector::iterator
TI = G.VecLengthFor.begin(),
TE = G.VecLengthFor.end();
TI != TE;
++TI) {
uint64_t VectorRegisterBytes = 0;
// Inspect the current target features to determine the
// appropriate vector size.
// This is currently X86 specific.
if (Target.hasFeature("avx2"))
VectorRegisterBytes = 64;
else if (Target.hasFeature("avx"))
VectorRegisterBytes = 32;
else if (Target.hasFeature("sse2"))
VectorRegisterBytes = 16;
else if (Target.hasFeature("sse") &&
(*TI)->isFloatingType() &&
C.getTypeSizeInChars(*TI).getQuantity() == 4)
VectorRegisterBytes = 16;
else if (Target.hasFeature("mmx") && (*TI)->isIntegerType())
VectorRegisterBytes = 8;
for (CilkElementalGroup::VecLengthVector::iterator
LI = G.VecLength.begin(),
LE = G.VecLength.end();
LI != LE;
++LI) {
uint64_t VL = *LI ? *LI :
(CharUnits::fromQuantity(VectorRegisterBytes)
/ C.getTypeSizeInChars(*TI));
llvm::MDNode *VecTypeNode
= MakeVecLengthMetadata(*this, "vec_length", *TI, VL);
{
SmallVector <llvm::Metadata*, 7> kernelMDArgs;
kernelMDArgs.push_back(llvm::ValueAsMetadata::get(Fn));
kernelMDArgs.push_back(ElementalNode);
kernelMDArgs.push_back(ParameterNameNode);
kernelMDArgs.push_back(StepNode);
kernelMDArgs.push_back(AligNode);
kernelMDArgs.push_back(VecTypeNode);
if (!G.Mask.empty())
kernelMDArgs.push_back((G.Mask.back()==0)?(NoMaskNode):(MaskNode));
llvm::MDNode *KernelMD = llvm::MDNode::get(Context, kernelMDArgs);
CilkElementalMetadata->addOperand(KernelMD);
}
// for (CilkElementalGroup::MaskVector::iterator
// MI = G.Mask.begin(),
// ME = G.Mask.end();
// MI != ME;
// ++MI) {
//
// SmallVector <llvm::Value*, 7> kernelMDArgs;
// kernelMDArgs.push_back(Fn);
// kernelMDArgs.push_back(ElementalNode);
// kernelMDArgs.push_back(ParameterNameNode);
// kernelMDArgs.push_back(StepNode);
// kernelMDArgs.push_back(AligNode);
// kernelMDArgs.push_back(VecTypeNode);
// kernelMDArgs.push_back((*MI==0)?(NoMaskNode):(MaskNode));
// if (ProcessorNode)
// kernelMDArgs.push_back(ProcessorNode);
// kernelMDArgs.push_back(VariantNode);
// llvm::MDNode *KernelMD = llvm::MDNode::get(Context, kernelMDArgs);
// CilkElementalMetadata->addOperand(KernelMD);
// ElementalVariantToEmit.push_back(
// ElementalVariantInfo(&FnInfo, FD, Fn, KernelMD));
// }
}
}
}
}
int ClassifySeqsCommand::execute(){
try {
if (abort) { if (calledHelp) { return 0; } return 2; }
string outputMethodTag = method;
if(method == "wang"){ classify = new Bayesian(taxonomyFileName, templateFileName, search, kmerSize, cutoff, iters, util.getRandomNumber(), flip, writeShortcuts, current->getVersion()); }
else if(method == "knn"){ classify = new Knn(taxonomyFileName, templateFileName, search, kmerSize, gapOpen, gapExtend, match, misMatch, numWanted, util.getRandomNumber(), current->getVersion()); }
else if(method == "zap"){
outputMethodTag = search + "_" + outputMethodTag;
if (search == "kmer") { classify = new KmerTree(templateFileName, taxonomyFileName, kmerSize, cutoff); }
else { classify = new AlignTree(templateFileName, taxonomyFileName, cutoff); }
}
else {
m->mothurOut(search + " is not a valid method option. I will run the command using wang.");
m->mothurOutEndLine();
classify = new Bayesian(taxonomyFileName, templateFileName, search, kmerSize, cutoff, iters, util.getRandomNumber(), flip, writeShortcuts, current->getVersion());
}
if (m->getControl_pressed()) { delete classify; return 0; }
m->mothurOut("Classifying sequences from " + fastafile + " ...\n" );
string baseTName = util.getSimpleName(taxonomyFileName);
//set rippedTaxName to
string RippedTaxName = "";
bool foundDot = false;
for (int i = baseTName.length()-1; i >= 0; i--) {
if (foundDot && (baseTName[i] != '.')) { RippedTaxName = baseTName[i] + RippedTaxName; }
else if (foundDot && (baseTName[i] == '.')) { break; }
else if (!foundDot && (baseTName[i] == '.')) { foundDot = true; }
}
if (outputDir == "") { outputDir += util.hasPath(fastafile); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(fastafile));
variables["[tag]"] = RippedTaxName;
variables["[tag2]"] = outputMethodTag;
string newTaxonomyFile = getOutputFileName("taxonomy", variables);
string newaccnosFile = getOutputFileName("accnos", variables);
string tempTaxonomyFile = outputDir + util.getRootName(util.getSimpleName(fastafile)) + "taxonomy.temp";
string taxSummary = getOutputFileName("taxsummary", variables);
if ((method == "knn") && (search == "distance")) {
string DistName = getOutputFileName("matchdist", variables);
classify->setDistName(DistName); outputNames.push_back(DistName); outputTypes["matchdist"].push_back(DistName);
}
outputNames.push_back(newTaxonomyFile); outputTypes["taxonomy"].push_back(newTaxonomyFile);
outputNames.push_back(taxSummary); outputTypes["taxsummary"].push_back(taxSummary);
long start = time(NULL);
int numFastaSeqs = createProcesses(newTaxonomyFile, tempTaxonomyFile, newaccnosFile, fastafile);
if (!util.isBlank(newaccnosFile)) { m->mothurOut("\n[WARNING]: mothur reversed some your sequences for a better classification. If you would like to take a closer look, please check " + newaccnosFile + " for the list of the sequences.\n");
outputNames.push_back(newaccnosFile); outputTypes["accnos"].push_back(newaccnosFile);
}else { util.mothurRemove(newaccnosFile); }
m->mothurOut("\nIt took " + toString(time(NULL) - start) + " secs to classify " + toString(numFastaSeqs) + " sequences.\n\n");
start = time(NULL);
//read namefile
map<string, vector<string> > nameMap;
map<string, vector<string> >::iterator itNames;
if(namefile != "") {
m->mothurOut("Reading " + namefile + "..."); cout.flush();
nameMap.clear(); //remove old names
util.readNames(namefile, nameMap);
m->mothurOut(" Done.\n");
}
//output taxonomy with the unclassified bins added
ifstream inTax;
util.openInputFile(newTaxonomyFile, inTax);
ofstream outTax;
string unclass = newTaxonomyFile + ".unclass.temp";
util.openOutputFile(unclass, outTax);
//get maxLevel from phylotree so you know how many 'unclassified's to add
int maxLevel = classify->getMaxLevel();
//read taxfile - this reading and rewriting is done to preserve the confidence scores.
string name, taxon;
GroupMap* groupMap = NULL;
CountTable* ct = NULL;
PhyloSummary* taxaSum;
if (hasCount) {
ct = new CountTable();
ct->readTable(countfile, true, false);
taxaSum = new PhyloSummary(ct, relabund, printlevel);
}else {
if (groupfile != "") { groupMap = new GroupMap(groupfile); groupMap->readMap(); }
taxaSum = new PhyloSummary(groupMap, relabund, printlevel);
}
while (!inTax.eof()) {
if (m->getControl_pressed()) { outputTypes.clear(); if (ct != NULL) { delete ct; } if (groupMap != NULL) { delete groupMap; } delete taxaSum; for (int i = 0; i < outputNames.size(); i++) { util.mothurRemove(outputNames[i]); } delete classify; return 0; }
inTax >> name; util.gobble(inTax);
taxon = util.getline(inTax); util.gobble(inTax);
string newTax = util.addUnclassifieds(taxon, maxLevel, probs);
outTax << name << '\t' << newTax << endl;
if (namefile != "") {
itNames = nameMap.find(name);
if (itNames == nameMap.end()) {
m->mothurOut(name + " is not in your name file please correct.\n"); exit(1);
}else{
//add it as many times as there are identical seqs
for (int i = 0; i < itNames->second.size(); i++) { taxaSum->addSeqToTree(itNames->second[i], newTax); }
itNames->second.clear();
nameMap.erase(itNames->first);
}
}else { taxaSum->addSeqToTree(name, newTax); }
}
inTax.close();
outTax.close();
util.mothurRemove(newTaxonomyFile);
util.renameFile(unclass, newTaxonomyFile);
if (m->getControl_pressed()) { outputTypes.clear(); if (ct != NULL) { delete ct; } if (groupMap != NULL) { delete groupMap; } for (int i = 0; i < outputNames.size(); i++) { util.mothurRemove(outputNames[i]); } delete classify; return 0; }
//print summary file
ofstream outTaxTree;
util.openOutputFile(taxSummary, outTaxTree);
taxaSum->print(outTaxTree, output);
outTaxTree.close();
if (ct != NULL) { delete ct; }
if (groupMap != NULL) { delete groupMap; } delete taxaSum;
util.mothurRemove(tempTaxonomyFile);
delete classify;
m->mothurOut("\nIt took " + toString(time(NULL) - start) + " secs to create the summary file for " + toString(numFastaSeqs) + " sequences.\n\n");
m->mothurOut("\nOutput File Names: \n");
for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
m->mothurOutEndLine();
//set taxonomy file as new current taxonomyfile
string currentName = "";
itTypes = outputTypes.find("taxonomy");
if (itTypes != outputTypes.end()) { if ((itTypes->second).size() != 0) { currentName = (itTypes->second)[0]; current->setTaxonomyFile(currentName); } }
currentName = "";
itTypes = outputTypes.find("accnos");
if (itTypes != outputTypes.end()) { if ((itTypes->second).size() != 0) { currentName = (itTypes->second)[0]; current->setAccnosFile(currentName); } }
return 0;
}
catch(exception& e) {
m->errorOut(e, "ClassifySeqsCommand", "execute");
exit(1);
}
}
void removeSubGroup(const std::string& name)
{
GroupMap::iterator it = groups.find(name);
if(it != groups.end())
groups.erase(it);
}
//**********************************************************************************************************************
int SharedCommand::createSharedFromListGroup() {
try {
GroupMap* groupMap = NULL;
CountTable* countTable = NULL;
pickedGroups = false;
if (groupfile != "") {
groupMap = new GroupMap(groupfile);
int groupError = groupMap->readMap();
if (groupError == 1) { delete groupMap; return 0; }
vector<string> allGroups = groupMap->getNamesOfGroups();
if (Groups.size() == 0) { Groups = allGroups; }
else { pickedGroups = true; }
}else{
countTable = new CountTable();
countTable->readTable(countfile, true, false);
vector<string> allGroups = countTable->getNamesOfGroups();
if (Groups.size() == 0) { Groups = allGroups; }
else { pickedGroups = true; }
}
int numGroups = Groups.size();
if (m->getControl_pressed()) { return 0; }
ofstream out;
string filename = "";
if (!pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
util.openOutputFile(filename, out);
}
//set fileroot
fileroot = outputDir + util.getRootName(util.getSimpleName(listfile));
map<string, string> variables;
variables["[filename]"] = fileroot;
string errorOff = "no error";
InputData input(listfile, "shared", Groups);
SharedListVector* SharedList = input.getSharedListVector();
string lastLabel = SharedList->getLabel();
SharedRAbundVectors* lookup;
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
out.close(); if (!pickedGroups) { util.mothurRemove(filename); }
return 0;
}
//sanity check
vector<string> namesSeqs;
int numGroupNames = 0;
if (current->getGroupMode() == "group") { namesSeqs = groupMap->getNamesSeqs(); numGroupNames = groupMap->getNumSeqs(); }
else { namesSeqs = countTable->getNamesOfSeqs(); numGroupNames = countTable->getNumUniqueSeqs(); }
int error = ListGroupSameSeqs(namesSeqs, SharedList);
if ((!pickedGroups) && (SharedList->getNumSeqs() != numGroupNames)) { //if the user has not specified any groups and their files don't match exit with error
m->mothurOut("Your group file contains " + toString(numGroupNames) + " sequences and list file contains " + toString(SharedList->getNumSeqs()) + " sequences. Please correct.\n"); m->setControl_pressed(true);
out.close(); if (!pickedGroups) { util.mothurRemove(filename); } //remove blank shared file you made
//delete memory
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
return 0;
}
if (error == 1) { m->setControl_pressed(true); }
//if user has specified groups make new groupfile for them
if ((pickedGroups) && (current->getGroupMode() == "group")) { //make new group file
string groups = "";
if (numGroups < 4) {
for (int i = 0; i < numGroups-1; i++) {
groups += Groups[i] + ".";
}
groups+=Groups[numGroups-1];
}else { groups = "merge"; }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(listfile));
variables["[group]"] = groups;
string newGroupFile = getOutputFileName("group",variables);
outputTypes["group"].push_back(newGroupFile);
outputNames.push_back(newGroupFile);
ofstream outGroups;
util.openOutputFile(newGroupFile, outGroups);
vector<string> names = groupMap->getNamesSeqs();
string groupName;
for (int i = 0; i < names.size(); i++) {
groupName = groupMap->getGroup(names[i]);
if (isValidGroup(groupName, Groups)) {
outGroups << names[i] << '\t' << groupName << endl;
}
}
outGroups.close();
}
//if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
set<string> processedLabels;
set<string> userLabels = labels;
bool printHeaders = true;
while((SharedList != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
if(allLines == 1 || labels.count(SharedList->getLabel()) == 1){
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
delete lookup;
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
processedLabels.insert(SharedList->getLabel());
userLabels.erase(SharedList->getLabel());
}
if ((util.anyLabelsToProcess(SharedList->getLabel(), userLabels, errorOff) ) && (processedLabels.count(lastLabel) != 1)) {
string saveLabel = SharedList->getLabel();
delete SharedList;
SharedList = input.getSharedListVector(lastLabel); //get new list vector to process
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
delete lookup;
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
processedLabels.insert(SharedList->getLabel());
userLabels.erase(SharedList->getLabel());
//restore real lastlabel to save below
SharedList->setLabel(saveLabel);
}
lastLabel = SharedList->getLabel();
delete SharedList;
SharedList = input.getSharedListVector(); //get new list vector to process
}
//output error messages about any remaining user labels
set<string>::iterator it;
bool needToRun = false;
for (it = userLabels.begin(); it != userLabels.end(); it++) {
if (processedLabels.count(lastLabel) != 1) {
needToRun = true;
}
}
//run last label if you need to
if (needToRun ) {
if (SharedList != NULL) { delete SharedList; }
SharedList = input.getSharedListVector(lastLabel); //get new list vector to process
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
delete SharedList;
}
if (!pickedGroups) { out.close(); }
if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (m->getControl_pressed()) {
if (!pickedGroups) { util.mothurRemove(filename); }
return 0;
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "SharedCommand", "createSharedFromListGroup");
exit(1);
}
}
/**
* Constructs a DlgCustomToolbars which is a child of 'parent', with the
* name 'name' and widget flags set to 'f'
*
* The dialog will by default be modeless, unless you set 'modal' to
* true to construct a modal dialog.
*/
DlgCustomToolbars::DlgCustomToolbars(DlgCustomToolbars::Type t, QWidget* parent)
: CustomizeActionPage(parent), type(t)
{
this->setupUi(this);
moveActionRightButton->setIcon(BitmapFactory().pixmap(":/icons/button_right.svg"));
moveActionLeftButton->setIcon(BitmapFactory().pixmap(":/icons/button_left.svg"));
moveActionDownButton->setIcon(BitmapFactory().pixmap(":/icons/button_down.svg"));
moveActionUpButton->setIcon(BitmapFactory().pixmap(":/icons/button_up.svg"));
CommandManager & cCmdMgr = Application::Instance->commandManager();
std::map<std::string,Command*> sCommands = cCmdMgr.getCommands();
GroupMap groupMap;
groupMap.push_back(std::make_pair(QLatin1String("File"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Edit"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Standard-View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Tools"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Window"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Help"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Macros"), qApp->translate("Gui::MacroCommand", "Macros")));
for (std::map<std::string,Command*>::iterator it = sCommands.begin(); it != sCommands.end(); ++it) {
QLatin1String group(it->second->getGroupName());
QString text = qApp->translate(it->second->className(), it->second->getGroupName());
GroupMap::iterator jt;
jt = std::find_if(groupMap.begin(), groupMap.end(), GroupMap_find(group));
if (jt != groupMap.end()) {
if (jt->second.isEmpty())
jt->second = text;
}
else {
groupMap.push_back(std::make_pair(group, text));
}
}
int index = 0;
for (GroupMap::iterator it = groupMap.begin(); it != groupMap.end(); ++it, ++index) {
categoryBox->addItem(it->second);
categoryBox->setItemData(index, QVariant(it->first), Qt::UserRole);
}
// fills the combo box with all available workbenches
QStringList workbenches = Application::Instance->workbenches();
workbenches.sort();
index = 1;
workbenchBox->addItem(QApplication::windowIcon(), tr("Global"));
workbenchBox->setItemData(0, QVariant(QString::fromLatin1("Global")), Qt::UserRole);
for (QStringList::Iterator it = workbenches.begin(); it != workbenches.end(); ++it) {
QPixmap px = Application::Instance->workbenchIcon(*it);
QString mt = Application::Instance->workbenchMenuText(*it);
if (mt != QLatin1String("<none>")) {
if (px.isNull())
workbenchBox->addItem(mt);
else
workbenchBox->addItem(px, mt);
workbenchBox->setItemData(index, QVariant(*it), Qt::UserRole);
index++;
}
}
QStringList labels;
labels << tr("Icon") << tr("Command");
commandTreeWidget->setHeaderLabels(labels);
commandTreeWidget->header()->hide();
commandTreeWidget->setIconSize(QSize(32, 32));
commandTreeWidget->header()->setResizeMode(0, QHeaderView::ResizeToContents);
labels.clear(); labels << tr("Command");
toolbarTreeWidget->setHeaderLabels(labels);
toolbarTreeWidget->header()->hide();
on_categoryBox_activated(categoryBox->currentIndex());
Workbench* w = WorkbenchManager::instance()->active();
if (w) {
QString name = QString::fromLatin1(w->name().c_str());
int index = workbenchBox->findData(name);
workbenchBox->setCurrentIndex(index);
}
on_workbenchBox_activated(workbenchBox->currentIndex());
}
/**
* Constructs a DlgCustomCommandsImp which is a child of 'parent', with the
* name 'name' and widget flags set to 'f'
*
* The dialog will by default be modeless, unless you set 'modal' to
* TRUE to construct a modal dialog.
*/
DlgCustomCommandsImp::DlgCustomCommandsImp( QWidget* parent )
: CustomizeActionPage(parent)
{
this->setupUi(this);
// paints for active and inactive the same color
QPalette pal = categoryTreeWidget->palette();
pal.setColor(QPalette::Inactive, QPalette::Highlight, pal.color(QPalette::Active, QPalette::Highlight));
pal.setColor(QPalette::Inactive, QPalette::HighlightedText, pal.color(QPalette::Active, QPalette::HighlightedText));
categoryTreeWidget->setPalette( pal );
connect(commandTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
this, SLOT(onDescription(QTreeWidgetItem*)));
connect(categoryTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
this, SLOT(onGroupActivated(QTreeWidgetItem*)));
CommandManager & cCmdMgr = Application::Instance->commandManager();
std::map<std::string,Command*> sCommands = cCmdMgr.getCommands();
GroupMap groupMap;
groupMap.push_back(std::make_pair(QLatin1String("File"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Edit"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Standard-View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Tools"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Window"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Help"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Macros"), qApp->translate("Gui::MacroCommand", "Macros")));
for (std::map<std::string,Command*>::iterator it = sCommands.begin(); it != sCommands.end(); ++it) {
QLatin1String group(it->second->getGroupName());
QString text = qApp->translate(it->second->className(), it->second->getGroupName());
GroupMap::iterator jt;
jt = std::find_if(groupMap.begin(), groupMap.end(), GroupMap_find(group));
if (jt != groupMap.end()) {
if (jt->second.isEmpty())
jt->second = text;
}
else {
groupMap.push_back(std::make_pair(group, text));
}
}
QStringList labels; labels << tr("Category");
categoryTreeWidget->setHeaderLabels(labels);
for (GroupMap::iterator it = groupMap.begin(); it != groupMap.end(); ++it) {
QTreeWidgetItem* item = new QTreeWidgetItem(categoryTreeWidget);
item->setText(0, it->second);
item->setData(0, Qt::UserRole, QVariant(it->first));
}
labels.clear();
labels << tr("Icon") << tr("Command");
commandTreeWidget->setHeaderLabels(labels);
commandTreeWidget->header()->hide();
commandTreeWidget->setIconSize(QSize(32, 32));
commandTreeWidget->header()->setResizeMode(0, QHeaderView::ResizeToContents);
categoryTreeWidget->setCurrentItem(categoryTreeWidget->topLevelItem(0));
}
//**********************************************************************************************************************
int RemoveRareCommand::processList(){
try {
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(listfile); }
string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(listfile)) + "pick" + m->getExtension(listfile);
string outputGroupFileName = thisOutputDir + m->getRootName(m->getSimpleName(groupfile)) + "pick" + m->getExtension(groupfile);
ofstream out, outGroup;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
//you must provide a label because the names in the listfile need to be consistent
string thisLabel = "";
if (allLines) { m->mothurOut("For the listfile you must select one label, using first label in your listfile."); m->mothurOutEndLine(); }
else if (labels.size() > 1) { m->mothurOut("For the listfile you must select one label, using " + (*labels.begin()) + "."); m->mothurOutEndLine(); thisLabel = *labels.begin(); }
else { thisLabel = *labels.begin(); }
InputData input(listfile, "list");
ListVector* list = input.getListVector();
//get first one or the one we want
if (thisLabel != "") {
//use smart distancing
set<string> userLabels; userLabels.insert(thisLabel);
set<string> processedLabels;
string lastLabel = list->getLabel();
while((list != NULL) && (userLabels.size() != 0)) {
if(userLabels.count(list->getLabel()) == 1){
processedLabels.insert(list->getLabel());
userLabels.erase(list->getLabel());
break;
}
if ((m->anyLabelsToProcess(list->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
processedLabels.insert(list->getLabel());
userLabels.erase(list->getLabel());
delete list;
list = input.getListVector(lastLabel);
break;
}
lastLabel = list->getLabel();
delete list;
list = input.getListVector();
}
if (userLabels.size() != 0) {
m->mothurOut("Your file does not include the label " + thisLabel + ". I will use " + lastLabel + "."); m->mothurOutEndLine();
list = input.getListVector(lastLabel);
}
}
//if groupfile is given then use it
GroupMap* groupMap;
if (groupfile != "") {
groupMap = new GroupMap(groupfile); groupMap->readMap();
SharedUtil util;
vector<string> namesGroups = groupMap->getNamesOfGroups();
util.setGroups(Groups, namesGroups);
m->openOutputFile(outputGroupFileName, outGroup);
}
if (list != NULL) {
//make a new list vector
ListVector newList;
newList.setLabel(list->getLabel());
//for each bin
for (int i = 0; i < list->getNumBins(); i++) {
if (m->control_pressed) { if (groupfile != "") { delete groupMap; outGroup.close(); m->mothurRemove(outputGroupFileName); } out.close(); m->mothurRemove(outputFileName); return 0; }
//parse out names that are in accnos file
string binnames = list->get(i);
vector<string> names;
string saveBinNames = binnames;
m->splitAtComma(binnames, names);
vector<string> newGroupFile;
if (groupfile != "") {
vector<string> newNames;
saveBinNames = "";
for(int k = 0; k < names.size(); k++) {
string group = groupMap->getGroup(names[k]);
if (m->inUsersGroups(group, Groups)) {
newGroupFile.push_back(names[k] + "\t" + group);
newNames.push_back(names[k]);
saveBinNames += names[k] + ",";
}
}
names = newNames;
saveBinNames = saveBinNames.substr(0, saveBinNames.length()-1);
}
if (names.size() > nseqs) { //keep bin
newList.push_back(saveBinNames);
for(int k = 0; k < newGroupFile.size(); k++) { outGroup << newGroupFile[k] << endl; }
}
}
//print new listvector
if (newList.getNumBins() != 0) {
wroteSomething = true;
newList.print(out);
}
}
out.close();
if (groupfile != "") { outGroup.close(); outputTypes["group"].push_back(outputGroupFileName); outputNames.push_back(outputGroupFileName); }
if (wroteSomething == false) { m->mothurOut("Your file contains only rare sequences."); m->mothurOutEndLine(); }
outputTypes["list"].push_back(outputFileName); outputNames.push_back(outputFileName);
return 0;
}
catch(exception& e) {
m->errorOut(e, "RemoveRareCommand", "processList");
exit(1);
}
}
int CountTable::createTable(string namefile, string groupfile, bool createGroup) {
try {
if (namefile == "") { m->mothurOut("[ERROR]: namefile cannot be blank when creating a count table.\n"); m->control_pressed = true; }
GroupMap* groupMap;
int numGroups = 0;
groups.clear();
totalGroups.clear();
indexGroupMap.clear();
indexNameMap.clear();
counts.clear();
map<int, string> originalGroupIndexes;
if (groupfile != "") {
hasGroups = true;
groupMap = new GroupMap(groupfile); groupMap->readMap();
numGroups = groupMap->getNumGroups();
groups = groupMap->getNamesOfGroups();
totalGroups.resize(numGroups, 0);
}else if(createGroup) {
hasGroups = true;
numGroups = 1;
groups.push_back("Group1");
totalGroups.resize(numGroups, 0);
}
//sort groups to keep consistent with how we store the groups in groupmap
sort(groups.begin(), groups.end());
for (int i = 0; i < groups.size(); i++) { indexGroupMap[groups[i]] = i; }
m->setAllGroups(groups);
bool error = false;
string name;
uniques = 0;
total = 0;
//open input file
ifstream in;
m->openInputFile(namefile, in);
int total = 0;
while (!in.eof()) {
if (m->control_pressed) { break; }
string firstCol, secondCol;
in >> firstCol; m->gobble(in); in >> secondCol; m->gobble(in);
m->checkName(firstCol);
m->checkName(secondCol);
vector<string> names;
m->splitAtChar(secondCol, names, ',');
map<string, int> groupCounts;
int thisTotal = 0;
if (groupfile != "") {
//set to 0
for (int i = 0; i < groups.size(); i++) { groupCounts[groups[i]] = 0; }
//get counts for each of the users groups
for (int i = 0; i < names.size(); i++) {
string group = groupMap->getGroup(names[i]);
if (group == "not found") { m->mothurOut("[ERROR]: " + names[i] + " is not in your groupfile, please correct."); m->mothurOutEndLine(); error=true; }
else {
map<string, int>::iterator it = groupCounts.find(group);
//if not found, then this sequence is not from a group we care about
if (it != groupCounts.end()) {
it->second++;
thisTotal++;
}
}
}
}else if (createGroup) {
groupCounts["Group1"]=0;
for (int i = 0; i < names.size(); i++) {
string group = "Group1";
groupCounts["Group1"]++; thisTotal++;
}
}else { thisTotal = names.size(); }
//if group info, then read it
vector<int> thisGroupsCount; thisGroupsCount.resize(numGroups, 0);
for (int i = 0; i < numGroups; i++) {
thisGroupsCount[i] = groupCounts[groups[i]];
totalGroups[i] += thisGroupsCount[i];
}
map<string, int>::iterator it = indexNameMap.find(firstCol);
if (it == indexNameMap.end()) {
if (hasGroups) { counts.push_back(thisGroupsCount); }
indexNameMap[firstCol] = uniques;
totals.push_back(thisTotal);
total += thisTotal;
uniques++;
}else {
error = true;
m->mothurOut("[ERROR]: Your count table contains more than 1 sequence named " + firstCol + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();
}
}
in.close();
if (error) { m->control_pressed = true; }
else { //check for zero groups
if (hasGroups) {
for (int i = 0; i < totalGroups.size(); i++) {
if (totalGroups[i] == 0) { m->mothurOut("\nRemoving group: " + groups[i] + " because all sequences have been removed.\n"); removeGroup(groups[i]); i--; }
}
}
}
if (groupfile != "") { delete groupMap; }
return 0;
}
catch(exception& e) {
m->errorOut(e, "CountTable", "createTable");
exit(1);
}
}
/**
* Constructs a DlgCustomKeyboardImp which is a child of 'parent', with the
* name 'name' and widget flags set to 'f'
*
* The dialog will by default be modeless, unless you set 'modal' to
* TRUE to construct a modal dialog.
*/
DlgCustomKeyboardImp::DlgCustomKeyboardImp( QWidget* parent )
: CustomizeActionPage(parent), firstShow(true)
{
this->setupUi(this);
CommandManager & cCmdMgr = Application::Instance->commandManager();
std::map<std::string,Command*> sCommands = cCmdMgr.getCommands();
GroupMap groupMap;
groupMap.push_back(std::make_pair(QLatin1String("File"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Edit"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Standard-View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Tools"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Window"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Help"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Macros"), qApp->translate("Gui::MacroCommand", "Macros")));
for (std::map<std::string,Command*>::iterator it = sCommands.begin(); it != sCommands.end(); ++it) {
QLatin1String group(it->second->getGroupName());
QString text = qApp->translate(it->second->className(), it->second->getGroupName());
GroupMap::iterator jt;
jt = std::find_if(groupMap.begin(), groupMap.end(), GroupMap_find(group));
if (jt != groupMap.end())
jt->second = text;
else
groupMap.push_back(std::make_pair(group, text));
}
int index = 0;
for (GroupMap::iterator it = groupMap.begin(); it != groupMap.end(); ++it, ++index) {
categoryBox->addItem(it->second);
categoryBox->setItemData(index, QVariant(it->first), Qt::UserRole);
}
QStringList labels;
labels << tr("Icon") << tr("Command");
commandTreeWidget->setHeaderLabels(labels);
commandTreeWidget->header()->hide();
commandTreeWidget->setIconSize(QSize(32, 32));
commandTreeWidget->header()->setResizeMode(0, QHeaderView::ResizeToContents);
assignedTreeWidget->setHeaderLabels(labels);
assignedTreeWidget->header()->hide();
}
int ClassifySeqsCommand::execute(){
try {
if (abort == true) { if (calledHelp) { return 0; } return 2; }
string outputMethodTag = method;
if(method == "wang"){ classify = new Bayesian(taxonomyFileName, templateFileName, search, kmerSize, cutoff, iters, rand(), flip, writeShortcuts); }
else if(method == "knn"){ classify = new Knn(taxonomyFileName, templateFileName, search, kmerSize, gapOpen, gapExtend, match, misMatch, numWanted, rand()); }
else if(method == "zap"){
outputMethodTag = search + "_" + outputMethodTag;
if (search == "kmer") { classify = new KmerTree(templateFileName, taxonomyFileName, kmerSize, cutoff); }
else { classify = new AlignTree(templateFileName, taxonomyFileName, cutoff); }
}
else {
m->mothurOut(search + " is not a valid method option. I will run the command using wang.");
m->mothurOutEndLine();
classify = new Bayesian(taxonomyFileName, templateFileName, search, kmerSize, cutoff, iters, rand(), flip, writeShortcuts);
}
if (m->control_pressed) { delete classify; return 0; }
for (int s = 0; s < fastaFileNames.size(); s++) {
m->mothurOut("Classifying sequences from " + fastaFileNames[s] + " ..." ); m->mothurOutEndLine();
string baseTName = m->getSimpleName(taxonomyFileName);
//set rippedTaxName to
string RippedTaxName = "";
bool foundDot = false;
for (int i = baseTName.length()-1; i >= 0; i--) {
if (foundDot && (baseTName[i] != '.')) { RippedTaxName = baseTName[i] + RippedTaxName; }
else if (foundDot && (baseTName[i] == '.')) { break; }
else if (!foundDot && (baseTName[i] == '.')) { foundDot = true; }
}
//if (RippedTaxName != "") { RippedTaxName += "."; }
if (outputDir == "") { outputDir += m->hasPath(fastaFileNames[s]); }
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s]));
variables["[tag]"] = RippedTaxName;
variables["[tag2]"] = outputMethodTag;
string newTaxonomyFile = getOutputFileName("taxonomy", variables);
string newaccnosFile = getOutputFileName("accnos", variables);
string tempTaxonomyFile = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + "taxonomy.temp";
string taxSummary = getOutputFileName("taxsummary", variables);
if ((method == "knn") && (search == "distance")) {
string DistName = getOutputFileName("matchdist", variables);
classify->setDistName(DistName); outputNames.push_back(DistName); outputTypes["matchdist"].push_back(DistName);
}
outputNames.push_back(newTaxonomyFile); outputTypes["taxonomy"].push_back(newTaxonomyFile);
outputNames.push_back(taxSummary); outputTypes["taxsummary"].push_back(taxSummary);
int start = time(NULL);
int numFastaSeqs = 0;
for (int i = 0; i < lines.size(); i++) { delete lines[i]; } lines.clear();
vector<unsigned long long> positions;
#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
positions = m->divideFile(fastaFileNames[s], processors);
for (int i = 0; i < (positions.size()-1); i++) { lines.push_back(new linePair(positions[i], positions[(i+1)])); }
#else
if (processors == 1) {
lines.push_back(new linePair(0, 1000));
}else {
positions = m->setFilePosFasta(fastaFileNames[s], numFastaSeqs);
if (numFastaSeqs < processors) { processors = numFastaSeqs; }
//figure out how many sequences you have to process
int numSeqsPerProcessor = numFastaSeqs / processors;
for (int i = 0; i < processors; i++) {
int startIndex = i * numSeqsPerProcessor;
if(i == (processors - 1)){ numSeqsPerProcessor = numFastaSeqs - i * numSeqsPerProcessor; }
lines.push_back(new linePair(positions[startIndex], numSeqsPerProcessor));
}
}
#endif
if(processors == 1){
numFastaSeqs = driver(lines[0], newTaxonomyFile, tempTaxonomyFile, newaccnosFile, fastaFileNames[s]);
}else{
numFastaSeqs = createProcesses(newTaxonomyFile, tempTaxonomyFile, newaccnosFile, fastaFileNames[s]);
}
if (!m->isBlank(newaccnosFile)) { m->mothurOutEndLine(); m->mothurOut("[WARNING]: mothur reversed some your sequences for a better classification. If you would like to take a closer look, please check " + newaccnosFile + " for the list of the sequences."); m->mothurOutEndLine();
outputNames.push_back(newaccnosFile); outputTypes["accnos"].push_back(newaccnosFile);
}else { m->mothurRemove(newaccnosFile); }
m->mothurOutEndLine();
m->mothurOut("It took " + toString(time(NULL) - start) + " secs to classify " + toString(numFastaSeqs) + " sequences."); m->mothurOutEndLine(); m->mothurOutEndLine();
start = time(NULL);
//read namefile
if(namefile != "") {
m->mothurOut("Reading " + namefileNames[s] + "..."); cout.flush();
nameMap.clear(); //remove old names
m->readNames(namefileNames[s], nameMap);
m->mothurOut(" Done."); m->mothurOutEndLine();
}
//output taxonomy with the unclassified bins added
ifstream inTax;
m->openInputFile(newTaxonomyFile, inTax);
ofstream outTax;
string unclass = newTaxonomyFile + ".unclass.temp";
m->openOutputFile(unclass, outTax);
//get maxLevel from phylotree so you know how many 'unclassified's to add
int maxLevel = classify->getMaxLevel();
//read taxfile - this reading and rewriting is done to preserve the confidence scores.
string name, taxon;
string group = "";
GroupMap* groupMap = NULL;
CountTable* ct = NULL;
PhyloSummary* taxaSum;
if (hasCount) {
ct = new CountTable();
ct->readTable(countfileNames[s], true, false);
taxaSum = new PhyloSummary(ct, relabund, printlevel);
}else {
if (groupfile != "") { group = groupfileNames[s]; groupMap = new GroupMap(group); groupMap->readMap(); }
taxaSum = new PhyloSummary(groupMap, relabund, printlevel);
}
while (!inTax.eof()) {
if (m->control_pressed) { outputTypes.clear(); if (ct != NULL) { delete ct; } if (groupMap != NULL) { delete groupMap; } delete taxaSum; for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } delete classify; return 0; }
inTax >> name >> taxon; m->gobble(inTax);
string newTax = m->addUnclassifieds(taxon, maxLevel, probs);
outTax << name << '\t' << newTax << endl;
if (namefile != "") {
itNames = nameMap.find(name);
if (itNames == nameMap.end()) {
m->mothurOut(name + " is not in your name file please correct."); m->mothurOutEndLine(); exit(1);
}else{
for (int i = 0; i < itNames->second.size(); i++) {
taxaSum->addSeqToTree(itNames->second[i], newTax); //add it as many times as there are identical seqs
}
itNames->second.clear();
nameMap.erase(itNames->first);
}
}else {
taxaSum->addSeqToTree(name, newTax);
}
}
inTax.close();
outTax.close();
m->mothurRemove(newTaxonomyFile);
rename(unclass.c_str(), newTaxonomyFile.c_str());
if (m->control_pressed) { outputTypes.clear(); if (ct != NULL) { delete ct; } if (groupMap != NULL) { delete groupMap; } for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } delete classify; return 0; }
//print summary file
ofstream outTaxTree;
m->openOutputFile(taxSummary, outTaxTree);
taxaSum->print(outTaxTree, output);
outTaxTree.close();
if (ct != NULL) { delete ct; }
if (groupMap != NULL) { delete groupMap; } delete taxaSum;
m->mothurRemove(tempTaxonomyFile);
m->mothurOutEndLine();
m->mothurOut("It took " + toString(time(NULL) - start) + " secs to create the summary file for " + toString(numFastaSeqs) + " sequences."); m->mothurOutEndLine(); m->mothurOutEndLine();
}
delete classify;
m->mothurOutEndLine();
m->mothurOut("Output File Names: "); m->mothurOutEndLine();
for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
m->mothurOutEndLine();
//set taxonomy file as new current taxonomyfile
string current = "";
itTypes = outputTypes.find("taxonomy");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTaxonomyFile(current); }
}
current = "";
itTypes = outputTypes.find("accnos");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setAccnosFile(current); }
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "ClassifySeqsCommand", "execute");
exit(1);
}
}
