コード例 #1
0
ファイル: views.py プロジェクト: Bernhard10/ernvis
def changeLoop(filename, loopname):
    posted=request.get_json(force=True)
    if posted["action"]=="change" and posted["method"]=="random":
        sm=get_sm(filename)
        sm.load_sampled_elems()
        if loopname not in sm.bg.coords:
            abort(404)
        original_cg=copy.deepcopy(sm.bg)
        new_filename=get_new_filename()
        smCache.renameSM(filename, new_filename)
        change_elem(sm, loopname)
        cg=sm.bg

        centroid0 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(original_cg))
        centroid1 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(cg))
        crds0 = ftuv.center_on_centroid(ftug.bg_virtual_residues(original_cg))
        crds1 = ftuv.center_on_centroid(ftug.bg_virtual_residues(cg))
        rot_mat = ftur.optimal_superposition(crds0, crds1)
        for k in cg.coords.keys():
            cg.coords[k] = (np.dot(rot_mat, cg.coords[k][0] - centroid1),
                            np.dot(rot_mat, cg.coords[k][1] - centroid1))
            if k[0] == 's':
                cg.twists[k] = (np.dot(rot_mat, cg.twists[k][0]),
                                np.dot(rot_mat, cg.twists[k][1]))

        filename=get_new_filename()
        cg.to_cg_file("user_files/"+filename)

        return jsonify({"url": url_for("structure_main", filename=filename)})
    else:
        abort(403)
コード例 #2
0
 def test_cg_rmsd(self):
     cg1 = ftmc.CoarseGrainRNA('test/forgi/threedee/data/1GID_A.cg')
     cg2 = ftmc.CoarseGrainRNA('test/forgi/threedee/data/1GID_A_sampled.cg')
     residues1 = ftug.bg_virtual_residues(cg1)
     residues2 = ftug.bg_virtual_residues(cg2)
     self.assertAlmostEqual(ftme.rmsd(residues1, residues2),
                            ftme.cg_rmsd(cg1, cg2))
コード例 #3
0
ファイル: cg_rmsd.py プロジェクト: marcelTBI/forgi
def main():
    usage = """
    python cg_rmsd.py file1.cg file2.cg

    Calculate the RMSD between two coarse grain models.
    """
    num_args= 2
    parser = OptionParser(usage=usage)

    #parser.add_option('-o', '--options', dest='some_option', default='yo', help="Place holder for a real option", type='str')
    #parser.add_option('-u', '--useless', dest='uselesss', default=False, action='store_true', help='Another useless option')

    (options, args) = parser.parse_args()

    if len(args) < num_args:
        parser.print_help()
        sys.exit(1)

    cg1 = ftmc.CoarseGrainRNA(args[0])
    cg2 = ftmc.CoarseGrainRNA(args[1])

    vrs1 = ftug.bg_virtual_residues(cg1)
    vrs2 = ftug.bg_virtual_residues(cg2)

    print ftur.centered_rmsd(vrs1, vrs2)
コード例 #4
0
def changeLoop(filename, loopname):
    posted = request.get_json(force=True)
    if posted["action"] == "change" and posted["method"] == "random":
        sm = get_sm(filename)
        sm.load_sampled_elems()
        if loopname not in sm.bg.coords:
            abort(404)
        original_cg = copy.deepcopy(sm.bg)
        new_filename = get_new_filename()
        smCache.renameSM(filename, new_filename)
        change_elem(sm, loopname)
        cg = sm.bg

        centroid0 = ftuv.get_vector_centroid(
            ftug.bg_virtual_residues(original_cg))
        centroid1 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(cg))
        crds0 = ftuv.center_on_centroid(ftug.bg_virtual_residues(original_cg))
        crds1 = ftuv.center_on_centroid(ftug.bg_virtual_residues(cg))
        rot_mat = ftur.optimal_superposition(crds0, crds1)
        for k in cg.coords.keys():
            cg.coords[k] = (np.dot(rot_mat, cg.coords[k][0] - centroid1),
                            np.dot(rot_mat, cg.coords[k][1] - centroid1))
            if k[0] == 's':
                cg.twists[k] = (np.dot(rot_mat, cg.twists[k][0]),
                                np.dot(rot_mat, cg.twists[k][1]))

        filename = get_new_filename()
        cg.to_cg_file("user_files/" + filename)

        return jsonify({"url": url_for("structure_main", filename=filename)})
    else:
        abort(403)
