Natural Bond Orbitals (NBO) in Organic Chemistry

Natural Dipole Analysis with IPython Notebook

noreply@blogger.com (Chemgplus) — Sun, 30 Aug 2015 17:09:00 +0000

Understanding electrostatic interactions in molecules and molecular complexes provides the basis for interpretation of chemical reactions and molecular interactions. First of the series of "Analyzing NBO output with IPython notebook" is the example of decomposing NLMO dipole vectors into a vector path that can be displayed as images and further analyzed for intramolecular dipole components.

The first example is built around the molecule of formamide and can be followed in the book of Weinhold and Landis: Weinhold, F. and Landis, C.R. in Discovering Chemistry with Natural Bond Orbitals, pp. 147-152.

After extracting the dipole components from .nbo file output, variants of dipole decomposition are created and their plots saved as .png images. Below is one such example indication NLMO orbital numbers and the corresponding dipole vectors withing the planar molecule of formamide.

Since the analysis and accompanying description are done in IPython Notebook (now Jupyter notebook), it is more convenient to render such notebooks in specialized Python-driven web-builders, such as Pelican static site generator.

Full version of this blog is available as Natural Dipole Analysis blog hosted at GitHub Pages.

You can download the notebook and accompanying files from the latter link (click the "Download .zip" button at the right bottom).

Web Visualization of NBOs Using jvxl File Format

noreply@blogger.com (Chemgplus) — Sat, 01 Aug 2015 21:05:00 +0000

In the previous post, we discussed embedding the NBO imagery into a Web page using the Jmol-generated x3d file format. To further expand on the Jmol web visualization possibilities, we will take a look at yet another implementation of the orbital imagery; one that uses jvxl format to encode the molecular surfaces [1].
While the web implementation of x3d files does not require the Jmol app or JavaScript support, successful implementation of jvxl files does require both. Until recently, running the Jmol in web browsers required both the Java and Jmol be installed on the computer. Security concerns around the implementation of Java (and Java applets) in browsers have recently resulted in disabling the Java support in Chrome. This is where JSmol, a new incarnation of Jmol, comes in. JSmol overcomes the security concerns of the Jmol Java applet by rendering the molecular models in a web page using only JavaScript and HTML5. JSmol implements the entire set of Jmol functionalities [2, 3]. Indeed, the JSmol web interface includes the whole context menu of Jmol. It can be easily invoked by right-mouse clicking within the main image frame (Figure 7 at the bottom).

In this blog article, we will go through the steps of getting the key elements for building an interactive website with NBO-specific layout. The visualization is based on jvxl surface files and JSmol support. With the help of css, JavaScript and its library, JQuery, we will be able to interact with the molecular and surface models generated by the Jmol standalone application. All files used in this post are available from the Download section at the end.

From the java.com official site:

"The Java plug-in for web browsers relies on the cross platform plugin architecture NPAPI, which has long been, and currently is, supported by all major web browsers. Google announced in September 2013 plans to remove NPAPI support from Chrome by "the end of 2014", thus effectively dropping support for Silverlight, Java, Facebook Video and other similar NPAPI based plugins. Recently, Google has revised their plans and now state that they plan to completely remove NPAPI by late 2015."

JVXL File Format:
jvxl stands for "Jmol Voxel" and it is a surface file format unique to Jmol. The purpose of the
JVXL file format is to provide a mechanism for the efficient delivery of molecular surface data
(orbitals, electron density plots, electrostatic potential maps, etc.) from a web server to a client page in a compact manner [1].
More on the jvxl file format and its use from the Wiki and Surfaces in Jmol.

Getting the Web Components:
In this section, we will outline the steps of the overall workflow for building the interactive webpage. Uses of such webpage include blogs and stand-alone pages. A simple implementation of local web server (discussed below) enables a "live" presentation in the classroom and conference settings.
This particular example (as in the x3d post) features analysis of the formamide molecule evaluated at HF/3-21G level [5].

Starting in the Jmol Application:

To generate the NBO imagery, we will use the Jmol-NBO Visualization Helper (JNVH), which was described earlier [4]. Briefly, the JNVH facilitates generation of Jmol .macro files that allow loading and visualization of the NBO archive files (.31-.46). The latter files are created by NBO executable compiled or linked into the variety of Electronic Structure Systems (ESS). Examples of such systems include Gaussian09 (NBO3), GAMESS, FIREFLY, and many other packages. GENNBO suite of NBO6-based programs [6] allows for direct linking to ESS or for a stand-alone processing of the wavefunction (archive file .47).
The sequence of steps in the JNVH is following:

Launch JNVH .jar file.
Load directory of NBO archive files (.37 for NBO set) by clicking the "1. Browse Dir" button.
Enter the range of NBOs to display into "NBOs" field (in this example 4-12)
Check the box "x3d-jvxl script?" and choose to write the output into the default $HOME/.macros directory.
Click "Create".
For interacting NBO pairs, check the box 'NBO Interactions" , enter the list of pairs (e.g. 4:16, 6:13,..), uncheck the "Clear default directory" box, and press "Create".

Layout and specific options in the JNVH panel are shown in Figure 1.

Fig. 1 Jmol Visualization Helper window.

Now, we will be heading to the $HOME/.macros directory (on Windows, C:\Users\username\.jmol\macros) and review the folder content. Next to the "*.macro" files, an accompanying script (*.scr) file was created for the each orbital presentation. For generation of surface images, another script file, "x3d-jvxl-*.spt" was created. This is a standard Jmol script containing instructions to generate the corresponding *.jvxl files.
Snapshot of the .macros directory is shown in Figure 2. Note the different script files created for each orbital type.

Fig. 2 Files generated by the JNVH with option from Fig. 1.

At this point, we launch the Jmol application and open the Console (File -> Console). Drag the x3d-jvxl-form.spt file into the main Jmol window (not the Console) as shown in Figure 3. The script will start processing the sequence of macro files and the corresponding .x3d and .jvxl files will be created.

Fig. 3 Running the script in Jmol.

Building the Webpage:

To build a simple static webpage on our computer, create the corresponding folder structure at any local drive. For example, D:\web\jsmolweb. Layout outlined in this blog is based on a "pluggable" container wrapper allowing to render the html index file as a stand-alone page or to be inserted into other .html file. The folder can be later uploaded to your server for the Internet access. In the local implementation, I am using a simple portable web server, mongoose.

A typical folder structure is shown in Figure 4.

Fig. 4 Website folder structure and exemplary files.

Copy the*.jvxl files created earlier from the .macros folder into the /nbo folder of your new site.

css files:

The folder contains css files that should suffice for building a respectable site container. The site layout is based on the popular 960 Grid System. Feel free to modify them.

Index.html file:

Html markup of the editable section of the index.html file is presented in Figure 5. Image names and orbital description in magenta should be changed according to your naming convention (see, img files: section below). The table has 2 rows and 3 columns and another row of icon images can be easily inserted by copying/pasting the segment that starts at  and ends by the last </tr> tag.

<!-- Table of available models -->      
<table id="icon_table" class="gallery">
  <tr class="row1">
       <td class="1"><a href="javascript:nbo2aj(nbo1)"><img src="./img/4.png" alt="" width="500" height="500" /></a></td>
       <td class="2"><a href="javascript:nbo2aj(nbo2);"><img src="./img/5.png" alt="" width="500" height="500" /></a></td>
       <td class="3"><a href="javascript:nbo2aj(nbo3)"><img src="./img/6.png" alt="" width="500" height="500" /></a></td>         
  </tr>

<tr class="row12"><td class="1">NBO4</td><td class="2">NBO5</td><td class="3">NBO6</td></tr>              
 <tr class="row2"> <!--Another row of models-->
      <td class="4"><a href="javascript:nbo2aj(nbo4)"><img src="./img/10.png" alt="" width="500" height="500" /></td>
      <td class="5"><a href="javascript:nbo2aj(nbo5)"><img src="./img/11.png" alt="" width="500" height="500" /></td>
      <td class="6"><a href="javascript:nbo2aj(nbo6)"><img src="./img/12.png" alt="" width="500" height="500" /></td>
  </tr>
  <tr class="row22"><td class="4">NBO10</td><td class="5">NBO11</td><td class="6">NBO12</td  ></tr>

  <!-- Insert third row here-->                           
</table>

Figure 5. Html markup of the gallery table.

JQuery and JavaScript code:

The script to initiate the JSmol objects and to have them interact with the gallery html elements is presented in Figure 6. The script is embedded within the main index.html file (part of the download package). Lines 13, 15-19 have to be modified with your specific files. Parameters set at lines 22 and 23 can be modified, depending on your preference.
Additional feature and purpose of the Ajax call is to retrieve orbital description, which originates in the GENNBO/NBO modules. Bond assignment and orbital occupancy are extracted from the jvxl file upon clicking the image icon in the gallery.
Let me know if there are other options to include.

1:  <script type="text/javascript">  
2:    Jmol._isAsync = false;  
3:    Jmol.getProfile() // records repeat calls to overridden or overloaded Java methods  
4:    var jmolApplet0; // set up in HTML table, below  
5:    
6:    // use ?_USE=JAVA or _USE=SIGNED or _USE=HTML5  
7:    jmol_isReady = function (applet) {  
8:      document.title = (applet._id + " is ready");  
9:      Jmol._getElement(applet, "appletdiv").style.border = "1px solid blue";  
10:    };  
11:    
12:    // Enter list of images to be displayed            
13:    var panel = "s4-form-NBO.jvxl"; // Type the name of image in the main panel  
14:    var nbo1 = panel // do not modify  
15:    var nbo2 = "s5-form-NBO.jvxl";  
16:    var nbo3 = "s6-form-NBO.jvxl";  
17:    var nbo4 = "s10-form-NBO.jvxl";  
18:    var nbo5 = "s11-form-NBO.jvxl";  
19:    var nbo6 = "s12-form-NBO.jvxl";  
20:    
21:    // Image display <Jmol> parameters (modify)  
22:    var param1 = "background {0,0,150}; color Rasmol;zoom 130;center {-0.4 0 0}; 
                     rotate z -100; rotate y 35; rotate z 90; translate x -3.0; 
                     translate y 7.5";  
