BOL: Related items

Mathivanan Lab

Fri, 20 Sep 2013 13:09:38 -0500

The major research interests are in exploring the role of extracellular matrix components (soluble secreted proteins and membrane vesicles) in cancer and intercellular communication. The lab integrates proteomic, genomic and bioinformatics methodologies to explore cancer cells.

More at http://www.mathivananlab.org/index.html

http://scholar.google.com/citations?user=U6PyEdYAAAAJ&hl=en

A Step-by-Step Guide to Running BLAST Offline

LEGE — Sat, 07 Dec 2024 22:32:37 -0600

BLAST (Basic Local Alignment Search Tool) is a powerful algorithm used to compare nucleotide or protein sequences to sequence databases, identifying regions of similarity. Running BLAST offline provides more control, ensures data security, and allows customization for specific research needs. Here’s a detailed guide to set up and run BLAST locally on your system.

Step 1: Install BLAST

Download BLAST:
- Visit the NCBI BLAST+ download page to download the appropriate version for your operating system (Windows, macOS, or Linux).
Install BLAST:
- Extract the downloaded archive. For Linux/Mac, use:
```
tar -xvzf ncbi-blast-*.tar.gz
cd ncbi-blast-*
```
- Add the BLAST binary folder to your system PATH for easier access:
```
export PATH=$PATH:/path/to/ncbi-blast-*/bin
```
Verify Installation:
Run the following command to ensure BLAST is installed correctly:
```
blastn -version
```

Step 2: Prepare a Local Database

To run BLAST offline, you’ll need a sequence database.

Download a Pre-Built Database (Optional):
- NCBI provides ready-to-use databases such as nt, nr, and Swiss-Prot. Use the update_blastdb.pl script (bundled with BLAST) to download these:
```
update_blastdb.pl --decompress nt
```
Create a Custom Database:
If you have specific sequences to use as a database:
- Prepare a FASTA file containing the sequences.
- Use makeblastdb to create a database:
```
makeblastdb -in your_sequences.fasta -dbtype [nucl|prot] -out custom_db
```
  Replace [nucl|prot] with nucl for nucleotide sequences or prot for protein sequences.

Step 3: Prepare the Query Sequence

Save your query sequence(s) in FASTA format.
Ensure the file is properly formatted, with a header line starting with > followed by the sequence name, and the sequence on subsequent lines.

Example:

>query_sequence
ATGCGTAGCTAGCGTAGCTAGCTAGCTA

Step 4: Run BLAST

Choose the Appropriate BLAST Tool:
Depending on your data type:
- blastn: For nucleotide-nucleotide searches.
- blastp: For protein-protein searches.
- blastx: Translates nucleotide sequences into proteins and compares them to a protein database.
- tblastn: Compares protein sequences to a nucleotide database.
- tblastx: Translates both nucleotide query and database sequences.
Run the Command:
Example command for blastn:
```
blastn -query query.fasta -db custom_db -out results.txt -outfmt 6 -evalue 1e-5
```
Explanation of Parameters:
- -query: Specifies the query file.
- -db: Points to the local database.
- -out: Output file name.
- -outfmt: Output format (e.g., 6 for tabular format).
- -evalue: E-value cutoff for significance.

Step 5: Interpret Results

Output Formats:
- Default (outfmt 0): Human-readable format.
- Tabular (outfmt 6): Includes fields like query ID, subject ID, percent identity, alignment length, etc.
Analyze Results:
Use tools like grep, Python, or R to parse and filter results for downstream analysis.

Step 6: Optimize Performance

For large datasets, BLAST can be resource-intensive. To improve performance:

Multithreading:
Use the -num_threads option to leverage multiple CPU cores:

blastn -query query.fasta -db custom_db -out results.txt -num_threads 4

Database Subsetting:
Split large databases into smaller chunks for faster searches.
Adjust Parameters:
- Lower the -evalue threshold for stricter matches.
- Use -max_target_seqs to limit the number of results per query.

Step 7: Update Databases (Optional)

If using NCBI databases, regularly update them to ensure the inclusion of the latest sequences:

update_blastdb.pl --decompress nt

Conclusion

Running BLAST offline is a straightforward process that offers flexibility and security for bioinformaticians working with sensitive data. By following this guide, you can harness the power of BLAST to analyze sequences efficiently and gain valuable biological insights.

For advanced use cases, explore BLAST’s customization options, such as custom scoring matrices, filtering, and iterative searches with tools like PSI-BLAST. Happy BLASTing!

Junior Research Fellow @ IIT

Sat, 21 Sep 2013 18:04:50 -0500

Applications are invited from the citizens of India for filling up the following temporary position for the sponsored project undertaken in the Department of Biosciences and Bioengineering of this Institute. The position is temporary initially for a period of 1 Year and tenable only for the duration of the project. The requisite qualification & experience etc. are given below:

Project Code, Project Title & Funding Agency
13DST016 : "Studies on the component of mimivirus DNA replication machinery" (Department of Science & Technology)

Position & Salary
Junior Research Fellow (1 Post )
Consolidated salary
Rs.16000/- p.m. + HRA
Qualification
MSc or MTech or BTech or BE in one of the following branches with first class-Biochemistry, Microbiology, genetic Engineering, Biotechnology, Medical Microbiology, Bioinformatics, life sciences etc.
Job Profile
Project involves virus culturing and purification, cloning, protein purification and measurement of helicase, primase, nuclease, translocase activities using various methods. Person should be highly motivated and some experience in cloning and protein purification is desirable. Experience in handling insect cell lines will be an added advantage.

More at http://www.ircc.iitb.ac.in/IRCC-Webpage/rnd/RecruitmentGenerateCircular.jsp?srno=2013086

Public Databases for Bioinformatics !

Jit — Tue, 23 Mar 2021 05:32:15 -0500

https://www.nature.com/articles/s41467-020-17155-y

Server Infrastructure:

File Server:

dhara: Synology 3614 Storage Appliance
4 Core Xeon
108TB disk storage
10Gb ethernet to SCG3
Access atx: dhara:5000
Has btsync server (try it - its much better than dropbox)

Compute Servers:

nandi: Kundaje and Phi Server
24 intel cores
256GB RAM
500GB of SSD storage 
36TB RAID6 local storage
4 Intel Phi's (space for 4 more GPU's)


durga: Montgomery and sensitive data
24 intel cores
256GB RAM
500GB of SSD RAID0 storage 
60TB RAID6 local storage

mitra: Bassik and Web/DB Server
24 core
256GB RAM 
500GB of SSD RAID0 storage 
36TB RAID6 local storage

vayu: Kundaje GPU server
4 core
64GB RAM 
200GB of SSD storage 
8TB RAID10 local storage
4 Nvidia GTX 970 4GB GPUs

amold: Bickel and SGE server
32 AMD core
128GB RAM 
200GB of SSD storage 
12TB RAID5 local storage

wotan: Bickel and SGE server
64 AMD core
256GB RAM 
200GB of SSD storage 
12TB RAID5 local storage

Filesystem:

/users/$USER
default home directory
full backups nightly 
nfs mount to dhara
should store code, papers, and other highly processed data here

/mnt/data/
globally accessible data
should store common data here
e.g. genomes and indexes, annotations, ENCODE data  
if you dont want this to count towards your quote you must chown

/mnt/lab_data/$LAB/
lab accessible data
should store lab project data here 
e.g. ATAC-seq prediction data, enhancer prediction, motif calls

/srv/scratch/$USER
fast local storage
not backed up, but on raid and data will never be deleted
most analysis should be performed here

/srv/persistent/$USER
fast local storage
synced nightly, but not backed up
       ie if the hard drives fail or you delete something and notice 
       within 24 hours we can recover. Otherwise not. (vs home which is 
       properly backed up )  
intermediate analysis products that would be hard to recover should be stored here 
       e.g. stochastic analysis results that need to be kept so that paper 
       results can be reproduced

/srv/www/$LABNAME/
web accessible from mitra.stanford.edu
*NOT BACKED UP*

Some parallel programming patterns:

# gzip a bunch of files
parallel gzip -- *.FILESTOGZIP

# fork example in python:
(for more detailed examples look at 
 https://github.com/nboley/grit/ grit/lib/multiprocessing_utils.py)

import os
import time
import random

import multiprocessing

class ProcessSafeOPStream( object ):
    def __init__( self, writeable_obj ):
        self.writeable_obj = writeable_obj
        self.lock = multiprocessing.Lock()
        self.name = self.writeable_obj.name
        return
    
    def write( self, data ):
        self.lock.acquire()
        self.writeable_obj.write( data )
        self.writeable_obj.flush()
        self.lock.release()
        return
    
    def close( self ):
        self.writeable_obj.close()

def worker(queue, ofp):
    # Try without this
    random.seed()
    while True:
        i = queue.get()
        if i == 'FINISHED': return
        # simulate an expensive function
        x = random.random()
        time.sleep(x/10)
        print i, x
        ofp.write("%i\t%s\n" % (i, x))

NSIMS = 10000
NPROC = 25

# populate queue
todo = multiprocessing.Queue()
for i in xrange(NSIMS): todo.put(i)
for i in xrange(NPROC): todo.put('FINISHED')

ofp = ProcessSafeOPStream( open("output.txt", "w") )

pids = []
for i in xrange(NPROC):
    pid = os.fork()
    if pid == 0:
       worker(todo, ofp)
       os._exit(0)
    else:
       pids.append(pid)  

for pid in pids:
    os.waitpid(pid, 0)

ofp.close()

print "FINISHED"

For use case 1 we obtained the following ENCODE and ROADMAP datasets https://www.encodeproject.org/files/ENCFF446WOD/@@download/ENCFF446WOD.bed.gz, https://www.encodeproject.org/files/ENCFF546PJU/@@download/ENCFF546PJU.bam, https://www.encodeproject.org/files/ENCFF059BEU/@@download/ENCFF059BEU.bam. Blacklisted regions were obtained from http://mitra.stanford.edu/kundaje/akundaje/release/blacklists/hg38-human/hg38.blacklist.bed.gz. The human genome version hg38 was obtained from http://hgdownload.cse.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz.

For use case 2 we used the set of narrowPeak files summarized in https://github.com/wkopp/janggu_usecases/tree/master/extra/urls.txt (archived version v1.0.1). The human genome version hg19 was obtained from http://hgdownload.cse.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz

For use case 3 we used the ENCODE datasets https://www.encodeproject.org/files/ENCFF591XCX/@@download/ENCFF591XCX.bam, https://www.encodeproject.org/files/ENCFF736LHE/@@download/ENCFF736LHE.bigWig, https://www.encodeproject.org/files/ENCFF177HHM/@@download/ENCFF177HHM.bam as we as the GENCODE annotation v29 from ftp://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_human/release_29/gencode.v29.annotation.gtf.gz.

Address of the bookmark: http://mitra.stanford.edu/

3 days intensive course on Understanding 'omics data in Basel, Switzerland, 19-21st November

Mon, 23 Sep 2013 10:46:57 -0500

Benefits for the participants

- Plan more efficient experiments
- Correctly interpret results
- Communicate results in publications more effectively

The course focus is on methodologies, not on particular software tools. After the course participants should be able to apply the methods in their respective environment. However, during the course, hands-on sessions will be performed using the Genedata Expressionist® software, which enables participants to quickly apply the discussed methods and visualize results. No previous knowledge on Expressionist® is required; access to the software is free of charge during the course.

More @ http://www.dixa-fp7.eu/dixa-training/dixa-training-agenda/genedata-academy#!

Anders Krogh Lab

Mon, 30 Sep 2013 19:07:40 -0500

In a lot of my work in bioinformatics, I have been using hidden Markov models (HMMs). As a postdoc with David Haussler at UCSC we developed the so-called profile HMMs (refs). Since then I have applied HMMs to membrane proteins (refs) and gene identification (refs) and have worked on methods for such things as discriminative estimation of HMMs (refs) and alternative decoding algorithms etc. (refs).

Now my main interests are in gene regulation, where we work on promoter analysis; non-coding RNA, where miRNAs and structure prediction are the main areas; and protein structure, where the group is working on methods for structure prediction from sequence. To read more about these topics, please see the research pages.

Lab page @ http://wiki.binf.ku.dk/User:Krogh

jobTree based python wrapper to run the genome simulation tool suite Evolver

Jit — Fri, 08 Dec 2017 16:26:32 -0600

evolverSimControl (eSC) can be used to simulate multi-chromosome genome evolution on an arbitrary phylogeny (Newick format). In addition to simply running evolver, eSC also automatically creates statistical summaries of the simulation as it runs including text and image files. Also included are convenience scripts to: check on a running simulation and see detailed status and logging information; extract fasta sequence files from the leaf nodes of a completed simulation; extract pairwise multiple alignment files (.maf) from leaf and branch nodes from a completed simulation and with the help of mafJoin, join them together into a single maf covering the entire simulation.

Address of the bookmark: https://github.com/dentearl/evolverSimControl

CRCRI Bioinfomatics Walk In on 08.10.2013

Fri, 27 Sep 2013 10:59:53 -0500

Walk-in-Interview for recruitment of one Project Fellow for a period of 10 months purely on temporary basis is proposed to be held at Central Tuber Crops Research Institute, Sreekariyam, Thiruvananthapuram for a KSCSTE funded project entitled “PARTICIPATORY DEVELOPMENT OF A WEB BASED USER FRIENDLY CASSAVA EXPERT SYSTEM”

Salary: Rs. 10,000/- per month.

Age limit: 35 for men and 40 for women & SC/ST.

Qualification: First class in M. Sc (Agriculture)/MCA/M.Sc (IT)/ M. Sc (Computer Application)/M.Sc (Bioinformatics)/M.Sc (Geoinformatics).

Desirable: Two years experience in web design and web programming.

Date & time of interview: 08.10.2013, 10 am

Interested candidates may appear for an interview at this institute along with their application in plain paper containing the following particulars viz. (1) Name (2) Father/Husband/Guardian’s Name (3) date of birth & age as on 01.10.2013 (4) Permanent address (5) Address for communication (6) Email address and Telephone No. with code (7) Qualification (8) National fellowship like ICAR/CSIR/UGC etc. if any (9) Whether SC/ST/OBC (10) Details of experience (Attested copies of degree certificate, proof of age, mark sheets). Original certificates should be produced for verification.

No TA/DA will be admissible to the candidates attending the test. The selected candidate will have to join immediately.

Advertisement: http://www.ctcri.org/careers/mithra_SRF.doc

Magic-BLAST: a tool for mapping large next-generation RNA or DNA sequencing runs against a whole genome or transcriptome.

Jit — Tue, 26 Dec 2017 22:23:39 -0600

Magic-BLAST is a tool for mapping large next-generation RNA or DNA sequencing runs against a whole genome or transcriptome. Each alignment optimizes a composite score, taking into account simultaneously the two reads of a pair, and in case of RNA-seq, locating the candidate introns and adding up the score of all exons. This is very different from other versions of BLAST, where each exon is scored as a separate hit and read-pairing is ignored.

Magic-BLAST incorporates within the NCBI BLAST code framework ideas developed in the NCBI Magic pipeline, in particular hit extensions by local walk and jump (http://www.ncbi.nlm.nih.gov/pubmed/26109056), and recursive clipping of mismatches near the edges of the reads, which avoids accumulating artefactual mismatches near splice sites and is needed to distinguish short indels from substitutions near the edges.

Address of the bookmark: https://ncbi.github.io/magicblast/

Bioinformatics Algorithms (Part 1) with Pavel Pevzner, Phillip E. C. Compeau,

Mon, 30 Sep 2013 11:34:09 -0500

The course Bioinformatics Algorithms (Part 1) by Pavel Pevzner, Phillip E. C. Compeau, and Nikolay Vyahhi from University of California, San Diego will be offered free of charge to everyone on the Coursera platform. Sign up at http://www.coursera.org/course/bioinformatics.