示例#1
0
    def get_info(self):

        symbol = []
        x_geo = []
        y_geo = []
        z_geo = []
        color = []
        size = []
        atoms_colors = blobs.get_colors()

        for i in range(self.geometry.natom()):
            symbol.append(self.geometry.fsymbol(i))
            x_geo.append(int((self.geometry.fx(i) - self.origin[0]) / self.spacing[0]))
            y_geo.append(int((self.geometry.fy(i) - self.origin[1]) / self.spacing[1]))
            z_geo.append(int((self.geometry.fz(i) - self.origin[2]) / self.spacing[2]))

            for atom in atoms_colors:
                if self.geometry.fsymbol(i) == atom:
                    color.append(atoms_colors[atom][0])
                    size.append(atoms_colors[atom][1] + 15)

        mol_dic = {
            "sym": symbol,
            "x": np.array(x_geo),
            "y": np.array(y_geo),
            "z": np.array(z_geo),
            "color": color,
            "size": np.array(size)
        }

        return mol_dic
示例#2
0
    def get_info(self):

        color = []
        size = []
        atoms_colors = blobs.get_colors()

        for i in range(len(self.geo)):
            for atom in atoms_colors:
                if self.sym[i] == atom:
                    color.append(atoms_colors[atom][0])
                    size.append(atoms_colors[atom][1] + 15)

        mol_dic = {"color": color, "size": np.array(size)}

        return mol_dic
