介绍
集群公共平台软件调用主要有2种方式
module¶
module使用之前需要配置，见 Module使用
目前module中包含几百个常用软件及常用库文件，另外也可以使用module调用常用生信数据库，见 NR等常用生信数据库使用。
module av 查看所有软件
module av a 查看软件名以a开头的软件
module av A 查看软件名以A开头的软件
modul load augustus/3.3.3 载入这个版本的augustus
因为有的软件名称首字母大小写不确定，搜的时候可以都大小写都可尝试。
singularity¶
singularity是专为HPC环境开发的一款容器，核心优点有3个：不需要常驻服务，使用时消耗的资源非常少；不需要特殊权限，普通用户就可以使用，多用户环境中安全性有保障；可直接使用docker镜像。
集群上下载了部分安装比较复杂的软件，放在/share/Singularity/下，可以直接调用，部分镜像列表见 集群singularity镜像列表。
具体的使用方式见 集群文档 Singularity使用。
ai agent skill¶
通过将一些集群软件使用注意事项及相应文档等提炼为 ncpgr-software skill，可以协助用户更好地使用本集群。
ncpgr-software skill 专注集群软件使用注意事项与优化指南。聚焦各软件的坑点、加速技巧、资源申请建议与软件选型推荐、集群已安装软件搜索，同时联动 ncpgr-lsf skill，可帮助用户编写 lsf 作业脚本。
Note
skill 会根据实际情况更新进化，因此下面安装 skill 时建议使用软连接而不是拷贝的方式，以保证使用的 skill 一直是最新版本。
这里以 Claude Code 为例，其它 AI agent 使用原则类似。安装配置 Claude Code，参考 Claude Code 使用。
安装配置完成后，将集群LSF使用的skills 链接安装到自己的 Claude Code 下。
$ mkdir ~/.claude/skills/
$ ln -s /public/home/software/opt/skills/ncpgr-software/ ~/.claude/skills/
❯ /ncpgr-software
● The ncpgr-software skill is loaded. I'm ready to help with any questions about:
- Software availability on the cluster (mii, module, singularity)
- LSF job script writing & optimization
- Resource recommendations (CPU/memory/queue)
- Software selection (variant calling, alignment, QC, etc.)
- Common pitfalls and acceleration tips
- Specific software usage tips
What do you need help with?
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯
/ncpgr-software 。 群体变异检测¶
❯ /ncpgr-software 我有1000个样本的群体数据要进行变异检测，有什么建议
● Skill(ncpgr-software)
⎿ Successfully loaded skill
● 1000样本的群体变异检测是一个大规模项目，以下是关键建议：
推荐方案
首选：Parabricks (GPU加速)
- 单样本比对+变异检测仅需 ~25分钟（vs 传统方法~30小时）
- 从 fq 到 gVCF 全流程 GPU 加速
- 学术免费，需申请 GPU 队列权限
联合分型：GLnexus
- 替代 GATK GenomicsDBImport + GenotypeGVCFs
- 速度快很多，但内存需求大（50-200GB），需用 high 或 smp 队列
提交策略
1000样本 × 多步骤，强烈建议先确认采用哪种策略：
┌──────────────────┬─────────────────────────────────────────────────────────────────────────┐
│ 策略 │ 说明 │
├──────────────────┼─────────────────────────────────────────────────────────────────────────┤
│ 逐步处理（推荐） │ 先提交所有样本的第1步（fastp），确认无错后再提交第2步（比对），以此类推 │
├──────────────────┼─────────────────────────────────────────────────────────────────────────┤
│ 依赖链一次提交 │ 用 -w "ended(jobid)" 建依赖链，一次提交全部，但出错难排查 │
└──────────────────┴─────────────────────────────────────────────────────────────────────────┘
大致资源估算
以 Parabricks + GLnexus 为例：
- 质控 (fastp)：每个样本 4核/8G，~1-2分钟/样本，1000个样本可批量并发
- 比对+变异 (Parabricks)：每个样本 16核+1GPU，~25分钟/样本
- 联合分型 (GLnexus)：1000个gVCF合并，需高队列 36核，50-200GB内存
存储注意事项
- 1000样本的中间文件（bam/gvcf）体量巨大，建议：
- 比对后直接输出 cram（比 bam 小 30-50%）
- 用 genozip 压缩中间 gVCF 文件
- VCF 务必 bgzip + tabix
需要确认
在生成作业脚本之前，请告诉我：
1. 数据类型：WGS 还是 WES？目标区域是什么物种？
2. 提交策略：逐步处理 还是 依赖链一次提交？
3. 是否有 GPU 队列权限？
确认后我可以帮你生成具体的 LSF 作业脚本。
❯ 数据为WGS，逐步处理，有 GPU 队列权限
● 好的，1000样本 WGS + GPU 权限 + 逐步处理。以下是完整的分步方案：
---
流程概览
┌──────┬─────────────────────────────────────────────┬───────────────┬──────────┐
│ 步骤 │ 内容 │ 每样本/总耗时 │ 队列 │
├──────┼─────────────────────────────────────────────┼───────────────┼──────────┤
│ 1 │ 质控 (fastp) │ ~2min/样本 │ normal │
├──────┼─────────────────────────────────────────────┼───────────────┼──────────┤
│ 2 │ 比对+去重+BQSR (Parabricks fq2bam) │ ~25min/样本 │ gpu │
├──────┼─────────────────────────────────────────────┼───────────────┼──────────┤
│ 3 │ 单样本变异检测 (Parabricks haplotypecaller) │ ~15min/样本 │ gpu │
├──────┼─────────────────────────────────────────────┼───────────────┼──────────┤
│ 4 │ 联合分型 (GLnexus) │ ~数小时 │ high/smp │
├──────┼─────────────────────────────────────────────┼───────────────┼──────────┤
│ 5 │ VCF 过滤与注释 │ ~快速 │ normal │
└──────┴─────────────────────────────────────────────┴───────────────┴──────────┘
---
Step 1: 质控 (fastp)
所有1000样本可批量提交（建议分批次，比如每次200个）：
#!/bin/bash
#BSUB -J fastp[1-1000]%200 # 数组作业，同时最多200个并行
#BSUB -n 4
#BSUB -q normal
#BSUB -o fastp_%J_%I.out
#BSUB -e fastp_%J_%I.err
module load fastp/0.23.4
# 样本列表（每行一个样本ID）
SAMPLE=$(sed -n "${LSB_JOBINDEX}p" sample_list.txt)
fastp \
-i ${SAMPLE}_R1.fastq.gz \
-I ${SAMPLE}_R2.fastq.gz \
-o ${SAMPLE}_clean_R1.fastq.gz \
-O ${SAMPLE}_clean_R2.fastq.gz \
-h ${SAMPLE}_fastp.html \
-j ${SAMPLE}_fastp.json \
-w $LSB_DJOB_NUMPROC \
--dont_eval_duplication
---
Step 2: 比对 + 排序 + 去重 + BQSR (Parabricks fq2bam)
每样本一个作业，需 GPU：
#!/bin/bash
#BSUB -J parabricks[1-1000]%100
#BSUB -n 16
#BSUB -R "span[hosts=1]"
#BSUB -gpu "num=1:gmem=11G"
#BSUB -q gpu
#BSUB -o parabricks_%J_%I.out
#BSUB -e parabricks_%J_%I.err
module load Singularity/3.7.3
SAMPLE=$(sed -n "${LSB_JOBINDEX}p" sample_list.txt)
REF_DIR=/path/to/reference
singularity exec --nv $IMAGE/clara-parabricks/4.4.0-1.sif pbrun fq2bam \
--low-memory \
--ref ${REF_DIR}/genome.fa \
--in-fq ${SAMPLE}_clean_R1.fastq.gz ${SAMPLE}_clean_R2.fastq.gz \
--out-bam ${SAMPLE}.sorted.dedup.bam
- 输出 BAM 已经过 sort、mark duplicates、BQSR
- %100 控制同时最多100个并行（根据 GPU 节点数量调整）
- 这一步最吃资源，可先跑10个样本测试确认无错后再全量提交
---
Step 3: 单样本变异检测 → gVCF (Parabricks haplotypecaller)
#!/bin/bash
#BSUB -J hcaller[1-1000]%100
#BSUB -n 8
#BSUB -R "span[hosts=1]"
#BSUB -gpu "num=1:gmem=11G"
#BSUB -q gpu
#BSUB -o hc_%J_%I.out
#BSUB -e hc_%J_%I.err
module load Singularity/3.7.3
SAMPLE=$(sed -n "${LSB_JOBINDEX}p" sample_list.txt)
REF_DIR=/path/to/reference
singularity exec --nv $IMAGE/clara-parabricks/4.4.0-1.sif pbrun haplotypecaller \
--ref ${REF_DIR}/genome.fa \
--in-bam ${SAMPLE}.sorted.dedup.bam \
--out-variants ${SAMPLE}.g.vcf.gz \
--emit-mode GVCF
- 每个样本输出一个 gVCF 文件
- 给8核够用，GPU 加速变异检测
---
中间步骤检查（建议）
在 Step 3 完成后、Step 4 之前，检查所有1000个 gVCF 是否成功生成：
# 检查是否所有样本都成功生成了 gVCF
for s in $(cat sample_list.txt); do
if [ ! -f "${s}.g.vcf.gz" ] || [ ! -f "${s}.g.vcf.gz.tbi" ]; then
echo "FAILED: $s"
fi
done
---
Step 4: 联合分型 (GLnexus)
1000个 gVCF 合并，需要高内存：
#!/bin/bash
#BSUB -J glnexus_joint
#BSUB -n 36
#BSUB -q high
#BSUB -R "span[hosts=1]"
#BSUB -o glnexus.out
#BSUB -e glnexus.err
module load glnexus/1.4.1
# 生成 gVCF 列表文件
ls *.g.vcf.gz > gvcf_list.txt
# WGS 不需要 --bed，WES 需要指定目标区域
glnexus_cli \
--config WGS \
--bed regions.bed \ # WGS 可去掉这行
--dir glnexus_work \
--threads $LSB_DJOB_NUMPROC \
--sample-name cohort_1000 \
$(cat gvcf_list.txt) > cohort_1000.bcf
# 转为 VCF
module load HTSlib/1.18
bcftools view cohort_1000.bcf -Oz -o cohort_1000.vcf.gz
bcftools index cohort_1000.vcf.gz
- 注意：1000个样本的 GLnexus 内存需求可能达到 100-200GB
- 如果内存不够，可按染色体分片跑，再合并
- --config WGS 适用于全基因组数据
如果 GLnexus 内存不够，按染色体拆分：
#!/bin/bash
#BSUB -J glnexus_chr[1-22]%10
#BSUB -n 36
#BSUB -q high
#BSUB -o glnexus_chr_%J_%I.out
module load glnexus/1.4.1
CHRS=(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y)
CHR=$(sed -n "${LSB_JOBINDEX}p" <<< "$(printf '%s\n' ${CHRS[@]})")
# 生成该染色体的 bed 区间
echo -e "${CHR}\t0\t999999999" > chr_${CHR}.bed
glnexus_cli \
--config WGS \
--bed chr_${CHR}.bed \
--dir glnexus_chr${CHR} \
--threads $LSB_DJOB_NUMPROC \
$(cat gvcf_list.txt) > chr_${CHR}.bcf
---
Step 5: VCF 压缩与索引
#!/bin/bash
#BSUB -J vcf_post
#BSUB -n 4
#BSUB -q normal
#BSUB -o vcf_post.out
module load HTSlib/1.18
# bgzip + tabix（Parabricks/haplotypecaller 输出的 VCF 可能需要压缩）
bgzip cohort_1000.vcf
tabix -p vcf cohort_1000.vcf.gz
# 基本过滤（可根据需要调整）
bcftools filter -e 'QUAL<30 || DP<10' -Oz -o cohort_1000.filtered.vcf.gz cohort_1000.vcf.gz
bcftools index cohort_1000.filtered.vcf.gz
---
提交顺序（逐步处理）
# 1. 准备样本列表（每行一个样本名，与fastq文件名对应）
ls *_R1.fastq.gz | sed 's/_R1.fastq.gz//' > sample_list.txt
# 2. 提交 Step 1: fastp 质控
bsub < step1_fastp.sh
# 3. 等所有质控完成后，检查 fastp 报告，然后提交 Step 2
# 检查：fastp 是否有大量样本 failed
# 确认无误后：
bsub < step2_parabricks.sh
# 4. 等比对完成后，检查 BAM 质量（flagstat），提交 Step 3
samtools flagstat *.bam > all_flagstat.txt
bsub < step3_haplotypecaller.sh
# 5. 检查 gVCF 生成情况，提交 Step 4
bash check_gvcf.sh # 上面的检查脚本
bsub < step4_glnexus.sh
# 6. 最后 Step 5 后处理
bsub < step5_vcf.sh
---
几个关键注意事项
1. Parabricks 参考基因组：需要先对参考基因组进行 Parabricks 预处理（生成 .dict 和 .fai），确保 genome.fa 已在 Parabricks 工作目录准备好
2. 存储：1000 样本 WGS 中间文件极大，单个 BAM 可能 80-100GB，建议：
- 每个样本结果产出后尽快清理原始 fastq（如果已不再需要）
- 最终结果用 genozip 进一步压缩归档
3. GPU 排队：%100 的并发度可根据实际 GPU 节点数调整，太多会排队很久
4. 先跑代表样本：建议先用 5-10 个样本跑完整流程，确认参数和资源无误后再全量提交
批量运行 Alphafold3¶
❯ /ncpgr-software 我有1000个蛋白fasta文件需要运行alphafold3
● Skill(ncpgr-software)
⎿ Successfully loaded skill
● Let me first check the AlphaFold3 cluster documentation and available resources.
......
● 了解了。1000 个蛋白 FASTA 跑 AlphaFold3 是个不小的任务，有几个关键点需要先确认：
● User answered Claude's questions:
⎿ · 1000个蛋白FASTA文件目前在哪里？是在某个目录下每个文件一个序列，还是合并成一个文件？文件路径是什么？ → 已有文件，告知路径
· AlphaFold3 分两步：① data pipeline（CPU，MSA搜索）② inference（GPU）。1000个蛋白想怎么提交？ → 分步提交
· 你是否有集群 GPU 队列使用权限？AlphaFold3 推理必须在 GPU 节点运行。 → 已有权限
● 好的，分步提交 + 有 GPU 权限。请告诉我 FASTA 文件的路径 — 是在一个目录下每个文件一条序列，还是所有序列合并到一个 FASTA 文件中？
另外说明一下整体流程：
AlphaFold3 流程（每个蛋白）：
1. 生成 JSON 输入文件 — 从 FASTA 序列转为 AF3 要求的 JSON 格式
2. Data pipeline（CPU 节点）— MSA 搜索，使用集群已有的数据库（UniRef90、MGnify、BFD 等）
3. Inference（GPU 节点）— 模型推理，输出结构文件
分步提交策略：
- 第一步：批量生成 1000 个 JSON 文件
- 第二步：提交 data pipeline 作业（CPU，可多个并行）
- 第三步：检查结果后，提交 inference 作业（GPU）
每步完成后你可以检查中间结果，确认无误再继续下一步。
✻ Worked for 1m 42s
❯ 继续
● 我先创建一个通用的工作目录结构和脚本。你之后把 FASTA 文件路径告诉我（或者放到当前目录下）即可运行。
● Bash(mkdir -p ./alphafold3_run/{inputs/json,work,data_pipeline,inference,output})
⎿ Done
● 现在开始创建各步骤脚本。
Step 1: FASTA 转 JSON
● Write(alphafold3_run/scripts/01_fasta_to_json.py)
⎿ Wrote 114 lines to alphafold3_run/scripts/01_fasta_to_json.py
1 #!/usr/bin/env python3
2 """
3 将 FASTA 文件批量转换为 AlphaFold3 所需的 JSON 格式。
4 支持两种输入：
5 1. 单个 FASTA 文件（包含多条序列）
6 2. 目录下每个 FASTA 文件含一条序列
7
8 用法:
9 python fasta_to_json.py <输入FASTA文件或目录> <输出JSON目录>
10 """
… +104 lines (ctrl+o to expand)
● Step 2: Data Pipeline 作业脚本 (CPU)
● Write(alphafold3_run/scripts/02_data_pipeline.sh)
⎿ Wrote 43 lines to alphafold3_run/scripts/02_data_pipeline.sh
1 #!/bin/bash
2 #BSUB -J af3_data_{JOB_NAME}
3 #BSUB -n 16
4 #BSUB -R "span[hosts=1]"
5 #BSUB -q normal
6 #BSUB -o logs/data_pipeline_{JOB_NAME}.%J.out
7 #BSUB -e logs/data_pipeline_{JOB_NAME}.%J.err
8
9 # AlphaFold3 Data Pipeline (CPU阶段 - MSA搜索)
10 # 用法: bsub < 02_submit_data_pipeline.sh
… +33 lines (ctrl+o to expand)
● Step 3: Inference 作业脚本 (GPU)
● Write(alphafold3_run/scripts/03_inference.sh)
⎿ Wrote 40 lines to alphafold3_run/scripts/03_inference.sh
1 #!/bin/bash
2 #BSUB -J af3_infer_{JOB_NAME}
3 #BSUB -n 8
4 #BSUB -R "span[hosts=1]"
5 #BSUB -q gpu
6 #BSUB -gpu "num=1:gmem=16G"
7 #BSUB -o logs/inference_{JOB_NAME}.%J.out
8 #BSUB -e logs/inference_{JOB_NAME}.%J.err
9
10 # AlphaFold3 Inference (GPU阶段 - 结构预测)
… +30 lines (ctrl+o to expand)
● Step 4: 批量提交脚本
● Write(alphafold3_run/scripts/04_submit_all_data_pipeline.sh)
⎿ Wrote 61 lines to alphafold3_run/scripts/04_submit_all_data_pipeline.sh
1 #!/bin/bash
2 # 批量提交 AlphaFold3 Data Pipeline 作业 (CPU)
3 # 用法: bash submit_all_data_pipeline.sh [并发数]
4 # 默认并发数: 20
5
6 SCRIPT_DIR=$(cd $(dirname $0) && pwd)
7 WORKDIR=$(dirname "$SCRIPT_DIR")
8 JSON_DIR="${WORKDIR}/inputs/json"
9 TEMPLATE="${SCRIPT_DIR}/02_data_pipeline.sh"
10 LOG_DIR="${WORKDIR}/logs"
… +51 lines (ctrl+o to expand)
● Write(alphafold3_run/scripts/05_submit_all_inference.sh)
⎿ Wrote 68 lines to alphafold3_run/scripts/05_submit_all_inference.sh
1 #!/bin/bash
2 # 批量提交 AlphaFold3 Inference 作业 (GPU)
3 # 用法: bash submit_all_inference.sh [并发数]
4 # 默认并发数: 5 (GPU资源有限)
5
6 SCRIPT_DIR=$(cd $(dirname $0) && pwd)
7 WORKDIR=$(dirname "$SCRIPT_DIR")
8 DATA_DIR="${WORKDIR}/data_pipeline"
9 TEMPLATE="${SCRIPT_DIR}/03_inference.sh"
10 LOG_DIR="${WORKDIR}/logs"
… +58 lines (ctrl+o to expand)
● Step 5: 状态检查脚本
● Write(alphafold3_run/scripts/06_check_status.sh)
⎿ Wrote 38 lines to alphafold3_run/scripts/06_check_status.sh
1 #!/bin/bash
2 # 检查 AlphaFold3 作业状态
3 # 用法: bash check_status.sh
4
5 WORKDIR=$(cd $(dirname $0)/.. && pwd)
6 JSON_DIR="${WORKDIR}/inputs/json"
7 DATA_DIR="${WORKDIR}/data_pipeline"
8 INFERENCE_DIR="${WORKDIR}/inference"
9 LOG_DIR="${WORKDIR}/logs"
… +28 lines (ctrl+o to expand)
Searched for 1 pattern (ctrl+o to expand)
● 所有脚本已创建好。以下是完整流程：
---
目录结构
alphafold3_run/
├── inputs/json/ # Step 1 生成的 JSON 文件
├── work/ # 中间工作目录
├── data_pipeline/ # Step 2 Data Pipeline 输出
├── inference/ # Step 3 Inference 输出 (mmcif结构文件)
├── output/ # 最终结果汇总
├── logs/ # 作业日志
└── scripts/
├── 01_fasta_to_json.py # FASTA → JSON
├── 02_data_pipeline.sh # Data Pipeline 模板 (CPU)
├── 03_inference.sh # Inference 模板 (GPU)
├── 04_submit_all_data_pipeline.sh # 批量提交 data pipeline
├── 05_submit_all_inference.sh # 批量提交 inference
└── 06_check_status.sh # 检查作业状态
使用方法
Step 1 — 生成 JSON（登录节点）
cd alphafold3_run
# 如果所有序列在一个FASTA文件中：
python scripts/01_fasta_to_json.py /path/to/all_proteins.fasta inputs/json
# 如果每个蛋白一个FASTA文件：
python scripts/01_fasta_to_json.py /path/to/fasta_directory inputs/json
Step 2 — 批量提交 Data Pipeline（CPU 节点，normal 队列）
cd alphafold3_run
bash scripts/04_submit_all_data_pipeline.sh 20 # 并发20个
- 每个作业 16 核，MSA 搜索
- 提交后等待全部完成：bjobs -J af3_data_
Step 3 — 检查结果后提交 Inference（GPU 节点）
# 检查 data pipeline 是否全部完成
bash scripts/06_check_status.sh
# 批量提交 inference（GPU，控制并发避免排队过长）
bash scripts/05_submit_all_inference.sh 5 # 并发5个GPU作业
资源估算
- Data Pipeline: 每个约 2-8 小时（取决于蛋白长度和MSA复杂度），16核 CPU，普通内存
- Inference: 每个约 10-60 分钟（取决于蛋白长度），1 GPU（16G显存），8核 CPU
你的 FASTA 文件在哪个路径？我可以先跑 Step 1 确认 JSON 生成是否正常。
软件查询¶
❯ 如何对vcf.gz文件创建索引
● 使用 tabix：
# 确保 HTSlib 或 tabix 已加载
module load HTSlib/1.18
# 创建索引（生成 .vcf.gz.tbi 文件）
tabix -p vcf sample.vcf.gz
前提是文件必须是 bgzip 压缩的（不能是普通 gzip）。如果不确定，先重新压缩：
# 如果是普通 gzip 压缩的，需先解压再用 bgzip 压缩
gunzip sample.vcf.gz
bgzip sample.vcf
tabix -p vcf sample.vcf.gz
索引完成后即可按区域快速查询：
tabix sample.vcf.gz chr1:10000-20000
❯ 有什么软件可以对bigwig格式的文件进行格式转换
● 常用的 BigWig 转换工具和场景：
转换工具
┌──────────────────────────────────────────────────┬──────────────────────────────────────────────────┐
│ 工具 │ 说明 │
├──────────────────────────────────────────────────┼──────────────────────────────────────────────────┤
│ UCSC Kent Utils (bigWigToWig / bigWigToBedGraph) │ 最常用，直接转回 wig 或 bedGraph │
├──────────────────────────────────────────────────┼──────────────────────────────────────────────────┤
│ BEDOPS (bigWigToBedGraph) │ 快速，适合批量 │
├──────────────────────────────────────────────────┼──────────────────────────────────────────────────┤
│ pyBigWig (Python) │ 编程读取/转换，pyBigWig.open() │
├──────────────────────────────────────────────────┼──────────────────────────────────────────────────┤
│ deepTools (bamCoverage) │ 从 BAM 生成 BigWig，反向不行 │
├──────────────────────────────────────────────────┼──────────────────────────────────────────────────┤
│ wigToBigWig / bedGraphToBigWig │ Kent Utils 中的反向转换（wig/bedGraph → BigWig） │
└──────────────────────────────────────────────────┴──────────────────────────────────────────────────┘
常用转换
# BigWig → bedGraph
bigWigToBedGraph input.bw -bedGraph=graph.txt
# BigWig → wig
bigWigToWig input.bw output.wig
# bedGraph → BigWig（需要先有染色体大小文件 chrom.sizes）
bedGraphToBigWig input.bedGraph chrom.sizes output.bw
# wig → BigWig
wigToBigWig input.wig chrom.sizes output.bw
chrom.sizes 可从 UCSC Genome Browser 下载，或用 samtools faidx 从参考基因组提取：
samtools faidx genome.fa
awk '{print $1, $2}' genome.fa.fai > chrom.sizes
集群上
NCPGR 集群中 UCSC Kent Utils 可通过 module 或 singularity 调用：
module av # 搜索是否有 ucsc/kent
# 或
singularity exec $IMAGE/ucsc/kent.sif bigWigToBedGraph input.bw -bedGraph=out.txt
软件命令查询¶
❯ /ncpgr-software 集群上是否有bedCoverage
● Skill(ncpgr-software)
⎿ Successfully loaded skill
● Bash(mii search bedCoverage)
⎿ Error: Exit code 127
bash: mii: command not found
● Bash(/public/home/software/opt/bio/software/mii/1.1.2/mii search bedCoverage 2>/dev/null || module av 2>&1 | grep -i -E "bed|ucsc|kent|coverage")
⎿ bedops/2.4.39
BEDTools/2.26.0-foss-2016b
BEDTools/2.27
… +2 lines (ctrl+o to expand)
● 集群上有 bedCoverage，它包含在 UCSC Kent Utils 中：
module load ucsc_kentUtils/v389
bedCoverage ...
生信数据库查询¶
❯ /ncpgr-software 集群上是否有ncbi NT 库，如何使用
● 根据 skill 中的信息，集群上有 NCBI NT 库，位于 /share/database/。
使用方法
# 1. 查看可用的 nt 模块版本
module av nt
# 2. 加载 nt 模块（加载后自动设置环境变量 $NT）
module load nt/20201013
# 3. 直接使用 $NT 变量，无需自己 makeblastdb 建索引
blastn -query seqs.fa -db $NT -out result.txt -num_threads 8 -outfmt 6
要点：
- 公共数据库已通过 module 配置好，加载后 $NT 环境变量直接可用
- 不需要自己下载或 makeblastdb 建索引
- blastn 线程数设 4~8 即可，更多核几乎不加速（CPU利用率不高）
- 如果序列较短（<50nt），加参数：-task blastn-short -word_size 4 -gapopen 1 -gapextend 1
- 大 query 文件可以分割成多段，提交多个作业并行跑
让我先确认一下集群当前实际可用的版本。
● Bash(module av 2>&1 | grep -i nt)
⎿ ant/1.9.7-Java-1.8.0_92
ART-MountRainier/2016-06-05
CentIER/3.0.1-py3.8
… +40 lines (ctrl+o to expand)
● 集群上目前有多个 NT 版本可用：
┌─────────────┬──────────┐
│ 模块名 │ 说明 │
├─────────────┼──────────┤
│ nt/20170605 │ 旧版 │
├─────────────┼──────────┤
│ nt/20171030 │ 旧版 │
├─────────────┼──────────┤
│ nt/20190802 │ 旧版 │
├─────────────┼──────────┤
│ nt/20201013 │ 常用版本 │
├─────────────┼──────────┤
│ nt/20240422 │ 最新版 │
└─────────────┴──────────┘
另外还有一个 core_nt/20240826（核心子集）。
使用示例
# 加载最新 NT 库
module load nt/20240422
# blastn 比对（线程数设 4~8 即可）
blastn -query seqs.fa -db $NT -out result.txt -num_threads 8 -outfmt 6
加载 module 后 $NT 环境变量自动设置好，不需要自己下载数据或 makeblastdb 建索引。
❯ 是否有 NR 库，如何使用
● 有的，从刚才的 module av 结果可以看到 NR 库有这些版本：
┌─────────────────────┬──────────────────────────────────────────┐
│ 模块名 │ 说明 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20141218 │ 旧版 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20170605 │ 旧版 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20171030 │ 旧版 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20190625 │ 旧版 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20251215 │ 最新版 │
├─────────────────────┼──────────────────────────────────────────┤
│ nr/20190625-diamond │ diamond 专用版（推荐用于 blastp/blastx） │
└─────────────────────┴──────────────────────────────────────────┘
使用方法
# 加载 NR 库（用 blast+ 套件）
module load nr/20251215
blastp -query proteins.fa -db $NR -out result.txt -num_threads 8 -outfmt 6
# 或者用 diamond 替代 blastp/blastx（速度快很多，强烈推荐）
module load nr/20190625-diamond
diamond blastp -q proteins.fa -d $NR -o result.txt --threads 8 --outfmt 6
要点：
- 加载 module 后 $NR 环境变量自动设置，不需要自己 makeblastdb
- blastp/blastx 优先用 diamond，速度比 blast+ 快很多
- 线程数设 4~8 即可
本站总访问量 次