23:    var param2 = "translucent 0.3;set antialiasDisplay";  
24:    nbo = nbo1;  
25:    
26:    Info = {  
27:      width: 300,  
28:      height: 300,  
29:      debug: false,  
30:      color: "#F0F0F0",  
31:      zIndexBase: 20000,  
32:      z: {  
33:        monitorZIndex: 100  
34:      },  
35:      use: "HTML5",  
36:      j2sPath: "./jsmol/j2s",  
37:      allowjavascript: true,  
38:      script: 'load ./nbo/' + panel + '; ' + param1 + '; isosurface ./nbo/' + panel 
         + ' ' + param2 + ' ',  
39:       }  
40:    
41:    function nbo2aj(x) {  
42:      nbo = x;  
43:      Jmol.script(jmolApplet0, 'load ./nbo/' + nbo + ';' + param1 + '; 
         isosurface ./nbo/' + nbo + ' ' + param2 + ' ');  
44:    
45:        $.ajax({  
46:          type: "GET",  
47:          url: './nbo/' + nbo,  
48:          dataType: "xml",  
49:          success: function(xml) {  
50:            $(xml).find("jvxlSurface").each(function () {  
51:                var Title = $(this).find('jvxlSurfaceTitle').text();  
52:              // Parse the title and remove Model 1.1 and filename              
53:              var myregexp = /^Model\s[0-9]{1,2}\.[0-9]{1,2}\s+|.+\.37/mg;            
54:              Title = Title.replace(eval(myregexp), "");  
55:              Title = Title.replace(/(^Occupancy.+)/mg, "<p>$1</p>");  
56:              $("#nbo-desc>span").replaceWith("<span>" + Title + "</span>");  
57:              });  
58:             }, // close success  
59:           error: function(xhr, textStatus, errorThrown) {  
60:              alert('An error occured! ' + (errorThrown ? errorThrown : xhr.status));  
61:                                        }  
62:           }); // close ajax  
63:         } // close nbo2aj  
64:  </script>

Figure 6. JQuery and Ajax syntax for the interactive site interface.

img files:

This folder contains images that you want to display at your site. Since there is a gallery table in the page (Figure 7), the corresponding icons for the orbital-images have to be created first. The easiest way is to create those icons while in the Jmol Console.

At the command prompt with 3-D image properly scaled and positioned type:

> write image 400 400 PNG "OrbNum.png"

where OrbNumber is the number of the orbital that will be displayed in the main image frame (e.g., 4.png, 12.png).

Fig. 7 Website view of the Gallery section.

nbo content:

This folder contains all *.jvxl files created earlier.

jsmol folder:

jsmol folder contains the files necessary for rendering and manipulation of images. It is the very same folder that is part of the Jmol application package (Figure 4). Just copy it from there to your web site folder. If you do not care for the examples and structural file, delete the folder "data".

... and the site:

First, download the .zip package from the download section and unpack it into any drive/folder. In our case, D:\web\jsmolweb. Start the local mongoose server and browse to the site directory created in previous steps. Location of the mongoose.exe file is one directory up from this jsmolweb site (D:\web). Address is http://localhost:8080/jsmolweb. A snapshot of the gallery section is shown in Figure 7. As indicated earlier, the orbital labels and images have to be provided by manually entering the values into the <table> markup. By clicking the "Reset the model" link, the molecule and its corresponding surface are rendered with transparency=0 and with atom labels displayed.

Alternatively, upload the unpacked folder to your web hosting server and access it from the Internet.

To illustrate the final appearance and flexibility of our new website, preview it at:

http://nbo.marcelpatek.com/mol/demo/jsmolweb

Update (12/06/2015):

Presented web site template was re-written to use the Bootstrap framework to allow responsive display on phone and tablet devices. File to download: Jsmolweb-responsive.zip. The original version is still available. Demo site now serves the responsive version.

Conclusions:

In this blog post, we explored the generation and implementation of .jvxl files for visualization of Natural Bond Orbitals in web browsers. We used the Jmol-NBO Visualization Helper to create the Jmol .macro files and scripts that assist in writing the corresponding .jvxl files in the Jmol application. Finally, we built a JavaScript-rich web page container for the presentation and discussion of NBO imagery.

Downloads:

Jmol-NBO Visualization Helper, main download site
Jmol
Complete set of example files (the whole web site)
Complete set of example files (responsive web site version)

References:

[1] R. M. Hanson, “The Jmol Voxel (JVXL) File Format,” 2006.

[2] R. M. Hanson, “Jmol/JSmol Interactive Script Documentation,” 2006. [Online].

[3] R. M. Hanson, J. Prilusky, Z. Renjian, T. Nakane, and J. L. Sussman, “JSmol and the Next-Generation Web-Based Representation of 3D Molecular Structure as Applied to Proteopedia,” Isr. J. Chem., vol. 53, no. 3–4, pp. 207–216, Apr. 2013. DOI: 10.1002/ijch.201300024

[4] M. Patek, “Jmol-NBO Visualization Helper,” Aug-2014. [Online].

[5] F. Weinhold, C.R. Landis, Discovering Chemistry With Natural Bond Orbitals. Wiley, 2012. http://books.google.com/books?id=y68Cs32WNI0C

[6] Natural Bond Orbital 6.0 Homepage.

Web Visualization of NBOs in x3d Format

noreply@blogger.com (Chemgplus) — Sun, 26 Jul 2015 21:02:00 +0000

In an earlier post, we discussed embedding the NBO imagery into a Web page using the Java-JmolApplet as well as the recent Jsmol JavaScript implementation. To further expand on the Jmol visualization possibilities, we will take a look at one implementation of the orbital imagery that uses open-source x3d format [2].

In this blog article, we will go through the steps of getting the key elements for building an interactive website with NBO-specific layout. All files used in this post are available from the Download section at the end.

x3d Format:
X3D stands for "Extensible 3D" and it is the new open standard for 3D content on the internet/web. In essence, X3D is intended to be the new format or language that is used/required for 3D interactive worlds on the web (replacing/extending the existing VRML97 standard).
More on x3d standard from the Wiki and web3d.org.

X3D is a royalty-free ISO standard XML-based file format for representing 3D computer graphics. X3D has a rich set of componentized features that can tailored for use in engineering and scientific visualization. X3D strives to become the 3D standard for the Web, as integrated in the HTML5 pages as other XML dialects (MathML, SVG) already are there. X3DOM is a proposed syntax model and its implementation as a script library that demonstrates how this integration can be achieved without a browser plugin, using only WebGL and JavaScript.

Getting the Web Components:
In this section, we will outline the steps of the overall workflow for building the interactive webpage. Uses of such webpage include blogs and stand-alone pages. A simple implementation of a local web server (discussed below) enables a "live" presentation in the classroom and conference settings.
This particular example will feature analysis of the formamide molecule evaluated at HF/3-21G level [1].

Starting in the Jmol Application:

To generate the NBO imagery, we will use Jmol-NBO Visualization Helper (JNVH), which was described earlier [3]. Briefly, the JNVH facilitates generation of Jmol .macro files that allow loading and visualization of the NBO archive files (.31-.46). The latter files are created by NBO executable compiled or linked into the variety of Electronic Structure Systems (ESS). Examples of such systems include Gaussian09 (NBO3), GAMESS, FIREFLY, and many other packages. GENNBO suite of NBO6-based programs [4] allows for direct linking to ESS or for a stand-alone processing of the wavefunction (archive file .47).
The sequence of steps in JNVH is following:

Launch JNVH .jar file.
Load directory of NBO archive files (.37 for NBO set) by clicking the "1. Browse Dir" button.
Enter the range of NBOs to display into "NBOs" field (in this example 4-12)
Check the box "x3d-jvxl script?" and choose to write the output into the default $HOME/.macros directory.
Click "Create".
For interacting NBO pairs, check the box 'NBO Interactions" , enter the list of pairs (e.g. 4:16, 6:13,..), uncheck the "Clear default directory" box, and press "Create".

Layout and specific options in the JNVH panel are shown in Figure 1.

Fig. 1 Jmol Visualization Helper window.

Now, we will be heading to the $HOME/.macros directory (on Windows, C:\Users\username\.jmol\macros) and review the folder content. Next to the "*.macro" files, an accompanying script (*.scr) file was created for each orbital presentation. For single surface images, another script file, "x3d-jvxl-*.spt" was created. This file is a standard Jmol script containing instructions to generate the corresponding *.x3d and *.jvxl files (see the code in Figure 4).

Web visualization with *.jvxl files including the Jsmol adaptation will be discussed in the upcoming post.

Snapshot of the .macros directory is shown in Figure 2. Note the different script files created for each orbital type.

Fig. 2 Files generated by the JNVH with option from Fig. 1.

At this point, we launch the Jmol application and open the Console (File -> Console). Drag the x3d-jvxl-form.spt file into the main Jmol window (not the Console) as shown in Figure 3. The script will start processing the sequence of macro files and the corresponding .x3d and .jvxl files will be created.

Fig. 3 Running the script in Jmol.

Details of the .spt script are shown in Figure 4. Replace the magenta-colored strings with your HOME directory. One could use the commands directly in the Jmol Console or modify the script before the run. The script is hardcoded in the JNVH app. Let me know if there are other options to include.

// x3d-jvxl-form.spt

// Strip the basename   
 function baseName(str) {  
   var nameArray = str.split('.');  
   var base = nameArray[nameArray.length - 1];  
   return base;  
 }  
 set defaultDirectory "$HOME\.jmol\macros"  
 fin = ["s10_form-NBO.scr", "s11_form-NBO.scr", "s12_form-NBO.scr",  
   "s4_form-NBO.scr", "s5_form-NBO.scr", "s6_form-NBO.scr",  
   "s7_form-NBO.scr", "s8_form-NBO.scr", "s9_form-NBO.scr"  
 ]  
 cd $HOME\.jmol\ macros  
 for (var i = 1; i <= fin.length; i = i + 1) {  
   var filename = fin[i]  
   script @filename  
   var newfile = baseName(filename) + ".x3d"  
   var jvxlfile = baseName(filename) + ".jvxl"  
   label off  
   color RasMol  
   write @newfile  
   write MO @jvxlfile  
 }

Figure 4. Jmol script to generate .x3d and .jvxl files from Jmol .macro files.

Building the Webpage:

To build a simple static webpage on our computer, create the corresponding folder structure at any local drive. For example, D:\web\x3d. Layout demonstrated in this blog is based on a "pluggable" container wrapper allowing to render the index.html file as a standalone page or to be inserted into another .html file. The folder can be later uploaded to your server for the Internet access. In the local implementation, I am using a simple portable web server, mongoose.

A typical folder structure is shown in Figure 5.

Fig. 5 Website folder structure and files.

Copy the*.x3d files created earlier from the .macros folder into the /nbo folder of your new site. Depending on your preference, there is one additional, although optional step required.

Jmol x3d export routine resets the transparency level of your orbitals to zero. The value is set in the '<Appearance>' tag located just before the '<CoordIndex>' tag in the x3d file. Included Python file "modfiles.py" sets the transparency tag back to 0.3. Run the Python script by double-clicking it in the folder where *x3d files are present. Alternatively, use the System Shell (cmd, bash, ..) and cd into directory containing the modfiles.py and *.x3d files. New set of x3d files is created with _t0.3_ string inserted into the filename.

css files:

The folder contains css files that should suffice for building a respectable site container. The site layout is based on the popular 960 Grid System. Feel free to modify them.

img files:

This folder contains images that you want to display at your site. Since there is a gallery table in the page (Figure 6), the corresponding icons for orbital-images have to be created first. The easiest way is to create those icons while in the Jmol Console.

At the command prompt with 3-D image properly scaled and positioned type:

> write image 400 400 PNG "OrbNum.png"

where OrbNumber is the number of the orbital that will be displayed in the main image frame (e.g., 4.png, 12.png).

Fig. 6 Website view of the Gallery section.

nbo content:

This folder contains the *.x3d files created and modified earlier.

... and the site:

First, download the .zip package from the download section and unpack it into any drive/folder. In our case, D:\web\x3d. Start the local mongoose server and browse to the site directory created in previous steps. Location of the mongoose.exe file is one directory up from this x3d site (D:\web). Address is http://localhost:8080/jsmolweb. A snapshot of the gallery section is shown in Figure 6. The orbital labels and images have to be provided by manually entering the values into the <table> markup.

Alternatively, upload the unpacked folder to your web hosting server and access it from the Internet.
To illustrate the final appearance and flexibility of our new website, preview it at:

http://nbo.marcelpatek.com/mol/demo/x3d

Conclusions:

In this blog post, we explored generation and implementation of .x3d 3-D files for visualization of Natural Bond Orbitals in web browsers. We used the Jmol-NBO Visualization Helper to create the Jmol .macro files and scripts that assist in writing .x3d files off the Jmol application. Finally, we built a simple web page container for presentation and discussion of NBO imagery.

Downloads:

Jmol-NBO Visualization Helper, main download site
Jmol
Complete set of example files (this tutorial)

References:

F. Weinhold, C. R. Landis, Discovering Chemistry With Natural Bond Orbitals. Wiley, 2012.

“Jmol/JSmol Interactive Script Documentation.” [Online] [Accessed: 26-Jul-2015].

M. Patek, “Jmol-NBO Visualization Helper,” Aug-2014.

E. D. Glendening, C. R. Landis, and F. Weinhold, “NBO 6.0: Natural bond orbital analysis program,” Journal of computational chemistry, vol. 34, no. 16, pp. 1429–1437, 2013. DOI: 10.1002/jcc.23266

Analyzing NBO Results with IPython Notebook

noreply@blogger.com (Chemgplus) — Sat, 29 Nov 2014 22:51:00 +0000

Introduction

Data processing, analysis, and visualization are routine tasks in sciences and humanities. The vast majority of data science today is conducted through R, Python, Java, Matlab, and SAS. With a plethora of programming languages suited for the data processing and visualization, Python seems the best general purpose functional programming language for such tasks. Indeed, being an interpreted, object-oriented language, Python became very attractive programming tool for application development as well as for use as scripting language for routine assignments in research and education. Python is open source software and it is freely available for a variety of platforms.

In the previous series of blogs related to Natural Bond Orbitals (NBO) (NBO Analysis, NBO Scripting), we have discussed several useful tools for parsing and analysis of text outputs from the NBO program [1-4]. For example, on the web pages dedicated to NBO Scripts and Handy Applications, we learned about pes_nbo3.py Python script. This standalone script was used to extract data from the potential energy scan (PES) output files generated by Gaussian09. In another example, Python Script nodes were included in KNIME workflow to process NBO Dipole Moment results. In general, NBO output consists of formatted tables and summaries describing results of NBO analysis. These results include Natural Population Analysis, NBO Summary, Natural Dipole Moment Analysis, Natural Steric analysis, energy effects based on second-order perturbation theory and other properties. Extracting text sections of such output files is a typical and repetitive task when examining molecular properties by methods of NBO analysis.

Python, IPython, and IPython Notebook

Until now we have worked with Python directly via the system shell by executing Python scripts. To make the work with Python and data easier for scientists, IPython interactive shell was introduced by Fernando Perez early in 2001. IPython provides tools for interactive and exploratory computing in Python making debugging, code optimization, and interactive plotting quite easy and straightforward. Effective use of IPython typically involves third-party specialized packages, such as NumPy, Pandas, and Matplotlib, which allow for analysis of large data sets. More importantly, IPython has a relatively new feature called the “Notebook”. IPython Notebook is a web-based interactive computing platform that combines live code, equations, narrative text, visualizations, images, interactive dashboards and other media. These documents provide a complete record of a computation that can be shared with others. Also, the IPython Notebook is not only a tool for scientific research and data analysis, but also a great tool for teaching. Technically, Notebook launches a web-based shell to an IPython session that has handy features, like the ability to save, edit, and delete lines of code. The code is organized into cells of Python, text, or Markdown. One can move the cells around, develop code interactively with documentation and notes, display objects that a browser can render (e.g., images, HTML, videos) and to share the whole notebook for a collaborative work.

To demonstrate the utility and benefits of using IPython Notebook, I will share such notebooks in the future blogs to explore molecular properties that are based on NBO analysis.

Installing IPython Notebook

Before we dive into the nuances of IPython Notebook, here are a few pre-requisites:

a) As indicated above, using IPython (and the Notebook) assumes familiarity with the Python language. We need to have a Python installation on our computer.