コード例 #5
0
ファイル: visualize_cg.py プロジェクト: marcelTBI/forgi
def align_cgs(cgs):
    '''
    Align each coarse grain RNA to the first one.

    The points representing each coarse grain RNA molecule
    will be the virtual residues.
    
    @param cgs: A list of CoarseGrainRNA structures.
    @return: Nothing, the cgs are modified in place
    '''
    centroid0 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(cgs[0]))
    crds0 = ftuv.center_on_centroid(ftug.bg_virtual_residues(cgs[0]))

    for cg in cgs:
        centroid1 = ftuv.get_vector_centroid(ftug.bg_virtual_residues(cg))
        crds1 = ftuv.center_on_centroid(ftug.bg_virtual_residues(cg))

        rot_mat = ftur.optimal_superposition(crds0, crds1)
        for k in cg.coords.keys():
            cg.coords[k] = (np.dot(rot_mat, cg.coords[k][0] - centroid1),
                            np.dot(rot_mat, cg.coords[k][1] - centroid1))

            if k[0] == 's':
                cg.twists[k] = (np.dot(rot_mat, cg.twists[k][0]),
                                np.dot(rot_mat, cg.twists[k][1]))
コード例 #6
0
ファイル: sampling.py プロジェクト: pkerpedjiev/ernwin
    def __init__(self, sm_orig, plotter=None, plot_color=None, silent=False, output_file=sys.stdout, save_n_best=3, dists=[], no_rmsd=False, save_iterative_cg_measures=False):
        '''
        @param sm_orig: The original Spatial Model against which to collect statistics.
        '''
        self.energy_rmsd_structs = []
        self.counter = 0
        self.plotter = plotter
        self.plot_color = plot_color
        self.silent = silent
        self.verbose = False
        self.output_file = output_file
        self.save_n_best = save_n_best
        self.sm_orig = sm_orig
        self.energy_orig = None
        self.step_save = 0
        self.save_iterative_cg_measures = save_iterative_cg_measures



        self.dists = dists

        self.highest_rmsd = 0.
        self.lowest_rmsd = 10000000000.
        self.no_rmsd = no_rmsd
        self.creation_time = time.time()

        try:
            self.centers_orig = ftug.bg_virtual_residues(sm_orig.bg)        
            self.confusion_matrix_calculator = ftme.ConfusionMatrix(sm_orig.bg)
        except KeyError:
            # if there are no coordinates provided in the original
            # bulge graph file, then don't calculate rmsds
            self.centers_orig = None
            self.confusion_matrix_calculator = None
