def test_add_loop_for_hairpin(self):
cg = ftmc.CoarseGrainRNA.from_dotbracket("(((...)))")
sm = fbm.SpatialModel(cg)
sm.elem_defs = {}
sm.elem_defs["s0"] = self.example_stem_stat
sm.elem_defs["h0"] = self.example_hairpin_stat
sm.stems['s0'] = sm.add_stem('s0', sm.elem_defs['s0'], fbm.StemModel(),
ftms.AngleStat(), (0, 1))
sm.add_loop("h0", "s0")
self.assertAlmostEqual(
ftuv.magnitude(sm.bulges["h0"].mids[1] - sm.bulges["h0"].mids[0]),
self.example_hairpin_stat.phys_length)
def setUp(self):
self.cg = ftmc.CoarseGrainRNA.from_bg_file(
'test/fess/data/1GID_A-structure1.coord')
self.cg_copy = ftmc.CoarseGrainRNA.from_bg_file(
'test/fess/data/1GID_A-structure1.coord')
self.sm = fbm.SpatialModel(self.cg)
self.cg2 = ftmc.CoarseGrainRNA.from_bg_file(
'test/fess/data/1GID_A-clash.coord')
self.sm2 = fbm.SpatialModel(self.cg2)
real_stats_fn = 'fess/stats/all_nr3.36.stats'
self.stat_source = stat_container.StatStorage(real_stats_fn)
self.sm.constraint_energy = fbe.StemVirtualResClashEnergy()
self.sm2.constraint_energy = fbe.StemVirtualResClashEnergy()
e1 = fbe.RoughJunctionClosureEnergy()
e2 = fbe.RoughJunctionClosureEnergy()
for e, sm in [(e1, self.sm), (e2, self.sm2)]:
for ml in sm.bg.defines:
if ml[0] == "m":
sm.junction_constraint_energy[ml] = e
self.builder = fbb.Builder(self.stat_source)
def setUp(self):
self.cg = ftmc.CoarseGrainRNA.from_bg_file('test/fess/data/1GID_A.cg')
self.real_stats_fn = 'test/fess/data/real.stats'
self.filtered_stats_fn = 'test/fess/data/filtered_stats_1gid.csv'
self.filtered_stats = ftms.FilteredConformationStats(
self.real_stats_fn, self.filtered_stats_fn)
self.stat_source = stat_container.StatStorage(self.real_stats_fn)
self.sm = fbm.SpatialModel(self.cg)
self.sm.sample_stats(self.stat_source)
return
def test_save_and_load_does_not_change_coords(self):
self.sm1.load_sampled_elems()
self.sm2.load_sampled_elems()
self.sm2.new_traverse_and_build()
cg2_str = self.sm2.bg.to_cg_string()
bg_loaded = ftmc.CoarseGrainRNA.from_bg_file(cg2_str)
sm2_reloaded = fbm.SpatialModel(bg_loaded)
sm2_reloaded.load_sampled_elems()
self.assertAlmostEqual(ftmsim.cg_rmsd(self.sm2.bg, sm2_reloaded.bg),
0,
places=6)
#assertModelsEqual(self.sm2, sm2_reloaded, 12)
assertModelsEqual(self.sm1, sm2_reloaded, 12)
def test_energy_zero_after_building(self):
assert "m2" not in self.cg.get_mst()
sm = fbm.SpatialModel(self.cg)
sm.load_sampled_elems()
sm.new_traverse_and_build()
if sm.bg.get_angle_type("m2", allow_broken=True) == 3:
sm.bg.sampled["m2"] = ["4GXY_A:m_16"]
elif sm.bg.get_angle_type("m2", allow_broken=True) == -3:
sm.bg.sampled["m2"] = ["4GXY_A:m_17"]
else:
assert False
energy = fbe.SampledFragmentJunctionClosureEnergy(
"m2", self.stat_source)
self.assertLess(energy.eval_energy(sm.bg), 10**-3)
def main(args):
rec = fbr.Reconstructor(args.source_pdb_dir, args.source_cg_dir, args.server)
with fuc.hide_traceback(): # Applies only to WrongFileFormat
cgs, fns = fuc.cgs_from_args(args, rna_type="only_cg", enable_logging=True, return_filenames=True)
# Preprocessing
most_common_pdbs = collections.Counter()
for cg in cgs:
sm = fbm.SpatialModel(cg)
sm.load_sampled_elems(None)
curr_fns = set()
for stat in sm.elem_defs.values():
stat_name = stat.pdb_name
pdb_basename = stat_name.split(":")[0]
pdb_filename = op.expanduser(op.join(rec.pdb_library_path, "_".join(pdb_basename.split("_")[:-1])+".cif"))
try:
with open(pdb_filename): pass
except IOError:
pdb_filename = pdb_filename.rstrip(".cif")+".pdb"
curr_fns.add(pdb_filename)
for fn in curr_fns:
most_common_pdbs[fn]+=1
for fn, count in most_common_pdbs.most_common(250):
if count==1:
break
print("Preloading {}, used {} times".format(fn, count))
rec.get_pdb(fn, True)
print("Preloading of most common PDBs done")
logging.getLogger("forgi").setLevel(logging.ERROR)
logging_exceptions.config_from_args(args)
for i, cg in enumerate(cgs):
try:
fn = fns[i]
reconstruct(cg, fn, args, rec)
except Exception as e:
logging_exceptions.log_exception(e)
log.exception("During reconstruction of cg %s, an error occurred: %s", fn, e)
i=0
def reconstruct(cg, fn, args, rec):
log.info("Processing %s", fn)
stat_source = fbs.from_args(args, cg)
sm = fbm.SpatialModel(cg)
sm.load_sampled_elems(stat_source)
if args.reassign_broken:
sm.bg.traverse_graph()
for ml in sm.bg.mloop_iterator():
if ml not in sm.bg.mst:
try:
del sm.elem_defs[ml]
except KeyError:
pass
fbm._perml_energy_to_sm(sm, "MAX10000[1FJC1]", stat_source)
for ml in sm.bg.mloop_iterator():
if ml not in sm.bg.mst:
e = sm.junction_constraint_energy[ml].eval_energy(sm.bg)
log.info("Deviation for %s is %s", ml, e)
energies = list(sm.junction_constraint_energy[ml].iterate_energies())
if len(energies)==1:
log.debug("Getting used_stat for single energy %s",energies)
used_stat = energies[0].used_stat
else:
log.debug("Multiple energies. Iterating")
for ef in energies:
if ef.element==ml:
used_stat = ef.used_stat
log.info("Used stat for %s is %s", ml, used_stat)
sm.elem_defs[ml] = used_stat
sm.save_sampled_elems()
log.info("Broken stats reassigned. Storing cg.")
sm.bg.to_file(fn+".reassigned.cg")
sm.new_traverse_and_build()
chains = rec.reconstruct(sm)
print("Writing", fn+".reconstr.pdb")
chains = ftup.rename_chains_for_pdb(chains)
ftup.output_multiple_chains(chains.values(), fn+".reconstr.pdb")
def main():
parser = OptionParser()
parser.add_option('-n', '--nucleotides', dest='num_nucleotides',
default=3, help="The number of nucleotides to sample",
type='int')
parser.add_option('-i', '--iterations', dest='iterations',
default=1, help="The number of times to repeat the \
simulation", type='int')
parser.add_option('-a', '--all_lengths', dest='all_lengths', default=False,
action='store_true', help='Try all nucleotide lengths up \
to the value specified by the --nucleotides parameter.')
parser.add_option('-o', '--output_file', dest='output_file', default=None,
help="The file to dump the output to", type='string')
(options, args) = parser.parse_args()
if options.all_lengths:
start_len = 1
else:
start_len = options.num_nucleotides
if options.output_file != None:
output = open(options.output_file, 'w')
else:
output = sys.stdout
for k in xrange(start_len, options.num_nucleotides+1):
min_len = 0. + 3. * k
max_len = 12. + 7. * k
for d in np.linspace(min_len, max_len, options.iterations):
s1 = get_random_stem_stats()
s2 = get_random_stem_stats()
ang_stat = get_random_angle_stat(min_len= d,
max_len = d)
# Construct a simple graph with an edge of length 3
bg = construct_test_graph(s1, s2, ang_stat, k)
# Create a spatial model that will be used to create
# the 3D model
try:
sm = cbm.SpatialModel(bg)
except IndexError as ie:
# This can be caused by trying to sample a junction region
# which is too long and we don't have statistics for
print >>sys.stderr, "Index error in cbm.SpatialModel(bg)"
print >>sys.stderr, ie
continue
# Indiciate which statistics to use for the 3D model construction
sm.sample_stats()
sm.elem_defs['s0'] = s1
sm.elem_defs['s1'] = s2
sm.elem_defs['m0'] = ang_stat
# Create the model
sm.traverse_and_build()
#sm.bg.output('out.bg')
# Reconstruct the stems
try:
chain = cbr.reconstruct_stems(sm)
except IOError as ie:
# Sometimes we'll be missing a fragment
# Just issue a warning and keep on truckin'
print >>sys.stderr, "Missing fragment..."
print >>sys.stderr, ie
except KeyError as ke:
print >>sys.stderr, "KeyError in reconstructing stems..."
print >>sys.stderr, ke
try:
((a,b,i1,i2), best_loop_chain, min_dist) = cbr.reconstruct_loop(chain, sm, 'm0', side=0, samples=3,
consider_contacts=False, consider_starting_pos=False)
# Calculate the distances in the coarse grain model
dist1 = bulge_length(bg, 'm0')
dist2 = bulge_virtual_residue_distance(bg, 'm0')
dist3 = bulge_virtual_atom_distance(bg, 'm0')
output.write("Key, bulge_length, virtual_residue_dist, virtual_atom_dist, min_dist")
output.write("%d %f %f %f %f\n" % (k, dist1, dist2, dist3, min_dist))
output.flush()
#print k, dist1, dist2, dist3, min_dist
except Exception as e:
print >>sys.stderr, e
def setUp(self):
cg1 = ftmc.CoarseGrainRNA.from_bg_file(
'test/fess/data/1GID_A-structure1.coord')
cg2 = ftmc.CoarseGrainRNA.from_bg_file(
'test/fess/data/1GID_A-structure2.coord')
self.sm1 = fbm.SpatialModel(cg1)
self.sm2 = fbm.SpatialModel(cg2)
self.sm1.load_sampled_elems()
self.sm2.load_sampled_elems()
self.energy1a = fbe.ProjectionMatchEnergy({
("h0", "m0"): 23.26,
("h0", "h1"): 43.27,
("h1", "m0"): 38.13
})
self.energy1b = fbe.ProjectionMatchEnergy({
("h0", "m2"): 37.2,
("h0", "i4"): 40.14,
("h0", "h1"): 40.14,
("m2", "i4"): 3.0,
("m2", "h1"): 6.75,
("i4", "h1"): 6.91
})
self.energy2a = fbe.ProjectionMatchEnergy({
("h1", "h2"): 42.74,
("h1", "s9"): 56.40,
("h1", "m0"): 51.96,
("h2", "m0"): 19.98,
("h2", "s9"): 18.62,
("m0", "s9"): 7.85
})
self.energy2b = fbe.ProjectionMatchEnergy({
("h2", "h1"): 47.95,
("h2", "m3"): 34.14,
("h2", "i1"): 21.67,
("h1", "m3"): 13.82,
("i1", "h1"): 29.33,
("i1", "m3"): 16.52
})
self.energyA1 = fbe.ProjectionMatchEnergy({
("h0", "h1"): 40.49,
("h0", "m0"): 39.78,
("h0", "t1"): 43.70,
("h0", "i6"): 32.64,
("h1", "m0"): 51.15,
("h1", "t1"): 50.02,
("h1", "i6"): 54.61,
("m0", "t1"): 6.08,
("m0", "i6"): 12.75,
("t1", "i6"): 18.82
})
self.energyA2 = fbe.ProjectionMatchEnergy({
("h0", "h1"): 40.49,
("h0", "m0"): 39.78,
("h0", "t1"): 43.70,
("h1", "m0"): 51.15,
("h1", "t1"): 50.02,
("m0", "t1"): 6.08
})
self.energyA3 = fbe.ProjectionMatchEnergy({
("h0", "h1"): 40.49,
("h0", "m0"): 39.78,
("h1", "m0"): 51.15
})
self.energyA4 = fbe.ProjectionMatchEnergy({("h0", "m0"): 39.78})
return
#! /usr/bin/python
import forgi.threedee.model.coarse_grain as ftmc
import fess.builder.models as fbm
import forgi.threedee.utilities.vector as ftuv
import forgi.threedee.utilities.graph_pdb as ftug
import sys
if __name__=="__main__":
filename=sys.argv[1]
print ("BUILDSTRUCTURE: Filename is ", filename)
cg=ftmc.CoarseGrainRNA(filename)
print ("BUILDSTRUCTURE: cg is ", cg)
sm=fbm.SpatialModel(cg)
print ("BUILDSTRUCTURE: sampling ")
sm.sample_stats()
print ("BUILDSTRUCTURE: traverse and build ")
sm.traverse_and_build()
print("BUILDSTRUCTURE: Writing File")
centroid0 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(sm.bg))
for k in cg.coords.keys():
cg.coords[k] = ((cg.coords[k][0] - centroid0),
(cg.coords[k][1] - centroid0))
sm.bg.to_cg_file(filename)
print ("BUILDSTRUCTURE: DONE")
def restore_cg(self, reference_cg):
self.ref_sm = fbm.SpatialModel(copy.deepcopy(reference_cg))
self.ref_sm.load_sampled_elems()
self.ref_vress = self.ref_sm.bg.get_ordered_virtual_residue_poss()
def compare(self, d, other_stats):
if not self.rmsd:
stats = self.ref_sm.elem_defs[d]
return is_similar(stats, other_stats, self.tol)
else:
self.ref_sm.elem_defs[d]=other_stats
self.ref_sm.traverse_and_build(start=d)
curr_vress=self.ref_sm.bg.get_ordered_virtual_residue_poss()
rmsd=ftur.rmsd(self.ref_vress, curr_vress)
return rmsd<self.tol
parser=generateParser()
if __name__=="__main__":
args = parser.parse_args()
cg=ftmc.CoarseGrainRNA(args.cg)
sm=fbm.SpatialModel(cg, ftms.get_conformation_stats(args.stats_file))
sm.load_sampled_elems()
maxNum=0
maxLoop=0
sumStats=0
comp = Comparison(sm.bg, args.tolerance, args.rmsd)
for define in cg.defines:
similar_stats=0
allstats = sm.conf_stats.sample_stats(cg, define)
numStats = len(allstats)
if define[0] in "mi" and numStats:
if args.cluster:
distance=np.full((len(allstats),len(allstats)),np.NAN)
for i, stat in enumerate(allstats):
if args.cluster:
for j, stat2 in enumerate(allstats):
def test_sample_elems_doesnot_crash(self):
sm = fbm.SpatialModel(self.cg)
sm.sample_stats(self.stat_source)
def setUp(self):
self.sm1 = fbm.SpatialModel(
ftmc.CoarseGrainRNA.from_bg_file('test/fess/data/4way.cg'))
self.sm2 = fbm.SpatialModel(
ftmc.CoarseGrainRNA.from_bg_file('test/fess/data/4way.cg'))
seq = fus.gen_random_sequence(len(dotbracket))
cg = ftmc.CoarseGrainRNA(dotbracket_str=dotbracket, seq=seq)
return cg
parser = generateParser()
if __name__ == "__main__":
args = parser.parse_args()
energy = fbe.CombinedEnergy([fbe.RoughJunctionClosureEnergy()])
for link_length in range(0, 4):
cutoff_distance = (link_length) * 6.22 + 14.0
print("\nLink Length {}".format(link_length))
for l in range(1, 30): #Sampling 30 times with different stem stats
cg = construct_test_graph(random.randrange(3, 15), l, link_length)
sm = fbm.SpatialModel(
cg,
ftms.get_conformation_stats(
data_file("stats/all_filtered.stats")))
sm.sample_stats()
possible_sstats = sm.conf_stats.sample_stats(cg, "s1")
for sstat in possible_sstats:
if sstat.pdb_name.startswith("ideal"):
break
maxdist = 0
sm.elem_defs["s1"] = sstat
possible_stats = sm.conf_stats.sample_stats(cg, "m0")
for i, stat in enumerate(possible_stats):
#if i%1000 == 0:
# print(i, "/", len(possible_stats), end="")
sm.elem_defs["m0"] = stat
sm.traverse_and_build()