b) We will also need to install IPython and Notebook and a few required packages.

Continuum Analytics offers the Anaconda Python Distribution, which includes all the common scientific Python packages as well as IPython and Notebook. Anaconda itself is free and it comes with many pre-installed data analytics and processing Python packages and libraries. It comes with an excellent package manager named conda. It lets you install easily many modules on most platforms (Windows, Linux, Mac OS X), in 64-bit or 32-bit versions.
To get Anaconda installed under Windows OS, download Anaconda 1.9.1 and run the executable.

This particular version worked best for me under Window 7 system (Python 2.7.6 with IPython Notebook). Typical path to install into is: C:/Anaconda. Download of the latest installer is here.

When done, add the following string into your PATH:

C:\Anaconda;C:\Anaconda\Scripts

To access the PATH editor, right-click on Computer → Advanced system settings → Advanced tab → Environment Variables → System variables → Path.

To check that Anaconda is installed, launch the command shell (cmd.exe) and execute command:

conda info --all

Typical output follows:

Current conda install:

platform : win-32
conda version : 3.7.1
conda-build version : 1.2.0
python version : 2.7.6.final.0
requests version : 2.4.3
root environment : C:\Anaconda (writable)
default environment : C:\Anaconda
envs directories : C:\Anaconda\envs
package cache : C:\Anaconda\pkgs
channel URLs : http://repo.continuum.io/pkgs/gpl/win-32/
http://repo.continuum.io/pkgs/free/win-32/
config file : C:\Users\USER\.condarc
is foreign system : False

In order to simplify installation of other packages in the future, we will install a popular package manager pip;

In the command shell type:

conda install pip

After that, let’s install another Python visualization library seaborn:

pip install seaborn

A detailed description of Anaconda install and setup is described here.
If IPython has been installed correctly, you should be able to run it from a system shell with the IPython command. Launch the command shell (cmd.exe) again and execute the command:

C:\> ipython

We should see output similar to Figure 1 below.

Figure 1 The IPython console

The official IPython documentation webpage at http://ipython.org/documentation.html is the place to go to get some help. It contains links to the online manual and to unofficial tutorials and articles created by the community. The StackOverflow website at stackoverflow.com is also a great place to request help for IPython.

To check that everything is correctly installed, type ipython notebook in the shell. This will launch a local web server on the 8888 port (by default).
Go to http://127.0.0.1:8888/ in a browser and check if you can see the page shown in Figure 2.

Figure 2 The notebook dashboard

The dashboard will list all notebooks and notebook folders that you created or cloned from repositories.
An informative overview of the Notebook UI is here.

Launching IPython Notebooks on Windows

The easiest way to launch a Notebook is to create IPython Notebook shortcut at your Desktop. On the Windows system, right mouse-click the IPython (Py 2.7) Notebook item in Start → All Programs menu and select Send To → Desktop (create shortcut) (Figure 3).

Figure 3 IPython Notebook shortcut from menu

Icon Properties for IPython Notebook

For general customization of Notebook shortcuts, here are typical settings. Notebook location can be changed (path in orange)
Icon path: %SystemDrive%\Anaconda\Menu\IPython.ico
Target: C:\Anaconda\python.exe "C:\Anaconda\Scripts/ipython-script.py" notebook
Start in: "C:\Users\USER\Documents\IPython Notebooks\"

Running a standalone script:

One can still run a standalone Python scripts from either the IPython console or from the IPython Notebook cell. While the standard shell command requires syntax:

> python script.py input_file.txt

IPython console or Notebook cell require using the %magic function run:

> %run script.py input_file.txt

Markdown

To decorate plain text in the notebook cell, use the markup syntax published at:
http://daringfireball.net/projects/markdown/ (Figure 6).

IPython Notebook Example

