Task* HMM3SearchWorker::tick() {
while (hmmPort->hasMessage()) {
hmms << hmmPort->get().getData().toMap().value(HMM3Lib::HMM3_SLOT.getId()).value<const P7_HMM*>();
}
if (!hmmPort->isEnded()) { // || hmms.isEmpty() || !seqPort->hasMessage()
return NULL;
}
if (seqPort->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(seqPort);
if (inputMessage.isEmpty() || hmms.isEmpty()) {
output->transit();
return NULL;
}
SharedDbiDataHandler seqId = inputMessage.getData().toMap().value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence dnaSequence = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
if (dnaSequence.alphabet->getType() != DNAAlphabet_RAW) {
QList<Task*> subtasks;
UHMM3SearchTaskSettings settings;
settings.inner = cfg;
foreach(const P7_HMM* hmm, hmms) {
subtasks << new UHMM3SWSearchTask (hmm, dnaSequence, settings);
}
Task* CDSearchWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
SharedDbiDataHandler seqId = inputMessage.getData().toMap().value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence seq = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
settings.query = seq.seq;
settings.alp = seq.alphabet;
if (!settings.alp->isAmino()) {
QString err = "Required amino acid input sequence";
return new FailTask(err);
}
settings.ev = actor->getParameter(EVALUE_ATTR)->getAttributeValue<float>(context);
settings.dbName = actor->getParameter(DATABASE_ATTR)->getAttributeValue<QString>(context);
bool local = actor->getParameter(LOCAL_ATTR)->getAttributePureValue().toBool();
CDSearchFactory* factory = NULL;
if (local) {
factory = AppContext::getCDSFactoryRegistry()->getFactory(CDSearchFactoryRegistry::LocalSearch);
if (!factory) {
QString err = tr("'External tools' plugin has to be loaded.");
return new FailTask(err);
}
settings.localDbFolder = actor->getParameter(DB_PATH_ATTR)->getAttributeValue<QString>(context);
} else { // remote
factory = AppContext::getCDSFactoryRegistry()->getFactory(CDSearchFactoryRegistry::RemoteSearch);
if (!factory) {
QString err = tr("'Remote blast' plugin has to be loaded.");
return new FailTask(err);
}
}
cds = factory->createCDSearch(settings);
Task* t = cds->getTask();
connect(new TaskSignalMapper(t), SIGNAL(si_taskFinished(Task*)), SLOT(sl_taskFinished(Task*)));
return t;
} else if (input->isEnded()) {
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);
}
Task* CollocationWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
cfg.distance = actor->getParameter(LEN_ATTR)->getAttributeValue<int>(context);
cfg.st = actor->getParameter(FIT_ATTR)->getAttributeValue<bool>(context) ?
CollocationsAlgorithm::NormalSearch : CollocationsAlgorithm::PartialSearch;
cfg.resultAnnotationsName = actor->getParameter(NAME_ATTR)->getAttributeValue<QString>(context);
QString annotations = actor->getParameter(ANN_ATTR)->getAttributeValue<QString>(context);
QSet<QString> names = QSet<QString>::fromList(annotations.split(QRegExp("\\W+"), QString::SkipEmptyParts));
QVariantMap qm = inputMessage.getData().toMap();
QString resultType = actor->getParameter(TYPE_ATTR)->getAttributeValue<QString>(context);
cfg.includeBoundaries = actor->getParameter(INC_BOUNDARY_ATTR)->getAttributeValue<bool>(context);
SharedDbiDataHandler seqId = qm.value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
CHECK(NULL != seqObj.data(), NULL);
const QList<SharedAnnotationData> atl = StorageUtils::getAnnotationTable(context->getDataStorage(), qm.value(FEATURE_TABLE_SLOT));
qint64 seqLength = seqObj->getSequenceLength();
if ((0 != seqLength) && !atl.isEmpty()) {
cfg.searchRegion.length = seqLength;
bool keepSourceAnns = (COPY_TYPE_ATTR == resultType);
Task* t = new CollocationSearchTask(atl, names, cfg, keepSourceAnns);
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
} else {
// void tick
output->put(Message(BaseTypes::ANNOTATION_TABLE_TYPE(), QVariant()));
if (input->isEnded()) {
output->setEnded();
}
return NULL;
}
} else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
Task* PWMatrixSearchWorker::tick() {
while (modelPort->hasMessage()) {
models << modelPort->get().getData().toMap().value(PWMatrixWorkerFactory::WMATRIX_SLOT.getId()).value<PWMatrix>();
}
if (!modelPort->isEnded()) {
return NULL;
}
if (dataPort->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(dataPort);
if (inputMessage.isEmpty() || models.isEmpty()) {
output->transit();
return NULL;
}
QVariantMap map = inputMessage.getData().toMap();
SharedDbiDataHandler seqId = map.value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence seq = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
if (!seq.isNull() && seq.alphabet->getType() == DNAAlphabet_NUCL) {
WeightMatrixSearchCfg config(cfg);
config.complOnly = (strand < 0);
if (strand <= 0) {
DNATranslation* compTT = AppContext::getDNATranslationRegistry()->
lookupComplementTranslation(seq.alphabet);
if (compTT != NULL) {
config.complTT = compTT ;
}
}
QList<Task*> subtasks;
foreach(PWMatrix model, models) {
subtasks << new WeightMatrixSingleSearchTask(model, seq.seq, config, 0);
}
Task* DNAStatWorker::tick() {
while (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
QVariantMap qm = inputMessage.getData().toMap();
SharedDbiDataHandler seqId = qm.value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (NULL == seqObj.data()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence dna = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
if(!dna.alphabet->isNucleic()) {
return new FailTask(tr("Sequence must be nucleotide"));
}
QList<SharedAnnotationData> res;
SharedAnnotationData gcAnn(new AnnotationData);
gcAnn->name = "statistics";
gcAnn->location->regions << U2Region( 0, dna.seq.size());
if (actor->getParameter(GCCONTENT)->getAttributeValue<bool>(context)) {
float gcContent = calcGCContent(dna.seq);
gcAnn->qualifiers.push_back(U2Qualifier("gc-content", QString::number(gcContent*100) + "%"));
}
if (actor->getParameter(GC1CONTENT)->getAttributeValue<bool>(context)) {
float gc1Content = calcGC1Content(dna.seq);
gcAnn->qualifiers.push_back(U2Qualifier("gc1-content", QString::number(gc1Content*100) + "%"));
}
if (actor->getParameter(GC2CONTENT)->getAttributeValue<bool>(context)) {
float gc2Content = calcGC2Content(dna.seq);
gcAnn->qualifiers.push_back(U2Qualifier("gc2-content", QString::number(gc2Content*100) + "%"));
}
if (actor->getParameter(GC3CONTENT)->getAttributeValue<bool>(context)) {
float gc3Content = calcGC3Content(dna.seq);
gcAnn->qualifiers.push_back(U2Qualifier("gc3-content", QString::number(gc3Content*100) + "%"));
}
if (gcAnn->qualifiers.isEmpty()) {
return new FailTask(tr("No statistics was selected"));
}
res << gcAnn;
const SharedDbiDataHandler tableId = context->getDataStorage()->putAnnotationTable(res);
const QVariant v = qVariantFromValue<SharedDbiDataHandler>(tableId);
output->put(Message(BaseTypes::ANNOTATION_TABLE_TYPE(), v));
}
if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
Task* ORFWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->put(Message::getEmptyMapMessage());
}
cfg.strand = getStrand(actor->getParameter(BaseAttributes::STRAND_ATTRIBUTE().getId())->getAttributeValue<QString>(context));
cfg.minLen = actor->getParameter(LEN_ATTR)->getAttributeValue<int>(context);
cfg.mustFit = actor->getParameter(FIT_ATTR)->getAttributeValue<bool>(context);
cfg.mustInit = actor->getParameter(INIT_ATTR)->getAttributeValue<bool>(context);
cfg.allowAltStart = actor->getParameter(ALT_ATTR)->getAttributeValue<bool>(context);
cfg.includeStopCodon = actor->getParameter(ISC_ATTR)->getAttributeValue<bool>(context);
cfg.maxResult2Search = actor->getParameter(RES_ATTR)->getAttributeValue<int>(context);
resultName = actor->getParameter(NAME_ATTR)->getAttributeValue<QString>(context);
if(resultName.isEmpty()) {
algoLog.error(tr("ORF: result name is empty, default name used"));
resultName = "misc_feature";
}
transId = actor->getParameter(ID_ATTR)->getAttributeValue<QString>(context);
if (cfg.minLen < 0) {
algoLog.error(tr("ORF: Incorrect value: min-length must be greater then zero"));
return new FailTask(tr("Incorrect value: min-length must be greater then zero"));
}
SharedDbiDataHandler seqId = inputMessage.getData().toMap().value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
const DNAAlphabet* alphabet = seqObj->getAlphabet();
if (alphabet && alphabet->getType() == DNAAlphabet_NUCL) {
ORFAlgorithmSettings config(cfg);
config.searchRegion.length = seqObj->getSequenceLength();
if (config.strand != ORFAlgorithmStrand_Direct) {
DNATranslation* compTT = AppContext::getDNATranslationRegistry()->
lookupComplementTranslation(alphabet);
if (compTT != NULL) {
config.complementTT = compTT;
} else {
config.strand = ORFAlgorithmStrand_Direct;
}
}
config.proteinTT = AppContext::getDNATranslationRegistry()->
lookupTranslation(alphabet, DNATranslationType_NUCL_2_AMINO, transId);
if (config.proteinTT) {
Task* t = new ORFFindTask(config,seqObj->getEntityRef());
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
}
}
QString err = tr("Bad sequence supplied to ORFWorker: %1").arg(seqObj->getSequenceName());
return new FailTask(err);
} else if (input->isEnded()) {
output->setEnded();
setDone();
}
return NULL;
}
Task* RepeatWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
cfg.algo = RFAlgorithm(actor->getParameter(ALGO_ATTR)->getAttributeValue<int>(context));
cfg.minLen = actor->getParameter(LEN_ATTR)->getAttributeValue<int>(context);
if(actor->getParameter(USE_MIN_DISTANCE_ATTR)->getAttributeValue<bool>(context)){
cfg.minDist = actor->getParameter(MIN_DIST_ATTR)->getAttributeValue<int>(context);
}else{
cfg.minDist = 0;
}
if(actor->getParameter(USE_MAX_DISTANCE_ATTR)->getAttributeValue<bool>(context)){
cfg.maxDist = actor->getParameter(MAX_DIST_ATTR)->getAttributeValue<int>(context);
}else{
cfg.maxDist = INT_MAX;
}
int identity = actor->getParameter(IDENTITY_ATTR)->getAttributeValue<int>(context);
cfg.setIdentity(identity);
cfg.nThreads = actor->getParameter(THREADS_ATTR)->getAttributeValue<int>(context);
cfg.inverted = actor->getParameter(INVERT_ATTR)->getAttributeValue<bool>(context);
cfg.filter = RepeatsFilterAlgorithm(actor->getParameter(NESTED_ATTR)->getAttributeValue<int>(context));
cfg.excludeTandems = actor->getParameter(TANMEDS_ATTR)->getAttributeValue<bool>(context);
resultName = actor->getParameter(NAME_ATTR)->getAttributeValue<QString>(context);
if(resultName.isEmpty()){
resultName = "repeat_unit";
algoLog.error(tr("result name is empty, default name used"));
}
if(identity > 100 || identity < 0){
algoLog.error(tr("Incorrect value: identity value must be between 0 and 100"));
return new FailTask(tr("Incorrect value: identity value must be between 0 and 100"));
}
QVariantMap map = inputMessage.getData().toMap();
SharedDbiDataHandler seqId = map.value(BaseSlots::DNA_SEQUENCE_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<U2SequenceObject> seqObj(StorageUtils::getSequenceObject(context->getDataStorage(), seqId));
if (seqObj.isNull()) {
return NULL;
}
U2OpStatusImpl os;
DNASequence seq = seqObj->getWholeSequence(os);
CHECK_OP(os, new FailTask(os.getError()));
if(cfg.minDist < 0){
algoLog.error(tr("Incorrect value: minimal distance must be greater then zero"));
return new FailTask(tr("Incorrect value: minimal distance must be greater then zero"));
}
if (!seq.alphabet->isNucleic()) {
QString err = tr("Sequence alphabet is not nucleic!");
return new FailTask(err);
}
Task* t = new FindRepeatsToAnnotationsTask(cfg, seq, resultName, QString(), "", GObjectReference());
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
} else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}