def main():
parser = argparse.ArgumentParser(description="Reconstruct 3D coordinates from normalized intrachromosomal Hi-C BED files.")
parser.add_argument("path", help="path to intrachromosomal Hi-C BED file")
parser.add_argument("--classical", action="store_true", help="use classical MDS (default: metric MDS)")
parser.add_argument("--full", action="store_true", help="use full MDS (default: partitioned MDS)")
parser.add_argument("-l", type=int, help="low resolution/high resolution", default=10)
parser.add_argument("-p", type=float, default=0.1, help="domain size parameter: larger value means fewer structures created (for partitioned MDS only)")
parser.add_argument("-m", type=float, default=0.05, help="minimum domain size parameter: prevents structures from being too small (for partitioned MDS only)")
parser.add_argument("-o", help="path to output file")
parser.add_argument("-r", default=32000000, help="maximum RAM to use (in kb)")
parser.add_argument("-n", default=3, help="number of threads")
parser.add_argument("-a", type=float, default=4, help="alpha factor for converting contact frequencies to physical distances")
parser.add_argument("-a2", type=float, default=2.5, help="short-range alpha factor for converting contact frequencies to physical distances")
args = parser.parse_args()
if args.full: #not partitioned
structure = fullMDS(args.path, args.classical, args.a, args.n)
else: #partitioned
params = (args.p, args.m, args.r, args.n, args.a, args.l, args.a2)
names = ("Domain size parameter", "Minimum domain size", "Maximum memory", "Number of threads", "Alpha", "Resolution ratio", "Short-range, alpha")
intervals = ((0, 1), (0, 1), (0, None), (0, None), (1, None), (1, None), (1, None))
if not tools.args_are_valid(params, names, intervals):
sys.exit(1)
structure = partitionedMDS(args.path, params)
if args.o:
structure.write(args.o)
else:
prefix = args.path.split(".bed")[0]
structure.write(prefix + "_structure.tsv")
def main():
parser = argparse.ArgumentParser(description="Reconstruct 3D coordinates from normalized interchromosomal Hi-C BED files.")
parser.add_argument("inter_prefix", help="prefix of interchromosomal Hi-C BED file")
parser.add_argument("intra_prefix", help="prefix of intrachromosomal Hi-C BED file")
parser.add_argument("inter_res", type=int, help="resolution of interchromosomal BED files (bp)")
parser.add_argument("intra_res", type=int, help="resolution of intrachromosomal BED files (bp)")
parser.add_argument("-c", action="append", default=[], help="Names of chromosomes to use, e.g. 1 (default: all human chromosomes other than Y)")
parser.add_argument("-l", type=int, help="resolution of low-res intrachromosomal files (bp) (for partitioned MDS only)")
parser.add_argument("-p", type=float, default=0.1, help="domain size parameter: larger value means fewer clusters created (for partitioned MDS only)")
parser.add_argument("-m", type=float, default=0.05, help="minimum domain size parameter: prevents clusters from being too small (for partitioned MDS only)")
parser.add_argument("-o", help="prefix of output file")
parser.add_argument("-r", default=32000000, help="maximum RAM to use (in kb)")
parser.add_argument("-n", default=3, help="Number of threads")
parser.add_argument("-a", type=float, default=4, help="alpha factor for converting contact frequencies to physical distances")
args = parser.parse_args()
if len(args.c) == 0:
chrom_names = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, "X"]
else:
chrom_names = args.c
params = (args.p, args.m, args.r, args.n, args.a)
names = ("Domain size parameter", "Minimum domain size", "Maximum memory", "Number of threads", "Alpha")
intervals = ((0,1), (0,1), (0, None), (0, None), (1, None))
if not tools.args_are_valid(params, names, intervals):
sys.exit(0)
clusters = interMDS(chrom_names, args.inter_prefix, args.intra_prefix, args.inter_res, args.intra_res, args.l, params)
if args.o is not None:
for cluster in clusters:
cluster.write("{}_{}_{}_cluster.tsv".format(args.o, cluster.chrom.name, tools.get_res_string(cluster.chrom.res)))
def main():
parser = argparse.ArgumentParser(
description=
"Reconstruct 3D coordinates from normalized intrachromosomal Hi-C BED files."
)
parser.add_argument("path", help="path to intrachromosomal Hi-C BED file")
parser.add_argument("--classical",
action="store_true",
help="use classical MDS (default: metric MDS)")
parser.add_argument(
"-l", help="path to low-resolution intrachromosomal Hi-C BED file")
parser.add_argument(
"-p",
type=float,
default=0.1,
help=
"domain size parameter: larger value means fewer clusters created (for partitioned MDS only)"
)
parser.add_argument(
"-m",
type=float,
default=0.05,
help=
"minimum domain size parameter: prevents clusters from being too small (for partitioned MDS only)"
)
parser.add_argument("-o", help="path to output file")
parser.add_argument("-r",
default=32000000,
help="maximum RAM to use (in kb)")
parser.add_argument("-n", default=3, help="number of threads")
parser.add_argument(
"-a",
type=float,
default=4,
help=
"alpha factor for converting contact frequencies to physical distances"
)
args = parser.parse_args()
if args.l is None: #not partitioned
cluster = fullMDS(args.path, args.classical, args.a)
else: #partitioned
params = (args.p, args.m, args.r, args.n, args.a)
names = ("Domain size parameter", "Minimum domain size",
"Maximum memory", "Number of threads", "Alpha")
intervals = ((0, 1), (0, 1), (0, None), (0, None), (1, None))
if not tools.args_are_valid(params, names, intervals):
sys.exit(0)
cluster = partitionedMDS(args.path, args.l, params)
if args.o is not None:
cluster.write(args.o)
def main():
parser = argparse.ArgumentParser(
description=
"Jointly reconstruct 3D coordinates from two normalized intrachromosomal Hi-C BED files."
)
parser.add_argument("path1",
help="path to first intrachromosomal Hi-C BED file")
parser.add_argument("path2",
help="path to second intrachromosomal Hi-C BED file")
parser.add_argument("--partitioned",
action="store_true",
help="use partitioned MDS (default: full MDS)")
parser.add_argument("-l",
type=int,
help="low resolution/high resolution",
default=10)
parser.add_argument("-o", help="output file prefix")
parser.add_argument("-r",
default=32000000,
help="maximum RAM to use (in kb)")
parser.add_argument("-n", type=int, default=3, help="number of threads")
parser.add_argument(
"-a",
type=float,
default=4,
help=
"alpha factor for converting contact frequencies to physical distances"
)
parser.add_argument("-P",
type=float,
default=0.05,
help="joint MDS penalty")
parser.add_argument("-m",
type=int,
default=0,
help="midpoint (usually centromere) for partitioning")
parser.add_argument("-N", type=int, default=2, help="number of partitions")
parser.add_argument("-w",
type=float,
default=0.05,
help="weight of distance decay prior")
args = parser.parse_args()
if args.partitioned:
#TODO: cleanup
params = (args.m, args.N, args.r, args.n, args.a, args.l, args.P,
args.w)
names = ("Midpoint", "Number of partitions", "Maximum memory",
"Number of threads", "Alpha", "Resolution ratio", "Penalty",
"Weight")
intervals = ((None, None), (1, None), (0, None), (0, None), (1, None),
(1, None), (0, None), (0, 1))
if not tools.args_are_valid(params, names, intervals):
sys.exit(0)
structure1, structure2 = partitionedMDS(args.path1, args.path2, params)
else:
structure1, structure2 = fullMDS(args.path1, args.path2, args.a,
args.P, args.n, args.w)
if args.o:
prefix = args.o
else:
prefix = ""
#print("structure 1")
#for i in range(len(structure1.points)):
# if structure1.points[i] != 0:
# print(structure1.points[i].relative_index)
#print("structure 2")
#for i in range(len(structure2.points)):
# if structure2.points[i] != 0:
# print(structure2.points[i].relative_index)
prefix1 = os.path.splitext(os.path.basename(args.path1))[0]
structure1.write("{}{}_structure.tsv".format(prefix, prefix1))
prefix2 = os.path.splitext(os.path.basename(args.path2))[0]
structure2.write("{}{}_structure.tsv".format(prefix, prefix2))
coords1 = np.array(structure1.getCoords())
coords2 = np.array(structure2.getCoords())
dists = [
la.calcDistance(coord1, coord2)
for coord1, coord2 in zip(coords1, coords2)
]
np.savetxt("{}{}_{}_relocalization.bed".format(prefix, prefix1, prefix2),
dists)
print("Fractional compartment change: ")
print(
calculate_compartment_fraction(structure1, structure2, args.path1,
args.path2))
def main():
parser = argparse.ArgumentParser(
description=
"Reconstruct 3D coordinates from normalized intrachromosomal Hi-C BED files."
)
parser.add_argument("path", help="path to intrachromosomal Hi-C BED file")
parser.add_argument("--classical",
action="store_true",
help="use classical MDS (default: metric MDS)")
parser.add_argument(
"-l", help="path to low-resolution intrachromosomal Hi-C BED file")
parser.add_argument(
"-p",
type=float,
help=
"domain size parameter: larger value means fewer clusters created (for partitioned MDS only)"
)
parser.add_argument(
"-m",
type=float,
help=
"minimum domain size parameter: prevents clusters from being too small (for partitioned MDS only)"
)
parser.add_argument("-o", help="path to output file")
parser.add_argument("-r", help="maximum RAM to use (in kb)")
parser.add_argument("-n", help="Number of threads")
args = parser.parse_args()
if args.l is None: #not partitioned
cluster = fullMDS(args.path, args.classical)
else: #partitioned
if args.p is None:
p = 0.1
else:
p = args.p
if args.m is None:
m = 0.05
else:
m = args.m
if args.r is None:
r = 32000000
else:
r = args.r
if args.n is None:
n = 3 #safe for standard 4-core desktop
else:
n = args.n
params = (p, m, r, n)
names = ("Domain size parameter", "Minimum domain size",
"Maximum memory", "Number of threads")
intervals = ((0, 1), (0, 1), (0, None), (0, None))
if not tools.args_are_valid(params, names, intervals):
sys.exit(0)
cluster = partitionedMDS(args.path, args.l, params)
if args.o is not None:
cluster.write(args.o)
def main():
parser = argparse.ArgumentParser(
description=
"Reconstruct 3D coordinates from normalized interchromosomal Hi-C BED files."
)
parser.add_argument("prefix", help="prefix of Hi-C BED files")
parser.add_argument("inter_res",
type=int,
help="resolution of interchromosomal BED files (bp)")
parser.add_argument("intra_res",
type=int,
help="resolution of intrachromosomal BED files (bp)")
parser.add_argument("--partitioned",
action="store_true",
help="use partitioned MDS (default: full MDS)")
parser.add_argument(
"-c",
action="append",
default=[],
help=
"names of chromosomes to use, e.g. 1 (default: all human chromosomes other than Y)"
)
parser.add_argument("-C", type=int, help="number of autosomes")
parser.add_argument("-l",
type=int,
help="low resolution/high resolution",
default=10)
parser.add_argument(
"-p",
type=float,
default=0.1,
help=
"domain size parameter: larger value means fewer structures created (for partitioned MDS only)"
)
parser.add_argument(
"-m",
type=float,
default=0.05,
help=
"minimum domain size parameter: prevents structures from being too small (for partitioned MDS only)"
)
parser.add_argument("-o", help="prefix of output file")
parser.add_argument("-r",
default=32000000,
help="maximum RAM to use (in kb)")
parser.add_argument("-n", type=int, default=3, help="Number of threads")
parser.add_argument(
"-a",
type=float,
default=4,
help=
"alpha factor for converting contact frequencies to physical distances"
)
parser.add_argument(
"-a2",
type=float,
default=2.5,
help=
"short-range alpha factor for converting contact frequencies to physical distances"
)
parser.add_argument("-w",
type=float,
default=0.05,
help="weight of distance decay prior")
args = parser.parse_args()
if len(args.c) == 0:
if args.C:
chrom_names = range(1, args.C + 1)
else:
chrom_names = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, "X"
]
else:
chrom_names = args.c
params = (args.p, args.m, args.r, args.n, args.a, args.l, args.a2, args.w)
names = ("Domain size parameter", "Minimum domain size", "Maximum memory",
"Number of threads", "Alpha", "Resolution ratio",
"Short-range alpha", "Weight")
intervals = ((0, 1), (0, 1), (0, None), (0, None), (1, None), (1, None),
(1, None), (None, 1))
if not tools.args_are_valid(params, names, intervals):
sys.exit(1)
structures = interMDS(chrom_names, args.prefix, args.inter_res,
args.intra_res, args.partitioned, params)
if args.o:
for structure in structures:
structure.write("{}_{}_{}_structure.tsv".format(
args.o, structure.chrom.name.strip("chr"),
tools.get_res_string(structure.chrom.res)))
else:
for structure in structures:
structure.write("{}_{}_{}_structure.tsv".format(
args.prefix, structure.chrom.name.strip("chr"),
tools.get_res_string(structure.chrom.res)))