We will conclude this blog article with the “real” example of IPython Notebook written on the topic of processing NBO outputs. In this particular example, we will extract DIPOLE MOMENT ANALYSIS summary from the NBO/GENNBO output file shown in Figure 4. For the sake of consistency, our example will use the molecule of formamide discussed in the KNIME blog. In its "DIPOLE MOMENT ANALYSIS:" section, the standard NBO output file contains the individual x,y,z-components and length of the total molecular dipole moment. Each of the entries is decomposed into the individual contributions of NLMO and NBO bond dipoles. We are going to extract those lines into a *.csv file for the later analysis.

Figure 4 Part of the Dipole moment summary output from the form.nbo file

Refer to the ReadNboDip.ipynb notebook for the parsing algorithm and steps at each cell. To run all steps in the notebook, click the “Cell” → “Run All” at the top navigation bar of the notebook page. Extracted NLMO part of the ‘DIPOLE MOMENT ANALYSIS:’ section is shown in Figure 5. The corresponding file form_dip.csv is saved for further analysis.

Figure 5 Formatted output of NLMO dipoles saved as form_dip.csv

The “pure” Python script ReadNboDip.py which is accomplishing the same task can be downloaded from the nbo-processing GitHub repository. For details on how to clone Git repository, see the next paragraph.

Figure 6 Top part of an exemplary Notebook

Complete IPython Notebook ReadNboDip.ipynb with the necessary files is available at Github. Html version of the notebook is available from here (or if the nbviewer website is unresponsive, use this link).

Working with GIT Repository

To download a local copy of examples and auxiliary files from this blog, you need git, a distributed versioning system. I recommend using one of the GUI applications, such as GitHub GUI for Windows or GUI for other platforms.

GitHub GUI for Windows comes with the icon shortcut to its own shell (Figure 7). To download the standalone Python script ReadNboDip.py and accompanying files, open Git Shell and type:

git clone https://github.com/marpat/nbo-processing.git

This will copy the repository of all processing scripts into a local folder named “nbo-processing”. While you can change the default GitHub directory from the GitHub GUI, path to the default location on Windows is:

Libraries/My Documents/GitHub

To clone the notebook described in this blog, either:
a) Clone it as git clone https://github.com/marpat/blog.git
b) or go to its Git repository and download it as blog-master.zip file

Again, to view the same notebook as html file in a browser, go to: http://nbviewer.ipython.org/github/marpat/blog/blob/master/ReadNboDip.ipynb

References

1. NBO 6.0. E. D. Glendening, J. K. Badenhoop, A. E. Reed, J. E. Carpenter, J.Bohmann, C. M. Morales, C. R. Landis, and F. Weinhold, Theoretical Chemistry Institute, University of Wisconsin, Madison (2013).

2. E. D. Glendening, C. R. Landis and F. Weinhold, “Natural Bond Orbital
Methods,” WIREs Comp. Mol. Sci. 2, 1-42 (2012)

3. F. Weinhold, “Natural bond orbital analysis: A critical overview of
relationships to alternative bonding perspectives,” J. Comput. Chem. (2012).

4. Further background and bibliographic materials can be found on the NBO website: http://nbo6.chem.wisc.edu/biblio_css.htm

5. Learning IPython for Interactive Computing and Data Visualization, by Cyrille Rossant, PACKT Publishing, e-Book, 2013

6. IPython Interactive Computing and Visualization Cookbook, by Cyrille Rossant, PACKT Publishing, e-Book, 2014

Potential Energy Scan and NBO Analysis

noreply@blogger.com (Chemgplus) — Sat, 30 Aug 2014 19:56:00 +0000

Introduction
NBO analysis of orbital interactions is a powerful approach to understanding molecular properties. Subtle interactions can be often revealed by studying the NBO-derived properties at the potential energy surface (PES). By plotting the potential energy changes along the defined molecular coordinate (atom distance, angle, dihedral), one can get a better appreciation of different components of the total energy.

In this post, we will explore a typical workflow utilizing Gaussian09W ESS to generate multiple molecular structures at the PES. We will introduce a new Java application that processes the Gaussian PES output files (*.out) and creates formatted Gaussian input files to perform a single point NBO analysis (Figure 1). In the simplest case, Gaussian Scan keyword performs a series of single point calculations at various geometries. This, so called rigid PES scan performs evaluations over a rectangular grid involving selected internal coordinates. The molecular structure must be defined in Z-matrix coordinates. To avoid potential troubles with a poorly constructed Z-matrix, NboScan app can only read output files generated by the relaxed PES scan initiated with the keyword Opt=ModRedundant. In such case, the keyword requests that a geometry optimization (Opt) be performed in redundant internal coordinate that may include scan and constraint information [2]. The latter option requires a separate input section to activate, freeze, and scan PES. Initial geometry can be supplied as Cartesian coordinates or as Z-matrix. Results are recorded in the job output file. Each PES output file contains table of "Initial Parameters", which indicate the name and the value of Scanned and Frozen coordinates. Atom coordinates together with the corresponding energy at each coordinate increment are all part of the output file. Efficient retrieval of all requested values is often challenging task, certainly not error proof. It is where the NboScan app comes handy.

To avoid potential troubles with a poorly constructed Z-matrix, this app can only read output files generated by the the relaxed PES scan initiated with the keyword Opt=ModRedundant.

Fig. 1. A typical workflow for PES calculation using NboScan.

N-Methyl Formamide Example

We will start with an example of rigid rotation of the methyl group in cis-N-methylformamide (CH3NHCHO, cis-NMF). Results can be compared to the example discussed in the excellent book of Frank Weinhold and Clark R. Landis [1] on pages 141-142. The molecule of formamide was evaluated at HF B3LYP/6-311++G** level of theory. Gaussian09W was used for the relaxed PES evaluation with additional constraints. The input .gjf file is shown in Figure 2. All discussed files can be downloaded from the Download section at the bottom of this post.

Fig. 2. Gaussian input in Cartesian coordinates with added redundant coordinates.

%chk=Formamide_rot_recoor.chk
# rhf/6-311++G(d,p) opt=modredundant nosymm

RHF/6-311++G(d,p) (MeHNCHO) Me rot 2-1-6-7= 0 to 60

0 1
N 0.00000000 0.00000000 -1.36100000
C 0.00000000 0.00000000 0.00000000
O 0.99400000 0.00000000 0.69340000
H -0.85910000 0.00000000 -1.88640000
H -1.02320000 0.00000000 0.42260000
C 1.28045663 0.00000000 -2.08303243
H 2.08663777 0.00000000 -1.37948999
H 1.34338205 -0.87365131 -2.69758412
H 1.34338270 0.87365135 -2.69758400

6 * F Freeze bond lengths around the atom 6
1 * F Freeze bond lengths around the atom 1
* 1 * F Freeze bond angles around the atom 1
* 2 * F Freeze bond angles around the atom 2
* 1 6 * R Relax coordinates passing through atoms 1-6 (dihedral)
D 2 1 6 7 S 12 5.0 Scan dihedral 2-1-6-7 in 12 steps of 5 deg

Upon completion of the run, results of the nearly rigid methyl group rotation are written into the corresponding .out file.

Extracting coordinates and energy data:

In the next step, we will launch the NboScan app by double-clicking the NboScan.jar file and load the above created .out file (Figure 3).

Fig. 3. Main window of the NboScan application.

Click on button 1. Browse Dir to locate the file. Set the output directory for newly created Gaussian input files (.gjf) using the 2. Set Dir button. Alternatively, check the Use input Dir box to direct output into the same directory (Figure 4).

Fig. 4. Loading files for processing and setting the output directory.

Set parameters for the following single point energy calculation in the section 3. Those include the level of theory, basis set (pull-down menus) and additional comments and keywords to the route card. Alternatively, type in the custom level of theory and basis set.

Fig. 5. Entering parameters for single point energy calculation at a given geometry.

Optionally, check the Plot profile box to output the energy profile along the scanned coordinate (Figure 6). This will plot the total electronic energies at different dihedral angles (0-60 deg).

Fig. 6. Energy profile along the scanned coordinate (dihedral 7-6-1-2).

Enable/disable additional options at the bottom of the window. Energy values at calculated points can be retrieved by pointing the mouse at the blue diamond. Axis values can be toggled between horizontal/vertical.

Section 4. involves entering NBO keywords or selecting the preset NBO properties (Figure 7). For more complex keyword lists, use the GennboHelper application described earlier and the Enter custom keywords. The latest version of the GennboHelper can be downloaded from the app’s website.

Fig. 7. Setting NBO keywords and Gaussian-NBO options.

Choosing the PLOT files only option will generate the corresponding NBO keywords necessary to create PLOT files for each scanned geometry. The last option, Set user 1, allows entering custom keywords that are retrieved next time when running the application.

Instructions to Gaussian program on how to perform NBO calculations are selected on line 5.

G03 option uses older NBO3 module compiled as part of Gaussian 03 package.
G09-link-NBO6 option adds keywords “EXTERNAL” and “pop=nbo6read” into the G09w route card and links NBO6 Windows binaries to G09w (revision D.01) [DEFAULT]. This option requires having gaunbo6.bat file (part of the NBO6 package) in the main Gaussian directory (e.g., C:\G09W\gaunbo6.bat).
G09-NBO option adds NBO6 specific keywords (pop=nbo6read) into the route card of G09w, which had NBO6 compiled together with G09w binaries.
.47 file only option instructs ESS to generate .47 archive file for later analysis by GENNBO5/6. This is equivalent to NBO keywords ARCHIVE FILE=xxx.

The message window at the bottom provides information related to the key scan parameters, such as, name of the scanned coordinate, its description in the output file, number of extracted geometries, and total number of atoms in the molecule. Path to files created by NboScan application is also part of the output.

To facilitate the next step, that is, evaluation of each geometry with specified NBO keywords, Gaussian batch file (*.bcf) is created at the end of the run. Just drop the batch file into the main Gaussian09w window and click the “run” triangle icon (Figure 8).

Fig. 8. Starting the batch process in main interface of Gaussian09w.

Files created after the run are shown in Figure 9. Each created file has a suffix indicating value of the scanned coordinate.