コード例 #7
0
def main(args):

    cgs = []
    projs = []
    for file_ in args.files:
        cgs.append(ftmc.CoarseGrainRNA(file_))
        try:
            projs.append(ftmp.Projection2D(cgs[-1]))
        except ValueError:
            projs.append(None)

    p_rmsds = OrderedDict()
    cg_rmsds = OrderedDict()
    p_rmsds[0] = 0.0
    cg_rmsds[0] = 0.0

    if "," in args.max_diff:
        diffs = map(int, args.max_diff.split(","))
    else:
        diffs = range(1, int(args.max_diff) + 1)
    for diff in diffs:
        print ("diff {}".format(diff))
        prmsd = 0
        cgrmsd = 0
        count = 0
        pcount = 0
        for i in range(0, len(cgs) - diff):
            count += 1
            try:
                vrs1 = np.array([x for p in sorted(projs[i]._coords.keys()) for x in projs[i]._coords[p]])
                vrs2 = np.array([x for p in sorted(projs[i + diff]._coords.keys()) for x in projs[i + diff]._coords[p]])
                prmsd += ftms.rmsd(vrs1, vrs2)
                pcount += 1
            except:
                pass
            cgrmsd += ftms.cg_rmsd(cgs[i], cgs[i + diff])
        if count:
            cg_rmsds[diff] = cgrmsd / count
        if pcount:
            p_rmsds[diff] = prmsd / pcount
    print "projection RMSDs:", p_rmsds
    print "3D-RMSDs:", cg_rmsds
    import matplotlib.pyplot as plt

    if args.target_structure and args.hausdorff_reference:
        fig, (ax, axT, axH) = plt.subplots(3)
    elif args.target_structure:
        fig, (ax, axT) = plt.subplots(2)
    elif args.hausdorff_reference:
        fig, (ax, axH) = plt.subplots(2)
    else:
        fig, ax = plt.subplots()

    if args.target_structure:
        target = ftmc.CoarseGrainRNA(args.target_structure)
        target_rmsds = []
        target_proj_rmsds = []
        try:
            target_proj = ftmp.Projection2D(target)
        except ValueError:
            pass
        else:
            target_vrs = np.array([x for p in sorted(target_proj._coords.keys()) for x in target_proj._coords[p]])
            for proj in projs:
                try:
                    vrs1 = np.array([x for p in sorted(proj._coords.keys()) for x in proj._coords[p]])
                    prmsd = ftms.rmsd(vrs1, target_vrs)
                    target_proj_rmsds.append(prmsd)
                except:
                    target_proj_rmsds.append(float("nan"))
        target_vrs = ftug.bg_virtual_residues(target)
        for cg in cgs:
            vrs1 = ftug.bg_virtual_residues(cg)
            cgrmsd = ftms.rmsd(vrs1, target_vrs)
            target_rmsds.append(cgrmsd)
        xval = np.arange(len(cgs)) * args.step_size
        if target_proj_rmsds:
            axT.plot(xval, target_proj_rmsds, label="Projection", color="green")
        axT.plot(xval, target_rmsds, label="3D", color="blue")
        axT.set_title("RMSD to target structure")
        axT.set_xlabel("step")
        axT.set_ylabel("RMSD")
        leg = axT.legend(framealpha=0.8, fancybox=True)
        leg.get_frame().set_linewidth(0.0)
        plt.subplots_adjust(hspace=0.4)
    if args.hausdorff_reference:
        ref_img = scipy.ndimage.imread(args.hausdorff_reference)
        ref_quarter = scipy.ndimage.zoom(ref_img, 0.3) > 150
        degrees = get_refimg_longest_axis(ref_img)
        global_optima = []
        local_optima = []
        for cg in cgs:
            score, img, params = fph.try_parameters(ref_img, args.hausdorff_scale, cg, degrees)
            local_optima.append(score)
            s, i, params = fph.globally_minimal_distance(
                ref_quarter, args.hausdorff_scale, cg, start_points=40, starting_rotations=degrees, virtual_atoms=False
            )
            score, img, params = fph.locally_minimal_distance(
                ref_img, args.hausdorff_scale, cg, params[1], params[2], params[0], maxiter=200
            )
            global_optima.append(score)

        axH.plot(xval, global_optima, label="Global Minimization", color="red")
        axH.plot(xval, local_optima, label="Local Minimization", color="lavender")
        axH.set_title("Hausdorff Distance to reference image")
        axH.set_xlabel("step")
        axH.set_ylabel("Hausdorff Distance")
        leg = axH.legend(framealpha=0.8, fancybox=True)
        leg.get_frame().set_linewidth(0.0)
        plt.subplots_adjust(hspace=0.4)

    p_rmsds = np.array(p_rmsds.items())
    cg_rmsds = np.array(cg_rmsds.items())
    ax.plot(p_rmsds[:, 0] * args.step_size, p_rmsds[:, 1], label="Projection", color="green", marker="o")
    ax.plot(cg_rmsds[:, 0] * args.step_size, cg_rmsds[:, 1], label="3D", color="blue", marker="o")
    ax.set_title("Average RMSD between structures X steps apart.")
    ax.set_xlabel("steps apart")
    ax.set_ylabel("RMSD")
    leg = ax.legend(framealpha=0.8, fancybox=True)
    leg.get_frame().set_linewidth(0.0)
    fig.patch.set_facecolor("white")
    if args.save_fig:
        with open(args.save_fig, "w") as f:
            pickle.dump(fig, f)
    plt.show()
コード例 #8
0
ファイル: compare_test.py プロジェクト: tcarlile/forgi
 def test_cg_rmsd(self):
     cg1 = ftmc.CoarseGrainRNA('test/forgi/threedee/data/1GID_A.cg')
     cg2 = ftmc.CoarseGrainRNA('test/forgi/threedee/data/1GID_A_sampled.cg')
     residues1 = ftug.bg_virtual_residues(cg1) 
     residues2 = ftug.bg_virtual_residues(cg2)
     self.assertAlmostEqual(ftur.centered_rmsd(residues1, residues2), ftme.cg_rmsd(cg1,cg2))
