CellLoop: Identifying single-cell 3D genome chromatin loops.
5 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 7 matches
- [1] § Results › Performance evaluation of CellLoop via loop frequency map (LFmap) ↔ CellLoop.py, lines 180 to 257 · score 0.68 · frequency map, LFmap, single cell loop, loop calling, aggregating, contact · block
oscr:b:WK6YZW1B49JW8-5· Report a mismatch - [2] § Results › Overview of CellLoop algorithm ↔ CellLoop.py, lines 180 to 257 · score 0.58 · LFmap, Frequency Map, contact maps, Chromatin Loop Frequency, aggregated, scloops · block
oscr:b:WK6YZW1B49JW8-5· Report a mismatch - [3] § Methods › UMAP visualization and clustering of single cells ↔ plot/plot_units.py, lines 350 to 405 · score 0.58 · Leiden clustering, genes expressed, UMAP, PCA, log · block
oscr:b:SR7ADPNXQMR6J-5· Report a mismatch - [4] § Methods › UMAP visualization and clustering of single cells ↔ src/GAGE-seq_preprocess.py, lines 96 to 152 · score 0.55 · RNA seq, Scanpy, SVD, UMAP, Leiden, filtered · block
oscr:b:EJA4HQ30VXN8E-Q· Report a mismatch - [5] § Methods › The enrichment analysis of ChIP-seq peak on chromatin loops ↔ src/plot_paper.py, lines 83 to 134 · score 0.54 · plot_surface, seq peaks · block
oscr:b:60H0M8X30PKZN-2· Report a mismatch - [6] § Methods › UMAP visualization and clustering of single cells ↔ plot/plot_units.py, lines 350 to 405 · score 0.50 · Leiden clustering, Scanpy, UMAP, filtered · block
oscr:b:SR7ADPNXQMR6J-5· Report a mismatch - [7] § Methods › Identification of single-cell chromatin loops ↔ src/sc_interactions.py, lines 963 to 1081 · score 0.50 · Node2Vec, walk, network, graph, embedding, neighboring · block
oscr:b:3XTYPQ5K717Z8-R· Report a mismatch
Paper
Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC
The paper is loaded when this pane is shown.
The authors' code
Python · 380 lines · 18 KB · no license · 2 matches
- # -*- coding: utf-8 -*-
- """
- Created on Wed Jul 6 14:32:26 2022
- @author: user
- """
- #!/usr/bin/env python3
- # -*- coding: utf-8 -*-
- import os
- #########################Initial parameters##############################################
- ###please write the directory where CellLoop package is located#####
- #main_dir='/home/dell/Desktop/CellLoop_test/CellLoop'
- main_dir='/mnt/nas/Projects/Project18/Codes/CellLoop_Install/CellLoop'
- os.chdir(main_dir)
- ######select the data type and bin resolution you want to analyze######
- DATASET='Dip-C'
- #DATASET='HiRES'
- #DATASET='GAGE-seq'
- BINSIZE=100e3
- if BINSIZE<=10e3:
- MAXDIST=5000000
- #knn_cell_num=50
- else:
- MAXDIST=10000000
- #knn_cell_num=50
- #default parameter to cut-off for removing short-range reads
- KNN_CELL_NUM=50
- LOW_CUTOFF=1e3
- if DATASET=='Dip-C':
- GENOME='mm10'
- #dataset dir
- INDIR="/mnt/nas/Datasets/2020_Dip-C/GSE162511"##
- FILE_SUFFIX=".contacts.pairs.txt.gz"
- MINCONCNUM=250000
- CHR_COLUMNS=[1,3]
- POS_COLUMNS=[2,4]
- FEATURE='higashi_embed'
- OUTDIR=INDIR+'_'+str(int(BINSIZE//1000))+'kb'+'_knn='+str(KNN_CELL_NUM)
- elif DATASET=='HiRES':
- GENOME='mm10'
- INDIR="/mnt/nas/Datasets/2023_Science/GSE223917"
- FILE_SUFFIX=".pairs.gz"
- MINCONCNUM=250000
- CHR_COLUMNS=[1,3]
- POS_COLUMNS=[2,4]
- FEATURE='RNA_embed'
- OUTDIR=INDIR+'_'+str(int(BINSIZE//1000))+'kb'+'_knn='+str(KNN_CELL_NUM)
- elif DATASET=='GAGE-seq':
- GENOME='mm10'
- INDIR="/mnt/data/Datasets/GAGE-seq/SingleCells"
- FILE_SUFFIX=".pairs"
- MINCONCNUM=200000
- CHR_COLUMNS=[0,2]
- POS_COLUMNS=[1,3]
- FEATURE='RNA_embed'
- OUTDIR=INDIR+'_'+str(int(BINSIZE//1000))+'kb'+'_knn='+str(KNN_CELL_NUM)
- if GENOME=='hg19':
- CHR_LEN=main_dir+'/ext/hg19.chrom.sizes'
- FILTER_FILE=main_dir+'/ext/hg19_filter_regions.txt'
- elif GENOME=='mm10':
- CHR_LEN=main_dir+'/ext/mm10.chrom.sizes'
- FILTER_FILE=main_dir+'/ext/mm10_filter_regions.txt'
- elif GENOME=='hg38':
- CHR_LEN='main_dir+/ext/hg38.chrom.sizes.txt'
- FILTER_FILE=main_dir+'/ext/hg38_filter_regions.txt'
- ###################################################################################
- import argparse
- import src.logger
- #import time
- from src.bin_reads import bin_sets
- import pandas as pd
- #from src.RepresentLearning_95 import get_rl_for_all_95
- #from src.sc_compartments import read_sc_compartment
- #from src.sc_tadboundaries import sctad_boundary
- from src.sc_interactions import scloops
- #from visual_show import visual_show
- #from src.commonorspecific_boundaries import comorspebound
- #from src.commonorspecific_loops import comorspeloops
- from src.sample_aggr_cells import get_aggr_cells
- #from src.Computing_contactprob import con_prob_dis
- from src.Aggrloops import aggreloops
- #from src.clustercells_loops import clustercells
- #from src.aggremaps_visualanalyzing import aggremaps,aggreloops_cluster,aggr_bulkmaps,aggr_bulkloops
- #from src.statistic_analysis_loops import statistic_analysis_loops
- import multiprocessing
- import scanpy as sc
- #import pandas as pd
- #########################################################################################
- def main():
- #__spec__ = "ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>)"
- parser = create_parser()
- args = parser.parse_args()
- chrom_dict = parse_chrom_lengths(args.chrom, args.chr_lens, args.genome, args.max_chrom_number)
- parallel_mode, rank, n_proc, parallel_properties = determine_parallelization_options(args.parallel, args.threaded, args.num_proc)
- if rank == 0 and not os.path.exists(args.outdir):
- os.makedirs(args.outdir)
- if parallel_mode == "parallel":
- parallel_properties['comm'].Barrier()
- threaded = True if parallel_mode == "threaded" else False
- logger = src.logger.Logger(f'{args.outdir}/scloops.log', rank = rank, verbose_threshold = args.verbose, threaded = threaded)
- ###############################################################################################
- #step 1; binning
- bin_dir = os.path.join(args.outdir, "binned")
- if 'bin' in args.steps:
- logger.write('starting the binning step')
- logger.flush()
- if parallel_mode == 'nonparallel':
- #indir=args.indir; suffix=args.suffix; binsize = args.binsize; outdir = bin_dir;
- #chr_columns = args.chr_columns; pos_columns = args.pos_columns;
- #low_cutoff = args.low_cutoff; mincontactnum=args.mincontactnum;dataset=args.dataset;n_proc = n_proc;rank = rank;logger = logger
- bin_sets(args.indir, args.suffix, binsize = args.binsize, outdir = bin_dir, \
- chr_columns = args.chr_columns, pos_columns = args.pos_columns, \
- low_cutoff = args.low_cutoff, mincontactnum=args.mincontactnum,dataset=args.dataset,n_proc = n_proc, rank = rank, logger = logger)
- elif parallel_mode == 'threaded':
- params = [(args.indir, args.suffix, args.binsize, bin_dir, args.chr_columns, args.pos_columns,\
- args.low_cutoff,args.mincontactnum,args.dataset,n_proc,i,logger) for i in range(n_proc)]
- with multiprocessing.Pool(n_proc) as pool:
- pool.starmap(bin_sets, params)
- logger.write("binning completed")
- logger.flush()
- ################### you can get using filelist ##########################
- filenames=os.listdir(bin_dir)
- filenames.sort()
- #for filelist
- f=open(args.indir+'/filelist.txt','w')
- for line in filenames:
- print(line)
- f.write(line.rstrip('.bedpe')+'\n')
- f.close()
- ####################################################################################################
- #step 1.1 #choose feature compute knn graph of single cells
- ####################################################################################################
- #indir=args.indir
- feature=args.feature
- if feature=='higashi_embed':
- feature_dir=main_dir+'/Dataset/'+DATASET+'/CellFeatures/'+feature
- filenames=os.listdir(bin_dir)
- filenames.sort()
- #for filelist
- f=open(feature_dir+'/filelist.txt','w')
- for line in filenames:
- print(line)
- f.write(line.rstrip('.bedpe')+'\n')
- f.close()
- elif feature=='RNA_embed':
- feature_dir=main_dir+'/Dataset/'+DATASET+'/CellFeatures/'+feature
- adata_rna=sc.read(feature_dir+'/adata_rna.h5ad')
- filelist_dir=args.indir+'/filelist.txt'
- filenames=pd.read_csv(filelist_dir, index_col=None,header=None,sep='\t')
- # filenames=os.listdir(bin_dir)
- # filenames.sort()
- adata_rna.obs_names=adata_rna.obs['cell']
- #adata_rna=adata_rna[[cellname in filenames for cellname in adata_rna.obs_names],:]
- filenames=filenames[[cellname in adata_rna.obs_names for cellname in filenames[0].values]]
- adata_rna=adata_rna[filenames[0].values.tolist(),:]
- # sc.pp.neighbors(adata_rna, n_neighbors=15, n_pcs=20)
- # sc.tl.umap(adata_rna)
- # sc.tl.leiden(adata_rna)
- # sc.pl.umap(adata_rna,color=['n_genes','leiden'], palette='tab20',size=10,wspace=1,hspace=0.1)
- adata_rna.write(feature_dir+'/adata_rna.h5ad')
- #for filelist
- f=open(feature_dir+'/filelist.txt','w')
- for line in filenames[0]:
- print(line)
- f.write(line.rstrip('.bedpe')+'\n')
- f.close()
- #############################################################################################
- #### step 2. Generating the enhanced contact map of the single cells#########################
- # sampling and getting aggregated cells
- #choose feature compute knn graph of single cells
- SampleAggrCell_dir=os.path.join(args.outdir,'sampleaggrcell_dir')
- knn_cell_num=args.knn_cell_num
- #k=20
- if 'sampleaggrcell' in args.steps:
- logger.write('starting the sampling aggragated cells step')
- logger.flush()
- #if parallel_mode == 'nonparallel':
- #bin_dir=bin_dir;outdir=SampleAggrCell_dir;feature_dir=feature_dir;feature=feature;chrom_lens=chrom_dict;
- #n_proc=n_proc;rank=rank;binsize=args.binsize;k=knn_cell_num;
- get_aggr_cells(bin_dir=bin_dir,outdir=SampleAggrCell_dir,feature_dir=feature_dir,feature=feature,chrom_lens=chrom_dict,\
- n_proc=n_proc, rank=rank,binsize=args.binsize,k=knn_cell_num)
- # bin_sets(args.indir, args.suffix, binsize = args.binsize, outdir = bin_dir, \
- # chr_columns = args.chr_columns, pos_columns = args.pos_columns, \
- # low_cutoff = args.low_cutoff, n_proc = n_proc, rank = rank, logger = logger)
- # elif parallel_mode == 'threaded':
- # params = [(bin_dir,SampleAggrCell_dir,feature_dir,feature,chrom_dict,n_proc,i,\
- # args.binsize,knn_cell_num) for i in range(n_proc)]
- # with multiprocessing.Pool(n_proc) as pool:
- # pool.starmap(get_aggr_cells, params)
- logger.write("binning completed")
- logger.flush()
- ### Step 3 Calling chromatin loops of single cells################################################################
- scloops_dir=os.path.join(args.outdir,'scloops_new')
- # temp_keys={'chr2','chr13'}
- # chrom_dict={key:chrom_dict[key] for key in chrom_dict.keys() & temp_keys }
- alpha=1
- scloops_outdir=os.path.join(scloops_dir+'_'+feature,'alpha='+str(alpha))
- # scloops_dir+'_'+feature+'_alpha='+str(alpha)
- if 'scloops' in args.steps:
- indir=SampleAggrCell_dir+'_'+feature
- logger.write('starting the chromatin loops calling')
- logger.flush()
- if parallel_mode=="nonparallel":
- #chrom_lens = chrom_dict;outdir = scloops_outdir;indir = indir
- #binsize = args.binsize;dist = args.dist
- #neighborhood_limit_lower = args.local_lower_limit; neighborhood_limit_upper = args.local_upper_limit
- #rank = rank; n_proc = n_proc; max_mem = args.max_memory; logger = logger
- scloops(indir = indir, outdir = scloops_outdir, chrom_lens = chrom_dict, \
- binsize = args.binsize, dist = args.dist, \
- neighborhood_limit_lower = args.local_lower_limit, \
- neighborhood_limit_upper = args.local_upper_limit,alpha=alpha,\
- rank = rank, n_proc = n_proc, max_mem = args.max_memory, logger = logger)
- elif parallel_mode == 'threaded':
- params = [(indir, scloops_outdir, chrom_dict, \
- args.binsize,args.dist,args.local_lower_limit,args.local_upper_limit,alpha,\
- i,n_proc, args.max_memory,logger) for i in range(n_proc)]
- with multiprocessing.Pool(n_proc) as pool:
- pool.starmap(scloops, params)
- logger.write("calling completed")
- logger.flush()
- #############################################################################################
- ##### Step 4. Generating chromatin loop frequency map(LFmap)##############################################################
- aggreloops_dir=os.path.join(args.outdir,'aggreloops','alpha='+str(alpha))
- if 'aggreloops' in args.steps:
- logger.write('starting aggregated loops')
- logger.flush()
- if parallel_mode=="nonparallel":
- #indir = scloops_outdir; outdir = aggreloops_dir;chrom_lens = chrom_dict;
- #binsize = args.binsize;dist = args.dist
- #rank = rank; n_proc = n_proc; max_mem = args.max_memory; logger = logger
- aggreloops(indir = scloops_outdir,outdir = aggreloops_dir,\
- chrom_lens = chrom_dict, binsize = args.binsize,
- rank = rank, n_proc = n_proc, logger = logger)
- elif parallel_mode == 'threaded':
- params = [(scloops_outdir, aggreloops_dir, chrom_dict, \
- args.binsize,\
- i,n_proc,logger) for i in range(n_proc)]
- with multiprocessing.Pool(n_proc) as pool:
- pool.starmap(aggreloops, params)
- logger.write("aggregating completed")
- logger.flush()
- def parse_chrom_lengths(chrom, chrom_lens_filename, genome, max_chrom_number):
- if not max_chrom_number or max_chrom_number == -1:
- if not chrom or chrom == "None":
- chrom_count = 22 if genome.startswith('hg') else 19 if genome.startswith("mm") else None
- if not chrom_count:
- raise("Genome name is not recognized. Use --max-chrom-number")
- chrom = ['chr' + str(i) for i in range(1, chrom_count + 1)]
- else:
- chrom = [c.strip() for c in chrom.split()]
- else:
- chrom = ['chr' + str(i) for i in range(1, max_chrom_number + 1)]
- with open(chrom_lens_filename) as infile:
- lines = infile.readlines()
- chrom_lens = {line.split()[0]: int(line.split()[1]) for line in lines if line.split()[0] in chrom}
- return chrom_lens
- def determine_parallelization_options(parallel, threaded, n_proc):
- if parallel and threaded:
- raise "Only one of 'parallel' or 'threaded' flags can be set. \
- If using a job scheduling system on a cluster with multiple machines, use parallel.\
- If using a single machine with multiple CPUs, use threaded"
- else:
- if parallel:
- #print('it;s parallel')
- from mpi4py import MPI
- comm = MPI.COMM_WORLD
- n_proc = comm.Get_size()
- rank = comm.Get_rank()
- #print('n proc is', n_proc)
- #print('rank is', rank)
- mode = 'parallel'
- properties = {'comm': comm}
- elif threaded:
- import multiprocessing
- if n_proc < 1:
- raise Exception('if threaded flag is set, n should be a positive integer')
- n_proc = n_proc
- mode = 'threaded'
- rank = 0
- properties = {}
- else:
- mode = 'nonparallel'
- n_proc = 1
- rank = 0
- properties = {}
- return mode, rank, n_proc, properties
- def create_parser():
- parser = argparse.ArgumentParser()
- ################################# Required parameters
- parser.add_argument('-i', '--indir', action = 'store', required =False, \
- help = 'input directory',default=INDIR)
- parser.add_argument('-s', '--suffix', required = False, \
- help = 'suffix of the input files', default=FILE_SUFFIX)
- parser.add_argument('-o', '--outdir', action = 'store', \
- required = False, help = 'output directory', default=OUTDIR)
- parser.add_argument('-c', '--chr-columns', action = 'store', nargs = 2, \
- type = int, help = 'two integer column numbers for chromosomes', required = False, default = CHR_COLUMNS)
- parser.add_argument('-p', '--pos-columns', action = 'store', nargs = 2, \
- type = int, help = 'two integer column numbers for read positions', required = False, default = POS_COLUMNS)
- parser.add_argument('-l', '--chr-lens', action = 'store', \
- help = 'path to the chromosome lengths file', required = False,\
- default=CHR_LEN)
- parser.add_argument('-g', '--genome', action = 'store', help = 'genome name; hgxx or mmxx', \
- required = False, default = "hg19")
- parser.add_argument('--dist', type = int, help = 'distance from diagonal to consider', \
- default =MAXDIST, required = False)
- parser.add_argument('--mincontactnum', type = int, help = 'minimum contact number for single cells', \
- default =MINCONCNUM, required = False)
- parser.add_argument('--dataset', action = 'store', help = 'choose dataset', \
- default = DATASET, required = False)
- parser.add_argument('--knn-cell-num', action = 'store', help = 'maximum neighboring cell number', \
- default =KNN_CELL_NUM, required = False)
- parser.add_argument('--feature', action = 'store', help = 'choose feature', \
- default = FEATURE, required = False)
- parser.add_argument('--binsize', type = int, help = 'bin size used for binning the reads', \
- required = False, default = BINSIZE)
- parser.add_argument('--low-cutoff', type = int, help = 'cut-off for removing short-range reads', \
- default = LOW_CUTOFF, required = False)
- ################################## optional parameters
- parser.add_argument('--parallel', action = 'store_true', default = False, \
- help = 'if set, will attempt to run in parallel mode', required = False)
- parser.add_argument('--threaded', action = 'store_true', default =True, \
- help = 'if set, will attempt to use multiprocessing on single machine', required = False)
- parser.add_argument('-n', '--num-proc', help = 'number of processes used in threaded mode',
- required = False, default = 10, type = int)
- parser.add_argument('--local-lower-limit', default = 2, type = int, required = False, \
- help = 'number of bins around center (in each direction) to exlude from neighborhood')
- parser.add_argument('--local-upper-limit', default = 5, type = int, required = False, \
- help = 'number of bins around center (in each direction) forming the neighborhood')
- parser.add_argument('--filter-file', default=FILTER_FILE, required = False, \
- help = "bed file of regions to be filtered.")
- parser.add_argument('--max-memory', default = 8, type = float, required = False, \
- help = 'memory available in GB, that will be used in constructing dense matrices')
- parser.add_argument('--verbose', type = int, required = False, default = 0,
- help = 'integer between 0 and 3 (inclusive), 0 for the least amount to print to log file')
- parser.add_argument('--steps', nargs = "*", default = ['bin','sampleaggrcell','scloops','aggreloops'] , \
- required = False, help = 'steps to run. Default is all steps.')
- parser.add_argument('--chrom', action = 'store', help = 'chromosome to process', \
- required = False, default = None)
- parser.add_argument('--max-chrom-number', action = "store", required = False, type = int, \
- help = "biggest chromosome number to consider in genome, for example 22 for hg", default = -1)
- return parser
- if __name__ == "__main__":
- main()
- #passa
CellLoop.py at commit 87e49ce, no license · at the source
Overview
- School of Computer Science and Technology, Xidian University,Xi’an, Shaanxi China
- NCMIS, CEMS, RCSDS, Academy of Mathematics and Systems Science, Chinese Academy of Sciences,Beijing, China
- School of Mathematical Sciences, University of Chinese Academy of Sciences,Beijing, China
- Key Laboratory of Systems Health Science of Zhejiang Province, School of Life Science, Hangzhou Institute for Advanced Study, University of Chinese Academy of Sciences, Chinese Academy of Sciences,Hangzhou, China
- Academy of Military Medical Sciences,Beijing, China
Abstract
The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.
Repositories
Its files are read in the Code ↔ Paper reader above, with 7 matches between paragraphs and lines of code.
YusenYe/CellLoop
87e49cefe2bbbab98e5ace6fad552dc7b4a1b5ee, 30 December 2025Availability: 1 check, the latest on 29 September 2026: the link answers
- 29 September 2026: the link answers
12 files
- CellLoop.py, Python, 380 lines, 2 matches
- plot/
__init__.py , Python, 7 lines - plot/
plot_units.py , Python, 510 lines, 2 matches - src/
Aggrloops.py , Python, 198 lines - src/
GAGE-seq_preprocess.py , Python, 182 lines, 1 match - src/
Hires_preprocess.py , Python, 98 lines - src/
bin_reads.py , Python, 183 lines - src/
logger.py , Python, 42 lines - src/
plot_paper.py , Python, 949 lines, 1 match - src/
sample_aggr_cells.py , Python, 275 lines - src/
sc_interactions.py , Python, 1,906 lines, 1 match - README.md, Text, 181 lines
Zenodo 18784293
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
- 29 September 2026: the link answers (HTTP 200)
12 files
- CellLoop.py, Python, 380 lines
- plot/
__init__.py , Python, 7 lines - plot/
plot_units.py , Python, 510 lines - src/
Aggrloops.py , Python, 198 lines - src/
GAGE-seq_preprocess.py , Python, 182 lines - src/
Hires_preprocess.py , Python, 98 lines - src/
bin_reads.py , Python, 183 lines - src/
logger.py , Python, 42 lines - src/
plot_paper.py , Python, 949 lines - src/
sample_aggr_cells.py , Python, 275 lines - src/
sc_interactions.py , Python, 1,906 lines - README.md, Text, 181 lines
Code availability statement
The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:
- it points to the authors' code: YusenYe/
CellLoop
Read it in the paper: doi.org/10.1038/s41467-026-71406-y.
Tracing map
Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.
What the map holds:
- 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
- 22 scripts, each with its path and the digest of its content;
- 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
- neither the text of the paper nor the code itself.
Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.
Data
Datasets cited
- figshare:1, at figshare; found in “Data availability”
- geo:GSE223917, at NCBI GEO; found in “Data availability”
Data availability statement
The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:
- it points to 2 datasets: figshare 1, NCBI GEO GSE223917
Read it in the paper: doi.org/10.1038/s41467-026-71406-y.
Versions
The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.
Version 1, 29 September 2026: the first record
Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 3 keywords, 6 MeSH terms, 1 funder, 45 references.
Cite
This paper
Ye, Y., Wang, Y., Liu, S., Hu, Y., Yu, L., Wang, W., Zhang, S., Chen, H., & Gao, L. (2026). CellLoop: Identifying single-cell 3D genome chromatin loops. Nature communications, 17(1), 4904. https://
BibTeX
@article{ye2026cellloop,
author = {Ye, Yusen and Wang, Yiheng and Liu, Shiji and Hu, Yuxuan and Yu, Liang and Wang, Weibing and Zhang, Shihua and Chen, Hebing and Gao, Lin},
title = {{CellLoop: Identifying single-cell 3D genome chromatin loops}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {4904},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/
url = {https://
pmid = {41942438},
pmcid = {PMC13230548}
}
RIS
TY - JOUR
AU - Ye, Yusen
AU - Wang, Yiheng
AU - Liu, Shiji
AU - Hu, Yuxuan
AU - Yu, Liang
AU - Wang, Weibing
AU - Zhang, Shihua
AU - Chen, Hebing
AU - Gao, Lin
TI - CellLoop: Identifying single-cell 3D genome chromatin loops
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/
VL - 17
IS - 1
SP - 4904
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.1038/
"type": "article-journal",
"title": "CellLoop: Identifying single-cell 3D genome chromatin loops",
"container-title": "Nature communications",
"author": [
{
"family": "Ye",
"given": "Yusen"
},
{
"family": "Wang",
"given": "Yiheng"
},
{
"family": "Liu",
"given": "Shiji"
},
{
"family": "Hu",
"given": "Yuxuan"
},
{
"family": "Yu",
"given": "Liang"
},
{
"family": "Wang",
"given": "Weibing"
},
{
"family": "Zhang",
"given": "Shihua"
},
{
"family": "Chen",
"given": "Hebing"
},
{
"family": "Gao",
"given": "Lin"
}
],
"container-title-short":
"volume": "17",
"issue": "1",
"page": "4904",
"DOI": "10.1038/
"PMID": "41942438",
"PMCID": "PMC13230548",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
6
]
]
}
}
The tracing map gets a citation of its own once an author has validated it and it has a DOI.
Similar papers
The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.
- [1] doi:10.1002/advs.202406364 [code]
- ImputeHiFI: An Imputation Method for Multiplexed DNA FISH Data by Utilizing Single-Cell Hi-C and RNA FISH Data.Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)In common: Scanpy, NetworkX, scikit-image, 5 other tools, mouse, 10 references, author Lin Gao
- [2] doi:10.1093/bib/bbag096 [code]
- scDIAGRAM: detecting chromatin compartments from individual single-cell Hi-C matrix without imputation or reference features.Journal: Briefings in bioinformaticsIn common: seaborn, scikit-learn, pandas, 3 other tools, mouse, 11 references
- [3] doi:10.1038/s41421-025-00770-8 [code]
- Droplet-based high-throughput 3D genome structure mapping of single cells with simultaneous transcriptomics.Journal: Cell discoveryIn common: seaborn, scikit-learn, pandas, 3 other tools, mouse, cellular / molecular, 10 references
- [4] doi:10.1038/s41587-024-02447-1 [code]
- Droplet Hi-C enables scalable, single-cell profiling of chromatin architecture in heterogeneous tissues.Journal: Nature biotechnologyIn common: Scanpy, seaborn, scikit-learn, 4 other tools, mouse, cellular / molecular, 9 references
- [5] doi:10.1038/s41467-024-50608-2 [code]
- Whole brain alignment of spatial transcriptomics between humans and mice with BrainAlign.Journal: Nature communicationsIn common: Scanpy, NetworkX, seaborn, 5 other tools, mouse, 2 references, author Shihua Zhang
- [6] doi:10.1038/s41592-024-02239-0 [code]
- Simultaneous single-cell three-dimensional genome and gene expression profiling uncovers dynamic enhancer connectivity underlying olfactory receptor choice.Journal: Nature methodsIn common: NetworkX, scikit-image, seaborn, 5 other tools, mouse, cellular / molecular, 5 references
- [7] doi:10.1126/sciadv.adv2067 [code]
- Cell type-specific 3D-genome organization and transcription regulation in the brain.Journal: Science advancesIn common: mouse, cellular / molecular, 10 references
- [8] doi:10.1126/science.adf5357 [code]
- Single-cell DNA methylation and 3D genome architecture in the human brain.Journal: Science (New York, N.Y.)In common: Scanpy, NetworkX, seaborn, 5 other tools, cellular / molecular, 5 references
- [9] doi:10.1038/s41586-023-06808-9 [code]
- Molecularly defined and spatially resolved cell atlas of the whole mouse brain.Journal: NatureIn common: Scanpy, NetworkX, scikit-image, 6 other tools, mouse, cellular / molecular, 4 references
- [10] doi:10.1038/s41586-021-03950-0 [code]
- A multimodal cell census and atlas of the mammalian primary motor cortex.Journal: NatureIn common: Scanpy, NetworkX, scikit-image, 6 other tools, mouse, 4 references
Contribute
The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.
Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 2 repositories of the authors' code, each at its verified commit and with its license, 22 scripts, and 7 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:3589796d1c379522…
Add the badge to the code's README
If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.
Markdown
<!-- oscr-badge:start -->
[](https://openscicode.org/badge/doi/10.1038/s41467-026-71406-y)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.1038/s41467-026-71406-y.svg
:target: https://openscicode.org/badge/doi/10.1038/s41467-026-71406-y
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s41467-026-71406-y"><img src="https://openscicode.org/badge/doi/10.1038/s41467-026-71406-y.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".
If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.
Request its removal
To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).
Discussion, reproductions, activity
Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.
Report a mismatch between the code and the paper · Report a code error (signed in)
Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.
Report a reproduction failure (signed in)
Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.
Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.