Fig. 9. List of input and output files.

A representative example of the newly created series of .gjf files is shown in Figure 10. Note the comment field referring to discrete geometry and the value of scanned coordinate (_10_, _20_, etc.).

Fig. 10. An example of created .gjf file.

References:

1. Weinhold, F. and Landis, C.R. in Discovering Chemistry with Natural Bond Orbitals.

2. Rigid and Relaxed Potential Energy Surface Scans (PES Scan) in Gaussian 03 and Gaussian 09, J. Barroso.

Downloads:

NboScan java application: NboScan.zip v1.3
NboScan java app. (Linux-Ubuntu, SUSE): NboScan1.3Lin.zip v1.3
NboScan manual: NboScan_manual.pdf

Input and output files (.out, .gjf, .bcf): io_files.zip
Latest updates are at: NBO Apps and Scripts webpage

Jmol-NBO Visualization Helper

noreply@blogger.com (Chemgplus) — Fri, 02 Aug 2013 01:56:00 +0000

Recent string of posts detailed different aspects of natural bond orbital (NBO) visualization. In one example, JmolApplet was built for web visualization. In another, Jmol scripts were generated for a simple copy/paste transfer to Jmol macro files. The last example presented java application for direct generation of Jmol macros. This post expands on the last example and introduces new, full featured java application:

Jmol-Nbo Visualization Helper

Typical imagery based on Jmol-Nbo Visualization Helper macro files.

Fig. 1 Jmol-NBO Visualization Helper GUI.

As earlier versions, Jmol-NBO Helper is written in Java and compiled with JDK7. Successful run requires having the latest version of Java installed on your computer. Jmol-NBO Helper was developed and tested in java environment of Windows 7 and Linux systems.

Installation involves unpacking files from JmolNboVHelper.zip archive (see download section at the bottom) and placing them into any disk/directory on your system. Recommended location is c:/nbo/JmolNboVHelper.
Requirements for a successful visualization of NBOs are Jmol and NBO PLOT files.

Jmol-Nbo Visualization Helper is a Java application that generates sets of Jmol .macro files that assist with generating orbital images in Jmol molecular viewer. Specific NBOs and NBO-NBO* pairs can be easily visualized and their interactions analyzed. Additional features include options to write .macro files into the default Jmol directory and to inspect source .nbo files for the key properties associated with NBO orbitals. The application has also options for visualization of 2-D contour images in customizable planes and an option to generate imagery for spin-polarized unrestricted solutions (alpha and beta spin orbitals). Java app GUI is now running both under Windows and Linux systems.

Overview:

Jmol-NBO Helper features two distinct tabs, Jmol Setup and NBO Analysis (Fig. 1). Jmol macro files are created from the first tab, selected NBO outputs can be retrieved on the NBO Analysis tab. By clicking the "1. Browse Dir" button on the Jmol Setup pane (A), browse for the desired PLOT file on your computer. Choose any of the related plot files in range of .31-.40. Selected filename and its extension are parsed into the corresponding fields (2 and 3). Alternatively, select the requested basis from drop-down menu (B) and the logical file name (LFN) in 3 will be updated accordingly (Fig. 2).

Fig. 2 Inputs

After a succesful run, when Jmol-Nbo Helper is opened the next time, filename and file extension from the previous run will be retrieved and filled into fields 1, 2, and 3. Next step involves selecting individual orbitals or range of orbitals in format 1,2,5,9 or 1-9, respectively. Homo and Lumo abbreviations are also allowed (Fig. 1). At the lower part of Jmol Setup panel, choose whether to write macro file(s) into Jmol default .macros directory (typical use) and if you want previously created macros be overwritten (i.e, clear the default directory). If none of the check boxes is selected, macro files will be written into the directory of .31-.40 files. Press "Create" (C) and set of macro files will be created. Confirmation message will appear in the text box at the bottom.

Orbital Interactions:

Now, let's move to options for creating imagery of orbital interactions. "NBO Interactions?" box is the key in instructing Jmol to display two orbitals of your choice at the same time. This feature is useful for inspecting Donor-Acceptor pairs as seen in the center image of the main application interface (Fig. 3). First, check the "NBO Interactions?" box then select interacting pairs and enter them into field "Orbital pairs". Format is D:A, D:A (columns and commas). For any visualization in Jmol, selection of background color is optional. Default is dark blue background. "Turn axes on" and "Labels OFF" options are self-explanatory. As with the single orbitals, check the "Default directory", "Clear default directory" boxes, and press "Create".

Fig. 3 Options for interacting orbitals

In case that D-A orbitals overlap with opposite signs (i.i, positive lobe with negative one, blue with yellow), use suffix i appended to the orbital number that you want the sign be inverted (e.g., 12:87i will invert sign of orbital 87).

Contours:

Generation of macro files for contour imagery is a new addition to the Jmol-Nbo Helper. For either single or interacting orbitals, checking "Contours" box will lead to additional 2-D orbital imagery (Fig. 4). Both surface (s) rendered and contours (c) images will be available. With "Contours" check box selected, choose definition of the plane onto which contours will be projected. Plane can be defined by atom numbers, atom numbers in combination with XYZ coordinates, just XYZ coordinates for each point, or by non parametric plane equation.
Due to the need for the plane definition, note that only one orbital or one orbital pair should be generated at the time. For one orbital only, use the field "Orb 1" to define projection plane (Fig. 5). For interacting pairs, plane for each orbital is defined in "Orb 1" and "Orb 2" fields. Scaling of projection contours is done experimentally for each orbital. While default values (Low, High) are often satisfactory, feel free to change limits to fit your requirements.

Fig. 4 Contours and plane definition

Fig. 5 Contours and scaling

Just underneath the Contour area is "NBO6 Surfaces (now Surfaces)" check box for including cutoff option to 3-D surfaces (Fig. 6). While this may be only a temporary option, it can be used in general to affect the size of orbital lobes. The greater the number, the small is orbital lobe.

Fig. 6 Cutoff values for Jmol orbitals

NBO6 Surfaces option has been changed in ver. 1.0.2. Surface scaling is now optional as normalization of primitives was fixed in NBO6. History of changes on NBO6 web site says: "Errors in PLOT, NJC, and NBCP output arising from inconsistencies in normalization of Gaussian primitives from different ESS hosts have been eliminated. The current code renormalizes GTOs as necessary to insure consistent results for all ESS hosts".

Output Analysis:

NBO Analysis pane was added to guide users with selecting orbitals and the corresponding numbers for input into Jmol Setup tab.

First, load the .nbo or .out file that corresponds to PLOT files used for NBO imagery (A). Path and filename are again saved in local xml file and will be retrieved in the next session. Next, choose one of the radio buttons indicating the requested information from the nbo/out file (B). By clicking "Run" button (C), selected output will be printed into the text field below.

Fig. 7 Content of the NBO output file

At the bottom of NBO Analysis tab, there are two free-text fields where you can make notes about selected orbitals and pairs. Copy and paste your list(s) into designated fields on the Jmol Setup tab.

Fig. 8 Running macros from Jmol.

Once done with generating macro files, launch the Jmol and go to Macros drop-down menu. Earlier created files will be listed by their abbreviated file names. Just click the macro name and further adjust created images from Jmol console or menus.

Current version 2.1

Version 2 of the JmolNbo Visualization Helper added an option to analyze open-shell NBO output. By checking the box "Open-shell?" in the lower part of the JmolSetup tab (Fig. 9), content of the loaded lfn file (section 3.) will be parsed for the corresponding alpha and beta sections and two lfn files will be created (e.g., filename_a.37 and filename_b.37). New files are created in directory from which the original lfn file was loaded from (1. Browse Dir). Accordingly, two macro files for each initial (α + β) NPA output will be created and can be visualized in JmolViewer.

Since new files are written to the directory containing .31-.46 files, make sure that the folder is given -write permission (Linux users).

Fig. 9 Option to create two separate alpha and beta spin sets and orbital imagery.

NBO Analysis tab now prints different portions of the NBO output file (.nbo or .out) with sections for α and β spin sets (Fig. 10). As a result of such separation, values are not anymore sorted. NBO output files (closed-shell and open-shell) are automatically recognized and parsed accordingly.

An example of open-shell system (HF+ radical cation) is part of the application download.

Fig. 10 Details of the Natural Bond Orbitals summary output for two spin systems.

Exemplary images for α-spin orbitals 5 and 6 of HF+ radical cation are shown in Fig. 11.

Fig. 11 2D countours and 3D images of alpha spin set for NBO 5 and 6 of HF+ radical cation.

Enhancements in version 2.1 include the option to generation Jmol scripts to output .x3d and .jvxl files for visualization of Natural Bond Orbitals in web browsers. As for version 2.1, the GUI is shown in Figure 12.

Fig. 12 Details of the application's main panel.

While not directly implemented in Jmol-NBO Visualization Helper, Gary Breton has described a creation of multiple orbital surfaces using combination of Jmol and Visualization Helper.

Downloads:

To download the latest version of Jmol-NBO Visualization Helper, please visit the NBO Scripts and Handy Applications web page at http://www.marcelpatek.com/nbo/nbo.html
Since the version 1.3, both Windows and Linux .jar files are part of the .zip download file. W suffix refers to the Windows OS, Ub/Lin suffix refers to the Linux (Ubuntu) OS.

Video Tutorial:

References:

Jmol: an open-source Java viewer for chemical structures in 3D.
Jmol/JSmol interactive scripting documentation.
F. Weinhold and C. R. Landis, Discovering Chemistry with Natural Bond Orbitals (Wiley-VCH, 2012), 319pp.
References at NBO6 Website.
NBOView and NBOPro are "gold" standards for creating NBO imagery and analysis of NBO outputs both originating and expanding concepts and software of Frank Weinhold.

Gennbo Helper

noreply@blogger.com (Chemgplus) — Sun, 21 Jul 2013 22:44:00 +0000

After a string of blogs on visualization of NBO orbitals in Jmol, today I am going to introduce new application:

Gennbo Helper

Gennbo Helper is java-based application which offers a simple way of generating:

