void MafftAddToAlignmentTask::prepare() {
algoLog.info(tr("Align sequences to an existing alignment by MAFFT started"));
MSAUtils::removeColumnsWithGaps(inputMsa, inputMsa->getNumRows());
tmpDirUrl = ExternalToolSupportUtils::createTmpDir("add_to_alignment", stateInfo);
QString tmpAddedUrl = generateTmpFileUrl(tmpDirUrl + QDir::separator() + "XXXXXXXXXXXXXXXX_add.fa");;
DocumentFormatRegistry *dfr = AppContext::getDocumentFormatRegistry();
DocumentFormat *dfd = dfr->getFormatById(BaseDocumentFormats::FASTA);
Document* tempDocument = dfd->createNewLoadedDocument(IOAdapterUtils::get(BaseIOAdapters::LOCAL_FILE), GUrl(tmpAddedUrl), stateInfo);
QListIterator<QString> namesIterator(settings.addedSequencesNames);
int currentRowNumber = inputMsa->getNumRows();
foreach(const U2EntityRef& sequenceRef, settings.addedSequencesRefs) {
uniqueIdsToNames[QString::number(currentRowNumber)] = namesIterator.next();
U2SequenceObject seqObject(QString::number(currentRowNumber), sequenceRef);
GObject* cloned = seqObject.clone(tempDocument->getDbiRef(), stateInfo);
CHECK_OP(stateInfo, );
cloned->setGObjectName(QString::number(currentRowNumber));
tempDocument->addObject(cloned);
currentRowNumber++;
}
saveSequencesDocumentTask = new SaveDocumentTask(tempDocument, tempDocument->getIOAdapterFactory(), tmpAddedUrl, SaveDocFlags(SaveDoc_Roll) | SaveDoc_DestroyAfter | SaveDoc_ReduceLoggingLevel);
addSubTask(saveSequencesDocumentTask);
QString tmpExistingAlignmentUrl = generateTmpFileUrl(tmpDirUrl + QDir::separator() + "XXXXXXXXXXXXXXXX.fa");
saveAlignmentDocumentTask = new SaveMSA2SequencesTask(inputMsa, tmpExistingAlignmentUrl, false, BaseDocumentFormats::FASTA);
addSubTask(saveAlignmentDocumentTask);
}
QList<Task*> PairwiseAlignmentHirschbergTask::onSubTaskFinished(Task *subTask) {
QList<Task*> res;
if (hasError() || isCanceled()) {
return res;
}
if (subTask->hasError() || subTask->isCanceled()) {
return res;
}
if (subTask == kalignSubTask) {
if (settings->inNewWindow == true) {
TaskStateInfo localStateInfo;
Project * currentProject = AppContext::getProject();
DocumentFormat * format = AppContext::getDocumentFormatRegistry()->getFormatById(BaseDocumentFormats::CLUSTAL_ALN);
Document * alignmentDoc = NULL;
QString newFileUrl = settings->resultFileName.getURLString();
changeGivenUrlIfDocumentExists(newFileUrl, currentProject);
alignmentDoc = format->createNewLoadedDocument(IOAdapterUtils::get(BaseIOAdapters::LOCAL_FILE), GUrl(newFileUrl), localStateInfo);
CHECK_OP(localStateInfo, res);
MAlignment resultMa = kalignSubTask->resultMA;
MAlignmentObject * docObject = MAlignmentImporter::createAlignment(alignmentDoc->getDbiRef(), resultMa, localStateInfo);
CHECK_OP(localStateInfo, res);
alignmentDoc->addObject(docObject);
SaveDocFlags flags = SaveDoc_Overwrite;
flags |= SaveDoc_OpenAfter;
res << new SaveDocumentTask(alignmentDoc, flags);
} else { //in current window
U2OpStatus2Log os;
DbiConnection con(settings->msaRef.dbiRef, os);
CHECK_OP(os, res);
QList<U2MsaRow> rows = con.dbi->getMsaDbi()->getRows(settings->msaRef.entityId, os);
CHECK_OP(os, res);
U2UseCommonUserModStep userModStep(settings->msaRef, os);
Q_UNUSED(userModStep);
SAFE_POINT_OP(os, res);
for (int rowNumber = 0; rowNumber < rows.length(); ++rowNumber) {
if (rows[rowNumber].sequenceId == settings->firstSequenceRef.entityId) {
con.dbi->getMsaDbi()->updateGapModel(settings->msaRef.entityId, rows[rowNumber].rowId, kalignSubTask->resultMA.getRow(0).getGapModel(), os);
CHECK_OP(os, res);
}
if (rows[rowNumber].sequenceId == settings->secondSequenceRef.entityId) {
con.dbi->getMsaDbi()->updateGapModel(settings->msaRef.entityId, rows[rowNumber].rowId, kalignSubTask->resultMA.getRow(1).getGapModel(), os);
CHECK_OP(os, res);
}
}
}
}
return res;
}
void ExportAlignmentTask::run() {
DocumentFormatRegistry* r = AppContext::getDocumentFormatRegistry();
DocumentFormat* f = r->getFormatById(format);
IOAdapterFactory* iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(IOAdapterUtils::url2io(fileName));
resultDocument = f->createNewLoadedDocument(iof, fileName, stateInfo);
CHECK_OP(stateInfo, );
MultipleSequenceAlignmentObject* obj = MultipleSequenceAlignmentImporter::createAlignment(resultDocument->getDbiRef(), ma, stateInfo);
CHECK_OP(stateInfo, );
resultDocument->addObject(obj);
f->storeDocument(resultDocument, stateInfo);
}
SaveDocumentTask * TopHatSupportTask::createSaveTask(const QString &url, QPointer<Document> &doc, const QList<Workflow::SharedDbiDataHandler> &seqs) {
DocumentFormat* docFormat = AppContext::getDocumentFormatRegistry()->getFormatById(BaseDocumentFormats::FASTQ);
doc = docFormat->createNewLoadedDocument(IOAdapterUtils::get(BaseIOAdapters::LOCAL_FILE), GUrl(url), stateInfo);
CHECK_OP(stateInfo, NULL);
doc->setDocumentOwnsDbiResources(false);
// Add all sequence objects to the document
foreach (Workflow::SharedDbiDataHandler seqId, seqs) {
U2SequenceObject* seqObj(Workflow::StorageUtils::getSequenceObject(settings.storage(), seqId));
if (NULL == seqObj) {
stateInfo.setError(tr("An unexpected error has occurred during preparing the TopHat task!"));
taskLog.trace(tr("Preparing TopHatSupportTask internal error: unable to get a sequence object!"));
return NULL;
}
doc->addObject(seqObj);
}
QList<Task*> DNASequenceGeneratorTask::onGenerateTaskFinished( ) {
QList<Task *> resultTasks;
SAFE_POINT( generateTask->isFinished( ) && !generateTask->getStateInfo( ).isCoR( ),
"Invalid task encountered", resultTasks );
IOAdapterFactory *iof = AppContext::getIOAdapterRegistry( )->getIOAdapterFactoryById(
IOAdapterUtils::url2io( cfg.getOutUrlString( ) ) );
if (cfg.saveDoc) {
DocumentFormat *format = AppContext::getDocumentFormatRegistry()->getFormatById(cfg.getDocumentFormatId());
Document* doc = format->createNewLoadedDocument(iof, cfg.getOutUrlString(), stateInfo);
CHECK_OP( stateInfo, resultTasks );
const QSet<QString> &supportedFormats = format->getSupportedObjectTypes( );
const bool isSequenceFormat = supportedFormats.contains( GObjectTypes::SEQUENCE );
if ( isSequenceFormat) {
addSequencesToSeqDoc( doc );
} else { // consider alignment format
SAFE_POINT( supportedFormats.contains( GObjectTypes::MULTIPLE_SEQUENCE_ALIGNMENT ),
"Unexpected format encountered", resultTasks );
addSequencesToMsaDoc( doc );
}
saveTask = new SaveDocumentTask(doc, SaveDoc_Overwrite);
resultTasks << saveTask;
} else { // TODO: avoid high memory consumption here
const DNAAlphabet *alp = cfg.getAlphabet( );
SAFE_POINT( NULL != alp, "Generated sequence has invalid alphabet", resultTasks );
const U2DbiRef dbiRef = generateTask->getDbiRef( );
const QString baseSeqName = cfg.getSequenceName( );
QList<U2Sequence> seqs = generateTask->getResults( );
for ( int sequenceNum = 0, totalSeqCount = seqs.size( ); sequenceNum < totalSeqCount;
++sequenceNum )
{
const QString seqName = ( 1 < totalSeqCount )
? ( baseSeqName + " " + QString::number( sequenceNum + 1 ) ) : baseSeqName;
DbiConnection con( dbiRef, stateInfo );
CHECK_OP( stateInfo, resultTasks );
const QByteArray seqContent = con.dbi->getSequenceDbi( )->getSequenceData(
seqs[sequenceNum].id, U2_REGION_MAX, stateInfo );
results << DNASequence( seqName, seqContent, alp );
}
}
return resultTasks;
}
void ExportMSA2SequencesTask::run() {
DocumentFormatRegistry* r = AppContext::getDocumentFormatRegistry();
DocumentFormat* f = r->getFormatById(format);
IOAdapterFactory* iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(IOAdapterUtils::url2io(url));
resultDocument = f->createNewLoadedDocument(iof, url, stateInfo);
CHECK_OP(stateInfo, );
QList<DNASequence> lst = MSAUtils::ma2seq(ma, trimAli);
QSet<QString> usedNames;
foreach(DNASequence s, lst) {
QString name = s.getName();
if (usedNames.contains(name)) {
name = TextUtils::variate(name, " ", usedNames, false, 1);
s.setName(name);
}
U2EntityRef seqRef = U2SequenceUtils::import(stateInfo, resultDocument->getDbiRef(), s);
CHECK_OP(stateInfo, );
resultDocument->addObject(new U2SequenceObject(name, seqRef));
usedNames.insert(name);
}
Document * ImportAnnotationsFromCSVTask::prepareNewDocument(const QMap<QString, QList<SharedAnnotationData> > &groups) {
DocumentFormat *format = AppContext::getDocumentFormatRegistry()->getFormatById(config.formatId);
CHECK(NULL != format, NULL);
IOAdapterId ioId = IOAdapterUtils::url2io(config.dstFile);
IOAdapterFactory* iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(ioId);
U2OpStatus2Log os;
Document *result = format->createNewLoadedDocument(iof, config.dstFile, os);
CHECK_OP(os, NULL);
AnnotationTableObject* ao = new AnnotationTableObject("Annotations", result->getDbiRef());
foreach (const QString &groupName, groups.keys()) {
ao->addAnnotations(groups[groupName], groupName);
}
ao->setModified(false);
result->addObject(ao);
adjustRelations(ao);
return result;
}
void GTest_uHMMERSearch::prepare() {
Document* doc = getContext<Document>(this, seqDocCtxName);
if (doc == NULL) {
stateInfo.setError( QString("context not found %1").arg(seqDocCtxName) );
return;
}
QList<GObject*> list = doc->findGObjectByType(GObjectTypes::SEQUENCE);
if (list.size() == 0) {
stateInfo.setError( QString("container of object with type \"%1\" is empty").arg(GObjectTypes::SEQUENCE) );
return;
}
GObject *obj = list.first();
if(obj==NULL){
stateInfo.setError( QString("object with type \"%1\" not found").arg(GObjectTypes::SEQUENCE) );
return;
}
assert(obj!=NULL);
U2SequenceObject * mySequence = qobject_cast<U2SequenceObject*>(obj);
if(mySequence==NULL){
stateInfo.setError( QString("error can't cast to sequence from GObject") );
return;
}
UHMMSearchSettings s;
if (expertOptions){
s.globE = evalueCutoff;
s.eValueNSeqs = number_of_seq;
s.domE = domEvalueCutoff;
s.domT = minScoreCutoff;
}
QString env_algo = env->getVar(ENV_HMMSEARCH_ALGORITHM_NAME);
if( !env_algo.isEmpty() ) {
if( ENV_HMMSEARCH_ALGORITHM_SSE == env_algo ) {
#if !defined(HMMER_BUILD_WITH_SSE2)
stateInfo.setError( QString("SSE2 was not enabled in this build") );
return;
#endif
s.alg = HMMSearchAlgo_SSEOptimized;
} else if( ENV_HMMSEARCH_ALGORITHM_CELL == env_algo ) {
#if !defined UGENE_CELL
stateInfo.setError( QString("HMMER-Cell was not enabled in this build") );
return;
#endif
s.alg = HMMSearchAlgo_CellOptimized;
} else {
stateInfo.setError( QString("unknown hmmsearch algorithm is selected") );
return;
}
}
if(customHmmSearchChunk) {
s.searchChunkSize = hmmSearchChunk;
}
QString annotationName = "hmm_signal";
QString url = env->getVar("TEMP_DATA_DIR")+"/uhmmsearch/"+resultDocName;
IOAdapterFactory* iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(IOAdapterUtils::url2io(url));
DocumentFormat* df = AppContext::getDocumentFormatRegistry()->getFormatById(BaseDocumentFormats::PLAIN_GENBANK);
assert(aDoc == NULL);
aDoc = df->createNewLoadedDocument(iof, url, stateInfo);
CHECK_OP(stateInfo, );
AnnotationTableObject *ao = new AnnotationTableObject( "Annotations", aDoc->getDbiRef( ) );
aDoc->addObject(ao);
DNASequence dnaSequence = mySequence->getWholeSequence(stateInfo);
CHECK_OP(stateInfo, );
searchTask = new HMMSearchToAnnotationsTask(env->getVar("COMMON_DATA_DIR")+"/"+hmmFileName, dnaSequence, ao, annotationName, "", U2FeatureTypes::MiscSignal, annotationName, s);
addSubTask(searchTask);
}