DiamondClassifyTaskSettings DiamondClassifyWorker::getSettings(U2OpStatus &os) {
DiamondClassifyTaskSettings settings;
settings.databaseUrl = getValue<QString>(DiamondClassifyWorkerFactory::DATABASE_ATTR_ID);
const Message message = getMessageAndSetupScriptValues(input);
settings.readsUrl = message.getData().toMap()[DiamondClassifyWorkerFactory::INPUT_SLOT].toString();
QString tmpDir = FileAndDirectoryUtils::createWorkingDir(context->workingDir(), FileAndDirectoryUtils::WORKFLOW_INTERNAL, "", context->workingDir());
tmpDir = GUrlUtils::createDirectory(tmpDir + DIAMOND_DIR , "_", os);
settings.classificationUrl = getValue<QString>(DiamondClassifyWorkerFactory::OUTPUT_URL_ATTR_ID);
if (settings.classificationUrl.isEmpty()) {
const MessageMetadata metadata = context->getMetadataStorage().get(message.getMetadataId());
QString fileUrl = metadata.getFileUrl();
settings.classificationUrl = tmpDir + "/" + (fileUrl.isEmpty() ? QString("DIAMOND_%1.txt").arg(NgsReadsClassificationUtils::CLASSIFICATION_SUFFIX)
: NgsReadsClassificationUtils::getBaseFileNameWithSuffixes(fileUrl,QStringList() << "DIAMOND"
<< NgsReadsClassificationUtils::CLASSIFICATION_SUFFIX,"txt", false));
}
settings.classificationUrl = GUrlUtils::rollFileName(settings.classificationUrl, "_");
settings.sensitive = getValue<QString>(DiamondClassifyWorkerFactory::SENSITIVE_ATTR_ID);
settings.topAlignmentsPercentage = getValue<int>(DiamondClassifyWorkerFactory::TOP_ALIGNMENTS_PERCENTAGE_ATTR_ID);
settings.matrix = getValue<QString>(DiamondClassifyWorkerFactory::MATRIX_ATTR_ID);
settings.max_evalue = getValue<double>(DiamondClassifyWorkerFactory::EVALUE_ATTR_ID);
settings.block_size = getValue<double>(DiamondClassifyWorkerFactory::BSIZE_ATTR_ID);
settings.gencode = getValue<unsigned>(DiamondClassifyWorkerFactory::GENCODE_ATTR_ID);
settings.frame_shift = getValue<unsigned>(DiamondClassifyWorkerFactory::FSHIFT_ATTR_ID);
settings.gap_open = getValue<int>(DiamondClassifyWorkerFactory::GO_PEN_ATTR_ID);
settings.gap_extend = getValue<int>(DiamondClassifyWorkerFactory::GE_PEN_ATTR_ID);
settings.index_chunks = getValue<int>(DiamondClassifyWorkerFactory::CHUNKS_ATTR_ID);
settings.num_threads = getValue<int>(DiamondClassifyWorkerFactory::THREADS_ATTR_ID);
return settings;
}
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 * CufflinksWorker::tick() {
if (false == settingsAreCorrect) {
return NULL;
}
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
SAFE_POINT(!inputMessage.isEmpty(), "Internal error: message can't be NULL!", NULL);
QVariantMap data = inputMessage.getData().toMap();
if (settings.fromFile) {
settings.url = data[BaseSlots::URL_SLOT().getId()].toString();
} else {
settings.assemblyId = data[BaseSlots::ASSEMBLY_SLOT().getId()].value<SharedDbiDataHandler>();
}
// Create the task
CufflinksSupportTask* cufflinksSupportTask = new CufflinksSupportTask(settings);
cufflinksSupportTask->addListeners(createLogListeners());
connect(cufflinksSupportTask, SIGNAL(si_stateChanged()), SLOT(sl_cufflinksTaskFinished()));
return cufflinksSupportTask;
}
else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
Task* PFMatrixBuildWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
mtype = PFMatrixWorkerFactory::FREQUENCY_MATRIX_MODEL_TYPE();
QVariantMap data = inputMessage.getData().toMap();
cfg.type = actor->getParameter(TYPE_ATTR)->getAttributeValue<bool>(context) ? PM_DINUCLEOTIDE : PM_MONONUCLEOTIDE;
QVariantMap qm = inputMessage.getData().toMap();
SharedDbiDataHandler msaId = qm.value(BaseSlots::MULTIPLE_ALIGNMENT_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<MAlignmentObject> msaObj(StorageUtils::getMsaObject(context->getDataStorage(), msaId));
SAFE_POINT(!msaObj.isNull(), "NULL MSA Object!", NULL);
const MAlignment &msa = msaObj->getMAlignment();
Task* t = new PFMatrixBuildTask(cfg, msa);
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
} else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
void CuffmergeWorker::takeAnnotations() {
Message m = getMessageAndSetupScriptValues(input);
QVariantMap data = m.getData().toMap();
SAFE_POINT(data.contains(BaseSlots::ANNOTATION_TABLE_SLOT().getId()), "No annotations in a message",);
QVariant annsVar = data[BaseSlots::ANNOTATION_TABLE_SLOT().getId()];
annTableHandlers << StorageUtils::getAnnotationTableHandlers(annsVar);
}
Task * BaseThroughWorker::processNextInputMessage() {
const Message message = getMessageAndSetupScriptValues(input);
U2OpStatusImpl os;
Task *task = createTask(message, os);
if (os.hasError()) {
reportError(os.getError());
}
return task;
}
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()) {
Task* CAP3Worker::tick() {
U2OpStatus2Log os;
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
SAFE_POINT(!inputMessage.isEmpty(), "NULL message!", NULL);
QVariantMap data = inputMessage.getData().toMap();
if (!data.contains(IN_URL_SLOT_ID)) {
os.setError("CAP3 input slot is empty!");
return new FailTask(os.getError());
}
QString dataset = data[BaseSlots::DATASET_SLOT().getId()].toString();
bool runCapForPreviousDataset = false;
if (dataset != currentDatasetName) {
if (!currentDatasetName.isEmpty()) {
runCapForPreviousDataset = true;
}
settings.inputFiles = inputSeqUrls;
inputSeqUrls.clear();
currentDatasetName = dataset;
}
inputSeqUrls << data.value(IN_URL_SLOT_ID).value<QString>();
if (runCapForPreviousDataset) {
return runCap3();
}
settings.inputFiles = inputSeqUrls;
}
else if (input->isEnded()) {
if (!settings.inputFiles.isEmpty()) {
return runCap3();
}
else {
datasetNumber = 0;
setDone();
}
}
return NULL;
}
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* ClustalOWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
cfg.numIterations=actor->getParameter(NUM_ITERATIONS)->getAttributeValue<int>(context);
cfg.maxGuidetreeIterations=actor->getParameter(MAX_GT_ITERATIONS)->getAttributeValue<int>(context);
cfg.maxHMMIterations=actor->getParameter(MAX_HMM_ITERATIONS)->getAttributeValue<int>(context);
cfg.setAutoOptions=actor->getParameter(SET_AUTO)->getAttributeValue<bool>(context);
cfg.numberOfProcessors=AppContext::getAppSettings()->getAppResourcePool()->getIdealThreadCount();
QString path=actor->getParameter(EXT_TOOL_PATH)->getAttributeValue<QString>(context);
if(QString::compare(path, "default", Qt::CaseInsensitive) != 0){
AppContext::getExternalToolRegistry()->getByName(ET_CLUSTALO)->setPath(path);
}
path=actor->getParameter(TMP_DIR_PATH)->getAttributeValue<QString>(context);
if(QString::compare(path, "default", Qt::CaseInsensitive) != 0){
AppContext::getAppSettings()->getUserAppsSettings()->setUserTemporaryDirPath(path);
}
QVariantMap qm = inputMessage.getData().toMap();
SharedDbiDataHandler msaId = qm.value(BaseSlots::MULTIPLE_ALIGNMENT_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<MultipleSequenceAlignmentObject> msaObj(StorageUtils::getMsaObject(context->getDataStorage(), msaId));
SAFE_POINT(!msaObj.isNull(), "NULL MSA Object!", NULL);
const MultipleSequenceAlignment msa = msaObj->getMultipleAlignment();
if (msa->isEmpty()) {
algoLog.error(tr("An empty MSA '%1' has been supplied to ClustalO.").arg(msa->getName()));
return NULL;
}
ClustalOSupportTask* supportTask = new ClustalOSupportTask(msa, GObjectReference(), cfg);
supportTask->addListeners(createLogListeners());
Task *t = new NoFailTaskWrapper(supportTask);
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
} else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
Task* SiteconWriter::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
return NULL;
}
url = getValue<QString>(BaseAttributes::URL_OUT_ATTRIBUTE().getId());
fileMode = actor->getParameter(BaseAttributes::FILE_MODE_ATTRIBUTE().getId())->getAttributeValue<uint>(context);
QVariantMap data = inputMessage.getData().toMap();
SiteconModel model = data.value(SiteconWorkerFactory::SITECON_SLOT.getId()).value<SiteconModel>();
QString anUrl = url;
if (anUrl.isEmpty()) {
anUrl = data.value(BaseSlots::URL_SLOT().getId()).toString();
}
if (anUrl.isEmpty()) {
QString err = tr("Unspecified URL for writing Sitecon");
//if (failFast) {
return new FailTask(err);
/*} else {
algoLog.error(err);
return NULL;
}*/
}
assert(!anUrl.isEmpty());
anUrl = context->absolutePath(anUrl);
int count = ++counter[anUrl];
if (count != 1) {
anUrl = GUrlUtils::prepareFileName(anUrl, count, QStringList("sitecon"));
} else {
anUrl = GUrlUtils::ensureFileExt( anUrl, QStringList("sitecon")).getURLString();
}
ioLog.info(tr("Writing SITECON model to %1").arg(anUrl));
return new SiteconWriteTask(anUrl, model, fileMode);
} else if (input->isEnded()) {
setDone();
}
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 *ConservationPlotWorker::tick() {
U2OpStatus2Log os;
while (inChannel->hasMessage()) {
Message m = getMessageAndSetupScriptValues(inChannel);
QVariantMap data = m.getData().toMap();
if (!data.contains(ANNOT_SLOT_ID)) {
os.setError("Annotations slot is empty");
return new FailTask(os.getError());
}
plotData = StorageUtils::getAnnotationTableHandlers(data[ANNOT_SLOT_ID]);
}
if (!inChannel->isEnded()) {
return NULL;
}
ConservationPlotSettings settings = createConservationPlotSettings(os);
if (os.hasError()) {
return new FailTask(os.getError());
}
ConservationPlotTask* t = new ConservationPlotTask(settings, context->getDataStorage(), plotData);
t->addListeners(createLogListeners());
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
if (inChannel->isEnded()) {
setDone();
}
return NULL;
}
Task* ClustalWWorker::tick() {
if (input->hasMessage()) {
Message inputMessage = getMessageAndSetupScriptValues(input);
if (inputMessage.isEmpty()) {
output->transit();
return NULL;
}
cfg.gapOpenPenalty=actor->getParameter(GAP_OPEN_PENALTY)->getAttributeValue<float>(context);
cfg.gapExtenstionPenalty=actor->getParameter(GAP_EXT_PENALTY)->getAttributeValue<float>(context);
cfg.gapDist=actor->getParameter(GAP_DIST)->getAttributeValue<float>(context);
cfg.endGaps=actor->getParameter(END_GAPS)->getAttributeValue<bool>(context);
cfg.noHGaps=actor->getParameter(NO_HGAPS)->getAttributeValue<bool>(context);
cfg.noPGaps=actor->getParameter(NO_PGAPS)->getAttributeValue<bool>(context);
if(actor->getParameter(ITERATION)->getAttributeValue<int>(context) != 0){
if(actor->getParameter(ITERATION)->getAttributeValue<int>(context) == 1){
cfg.iterationType="TREE";
}else if(actor->getParameter(ITERATION)->getAttributeValue<int>(context) == 2){
cfg.iterationType="ALIGNMENT";
}
if(actor->getParameter(NUM_ITERATIONS)->getAttributeValue<int>(context) != 3){
cfg.numIterations=actor->getParameter(NUM_ITERATIONS)->getAttributeValue<int>(context);
}
}
if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == -1){
if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 0){
cfg.matrix="IUB";
}else if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 1){
cfg.matrix="CLUSTALW";
}else if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 2){
cfg.matrix="BLOSUM";
}else if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 3){
cfg.matrix="PAM";
}else if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 4){
cfg.matrix="GONNET";
}else if(actor->getParameter(MATRIX)->getAttributeValue<int>(context) == 5){
cfg.matrix="ID";
}
}
QString path=actor->getParameter(EXT_TOOL_PATH)->getAttributeValue<QString>(context);
if(QString::compare(path, "default", Qt::CaseInsensitive) != 0){
AppContext::getExternalToolRegistry()->getByName(ET_CLUSTAL)->setPath(path);
}
path=actor->getParameter(TMP_DIR_PATH)->getAttributeValue<QString>(context);
if(QString::compare(path, "default", Qt::CaseInsensitive) != 0){
AppContext::getAppSettings()->getUserAppsSettings()->setUserTemporaryDirPath(path);
}
QVariantMap qm = inputMessage.getData().toMap();
SharedDbiDataHandler msaId = qm.value(BaseSlots::MULTIPLE_ALIGNMENT_SLOT().getId()).value<SharedDbiDataHandler>();
QScopedPointer<MultipleSequenceAlignmentObject> msaObj(StorageUtils::getMsaObject(context->getDataStorage(), msaId));
SAFE_POINT(!msaObj.isNull(), "NULL MSA Object!", NULL);
const MultipleSequenceAlignment msa = msaObj->getMultipleAlignment();
if (msa->isEmpty()) {
algoLog.error(tr("An empty MSA '%1' has been supplied to ClustalW.").arg(msa->getName()));
return NULL;
}
ClustalWSupportTask* supportTask = new ClustalWSupportTask(msa, GObjectReference(), cfg);
supportTask->addListeners(createLogListeners());
Task *t = new NoFailTaskWrapper(supportTask);
connect(t, SIGNAL(si_stateChanged()), SLOT(sl_taskFinished()));
return t;
} else if (input->isEnded()) {
setDone();
output->setEnded();
}
return NULL;
}
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;
}
