Summary |
Help |
AddBlastBlocks
Add blast hits as blocks
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
- other: Input blocks
- target: Blast hits sliced from input blocks
|
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--remove-after arg (=0) remove file out-hits
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
|
AddBlastBlocksToSelf
AddBlastBlocksToSelf: AddBlastBlocksToSelf
Filter: Filter blocks
Rest: Add to target blocks of nucleotides, not included to other
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--remove-after arg (=0) remove file out-hits
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
|
AddGenes
Add genes from EBI genes description
- target: Blockset where genes are added
|
Add genes from EBI genes description:
--in-genes arg input database files with genes
--product arg (=1) Append product name to block name
|
AddingLoopBySize
Align and move overlapless from other to target
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
- other: source blockset
- target: destination blockset
|
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
Align
LiteAlign + Filter + SelfOverlapsResolver
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
|
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
AllOptions
Print HTML help about all global options
|
Print HTML help about all global options:
--out arg (=:cout) Output file
--remove-after arg (=0) remove file out
|
AllProcessors
Print HTML help about all processors
|
Print HTML help about all processors:
--out arg (=:cout) Output file
--remove-after arg (=0) remove file out
|
AnchorBlastJoiner
AnchorBlastJoiner: AnchorBlastJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
|
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
Any processor:
--smth-opts arg options for processor
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
|
AnchorFinder
Find anchors
- target: Blockset to search anchors in
|
Find anchors:
--anchor-fp arg (=0.1) Probability of false positive in Bloom
filter (first step of AnchorFinder)
--anchor-similar arg (=1) If neighbour anchors are skipped
--anchor-size arg (=20) anchor size
--max-anchor-fragments arg (=100000) Maximum number of anchors fragments to
return
|
AnchorJoiner
AnchorJoiner: AnchorJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
|
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
Any processor:
--smth-opts arg options for processor
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
|
AnchorJoinerFast
AnchorJoinerFast: AnchorJoinerFast
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
|
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
Any processor:
--smth-opts arg options for processor
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
|
AnchorLoop
AnchorLoop: AnchorLoop
Filter: Filter blocks
Rest: Add to target blocks of nucleotides, not included to other
ConSeq: Blocks to consensus sequences
AnchorFinder: Find anchors
MoveUnchanged: Move unchanged blocks from other to target
Clear: Remove all blocks and/or sequences from blockset
DummyAligner: Align by adding gaps to sequences
UniqueNames: Set unique names to all blocks of this block set
Union: Add clones of blocks from other to this block set
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
RemoveWithSameName: Remove from target blocks with names from other
SplitExtendable: Find extendable subblocks
Filter: Filter blocks
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
RemoveNames: Remove all blocks and/or sequences names
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
ExtendLoop: ExtendLoop
MoveUnchanged: Move unchanged blocks from other to target
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
Clear: Remove all blocks and/or sequences from blockset
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
ExtendLoop: ExtendLoop
MoveUnchanged: Move unchanged blocks from other to target
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
Clear: Remove all blocks and/or sequences from blockset
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
Clear: Remove all blocks and/or sequences from blockset
Clear: Remove all blocks and/or sequences from blockset
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Find anchors:
--anchor-fp arg (=0.1) Probability of false positive in Bloom
filter (first step of AnchorFinder)
--anchor-similar arg (=1) If neighbour anchors are skipped
--anchor-size arg (=20) anchor size
--max-anchor-fragments arg (=100000) Maximum number of anchors fragments to
return
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
--clear-seqs arg (=0) Remove sequences (warning: this makes dangling
pointers from orphaned blocks, if they remain)
Align by adding gaps to sequences:
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Move block's boundaries and align only new parts:
--extend-length-portion arg (=0) Length of extended part portion in source
|
AnchorLoopFast
AnchorLoopFast: AnchorLoopFast
Filter: Filter blocks
Rest: Add to target blocks of nucleotides, not included to other
ConSeq: Blocks to consensus sequences
AnchorFinder: Find anchors
MoveUnchanged: Move unchanged blocks from other to target
Clear: Remove all blocks and/or sequences from blockset
DummyAligner: Align by adding gaps to sequences
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
ExtendLoopFast: ExtendLoopFast
MoveUnchanged: Move unchanged blocks from other to target
ExtendAndFix: ExtendAndFix
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
FixEnds: Cut bad aligned ends
Move: Move all blocks from other blockset to target blockset
OverlaplessUnion: Add clones of blocks from other, non-overlapping target
Clear: Remove all blocks and/or sequences from blockset
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Find anchors:
--anchor-fp arg (=0.1) Probability of false positive in Bloom
filter (first step of AnchorFinder)
--anchor-similar arg (=1) If neighbour anchors are skipped
--anchor-size arg (=20) anchor size
--max-anchor-fragments arg (=100000) Maximum number of anchors fragments to
return
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
--clear-seqs arg (=0) Remove sequences (warning: this makes dangling
pointers from orphaned blocks, if they remain)
Align by adding gaps to sequences:
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Add clones of blocks from other, non-overlapping target:
--ou-filter arg (=0) Do not copy good blocks to target, but remove bad
blocks from other
|
AreBlocksGood
Print if all blocks in block set are good
AreBlocksGood: Print if all blocks in block set are good
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
- target: Target blockset to be tested
|
Print if all blocks in block set are good:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
--out-is-pangenome arg Output file with verdict
--remove-after arg (=0) remove file out-is-pangenome
--respect-minor arg (=1) Do not check length and alignment of minor blocks
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
|
BlastFinder
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
- target: Blockset in which hits are searched
|
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--remove-after arg (=0) remove file out-hits
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Import blast hits:
--blast-min-length arg (=100) min length of blast hit
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
|
BlastRunner
Blast runner
|
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--in-consensus arg Input files with consensuses
--out-hits arg Output file with blast hits
--remove-after arg (=0) remove file out-hits
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
|
BlockFinder
Locate block by sequence of its fragments
BlockFinder: Locate block by sequence of its fragments
FragmentFinder: Locate fragment by its sequence
OverlapFinder: Finds blocks from 'bank', overlapping with 'pattern', results are copied to 'hits'
- other: where to look for
- target: where to look for
|
Locate block by sequence of its fragments:
--pattern arg Sequence searched for
Locate fragment by its sequence:
--max-matches arg (=1000) Maximum number of matches
|
BlockInfo
Print information about blocks
|
Print information about blocks:
--info-count-seqs arg (=0) Add columns with orrurences in each sequence
--info-file arg output file with all blocks
--info-mask arg mask of output files (${block} is replaced with
block name)
|
BlocksExpander
Add fragments to blocks using information about neighbours (deprecated)
|
Add fragments to blocks using information about neighbours (deprecated):
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
|
CheckNoOverlaps
Make sure no blocks overlap other blocks, else throw
CheckNoOverlaps: Make sure no blocks overlap other blocks, else throw
CheckNoOverlapsImpl: Resolve overlaping fragments (deprecated)
Connector: Connect all the fragments (prev-next)
CheckNoOverlapsImpl: Resolve overlaping fragments (deprecated)
|
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
|
CheckPangenome
CheckPangenome: CheckPangenome
In: Input block set
IsPangenome: Print if block set is good pangenome
AreBlocksGood: Print if all blocks in block set are good
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
|
Input block set:
--in-blocks arg (=pangenome.bs) input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory ('map'
or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Print if all blocks in block set are good:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
--out-is-pangenome arg Output file with verdict
--remove-after arg (=0) remove file out-is-pangenome
--respect-minor arg (=1) Do not check length and alignment of minor blocks
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
Any processor:
--smth-opts arg options for processor
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
|
ChrBSA
Build block set alignments from all chromosomes
ChrBSA: Build block set alignments from all chromosomes
FindBSA: Build block set alignment
|
Build block set alignment:
--bsa-name arg Name of new block set alignment
--bsa-seqs arg List of sequences used for alignment, sequence groups
can be selected by genome name or chromosome name,
'all' means all sequences of block set
|
CleanUp
Connect, resolve overlaps, expand, filter (deprecated)
CleanUp: Connect, resolve overlaps, expand, filter (deprecated)
CleanUpLoop: CleanUpLoop
FragmentsExpander: Expand fragments (deprecated)
Filter: Filter blocks
OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
Connector: Connect all the fragments (prev-next)
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Connector: Connect all the fragments (prev-next)
FragmentsExpander: Expand fragments (deprecated)
|
Expand fragments (deprecated):
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--max-overlap arg (=200) max number of positions added after first overlap
occur
--mismatch-penalty arg (=1) Mismatch penalty
--ori arg (=0) direction of expansion
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Resolve overlaping fragments (version 2, deprecated):
--min-distance arg (=30) Min distance between fragment boundaries
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
Join blocks:
--join-max-dist arg (=100) Max allowed distance when joining fragments
--join-to-fragment arg (=0.5) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=1.5) Max allowed ratio of gaps' lengths (inside a
block) when joining
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
Clear
Remove all blocks and/or sequences from blockset
|
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
--clear-seqs arg (=0) Remove sequences (warning: this makes dangling
pointers from orphaned blocks, if they remain)
|
ConSeq
Blocks to consensus sequences
- other: Blockset, from which blocks are taken
- target: Blockset, where consensus sequences are added
|
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
|
Connector
Connect all the fragments (prev-next)
|
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
|
Consensus
Consensus writer
Consensus: Consensus writer
ConSeq: Blocks to consensus sequences
Output: Output block set
Clear: Remove all blocks and/or sequences from blockset
|
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Output block set:
--cons-export-alignment arg (=1) use alignment information if available
--cons-export-contents arg (=1) print contents of fragments
--cons-file arg output file with all blocks
--cons-mask arg mask of output files (${block} is replaced
with block name)
Remove all blocks and/or sequences from blockset:
--clear-bsas arg (=1) Remove block set alignments
|
ConsensusTree
Print consensus tree
ConsensusTree: Print consensus tree
BranchGenerator: BranchGenerator
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
|
Print consensus tree:
--bootstrap-diagnostic-min-block arg (=4)
Minimum block used to calculate number
of diagnostic positions
--bootstrap-diagnostic-stem arg (=1) If only stem blocks are used to
calculate number of diagnostic
positions
--bootstrap-percent arg (=0) If bootstrap is percentage
--bootstrap-print arg (=in-braces) How to print bootstrap values ('no',
'in-braces', 'before-length')
--bootstrap-values arg (=diagnostic-positions)
What to use as bootstrap values
('blocks', 'length',
'diagnostic-positions')
--out-branch arg Output file with branches
--out-consensus-tree arg Output file with consensus tree
--print-branches arg (=1) If branches are logged
--remove-after arg (=0) remove file out-consensus-tree
--tree-pseudo-leafs arg (=0) Convert each leaf to short branch
(workaround to make viewer programs
show bootstrap values of leafs)
BranchGenerator:
--log arg (=1) block weight is log(number of nonidentical positions)
(otherwse linear)
--min-noident arg (=5) Minimum number of nonidentical positions in block
Build and print newick trees of blocks:
--tree-file arg output file with all blocks
--tree-mask arg mask of output files (${block} is replaced with block
name)
--tree-method arg (=nj) Method of tree construction (upgma/nj)
Calculate distance between fragments in block:
--tree-distance-file arg output file with all blocks
--tree-distance-mask arg mask of output files (${block} is replaced
with block name)
|
CutGaps
Cut terminal gaps
|
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
|
DeConSeq
Build blocks from blocks, set to sequences of blocks of other
- other: From where consensus blocks are taken
- target: Where new blocks are added
|
|
DummyAligner
Align by adding gaps to sequences
|
Align by adding gaps to sequences:
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
|
ExactStemBSA
Replace all non-stem blocks with gaps in block set alignment
|
Replace all non-stem blocks with gaps in block set alignment:
--bsa-min-length arg (=100) Min length of accepted block
--bsa-stem-improve arg (=1) Move fragments and remove pure gaps
|
ExtendAndAlign
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
|
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
ExtendAndFix
ExtendAndFix: ExtendAndFix
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
FixEnds: Cut bad aligned ends
|
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Cut bad aligned ends:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
ExtendLoop
ExtendLoop: ExtendLoop
MoveUnchanged: Move unchanged blocks from other to target
ExtendAndAlign: ExtendAndAlign
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
Clear: Remove all blocks and/or sequences from blockset
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
|
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
ExtendLoopFast
ExtendLoopFast: ExtendLoopFast
MoveUnchanged: Move unchanged blocks from other to target
ExtendAndFix: ExtendAndFix
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
FixEnds: Cut bad aligned ends
Move: Move all blocks from other blockset to target blockset
OverlaplessUnion: Add clones of blocks from other, non-overlapping target
Clear: Remove all blocks and/or sequences from blockset
Move: Move all blocks from other blockset to target blockset
Clear: Remove all blocks and/or sequences from blockset
|
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Cut bad aligned ends:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Add clones of blocks from other, non-overlapping target:
--ou-filter arg (=0) Do not copy good blocks to target, but remove bad
blocks from other
|
ExternalAligner
External aligner
|
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
|
ExtractGenes
ExtractGenes: ExtractGenes
In: Input block set
AddGenes: Add genes from EBI genes description
Output: Output block set
|
Input block set:
--in-blocks arg (=genomes-renamed.fasta)
input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Add genes from EBI genes description:
--in-genes arg (=features.embl) input database files with genes
--product arg (=1) Append product name to block name
Output block set:
--out-dump-block arg (=1) dump blocks
--out-dump-seq arg (=0) dump sequences before blocks
--out-export-alignment arg (=1) use alignment information if available
--out-file arg (=features.bs) output file with all blocks
--out-mask arg mask of output files (${block} is replaced
with block name)
|
FastaBSA
Print block set alignment as fasta
|
Print block set alignment as fasta:
--bsa-fasta arg Output fasta file with block set alignment
--bsa-name arg Name of block set alignment.
--remove-after arg (=0) remove file bsa-fasta
|
FileCopy
Copy file
|
Copy file:
--dst arg (=:null) Destination of copy
--src arg Source file to copy
|
FileRemover
Remove file
|
Remove file:
--filename arg File to be removed
|
Filter
Filter blocks
- other: Target blockset for good blocks (if --good-to-other)
- target: Filtered blockset
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
FindBSA
Build block set alignment
|
Build block set alignment:
--bsa-name arg Name of new block set alignment
--bsa-seqs arg List of sequences used for alignment, sequence groups
can be selected by genome name or chromosome name,
'all' means all sequences of block set
|
FindGeneConversion
FindGeneConversion: FindGeneConversion
FragmentDistance: Calculate distance between fragments in block
- other: Where gene conversion is searched
- target: Where results are added
|
Calculate distance between fragments in block:
--distance-file arg output file with all blocks
--distance-mask arg mask of output files (${block} is replaced with
block name)
|
FindGeneGroups
Find groups of gene parts according to pangenome
- genes: Blocks of this block set represent genes
- pangenome: Similar parts of genomes
- target: Where gene groups are written to
|
|
FindLowSimilar
Find regions of low similarity in blocks
- other: Source blocks
- target: Destination for low similarity sub-blocks
|
Find regions of low similarity in blocks:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
FixEnds
Cut bad aligned ends
|
Cut bad aligned ends:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
FragmentDistance
Calculate distance between fragments in block
|
Calculate distance between fragments in block:
--distance-file arg output file with all blocks
--distance-mask arg mask of output files (${block} is replaced with
block name)
|
FragmentFinder
Locate fragment by its sequence
- target: search in sequences, add fragments
|
Locate fragment by its sequence:
--max-matches arg (=1000) Maximum number of matches
--pattern arg Sequence searched for
|
FragmentsExpander
Expand fragments (deprecated)
|
Expand fragments (deprecated):
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--max-overlap arg (=0) max number of positions added after first overlap
occur
--mismatch-penalty arg (=1) Mismatch penalty
--ori arg (=0) direction of expansion
|
FragmentsExtender
Move block's boundaries and align only new parts
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
--extend-length-portion arg (=0) Length of extended part portion in source
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
GetData
Download genomes from Web
|
Download genomes from Web:
--data arg Output file
--remove-after arg (=0) remove file data
--table arg Table of genomes
--type arg (=fasta) Type of content downloaded (fasta|genes)
|
GetFasta
GetFasta: GetFasta
GetData: Download genomes from Web
|
Download genomes from Web:
--data arg (=genomes-raw.fasta) Output file
--remove-after arg (=0) remove file data
--table arg (=genomes.tsv) Table of genomes
|
GetGenes
GetGenes: GetGenes
GetData: Download genomes from Web
|
Download genomes from Web:
--data arg (=features.embl) Output file
--remove-after arg (=0) remove file data
--table arg (=genomes.tsv) Table of genomes
|
Hash
Print hash of blockset
|
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
|
ImportBlastHits
Import blast hits
- other: Consensuses (blocks or sequences) on which blast was run
- target: Where hits are added
|
Import blast hits:
--blast-hits arg results of blast -m 8
--blast-min-length arg (=100) min length of blast hit
|
In
Input block set
- target: Default blockset where blocks are added
|
Input block set:
--in-blocks arg input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory ('map'
or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
|
Info
Print human readable summary and statistics
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
|
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
--remove-after arg (=0) remove file out-stats
|
InputBSA
Input block set alignment
|
Input block set alignment:
--in-bsa arg input file(s) with block set alignments
|
IsPangenome
Print if block set is good pangenome
IsPangenome: Print if block set is good pangenome
AreBlocksGood: Print if all blocks in block set are good
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
- all-blast-hits: All blast hits
- blast-hits: Good blast hits
- joined: Results of joining neighbour blocks
- non-internal-hits: Non-internal blast hits
- target: Target blockset to be tested
|
Print if all blocks in block set are good:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
--out-is-pangenome arg Output file with verdict
--remove-after arg (=0) remove file out-is-pangenome
--respect-minor arg (=1) Do not check length and alignment of minor blocks
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
Any processor:
--smth-opts arg options for processor
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
|
Joiner
Join blocks
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Join blocks:
--join-max-dist arg (=-1) Max allowed distance when joining fragments
--join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=-1) Max allowed ratio of gaps' lengths (inside a
block) when joining
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
JoinerP
JoinerP: JoinerP
Filter: Filter blocks
OriByMajority: Set ori so that most nucleotides have ori=1
Rest: Add to target blocks of nucleotides, not included to other
MergeUnique: Merge unique fragments with both common neighbours
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Rest: Add to target blocks of nucleotides, not included to other
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Join blocks:
--join-max-dist arg (=-1) Max allowed distance when joining fragments
--join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=-1) Max allowed ratio of gaps' lengths (inside a
block) when joining
|
LinkEqualFragments
Link fragments equal to fragments from other block set
- other: Blockset fragments of which are searched in target blockset
- target: Blockset where fragments, equal to ones from other blockset, are replaced and blocks are marked as weak
|
|
LiteAlign
Align, move and cut gap
LiteAlign: Align, move and cut gap
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
LiteAlignLoop: LiteAlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
|
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
|
LiteFilter
Filter blocks (checks only frangment length and block size)
|
Filter blocks (checks only frangment length and block size):
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--remove-fragments arg (=1) Delete individual fragments instead of whole
block
|
LiteJoinerP
LiteJoinerP: LiteJoinerP
LiteFilter: Filter blocks (checks only frangment length and block size)
OriByMajority: Set ori so that most nucleotides have ori=1
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Filter blocks (checks only frangment length and block size):
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--remove-fragments arg (=1) Delete individual fragments instead of whole
block
Join blocks:
--join-max-dist arg (=-1) Max allowed distance when joining fragments
--join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=-1) Max allowed ratio of gaps' lengths (inside a
block) when joining
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
MafftAligner
Mafft aligner
|
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
|
MakePangenome
MakePangenome: MakePangenome
AnchorJoinerFast: AnchorJoinerFast
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
AnchorJoiner: AnchorJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
AnchorBlastJoiner: AnchorBlastJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
RemoveNames: Remove all blocks and/or sequences names
UniqueNames: Set unique names to all blocks of this block set
Rest: Add to target blocks of nucleotides, not included to other
MergeUnique: Merge unique fragments with both common neighbours
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
Any processor:
--smth-opts arg options for processor
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
|
MarkNonWeak
Mark all blocks non-weak
|
|
MergeStemJoin
MergeStemJoin: MergeStemJoin
Rest: Add to target blocks of nucleotides, not included to other
MergeUnique: Merge unique fragments with both common neighbours
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Stem: Filter out blocks not represented in at least one of genomes
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Join blocks:
--join-max-dist arg (=-1) Max allowed distance when joining fragments
--join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=-1) Max allowed ratio of gaps' lengths (inside a
block) when joining
|
MergeUnique
Merge unique fragments with both common neighbours
|
|
MetaAligner
Align blocks with one of possible aligners
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
|
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
MetaProcessor
Any processor
- other: Other blockset
- target: Target blockset
|
Any processor:
--opts arg options for processor
--processor arg processor name
|
MkDir
Create directory
|
Create directory:
--dirname arg Dir to be created
|
Move
Move all blocks from other blockset to target blockset
- other: Source from where blocks are moved
- target: Destination to where blocks are moved
|
|
MoveGaps
Move terminal letters inside
|
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
|
MoveUnchanged
Move unchanged blocks from other to target
- other: Where unchanged blocks are looked for
- target: Where unchanged blocks are moved to
|
|
MultipleAligner
Internal aligner
|
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
|
MuscleAligner
Muscle aligner
|
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
|
MutationsSequences
Create a seq. per genome of mutations and map blocks
MutationsSequences: Create a seq. per genome of mutations and map blocks
PrintMutations: Find all mutations in block
- other: Exact Stem of pangenome
- target: Where new sequences composed from mutationsare added
|
Create a seq. per genome of mutations and map blocks:
--mutation-distance arg (=0) Distance to sequence around mutation to
keep
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Find all mutations in block:
--file arg output file with all blocks
--mask arg mask of output files (${block} is replaced with block
name)
|
OldMakePangenome
Run blast and Joiner until this block set becomes pangenome (deprecated)
OldMakePangenome: Run blast and Joiner until this block set becomes pangenome (deprecated)
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Union: Add clones of blocks from other to this block set
Joiner: Join blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Filter: Filter blocks
OverlaplessUnion: Add clones of blocks from other, non-overlapping target
Clear: Remove all blocks and/or sequences from blockset
Rest: Add to target blocks of nucleotides, not included to other
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
OneByOne: Split blockset according to hits, processed one by one
Filter: Filter blocks
LiteAlign: Align, move and cut gap
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
LiteAlignLoop: LiteAlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Filter: Filter blocks
Rest: Add to target blocks of nucleotides, not included to other
RemoveNames: Remove all blocks and/or sequences names
UniqueNames: Set unique names to all blocks of this block set
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
- target: Target blockset with pre-pangenome, which is evolved to pangenome
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
--clear-seqs arg (=0) Remove sequences (warning: this makes dangling
pointers from orphaned blocks, if they remain)
Join blocks:
--join-max-dist arg (=-1) Max allowed distance when joining fragments
--join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio
when joining fragments
--join-to-gap arg (=-1) Max allowed ratio of gaps' lengths (inside a
block) when joining
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Add clones of blocks from other, non-overlapping target:
--ou-filter arg (=0) Do not copy good blocks to target, but remove bad
blocks from other
--ou-move arg (=0) Move blocks from other to target
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Blocks to consensus sequences:
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--remove-after arg (=0) remove file out-hits
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=:null) Destination of copy
Copy file:
--blast-hits-dst arg (=:null) Destination of copy
Remove all blocks and/or sequences names:
--remove-blocks-names arg (=1) Remove blocks names
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
|
OldMakePrePangenome
Run anchor finder, expand blocks and resolve overlaps (deprecated)
OldMakePrePangenome: Run anchor finder, expand blocks and resolve overlaps (deprecated)
AnchorFinder: Find anchors
Connector: Connect all the fragments (prev-next)
FragmentsExpander: Expand fragments (deprecated)
Filter: Filter blocks
OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
Filter: Filter blocks
FragmentsExpander: Expand fragments (deprecated)
OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Filter: Filter blocks
Rest: Add to target blocks of nucleotides, not included to other
- target: Target blockset with sequences on which pre-pangenome is built
|
Find anchors:
--anchor-fp arg (=0.1) Probability of false positive in Bloom
filter (first step of AnchorFinder)
--anchor-similar arg (=1) If neighbour anchors are skipped
--anchor-size arg (=20) anchor size
--max-anchor-fragments arg (=100000) Maximum number of anchors fragments to
return
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
Expand fragments (deprecated):
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
--ori arg (=0) direction of expansion
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Resolve overlaping fragments (version 2, deprecated):
--min-distance arg (=30) Min distance between fragment boundaries
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
|
OneByOne
Split blockset according to hits, processed one by one
OneByOne: Split blockset according to hits, processed one by one
Filter: Filter blocks
LiteAlign: Align, move and cut gap
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
LiteAlignLoop: LiteAlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
- other: Source of added blocks
- target: Destination of added blocks
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
|
OriByMajority
Set ori so that most nucleotides have ori=1
|
|
Output
Output block set
|
Output block set:
--out-dump-block arg (=1) dump blocks
--out-dump-seq arg (=0) dump sequences before blocks
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-file arg output file with all blocks
--out-mask arg mask of output files (${block} is replaced
with block name)
|
OutputPipe
Grace output
OutputPipe: Grace output
OriByMajority: Set ori so that most nucleotides have ori=1
Connector: Connect all the fragments (prev-next)
Rest: Add to target blocks of nucleotides, not included to other
Connector: Connect all the fragments (prev-next)
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
|
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Output block set:
--out-dump-block arg (=1) dump blocks
--out-dump-seq arg (=0) dump sequences before blocks
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-file arg output file with all blocks
--out-mask arg mask of output files (${block} is replaced
with block name)
|
OverlapFinder
Finds blocks from 'bank', overlapping with 'pattern', results are copied to 'hits'
- bank: where to find overlapping blocks
- hits: overlapping blocks from bank are copied here
- pattern: overlaps are looked for with these blocks
|
|
OverlaplessUnion
Add clones of blocks from other, non-overlapping target
- other: Source of blocks addition
- target: Destination of blocks addition
|
Add clones of blocks from other, non-overlapping target:
--ou-filter arg (=0) Do not copy good blocks to target, but remove bad
blocks from other
--ou-move arg (=0) Move blocks from other to target
|
OverlapsResolver
Resolve overlaping fragments (deprecated)
|
|
OverlapsResolver2
Resolve overlaping fragments (version 2, deprecated)
- other: Where input blocks are taken
- target: Where resolved blocks are added
|
Resolve overlaping fragments (version 2, deprecated):
--min-distance arg (=30) Min distance between fragment boundaries
|
Pangenome
Pangenome: Pangenome
In: Input block set
MakePangenome: MakePangenome
AnchorJoinerFast: AnchorJoinerFast
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
AnchorJoiner: AnchorJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
AnchorBlastJoiner: AnchorBlastJoiner
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
Hash: Print hash of blockset
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
RemoveNames: Remove all blocks and/or sequences names
UniqueNames: Set unique names to all blocks of this block set
Rest: Add to target blocks of nucleotides, not included to other
MergeUnique: Merge unique fragments with both common neighbours
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
OutputPipe: Grace output
OriByMajority: Set ori so that most nucleotides have ori=1
Connector: Connect all the fragments (prev-next)
Rest: Add to target blocks of nucleotides, not included to other
Connector: Connect all the fragments (prev-next)
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
|
Input block set:
--in-blocks arg (=genomes-renamed.fasta)
input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Print hash of blockset:
--hash-file arg Output file with blockset hash
--remove-after arg (=0) remove file hash-file
Any processor:
--smth-opts arg options for processor
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
Connect all the fragments (prev-next):
--connect-circular arg (=0) Connect last and first fragments of circular
chromosomes
Output block set:
--out-dump-block arg (=1) dump blocks
--out-dump-seq arg (=0) dump sequences before blocks
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-file arg (=pangenome.bs) output file with all blocks
--out-mask arg mask of output files (${block} is replaced
with block name)
|
Partition
Split fragments of target according to fragments of other
- other: Splitting rules (boundaries)
- target: Blocks to split
|
|
Pipe
|
|
PostProcessing
Postprocess pangenome
PostProcessing: Postprocess pangenome
In: Input block set
BlockInfo: Print information about blocks
Info: Print human readable summary and statistics
Stats: Print human readable summary and statistics about block set
Hash: Print hash of blockset
Union: Add clones of blocks from other to this block set
Stem: Filter out blocks not represented in at least one of genomes
MkDir: Create directory
IsPangenome: Print if block set is good pangenome
AreBlocksGood: Print if all blocks in block set are good
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
AddBlastBlocks: Add blast hits as blocks
SequencesFromOther: Copy sequences from other block set
ConSeq: Blocks to consensus sequences
FilterSeqs: FilterSeqs
BlastFinder: BlastFinder
Output: Output block set
BlastRunner: Blast runner
ImportBlastHits: Import blast hits
FileCopy: Copy file
FileCopy: Copy file
FileRemover: Remove file
FileRemover: Remove file
DeConSeq: Build blocks from blocks, set to sequences of blocks of other
Clear: Remove all blocks and/or sequences from blockset
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
MkDir: Create directory
PrintMutations: Find all mutations in block
MutationsSequences: Create a seq. per genome of mutations and map blocks
PrintMutations: Find all mutations in block
Output: Output block set
Output: Output block set
MkDir: Create directory
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
ConsensusTree: Print consensus tree
BranchGenerator: BranchGenerator
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
ConsensusTree: Print consensus tree
BranchGenerator: BranchGenerator
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
FragmentDistance: Calculate distance between fragments in block
ChrBSA: Build block set alignments from all chromosomes
FindBSA: Build block set alignment
PrintBSA: Print block set alignment
ExactStemBSA: Replace all non-stem blocks with gaps in block set alignment
PrintBSA: Print block set alignment
SplitRepeats: Find splittable blocks-repeats and split them
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
FindLowSimilar: Find regions of low similarity in blocks
UniqueNames: Set unique names to all blocks of this block set
Output: Output block set
BlockInfo: Print information about blocks
|
Input block set:
--in-blocks arg (=pangenome.bs) input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory ('map'
or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Print information about blocks:
--info-mask arg mask of output files (${block} is replaced with block
name)
Print human readable summary and statistics about block set:
--out-stats arg (=pangenome.info) Output file with statistics
--remove-after arg (=0) remove file out-stats
Print hash of blockset:
--hash-file arg (=pangenome.hash) Output file with blockset hash
Print if all blocks in block set are good:
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if
alignment is known)
--min-identity arg (=0.9) Minimum block identity (only if
alignment is known, columns without
gaps as 1, columns with gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max
- min) / avg)
--out-is-pangenome arg (=check/isgood)
Output file with verdict
--respect-minor arg (=1) Do not check length and alignment of
minor blocks
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
FilterSeqs:
--blast-min-length arg (=100) min length of blast hit
Output block set:
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-mask arg mask of output files (${block} is replaced
with block name)
Blast runner:
--blast-plus arg (=0) Use blast+ (otherwise blast)
--evalue arg (=0.001) Max acceptable e-value of hit
--skip-low-complexity-regions arg (=0)
Tell blast not to search in low
complexity regions
Copy file:
--blast-cons-dst arg (=check/consensuses.fasta)
Destination of copy
Copy file:
--blast-hits-dst arg (=check/hits.blast)
Destination of copy
Remove all blocks and/or sequences from blockset:
--clear-blocks arg (=1) Remove blocks
--clear-bsas arg (=1) Remove block set alignments
Any processor:
--smth-opts arg options for processor
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Output block set:
--out-dump-block arg (=1) dump blocks
--out-dump-seq arg (=0) dump sequences before blocks
Find all mutations in block:
--mask arg mask of output files (${block} is replaced with block
name)
Create a seq. per genome of mutations and map blocks:
--mutation-distance arg (=1) Distance to sequence around mutation to keep
Find all mutations in block:
--file arg output file with all blocks
Build and print newick trees of blocks:
--tree-file arg (=trees/all_trees.tsv)
output file with all blocks
--tree-mask arg mask of output files (${block} is
replaced with block name)
--tree-method arg (=nj) Method of tree construction (upgma/nj)
Calculate distance between fragments in block:
--tree-distance-file arg output file with all blocks
--tree-distance-mask arg mask of output files (${block} is replaced
with block name)
Print consensus tree:
--nj-bootstrap-diagnostic-min-block arg (=4)
Minimum block used to calculate number
of diagnostic positions
--nj-bootstrap-diagnostic-stem arg (=1)
If only stem blocks are used to
calculate number of diagnostic
positions
--nj-bootstrap-percent arg (=0) If bootstrap is percentage
--nj-bootstrap-print arg (=before-length)
How to print bootstrap values ('no',
'in-braces', 'before-length')
--nj-bootstrap-values arg (=diagnostic-positions)
What to use as bootstrap values
('blocks', 'length',
'diagnostic-positions')
--nj-out-branch arg (=trees/nj.branch)
Output file with branches
--nj-out-consensus-tree arg (=trees/nj-constree.tre)
Output file with consensus tree
--nj-print-branches arg (=1) If branches are logged
--nj-remove-after arg (=0) remove file out-consensus-tree
--nj-tree-pseudo-leafs arg (=1) Convert each leaf to short branch
(workaround to make viewer programs
show bootstrap values of leafs)
BranchGenerator:
--nj-log arg (=1) block weight is log(number of nonidentical
positions) (otherwse linear)
--nj-min-noident arg (=5) Minimum number of nonidentical positions in block
Build and print newick trees of blocks:
--nj-tree-file arg output file with all blocks
--nj-tree-mask arg mask of output files (${block} is replaced with
block name)
Calculate distance between fragments in block:
--nj-tree-distance-file arg output file with all blocks
--nj-tree-distance-mask arg mask of output files (${block} is
replaced with block name)
Print consensus tree:
--upgma-bootstrap-diagnostic-min-block arg (=4)
Minimum block used to calculate number
of diagnostic positions
--upgma-bootstrap-diagnostic-stem arg (=1)
If only stem blocks are used to
calculate number of diagnostic
positions
--upgma-bootstrap-percent arg (=0) If bootstrap is percentage
--upgma-bootstrap-print arg (=before-length)
How to print bootstrap values ('no',
'in-braces', 'before-length')
--upgma-bootstrap-values arg (=diagnostic-positions)
What to use as bootstrap values
('blocks', 'length',
'diagnostic-positions')
--upgma-out-branch arg (=trees/upgma.branch)
Output file with branches
--upgma-out-consensus-tree arg (=trees/upgma-constree.tre)
Output file with consensus tree
--upgma-print-branches arg (=1) If branches are logged
--upgma-remove-after arg (=0) remove file out-consensus-tree
--upgma-tree-pseudo-leafs arg (=1) Convert each leaf to short branch
(workaround to make viewer programs
show bootstrap values of leafs)
BranchGenerator:
--upgma-log arg (=1) block weight is log(number of nonidentical
positions) (otherwse linear)
--upgma-min-noident arg (=5) Minimum number of nonidentical positions in
block
Build and print newick trees of blocks:
--upgma-tree-file arg output file with all blocks
--upgma-tree-mask arg mask of output files (${block} is replaced with
block name)
Calculate distance between fragments in block:
--upgma-tree-distance-file arg output file with all blocks
--upgma-tree-distance-mask arg mask of output files (${block} is
replaced with block name)
number of threads
Calculate distance between fragments in block:
--distance-file arg (=trees/distances.tsv)
output file with all blocks
--distance-mask arg mask of output files (${block} is
replaced with block name)
Build block set alignment:
--bsa-name arg Name of new block set alignment
--bsa-seqs arg List of sequences used for alignment, sequence groups
can be selected by genome name or chromosome name,
'all' means all sequences of block set
Print block set alignment:
--bsa-blocks arg (=1) Print block names in alignment (else fragments)
--bsa-conservative arg (=1) Print conservative columns line
--bsa-orientation arg (=1) Print orientation after fragment
Replace all non-stem blocks with gaps in block set alignment:
--bsa-min-length arg (=100) Min length of accepted block
--bsa-stem-improve arg (=1) Move fragments and remove pure gaps
Find splittable blocks-repeats and split them:
--min-diagnostic-mutations arg (=2) Min number of diagnostic mutations in
part of block splitted out
--min-mutations arg (=4) Min number of mutations in candidate
block to be splited
|
Prepare
Prepare: Prepare
GetFasta: GetFasta
GetData: Download genomes from Web
Rename: Rename
In: Input block set
ReplaceNames: Replace names in downloaded sequences according to table
Output: Output block set
GetGenes: GetGenes
GetData: Download genomes from Web
AddGenes: Add genes from EBI genes description
Output: Output block set
|
Download genomes from Web:
--remove-after arg (=0) remove file data
--table arg (=genomes.tsv) Table of genomes
Input block set:
--in-blocks arg (=genomes-raw.fasta) input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Output block set:
--out-dump-block arg (=1) dump blocks
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-file arg (=genomes-renamed.fasta)
output file with all blocks
--out-mask arg mask of output files (${block} is
replaced with block name)
Add genes from EBI genes description:
--in-genes arg (=features.embl) input database files with genes
--product arg (=1) Append product name to block name
Output block set:
--out-dump-seq arg (=0) dump sequences before blocks
|
PrintBSA
Print block set alignment
|
Print block set alignment:
--bsa-blocks arg (=1) Print block names in alignment (else fragments)
--bsa-conservative arg (=1) Print conservative columns line
--bsa-orientation arg (=1) Print orientation after fragment
--out-bsa arg Output file with block set alignment
--remove-after arg (=0) remove file out-bsa
|
PrintGeneGroups
Print information about gene groups
- pangenome: Similar parts of genomes
- target: Gene groups, weak blocks
|
Print information about gene groups:
--file arg output file with all blocks
--mask arg mask of output files (${block} is replaced with block
name)
|
PrintMutations
Find all mutations in block
|
Find all mutations in block:
--file arg output file with all blocks
--mask arg mask of output files (${block} is replaced with block
name)
|
PrintOverlaps
Print ASCII diagram with all fragments overlapping with a block
- other: Container blocks (outer)
- target: Contained blocks (internal)
|
Print ASCII diagram with all fragments overlapping with a block:
--overlaps-bottom-scale arg (=1) if bottom scale is printed
--overlaps-file arg output file with all blocks
--overlaps-marker arg (=*) char used to mark fragment
--overlaps-mask arg mask of output files (${block} is replaced
with block name)
--overlaps-print-block arg (=1) if block name is printed
--overlaps-print-fragment arg (=0) if fragment name is printed
--overlaps-top-scale arg (=1) if top scale is printed
--overlaps-width arg (=76) max allowed line width of output
|
PrintPartition
Print overlaps between two block sets as table
- other: Blocks with which overlaps are searched
- target: Blocks in which overlaps are searched
|
Print overlaps between two block sets as table:
--file arg output file with all blocks
--mask arg mask of output files (${block} is replaced with block
name)
|
PrintTree
Build and print newick trees of blocks
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
|
Build and print newick trees of blocks:
--tree-file arg output file with all blocks
--tree-mask arg mask of output files (${block} is replaced with block
name)
--tree-method arg (=nj) Method of tree construction (upgma/nj)
Calculate distance between fragments in block:
--tree-distance-file arg output file with all blocks
--tree-distance-mask arg mask of output files (${block} is replaced
with block name)
|
Processor
|
|
ReAlign
Realign blocks
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
|
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
|
RemoveAlignment
Remove alignment from blocks
|
|
RemoveMinorBlocks
Remove minor blocks (name starts with "m")
|
|
RemoveNames
Remove all blocks and/or sequences names
|
Remove all blocks and/or sequences names:
--remove-blocks-names arg (=1) Remove blocks names
--remove-seqs-names arg (=1) Remove seqences names
|
RemoveWeak
Remove weak blocks
|
|
RemoveWithSameName
Remove from target blocks with names from other
- other: Reference blocks
- target: Modified blockset
|
|
Rename
Rename: Rename
In: Input block set
ReplaceNames: Replace names in downloaded sequences according to table
Output: Output block set
|
Input block set:
--in-blocks arg (=genomes-raw.fasta) input fasta file(s) with blocks
--row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
--seq-storage arg (=compact_low_n) way of storing sequences in memory
('asis', 'compact' or 'compact_low_n')
Replace names in downloaded sequences according to table:
--table arg (=genomes.tsv) Table of genomes
Output block set:
--out-dump-block arg (=1) dump blocks
--out-export-alignment arg (=1) use alignment information if available
--out-export-contents arg (=1) print contents of fragments
--out-file arg (=genomes-renamed.fasta)
output file with all blocks
--out-mask arg mask of output files (${block} is
replaced with block name)
|
ReplaceNames
Replace names in downloaded sequences according to table
- target: Modified blockset
|
Replace names in downloaded sequences according to table:
--table arg Table of genomes
|
Rest
Add to target blocks of nucleotides, not included to other
- other: Input blocks
- target: Where created blocks are added
|
Add to target blocks of nucleotides, not included to other:
--skip-rest arg (=0) do not add unique fragments to block set
|
SameChr
Filter out blocks fragments located on different chromosomes
|
|
SelfOverlapsResolver
Resolve self-overlaps
|
|
SequencesFromOther
Copy sequences from other block set
- other: Source
- target: Destination
|
|
SimilarAligner
Align blocks with high similarity
|
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
|
SplitExtendable
Find extendable subblocks
SplitExtendable: Find extendable subblocks
Filter: Filter blocks
FragmentsExtender: Move block's boundaries and align only new parts
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
- other: source blocks
- target: output, extended good blocks
|
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-identity arg (=0.9) Minimum block identity (only if alignment is
known, columns without gaps as 1, columns with
gaps as 0.5)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Move block's boundaries and align only new parts:
--extend-length arg (=100) Length of extended part
--extend-length-portion arg (=0) Length of extended part portion in source
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
|
SplitRepeats
Find splittable blocks-repeats and split them
SplitRepeats: Find splittable blocks-repeats and split them
PrintTree: Build and print newick trees of blocks
FragmentDistance: Calculate distance between fragments in block
- other: Input blocks (const)
- target: Destination for weak blocks
|
Find splittable blocks-repeats and split them:
--min-diagnostic-mutations arg (=2) Min number of diagnostic mutations in
part of block splitted out
--min-mutations arg (=4) Min number of mutations in candidate
block to be splited
Build and print newick trees of blocks:
--tree-file arg output file with all blocks
--tree-mask arg mask of output files (${block} is replaced with block
name)
--tree-method arg (=nj) Method of tree construction (upgma/nj)
Calculate distance between fragments in block:
--tree-distance-file arg output file with all blocks
--tree-distance-mask arg mask of output files (${block} is replaced
with block name)
|
Stats
Print human readable summary and statistics about block set
|
Print human readable summary and statistics about block set:
--out-stats arg Output file with statistics
--remove-after arg (=0) remove file out-stats
|
Stem
Filter out blocks not represented in at least one of genomes
|
Filter out blocks not represented in at least one of genomes:
--exact arg (=0) Require exactly one fragment in each genome
|
StickBoundaries
Turn nearby fragment boundaries into one
|
Turn nearby fragment boundaries into one:
--min-distance arg (=30) Min distance between fragment boundaries
|
Subtract
Remove from target fragments that have overlaps with other
- other: Blocks to which overlaps are found
- target: Blocks which are removed if overlap with blocks from other
|
Remove from target fragments that have overlaps with other:
--subtract-equal arg (=0) Delete only equal fragments
|
TrySmth
Try to do something, align (and filter), restore original if worse
TrySmth: Try to do something, align (and filter), restore original if worse
Union: Add clones of blocks from other to this block set
UniqueNames: Set unique names to all blocks of this block set
MetaProcessor: Any processor
RemoveNames: Remove all blocks and/or sequences names
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
Move: Move all blocks from other blockset to target blockset
AddingLoopBySize: Align and move overlapless from other to target
AddingLoop: AddingLoop
Align: LiteAlign + Filter + SelfOverlapsResolver
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
SelfOverlapsResolver: Resolve self-overlaps
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
AlignLoop: AlignLoop
MoveGaps: Move terminal letters inside
CutGaps: Cut terminal gaps
Filter: Filter blocks
SmthUnion: SmthUnion
UniqueNames: Set unique names to all blocks of this block set
ReAlign: Realign blocks
MetaAligner: Align blocks with one of possible aligners
ExternalAligner: External aligner
MafftAligner: Mafft aligner
MuscleAligner: Muscle aligner
MultipleAligner: Internal aligner
SimilarAligner: Align blocks with high similarity
DummyAligner: Align by adding gaps to sequences
Filter: Filter blocks
Clear: Remove all blocks and/or sequences from blockset
|
Any processor:
--smth-opts arg options for processor
--smth-processor arg processor name
Align blocks with one of possible aligners:
--aligner-type arg (=similar) Type of aligner (external, mafft, muscle,
multiple, similar, dummy). Specify several
types, separated by comma, the first working
one will be used or the last one if all fail.
--row-type arg (=compact) way of storing alignments in memory ('map' or
'compact')
External aligner:
--aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
Mafft aligner:
--mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
Template of command for external
aligner
--mafft-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Muscle aligner:
--muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
Template of command for external
aligner
--muscle-row-type arg (=compact) way of storing alignments in memory
('map' or 'compact')
Internal aligner:
--batch arg (=100) batch size for pair aligner
--gap-penalty arg (=2) Gap open or extension penalty
--gap-range arg (=15) Max distance from main diagonal of considered
states of pair alignment. The more gap_range, the
more time.
--max-errors arg (=11) Max number of errors in pair alignment
--mismatch-penalty arg (=1) Mismatch penalty
Align blocks with high similarity:
--aligned-check arg (=10) Min equal aligned part
--gap-check arg (=2) Min number of equal columns after single gap
--min-identity arg (=0.9) Min identity of block
--min-length arg (=100) Min length of fragment
--mismatch-check arg (=1) Min number of equal columns after single mismatch
Move terminal letters inside:
--max-tail arg (=3) Max length of tail
--max-tail-to-gap arg (=1) Max tail length to gap length ratio
Cut terminal gaps:
--cut-strict arg (=0) cut more gaps
Filter blocks:
--find-subblocks arg (=1) Find and add good subblocks of bad blocks
--good-to-other arg (=0) Do not remove bad blocks, but copy good blocks to
other blockset
--max-block arg (=-1) Maximum block size (-1 = all)
--max-fragment arg (=-1) Maximum fragment length (-1 = all)
--max-gaps arg (=0.2) Max gap columns percentage
--max-identity arg (=1) Maximum block identity
--max-spreading arg (=0.2) Maximum fragment length spreading
--min-block arg (=2) Minimum block size
--min-fragment arg (=100) Minimum fragment length
--min-gaps arg (=0) Min gap columns percentage (only if alignment is
known)
--min-spreading arg (=0) Minimum fragment length spreading ((max - min) /
avg)
Realign blocks:
--force-realign arg (=0) If realigned block is worse, realign anyway
|
Union
Add clones of blocks from other to this block set
- other: Source of blocks copying
- target: Destination of blocks copying
|
|
UniqueNames
Set unique names to all blocks of this block set
|
|