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;
}
QList<Task*> DefaultConvertFileTask::onSubTaskFinished(Task *subTask) {
QList<Task*> result;
CHECK(!subTask->hasError() && !subTask->isCanceled(), result);
CHECK(!hasError() && !isCanceled(), result);
if (saveTask == subTask) {
return result;
}
SAFE_POINT_EXT(loadTask == subTask, setError("Unknown subtask"), result);
bool mainThread = false;
Document *srcDoc = loadTask->getDocument(mainThread);
SAFE_POINT_EXT(NULL != srcDoc, setError("NULL document"), result);
DocumentFormatRegistry *dfr = AppContext::getDocumentFormatRegistry();
DocumentFormat *df = dfr->getFormatById(targetFormat);
SAFE_POINT_EXT(NULL != df, setError("NULL document format"), result);
QSet<GObjectType> selectedFormatObjectsTypes = df->getSupportedObjectTypes();
QSet<GObjectType> inputFormatObjectTypes;
QListIterator<GObject*> objectsIterator(srcDoc->getObjects());
while (objectsIterator.hasNext()) {
GObject *obj = objectsIterator.next();
inputFormatObjectTypes << obj->getGObjectType();
}
inputFormatObjectTypes.intersect(selectedFormatObjectsTypes);
if (inputFormatObjectTypes.empty()) {
setError(tr("The formats are not compatible: %1 and %2").arg(srcDoc->getDocumentFormatId()).arg(targetFormat));
return result;
}
QString ext = targetFormat;
if (!df->getSupportedDocumentFileExtensions().isEmpty()) {
ext = df->getSupportedDocumentFileExtensions().first();
}
if (targetUrl.isEmpty()) {
QString fileName = srcDoc->getName() + "." + ext;
targetUrl = GUrlUtils::rollFileName(workingDir + fileName, QSet<QString>());
} else {
if (QFileInfo(targetFormat).suffix() != ext) {
targetUrl += "." + ext;
}
targetUrl = GUrlUtils::rollFileName(targetUrl, QSet<QString>());
}
IOAdapterFactory *iof = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(IOAdapterUtils::url2io(srcDoc->getURL()));
Document *dstDoc = srcDoc->getSimpleCopy(df, iof, srcDoc->getURL());
saveTask = new SaveDocumentTask(dstDoc, iof, targetUrl);
result << saveTask;
return result;
}
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;
}
QVariant FileExtensionRelation::getAffectResult(const QVariant &influencingValue, const QVariant &dependentValue,
DelegateTags * /*infTags*/, DelegateTags *depTags) const {
QString newFormatId = influencingValue.toString();
DocumentFormat *newFormat = AppContext::getDocumentFormatRegistry()->getFormatById(newFormatId);
updateDelegateTags(influencingValue, depTags);
QString urlStr = dependentValue.toString();
if (urlStr.isEmpty()) {
return "";
}
QString extension;
if (NULL == newFormat) {
extension = newFormatId;
} else {
extension = newFormat->getSupportedDocumentFileExtensions().first();
}
QString lastSuffix = GUrl(urlStr).lastFileSuffix();
bool withGz = false;
if ("gz" == lastSuffix) {
int dotPos = urlStr.length() - lastSuffix.length() - 1;
if ((dotPos >= 0) && (QChar('.') == urlStr[dotPos])) {
withGz = true;
urlStr = urlStr.left(dotPos);
lastSuffix = GUrl(urlStr).lastFileSuffix();
}
}
DocumentFormat *currentFormat = AppContext::getDocumentFormatRegistry()->selectFormatByFileExtension(lastSuffix);
QString currentFormatId("");
if(currentFormat){
currentFormatId = currentFormat->getFormatId();
}
bool foundExt = false;
if (0 == QString::compare(lastSuffix, "csv", Qt::CaseInsensitive)) {
foundExt = true;
}else if (NULL == currentFormat) {
foundExt = (lastSuffix == currentFormatId);
} else {
QStringList extensions(currentFormat->getSupportedDocumentFileExtensions());
if (NULL == newFormat) {
extensions << newFormatId;
} else {
extensions << newFormat->getSupportedDocumentFileExtensions();
}
foreach (QString supExt, extensions) {
if (lastSuffix == supExt) {
foundExt = true;
break;
}
}
}
if (foundExt) {
int dotPos = urlStr.length() - lastSuffix.length() - 1;
if ((dotPos >= 0) && (QChar('.') == urlStr[dotPos])) { //yes, lastSuffix is a correct extension with .
urlStr = urlStr.left(dotPos);
}
}
urlStr += "." + extension;
if (withGz) {
urlStr += ".gz";
}
return urlStr;
}
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);
}