DataTypePtr const SiteconWorkerFactory::SITECON_MODEL_TYPE() {
DataTypeRegistry* dtr = WorkflowEnv::getDataTypeRegistry();
assert(dtr);
static bool startup = true;
if (startup)
{
dtr->registerEntry(DataTypePtr(new DataType(SITECON_MODEL_TYPE_ID, SiteconIO::tr("Sitecon model"), "")));
startup = false;
}
return dtr->getById(SITECON_MODEL_TYPE_ID);
}
void DNAStatWorkerFactory::init() {
QList<PortDescriptor*> portDescs;
QList<Attribute*> attribs;
//accept sequence and annotated regions as input
QMap<Descriptor, DataTypePtr> inputMap;
QMap<Descriptor, DataTypePtr> outputMap;
inputMap[ BaseSlots::DNA_SEQUENCE_SLOT() ] = BaseTypes::DNA_SEQUENCE_TYPE();
outputMap[ BaseSlots::ANNOTATION_TABLE_SLOT() ] = BaseTypes::ANNOTATION_TABLE_TYPE();
{ //Create input port descriptors
Descriptor inDesc( BasePorts::IN_SEQ_PORT_ID(), DNAStatWorker::tr("Input sequence"),
DNAStatWorker::tr("Sequence for which GC-content and GC3-content will be evaluated.") );
Descriptor outDesc( BasePorts::OUT_ANNOTATIONS_PORT_ID(), DNAStatWorker::tr("Result annotation"),
DNAStatWorker::tr("Resulted annotations, with GC-content and GC3-content.") );
portDescs << new PortDescriptor( inDesc, DataTypePtr(new MapDataType("filter.anns", inputMap)), /*input*/ true );
portDescs << new PortDescriptor( outDesc, DataTypePtr(new MapDataType("filter.anns", outputMap)), /*input*/false, /*multi*/true );
}
attribs << new Attribute(Descriptor(GCCONTENT, DNAStatWorker::tr("GC-content"), DNAStatWorker::tr("Evaluate GC-content.")),
BaseTypes::BOOL_TYPE(),false, true);
attribs << new Attribute(Descriptor(GC1CONTENT, DNAStatWorker::tr("GC1-content"), DNAStatWorker::tr("Evaluate GC1-content.")),
BaseTypes::BOOL_TYPE(),false, true);
attribs << new Attribute(Descriptor(GC2CONTENT, DNAStatWorker::tr("GC2-content"), DNAStatWorker::tr("Evaluate GC2-content.")),
BaseTypes::BOOL_TYPE(),false, true);
attribs << new Attribute(Descriptor(GC3CONTENT, DNAStatWorker::tr("GC3-content"), DNAStatWorker::tr("Evaluate GC3-content.")),
BaseTypes::BOOL_TYPE(),false, true);
Descriptor desc( ACTOR_ID,
DNAStatWorker::tr("DNA Statistics"),
DNAStatWorker::tr("Evaluates statistics for DNA sequences.") );
ActorPrototype * proto = new IntegralBusActorPrototype( desc, portDescs, attribs );
proto->setPrompter( new DNAStatWorkerPrompter() );
proto->setEditor(new DelegateEditor(QMap<QString, PropertyDelegate*>()));
WorkflowEnv::getProtoRegistry()->registerProto( BaseActorCategories::CATEGORY_STATISTIC(), proto );
DomainFactory* localDomain = WorkflowEnv::getDomainRegistry()->getById( LocalDomainFactory::ID );
localDomain->registerEntry( new DNAStatWorkerFactory() );
}
void DataTypeManager::load(const std::string& _fileName)
{
std::string fileName = MyGUI::DataManager::getInstance().getDataPath(_fileName);
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(fileName.c_str());
if (result)
{
pugi::xpath_node_set nodes = doc.select_nodes("Document/DataTypes/DataType");
for (pugi::xpath_node_set::const_iterator node = nodes.begin(); node != nodes.end(); node ++)
{
DataTypePtr data = DataTypePtr(new DataType());
data->deserialization((*node).node());
mDataInfos.push_back(data);
}
}
}
void FindPrimerPairsWorkerFactory::init() {
QList<PortDescriptor*> p; QList<Attribute*> a;
{
Descriptor id(BasePorts::IN_SEQ_PORT_ID(),
FindPrimerPairsWorker::tr("Input sequences"),
FindPrimerPairsWorker::tr("Set of primers, which must be tested."));
QMap<Descriptor, DataTypePtr> inM;
inM[BaseSlots::DNA_SEQUENCE_SLOT()] = BaseTypes::DNA_SEQUENCE_TYPE();
p << new PortDescriptor(id, DataTypePtr(new MapDataType("findPrimers.seq", inM)), true,
false, IntegralBusPort::BLIND_INPUT);
}
Descriptor desc( FindPrimerPairsWorkerFactory::ACTOR_ID,
FindPrimerPairsWorker::tr("Find correct primer pairs"),
FindPrimerPairsWorker::tr("Find correct primer pairs, which consist of valid primers without dimers.") );
Descriptor reportFileDesc(FindPrimerPairsWorkerFactory::OUT_FILE,
FindPrimerPairsWorker::tr("Output report file"),
FindPrimerPairsWorker::tr("Path to the report output file."));
QList<Attribute*> attrs;
attrs << new Attribute(reportFileDesc, BaseTypes::STRING_TYPE(), true);
ActorPrototype * proto = new IntegralBusActorPrototype( desc, p, attrs);
QMap<QString, PropertyDelegate*> delegates;
const QString filter = DialogUtils::prepareFileFilter(FindPrimerPairsWorker::tr("Report file"), QStringList("html"), true);
DelegateTags tags;
tags.set("filter", filter);
tags.set("extensions", QStringList() << "html");
delegates[OUT_FILE] = new URLDelegate(tags, "");
proto->setEditor(new DelegateEditor(delegates));
proto->setPrompter( new FindPrimerPairsPromter() );
WorkflowEnv::getProtoRegistry()->registerProto( BaseActorCategories::CATEGORY_BASIC(), proto );
DomainFactory* localDomain = WorkflowEnv::getDomainRegistry()->getById( LocalDomainFactory::ID );
localDomain->registerEntry( new FindPrimerPairsWorkerFactory() );
}
void SiteconWorkerFactory::init()
{
ActorPrototypeRegistry* r = WorkflowEnv::getProtoRegistry();
assert(r);
{
QMap<Descriptor, DataTypePtr> m;
m[BaseSlots::URL_SLOT()] = BaseTypes::STRING_TYPE();
m[SiteconWorkerFactory::SITECON_SLOT] = SiteconWorkerFactory::SITECON_MODEL_TYPE();
DataTypePtr t(new MapDataType(Descriptor("write.sitecon.content"), m));
QList<PortDescriptor*> p; QList<Attribute*> a;
Descriptor pd(SITECON_IN_PORT_ID, SiteconIO::tr("Sitecon model"), SiteconIO::tr("Input Sitecon model"));
p << new PortDescriptor(pd, t, true /*input*/);
Descriptor desc(SiteconWriter::ACTOR_ID, SiteconIO::tr("Write SITECON Model"), SiteconIO::tr("Saves all input SITECON profiles to specified location."));
IntegralBusActorPrototype* proto = new WriteSiteconProto(desc, p, a);
proto->setPrompter(new SiteconWritePrompter());
r->registerProto(BaseActorCategories::CATEGORY_TRANSCRIPTION(), proto);
}
{
QList<PortDescriptor*> p; QList<Attribute*> a;
Descriptor pd(SITECON_OUT_PORT_ID, SiteconIO::tr("Sitecon model"), SiteconIO::tr("Loaded SITECON profile data."));
QMap<Descriptor, DataTypePtr> outM;
outM[SiteconWorkerFactory::SITECON_SLOT] = SiteconWorkerFactory::SITECON_MODEL_TYPE();
p << new PortDescriptor(pd, DataTypePtr(new MapDataType("sitecon.read.out", outM)), false /*input*/, true /*multi*/);
Descriptor desc(SiteconReader::ACTOR_ID, SiteconIO::tr("Read SITECON Model"), SiteconIO::tr("Reads SITECON profiles from file(s). The files can be local or Internet URLs."));
IntegralBusActorPrototype* proto = new ReadSiteconProto(desc, p, a);
proto->setPrompter(new SiteconReadPrompter());
r->registerProto(BaseActorCategories::CATEGORY_TRANSCRIPTION(), proto);
}
SiteconBuildWorker::registerProto();
SiteconSearchWorker::registerProto();
DomainFactory* localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new SiteconWorkerFactory(SiteconReader::ACTOR_ID));
localDomain->registerEntry(new SiteconWorkerFactory(SiteconWriter::ACTOR_ID));
localDomain->registerEntry(new SiteconWorkerFactory(SiteconSearchWorker::ACTOR_ID));
localDomain->registerEntry(new SiteconWorkerFactory(SiteconBuildWorker::ACTOR_ID));
}
void PFMatrixConvertWorker::registerProto() {
QList<PortDescriptor*> p; QList<Attribute*> a;
QMap<Descriptor, DataTypePtr> m;
Descriptor id(FMATRIX_IN_PORT_ID, PFMatrixConvertWorker::tr("Frequency matrix"),
PFMatrixConvertWorker::tr("Frequency matrix to convert."));
m[PFMatrixWorkerFactory::FMATRIX_SLOT] = PFMatrixWorkerFactory::FREQUENCY_MATRIX_MODEL_TYPE();
DataTypePtr t(new MapDataType(Descriptor("convert.pfmatrix.content"), m));
Descriptor od(WMATRIX_OUT_PORT_ID, PFMatrixConvertWorker::tr("Weight matrix"),
PFMatrixConvertWorker::tr("Produced statistical model of specified TFBS data."));
p << new PortDescriptor(id, t, true /*input*/);
QMap<Descriptor, DataTypePtr> outM;
outM[PWMatrixWorkerFactory::WMATRIX_SLOT] = PWMatrixWorkerFactory::WEIGHT_MATRIX_MODEL_TYPE();
p << new PortDescriptor(od, DataTypePtr(new MapDataType("fmatrix.convert.out", outM)), false /*input*/, true /*multi*/);
{
Descriptor ad(ALG_ATTR, PWMatrixBuildWorker::tr("Weight algorithm"), PWMatrixBuildWorker::tr("Different weight algorithms uses different functions to build weight matrices. It allows us to get better precision on different data sets. Log-odds, NLG and Match algorithms are sensitive to input matrices with zero values, so some of them may not work on those matrices."));
a << new Attribute(ad, BaseTypes::STRING_TYPE(), true, BuiltInPWMConversionAlgorithms::BVH_ALGO);
}
{
Descriptor td(TYPE_ATTR, PWMatrixBuildWorker::tr("Matrix type"), PWMatrixBuildWorker::tr("Dinucleic matrices are more detailed, while mononucleic one are more useful for small input data sets."));
a << new Attribute(td, BaseTypes::BOOL_TYPE(), true, false /* false = mononucleic, true = dinucleic */);
}
Descriptor desc(ACTOR_ID, tr("Convert Frequency Matrix"),
tr("Converts frequency matrix to weight matrix. Weight matrices are used for probabilistic recognition of transcription factor binding sites."));
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
QMap<QString, PropertyDelegate*> delegates;
{
QVariantMap modeMap;
QStringList algo = AppContext::getPWMConversionAlgorithmRegistry()->getAlgorithmIds();
foreach (QString curr, algo) {
modeMap[curr] = QVariant(curr);
}
delegates[ALG_ATTR] = new ComboBoxDelegate(modeMap);
}
void PFMatrixBuildWorker::registerProto() {
QList<PortDescriptor*> p; QList<Attribute*> a;
QMap<Descriptor, DataTypePtr> m;
Descriptor id(BasePorts::IN_MSA_PORT_ID(), PFMatrixBuildWorker::tr("Input alignment"),
PFMatrixBuildWorker::tr("Input multiple sequence alignment for building statistical model."));
m[BaseSlots::MULTIPLE_ALIGNMENT_SLOT()] = BaseTypes::MULTIPLE_ALIGNMENT_TYPE();
DataTypePtr t(new MapDataType(Descriptor("build.pfmatrix.content"), m));
Descriptor od(FMATRIX_OUT_PORT_ID, PFMatrixBuildWorker::tr("Frequency matrix"),
PFMatrixBuildWorker::tr("Produced statistical model of specified TFBS data."));
p << new PortDescriptor(id, t, true /*input*/);
QMap<Descriptor, DataTypePtr> outM;
outM[PFMatrixWorkerFactory::FMATRIX_SLOT] = PFMatrixWorkerFactory::FREQUENCY_MATRIX_MODEL_TYPE();
p << new PortDescriptor(od, DataTypePtr(new MapDataType("fmatrix.build.out", outM)), false /*input*/, true /*multi*/);
{
Descriptor td(TYPE_ATTR, PWMatrixBuildWorker::tr("Matrix type"), PWMatrixBuildWorker::tr("Dinucleic matrices are more detailed, while mononucleic one are more useful for small input data sets."));
a << new Attribute(td, BaseTypes::BOOL_TYPE(), true, false /* false = mononucleic, true = dinucleic */);
}
Descriptor desc(ACTOR_ID, tr("Build Frequency Matrix"),
tr("Builds frequency matrix. Frequency matrices are used for probabilistic recognition of transcription factor binding sites."));
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
QMap<QString, PropertyDelegate*> delegates;
{
QVariantMap modeMap;
modeMap[tr("Mononucleic")] = QVariant(false);
modeMap[tr("Dinucleic")] = QVariant(true);
delegates[TYPE_ATTR] = new ComboBoxDelegate(modeMap);
}
proto->setPrompter(new PFMatrixBuildPrompter());
proto->setEditor(new DelegateEditor(delegates));
proto->setIconPath(":weight_matrix/images/weight_matrix.png");
WorkflowEnv::getProtoRegistry()->registerProto(BaseActorCategories::CATEGORY_TRANSCRIPTION(), proto);
}
void KrakenBuildWorkerFactory::init() {
QList<PortDescriptor *> ports;
{
const Descriptor outSlotDesc(BaseSlots::URL_SLOT().getId(), KrakenBuildPrompter::tr("Output URL"), KrakenBuildPrompter::tr("Output URL."));
QMap<Descriptor, DataTypePtr> outType;
outType[outSlotDesc] = BaseTypes::STRING_TYPE();
const Descriptor outPortDesc(OUTPUT_PORT_ID, KrakenBuildPrompter::tr("Output Kraken database"), KrakenBuildPrompter::tr("URL to the folder with the Kraken database."));
ports << new PortDescriptor(outPortDesc, DataTypePtr(new MapDataType(ACTOR_ID + "-out", outType)), false /*input*/, true /*multi*/);
}
QList<Attribute *> attributes;
{
const Descriptor modeDesc(MODE_ATTR_ID, KrakenBuildPrompter::tr("Mode"),
KrakenBuildPrompter::tr("Select \"Build\" to create a new database from a genomic library (--build).<br><br>"
"Select \"Shrink\" to shrink an existing database to have only specified number of k-mers (--shrink)."));
const Descriptor inputDatabaseNameDesc(INPUT_DATABASE_NAME_ATTR_ID, KrakenBuildPrompter::tr("Input database"),
KrakenBuildPrompter::tr("Name of the input database that should be shrunk (corresponds to --db that is used with --shrink)."));
const Descriptor newDatabaseNameDesc(NEW_DATABASE_NAME_ATTR_ID, KrakenBuildPrompter::tr("Database"),
KrakenBuildPrompter::tr("Name of the output Kraken database (corresponds to --db that is used with --build, and to --new-db that is used with --shrink)."));
const Descriptor genomicLibraryDesc(GENOMIC_LIBRARY_ATTR_ID, KrakenBuildPrompter::tr("Genomic library"),
KrakenBuildPrompter::tr("Genomes that should be used to build the database.<br><br>"
"The genomes should be specified in FASTA format. The sequence IDs must contain either a GI number or a taxonomy ID (see documentation for details)."));
const Descriptor numberOfKmersDesc(NUMBER_OF_K_MERS_ATTR_ID, KrakenBuildPrompter::tr("Number of k-mers"),
KrakenBuildPrompter::tr("The new database will contain the specified number of k-mers selected from across the input database."));
const Descriptor kMerLengthDesc(K_MER_LENGTH_ATTR_ID, KrakenBuildPrompter::tr("K-mer length"),
KrakenBuildPrompter::tr("K-mer length in bp (--kmer-len)."));
const Descriptor minimizerLengthDesc(MINIMIZER_LENGTH_ATTR_ID, KrakenBuildPrompter::tr("Minimizer length"),
KrakenBuildPrompter::tr("Minimizer length in bp (--minimizer-len).<br><br>"
"The minimizers serve to keep k-mers that are adjacent in query sequences close to each other in the database, which allows Kraken to exploit the CPU cache.<br><br>"
"Changing the value of the parameter can significantly affect the speed of Kraken, and neither increasing nor decreasing of the value will guarantee faster or slower speed."));
const Descriptor maximumDatabaseSizeDesc(MAXIMUM_DATABASE_SIZE_ATTR_ID, KrakenBuildPrompter::tr("Maximum database size"),
KrakenBuildPrompter::tr("By default, a full database build is done.<br><br>"
"To shrink the database before the full build, input the size of the database in Mb "
"(this corresponds to the --max-db-size parameter, but Mb is used instead of Gb). "
"The size is specified together for the database and the index."));
const Descriptor shrinkBlockOffsetDesc(SHRINK_BLOCK_OFFSET_ATTR_ID, KrakenBuildPrompter::tr("Shrink block offset"),
KrakenBuildPrompter::tr("When shrinking, select the k-mer that is NUM positions from the end of a block of k-mers (--shrink-block-offset)."));
const Descriptor cleanDesc(CLEAN_ATTR_ID, KrakenBuildPrompter::tr("Clean"),
KrakenBuildPrompter::tr("Remove unneeded files from a built database to reduce the disk usage (--clean)."));
const Descriptor workOnDiskDesc(WORK_ON_DISK_ATTR_ID, KrakenBuildPrompter::tr("Work on disk"),
KrakenBuildPrompter::tr("Perform most operations on disk rather than in RAM (this will slow down build in most cases)."));
const Descriptor jellyfishHashSizeDesc(JELLYFISH_HASH_SIZE_ATTR_ID, KrakenBuildPrompter::tr("Jellyfish hash size"),
KrakenBuildPrompter::tr("The \"kraken-build\" tool uses the \"jellyfish\" tool. This parameter specifies the hash size for Jellyfish.<br><br>"
"Supply a smaller hash size to Jellyfish, if you encounter problems with allocating enough memory during the build process (--jellyfish-hash-size).<br><br>"
"By default, the parameter is not used."));
const Descriptor threadNumberDesc(THREADS_NUMBER_ATTR_ID, KrakenBuildPrompter::tr("Number of threads"),
KrakenBuildPrompter::tr("Use multiple threads (--threads)."));
Attribute *modeAttribute = new Attribute(modeDesc, BaseTypes::STRING_TYPE(), false, KrakenBuildTaskSettings::BUILD);
Attribute *inputDatabaseNameAttribute = new Attribute(inputDatabaseNameDesc, BaseTypes::STRING_TYPE(), true);
Attribute *newDatabaseName = new Attribute(newDatabaseNameDesc, BaseTypes::STRING_TYPE(), true);
Attribute *genomicLibraryAttribute = new Attribute(genomicLibraryDesc, BaseTypes::URL_DATASETS_TYPE(), true);
Attribute *numberOfKmersAttribute = new Attribute(numberOfKmersDesc, BaseTypes::NUM_TYPE(), true, 10000);
Attribute *kMerLengthAttribute = new Attribute(kMerLengthDesc, BaseTypes::NUM_TYPE(), false, 31);
Attribute *minimizerLengthAttribute = new Attribute(minimizerLengthDesc, BaseTypes::NUM_TYPE(), false, 15);;
Attribute *maximumDatabaseSizeAttribute = new Attribute(maximumDatabaseSizeDesc, BaseTypes::NUM_TYPE(), false, 0);
Attribute *shrinkBlockOffsetAttribute = new Attribute(shrinkBlockOffsetDesc, BaseTypes::NUM_TYPE(), false, 1);
Attribute *cleanAttribute = new Attribute(cleanDesc, BaseTypes::BOOL_TYPE(), false, true);
Attribute *workOnDiskAttribute = new Attribute(workOnDiskDesc, BaseTypes::BOOL_TYPE(), false, false);
Attribute *jellyfishHashSizeAttribute = new Attribute(jellyfishHashSizeDesc, BaseTypes::NUM_TYPE(), false, 0);
Attribute *threadNumberAttribute = new Attribute(threadNumberDesc, BaseTypes::NUM_TYPE(), false, AppContext::getAppSettings()->getAppResourcePool()->getIdealThreadCount());
attributes << modeAttribute;
attributes << inputDatabaseNameAttribute;
attributes << newDatabaseName;
attributes << genomicLibraryAttribute;
attributes << numberOfKmersAttribute;
attributes << kMerLengthAttribute;
attributes << minimizerLengthAttribute;
attributes << maximumDatabaseSizeAttribute;
attributes << shrinkBlockOffsetAttribute;
attributes << cleanAttribute;
attributes << workOnDiskAttribute;
attributes << jellyfishHashSizeAttribute;
attributes << threadNumberAttribute;
inputDatabaseNameAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::SHRINK));
genomicLibraryAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::BUILD));
numberOfKmersAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::SHRINK));
maximumDatabaseSizeAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::BUILD));
shrinkBlockOffsetAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::SHRINK));
cleanAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::BUILD));
jellyfishHashSizeAttribute->addRelation(new VisibilityRelation(MODE_ATTR_ID, KrakenBuildTaskSettings::BUILD));
}
QMap<QString, PropertyDelegate *> delegates;
{
QVariantMap modeValues;
modeValues[KrakenSupport::tr("Build")] = KrakenBuildTaskSettings::BUILD;
modeValues[KrakenSupport::tr("Shrink")] = KrakenBuildTaskSettings::SHRINK;
delegates[MODE_ATTR_ID] = new ComboBoxDelegate(modeValues);
delegates[INPUT_DATABASE_NAME_ATTR_ID] = new URLDelegate("", "kraken/database", false, true, false);
const URLDelegate::Options options = URLDelegate::AllowSelectOnlyExistingDir |
URLDelegate::SelectFileToSave |
URLDelegate::DoNotUseWorkflowOutputFolder;
delegates[NEW_DATABASE_NAME_ATTR_ID] = new URLDelegate("", "kraken/database", options);
delegates[GENOMIC_LIBRARY_ATTR_ID] = new GenomicLibraryDelegate();
QVariantMap numberOfKmersProperties;
numberOfKmersProperties["minimum"] = 1;
numberOfKmersProperties["maximum"] = std::numeric_limits<int>::max();
numberOfKmersProperties["accelerated"] = true;
delegates[NUMBER_OF_K_MERS_ATTR_ID] = new SpinBoxDelegate(numberOfKmersProperties);
QVariantMap kMerLengthProperties;
kMerLengthProperties["minimum"] = 3;
kMerLengthProperties["maximum"] = 31;
delegates[K_MER_LENGTH_ATTR_ID] = new SpinBoxDelegate(kMerLengthProperties);
QVariantMap minimizerLengthProperties;
minimizerLengthProperties["minimum"] = 1;
minimizerLengthProperties["maximum"] = 30;
delegates[MINIMIZER_LENGTH_ATTR_ID] = new SpinBoxDelegate(minimizerLengthProperties);
QVariantMap maximumDatabaseSizeProperties;
maximumDatabaseSizeProperties["minimum"] = 0;
maximumDatabaseSizeProperties["maximum"] = std::numeric_limits<int>::max();
maximumDatabaseSizeProperties["suffix"] = " Mb";
maximumDatabaseSizeProperties["specialValueText"] = KrakenBuildPrompter::tr("No limit");
maximumDatabaseSizeProperties["accelerated"] = true;
delegates[MAXIMUM_DATABASE_SIZE_ATTR_ID] = new SpinBoxDelegate(maximumDatabaseSizeProperties);
QVariantMap shrinkBlockOffsetProperties;
shrinkBlockOffsetProperties["minimum"] = 1;
shrinkBlockOffsetProperties["maximum"] = std::numeric_limits<int>::max();
delegates[SHRINK_BLOCK_OFFSET_ATTR_ID] = new SpinBoxDelegate(shrinkBlockOffsetProperties);
delegates[CLEAN_ATTR_ID] = new ComboBoxWithBoolsDelegate();
delegates[WORK_ON_DISK_ATTR_ID] = new ComboBoxWithBoolsDelegate();
QVariantMap jelyfishHashSizeProperties;
jelyfishHashSizeProperties["minimum"] = 0;
jelyfishHashSizeProperties["maximum"] = std::numeric_limits<int>::max();
jelyfishHashSizeProperties["suffix"] = " M";
jelyfishHashSizeProperties["specialValueText"] = KrakenBuildPrompter::tr("Skip");
delegates[JELLYFISH_HASH_SIZE_ATTR_ID] = new SpinBoxDelegate(jelyfishHashSizeProperties);
QVariantMap threadsNumberProperties;
threadsNumberProperties["minimum"] = 1;
threadsNumberProperties["maximum"] = QThread::idealThreadCount();
delegates[THREADS_NUMBER_ATTR_ID] = new SpinBoxDelegate(threadsNumberProperties);
}
const Descriptor desc(ACTOR_ID, KrakenBuildPrompter::tr("Build Kraken Database"),
KrakenBuildPrompter::tr("Build a Kraken database from a genomic library or shrink a Kraken database."));
ActorPrototype *proto = new IntegralBusActorPrototype(desc, ports, attributes);
proto->setEditor(new DelegateEditor(delegates));
proto->setPrompter(new KrakenBuildPrompter(NULL));
proto->addExternalTool(KrakenSupport::BUILD_TOOL);
proto->setValidator(new KrakenBuildValidator());
WorkflowEnv::getProtoRegistry()->registerProto(NgsReadsClassificationPlugin::WORKFLOW_ELEMENTS_GROUP, proto);
DomainFactory *localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new KrakenBuildWorkerFactory());
}
void MergeFastqWorkerFactory::init() {
Descriptor desc( ACTOR_ID, MergeFastqWorker::tr("FASTQ Merger"),
MergeFastqWorker::tr("Merges input sequences to one output file") );
QList<PortDescriptor*> p;
{
Descriptor inD(BaseNGSWorker::INPUT_PORT, MergeFastqWorker::tr("Input File"),
MergeFastqWorker::tr("Set of FASTQ reads files"));
Descriptor outD(BaseNGSWorker::OUTPUT_PORT, MergeFastqWorker::tr("Output File"),
MergeFastqWorker::tr("Output FASTQ file"));
QMap<Descriptor, DataTypePtr> inM;
inM[BaseSlots::URL_SLOT()] = BaseTypes::STRING_TYPE();
p << new PortDescriptor(inD, DataTypePtr(new MapDataType("cf.input-url", inM)), true);
QMap<Descriptor, DataTypePtr> outM;
outM[BaseSlots::URL_SLOT()] = BaseTypes::STRING_TYPE();
p << new PortDescriptor(outD, DataTypePtr(new MapDataType("cf.output-url", outM)), false, true);
}
QList<Attribute*> a;
{
Descriptor outDir(BaseNGSWorker::OUT_MODE_ID, MergeFastqWorker::tr("Output directory"),
MergeFastqWorker::tr("Select an output directory. <b>Custom</b> - specify the output directory in the 'Custom directory' parameter. "
"<b>Workflow</b> - internal workflow directory. "
"<b>Input file</b> - the directory of the input file."));
Descriptor customDir(BaseNGSWorker::CUSTOM_DIR_ID, MergeFastqWorker::tr("Custom directory"),
MergeFastqWorker::tr("Select the custom output directory."));
Descriptor outName(BaseNGSWorker::OUT_NAME_ID, MergeFastqWorker::tr("Output file name"),
MergeFastqWorker::tr("A name of an output file. If default of empty value is provided the output name is the name of the first file with additional extention."));
a << new Attribute(outDir, BaseTypes::NUM_TYPE(), false, QVariant(FileAndDirectoryUtils::WORKFLOW_INTERNAL));
Attribute* customDirAttr = new Attribute(customDir, BaseTypes::STRING_TYPE(), false, QVariant(""));
customDirAttr->addRelation(new VisibilityRelation(BaseNGSWorker::OUT_MODE_ID, FileAndDirectoryUtils::CUSTOM));
a << customDirAttr;
a << new Attribute( outName, BaseTypes::STRING_TYPE(), false, QVariant(BaseNGSWorker::DEFAULT_NAME));
}
QMap<QString, PropertyDelegate*> delegates;
{
QVariantMap directoryMap;
QString fileDir = MergeFastqWorker::tr("Input file");
QString workflowDir = MergeFastqWorker::tr("Workflow");
QString customD = MergeFastqWorker::tr("Custom");
directoryMap[fileDir] = FileAndDirectoryUtils::FILE_DIRECTORY;
directoryMap[workflowDir] = FileAndDirectoryUtils::WORKFLOW_INTERNAL;
directoryMap[customD] = FileAndDirectoryUtils::CUSTOM;
delegates[BaseNGSWorker::OUT_MODE_ID] = new ComboBoxDelegate(directoryMap);
delegates[BaseNGSWorker::CUSTOM_DIR_ID] = new URLDelegate("", "", false, true);
}
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
proto->setEditor(new DelegateEditor(delegates));
proto->setPrompter(new MergeFastqPrompter());
WorkflowEnv::getProtoRegistry()->registerProto(BaseActorCategories::CATEGORY_NGS_BASIC(), proto);
DomainFactory *localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new MergeFastqWorkerFactory());
}
void QualityTrimWorkerFactory::init() {
Descriptor desc( ACTOR_ID, QualityTrimWorker::tr("FASTQ Quality Trimmer"),
QualityTrimWorker::tr("The workflow scans each input sequence from the end to find the first position where the quality is greater or equal to the minimum quality threshold. "
"Then it trims the sequence to that position. If a the whole sequence has quality less than the threshold or the length of the output sequence less than "
"the minimum length threshold then the sequence is skipped.") );
QList<PortDescriptor*> p;
{
Descriptor inD(BaseNGSWorker::INPUT_PORT, QualityTrimWorker::tr("Input File"),
QualityTrimWorker::tr("Set of FASTQ reads files"));
Descriptor outD(BaseNGSWorker::OUTPUT_PORT, QualityTrimWorker::tr("Output File"),
QualityTrimWorker::tr("Output FASTQ files"));
QMap<Descriptor, DataTypePtr> inM;
inM[BaseSlots::URL_SLOT()] = BaseTypes::STRING_TYPE();
p << new PortDescriptor(inD, DataTypePtr(new MapDataType("cf.input-url", inM)), true);
QMap<Descriptor, DataTypePtr> outM;
outM[BaseSlots::URL_SLOT()] = BaseTypes::STRING_TYPE();
p << new PortDescriptor(outD, DataTypePtr(new MapDataType("cf.output-url", outM)), false, true);
}
QList<Attribute*> a;
{
Descriptor outDir(BaseNGSWorker::OUT_MODE_ID, QualityTrimWorker::tr("Output directory"),
QualityTrimWorker::tr("Select an output directory. <b>Custom</b> - specify the output directory in the 'Custom directory' parameter. "
"<b>Workflow</b> - internal workflow directory. "
"<b>Input file</b> - the directory of the input file."));
Descriptor customDir(BaseNGSWorker::CUSTOM_DIR_ID, QualityTrimWorker::tr("Custom directory"),
QualityTrimWorker::tr("Select the custom output directory."));
Descriptor outName(BaseNGSWorker::OUT_NAME_ID, QualityTrimWorker::tr("Output file name"),
QualityTrimWorker::tr("A name of an output file. If default of empty value is provided the output name is the name of the first file with additional extention."));
Descriptor qualT(QUALITY_ID, QualityTrimWorker::tr("Quality threshold"),
QualityTrimWorker::tr("Quality threshold for trimming."));
Descriptor lenT(LEN_ID, QualityTrimWorker::tr("Min Length"),
QualityTrimWorker::tr("Too short reads are discarded by the filter."));
Descriptor bothD(BOTH_ID, QualityTrimWorker::tr("Trim both ends"),
QualityTrimWorker::tr("Trim the both ends of a read or not. Usually, you need to set <b>True</b> for <b>Sanger</b> sequencing and <b>False</b> for <b>NGS</b>"));
a << new Attribute(outDir, BaseTypes::NUM_TYPE(), false, QVariant(FileAndDirectoryUtils::WORKFLOW_INTERNAL));
Attribute* customDirAttr = new Attribute(customDir, BaseTypes::STRING_TYPE(), false, QVariant(""));
customDirAttr->addRelation(new VisibilityRelation(BaseNGSWorker::OUT_MODE_ID, FileAndDirectoryUtils::CUSTOM));
a << customDirAttr;
a << new Attribute( outName, BaseTypes::STRING_TYPE(), false, QVariant(BaseNGSWorker::DEFAULT_NAME));
a << new Attribute( qualT, BaseTypes:: NUM_TYPE(), false, QVariant(30));
a << new Attribute( lenT, BaseTypes::NUM_TYPE(), false, QVariant(0));
a << new Attribute( bothD, BaseTypes::BOOL_TYPE(), false, true);
}
QMap<QString, PropertyDelegate*> delegates;
{
QVariantMap directoryMap;
QString fileDir = QualityTrimWorker::tr("Input file");
QString workflowDir = QualityTrimWorker::tr("Workflow");
QString customD = QualityTrimWorker::tr("Custom");
directoryMap[fileDir] = FileAndDirectoryUtils::FILE_DIRECTORY;
directoryMap[workflowDir] = FileAndDirectoryUtils::WORKFLOW_INTERNAL;
directoryMap[customD] = FileAndDirectoryUtils::CUSTOM;
delegates[BaseNGSWorker::OUT_MODE_ID] = new ComboBoxDelegate(directoryMap);
delegates[BaseNGSWorker::CUSTOM_DIR_ID] = new URLDelegate("", "", false, true);
QVariantMap len; len["minimum"] = 0; len["maximum"] = INT_MAX;
delegates[QUALITY_ID] = new SpinBoxDelegate(len);
delegates[LEN_ID] = new SpinBoxDelegate(len);
}
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
proto->setEditor(new DelegateEditor(delegates));
proto->setPrompter(new QualityTrimPrompter());
WorkflowEnv::getProtoRegistry()->registerProto(BaseActorCategories::CATEGORY_NGS_BASIC(), proto);
DomainFactory *localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new QualityTrimWorkerFactory());
}
void CollocationWorkerFactory::init() {
QMap<Descriptor, DataTypePtr> m;
{
m[BaseSlots::DNA_SEQUENCE_SLOT()] = BaseTypes::DNA_SEQUENCE_TYPE();
m[BaseSlots::ANNOTATION_TABLE_SLOT()] = BaseTypes::ANNOTATION_TABLE_LIST_TYPE();
}
DataTypePtr inSet(new MapDataType(Descriptor("regioned.sequence"), m));
DataTypeRegistry* dr = WorkflowEnv::getDataTypeRegistry();
assert(dr);
dr->registerEntry(inSet);
QList<PortDescriptor*> p; QList<Attribute*> a;
p << new PortDescriptor(Descriptor(BasePorts::IN_SEQ_PORT_ID(), CollocationWorker::tr("Input data"),
CollocationWorker::tr("An input sequence and a set of annotations to search in.")), inSet, true /*input*/);
QMap<Descriptor, DataTypePtr> outM;
outM[BaseSlots::ANNOTATION_TABLE_SLOT()] = BaseTypes::ANNOTATION_TABLE_TYPE();
p << new PortDescriptor(Descriptor(BasePorts::OUT_ANNOTATIONS_PORT_ID(),
CollocationWorker::tr("Group annotations"), CollocationWorker::tr("Annotated regions containing found collocations.")),
DataTypePtr(new MapDataType(Descriptor("collocation.annotations"), outM)), false /*input*/, true/*multi*/);
static const QString newAnnsStr = CollocationWorker::tr("Create new annotations");
{
Descriptor nd(NAME_ATTR, CollocationWorker::tr("Result annotation"),
CollocationWorker::tr("Name of the result annotations to mark found collocations."));
Descriptor ad(ANN_ATTR, CollocationWorker::tr("Group of annotations"),
CollocationWorker::tr("A list of annotation names to search. Found regions will contain all the named annotations."));
Descriptor ld(LEN_ATTR, CollocationWorker::tr("Region size"),
CollocationWorker::tr("Effectively this is the maximum allowed distance between the interesting annotations in a group."));
Descriptor fd(FIT_ATTR, CollocationWorker::tr("Must fit into region"),
CollocationWorker::tr("Whether the interesting annotations should entirely fit into the specified region to form a group."));
Descriptor td(TYPE_ATTR, CollocationWorker::tr("Result type"),
CollocationWorker::tr("Copy original annotations or annotate found regions with new ones."));
Descriptor id(INC_BOUNDARY_ATTR, CollocationWorker::tr("Include boundaries"),
CollocationWorker::tr("Include most left and most right boundary annotations regions into result or exclude them."));
Attribute *nameAttr = new Attribute(nd, BaseTypes::STRING_TYPE(), true, QVariant("misc_feature"));
Attribute *typeAttr = new Attribute(td, BaseTypes::STRING_TYPE(), false, NEW_TYPE_ATTR);
Attribute *boundAttr = new Attribute(id, BaseTypes::BOOL_TYPE(), false, true);
a << typeAttr;
a << nameAttr;
a << boundAttr;
a << new Attribute(ad, BaseTypes::STRING_TYPE(), true);
a << new Attribute(ld, BaseTypes::NUM_TYPE(), false, QVariant(1000));
a << new Attribute(fd, BaseTypes::BOOL_TYPE(), false, QVariant(false));
nameAttr->addRelation(new VisibilityRelation(TYPE_ATTR, NEW_TYPE_ATTR));
boundAttr->addRelation(new VisibilityRelation(TYPE_ATTR, NEW_TYPE_ATTR));
}
Descriptor desc(ACTOR_ID, CollocationWorker::tr("Collocation Search"),
CollocationWorker::tr("Finds groups of specified annotations in each supplied set of annotations, stores found regions as annotations."));
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
QMap<QString, PropertyDelegate*> delegates;
{
QVariantMap lenMap; lenMap["minimum"] = QVariant(0); lenMap["maximum"] = QVariant(INT_MAX);
delegates[LEN_ATTR] = new SpinBoxDelegate(lenMap);
delegates[FIT_ATTR] = new ComboBoxWithBoolsDelegate();
QVariantMap typeMap;
typeMap[CollocationWorker::tr("Copy original annotations")] = COPY_TYPE_ATTR;
typeMap[newAnnsStr] = NEW_TYPE_ATTR;
delegates[TYPE_ATTR] = new ComboBoxDelegate(typeMap);
}
proto->setEditor(new DelegateEditor(delegates));
proto->setValidator(new CollocationValidator());
proto->setIconPath(":annotator/images/regions.png");
proto->setPrompter(new CollocationPrompter());
WorkflowEnv::getProtoRegistry()->registerProto(BaseActorCategories::CATEGORY_BASIC(), proto);
DomainFactory* localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new CollocationWorkerFactory());
}
void KrakenClassifyWorkerFactory::init() {
QList<PortDescriptor *> ports;
{
const Descriptor inSlotDesc(INPUT_SLOT,
KrakenClassifyPrompter::tr("Input URL 1"),
KrakenClassifyPrompter::tr("Input URL 1."));
const Descriptor inPairedSlotDesc(PAIRED_INPUT_SLOT,
KrakenClassifyPrompter::tr("Input URL 2"),
KrakenClassifyPrompter::tr("Input URL 2."));
QMap<Descriptor, DataTypePtr> inType;
inType[inSlotDesc] = BaseTypes::STRING_TYPE();
inType[inPairedSlotDesc] = BaseTypes::STRING_TYPE();
QMap<Descriptor, DataTypePtr> outType;
outType[TaxonomySupport::TAXONOMY_CLASSIFICATION_SLOT()] = TaxonomySupport::TAXONOMY_CLASSIFICATION_TYPE();
const Descriptor inPortDesc(INPUT_PORT_ID,
KrakenClassifyPrompter::tr("Input sequences"),
KrakenClassifyPrompter::tr("URL(s) to FASTQ or FASTA file(s) should be provided.\n\n"
"In case of SE reads or contigs use the \"Input URL 1\" slot only.\n\n"
"In case of PE reads input \"left\" reads to \"Input URL 1\", \"right\" reads to \"Input URL 2\".\n\n"
"See also the \"Input data\" parameter of the element."));
const Descriptor outPortDesc(OUTPUT_PORT_ID, KrakenClassifyPrompter::tr("Kraken Classification"), KrakenClassifyPrompter::tr("A map of sequence names with the associated taxonomy IDs, classified by Kraken."));
ports << new PortDescriptor(inPortDesc, DataTypePtr(new MapDataType(ACTOR_ID + "-in", inType)), true /*input*/);
ports << new PortDescriptor(outPortDesc, DataTypePtr(new MapDataType(ACTOR_ID + "-out", outType)), false /*input*/, true /*multi*/);
}
QList<Attribute *> attributes;
{
const Descriptor inputDataDesc(INPUT_DATA_ATTR_ID, KrakenClassifyPrompter::tr("Input data"),
KrakenClassifyPrompter::tr("To classify single-end (SE) reads or contigs, received by reads de novo assembly, set this parameter to \"SE reads or contigs\".<br><br>"
"To classify paired-end (PE) reads, set the value to \"PE reads\".<br><br>"
"One or two slots of the input port are used depending on the value of the parameter. Pass URL(s) to data to these slots.<br><br>"
"The input files should be in FASTA or FASTQ formats."));
const Descriptor databaseDesc(DATABASE_ATTR_ID, KrakenClassifyPrompter::tr("Database"),
KrakenClassifyPrompter::tr("A path to the folder with the Kraken database files."));
const Descriptor outputUrlDesc(OUTPUT_URL_ATTR_ID, KrakenClassifyPrompter::tr("Output file"),
KrakenClassifyPrompter::tr("Specify the output file name."));
const Descriptor quickOperationDesc(QUICK_OPERATION_ATTR_ID, KrakenClassifyPrompter::tr("Quick operation"),
KrakenClassifyPrompter::tr("Stop classification of an input read after the certain number of hits.<br><br>"
"The value can be specified in the \"Minimum number of hits\" parameter."));
const Descriptor minHitsDesc(MIN_HITS_NUMBER_ATTR_ID, KrakenClassifyPrompter::tr("Minimum number of hits"),
KrakenClassifyPrompter::tr("The number of hits that are required to declare an input sequence classified.<br><br>"
"This can be especially useful with custom databases when testing to see if sequences either do or do not belong to a particular genome."));
const Descriptor threadsDesc(THREADS_NUMBER_ATTR_ID, KrakenClassifyPrompter::tr("Number of threads"),
KrakenClassifyPrompter::tr("Use multiple threads (--threads)."));
const Descriptor preloadDatabaseDesc(PRELOAD_DATABASE_ATTR_ID, KrakenClassifyPrompter::tr("Load database into memory"),
KrakenClassifyPrompter::tr("Load the Kraken database into RAM (--preload).<br><br>"
"This can be useful to improve the speed. The database size should be less than the RAM size.<br><br>"
"The other option to improve the speed is to store the database on ramdisk. Set this parameter to \"False\" in this case."));
const Descriptor classifyToolDesc(NgsReadsClassificationPlugin::WORKFLOW_CLASSIFY_TOOL_ID,
WORKFLOW_CLASSIFY_TOOL_KRAKEN,
"Classify tool. Hidden attribute");
Attribute *inputDataAttribute = new Attribute(inputDataDesc, BaseTypes::STRING_TYPE(), false, KrakenClassifyTaskSettings::SINGLE_END);
inputDataAttribute->addSlotRelation(new SlotRelationDescriptor(INPUT_PORT_ID, PAIRED_INPUT_SLOT, QVariantList() << KrakenClassifyTaskSettings::PAIRED_END));
attributes << inputDataAttribute;
QString minikrakenPath;
U2DataPath *minikrakenDataPath = AppContext::getDataPathRegistry()->getDataPathByName(NgsReadsClassificationPlugin::MINIKRAKEN_4_GB_DATA_ID);
if (NULL != minikrakenDataPath && minikrakenDataPath->isValid()) {
minikrakenPath = minikrakenDataPath->getPathByName(NgsReadsClassificationPlugin::MINIKRAKEN_4_GB_ITEM_ID);
}
Attribute *databaseAttribute = new Attribute(databaseDesc, BaseTypes::STRING_TYPE(), Attribute::Required | Attribute::NeedValidateEncoding, minikrakenPath);
attributes << databaseAttribute;
attributes << new Attribute(quickOperationDesc, BaseTypes::BOOL_TYPE(), Attribute::None, false);
Attribute *minHitsAttribute = new Attribute(minHitsDesc, BaseTypes::NUM_TYPE(), Attribute::None, 1);
attributes << minHitsAttribute;
attributes << new Attribute(preloadDatabaseDesc, BaseTypes::BOOL_TYPE(), Attribute::None, true);
attributes << new Attribute(threadsDesc, BaseTypes::NUM_TYPE(), Attribute::None, AppContext::getAppSettings()->getAppResourcePool()->getIdealThreadCount());
attributes << new Attribute(outputUrlDesc, BaseTypes::STRING_TYPE(), Attribute::Required | Attribute::NeedValidateEncoding | Attribute::CanBeEmpty);
attributes << new Attribute(classifyToolDesc, BaseTypes::STRING_TYPE(),
static_cast<Attribute::Flags>(Attribute::Hidden),
WORKFLOW_CLASSIFY_TOOL_KRAKEN);
minHitsAttribute->addRelation(new VisibilityRelation(QUICK_OPERATION_ATTR_ID, "true"));
databaseAttribute->addRelation(new DatabaseSizeRelation(PRELOAD_DATABASE_ATTR_ID));
}
QMap<QString, PropertyDelegate *> delegates;
{
QVariantMap inputDataMap;
inputDataMap[SINGLE_END_TEXT] = KrakenClassifyTaskSettings::SINGLE_END;
inputDataMap[PAIRED_END_TEXT] = KrakenClassifyTaskSettings::PAIRED_END;
delegates[INPUT_DATA_ATTR_ID] = new ComboBoxDelegate(inputDataMap);
delegates[DATABASE_ATTR_ID] = new DatabaseDelegate(ACTOR_ID,
DATABASE_ATTR_ID,
NgsReadsClassificationPlugin::MINIKRAKEN_4_GB_DATA_ID,
NgsReadsClassificationPlugin::MINIKRAKEN_4_GB_ITEM_ID,
"kraken/database",
true);
DelegateTags outputUrlTags;
outputUrlTags.set(DelegateTags::PLACEHOLDER_TEXT, "Auto");
outputUrlTags.set(DelegateTags::FILTER, DialogUtils::prepareDocumentsFileFilter(BaseDocumentFormats::PLAIN_TEXT, true, QStringList()));
outputUrlTags.set(DelegateTags::FORMAT, BaseDocumentFormats::PLAIN_TEXT);
delegates[OUTPUT_URL_ATTR_ID] = new URLDelegate(outputUrlTags, "kraken/output");
delegates[QUICK_OPERATION_ATTR_ID] = new ComboBoxWithBoolsDelegate();
QVariantMap threadsProperties;
threadsProperties["minimum"] = 1;
threadsProperties["maximum"] = QThread::idealThreadCount();
delegates[THREADS_NUMBER_ATTR_ID] = new SpinBoxDelegate(threadsProperties);
delegates[PRELOAD_DATABASE_ATTR_ID] = new ComboBoxWithBoolsDelegate();
}
const Descriptor desc(ACTOR_ID, KrakenClassifyPrompter::tr("Classify Sequences with Kraken"),
KrakenClassifyPrompter::tr("Kraken is a taxonomic sequence classifier that assigns taxonomic labels to short DNA reads. "
"It does this by examining the k-mers within a read and querying a database with those."));
ActorPrototype *proto = new IntegralBusActorPrototype(desc, ports, attributes);
proto->setEditor(new DelegateEditor(delegates));
proto->setPrompter(new KrakenClassifyPrompter(NULL));
proto->addExternalTool(KrakenSupport::CLASSIFY_TOOL);
proto->setValidator(new KrakenClassifyValidator());
proto->setPortValidator(INPUT_PORT_ID, new PairedReadsPortValidator(INPUT_SLOT, PAIRED_INPUT_SLOT));
WorkflowEnv::getProtoRegistry()->registerProto(NgsReadsClassificationPlugin::WORKFLOW_ELEMENTS_GROUP, proto);
DomainFactory *localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new KrakenClassifyWorkerFactory());
}
void RepeatWorkerFactory::init() {
QList<PortDescriptor*> p; QList<Attribute*> a;
{
Descriptor id(BasePorts::IN_SEQ_PORT_ID(), RepeatWorker::tr("Input sequences"),
RepeatWorker::tr("A nucleotide sequence to search repeats in."));
Descriptor od(BasePorts::OUT_ANNOTATIONS_PORT_ID(), RepeatWorker::tr("Repeat annotations"),
RepeatWorker::tr("A set of annotations marking repeats found in the sequence."));
QMap<Descriptor, DataTypePtr> inM;
inM[BaseSlots::DNA_SEQUENCE_SLOT()] = BaseTypes::DNA_SEQUENCE_TYPE();
p << new PortDescriptor(id, DataTypePtr(new MapDataType("repeat.seq", inM)), true /*input*/);
QMap<Descriptor, DataTypePtr> outM;
outM[BaseSlots::ANNOTATION_TABLE_SLOT()] = BaseTypes::ANNOTATION_TABLE_TYPE();
p << new PortDescriptor(od, DataTypePtr(new MapDataType("repeat.annotations", outM)), false /*input*/, true /*multi*/);
}
{
Descriptor nd(NAME_ATTR, RepeatWorker::tr("Annotate as"), RepeatWorker::tr("Name of the result annotations marking found repeats."));
Descriptor idd(IDENTITY_ATTR, RepeatWorker::tr("Identity"), RepeatWorker::tr("Repeats identity."));
Descriptor ld(LEN_ATTR, RepeatWorker::tr("Min length"), RepeatWorker::tr("Minimum length of repeats."));
Descriptor mid(MIN_DIST_ATTR, RepeatWorker::tr("Min distance"), RepeatWorker::tr("Minimum distance between repeats."));
Descriptor mad(MAX_DIST_ATTR, RepeatWorker::tr("Max distance"), RepeatWorker::tr("Maximum distance between repeats."));
Descriptor ind(INVERT_ATTR, RepeatWorker::tr("Inverted"), RepeatWorker::tr("Search for inverted repeats."));
Descriptor nsd(NESTED_ATTR, RepeatWorker::tr("Filter algorithm"), RepeatWorker::tr("Filter repeats algorithm."));
Descriptor ald(ALGO_ATTR, RepeatWorker::tr("Algorithm"), RepeatWorker::tr("Control over variations of algorithm."));
Descriptor thd(THREADS_ATTR, RepeatWorker::tr("Parallel threads"), RepeatWorker::tr("Number of parallel threads used for the task."));
Descriptor tan(TANMEDS_ATTR, RepeatWorker::tr("Exclude tandems"), RepeatWorker::tr("Exclude tandems areas before find repeat task is run."));
Descriptor umaxd(USE_MAX_DISTANCE_ATTR, RepeatWorker::tr("Apply 'Max distance' attribute"), RepeatWorker::tr("Apply 'Max distance' attribute."));
Descriptor umind(USE_MIN_DISTANCE_ATTR, RepeatWorker::tr("Apply 'Min distance' attribute"), RepeatWorker::tr("Apply 'Max distance' attribute."));
FindRepeatsTaskSettings cfg = FindRepeatsDialog::defaultSettings();
Attribute *aa;
a << new Attribute(nd, BaseTypes::STRING_TYPE(), true, "repeat_unit");
aa = new Attribute(ld, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.minLen);
a << aa;
aa = new Attribute(idd, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.getIdentity());
a << aa;
a << new Attribute(umind, BaseTypes::BOOL_TYPE(), false, true);
aa = new Attribute(mid, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.minDist);
aa->addRelation(new VisibilityRelation(USE_MIN_DISTANCE_ATTR, true));
a << aa;
a << new Attribute(umaxd, BaseTypes::BOOL_TYPE(), false, true);
aa = new Attribute(mad, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.maxDist);
aa->addRelation(new VisibilityRelation(USE_MAX_DISTANCE_ATTR, true));
a << aa;
aa = new Attribute(ind, BaseTypes::BOOL_TYPE(), false);
aa->setAttributeValue(cfg.inverted);
a << aa;
aa = new Attribute(nsd, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.filter);
a << aa;
aa = new Attribute(ald, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.algo);
a << aa;
aa = new Attribute(thd, BaseTypes::NUM_TYPE(), false);
aa->setAttributeValue(cfg.nThreads);
a << aa;
aa = new Attribute(tan, BaseTypes::BOOL_TYPE(), false);
aa->setAttributeValue(cfg.excludeTandems);
a << aa;
}
Descriptor desc(ACTOR_ID, RepeatWorker::tr("Find Repeats"),
RepeatWorker::tr("Finds repeats in each supplied sequence, stores found regions as annotations.")
);
ActorPrototype* proto = new IntegralBusActorPrototype(desc, p, a);
QMap<QString, PropertyDelegate*> delegates;
delegates[USE_MIN_DISTANCE_ATTR] = new ComboBoxWithBoolsDelegate();
delegates[USE_MAX_DISTANCE_ATTR] = new ComboBoxWithBoolsDelegate();
{
QVariantMap m; m["minimum"] = 0; m["maximum"] = INT_MAX; m["suffix"] = L10N::suffixBp();
delegates[MIN_DIST_ATTR] = new SpinBoxDelegate(m);
m["specialValueText"] = RepeatWorker::tr("Any");
delegates[MAX_DIST_ATTR] = new SpinBoxDelegate(m);
m["minimum"] = 2;
delegates[LEN_ATTR] = new SpinBoxDelegate(m);
}
{
QVariantMap m; m["minimum"] = 50; m["maximum"] = 100; m["suffix"] = "%";
delegates[IDENTITY_ATTR] = new SpinBoxDelegate(m);
}
{
QVariantMap m; m["specialValueText"] = "Auto";
delegates[THREADS_ATTR] = new SpinBoxDelegate(m);
}
{
QVariantMap m;
m["Auto"] = RFAlgorithm_Auto;
m["Diagonals"] = RFAlgorithm_Diagonal;
m["Suffix index"] = RFAlgorithm_Suffix;
delegates[ALGO_ATTR] = new ComboBoxDelegate(m);
}
{
QVariantMap m;
m["Disjoint repeats"] = DisjointRepeats;
m["No filtering"] = NoFiltering;
m["Unique repeats"] = UniqueRepeats;
delegates[NESTED_ATTR] = new ComboBoxDelegate(m);
}
proto->setPrompter(new RepeatPrompter());
proto->setEditor(new DelegateEditor(delegates));
proto->setIconPath(":repeat_finder/images/repeats.png");
WorkflowEnv::getProtoRegistry()->registerProto(BaseActorCategories::CATEGORY_BASIC(), proto);
DomainFactory* localDomain = WorkflowEnv::getDomainRegistry()->getById(LocalDomainFactory::ID);
localDomain->registerEntry(new RepeatWorkerFactory());
}