コード例 #9
0
ファイル: buildstructure.py プロジェクト: Bernhard10/ernvis
#! /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")
コード例 #10
0
def main(args):

    cgs = []
    projs = []
    for file_ in args.files:
        cgs.append(ftmc.CoarseGrainRNA(file_))
        try:
            projs.append(ftmp.Projection2D(cgs[-1]))
        except ValueError:
            projs.append(None)

    p_rmsds = OrderedDict()
    cg_rmsds = OrderedDict()
    p_rmsds[0] = 0.
    cg_rmsds[0] = 0.

    if "," in args.max_diff:
        diffs = map(int, args.max_diff.split(","))
    else:
        diffs = range(1, int(args.max_diff) + 1)
    for diff in diffs:
        print("diff {}".format(diff))
        prmsd = 0
        cgrmsd = 0
        count = 0
        pcount = 0
        for i in range(0, len(cgs) - diff):
            count += 1
            try:
                vrs1 = np.array([
                    x for p in sorted(projs[i]._coords.keys())
                    for x in projs[i]._coords[p]
                ])
                vrs2 = np.array([
                    x for p in sorted(projs[i + diff]._coords.keys())
                    for x in projs[i + diff]._coords[p]
                ])
                prmsd += ftms.rmsd(vrs1, vrs2)
                pcount += 1
            except:
                pass
            cgrmsd += ftms.cg_rmsd(cgs[i], cgs[i + diff])
        if count:
            cg_rmsds[diff] = cgrmsd / count
        if pcount:
            p_rmsds[diff] = prmsd / pcount
    print("projection RMSDs:", p_rmsds)
    print("3D-RMSDs:", cg_rmsds)
    import matplotlib.pyplot as plt
    if args.target_structure and args.hausdorff_reference:
        fig, (ax, axT, axH) = plt.subplots(3)
    elif args.target_structure:
        fig, (ax, axT) = plt.subplots(2)
    elif args.hausdorff_reference:
        fig, (ax, axH) = plt.subplots(2)
    else:
        fig, ax = plt.subplots()

    if args.target_structure:
        target = ftmc.CoarseGrainRNA(args.target_structure)
        target_rmsds = []
        target_proj_rmsds = []
        try:
            target_proj = ftmp.Projection2D(target)
        except ValueError:
            pass
        else:
            target_vrs = np.array([
                x for p in sorted(target_proj._coords.keys())
                for x in target_proj._coords[p]
            ])
            for proj in projs:
                try:
                    vrs1 = np.array([
                        x for p in sorted(proj._coords.keys())
                        for x in proj._coords[p]
                    ])
                    prmsd = ftms.rmsd(vrs1, target_vrs)
                    target_proj_rmsds.append(prmsd)
                except:
                    target_proj_rmsds.append(float("nan"))
        target_vrs = ftug.bg_virtual_residues(target)
        for cg in cgs:
            vrs1 = ftug.bg_virtual_residues(cg)
            cgrmsd = ftms.rmsd(vrs1, target_vrs)
            target_rmsds.append(cgrmsd)
        xval = np.arange(len(cgs)) * args.step_size
        if target_proj_rmsds:
            axT.plot(xval,
                     target_proj_rmsds,
                     label="Projection",
                     color="green")
        axT.plot(xval, target_rmsds, label="3D", color="blue")
        axT.set_title("RMSD to target structure")
        axT.set_xlabel("step")
        axT.set_ylabel("RMSD")
        leg = axT.legend(framealpha=0.8, fancybox=True)
        leg.get_frame().set_linewidth(0.0)
        plt.subplots_adjust(hspace=0.4)
    if args.hausdorff_reference:
        ref_img = scipy.ndimage.imread(args.hausdorff_reference)
        ref_quarter = (scipy.ndimage.zoom(ref_img, 0.3) > 150)
        degrees = get_refimg_longest_axis(ref_img)
        global_optima = []
        local_optima = []
        for cg in cgs:
            score, img, params = fph.try_parameters(ref_img,
                                                    args.hausdorff_scale, cg,
                                                    degrees)
            local_optima.append(score)
            s, i, params = fph.globally_minimal_distance(
                ref_quarter,
                args.hausdorff_scale,
                cg,
                start_points=40,
                starting_rotations=degrees,
                virtual_atoms=False)
            score, img, params = fph.locally_minimal_distance(
                ref_img,
                args.hausdorff_scale,
                cg,
                params[1],
                params[2],
                params[0],
                maxiter=200)
            global_optima.append(score)

        axH.plot(xval, global_optima, label="Global Minimization", color="red")
        axH.plot(xval,
                 local_optima,
                 label="Local Minimization",
                 color="lavender")
        axH.set_title("Hausdorff Distance to reference image")
        axH.set_xlabel("step")
        axH.set_ylabel("Hausdorff Distance")
        leg = axH.legend(framealpha=0.8, fancybox=True)
        leg.get_frame().set_linewidth(0.0)
        plt.subplots_adjust(hspace=0.4)

    p_rmsds = np.array(list(p_rmsds.items()))
    cg_rmsds = np.array(list(cg_rmsds.items()))
    ax.plot(p_rmsds[:, 0] * args.step_size,
            p_rmsds[:, 1],
            label="Projection",
            color="green",
            marker="o")
    ax.plot(cg_rmsds[:, 0] * args.step_size,
            cg_rmsds[:, 1],
            label="3D",
            color="blue",
            marker="o")
    ax.set_title("Average RMSD between structures X steps apart.")
    ax.set_xlabel("steps apart")
    ax.set_ylabel("RMSD")
    leg = ax.legend(framealpha=0.8, fancybox=True)
    leg.get_frame().set_linewidth(0.0)
    fig.patch.set_facecolor('white')
    if args.save_fig:
        with open(args.save_fig, "w") as f:
            pickle.dump(fig, f)
    plt.show()