Keylists and the corresponding keywords for standalone program GENNBO5/6 (processing of existing archive files (FILE47))
Keylists and the corresponding keywords for ESS-linked or "embedded" NBO modules
Input files with nbo keywords for two ESS/NBO programs, namely Gaussian09 and PC-GAMESS/Firefly

Gennbo Helper assists with syntax of NBO keylists and keywords and formats them for input into standalone Gennbo program.

The main reason behind Gennbo Helper was to "script" repetitive tasks behind preparation of .47 archive files, running the stand-alone GENNBO module, and consistently writing properly formatted ESS input files.

Fig. 1 Gennbo Helper GUI.

Being written in Java7 code, this application requires having the latest version of Java installed on your computer. Gennbo Helper was developed and tested in java environment of Windows 7 and Linux systems. Installation is rather simple. Files from GennboHelper.zip archive can be placed into any disk/directory on your system.

Without any doubts, efficient use of Gennbo Helper assumes familiarity with NBO concepts and programs developed by Frank Weinhold at the University of Wisconsin. Reference section below lists key resources, which are invaluable for better understanding of chemical phenomena predicted by NBO analysis.

Since this application makes direct use of standalone NBO6w program, having NBO6w installed on your computer will fully utilize capabilities of Gennbo Helper. For details and availability of NBO programs, visit the NBO6 website.

Gennbo Helper works with local NBO6 gennbo executable to process .47 archive files. Alternatively, modified .47 file can be used as input for the older Gennbo5W program.

Brief Overview:

Gennbo Helper graphical user interface (Fig. 1) consists of three main areas:

1) File input (top area)
2) Options (middle section)
3) Output (bottom area)

Archive file .47 is loaded first at the top by clicking "1. Browse dir" button. Filename and extension is parsed into different text fields and optional suffix can be added.

Fig. 2 Basic keywords tab

Middle panel is subdivided into three tabs for different tasks. On the Basic keywords panel, options are selected by checking the corresponding check boxes, levels, atom lists, and drop-down menus (Fig. 2). In the middle part of Options is a group of control keywords. By selecting Plot or Archive keyword will always set FILE keyword on as well. Clicking button "3. Create/Append input" generates string of NBO keywords in the output area below (in blue). Typical flow includes clicking "Write *47" and "Run Gennbo6" buttons. String of formatted NBO keywords is inserted into .47 archive file and processed by nbo6 modules. Alternatively, older GENNBO5W can be used to load and run modified .47 file manually.

On the Keylists tab (Fig. 3), user can create two main keylists with their specific keywords. Those are $CHOOSE and $DELETE. The former list can be used with standalone GENNBO application, the latter list with ESS-linked nbo6 modules or with ESS program having nbo routines included. While NEDA and NCS keywords are not necessarily parts of $DEL list, they were added into this group as they also require nbo modules being either internal or linked to ESS program. If format of keylist is incorrect, warning message will appear asking you to correct formatting. Hovering mouse over any field will display tip on format or the keyword.

Fig. 3 Keylists

ESS Input tab (Fig. 4) allows generating basic input files for two ESS programs, Gaussian 09 and GAMESS/FIREFLY. Molecular geometries can either be pasted in or loaded from Examples drop-down menu. From this tab, input file with instructions to generate the necessary .47 archive file can be created and directly used with the two ESS programs mentioned above. Pull-down menus and check boxes offer selection of computational method, examples of molecular geometries, symmetry, and other options to be added into input files. After all the necessary parameters are entered, click on buttons 4.-5.-6. “Create NBO input” button has the same function as button “3. Create/Append input”. It populates the output area with NBO keywords. “Save NBO param” will copy all keylists and keywords from the nbo output area and “Generate Input” button will create new .inp or .gjf file for use in FF or G09, respectively.

Checking the new checkbox “Run” and clicking button 6. will generate windows batch file “gaussrun.bat” in the directory set by clicking button 2. If Gaussian program is installed in C:/G09W, the job will start immediately. This option was added for a greater convenience of Windows users and won’t work on other systems. All options except of running Gaussian (&Run) work also under Linux OS.

Fig. 4 ESS Input tab

In case that GAMESS/Firefly option was checked, button "6. Generate Input" will also create initialization batch file filename_RUN.bat in the directory of Firefly executable. To launch Firefly job, just double-click the .bat file.

In the Input and Output areas, there are two drop-down menus with nbo keyword presets and user settings. NBO keywords that are generated by user (or just typed in) can be saved (and re-used) in three different User settings.

Batch Input tab (Fig. 5) allows GENNBO processing of multiple .47 files from one directory. Running a batch of .47 files is independent of other settings in the app.

Prerequisites:
In order to process .47 files by GENNBO6 modules, a helper jvgennbo.bat file has to be present in the main NBO6 directory (here c:/nbo6w). The file is part of the download. Since it is Windows file, the Batch processing is limited to Window users.

1. First set the NBO6 (GENNBO) directory using the button “2. Load Dir”.
2. Load .47 files by clicking the “Load Files” button (1.) and by control-selecting multiple files in that directory. Selected files will appear in the Batch list area.
3. Write NBO keywords and lists into $NBO $END section of the .47 files. By clicking the “Write Batch” button, keywords in the NBO keyword and keylist area will be inserted into all .47 files. Successful insertion of keywords will be indicated in the Notification area at the bottom of the window.
Optionally, if .47 files already have $NBO section populated, skip the “Write Batch” step. Clicking the “Write Batch” button (2.) with no keywords in the Keyword and keylist area, default keyword PRINT=0 will be used.
4. By pressing “Run batch” button (3.) a loop feeding each .47 file into GENNBO modules will be launched. Progress monitor bar will indicate status of the processing and current file being process by GENNBO modules will be shown in the text field left of the progress bar. Upon completion, a message window will pop up.

Fig. 5 Batch List tab

Download:

The latest version of GennboHelper.zip file (ver 1.32 on April 2015) can be downloaded from NBO Scripts and Handy Applications website. Gennbo Helper manual, README file, and accessory files are included.

Video Tutorial:

References:

NBO6 manual
F. Weinhold, “Natural bond orbital analysis: A critical overview of relationships to alternative bonding perspectives,” J. Comput. Chem. (2012).
F. Weinhold and C. R. Landis, Valency and Bonding: A Natural Bond Orbital Donor-Acceptor Perspective (Cambridge U. Press, 2004), 760pp.
F. Weinhold and C. R. Landis, Discovering Chemistry with Natural Bond Orbitals (Wiley-VCH, 2012), 319pp.
References at NBO6 Website.

Jmol Scripts for Visualizing Multiple NBOs

noreply@blogger.com (Chemgplus) — Sun, 31 Mar 2013 21:13:00 +0000

In the previous part, single visualization scripts were created to display individual or interacting NBOs in Jmol viewer. We have used a simple Java application to generate the corresponding Jmol script files. Here, a slightly modified version of the previous application is described, which allows for generation of sets of macro files for specific NBOs or interacting NBO-NBO* pairs.

In brief, we browse for specific NBO "PLOT" (.32 - .40) file, click on it, and choose or leave default logical file name (LFN). In the next step, we proceed to the input of molecular orbitals (fields NBOs or NBO pairs). To visualize interacting orbitals, we check the "NBO Interactions" check box and enter list of interacting pairs (e.g. homo:lumo, 12:87).

Pairs are separated by comma and interacting pairs are denoted by column separator. For a simple list of orbitals, we enter comma separated list of orbital numbers (e.g. 10, 12, lumo). After clicking "Create" button, the corresponding script files will be created and confirmation printed in the text field below (Fig. 1). From there, we launch JmolViewer, go to "Macros" pull-down menu, and choose one of the listed macros.

Java Application - Details:

As indicated in Fig. 1 (magenta lines), we fill in the file path (Browse for and click any plot file), check the filename, and enter LFN type (37 for NBO).

File name is parsed from the selected path, filetype is removed. For example, by clicking on c:/nbo/form.37, directory c:/nbo is selected in field 1. and "form" is auto filled in field 2.
Values for fields 1, 2, and 3 are recorded in newly created file "nbo_settings.xml' and re-used next time when application is launched. This file is stored together with the .jar executable.

In the next step, we will specify list of orbitals (1) or interaction orbital pairs (2).

For list of orbitals, we enter comma separated order of orbital numbers (from .nbo file). For example, "10, 12,homo,lumo". Spaces are tolerated. The latest revision also features option to enter ranges of orbital, such as "5-10,12,homo,85-87".
To indicate the interacting pair list, we have to check the box "NBO Interactions?" and type comma separated list of orbital numbers with column character indicating interaction pair. For example, list containing "12:87, 10:65, homo:lumo" will create three macro files for the following interacting pairs: 12-87, 10-65, and homo-lumo.

In this version, there is one additional feature - option to write macro files into the default JmolViewer .jmol/macros directory. Its path depends on the computer system (Win, Linux). If this check box is unchecked, macro files are created in the original directory (here c:/nbo) and have to be manually moved into .jmol/macros directory before launching JmolViewer.

Fig. 1 Interacting orbitals of formamide.

After clicking "Create", the corresponding macro files will be generated in the assigned directory. Summary of executed tasks is shown in the text area. Note the number of macro files created (here two), type of orbitals (here NBO), and path to the macro files.

Plot file number (.32-.40) is translated into the corresponding orbital type (PNAO, NBO, ...) and abbreviated in the file name (Fig. 2).
Spaces between interacting pairs are tolerated (12:87, \s homo:lumo), but other irregularities, such as "12-87" in the format are not checked for.

To clear output field and fields for NBO entry, click the "Clear text" button.

Fig. 2 Macro files created in the %USERPROFILE%/.jmol/macros directory.

Occasionally check for updates on this blog "Click here for update" link at the bottom of application window.

Download:

Download zipped .jar file by clicking the following link:

Latest version: nbo_list_macro_rev3.1.zip

Other versions:
rev2: nbo_list_macro_rev2.0.zip
rev1: nbo_list_macro_rev1.0.zip