示例#3
0
    def plot(self,
             size=1,
             nframes = 8,
             vib = 0, 
            ):

        atoms_colors = blobs.get_colors()
        bonds = build_bond_list(self.geo)   
        self.bonds = bonds    
        fms = []
        norm_coord = self.wfn.frequency_analysis['x'][2][:,self.indices].T.reshape(len(self.indices),len(self.geo),3)
        self.norm = norm_coord
                       
        for frame in range(nframes - 1):
                      
            data = [] 
            data.append(go.Scatter3d(x=self.geo[:,0] + self.norm[vib][:,0]/(nframes - frame), 
                                     y=self.geo[:,1] + self.norm[vib][:,1]/(nframes - frame), 
                                     z=self.geo[:,2] + self.norm[vib][:,2]/(nframes - frame)))
            fms.append(go.Frame(data=data))         

            for i in range(1, len(bonds)):
                
                bond_color_1= atoms_colors[self.sym[bonds[i][0]]][0]
                bond_color_2= atoms_colors[self.sym[bonds[i][1]]][0]

                midx  = (self.geo[bonds[i][0]][0] + self.norm[vib][bonds[i][0],0]/(nframes - frame) + self.geo[bonds[i][1]][0] + self.norm[vib][bonds[i][1],0]/(nframes - frame)) / 2
                midy  = (self.geo[bonds[i][0]][1] + self.norm[vib][bonds[i][0],1]/(nframes - frame) + self.geo[bonds[i][1]][1] + self.norm[vib][bonds[i][1],1]/(nframes - frame)) / 2
                midz  = (self.geo[bonds[i][0]][2] + self.norm[vib][bonds[i][0],2]/(nframes - frame) + self.geo[bonds[i][1]][2] + self.norm[vib][bonds[i][1],2]/(nframes - frame)) / 2

                bond_x_1 = [self.geo[:,0][bonds[i][0]] + self.norm[vib][bonds[i][0],0]/(nframes - frame), midx]
                bond_y_1 = [self.geo[:,1][bonds[i][0]] + self.norm[vib][bonds[i][0],1]/(nframes - frame), midy]
                bond_z_1 = [self.geo[:,2][bonds[i][0]] + self.norm[vib][bonds[i][0],2]/(nframes - frame), midz]

                bond_x_2 = [self.geo[:,0][bonds[i][1]] + self.norm[vib][bonds[i][1],0]/(nframes - frame), midx]
                bond_y_2 = [self.geo[:,1][bonds[i][1]] + self.norm[vib][bonds[i][1],1]/(nframes - frame), midy]
                bond_z_2 = [self.geo[:,2][bonds[i][1]] + self.norm[vib][bonds[i][1],2]/(nframes - frame), midz]

                data.append(go.Scatter3d(
                            x=bond_x_1,
                            y=bond_y_1,
                            z=bond_z_1,
                            mode="lines",
                            line={
                                "color": bond_color_1,
                                "width": 7 * size
                            },
                        ))

                data.append(go.Scatter3d(
                            x=bond_x_2,
                            y=bond_y_2,
                            z=bond_z_2,
                            mode="lines",
                            line={
                                "color": bond_color_2,
                                "width": 7 * size
                            },
                        ))

        fms.reverse()
        fms_inv = fms.copy()
        fms.reverse()

        data = [go.Scatter3d(x=self.geo[:,0] + norm_coord[vib][:,0]/nframes, 
                            y=self.geo[:,1] + norm_coord[vib][:,1]/nframes, 
                            z=self.geo[:,2] + norm_coord[vib][:,2]/nframes,
                       mode='markers',
                       marker={"showscale": False,
                               "color": self.info["color"],
                                "size": self.info["size"] * size / 1.0,
                                "showscale": False,
                                "opacity": 1.0,
                                "line": {
                                        "width": 2,
                                        "color": "black"
                                        }
                                    })]

        for i in range(len(bonds)):

            midx  = (self.geo[bonds[i][0]][0] + self.norm[vib][bonds[i][0],0]/(nframes) + self.geo[bonds[i][1]][0] + self.norm[vib][bonds[i][1],0]/(frame)) / 2
            midy  = (self.geo[bonds[i][0]][1] + self.norm[vib][bonds[i][0],1]/(nframes) + self.geo[bonds[i][1]][1] + self.norm[vib][bonds[i][1],1]/(frame)) / 2
            midz  = (self.geo[bonds[i][0]][2] + self.norm[vib][bonds[i][0],2]/(nframes) + self.geo[bonds[i][1]][2] + self.norm[vib][bonds[i][1],2]/(frame)) / 2

            bond_color_1= atoms_colors[self.sym[bonds[i][0]]][0]
            bond_color_2= atoms_colors[self.sym[bonds[i][1]]][0]

            bond_x_1 = [self.geo[:,0][bonds[i][0]] + self.norm[vib][bonds[i][0],0]/(frame), midx]
            bond_y_1 = [self.geo[:,1][bonds[i][0]] + self.norm[vib][bonds[i][0],1]/(frame), midy]
            bond_z_1 = [self.geo[:,2][bonds[i][0]] + self.norm[vib][bonds[i][0],2]/(frame), midz]

            bond_x_2 = [self.geo[:,0][bonds[i][1]] + self.norm[vib][bonds[i][1],0]/(frame), midx]
            bond_y_2 = [self.geo[:,1][bonds[i][1]] + self.norm[vib][bonds[i][1],1]/(frame), midy]
            bond_z_2 = [self.geo[:,2][bonds[i][1]] + self.norm[vib][bonds[i][1],2]/(frame), midz]

            # midx  = (self.geo[bonds[i][0]][0] + self.geo[bonds[i][1]][0]) / 2
            # midy  = (self.geo[bonds[i][0]][1] + self.geo[bonds[i][1]][1]) / 2
            # midz  = (self.geo[bonds[i][0]][2] + self.geo[bonds[i][1]][2]) / 2

            # bond_color_1= atoms_colors[self.sym[bonds[i][0]]][0]
            # bond_color_2= atoms_colors[self.sym[bonds[i][1]]][0]

            # bond_x_1 = [self.geo[bonds[i][0]][0], midx]
            # bond_y_1 = [self.geo[bonds[i][0]][1], midy]
            # bond_z_1 = [self.geo[bonds[i][0]][2], midz]
            # bond_x_2 = [self.geo[bonds[i][1]][0], midx]
            # bond_y_2 = [self.geo[bonds[i][1]][1], midy]
            # bond_z_2 = [self.geo[bonds[i][1]][2], midz]

            data.append(go.Scatter3d(
                        x=bond_x_1,
                        y=bond_y_1,
                        z=bond_z_1,
                        mode="lines",
                        line={
                            "color": bond_color_1,
                            "width": 7
                        },
                    ))

            data.append(go.Scatter3d(
                        x=bond_x_2,
                        y=bond_y_2,
                        z=bond_z_2,
                        mode="lines",
                        line={
                            "color": bond_color_2,
                            "width": 7
                        },
                    ))
          
        fig = go.Figure(data=data, 
            
        layout=go.Layout(
            scene = {'xaxis': {'range': [self.geo[:,0].min() -2, self.geo[:,0].max() + 2], 'autorange': False},
                     'yaxis': {'range': [self.geo[:,1].min() -2, self.geo[:,1].max() + 2], 'autorange': False},
                     'zaxis': {'range': [self.geo[:,2].min() -2, self.geo[:,2].max() + 2], 'autorange': False}},
            title=F"Frequency: {self.frequencies[vib].real:.2f} 1/cm",
            updatemenus=[dict(
                type="buttons",
                buttons=[dict(label="Play",
                              method="animate",
                              args=[None,{"frame": {"duration": 0, "redraw": True}}]),

                        {"args": [[None], {"frame": {"duration": 0, "redraw": False},
                                           "mode": "immediate",
                                           "transition": {"duration": 0}}],
                        "label": "Stop",
                        "method": "animate"}
                        ])]),
                       
        frames = fms + fms_inv + fms + fms_inv + fms + fms_inv + fms + fms_inv + fms + fms_inv
        )

        #layout = go.layout.Template(layout=go.Layout(title_font=dict(family="Rockwell", size=24)))

        fig.update_layout(scene_xaxis_showticklabels=False,
                          scene_yaxis_showticklabels=False,
                          scene_zaxis_showticklabels=False,
                          dragmode="orbit",
                          width=size * 500,
                          height=size * 500,
                          template="plotly_white",
                          autosize=True,
                          showlegend=False,
                          hovermode=False,
                          xaxis=dict(autorange=True, showgrid=False, ticks='', showticklabels=False),
                          yaxis=dict(autorange=True, showgrid=False, ticks='', showticklabels=False),
                          scene={
                              "xaxis": {
                                  "range": (self.geo[:,0].min() -2, self.geo[:,0].max() + 2),
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showticklabels": False, 
                                  "showspikes" : False
                              },
                              "yaxis": {
                                  "range": (self.geo[:,1].min() -2, self.geo[:,1].max() + 2),
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showticklabels": False, 
                                  "showspikes": False
                                  
                              },
                              "zaxis": {
                                  "range": (self.geo[:,2].min() -2, self.geo[:,2].max() + 2),
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showticklabels": False, 
                                  "showspikes": False
                              }
                          })

        fig.show(config={'scrollZoom': False})