コード例 #11
0
ファイル: sampling.py プロジェクト: pkerpedjiev/ernwin
    def update_statistics(self, energy_function, sm, prev_energy, tracking_energies = None, tracked_energies=None):
        '''
        Add a newly sampled structure to the set of statistics.

        :param energy_function: The energy_function used to evaluate the structure.
        :param sm: The spatial model that was sampled.
        :param prev_energy: The evaluated (accepted) energy of the current step 
        :tracking_energyis: The energy_functions which are calculated for statistics, but not used for sampling.
        :tracked_energies: The energy values of the tracking_energies.
        '''
        self.counter += 1

        if self.energy_orig is None:
            self.energy_orig = 0.
            try:
                self.sm_orig.bg.add_all_virtual_residues()
                self.energy_orig = energy_function.eval_energy(self.sm_orig)
            except KeyError:
                # most likely no native structure was provided
                pass

        energy = prev_energy
        #energy = energy_function.eval_energy(sm, background=True)
        if energy_function.uses_background():
            energy_nobg = energy_function.eval_energy(sm, background=False)
        else:
            energy_nobg=energy

        mcc = None

        if self.centers_orig is not None:
            r = 0.
            if not self.no_rmsd:
                centers_new = ftug.bg_virtual_residues(sm.bg)
                r = cbr.centered_rmsd(self.centers_orig, centers_new)
                #r = cbr.drmsd(self.centers_orig, centers_new)
                cm = self.confusion_matrix_calculator.evaluate(sm.bg)
                mcc = ftme.mcc(cm)
        else:            
            # no original coordinates provided so we can't calculate rmsds
            r = 0.

        dist = None
        dist2 = None

        cg = sm.bg
        dists = []

        for (self.dist1, self.dist2) in self.dists:
            node1 = cg.get_node_from_residue_num(self.dist1)
            node2 = cg.get_node_from_residue_num(self.dist2)

            pos1, len1 = cg.get_position_in_element(self.dist1)
            pos2, len2 = cg.get_position_in_element(self.dist2)

            #fud.pv('node1, node2, pos1, pos2')

            vec1 = cg.coords[node1][1] - cg.coords[node1][0]
            vec2 = cg.coords[node2][1] - cg.coords[node2][0]

            #mid1 = (cg.coords[node1][0] + cg.coords[node1][1]) / 2
            #mid2 = (cg.coords[node2][0] + cg.coords[node2][1]) / 2

            mid1 = cg.coords[node1][0] + pos1 * (vec1 / len1)
            mid2 = cg.coords[node2][0] + pos2 * (vec2 / len2)
            
            #fud.pv('mid1, mid2')

            dists += [ftuv.vec_distance(mid1, mid2)]

        #self.energy_rmsd_structs += [(energy, r, sm.bg)]
        self.energy_rmsd_structs += [(energy_nobg, r, copy.deepcopy(sm.bg))]
        #self.energy_rmsd_structs += [(energy, r, sm.bg.copy())]

        sorted_energies = sorted(self.energy_rmsd_structs, key=lambda x: x[0])
        self.energy_rmsd_structs = sorted_energies[:self.save_n_best]

        if r > self.highest_rmsd:
            self.highest_rmsd = r

        if r < self.lowest_rmsd:
            self.lowest_rmsd = r

        lowest_energy = sorted_energies[0][0]
        lowest_rmsd = sorted_energies[0][1]

        '''
        if energy == lowest_energy:
            for key in sm.angle_defs:
                print >>sys.stderr, key, str(sm.angle_defs[key])
        '''

        if not self.silent:
            if self.verbose:
                '''
                for energy_func in energy_function.energies:
                    print energy_func.__class__.__name__, energy_func.eval_energy(sm)
                '''
            _, rog=fbe.length_and_rog(sm.bg)
            #output_str = u"native_energy [{:s} {:d}]: {:3d} {:5.03g} {:5.3f} ROG: {:5.3f} | min:
            output_str = u"native_energy [%s %d]: %3d %5.03g  %5.3f ROG: %5.3f | min: %5.2f (%5.2f) %5.2f | extreme_rmsds: %5.2f %5.2f (%.2f)" % ( sm.bg.name, sm.bg.seq_length, self.counter, energy, r , rog, lowest_energy, self.energy_orig, lowest_rmsd, self.lowest_rmsd, self.highest_rmsd, energy_nobg)
            output_str += " |"

            # assume that the energy function is a combined energy
            if isinstance(self.energy_function, fbe.CombinedEnergy):
                for e in self.energy_function.iterate_energies():
                    if isinstance(e,fbe.DistanceExponentialEnergy):
                        output_str += " [clamp {},{}: {:.1f}]".format(e.from_elem,
                                                                      e.to_elem,
                                                                      e.get_distance(sm))
            if tracked_energies and tracking_energies:
                output_str += " | [tracked Energies]"
                for i,e in enumerate(tracking_energies):
                    sn=e.shortname()
                    if len(sn)>12:
                        sn=sn[:9]+"..."
                    output_str += "  [{}]: ".format(sn)
                    output_str += "%5.03g" % (tracked_energies[i])
            elif tracking_energies:
                output_str += " | [tracked Energies]"
                for e in tracking_energies:
                    sn=e.shortname()
                    if len(sn)>12:
                        sn=sn[:9]+"..."
                    output_str += "  [{}]: ".format(sn)
                    output_str += "%5.03g" % (e.eval_energy(sm))

            if dist:
                output_str += " | dist %.2f" % (dist)

            for dist2 in dists:
                if dist2 is not None:
                    output_str += " | [dist2: %.2f]" % (dist2)

            if mcc is not None:
                output_str += " | [mcc: %.3f]" % (mcc)

            output_str += " [time: %.1f]" % (time.time() - self.creation_time)

            #Print to both STDOUT and the log file.
            if self.output_file != sys.stdout:
                print (output_str.strip())

            if self.output_file != None:
                print(output_str, file=self.output_file)
                self.output_file.flush()

        self.update_plots(energy, r)

        '''
        if self.counter % 1000 == 0:
            import pdb; pdb.set_trace()
        '''

        if self.counter % 10 == 0:
            if not self.silent:
                self.save_top(self.save_n_best, counter=self.counter)

        if self.step_save > 0 and self.counter % self.step_save == 0:
            #If a projection match energy was used, save the optimal projection direction to the file.
            if isinstance(self.energy_function, fbe.CombinedEnergy):
                for e in self.energy_function.iterate_energies():
                    if hasattr(e, "accepted_projDir"):
                        sm.bg.project_from=e.accepted_projDir
            sm.bg.to_cg_file(os.path.join(cbc.Configuration.sampling_output_dir, 'step%06d.coord' % (self.counter)))