lgvar 1.3.0__py3-none-any.whl

lgvar-1.3.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: lgvar
+Version: 1.3.0
+Summary: LGvar is a comprehensive toolset designed for large-scale structural variant (SV) detection based on genome assemblies. It excels in cross-species variant identification, particularly demonstrating superior performance in inversion detection compared to existing tools.
+Author: Feifei Zhou
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: <3.10,>=3.9
+Description-Content-Type: text/markdown
+
+# LGvar: Large-scale Genomic VARiation
+[![Conda version](https://img.shields.io/badge/conda-v1.3.0-green)](https://anaconda.org/channels/zhoufeifei/packages/lgvar/overview)  [![Appatiner Image Version](https://img.shields.io/badge/singularity-v1.3.0-blue)](https://cloud.sylabs.io/library/feifeizhou/tool/lgvar) [![License](https://img.shields.io/badge/license-MIT-yellow)](https://github.com/YafeiMaoLab/LGvar/blob/main/LICENSE)  [![release](https://img.shields.io/badge/releases-June%202026-purple)](https://github.com/YafeiMaoLab/LGvar/releases/tag/v1.3.0)
+
+## Quick Start
+* [Why LGvar?](#WhyLGvar)
+* [Installation](#installation)
+* [Usage & Examples](#Usage-Examples)
+    * [Reverse-complement the genome](#reverse)
+    * [Generate orthologous chromosome pairs](#pair)
+    * [Whole genome SV identification](#run)
+    * [Output files](#output)
+    * [Plot whole genome alignment synteny](#plot)
+* [Benchmarking](#benchmark)
+* [Getting Help](#getting-help)
+* [Citing LGvar](#citation)
+
+## Why LGvar <a id="WhyLGvar"></a>
+**LGvar** is a comprehensive toolset designed for large-scale structural variant (SV) detection based on genome assemblies. It excels in **cross-species variant identification**, particularly demonstrating superior performance in **inversion detection** compared to existing tools.
+
+- **Easily use:** Only FASTA and chromosome pairs (.tsv) are needed for input (users can alternatively provide pre-aligned PAF files).
+- **Comprehensive and fast:** LGvar detects not only insertions, deletions, inversions, translocations, duplications, INDELs and SNVs, but also detects structurally divergent regions (SDRs) and nested-inversions (INV-INV).
+- **More efficient in detection of inversions:** LGvar performs realignment within SDRs to detect inversions missed in initial alignment.
+
+## Installation <a id="installation"></a>
+
+**Option 1: Conda (Recommended)**
+
+```Bash
+# You can install LGvar from anaconda.org
+conda install -c conda-forge -c bioconda lgvar
+```
+```Bash
+# Or you can directly create a new environment
+# Clone the repository  
+git clone https://github.com/YafeiMaoLab/LGvar.git 
+cd LGvar
+# Create and activate environment  
+conda env create -f env.yml  
+conda activate LGvar
+```
+**Option 2: Singularity**
+```Bash
+# If conda is not available, use our pre-built images:
+singularity pull library://feifeizhou/tool/lgvar:v1.3.0 
+# Execution example:  
+singularity exec lgvar_v1.3.0.sif /LGVAR/LGVAR [subcommands]
+```
+
+## Usage & Examples <a id="Usage-Examples"></a>
+
+* LGvar provides several subcommands to streamline the genomic analysis pipeline:
+    <details>
+    <summary><b>Subcommands List (click to expand)</b></summary>
+
+    | Command | Function |
+    | :------ | :------- |
+    | **run** | **Run SV identification.** Detects SDRs, DELs, INSs, INVs, DUPs, INDELs, SNVs etc. |
+    | **plot** | **Syntenic Plot.** Visualizes the alignment between genomes. Blue regions represent syntenic blocks, while orange regions represent inversions. |
+    | **pair** | **Homology Mapping.** Generates homologous chromosome pair files. |
+    | **reverse** | **RC-Check.** Identifies and reverse-complements misoriented chromosomes. |
+
+    </details>
+
+
+**1\. Reverse-complement the genome <a id="reverse"></a>**
+
+* Before calling SVs, using `LGvar reverse` to check if query chromosomes need reverse-complementing to ensure inversion calling accuracy, this step identifies a chromosome as needing reverse complementation by checking if the total length of alignments mapped to the reverse strand exceeds `half` the chromosome’s total length in the PAF file.
+    ```Bash
+    # Recommended: align first then check orientation  
+    LGVAR reverse -p align.paf -r reverse.txt -g original.genome.fa -n new.genome.fa
+    # Or use the script
+    bash /src/scripts/rc_chrom.sh align.paf reverse.txt original.genome.fa new.genome.fa
+    #Then use new.genome.fa as query genome to do SV calling
+    ```
+    `reverse.txt` contains the chromosomes that need to be reverse-complemented.
+
+**2\. Generate orthologous chromosome pairs <a id="pair"></a>**
+
+* LGvar identifies variants between each pair of orthologous chromosomes. If you do not have a tab-delimited TSV file containing `ref   query` columns, you can generate the orthologous chromosome TSV file using the `LGvar pair` command.
+    ```Bash
+    LGVAR pair -p align.paf -l 1000000 -o pair
+    ```
+    where the `-l` parameter specifies the minimum alignment length (in base pairs) required to define a reliable orthologous chromosome pair; only alignments meeting or exceeding this `1Mbp` threshold will be used to determine the corresponding relationships between chromosomes. It is recommended to increase this value when analyzing two species with a large evolutionary divergence (e.g. human vs. lemur, `-l` can be set to `5Mbp`).
+
+**3\. Whole genome SV identification  <a id="run"></a>**
+
+* Once you have prepared the reference genome, query genome and orthologous chromosome pair files, you can use `LGVAR run` to perform genome-wide variant detection. You may optionally provide files containing `centromere and telomere` coordinates of the reference genome to mask highly repetitive regions, thus improving running efficiency.
+    ```Bash
+    LGVAR run \
+        -r ref.fa \
+        -q1 query.hap1.fa \
+        -q2 query.hap2.fa \
+        -cp1 query.hap1.pair.tsv \
+        -cp2 query.hap2.pair.tsv \
+        -m sensitive \
+        -s query
+    ```
+    Centromere and telomere coordinate files for `T2T-CHM13` are available under the `examples/data` directory, namely `chm13_cen.tsv` and `chm13_telo.tsv`.
+
+* Here is an running example. The test data is located in `examples/`. We'll use Human chromosome 21(T2T-CHM13) as reference and Chimpanzee (PTR) as query.
+    ```Bash
+    # 1. Setup working directory  
+    mkdir LGvar_work
+    # 2. Decompress test genomes  
+    cd examples/genome && gunzip *.gz  
+    cd LGvar_work
+    # 3. Execution (Example with existing PAF alignments)  
+    LGVAR run \  
+        -r /examples/genome/chr21.chm13.fa \ 
+        -q1 /examples/genome/chr21.ptr.hap1.fa \  
+        -q2 /examples/genome/chr21.ptr.hap2.fa \  
+        -p1 /examples/align/align_hap1.paf \  
+        -p2 /examples/align/align_hap2.paf \
+        -cp1 /examples/data/PTR_hap1_pairs.tsv \
+        -cp2 /examples/data/PTR_hap2_pairs.tsv \
+        -m sensitive \
+        -s PTR
+    ```
+
+**4\. Output Files <a id="output"></a>**
+
+* Results are saved in the `${work_dir}/results` folder:
+    <details>
+    <summary><b>results</b></summary>
+
+    | File | Function |
+    | :------ | :------- |
+    | **sortLGvar_all.vcf** | Combined results of SNVs, INDELs and SVs for both haplotypes. |
+    | **LGvarhap1(2).vcf** | Haplotype-specific SV details. |
+    | **LGvarhap1(2).bed** | Haplotype-specific SV details (with SDRs, DUPs, TRANs). |
+    | **LGvar.bed** | Merged variant regions (Hap1 + Hap2). |
+
+    </details>
+
+    | Label | Description |
+    | :---- | :---- |
+    | **SNVs** | Single Nucleotide Variation |
+    | **INDELs** | Small insertions and deletions (Length < 50bp) |
+    | **DELs/INSs** | Deletions and Insertions (filtered at 50bp threshold) |
+    | **INVs/INV-INV** | Simple and Nested Inversions |
+    | **DUP** | Duplications |
+    | **TRANS** | Translocations |
+    | **SDRs** | Structurally Divergent Regions |
+
+**5\. Plot whole genome alignment synteny<a id="plot"></a>**
+
+* You can visualize whole-genome alignments using `PAF` and `PAIR` files.
+    ```Bash
+    LGVAR plot -p align.paf -f pair.tsv -o align.pdf
+    ```
+    This is an example using T2T-CHM13 as reference and chimpanzee hap1 as query genome.
+    ![https://github.com/YafeiMaoLab/LGvar/images/alignment.png](https://github.com/YafeiMaoLab/LGvar/blob/main/images/alignment.png)
+
+## Benchmarking<a id="benchmark"></a>
+* We benchmarked LGvar in many genomes include simulated, population and cross-species data (see forthcoming paper). See [Analysis.md](https://github.com/YafeiMaoLab/LGvar/blob/main/README.md):
+
+
+## Getting help <a id="getting-help"></a>
+
+* If you encounter any issues or have questions about specific parameters, please [Open an Issue](https://github.com/YafeiMaoLab/LGvar) or contact zhoufeifei@sjtu.edu.cn.
+
+
+## Citing LGvar <a id="citation"></a>
+
+* If you use LGvar in your research, please cite our repository (and forthcoming paper): (https://github.com/YafeiMaoLab/LGvar)

lgvar-1.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+lgvar_cli.py,sha256=SvkoRfXGs3jmnkJ9O95CifB7HGSIxYpNqOfZkUP1lEw,861
+utils.py,sha256=EtOnHWqYPmo5jD-be7PejLLcs22nID3N3OQQnnBU4mk,13422
+lgvar-1.3.0.dist-info/METADATA,sha256=bEG5gqg-gVuTmou-oFAf13-A8t53EncJ9Hc12dINR3Q,9094
+lgvar-1.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+lgvar-1.3.0.dist-info/entry_points.txt,sha256=sMh9SZ_2J1-LwWOVVzOET2CSnannqJMe4zeUHgic31w,41
+lgvar-1.3.0.dist-info/top_level.txt,sha256=IvbxecdfQeXiz4T1zikvitPtJRveotHpZC0wgTrl_bk,16
+lgvar-1.3.0.dist-info/RECORD,,

lgvar-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lgvar-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+LGVAR = lgvar_cli:main

lgvar-1.3.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+lgvar_cli
+utils

lgvar_cli.py

@@ -0,0 +1,29 @@
+import os
+import subprocess
+import sys
+
+
+def main():
+    # 获取当前安装目录（即 site-packages/ 根目录）
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # 此时 LGVAR 与 utils.py、src/ 都在 package_dir 下
+    lgvar_script = os.path.join(package_dir, "LGVAR")
+
+    if os.path.exists(lgvar_script):
+        os.chmod(lgvar_script, 0o755)
+        cmd = [lgvar_script] + sys.argv[1:]
+        try:
+            # 指定 working directory 为 package_dir，确保路径完全匹配
+            result = subprocess.run(cmd, cwd=package_dir)
+            sys.exit(result.returncode)
+        except Exception as e:
+            print(f"[Error] Failed to execute LGVAR: {e}")
+            sys.exit(1)
+    else:
+        print(f"[Error] Could not locate 'LGVAR' in {package_dir}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,390 @@
+import os
+import glob
+import time
+import sys
+import logging
+import subprocess
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def run_minimap(ref_path, hap_path, hap_label, chrom_pair_file):
+    """1. Whole genome alignments"""
+    cmd = [
+        "minimap2",
+        "-t", "12",
+        "-cx", "asm20",
+        "--secondary=no",
+        "--eqx",
+        "-m 10000",
+        "-z 10000,50",
+        "-r 50000",
+        "--end-bonus=100",
+        "-O 5,56",
+        "-E 4,1",
+        "-B 5",
+        ref_path,
+        hap_path,
+        "-o", f"align_{hap_label}.paf"
+    ]
+    logging.info("0.Map")
+    logging.info(f"Running minimap2 for {hap_label}...")
+    
+    result = subprocess.run(cmd, check=True)
+    
+    if result.returncode == 0:
+        logging.info(f"Minimap2 completed for {hap_label}")
+    
+    logging.info(f"Selecting alignments for homologous chromosomes in {hap_label}...")
+    process_paf(f"align_{hap_label}.paf",chrom_pair_file,hap_label)
+
+def process_paf(paf_file, chrom_pair_file, hap_label):
+    """2. Filter extra alignments"""
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    p_c_chrlen_file = middle_dir/f"{hap_label}_chrlen.txt"
+    output_file = f"align_{hap_label}.flt.paf"
+    
+    # Read mapping
+    mapping = {}
+    with open(chrom_pair_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"): continue
+            key, value = line.split("\t")
+            mapping[key] = value.split(",")
+    
+    # Filter PAF
+    logging.info(f"Filtering PAF for {hap_label}...")
+    with open(paf_file, 'r') as fin, open(output_file, 'w') as fout:
+        for line in fin:
+            line = line.strip()
+            if not line or line.startswith("#"): continue
+            content = line.split("\t")
+            try:
+                if content[5] in mapping.keys() and content[0] in mapping[content[5]]:
+                    print(line, file=fout)
+            except Exception as e:
+                content = line.split(" ") 
+                if content[5] in mapping.keys() and content[0] in mapping[content[5]]:
+                    print(line, file=fout)
+    
+    # Extract chrlen info
+    with open(output_file, 'r') as fin, open(p_c_chrlen_file, 'w') as fout:
+        for line in fin:
+            content = line.strip().split("\t")
+            if content:
+                print(f"{content[5]} {content[6]} {content[0]} {content[1]}", file=fout)
+
+def process_filtering(hap_label, mode, divergence):
+    """3. Filter high-divergence alignments"""
+    nowdic = Path.cwd()
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    
+    saffire_dir = Path(f"saffire{hap_label}")
+    saffire_dir.mkdir(exist_ok=True)
+    p_c_chrlen_file = middle_dir/f"{hap_label}_chrlen.txt"
+    output_file = middle_dir/f"{hap_label}_syntenic.tsv"
+    
+    # run scripts
+    chaos_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/scripts/chaos_filt.r"
+    
+    if mode == "insensitive":
+        cmd = [
+            "cp",
+            f"align_{hap_label}.flt.paf",
+            f"align_{hap_label}.final.paf"
+        ]
+        
+        result = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        
+    elif mode == "sensitive":
+        if divergence is None:
+            logging.error("Error: When using 'sensitive' mode, you must provide divergence argument.")
+            sys.exit(1)
+        cmd = [
+            "Rscript", str(chaos_script),
+            str(p_c_chrlen_file), 
+            f"{str(saffire_dir)}/", 
+            f"align_{hap_label}.flt.paf", 
+            f"align_{hap_label}.final.paf",
+            str(mode),
+            str(divergence)
+        ]
+        
+        logging.info(f"Running chaos filter for {hap_label} in 'sensitive' mode...")
+        result = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    cmd = f"awk 'BEGIN{{OFS=\"\\t\"}} {{print $6, $8, $9, ($8+$9)/2, $1, $3, $4, ($3+$4)/2, $5}}' align_{hap_label}.final.paf | sort -k1,1 -k2,2n > {output_file}"
+    subprocess.run(cmd, shell=True, check=True)
+
+def run_cluster_and_call(ref_path, hap_path, hap_label, cluster, invcluster, threads, chunk_size, distance, fraction, refine_breakpoints, combine_inversion):
+    """4. Cluster and SV calling"""
+    
+    denSDR_dir = Path(f"denSDR{hap_label}")
+    denSDR_dir.mkdir(exist_ok=True)
+    #dotplot_dir = Path(f"dotplot{hap_label}")
+    #dotplot_dir.mkdir(exist_ok=True)
+    sdrall_file = denSDR_dir/"SDRall.txt"
+    paf_file = f"align_{hap_label}.final.paf"
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    
+    cluster_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/scripts/denSDR.r"
+    fun_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/scripts/denSDRfun.r"
+    
+    cmd = [
+        "Rscript", str(cluster_script),
+        str(fun_script),
+        middle_dir/f"{hap_label}_syntenic.tsv",
+        middle_dir/f"{hap_label}_chrlen.txt",
+        f"{str(denSDR_dir)}/",
+        str(cluster),
+        str(invcluster),
+        str(distance),
+        str(refine_breakpoints),   # this is TRUE or FALSE
+        str(combine_inversion),
+        paf_file
+    ]
+    
+    logging.info(f"SV calling for {hap_label}...")
+
+    result = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    logging.info(f"SV calling on {hap_label} finished...")
+    
+    cmd = [
+        "cat", f"{denSDR_dir}/*end.tsv", ">", str(sdrall_file)
+    ]
+    
+    subprocess.run(" ".join(cmd), shell=True, check=True)
+    
+    # realign to find simple inversions from SDR
+    realign_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/vcf/realign.sh"
+
+    cmd = [
+        "bash", str(realign_script),
+        "-i", str(sdrall_file),
+        "-r", ref_path,
+        "-q", hap_path,
+        "-o", str(denSDR_dir/"SDRall_final.txt"),
+        "-t", str(threads),
+        "-c", str(chunk_size),
+        "-p", f"align_{hap_label}.final.paf",
+        "-f", str(fraction)
+    ]
+    
+    subprocess.run(cmd, check=True)
+    logging.info(f"Inversion re-identification of {hap_label} finished")
+
+    # restore local alignments
+    restore_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/restore_paf.py"
+    cmd = [
+        "python", str(restore_script),
+        middle_dir/f"minimap2.paf",
+        middle_dir/f"restore.paf",
+        hap_path,
+        ref_path
+    ]
+    subprocess.run(cmd, check=True)
+    subprocess.run(f"cat half/restore.paf >> align_{hap_label}.final.paf", shell=True, check=True)
+    subprocess.run("rm -f temp/*.tmp", shell=True, check=True)
+    logging.info(f"Restore local alignment of {hap_label} finished")
+
+def run_cigar_processing(ref_path, hap_path, hap_label):
+    """ 5.extract variationas from CIGAR """
+    cigar_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/CIGAR.py"
+    temp_dir = Path("temp")
+    temp_dir.mkdir(exist_ok=True)
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    
+    cmd = [
+        "python", str(cigar_script),
+        "--r", ref_path,
+        "--q", hap_path,
+        "--paf", f"align_{hap_label}.final.paf",
+        "--o", middle_dir/f"{hap_label}cigar.txt"
+    ]
+    
+    logging.info(f"Small variants identification for {hap_label}...")
+    
+    subprocess.run(cmd, check=True)
+    
+    output_file = middle_dir/f"{hap_label}cigarend.txt"
+    
+    with open(output_file, 'w') as dest:
+        with open(os.path.join("half", f"{hap_label}cigar.txt"), 'r') as src:
+            for line in src:
+                dest.write(line)
+        
+        for file_path in glob.glob(os.path.join("temp", "*.cigar")):
+            with open(file_path, 'r') as src:
+                for line in src:
+                    dest.write(line)
+
+    cmd = [
+        "find", str(temp_dir), "-type", "f", "-name", "*.cigar", "-delete"
+    ]
+    
+    subprocess.run(cmd, check=True)
+    logging.info(f"Small variants identification for {hap_label} finished...")
+    #print(f"CIGAR generated for {hap_label} finished at {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}", flush=True)
+
+def run_dup_filtering(hap_label):
+    """6. dup filter"""
+    dup_filt_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/vcf/dup_filt.sh"
+    filt_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/dup_filt.py"
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    paf_file = f"align_{hap_label}.final.paf"
+    cigar_end_file = middle_dir/f"{hap_label}cigarend.txt"
+    output_file = middle_dir/f"{hap_label}cigarout.txt"
+
+    cmd = [
+        "bash", str(dup_filt_script),
+        paf_file,
+        cigar_end_file,
+        output_file,
+        filt_script
+    ]
+    
+    logging.info("Filtering duplication...")
+    subprocess.run(cmd, check=True)
+
+def generate_vcf(ref_path, hap_path, hap_label, variant_type):
+    """7. Generate variation results -- vcf"""
+    results_dir = Path(f"results")
+    results_dir.mkdir(exist_ok=True)
+
+    middle_dir = Path("half")
+    middle_dir.mkdir(exist_ok=True)
+    cigar_to_vcf_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/vcf/CIGAR2VCF.sh"
+    py_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/SDR2VCF.py"
+    cigar_out_file = middle_dir/f"{hap_label}cigarout.txt"
+    vcf_file = f"{results_dir}/LGvar{hap_label}.vcf"
+    sdrall_final_file = f"denSDR{hap_label}/SDRall_final.txt"
+    cigarsdr_txt_file = middle_dir/f"{hap_label}cigarsdr.txt"
+    lgvarend_bed_file = f"{results_dir}/LGvar{hap_label}.bed"
+ 
+    cmd = [
+        "bash", str(cigar_to_vcf_script),
+        cigar_out_file,
+        vcf_file,
+        sdrall_final_file,
+        ref_path,
+        hap_path,
+        cigarsdr_txt_file,
+        str(py_script),
+        lgvarend_bed_file,
+        str(variant_type)
+    ]
+    
+    
+    logging.info(f"Generating VCF of {hap_label}...")
+    subprocess.run(cmd, check=True)
+
+def integrate_results(hap1_dir, hap2_dir, sample_name, max_distance, small_distance, similarity_threshold, variant_type):
+    """8. Variants classification"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    split_script = Path(script_dir) / "src/vcf/splitfile.sh"
+    hap_dir_obj = Path("hap1")
+    hap_dir_obj.mkdir(exist_ok=True)
+    cmd1 = [
+        "bash", str(split_script),
+        f"{str(hap_dir_obj)}/",
+        "results/LGvarhap1.vcf",
+        str(variant_type)
+    ]
+    subprocess.run(cmd1, check=True)
+
+    hap_dir_obj2 = Path("hap2")
+    hap_dir_obj2.mkdir(exist_ok=True)
+    cmd2 = [
+        "bash", str(split_script),
+        f"{str(hap_dir_obj2)}/",
+        "results/LGvarhap2.vcf",
+        str(variant_type)
+    ]
+    subprocess.run(cmd2, check=True)
+
+    """9. merge two haplotypes' variation"""
+    phenotype_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/phenotype.py"
+    
+    variants = list(set(variant_type.split(',')))
+    output_vcf = f"sortLGvar_{'_'.join(sorted(variants))}.vcf"
+
+    cmd = [
+        "python", str(phenotype_script),
+        "--output", f"results/{output_vcf}",
+        "--max_distance", str(max_distance),
+        "--small_distance", str(small_distance),
+        "--similarity_threshold", str(similarity_threshold),
+        "--sample_name", sample_name
+    ]
+    
+    cmd_extended = False
+    if "snv" in variants or "all" in variants:
+        cmd.extend(["--hap1_snv", f"{hap1_dir}/sortsnv.vcf.gz"])
+        cmd.extend(["--hap2_snv", f"{hap2_dir}/sortsnv.vcf.gz"])
+        cmd_extended = True
+    if "ins" in variants or "del" in variants or "all" in variants:
+        cmd.extend(["--hap1_indel", f"{hap1_dir}/sortindel.vcf.gz"])
+        cmd.extend(["--hap2_indel", f"{hap2_dir}/sortindel.vcf.gz"])
+        cmd_extended = True
+    if "inv" in variants or "all" in variants:
+        cmd.extend(["--hap1_sv", f"{hap1_dir}/sortSV.vcf.gz"])
+        cmd.extend(["--hap2_sv", f"{hap2_dir}/sortSV.vcf.gz"])
+        cmd_extended = True
+
+    if cmd_extended:
+        subprocess.run(cmd, check=True)
+
+    vcf2bedgt_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/vcf/vcf2bedGT.sh"
+    
+    cmd = [
+        "bash", str(vcf2bedgt_script),
+        f"results/{output_vcf}",
+        f"results/LGvarhap1.bed",
+        f"results/LGvarhap2.bed",
+        f"results/LGvarall.bed"
+    ]
+    
+    subprocess.run(cmd, check=True)
+    logging.info("Complete!")
+
+def plot(paf, output, minimum, distance, file):
+    plot_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/pyFiles/plotpaf.py"
+    cmd = [
+        "python", str(plot_script),
+        "-p", paf,
+        "-o", output,
+        "-m", str(minimum),
+        "-d", str(distance),
+        "-f", file
+    ]
+    subprocess.run(cmd, check=True)
+    logging.info("Done!")
+
+def pair(paf, length, output_prefix):
+    pair_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/scripts/chrom_pair.sh"
+    cmd = [
+        "bash", str(pair_script),
+        paf,
+        str(length),
+        output_prefix
+    ]
+    subprocess.run(cmd, check=True)
+
+def reverse(paf, reverse, genome, new_genome):
+    reverse_script = Path(os.path.dirname(os.path.abspath(__file__))) / "src/scripts/rc_chrom.sh"
+    cmd = [
+        "bash", str(reverse_script),
+        paf,
+        reverse,
+        genome,
+        new_genome
+    ]
+    subprocess.run(cmd, check=True)
+
+