示例#4
0
    def plot(self,
             cube_file,
             iso=0.03,
             cube_type="density",
             colorscale="Blues",
             size=1,
             plot_geometry=True,
             plot_bonds=True):

        atoms_colors = blobs.get_colors()
        cube, meta = cube_to_array(cube_file)
        self.meta = meta

        X, Y, Z = np.mgrid[:cube.shape[0], :cube.shape[1], :cube.shape[2]]

        data = []

        vol_data = go.Isosurface(x=X.flatten(),
                                 y=Y.flatten(),
                                 z=Z.flatten(),
                                 value=cube.flatten(),
                                 showscale=False,
                                 surface_count=2,
                                 isomax=iso,
                                 isomin=iso,
                                 opacity=0.2,
                                 colorscale=colorscale)

        data.append(vol_data)

        if cube_type == "orbital":
            vol_data_neg = go.Isosurface(x=X.flatten(),
                                         y=Y.flatten(),
                                         z=Z.flatten(),
                                         value=cube.flatten(),
                                         showscale=False,
                                         isomin=-1 * iso,
                                         isomax=-1 * iso,
                                         opacity=0.2,
                                         colorscale="Reds")

            data.append(vol_data_neg)

        if plot_geometry == True:
            geo_data = go.Scatter3d(x=self.info["x"],
                                    y=self.info["y"],
                                    z=self.info["z"],
                                    mode="markers",
                                    marker={
                                        "showscale": False,
                                        "color": self.info["color"],
                                        "size": self.info["size"] * size / 1.0,
                                        "showscale": False,
                                        "opacity": 1.0,
                                        "line": {
                                            "width": 10,
                                            "color": "black"
                                        }
                                    })

            data.append(geo_data)

        fig = go.Figure(data=data)

        if plot_bonds == True:
            
            bonds = build_bond_list(self.geometry.geometry().np)

            for i in range(len(bonds)):
                
                midx  = (self.info["x"][bonds[i][0]] + self.info["x"][bonds[i][1]]) / 2
                midy  = (self.info["y"][bonds[i][0]] + self.info["y"][bonds[i][1]]) / 2
                midz  = (self.info["z"][bonds[i][0]] + self.info["z"][bonds[i][1]]) / 2
                
                bond_color_1= atoms_colors[self.info["sym"][bonds[i][0]]][0]
                bond_color_2= atoms_colors[self.info["sym"][bonds[i][1]]][0]

                bond_x_1 = [self.info["x"][bonds[i][0]], midx]
                bond_y_1 = [self.info["y"][bonds[i][0]], midy]
                bond_z_1 = [self.info["z"][bonds[i][0]], midz]

                bond_x_2 = [self.info["x"][bonds[i][1]], midx]
                bond_y_2 = [self.info["y"][bonds[i][1]], midy]
                bond_z_2 = [self.info["z"][bonds[i][1]], midz]
                
                fig.add_trace(
                    go.Scatter3d(
                        x=bond_x_1,
                        y=bond_y_1,
                        z=bond_z_1,
                        mode="lines",
                        line={
                            "color": bond_color_1,
                            "width": 7 * size
                        },
                    ))

                fig.add_trace(
                    go.Scatter3d(
                        x=bond_x_2,
                        y=bond_y_2,
                        z=bond_z_2,
                        mode="lines",
                        line={
                            "color": bond_color_2,
                            "width": 7 * size
                        },
                    ))
        

        layout = go.layout.Template(layout=go.Layout(title_font=dict(family="Rockwell", size=24)))

        fig.update_layout(scene_xaxis_showticklabels=False,
                          scene_yaxis_showticklabels=False,
                          scene_zaxis_showticklabels=False,
                          dragmode="orbit",
                          width=size * 500,
                          height=size * 500,
                          template="plotly_white",
                          autosize=True,
                          showlegend=False,
                          hovermode=False,
                          xaxis=dict(autorange=True, showgrid=False, ticks='', showticklabels=False),
                          yaxis=dict(autorange=True, showgrid=False, ticks='', showticklabels=False),
                          scene={
                              "xaxis": {
                                  "autorange": True,
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showticklabels": False,
                                  "showbackground": False,  
                                  "showspikes" : False
                              },
                              "yaxis": {
                                  "autorange": True,
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showticklabels": False,
                                  "showbackground": False,  
                                  "showspikes": False
                                  
                              },
                              "zaxis": {
                                  "autorange": True,
                                  "showgrid": False,
                                  "zeroline": False,
                                  "showline": False,
                                  "title": "",
                                  "ticks": '',
                                  "showbackground": False,
                                  "showticklabels": False, 
                                  "showspikes": False
                              }
                          })

        fig.show(config={'scrollZoom': False})