History:
4/14/2013 - rev3.1 fixed bug with directory opening in the default place instead in the directory visited last.
4/9/2013 - rev3.0 added option to delete files in default JmolViewer directory; Changed file naming to allow for numerical sorting of interacting orbitals in JmolViewer (from name_10:57-NBO.macro to 10:57_name-NBO.macro)
4/7/2013 - rev2.0; added option to enter ranges of orbitals (e.g., 1-5, 6-9,12). Changed file naming to allow for numerical sorting of individual orbitals in JmolViewer (from name_1-NBO.macro to 1_name-NBO.macro)
3/31/2013 - rev1.0; original version

Java classes (and application) were compiled with JDK 1.7. Any updates to the files will have revision suffix added to the filename (rev1.x) .

Contact me with any bugs, suggestions, or if there is a problem with the download (I'll e-mail you the files).

References:

Dr. Joaquin Barroso's Blog NBO thread.
Natural Bond Orbitals (NBO) visualization at Dr. Joaquin Barroso's blog.
Natural Bond Orbital 6.0 homepage.
Molecular Modeling Basics - Jmol and more ...

Create Jmol Scripts for NBO Visualization

noreply@blogger.com (Chemgplus) — Tue, 19 Feb 2013 01:34:00 +0000

So far, we have worked out preparation of files for NBO visualization in the Jmol viewer. At some point, one would like to visually inspect specific NBOs or interacting NBO-NBO* pairs. Jmol offers two approaches to "loading" molecules and their properties. One is via Jmol Console (File → Console, Fig. 2), the other one is to load a macro script from Macros menu. To make either approach more easy, I wrote a simple java application that generates both the script and macro for single NBO or pair of interacting NBO-NBO* orbitals.

In brief, we browse for the specific NBO "PLOT" (.37 - .46) file, choose or leave default logical file name (LFN) and then proceed to input of molecular orbitals (field NBO). To visualize interacting orbitals, we check the "NBO Interactions" check box and enter interacting pair of orbitals into "NBO" and "NBO*" fields. After clicking "Create" button, the corresponding script will appear in the blank text field at the bottom.

From there, we can copy it to clipboard, save the macro file, or clear the text field. Detailed how-to can be found in each downloaded zip file.

App Requirements:

Platform independent
Preferably standalone on desktops, possibly servers
Simple, yet scalable

Java programming language not only fits all the above requirements, but it is also fun to work with.

All discussed applications use Java SE 7 and JDK 1.7. To ensure that all apps work fine with older JAVA editions, JDK 1.6 versions (JAVA 6) are also included. Both versions were tested under Windows 7 and Ubuntu 11.04 virtual machine (VMware Workstation 7.0) hosted by Windows 7.

Java Application:

Let's begin with the Console input. I usually open Console window next to the main JmolViewer window for more interactive navigation. Typical example of Console script commands is shown in Fig. 1. For more scripting commands, see this scripting documentation. Specifics around molecular surfaces are described here.

Fig. 1 Jmol Console.

As outlined above and shown in Fig. 2, we fill in the file path (Browse for and click the particular plot file), check the filename and enter LFN type (37 for NBO), and proceed to field "NBO". Here, we enter orbital number or just type "homo, homo-1, etc.). After clicking "Create", the corresponding script will appear in the empty text field.

Fig. 2 Create Jmol Script for NBO Visualization.

From here, we can copy the script to clipboard or save it as macro. In this example, file form_12.macro will be saved in the original directory of plot files. Data which is now in the clipboard can be directly pasted into Jmol Console (Fig. 1). After pressing "Enter", new imagery will appear in the main Jmol viewer window.
To visualize interacting pairs of orbitals, check the box "NBO Interactions?" and provide the pair of interacting orbitals into "NBO" and "NBO*" fields, respectively. (Fig. 3).

Fig. 3 Create Jmol Script for NBO Visualization - I.

Fig. 4 Interacting orbitals of formamide.

Pasting the script into Console or saving it as macro file will result in visualization shown in Fig. 4. Save the above created macro file in the "macro" folder located at "%USERPROFILE%/.jmol/macros" (Windows 7). Hint - type the above path (without quotation marks) to Windows Explorer address bar and hit enter.

As the project evolved, I built two versions of the application. One is called "light" and does exactly what is described above. The other version, called "extended", has a few additional features - it will remember the previous state of file path, file name, and LFN type as data is stored (and retrieved) from dynamically created nbo_settings.xml file. This latter version also features link to any updates on this blog.

Download the files:

App/JAVA SE	JAVA 6	JAVA 7
nbo_macro_light	nbo_macro_light6.zip	nbo_macro_light7.zip
nbo_macro	nbo_macro6.zip	nbo_macro7.zip

As table headers indicate, the same java classes (and application) are compiled for JDK 1.6 and JDK 1.7 environment. Any updates to the files will have revision suffix added to the filename (rev1) .

Contact me with any bugs or if there is a problem with the download (I'll e-mail you the files).

Future Work:

While both light and "extended" versions provide quick access to the script and macro files for use in JmolViewer, generation of custom set of macro files is clearly the next step. I'll post the blog update when new custom macro "generator" will be available. Another enhancements may include web access to java applet or Java Web Start deployment.

How-to Video:

References:

Dr. Joaquin Barroso's Blog NBO thread.
Natural Bond Orbitals (NBO) visualization at Dr. Joaquin Barroso's blog.
Natural Bond Orbital 6.0 homepage.
Molecular Modeling Basics - Jmol and more ...

JmolApplet and Visualiziation of NBOs in Web Browsers

noreply@blogger.com (Chemgplus) — Sun, 28 Oct 2012 21:13:00 +0000

Lone-pair -> antibond delocalization in formamide.

In this post, we will continue exploring visualization possibilities offered by the free Jmol viewer, particularly, the graphical representations of Natural Bond Orbitals (NBOs) generated by GENNBO 5.0W. Other sources of .31-.46 plot files can be used as well. Ultimately, we should be able to output and dynamically display selected NBOs in any web browser and further they display properties.

Jmol is a free, open source molecule viewer running on several common operating systems (Mac, Windows). There are two main applications that most users will want to use for visualization of molecular orbitals and molecular surfaces:

The JmolApplet is a web browser applet that can be integrated into web pages.
The Jmol application is a standalone Java application that runs on the desktop.

Jmol: an open-source Java viewer for chemical structures in 3D. http://www.jmol.org/

Let's go through the steps of setting up files, directories, and parameters to output visualization directly to a web browser.

As briefly outlined in the previous post, we first need to get the Jmol application files from

jmolsourceforge.net (zip file). Unpack the zip file into any drive/folder (e.g. D:/computation/jmol for this tutorial) and make a shortcut to Jmol.jar file on your desktop. Next, we will need the formamide.31-.46 plot files generated earlier (previous post). In case that you wish to reproduce examples in this tutorial, here are the files. For now, just keep them separate from the jmol directory.
To be able to use ScriptButton features of the Export to Web module of the Jmol application, we need to run a simple web server*. There are several choices available:

Using your own or institution's web server
Installing a free web server environment, such as WampServer
Running a simple portable web server, such as mongoose

* Launching .html files directly from the web export folder fails to display Interactive buttons and most importantly, the java visualizations.

Assuming that we want to run visualization on our local computer, the address will be http://localhost:8080/dir/file.html, where dir and file will be replaced by your actual directory name and the corresponding .html file name.

While I am using WampServer (on Windows 7, 32bit), examples discussed here use simpler and "light-weight" mongoose server. Download it (mongoose-x.x.exe) from the above link and place the .exe file at the same level where the Jmol file is located (Fig. 1).

This blog has been UPDATED (summer 2015) to reflect the recent changes in Jmol structure and Web presentation.

With the Chrome browser phasing out support of Java-based plugins (applets), Jmol development has moved to JavaScript-based framework and HTML5 support.

As of mid-2015, Firefox, Opera, and IE still support java applets and plugins.

Fig. 1 Folder structure of the Jmol app and loca/server files

Preparing the web output:

Now, open the desktop version of Jmol (click Jmol.jar shortcut) and make sure to have sevral macro files ready (created earlier with JmolNBO Visualization Helper). Then go to:

File -> Export -> Export to web page and select tab "ScriptButton Jmol"

Fig. 2 Jmol Web Page Maker main window

Fill out the Author field, and enter "./jsmol" into the "Relative server path to jar files" field. Upon saving the html page, Jmol export Jsmol directory to your server structure (./java/jsmol). Enter just a dot into the "Relative path to local jar files" field (see Fig. 2).
For each desirable loaded visualization (through the macro scripts in the main Jmol app window), click "Add Present Jmol State as Instance" button to add NBOs to make them available for display in the browser. Name the state (NBO) by its corresponding number (Fig. 2).
Click "Save HTML as" and navigate to the folder where Jmol folder is located (Fig. 3). In this example, it is D:/computation/jmol/java.

Fig. 3 Exporting web files with the folder layout

Now, the important part - go to the folder with .31-.42 plot files created earlier. Due to an unknown bug in the java code, you have to re-name files form.31 and form.46 to form.37.31 and form37.46, respectively and copy them into the just created web folder /java. Essentially, we just insert .37 in the middle of the file name. Files in that directory should look similar to the top three files in Fig. 4.

Fig. 4 Structure and new files in the web export folder

All files created in this last step (except of jsmol directory) are available for download (java.zip). Unpack them next to the Jmol folder (Fig. 5) and follow the next step to reproduce this tutorial.

Fig. 5 Final directory layout

Launching the server:

Launch mongoose.exe by double clicking it (Fig. 5). Mongoose web server icon will appear at the right-bottom notification area.
Confirm security exception (if any) and check "Install service".
Type http://localhost:8080/java/java.html to launch the in browser. Again, replace "java" with the name of your actual folder and .html file name.
After finishing visualization, cancel and exit the mongoose server service.

Since the visualization and web structure use a lot of JavaScript, loading of all files may take 10-20s. Once the image is loaded there is a small 3D icon positioned down-left in the image window. Click on that icon to start loading 3D view and Jmol menu (opens on right-mouse click).

The final web view is shown below.

Note that there is still the option to switch to Java-driven view (link below the image). However, the view will not work in the Chrome browser as of version 43.

Watch video tutorial:
This video pertains to the early version of Jmol tutorial. While many steps are the same, please adapt revisions from the updated blog.
mobile link:

Visualizing NBOs in Jmol

noreply@blogger.com (Chemgplus) — Sat, 27 Oct 2012 23:45:00 +0000

In the previous post, concept and usage of NBO analysis were introduced. This post outlines steps for visualization of natural bond orbitals in open source viewer - Jmol. We will also assume the least practical scenario - running our calculations in Gaussian 09 for Windows (G09W).

There are two prerequisite parts that we need for NBO analysis:

Molecular system wavefunction and
NBO program that perform the analysis

The former is usually generated by our electronic structure system (ESS), the latter one is either part of the ESS or has to be purchased separately (see NBO web site). Currently, the most recent version of the NBO program is at version 5.9 (aka NBO5). Unfortunately, users of Windows version of Gaussian have only access to the older version of NBO (3.1), which is incorporated in binaries G03W or G09W. To gain access to NBO5 options, Windows users have to use GENNBO 5.0W application, which performs analysis of wavefunction generated by the Gaussian ESS.

The process of obtaining NBO5 output files and results of NBO analysis is following:

Specify POP=NBOREAD keyword in route card of Gaussian input file ($NBO keylist will be read and processed)
Include the ARCHIVE and FILE=name in the $NBO keylist that is specified after the "standard" Gaussian input (Fig. 1). Leave one blank line before and after the keylist.
File name.47 (in our case form.47) will be stored in "Scratch" directory of the G09W install path (typically C:\G09W).
Open this name.47 file in any text editor and enter keywords "file=form plot" between $NBO ... $END delimiters at the top of the file (Fig. 2).
Save the file and use it as input for GENNBO 5.0W analysis.

Fig. 1 Example of G09W input file for formamide

Fig. 2 Setting up $NBO keylist in name.47 file

After GENNBO analysis finishes, the corresponding .31-.46 plot files will be in the GENNBO5 main directory. I usually just move them into directory where all other output files reside. At this point, our directory should contain the following files (Fig. 3):

Fig. 3 List of created files

Having GaussView 5.0, but not GENNBO 5.0W? For direct output of NBOs from G09W/NBO3.1 binary, include command "POP=(nbo,savenbo)" in the input file route card. Only NBOs (not other orbitals) are then saved in .chk file for further analysis. Format the checkpoint .chk file with Gaussian utility to formatted .fch file and use GaussView 5.0 to visualize NBOs. Due to the slight differences in NBO3.1 and NBO5 calculations, NBOs may look a bit different.

With plot files .32-.46 in place, we are ready to inspect shapes and size of NBOs. Actually, not just yet. We need to install Jmol application that will run on our desktop. It is a free, open-source molecule viewer, running on Windows, Mac OS X, and Linux/Unix systems. Jmol can be downloaded from jmolsourceforge.net as .zip file. Unpack it in any place you wish and make shortcut to Jmol.jar file on your desktop. Then, just run it.

To make generation of the NBO imagery easier, we will use Jmol scripts that can be run as "macro". Save the following text between the dashed lined into file called, nbo12.macro
---------------------------------------------

Title=NBO12
Script=reset;background [0,0,150];load F:/your/path/to/plotfiles/form.37;mo 12;wireframe 30;spacefill 50;center {0.0 0.419936 0.0}; rotate z 145.3; rotate y 176.92; rotate z 13.53; translate x 3.92; translate y 5.95; set rotationRadius 3.27;isosurface color [247,255,71] [113,168,254] mo 12 opaque;mo nomesh;isosurface translucent 0.3;

---------------------------------------------

This file should have no line breaks after the first line (just a long line text). You will need to change the path to your set of .32-.40 plot files and orbital number after "mo" command. Currently, it will display mo 12 (NBO), which is the HOMO in our formamide example.

Now, save the above created file nbo12.macro in the "macro" folder located at:
C:\Users\username\.jmol\macros (Windows 7)

Launch the Jmol, click on "Macros" in the menu and click on "NBO12". You should see the following image.

Fig. 4 NBO 12 of formamide (HOMO)

In the next post, we will explore Jmol Applet and Visualiziation of NBOs in web browsers. Some other time, I'll take a look at the same visualization using Molekel 4.3.

Weinhold, F.; Discovering Chemistry With Natural Bond Orbitals, Willey, 2012.
Natural Bond Orbitals (NBO) visualization at Dr. Joaquin Barroso's blog.

Natural Bond Orbitals (NBO)

noreply@blogger.com (Chemgplus) — Sun, 23 Sep 2012 17:08:00 +0000

Some of the most important information about chemistry can be obtained from solutions of the Schrödinger equation. It is through the use of quantum mechanics that we are able to arrive to solutions that can predict properties of molecules with a high level of accuracy. While there are many excellent teachers, books, and lectures describing the fundamental theory of quantum mechanics (QM), it is the interpretation and practicality of many existing QM schemes that chemists find difficult to translate into their everyday observations and understanding. By solving the Schrodinger equation one obtains "electronic energy" for a specific spatial and spin state of electron, called molecular orbital. As an exact solution of Schrödinger equation has only been achieved for one-electron system (hydrogen), there are many computational techniques developed that approximate the solution for multiple-electron system.

To understand properties and reactivity of organic compounds, chemists have to rely on concepts such as, chemical bond, lone electron pair, conjugation, charges, aromaticity, and other properties, which are often difficult to predict or quantify. By successfully applying those understandings to molecular structures, more complex properties or concepts including anomeric effect, rotational barriers, hyperconjugation, resonance, and basicity can be described and predicted.

Molecular Orbitals:
The most commonly used technique to approximately solve the Schrödinger equation is called a Hartree-Fock method (HF), which decomposes many-electron wavefunction into a combination of molecular orbitals that are normalized and orthogonal. Molecular orbitals are then expanded in terms of atomic orbitals as linear combination of atomic orbitals (LCAO). Conceptually different, but similar in mathematical formalism is Density functional theory (DFT), which has evolved rather recently from the Hohenberg and Kohn theorem, determines the energy of a molecule from the electron density instead of a wavefunction. In the HF analogy, a determinant of Kohn-Scham (K-S) orbitals is formed and the electron density is used to calculate energy. While there has been some debate over the interpretation of K-S orbitals (being a pure mathematical construct used to re-construct the density), their shapes tend to be remarkably similar to canonical HF MOs. Today, DFT formalism including the K-S orbitals are frequently used in qualitative analysis of chemical properties.

Although "classical" Hartree-Fock and Kohn-Sham orbitals are, by definition, the best possible for a single-configuration wavefunction or electron density, respectively, there is even a "better" set of orbitals, called "natural" orbitals, to describe the correlated electron density. And this is the point, where the concept of Natural Bond Orbitals comes in. NBO localization algorithm permits the form of the BOs to be fully optimized with respect to a maximum-occupancy criterion based solely on the first-order reduced density matrix. In NBO analysis, the input basis set is transformed successively into various localized basis sets, first to natural atomic orbitals and then to hybrid orbitals which are used to form bond orbitals (NBOs). Finally the NBOs are transformed into localized MOs. The NBO analysis can illuminate interesting chemical aspects of the bonding and allow explanations of the various chemistry phenomena, such as, reactivity, stereoselectivity, basicity, and intramolecular and intermolecular energy barriers, all based on orbital interaction concepts. Most importantly, from the chemist's perspective, NBO analysis provides an orbital picture that is as close as possible to a classical "textbook" Lewis structure for a molecule.

NBO methodology:

The NBO analysis involves sequential transformation of nonorthogonal atomic orbitals (AOs) to the complete and orthonormal sets of “natural” atomic orbitals (NAOs), hybrid orbitals (NHOs), and bond orbital (NBOs). These localized basis sets describe electron density and other properties by the smallest number of filled orbitals in the most rapidly convergent fashion. As mentioned earlier, these orbital are closely related to the localized orbitals (bonds and lone pairs) used by organic chemists. The NBO method was developed by Weinhold and co-authors and it is becoming a powerful and popular method for study of bonding concepts.

On a more technical level, the NBO localization protocol divides NBOs into core, bonding, anti-bonding and ‘‘Rydberg’’(remaining) orbitals. The core and bonding orbitals describe the strictly localized Lewis structure of a molecule. The sequence goes through various localized basis sets in the following order:

AOs-> NAOs -> NHOs -> NBOs -> NLMOs -> CMOs

Examples of properties that can be calculated in NBO basis include:

Dipole, polarizability, atomic charges,
Bonding-anti-bonding orbital interactions,
Resonance structures (second order perturbation theory),
Bond orders,
Energy decomposition,
Chemical shift, J-couplings,
Steric analysis,
Canonical MO analysis.

Differences between canonical and NBO MOs:

Canonical MOs (CMOs) are delocalized over the whole molecule,
They usually bear no resemblance to localized s and p bonds, or to lone pairs, so they cannot be used to support familiar chemical reasoning
On the path to NBOs, an ordinary MO calculation is done at a high enough level to reproduce measured geometry or energies (delocalized MOs are obtained),
Then the atomic basis set is transformed into an equal number of natural atomic orbitals (NAOs), and the MOs into an equal number of natural bond orbitals (NBOs)
These additional transformations are cheap in computer time
More intuitive NBOs are result of those mathematical transformations

While analysis of the NBO results is instructive and informative, one usually wishes to visualize newly generated NBOs. In the next post, I will describe the use of Jmol for visualization of NBOs.

References:

F. Weinhold, "Natural Bond Orbital Methods" in, Encyclopedia of Computational Chemistry, P. v.R. Schleyer, N. L. Allinger, T. Clark, J. Gasteiger., P. A. Kollman, H. F. Schaefer III, P. R. Schreiner (Eds.), (John Wiley & Sons, Chichester, UK, 1998), Vol. 3, pp. 1792-1811.

F. Weinhold and C. R. Landis, Valency and Bonding: A Natural Bond Orbital Donor-Acceptor Perspective (Cambridge University Press, Sept 2005).

A. E. Reed, L. A. Curtiss, and F. Weinhold, Chem. Rev. 88, 899-926 (1988).

L. Pauling, "The Nature of the Chemical Bond", (Cornell University Press, 3rd ed., 1960)