def main(
        self,
        jobid,
        lines,
        atoms_hessian=['CA'],
        frames=50,
        cutoff_distance=10.,
        path_html=None,
        path_python=None,
        verbose=False,
        paralleldir='',
        chains=None,
        winsize=1,
        pre_perturbation_plot=True,
        polyhedron=None,
    ):

        import goodvibes_core

        ##
        ## parse pdb
        ##
        (
            d_REMARK350,
            d_primary,  ## i.e. SEQRES, MODRES
            d_secondary,  ## i.e. HELIX, SHEET
            d_coordinates,  ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
        ) = goodvibes_core.parse_pdb(lines, chains)

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(
            d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(
            l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N,
                                                  matrix_distances,
                                                  d_coordinates,
                                                  float(cutoff_distance),
                                                  l_coordinates,
                                                  verbose=verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_combined_nonperturbed = goodvibes_core.eigenv_calccomb(
            matrix_hessian, jobid, verbose)

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(eigenvectors_nonperturbed, frames, chains,
                             d_coordinates, jobid, d_primary)

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,
                cutoff_distance,
                chains,
                d_secondary,
                eigenvectors_nonperturbed,
                eigenvectors_combined_nonperturbed,
            )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        d_vertices = {
            'tetrahedron': 4,
            'hexahedron': 8,
            'octahedron': 6,
            'icosahedron': 12,
        }

        ##
        ## loop over remres1
        ##
        for remres1 in range((winsize - 1) / 2,
                             N - winsize - (winsize - 1) / 2):

            resrange1 = range(remres1 - (winsize - 1) / 2,
                              remres1 + (winsize - 1) / 2 + 1)
            l_c1 = []
            for res1 in resrange1:
                c1 = l_coordinates[res1]
                l_c1 += goodvibes_core.platonicsolid(c1, polyhedron=polyhedron)

            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(
                datadic, filename, remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1 + 2 * (winsize - 1) / 2 + 1,
                                 N - (winsize - 1) / 2):

                print remres1, remres2

                resrange2 = range(remres2 - (winsize - 1) / 2,
                                  remres2 + (winsize - 1) / 2 + 1)
                l_c2 = []
                for res2 in resrange2:
                    c2 = l_coordinates[res2]
                    l_c2 += goodvibes_core.platonicsolid(c2,
                                                         polyhedron=polyhedron)

                l_add = []
                n_vertices = d_vertices[polyhedron]
                for i in range(n_vertices * (2 * winsize)):
                    l_add += [N + i]

                l_coordinates_perturbed = l_coordinates + l_c1 + l_c2

                matrix_hessian_perturbed = self.hessian_calculation(
                    N,
                    matrix_distances,
                    d_coordinates,
                    float(cutoff_distance),
                    l_coordinates_perturbed,
                    verbose=verbose,
                )

                (eigenvectors_perturbed, eigenvalues_perturbed,
                 eigenvectors_perturbed_combined
                 ) = goodvibes_core.eigenv_calccomb(matrix_hessian_perturbed,
                                                    jobid, verbose)

                (overlaps_single, max_overlaps_single,
                 perturbed_modes_of_max_overlap_single,
                 delta_perturbed_eigenvalues_of_max_overlap
                 ) = goodvibes_core.overlap_calculation(
                     eigenvectors_perturbed,
                     eigenvectors_nonperturbed,
                     eigenvalues_perturbed,
                     eigenvalues_nonperturbed,
                     l_add=l_add)

                (overlaps_combined, max_overlaps_combined,
                 perturbed_modes_of_max_overlap_combined
                 ) = goodvibes_core.overlap_calculation(
                     eigenvectors_perturbed_combined,
                     eigenvectors_nonperturbed,
                     eigenvalues_perturbed,
                     eigenvalues_nonperturbed,
                     l_add=l_add,
                 )[:-1]
                print overlaps_single[6]

                ##        ## do vmd of perturbed structure
                ##        self.morph(eigenvectors, frames, biomolecule, d_coordinates, atoms_hessian, cluster, matrix_hessian, jobid+'-'+str(xvalue)+'-'+str(yvalue), cutoff_distance)

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                }
                for key in datadic:
                    for mode in range(6, 12):
                        datadic[key]['data'][mode][remres1][
                            remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][
                            remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][
                    remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][
                    remres1] = overlaps_combined[-1]

            ## write data to txt files in case of crash during loop over residues/clusters
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            goodvibes_core.multiple_cpus_write(datadic, filename, remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
        goodvibes_core.post_perturbation_plot(
            datadic,
            jobid,
            chains,
            cutoff_distance,
            d_hessian,
            N,
            d_secondary,
            d_coordinates,
            winsize=winsize,
        )

        return
    def main(
        self, jobid, lines, atoms_hessian = ['CA'], frames = 50,
        cutoff_distance = 10.,
        path_python = None, verbose = False, paralleldir = '',
        biomolecule = None, chains = [], model = None,
        pre_perturbation_plot = False,
        winsize = 1,
        ):

        '''
        Use first model if no model specified by user.
        chain(s): Y, biomolecule: Y; parse chains specified by user and apply transformation
        chain(s): Y, biomolecule: N; parse chains specified by user but don't apply transformation
        chain(s): N, biomolecule: Y; parse chains of biomolecule and apply transformation
        chain(s): N, biomolecule: N; parse chains of first biomolecule and apply transformation
        '''

        import os, Numeric, goodvibes_core

        results = []

        ## parse pdb
        (
            d_REMARK350,
            d_primary, ## i.e. SEQRES, MODRES
            d_secondary, ## i.e. HELIX, SHEET
            d_coordinates, ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
            ) = goodvibes_core.parse_pdb(lines, chains)

        ## assume multimeric biological unit if chains not specified by user
        if chains == []:
            chains = d_coordinates['chains'].keys()
            chains.sort()

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N, d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates, verbose = verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_comb_nonperturbed, = goodvibes_core.eigenv_calccomb(
                matrix_hessian, jobid, verbose,
                )

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(
            eigenvectors_nonperturbed, frames, chains, d_coordinates,
            jobid, d_primary,
            )

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,cutoff_distance,chains,d_secondary,
                eigenvectors_nonperturbed,eigenvectors_comb_nonperturbed,
                )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        ##
        ## loop over remres1
        ##
        for remres1 in range((winsize-1)/2,N-winsize-(winsize-1)/2):

            resrange1 = range(remres1-(winsize-1)/2,remres1+(winsize-1)/2+1)

            ##
            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            ##
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(datadic,filename,remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1+2*(winsize-1)/2+1,N-(winsize-1)/2):

                print remres1, remres2
                resrange2 = range(remres2-(winsize-1)/2,remres2+(winsize-1)/2+1)

                matrix_hessian_perturbed = self.hessian_calculation(
                    N, d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates, resrange1 = resrange1, resrange2 = resrange2, verbose = verbose,
                    )

                (
                    eigenvectors_perturbed, eigenvalues_perturbed, eigenvectors_perturbed_combined,
                    ) = goodvibes_core.eigenv_calccomb(
                        matrix_hessian_perturbed, jobid, verbose
                        )

                (
                    overlaps_single, max_overlaps_single, perturbed_modes_of_max_overlap_single, delta_perturbed_eigenvalues_of_max_overlap,
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed,
                        )

                (
                    overlaps_combined, max_overlaps_combined, perturbed_modes_of_max_overlap_combined,
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed_combined, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed,
                        )[:-1]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                    }
                for key in datadic:
                    for mode in range(6,12):
                        datadic[key]['data'][mode][remres1][remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][remres1] = overlaps_combined[-1]

                print overlaps_single[6]

            ##
            ## write data to txt files in case of crash during loop over residues/clusters
            ##
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            goodvibes_core.multiple_cpus_write(datadic,filename,remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
        goodvibes_core.post_perturbation_plot(
            datadic, jobid, chains, cutoff_distance, d_hessian, N, d_secondary, d_coordinates,
            winsize = winsize,
            )


        return
    def main(
        self, jobid, lines, atoms_hessian = ['CA'], frames = 50,
        cutoff_distance = 10.,
        path_html = None, path_python = None, verbose = False, paralleldir = '',
        chains = None,
        ):

        import goodvibes_core

        ##
        ## parse pdb
        ##
        (
            d_REMARK350,
            d_primary, ## i.e. SEQRES, MODRES
            d_secondary, ## i.e. HELIX, SHEET
            d_coordinates, ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
            ) = goodvibes_core.parse_pdb(lines, chains)


        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N, d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates, verbose = verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_combined_nonperturbed = goodvibes_core.eigenv_calccomb(matrix_hessian, jobid, verbose)

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(eigenvectors_nonperturbed, frames, chains, d_coordinates, jobid, d_primary)

        ##
        ## do plots prior to perturbation
        ##
        goodvibes_core.pre_perturbation_plot(
            jobid,cutoff_distance,chains,d_secondary,
            eigenvectors_nonperturbed,eigenvectors_combined_nonperturbed,
            )
        
        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        ##
        ## loop over remres1
        ##
        for remres1 in range(N-1):

            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(datadic,filename,remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1+1,N):

                print remres1, remres2
                l_mod = [remres1,remres2]

                ##
                ## calculate hessian matrix
                ##
                matrix_hessian_perturbed = self.hessian_calculation(
                    N, d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates, verbose = verbose, l_mod = l_mod,
                    )

                ##
                ## diagonalize hessian matrix and calculate eigenvectors
                ##
                (
                    eigenvectors_perturbed, eigenvalues_perturbed, eigenvectors_perturbed_combined
                    ) = goodvibes_core.eigenv_calccomb(
                        matrix_hessian_perturbed, jobid, verbose
                        )

                ##
                ## calculate overlap between eigenvectors
                ##
                (
                    overlaps_single, max_overlaps_single, perturbed_modes_of_max_overlap_single, delta_perturbed_eigenvalues_of_max_overlap
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed,
                        )
                
                (
                    overlaps_combined, max_overlaps_combined, perturbed_modes_of_max_overlap_combined
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed_combined, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed,
                        )[:-1]
                print overlaps_single[6]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                    }
                for key in datadic:
                    for mode in range(6,12):
                        datadic[key]['data'][mode][remres1][remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][remres1] = overlaps_combined[-1]

            ## write data to txt files in case of crash during loop over residues/clusters
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            goodvibes_core.multiple_cpus_write(datadic,filename,remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
        goodvibes_core.post_perturbation_plot(
            datadic, jobid, chains, cutoff_distance, d_hessian, N, d_secondary, d_coordinates,
            )


        return
示例#4
0
    def main(
        self,
        jobid,
        lines,
        atoms_hessian=['CA'],
        frames=50,
        cutoff_distance=10.,
        path_html=None,
        path_python=None,
        verbose=False,
        paralleldir='',
        chains=None,
    ):

        import goodvibes_core

        ##
        ## parse pdb
        ##
        (
            d_REMARK350,
            d_primary,  ## i.e. SEQRES, MODRES
            d_secondary,  ## i.e. HELIX, SHEET
            d_coordinates,  ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
        ) = goodvibes_core.parse_pdb(lines, chains)

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(
            d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(
            l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N,
                                                  d_coordinates,
                                                  chains,
                                                  atoms_hessian,
                                                  float(cutoff_distance),
                                                  d_secondary,
                                                  matrix_distances,
                                                  l_coordinates,
                                                  verbose=verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_combined_nonperturbed = goodvibes_core.eigenv_calccomb(
            matrix_hessian, jobid, verbose)

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(eigenvectors_nonperturbed, frames, chains,
                             d_coordinates, jobid, d_primary)

        ##
        ## do plots prior to perturbation
        ##
        goodvibes_core.pre_perturbation_plot(
            jobid,
            cutoff_distance,
            chains,
            d_secondary,
            eigenvectors_nonperturbed,
            eigenvectors_combined_nonperturbed,
        )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        ##
        ## loop over remres1
        ##
        for remres1 in range(N - 1):

            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(
                datadic, filename, remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1 + 1, N):

                print remres1, remres2
                l_mod = [remres1, remres2]

                ##
                ## calculate hessian matrix
                ##
                matrix_hessian_perturbed = self.hessian_calculation(
                    N,
                    d_coordinates,
                    chains,
                    atoms_hessian,
                    float(cutoff_distance),
                    d_secondary,
                    matrix_distances,
                    l_coordinates,
                    verbose=verbose,
                    l_mod=l_mod,
                )

                ##
                ## diagonalize hessian matrix and calculate eigenvectors
                ##
                (eigenvectors_perturbed, eigenvalues_perturbed,
                 eigenvectors_perturbed_combined
                 ) = goodvibes_core.eigenv_calccomb(matrix_hessian_perturbed,
                                                    jobid, verbose)

                ##
                ## calculate overlap between eigenvectors
                ##
                (overlaps_single, max_overlaps_single,
                 perturbed_modes_of_max_overlap_single,
                 delta_perturbed_eigenvalues_of_max_overlap
                 ) = goodvibes_core.overlap_calculation(
                     eigenvectors_perturbed,
                     eigenvectors_nonperturbed,
                     eigenvalues_perturbed,
                     eigenvalues_nonperturbed,
                 )

                (overlaps_combined, max_overlaps_combined,
                 perturbed_modes_of_max_overlap_combined
                 ) = goodvibes_core.overlap_calculation(
                     eigenvectors_perturbed_combined,
                     eigenvectors_nonperturbed,
                     eigenvalues_perturbed,
                     eigenvalues_nonperturbed,
                 )[:-1]
                print overlaps_single[6]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                }
                for key in datadic:
                    for mode in range(6, 12):
                        datadic[key]['data'][mode][remres1][
                            remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][
                            remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][
                    remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][
                    remres1] = overlaps_combined[-1]

            ## write data to txt files in case of crash during loop over residues/clusters
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            goodvibes_core.multiple_cpus_write(datadic, filename, remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
        goodvibes_core.post_perturbation_plot(
            datadic,
            jobid,
            chains,
            cutoff_distance,
            d_hessian,
            N,
            d_secondary,
            d_coordinates,
        )

        return
    def main(
        self,
        jobid,
        lines,
        atoms_hessian=['CA'],
        frames=50,
        cutoff_distance=10.,
        path_python=None,
        verbose=False,
        paralleldir='',
        biomolecule=None,
        chains=[],
        model=None,
        pre_perturbation_plot=False,
        winsize=1,
    ):
        '''
        Use first model if no model specified by user.
        chain(s): Y, biomolecule: Y; parse chains specified by user and apply transformation
        chain(s): Y, biomolecule: N; parse chains specified by user but don't apply transformation
        chain(s): N, biomolecule: Y; parse chains of biomolecule and apply transformation
        chain(s): N, biomolecule: N; parse chains of first biomolecule and apply transformation
        '''

        import os, Numeric, goodvibes_core

        results = []

        ## parse pdb
        (
            d_REMARK350,
            d_primary,  ## i.e. SEQRES, MODRES
            d_secondary,  ## i.e. HELIX, SHEET
            d_coordinates,  ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
        ) = goodvibes_core.parse_pdb(lines, chains)

        ## assume multimeric biological unit if chains not specified by user
        if chains == []:
            chains = d_coordinates['chains'].keys()
            chains.sort()

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(
            d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(
            l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N,
                                                  d_coordinates,
                                                  chains,
                                                  atoms_hessian,
                                                  float(cutoff_distance),
                                                  d_secondary,
                                                  matrix_distances,
                                                  l_coordinates,
                                                  verbose=verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_comb_nonperturbed, = goodvibes_core.eigenv_calccomb(
            matrix_hessian,
            jobid,
            verbose,
        )

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(
            eigenvectors_nonperturbed,
            frames,
            chains,
            d_coordinates,
            jobid,
            d_primary,
        )

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,
                cutoff_distance,
                chains,
                d_secondary,
                eigenvectors_nonperturbed,
                eigenvectors_comb_nonperturbed,
            )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        ##
        ## loop over remres1
        ##
        for remres1 in range((winsize - 1) / 2,
                             N - winsize - (winsize - 1) / 2):

            resrange1 = range(remres1 - (winsize - 1) / 2,
                              remres1 + (winsize - 1) / 2 + 1)

            ##
            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            ##
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(
                datadic, filename, remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1 + 2 * (winsize - 1) / 2 + 1,
                                 N - (winsize - 1) / 2):

                print remres1, remres2
                resrange2 = range(remres2 - (winsize - 1) / 2,
                                  remres2 + (winsize - 1) / 2 + 1)

                matrix_hessian_perturbed = self.hessian_calculation(
                    N,
                    d_coordinates,
                    chains,
                    atoms_hessian,
                    float(cutoff_distance),
                    d_secondary,
                    matrix_distances,
                    l_coordinates,
                    resrange1=resrange1,
                    resrange2=resrange2,
                    verbose=verbose,
                )

                (
                    eigenvectors_perturbed,
                    eigenvalues_perturbed,
                    eigenvectors_perturbed_combined,
                ) = goodvibes_core.eigenv_calccomb(matrix_hessian_perturbed,
                                                   jobid, verbose)

                (
                    overlaps_single,
                    max_overlaps_single,
                    perturbed_modes_of_max_overlap_single,
                    delta_perturbed_eigenvalues_of_max_overlap,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed,
                    eigenvectors_nonperturbed,
                    eigenvalues_perturbed,
                    eigenvalues_nonperturbed,
                )

                (
                    overlaps_combined,
                    max_overlaps_combined,
                    perturbed_modes_of_max_overlap_combined,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed_combined,
                    eigenvectors_nonperturbed,
                    eigenvalues_perturbed,
                    eigenvalues_nonperturbed,
                )[:-1]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                }
                for key in datadic:
                    for mode in range(6, 12):
                        datadic[key]['data'][mode][remres1][
                            remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][
                            remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][
                    remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][
                    remres1] = overlaps_combined[-1]

                print overlaps_single[6]

            ##
            ## write data to txt files in case of crash during loop over residues/clusters
            ##
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            goodvibes_core.multiple_cpus_write(datadic, filename, remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
        goodvibes_core.post_perturbation_plot(
            datadic,
            jobid,
            chains,
            cutoff_distance,
            d_hessian,
            N,
            d_secondary,
            d_coordinates,
            winsize=winsize,
        )

        return
    def main(
        self,
        jobid,
        lines,
        atoms_hessian=['CA'],
        frames=50,
        cutoff_distance=10.,
        path_python=None,
        verbose=False,
        paralleldir='',
        biomolecule=None,
        chains=[],
        model=None,
        winsize=1,
        pre_perturbation_plot=True,
    ):
        '''
        Use first model if no model specified by user.
        chain(s): Y, biomolecule: Y; parse chains specified by user and apply transformation
        chain(s): Y, biomolecule: N; parse chains specified by user but don't apply transformation
        chain(s): N, biomolecule: Y; parse chains of biomolecule and apply transformation
        chain(s): N, biomolecule: N; parse chains of first biomolecule and apply transformation
        '''

        import os, Numeric, goodvibes_core

        results = []

        ## parse pdb
        (
            d_REMARK350,
            d_primary,  ## i.e. SEQRES, MODRES
            d_secondary,  ## i.e. HELIX, SHEET
            d_coordinates,  ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
        ) = goodvibes_core.parse_pdb(lines, chains)

        ## assume multimeric biological unit if chains not specified by user
        if chains == []:
            chains = d_coordinates['chains'].keys()
            chains.sort()

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(
            d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(
            l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N,
                                                  d_coordinates,
                                                  chains,
                                                  atoms_hessian,
                                                  float(cutoff_distance),
                                                  d_secondary,
                                                  matrix_distances,
                                                  l_coordinates,
                                                  verbose=verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_comb_nonperturbed, = goodvibes_core.eigenv_calccomb(
            matrix_hessian,
            jobid,
            verbose,
        )

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(
            eigenvectors_nonperturbed,
            frames,
            chains,
            d_coordinates,
            jobid,
            d_primary,
        )

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,
                cutoff_distance,
                chains,
                d_secondary,
                eigenvectors_nonperturbed,
                eigenvectors_comb_nonperturbed,
            )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        range2 = [
            0,
            4,
            8,
            16,
        ]
        datadic = goodvibes_core.datadic_return(
            N,
            range2=range2,
        )

        ##
        ## loop over remres1
        ##
        for remres1 in range(N):

            ##
            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            ##
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(
                datadic, filename, remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range2:

                sphere_radius = remres2

                sq_sphere_radius = sphere_radius**2

                print remres1, sphere_radius

                l_rem = []
                for res in range(len(matrix_distances[remres1])):
                    if matrix_distances[remres1][res] < sq_sphere_radius:
                        l_rem += [res]
                l_rem.sort()

                ##
                ## remove selected alpha carbon atoms!!!
                ##
                l_coordinates_perturbed = []
                for res in range(len(l_coordinates)):
                    if res not in l_rem:
                        l_coordinates_perturbed += [l_coordinates[res]]

                matrix_hessian_perturbed = self.hessian_calculation(
                    N - len(l_rem),
                    d_coordinates,
                    chains,
                    atoms_hessian,
                    float(cutoff_distance),
                    d_secondary,
                    matrix_distances,
                    l_coordinates_perturbed,
                    verbose=verbose,
                )

                (
                    eigenvectors_perturbed,
                    eigenvalues_perturbed,
                    eigenvectors_perturbed_combined,
                ) = goodvibes_core.eigenv_calccomb(matrix_hessian_perturbed,
                                                   jobid, verbose)

                (
                    overlaps_single,
                    max_overlaps_single,
                    perturbed_modes_of_max_overlap_single,
                    delta_perturbed_eigenvalues_of_max_overlap,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed, eigenvectors_nonperturbed,
                    eigenvalues_perturbed, eigenvalues_nonperturbed, l_rem)

                (
                    overlaps_combined,
                    max_overlaps_combined,
                    perturbed_modes_of_max_overlap_combined,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed_combined,
                    eigenvectors_nonperturbed,
                    eigenvalues_perturbed,
                    eigenvalues_nonperturbed,
                    l_rem,
                )[:-1]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                }
                for key in datadic:
                    for mode in range(6, 12):
                        datadic[key]['data'][mode][remres1][
                            remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][
                            remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][
                    remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][
                    remres1] = overlaps_combined[-1]

                print overlaps_single[6]

            ##
            ## write data to txt files in case of crash during loop over residues/clusters
            ##
            filename = '%s/%s_residue%s.txt' % (paralleldir, jobid,
                                                remres1 + 1)
            goodvibes_core.multiple_cpus_write(datadic, filename, remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
            goodvibes_core.post_perturbation_plot(
                datadic,
                jobid,
                chains,
                cutoff_distance,
                d_hessian,
                N,
                d_secondary,
                d_coordinates,
                winsize=winsize,
            )

        d_overlaps = {}
        for sphere in range2:
            d_overlaps[sphere] = []
        for res in range(N):
            fd = open('2lzm_residue%s.txt' % (res + 1))
            lines = fd.readlines()
            fd.close()
            parse = False
            for i in range(len(lines)):
                line = lines[i]
                if 'data overlaps_' in line:
                    for sphere in range2:
                        overlap = float(lines[i + 2 + sphere])
                        d_overlaps[sphere] += [overlap]
                    break

        for sphere_radius in range2:
            l_overlaps = d_overlaps[sphere_radius]
            goodvibes_core.write_overlaps_to_pdb_file(
                d_coordinates,
                d_hessian,
                l_overlaps,
                6,
                jobid + 'sphere%s' % (sphere_radius),
                winsize=winsize,
            )

        return
    def main(
        self,
        jobid,
        lines,
        atoms_hessian=["CA"],
        frames=50,
        cutoff_distance=10.0,
        path_html=None,
        path_python=None,
        verbose=False,
        paralleldir="",
        chains=None,
        winsize=1,
        pre_perturbation_plot=True,
        polyhedron=None,
    ):

        import goodvibes_core

        ##
        ## parse pdb
        ##
        (
            d_REMARK350,
            d_primary,  ## i.e. SEQRES, MODRES
            d_secondary,  ## i.e. HELIX, SHEET
            d_coordinates,  ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
        ) = goodvibes_core.parse_pdb(lines, chains)

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(
            d_coordinates, chains, atoms_hessian
        )

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(
            N, matrix_distances, d_coordinates, float(cutoff_distance), l_coordinates, verbose=verbose
        )

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_combined_nonperturbed = goodvibes_core.eigenv_calccomb(
            matrix_hessian, jobid, verbose
        )

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(eigenvectors_nonperturbed, frames, chains, d_coordinates, jobid, d_primary)

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,
                cutoff_distance,
                chains,
                d_secondary,
                eigenvectors_nonperturbed,
                eigenvectors_combined_nonperturbed,
            )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        datadic = goodvibes_core.datadic_return(N)

        d_vertices = {"tetrahedron": 4, "hexahedron": 8, "octahedron": 6, "icosahedron": 12}

        ##
        ## loop over remres1
        ##
        for remres1 in range((winsize - 1) / 2, N - winsize - (winsize - 1) / 2):

            resrange1 = range(remres1 - (winsize - 1) / 2, remres1 + (winsize - 1) / 2 + 1)
            l_c1 = []
            for res1 in resrange1:
                c1 = l_coordinates[res1]
                l_c1 += goodvibes_core.platonicsolid(c1, polyhedron=polyhedron)

            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            filename = "%s/%s_residue%s.txt" % (paralleldir, jobid, remres1 + 1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(datadic, filename, remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range(remres1 + 2 * (winsize - 1) / 2 + 1, N - (winsize - 1) / 2):

                print remres1, remres2

                resrange2 = range(remres2 - (winsize - 1) / 2, remres2 + (winsize - 1) / 2 + 1)
                l_c2 = []
                for res2 in resrange2:
                    c2 = l_coordinates[res2]
                    l_c2 += goodvibes_core.platonicsolid(c2, polyhedron=polyhedron)

                l_add = []
                n_vertices = d_vertices[polyhedron]
                for i in range(n_vertices * (2 * winsize)):
                    l_add += [N + i]

                l_coordinates_perturbed = l_coordinates + l_c1 + l_c2

                matrix_hessian_perturbed = self.hessian_calculation(
                    N, matrix_distances, d_coordinates, float(cutoff_distance), l_coordinates_perturbed, verbose=verbose
                )

                (
                    eigenvectors_perturbed,
                    eigenvalues_perturbed,
                    eigenvectors_perturbed_combined,
                ) = goodvibes_core.eigenv_calccomb(matrix_hessian_perturbed, jobid, verbose)

                (
                    overlaps_single,
                    max_overlaps_single,
                    perturbed_modes_of_max_overlap_single,
                    delta_perturbed_eigenvalues_of_max_overlap,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed,
                    eigenvectors_nonperturbed,
                    eigenvalues_perturbed,
                    eigenvalues_nonperturbed,
                    l_add=l_add,
                )

                (
                    overlaps_combined,
                    max_overlaps_combined,
                    perturbed_modes_of_max_overlap_combined,
                ) = goodvibes_core.overlap_calculation(
                    eigenvectors_perturbed_combined,
                    eigenvectors_nonperturbed,
                    eigenvalues_perturbed,
                    eigenvalues_nonperturbed,
                    l_add=l_add,
                )[
                    :-1
                ]
                print overlaps_single[6]

                ##        ## do vmd of perturbed structure
                ##        self.morph(eigenvectors, frames, biomolecule, d_coordinates, atoms_hessian, cluster, matrix_hessian, jobid+'-'+str(xvalue)+'-'+str(yvalue), cutoff_distance)

                datadic_loop = {
                    "eigenvalues_perturbed": eigenvalues_perturbed,
                    "emo": delta_perturbed_eigenvalues_of_max_overlap,
                    "overlaps_single": overlaps_single,
                    "overlaps_max": max_overlaps_single,
                    "mmo": perturbed_modes_of_max_overlap_single,
                    "overlaps_combined": overlaps_combined,
                }
                for key in datadic:
                    for mode in range(6, 12):
                        datadic[key]["data"][mode][remres1][remres2] = datadic_loop[key][mode]
                        datadic[key]["data"][mode][remres2][remres1] = datadic_loop[key][mode]
                datadic["overlaps_combined"]["data"][-1][remres1][remres2] = overlaps_combined[-1]
                datadic["overlaps_combined"]["data"][-1][remres2][remres1] = overlaps_combined[-1]

            ## write data to txt files in case of crash during loop over residues/clusters
            filename = "%s/%s_residue%s.txt" % (paralleldir, jobid, remres1 + 1)
            goodvibes_core.multiple_cpus_write(datadic, filename, remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print "generating plots"
        goodvibes_core.post_perturbation_plot(
            datadic, jobid, chains, cutoff_distance, d_hessian, N, d_secondary, d_coordinates, winsize=winsize
        )

        return
    def main(
        self, jobid, lines, atoms_hessian = ['CA'], frames = 50,
        cutoff_distance = 10.,
        path_python = None, verbose = False, paralleldir = '',
        biomolecule = None, chains = [], model = None,
        winsize = 1,
        pre_perturbation_plot = True,
        ):

        '''
        Use first model if no model specified by user.
        chain(s): Y, biomolecule: Y; parse chains specified by user and apply transformation
        chain(s): Y, biomolecule: N; parse chains specified by user but don't apply transformation
        chain(s): N, biomolecule: Y; parse chains of biomolecule and apply transformation
        chain(s): N, biomolecule: N; parse chains of first biomolecule and apply transformation
        '''

        import os, Numeric, goodvibes_core

        results = []

        ## parse pdb
        (
            d_REMARK350,
            d_primary, ## i.e. SEQRES, MODRES
            d_secondary, ## i.e. HELIX, SHEET
            d_coordinates, ## i.e. ATOM, HETATM, TER, MODEL, ENDMDL
            d_ligands,
            ) = goodvibes_core.parse_pdb(lines, chains)

        ## assume multimeric biological unit if chains not specified by user
        if chains == []:
            chains = d_coordinates['chains'].keys()
            chains.sort()

        ##
        ## calculate N and convert coordinates from dic to list
        ##
        N, d_hessian, l_coordinates = goodvibes_core.parse_dictionary_of_coordinates(d_coordinates, chains, atoms_hessian)

        ##
        ## calculate distance matrix
        ##
        matrix_distances = goodvibes_core.calculate_distance_matrix(l_coordinates)

        ##
        ## calculate hessian matrix
        ##
        matrix_hessian = self.hessian_calculation(N, d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates, verbose = verbose)

        ##
        ## diagonalize hessian matrix
        ##
        eigenvectors_nonperturbed, eigenvalues_nonperturbed, eigenvectors_comb_nonperturbed, = goodvibes_core.eigenv_calccomb(
                matrix_hessian, jobid, verbose,
                )

        ##
        ## visualize eigenvectors
        ##
        goodvibes_core.morph(
            eigenvectors_nonperturbed, frames, chains, d_coordinates,
            jobid, d_primary,
            )

        ##
        ## do plots prior to perturbation
        ##
        if pre_perturbation_plot == True:
            goodvibes_core.pre_perturbation_plot(
                jobid,cutoff_distance,chains,d_secondary,
                eigenvectors_nonperturbed,eigenvectors_comb_nonperturbed,
                )

        ##
        ## set data lists and append matrices to be plotted for each combination of modes 6-12 before initiating loops over the two axes of the plot
        ##
        range2 = [0,4,8,16,]
        datadic = goodvibes_core.datadic_return(N,range2=range2,)

        ##
        ## loop over remres1
        ##
        for remres1 in range(N):

            ##
            ## continue the remres1 loop if another processor is running calculations for that value of remres1
            ##
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            datadic, Continue = goodvibes_core.multiple_cpus_read(datadic,filename,remres1)
            if Continue == True:
                continue

            ##
            ## loop over remres2
            ##
            for remres2 in range2:

                sphere_radius = remres2
                
                sq_sphere_radius = sphere_radius**2

                print remres1, sphere_radius

                l_rem = []
                for res in range(len(matrix_distances[remres1])):
                    if matrix_distances[remres1][res] < sq_sphere_radius:
                        l_rem += [res]
                l_rem.sort()

                ##
                ## remove selected alpha carbon atoms!!!
                ##
                l_coordinates_perturbed = []
                for res in range(len(l_coordinates)):
                    if res not in l_rem:
                        l_coordinates_perturbed += [l_coordinates[res]]
            
                matrix_hessian_perturbed = self.hessian_calculation(
                    N-len(l_rem), d_coordinates, chains, atoms_hessian, float(cutoff_distance), d_secondary, matrix_distances, l_coordinates_perturbed, verbose = verbose,
                    )

                (
                    eigenvectors_perturbed, eigenvalues_perturbed, eigenvectors_perturbed_combined,
                    ) = goodvibes_core.eigenv_calccomb(
                        matrix_hessian_perturbed, jobid, verbose
                        )

                (
                    overlaps_single, max_overlaps_single, perturbed_modes_of_max_overlap_single, delta_perturbed_eigenvalues_of_max_overlap,
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed, l_rem
                        )

                (
                    overlaps_combined, max_overlaps_combined, perturbed_modes_of_max_overlap_combined,
                    ) = goodvibes_core.overlap_calculation(
                        eigenvectors_perturbed_combined, eigenvectors_nonperturbed, eigenvalues_perturbed, eigenvalues_nonperturbed, l_rem,
                        )[:-1]

                datadic_loop = {
                    'eigenvalues_perturbed': eigenvalues_perturbed,
                    'emo': delta_perturbed_eigenvalues_of_max_overlap,
                    'overlaps_single': overlaps_single,
                    'overlaps_max': max_overlaps_single,
                    'mmo': perturbed_modes_of_max_overlap_single,
                    'overlaps_combined': overlaps_combined
                    }
                for key in datadic:
                    for mode in range(6,12):
                        datadic[key]['data'][mode][remres1][remres2] = datadic_loop[key][mode]
                        datadic[key]['data'][mode][remres2][remres1] = datadic_loop[key][mode]
                datadic['overlaps_combined']['data'][-1][remres1][remres2] = overlaps_combined[-1]
                datadic['overlaps_combined']['data'][-1][remres2][remres1] = overlaps_combined[-1]

                print overlaps_single[6]

            ##
            ## write data to txt files in case of crash during loop over residues/clusters
            ##
            filename = '%s/%s_residue%s.txt' %(paralleldir, jobid, remres1+1)
            goodvibes_core.multiple_cpus_write(datadic,filename,remres1)

        ##
        ## do plots for perturbation results
        ##
        if verbose == True:
            print 'generating plots'
            goodvibes_core.post_perturbation_plot(
                datadic, jobid, chains, cutoff_distance, d_hessian, N, d_secondary, d_coordinates,
                winsize = winsize,
                )


        d_overlaps = {}
        for sphere in range2:
            d_overlaps[sphere] = []
        for res in range(N):
            fd = open('2lzm_residue%s.txt' %(res+1))
            lines = fd.readlines()
            fd.close()
            parse = False
            for i in range(len(lines)):
                line = lines[i]
                if 'data overlaps_' in line:
                    for sphere in range2:
                        overlap = float(lines[i+2+sphere])
                        d_overlaps[sphere] += [overlap]
                    break
                        
        for sphere_radius in range2:
            l_overlaps = d_overlaps[sphere_radius]
            goodvibes_core.write_overlaps_to_pdb_file(
                d_coordinates, d_hessian, l_overlaps, 6, jobid+'sphere%s' %(sphere_radius), winsize = winsize,
                )


        return