Comandos úteis para reparar o linux

Comandos úteis para reparar o linux: "Repair:dpkg --configure -a
Reconfigure:dpkg-reconfigure pkg (-a)
Fix:apt-get -f install (pkg)
Nuke:dpkg --force-remove-reinstreq -r pkg
Corrupt deb:rm /var/cache/apt/archives/pkg
Hack dpkg:rm /var/lib/dpkg/info/pkg*"

vibrational frequencies

vibrational frequencies: "Scaling Vibrational Frequencies


A final point concerns the accuracy obtained in vibrational frequency calculations as a function of
the theoretical method used. In many cases, the experimentally measured values will differ significantly
from those calculated theoretically. One source of discrepancy is that experimental values are often
measured in solution while calculated values refer to the
gas phase. A second source of error is the
assumption of the harmonic approximation. There is, however, also a
method-dependent difference between
calculated and experimentally measured harmonic vibrational frequencies in the gas phase. For more
economical methods such as HF or AM1, the deviations typically range around 10%. In order to account
for this systematic deviation, all vibrational frequencies can be scaled
(=multiplied with the
same value) down to fit the experimental harmonic frequencies. Radom et al. have published a list
of recommended scale factors for frequently used theoretical methods in J. Phys. Chem. 1996,
100, 16502. A small selection is:

method	scale factor	rms deviation (cm-1)
AM1	0.9532	126
PM3	0.9761	159
HF/6-31G(d)	0.8953	50
MP2(FC)/6-31G(d)	0.9427	61
QCISD(FC)/6-31G(d)	0.9537	37
BLYP/6-31G(d)	0.9945	45
B3LYP/6-31G(d)	0.9614	34

It is clear from these results that semiempirical methods such as AM1 and PM3 will, even after
scaling, not be particularly reliable in predicting vibrational spectra. Rather good results can
be obtained either from highly correlated, expensive methods such as QCISD, or from hybrid
density functional calculations such as B3LYP.

"

Using Intel Compilers for Linux with Ubuntu - Intel® Software Network

Using Intel Compilers for Linux with Ubuntu - Intel® Software Network: "

rev history:
29 April 2010: This guide also applies to Ubuntu 10.04.

rev history:
2009 November 3: added notes for Ubuntu 9.10

Note: Newer versions of this linux distribution may NOT be officially supported by Intel Compiler Professional Editions 11.1. Please see your ReleaseNotes document with your compiler to find the support Linux distributions and versions. These instructions are merely to help install the compiler, keep in mind that versions of this distribution NOT in the ReleaseNotes document are NOT tested nor supported. You are on your own here.

Introduction :


Using Intel(R) Compilers version 11.1 under Ubuntu (10.04, 9.10, 9.04, 8.04 and 8.10) Desktop and Debian Desktop

For older Ubuntu and Debian versions, see THIS ARTICLE. Make sure to use the latest Intel Compilers version 11.1. Older compilers will not be compatible with the latest Ubuntu distributions. For compatibility and supported versions always read the ReleaseNotes document for your compiler.

These notes apply to Ubuntu Desktop. Ubuntu Server was not tested but should be similar.

2 November 2009: Ubuntu 10.04 and 9.10

For users of Ubuntu 10 and 9.10, follow the instructions here. If you have 9.04 or older, skip ahead to the section titled 'Ubuntu 9.04 and Older'

BEFORE YOU INSTALL Intel(R) Fortran for Linux or Intel(R) C++ for Linux on your fresh Ubuntu Desktop installation, you will first need to install several packages to prepare the system to serve as a development platform. First, open a Terminal window and become root:
sudo bash
(type your user password)

At this point, you should have a root shell. Test this with command 'whoami' which should return "root"

Check that gcc is installed. By default. Check this with:

gcc --version

It should return "gcc (Ubuntu 4.4.1-4ubuntu8) 4.4.1 (or some newer version - as long as it returns a version you have gcc installed)

If, for some reason, you do not have gcc installed, use Synaptic Package Manager (under 'System' -> 'Administration' menus) OR use apt-get to install gcc:


apt-get install gcc


Next, install the 'build-essential' package and package g++. This is not installed by default. Again, use Synaptic Package Manager or apt-get :

apt-get install build-essential

this should also install g++, but in test this with:
g++ --version

if g++ is not found, install it:

apt-get install g++

A few other packages are required:
apt-get install rpm
apt-get install ia32-libs (this is only required on 64bit Ubuntu/Debian systems)

To use the Intel IDB graphical debugger, you will also need the Java JRE 5 or 6 installed. One way to get this is through Synaptic package manager. Open Synaptic and for sources enable Ubuntu's partner repository. Once that is done, use Synaptic to fetch the package sun-java6-jre.

We also recommend fetching the Sun JRE directly from Sun: get the latest JRE from:

http://java.com/en/download/manual.jsp

OR you can use the OpenJDK from the distribution:

apt-get install openjdk-6-jre-headless

Next, Ubuntu 9.10 Desktop does not provide libstdc++5, which is required for the Intel Compilers. You will have to get the package for libstdc++5 from an older Debian or Ubuntu distribution ( 9.04 for example ). A repository is here:

http://packages.debian.org/stable/base/libstdc++5

On this page, you will see the title "The GNU Standard C++ Library V3". Scrolling down, find the table for "Download libstdc++5".

9.10: For 32bit Ubuntu i386 libstdc++5 Installation:
For 32bit Ubuntu systems you will need to install the 32bit version of libstdc++5, that is, the "i386" package.
Select the download for the libstdc++5 package for 'i386". Pick a mirror site to begin the download. If you are using Firefox, you will be prompted if you want to "Open with GDebi Package Installer" - select OK to continue. Otherwise, save the deb package and use your favorite package manager to install. Install the i386 libstdc++ deb package. SKIP the Intel 64 Libstdc++5 (AMD64) directions below and find the section on installing the compiler after prerequisites are installed.


9.10: For Intel 64 / AMD64 (64bit Linux installation) Libstdc++5:
follow these instructions IF AND ONLY IF you have a 64bit Ubuntu installation.

Intel 64 installation: Select the download for the libstdc++5 package for "amd64". If you are using Firefox, you will be prompted if you want to "Open with GDebi Package Installer" - select OK to continue. Otherwise, save the deb package and use your favorite package manager to install. Install the amd64 libstdc++ deb package.

by default, the 64bit libstdc++.so.5 library will install in /usr/lib which is linked to /usr/lib64.

Now, you also will need the 32bit libstdc++.so.5 installed in /usr/lib32. Unfortunately, the "i386" version of the libstdc++5 package wants to install in /usr/lib which is your 64bit library directory and where you just installed the "amd64" libraries - so you DON'T want to download and install the "i386" package into the default location.
We'll need to download the 'i386' package to a temporary directory, use dpkg to extract the contents to the temp directory, then manually copy the library to /usr/lib32 and create the symbolic link:

First, download libstc++5 package for "i386" - save to disk and do NOT launch a package manger to install it. Save it in your 'Downloads' folder or /tmp (or any other scratch directory).
Using your root terminal window, cd to the directory where you have downloaded the .deb package, it should have a name similar to 'libstdc++5_3.3.6-18_i386.deb'. The exact version is not important, but make sure it is a "i386" deb package.
Extract to the local directory:

dpkg --extract libstdc++5_3.3.6-18_i386.deb ./

Notice that a 'usr/' folder was created and the package contents extracted here. Now we'll copy the library to /usr/lib32

cd usr/lib
cp libstdc++.so.5.0.7 /usr/lib32
cd /usr/lib32
ln -s libstdc++.so.5.0.7 libstdc++.so.5


9.10: Installing the Compiler Now That Prerequisities are Installed (32 and 64bit):

Once you've completed the above, extract your compiler .tgz kit, cd to the compiler installation directory, and run ./install.sh

During the installation, you WILL get a warning message 'Detected operating system Debian* (generic) is not supported', followed by
----------------------------------------------------------------- ---------------
Missing optional pre-requisite
-- operating system type is not supported.
-- system glibc or kernel version not supported or not detectable
-- binutils version not supported or not detectable
----------------------------------------------------------------- ---------------
'Would you like to perform an unsupported install of this product [yes/no] (no)?'

enter 'yes'

This will complete the installation. Keep in mind, you will get this warning from the compiler installer until such time as this particular OS and version are supported. Once installed, you can read the ReadMe notes in ...installdir.../Documentation directory which has a list of the supported Linux distributions and versions.


Debugger Notes:

Known Intel® IDB Debugger issues under Ubuntu:
1) Ubuntu 9.x versions, IA32 and Intel64 platforms:

- When loading an executable, a startup dialog may appear that should not. If this dialog, "Unable to locate source file “…/start.S – Do you like to search for it manually?” appears, click ‘No’ and continue normal debugging.

- Avoid using debug commands such as ‘next’, ‘step’ on the Console Window of the Debugger GUI since this may lead to unexpected behavior of the debugger; use the corresponding options ‘Continue’, Step Into’ etc. from the Run menu instead.

2) Ubuntu 9.10, IA32 and Intel64 platforms:

- You need to set the environment variable GDK_NATIVE_WINDOWS=1 to avoid a known bug in Eclipse delivered with Ubuntu 9.10. Add export GDK_NATIVE_WINDOWS=1
to your ~/.bashrc file or execute this command on command line:
export GDK_NATIVE_WINDOWS=1



Ubuntu 9.04 and Older:

In order to use Intel(R) Compilers ( Fortran or C++ ) under Ubuntu 9.04, 8.04 or 8.10 you will need the latest 11.0 or 10.1 version of the Intel compiler(s). Older 10.0 and 9.1 versions of the compilers may not work properly under Ubuntu 9.04, 8.04 or 8.10. Keep in mind that new versions of Ubuntu/Debian may not be OFFICIALLY supported by the Intel Compilers. Please see your ReleaseNotes document with your compiler version for a list of officially supported distributions and versions.

If you have active support for your compiler, you can download the latest Intel compiler version from
https://registrationcenter.intel.com

BEFORE YOU INSTALL Intel(R) Fortran for Linux or Intel(R) C++ for Linux on your fresh Ubuntu Desktop installation, you will first need to install several packages to prepare the system to serve as a development platform:

Check that gcc is installed. By default. Check this with:

gcc --version

By default, Ubuntu 8.04 Desktop installs gcc 4.2.3-2ubuntu7. 8.10 should have gcc 4.3.2, 9.04 gcc 4.3.3

If, for some reason, you do not have gcc installed, use Synaptic Package Manager (under 'System' -> 'Administration' menus) OR use apt-get to install gcc:


apt-get install gcc


Next, install g++. This is not installed by default. Again, use Synaptic Package Manager or apt-get to install package 'g++'

apt-get install build-essential
apt-get install g++


Next, you need to install the 32bit compatibility library libstdc++.so.5. To do this, use apt-get or Synaptic Package Manager to retrieve and install package 'libstdc++5'

apt-get install libstdc++5

This package may require installing another package as a prerequisite,
'gcc-3.3-base'

If so, go ahead and install this older gcc package.

For x86-64 architecture, you will also need a number of other packages, including package 'ia32-libs' to install the 32bit versions of libstdc++.so.5 in /usr/lib32 as well as 32bit header files in libc6-dev-i386. These notes apply to Ubuntu 9.04 but should also apply to 8.10 and 8.04

apt-get install ia32-libs
apt-get install lib32stdc++6
apt-get install libc6-dev-i386
apt-get install gcc-multilib
apt-get install g++-multilib


Finally, there is an optional package to consider: The 11.0 version of the Intel Compiler for Linux has a graphical
debugger, a new graphical interface for the IDB debugger. If you want to use this debugger, please make sure to install the Java JRE version 1.5 or greater. This can be done at anytime after the installation of the compiler. However, you will get a warning message about 'missing prerequisite' for the JRE - simply ignore that message and proceed with the installation. OR to avoid that message and enable the graphical IDE, get the latest JRE from:

http://java.com/en/download/manual.jsp

Once installation of prerequisites is complete, you are ready to start the Intel compiler(s) installation. During the installation, you may get a message 'Detected operating system Debian* (generic) is not supported', followed by
----------------------------------------------------------------- ---------------
Missing optional pre-requisite
-- operating system type is not supported.
-- system glibc or kernel version not supported or not detectable
-- binutils version not supported or not detectable
----------------------------------------------------------------- ---------------
'Would you like to perform an unsupported install of this product [yes/no] (no)?'

enter 'yes'

This will complete the installation. Keep in mind, you will get this warning from the compiler installer until such time as this particular OS and version are supported. Once installed, you can read the ReadMe notes in ...installdir.../Documentation directory which has a list of the supported Linux distributions and versions.


Using the Compiler:

The next step after installing the compiler is to set up the user environment to use the compiler and libraries. First, locate your documentation: it is installed in <installdir>/Documentation/en_US (currently, US English is the language supported in the documentation). Under this directory, read the <installdir>/Documentation/en_US/getting_started_f.pdf or getting_started_c.pdf document. Read how to use iccvars.sh or ifortvars.sh (or the .csh equivalents) to set your environment to use the compiler(s). You may wish to put the 'source ifortvars.....' command into your home startup scripts.

Next, use a browser to open <installdir>/Documentation/en_US/documentation_f.htm or documentation_c.htm which is an index to the rest of the online documents. Browse the documents to familiarize yourself with their locations and contents.

Finishing up: Usage

Once the compilers are installed, it is necessary to source the ifortvars.sh or ifortvars.csh file to properly set the user environment to use the Intel compilers. This (these) commands can be placed in a user's ~/.bashrc or other system login file (fortran 11.1.046 example shown below, bash user):

64bit compiler selection:
source /opt/intel/Compiler/11.1/046/bin/ifortvars.sh intel64

32bit compiler selection:
source /opt/intel/Compiler/11.1/046/bin/ifortvars.sh ia32

C/C++ users: substitute 'iccvars' for 'ifortvars' above.

Other versions: substitute your actual minor version for "046" above.
Also, if you are a CSH or TCSH user, use ifortvars.csh or iccvars.csh as appropriate.

Need more help? Join our User Forums:
Fortran: http://software.intel.com/en-us/forums/intel-fortran-compiler-for-linux-and-mac-os-x/
C/C++: http://software.intel.com/en-us/forums/intel-c-compiler/

"

Using GaussView

Using GaussView: "

A Practical Guide to Gaussian Calculations

(c) 2003 C. Kemnitz

Throughout this guide blue will be used to designate typed text or filenames and green text will be used to designate menu selections.

Keeping Things Organized

You will be creating several files and the chemistry programs themselves will be creating dozens of files in each directory. It is, therefore, essential to keep everything well organized so that you can find important files quickly and do not inadvertently write over or delete an important file. Create a folder on the C drive called 352, C:\Chem352 then create a subfolder within that with your first initial and last name (e.g., C:\Chem352\ckemnitz). All of your files will be kept within this folder. The files also serve as your lab notebook for this class so they must be maintained and named in an organized fashion. You may also wish to keep a notepad handy for sketching molecules and jotting down information.

At the very least, i expect that you will create a new folder for each lab. So create four new folders immediately and call them: lab1, lab2, lab3, and lab4.

Within each lab's directory you should have a descriptive file that serves as an index and laboratory notebook for that laboratory. The file should be named, for example, _lab1_notebook.doc. This naming will keep the file at the beginning of any alphabetical listing. Use any word processor to create a file that provides a brief description of the contents of that directory. In a manner that a peer could understand, describe what kind of calculations were done, for what purpose, and at what level of theory. This file should provide the reader with a key to all abbreviations used in your naming system. It lists all jobs (see below) followed by a brief description of the results [symmetry, energy (all digits), vibrational energy, key geometric features/charges]. Many of these numbers should be copied and pasted from the output files to save time and reduce the likelihood of errors. Please copy all of the digits so that there are no rounding errors. See an example of a notebook file here.

See below for recommended naming systems.

GaussView 3.0 and Gaussian 03

User Interface. GaussView is the visual interface to Gaussian 03 (which does all the serious math). GaussView allows you to build input geometries, submit geometry optimizations, and view results.

Input vs. Output Geometries. Initially you will create an 'input geometry' which is your best guess as to what the molecule looks like. You will submit that geometry to an 'optimization routine' that will adjust the bond lengths, bond angles, and dihedrals to give you an 'output geometry.' Both of these may look quite similar on the screen but it is essential that you keep them straight, thus, they are kept in different file types by the computer and can be differentiated by their file extension.

Input geometry: filename.gjf

Output geometry: filename.log, filename.out, or filename.chk

Running a Job

Running a job requires four steps: (1) planning (2) creating an input geometry (3) submitting the job (4) analyzing the output.

(1) Planning. Although each 'job' can be a single calculation, the real job to be done often consists of a series of calculations on a single molecule, usually, with the aim of finding the best geometry at the highest level of theory. Before you begin you must have an idea of the general geometric features of your chemical structure (VSEPR) and enumerate all of the possible/likely conformations for fluxional molecules. You can only determine the global minimum on a potential energy surface if you have evaluated the energy at all of the reasonable conformations. Planning also entails using names wisely. A job will have several files associated with it and you will want to keep them all straight. At a minimum, each calculation should specify the chemical name or structure, which conformation is being probed, and the level of theory used. Here are two reasonable names for the input file of the eclipsed conformation (dihedral=0) for ethane run using the AM1 level of theory.

ethane_ecl_am1.com

or ch3ch3_0_am1.com

Update your description file, _DESCRIPTIONFILE, as you plan. Of course, it should give a key to all of your abbreviations. See an example of a description file here.

(2) Creating An Input Geometry. Input geometries are created using GaussView's builder interface. You can add atoms , rings , or groups by clicking on the appropriate button. The selected element has various possible attachments (initially specified as H atoms). You can select from different bonding modes for instance, from a tetracoordinate sp3 carbon to tricoordinate sp2 carbon. The selected element with its attached hydrogen atoms will appear on the screen where you click. Clicking on one of the hydrogen atoms converts it into the 'hot' atom. Once you have all of the right atoms connected properly, you can adjust the bond lengths, bond angles, and dihedral angles by using the appropriate buttons (see table below).

Buttons for Building and Evaluating Structures
	adjust bond length and define bond type (none, single, double, triple)
	adjust bond angle
	adjust dihedral angle
	measure distances, angles, and dihedral angles
	add a hydrogen to an atom and increase its valence
	delete an atom

Mouse Controls

click and drag	direction	control
left mouse button	Left-Right	rotates around y-axis
	Up-Down	rotates around x-axis
right mouse button	Left-Right	rotates around z-axis
	Up-Down	zoom
middle mouse button	All	move

You can either build a molecule from scratch OR modify an output file. None of the modifications you make are saved until you save the .gjf or submit the job to Gaussian. At that time it is saved as an input file. It is very important that you change the filename if you used another molecule/conformation as a template otherwise your old file will be overwritten.

Note About Symmetry. Under normal conditions Gaussian will never change your symmetry point group, so if you start with ethane exactly eclipsed, Guassian will not attempt to change the dihedral angle from 0 and the optimized geometry will be eclipsed despite the fact that this is not the optimum geometry. Gaussian, however, only recognizes symmetry when it is exact. If the two bond lengths for H2O are 1.0000 and 1.0001 they will not be considered equivalent.

If symmetry is desired in the molecule select >Edit>Point Group and choose Enable Point Group Symmetry from the dialogue box (shown, right). Select the appropriate point group from the Approximate higher-order point groups drop box and click the Symmetrize button.

(3) Submitting the Job.

After an input geometry is prepared, you will need to submit it by selecting >calculate>Gaussian. GaussView is only used as interface between you and Gaussian 03. GaussView submits a job to Gaussian 03, and in some circumstances, keeps track of the job, tells you when it's done, and shows you the outcome. There are several fields that must be filled in properly for the calculation to work. The ones that we'll adjust most often are Job Type, Method, Title, and Link 0.

There are four types of jobs commonly submitted to Gaussian. Select:

>Energy: Calculates the energy at the given geometry (the molecular geometry is not altered). This is often called a 'Single Point' calculation.

>Optimization: The geometry is altered in an attempt to find a local minimum or transition state. An optimization will also give you the energy at the optimized geometry.

>Minimum: The default is to optimize to a minimum. This computation asks Gaussian to find the closest local minimum on the potential energy surface.

>Transition State: The geometry is altered in an attempt to find a transition state (a 'saddle point' on the potential energy surface). You must always start with force constants by reading them from a previous job or by computing them. Always check to make sure that the transition state that you've calculated is the one that you intend (see below).

>Frequency: The vibrational (IR) frequencies are calculated at the specified geometry. You should select 'No Raman Intensities.' NOTE: Frequency calculations are only valid when the geometry has been optimized at the same level of theory so you must open an optimized log file to begin a frequency calculation. If you know what you are doing, you can save time by asking the computation to first optimize the geometry then calculate the frequencies (>Opt+Freq).*

*Warning: The Opt+Freq results are good but subsequent calculations from the Opt+Freq log files will have extraneous keywords that will mess up future calculations. You may need to revert all keywords to the defaults when starting from an Opt+Freq geometry and re-enter all non-default selections.

Method: The 'Level of Theory' consists of a 'method' (we'll generally use Semi-Empirical AM1, Hartree-Fock, or Density Functional B3LYP) and a basis set--e.g., 6-31G(d). [Note, semi-empirical methods like AM1 have their basis set 'built in' so additional entry is not needed.] We'll talk more about interpreting this lingo in class but, for now, you'll be told what to use.

charge = 0 for neutral, 1 for +, and -1 for -.

spin multiplicity = singlet (all electrons paired), doublet for a radical (one unpaired electron), and triplet for a two unpaired electrons.

Please utilize the title field to include, at the very least, the full name of the molecule (with conformational details) and any other specifics.

The Link0 tab is optional. There are times where your professor will recommend saving a checkpoint file by clicking next to %chk= and selecting the >checkpoint file... button to save the file to a specific directory. Memory is controlled by typing an amount next to the %mem field. Some jobs, but not all of them, will run faster with more memory. For our computers 100MB is usually best.

>Submit.

When all of this information is complete, you can submit the job using the button on the bottom left. This is the first time that any information is saved. You will be prompted for a filename. Make certain that you are in the proper folder and give it an appropriate filename (as discussed earlier). This saves your input file, which should have a .gjf extension, and submits your job to Gaussian. The output file will have the same name as the input file but with a .log extension. If you'd like to edit the .gjf file as a text file before submitting it you can do so by clicking Edit.

Checking on Current Jobs. Any job, running or not, can (and should) be monitored by opening the .log file, using >file>open (see below). Unnecessary or errant jobs should be 'killed' (don't feel bad for them, they will be reborn as new jobs with happy lives). Jobs that have been submitted with the currently run session of GaussView can be killed by selecting >calculate>Current Jobs other jobs can be killed by quitting Gaussian. Some jobs take days or weeks to complete so it is important not to let them run amok.

(4) Analyzing the Output.

The output is found in the .log file. You can open an output file from GaussView by selecting >file>open and changing the job type to *.log. This will only display log files in any directory. Make sure to switch back to *.gjf when you want to view input files. You should always visually inspect the output geometry.

A job can terminate in any number of ways (listed below). To determine why a job completed you must peruse the log file as text. To view the log file select >Results>View File ...

Crash.

Sometimes there are errors or typos that cause a 'crash.' You can tell because there will be an error message in the log file, usually at the end of your log file. You should always delete these log files as soon as you know what caused the crash. If you want to keep a file but it doesn't yet contain the best geometry then change its filename to something like err_ethane_ecl_am1.log so that you don't accidentally think that the file contains an optimized geometry.

Successful Energy Calculation.

The energy is listed in Hartrees by choosing >Results>Summary.... Make sure the molecule, conformation, method, and symmetry match what you thought you were running. The absolute energy is in atomic units, often called Hartrees, and is often a large negative number (see below for conversion factor). Please round to 5 digits past the decimal. This is well beyond experimental accuracy.

Successful Geometry Optimization. There are three things you should check in an optimization log file.

(i) Visually inspect the molecule to make sure it has the structure you were interested in measuring. During optimization the molecule can move, and in some cases even changes bonding.

It may also help to see what symmetry the computer thinks your molecule is in. This is listed in >Results>Summary....

You may want to save a JPEG of the image for your lab report. To do this, find a good view of the molecule and enlarge it to occupy most of the screen. Then select >File>Save Image....

(ii) Check the convergence criteria. At the end of the log file, just before the Optimized Parameters, there should be four YESs for the four optimization criteria. Max Force, RMS Force, Max Displacement, and RMS Displacement.

(iii) Check the summary text at the end of the log file for the molecular formula, charge, multiplicity, and level of theory. Then write down (or copy/paste) the absolute energy to 5 decimal places in Hartrees.

Successful Frequency Calculation. There are two things you should check and two additional things to record when you look at a log file from a frequency calculation.

Check the Frequencies.

In GaussView select >Results>Vibrations ... to view a list of frequencies. The number of imaginary frequencies (NIMAG), represented as negative numbers here, should match the type of optimization.

NIMAG = 0 for a minimum

NIMAG = 1 for a transition state

By animating the imaginary frequency you can see that the vibrational motion represents movement along the reaction coordinate (deformation to a more stable structure).

Check the Energy.

Since frequency calculations shouldn't have changed the geometry from that optimized earlier, the energy should match that recorded for the geometry optimization.

Record the Zero-Point Vibrational Energy (ZPVE).

In the log file there will be a long list of vibrational frequencies with xyz coordinates. Look at the end of that list for Zero-point vibrational energy and write down the number.

Record the Heat Capacity (C_V).

Shortly after the ZPVE comes a table that includes total CV in cal/mol-K.

Looking at Molecular Orbitals.

It is often helpful to view molecular orbitals. The easiest way to do this is to set a checkpoint file location when you first run the calculation. Make sure your checkpoint file is saved with a recognizable filename in your directory by selecting the Link0 tab, clicking next to %chk=, and selecting the >checkpoint file... button to save the file to a specific directory. When the computation is done, make sure you open the checkpoint file (*.chk). You can look at the orbitals and their energy levels in the MO window (shown below), by selecting >Edit>MOs, clicking the visualize tab, highlighting the energy levels that you'd like to see, and clicking the update... button. Orbitals cannot be printed directly from the MO window. To print an orbital, select >Results>Surfaces in the main window. If the surface has already been visualized, as described above, it will be available for display by selecting >Show Surface from the pull down menu as shown.

Running Gaussian Batch Files.

Sometimes one job is finished before there's even time to create your next input file but when the molecules are large or the level of theory is high, the computations could take considerable time. In those cases it could be expedient to create several input files and have Gaussian run them each in sequence. The benefit of this is that you can leave the computer to finish up the work and come back the next day to check the results. This method is called running files in batch. To do this, create all of your files and save them in a convenient folder. Open Gaussian and select >Utilities>Edit Batch List select add for each input file and type in the full path and filename of your input file. [Hint: It may be easier to cut and paste this information from another location. When everything is ready, save the batch file (using >File>Save As) and exit the batch editor. If the Gaussian progress message says Ready for Batch Processing Start then you may begin processing by selecting the start button .

Describing the Results and Analyzing the Data.

Usually you want the best answer in the least time. Since optimizations and frequency calculations take a long time to complete a compromise is often struck. A low level of theory (say AM1) will be used to determine the best conformation of the molecule (the one with the lowest energy). That conformation will be re-optimized at a higher level of theory, say HF/6-31G(d) and the minimum will be confirmed using a frequency calculation. A better energy (by energy, we mean electronic energy) will be determined by a 'Single Point' energy calculation at an even higher level of theory, say B3LYP/6-31+G(d,p). The format to represent this in shorthand is:

'energy method'//'optimization method'

or, for the example above, B3LYP/6-31+G(d,p)//HF/6-31G(d)

Absolute energies are of little use. For chemically interesting numbers we need to discuss relative energies. For instance, we could assess the relative energies of ethane in the staggered versus eclipsed conformations. Both molecules must have the same formula, same charge, and must be computed at the same level of theory. Relative energies, ΔE, can be converted to chemically meaningful energies using the following conversion.

1 Hartree = 627.5 kcal/mol

When we want to discuss the enthalpy of chemical reactions, for instance, the combustion of ethane, there are several computations that will be involved. The global minimum energy must be found for each molecule and a frequency calculation must be performed. First calculate the energy of reaction,

ΔE_rxn = [E(products) - E(reactants)](627.5 kcal/mol-Hartree)

Then convert the energy to enthalpy by adding in terms for vibrational energy and heat capacity at the specified temperature (in K).

ΔH_rxn = ΔE_rxn + ΔZPVE + (ΔC_V)(T)(1 kcal/1000 cal)

So for the combustion of ethane, one would find the minimum energy geometries of ethane, O₂, H₂O, and CO₂ and run frequency calculations at that level. Then one might get a better energy for each molecule using a higher level of theory to calculate a good relative energy (ΔE_rxn ). The ZPVE and Cv corrections come from the lower level frequency calculation.

For most calculations, you cannot expect better than a 1-3 kcal/mol accuracy (semi-quantitative accuracy) but trends can often be trusted even when the numbers are only qualitative.

"

The Absolute Beginners Guide to Gaussian: "

The Absolute Beginners Guide to Gaussian

David Young

Cytoclonal Pharmaceutics Inc.

Introduction:

This is to teach the beginner how to use the Gaussian XX series of programs.
This guide is intended for use by someone who has never used the program
before.

This guide is in no way intended to be a comprehensive or advanced guide to
the Gaussian program. Also, this is not an explanation of the theory behind
the types of calculations or their strengths, weaknesses, accuracy, etc.

The term 'ab initio' in this guide refers to methods which calculate purely
from the principle of quantum mechanics with no experimental data involved.
The term 'semiempirical' refers to methods which use the general process
dictated by quantum mechanics, but simplify it to gain speed then correct for
the simplification by the use of some experimental data.

The Gaussian programs are given version numbers according to which year they
were released (i.e. Gaussian 90 is the 1990 version). Gaussian is a program
for doing ab initio and semiempirical calculations on atoms and molecules. The
program is operated by making an ASCII input file using any convenient text
editor then running the program. The results of the calculation are put in one
or more output file. Gaussian itself currently has no provisions for graphical
or interactive inputs or outputs. However, such things do exist for use with
Gaussian and can be obtained from other sources.

This guide gives the input description by showing three sample input files and
describing what they mean. A section is provided on the calculation of
vibrational frequencies followed by a brief description of outputs and lists of
the input options.

Input file for an atom:

Input files can have any name but often use the extension '.inp' or '.input'
or '.com' depending on the system. Here is a sample input file for a single
atom calculation.

$ RunGauss

#n test rohf/sto-3g pop=full GFINPUT

O sto-3g triplet

0 3

O

Line 1: '$ RunGauss' This line is always the same. Although optional on some
machines it is a good practice to use it always.

Line 2: (blank) Line 2 is blank for many calculations. It can be used to
specify a checkpoint file name or memory allocation.

Line 3: '#n test rohf/sto-3g pop=full GFINPUT' Line 3 is called the route
card. It specifies what type of calculation to do and what to calculate and
output. The line always starts with '#'. The 'n' suppresses printing of
debugging messages. The 'test' suppresses keeping a summary of the job in a
central data bank called an archive. 'rohf' is the ab initio keyword. It
stands for 'restricted open-shell Hartree Fock'. Ab initio keywords must
always be followed by a '/' and a basis set designation such as 'sto-3g'. The
'pop=full' specifies the printing of a full Mulliken population analysis. The
'GFINPUT' puts a copy of the basis set in the output file.

Line 4 is blank.

Line 5: 'O sto-3g triplet' Line 5 is a comment for the users reference only.

Line 6 is blank.

Line 7: '0 3' Line 7 consists of two numbers. The first is the charge and
the second is the spin multiplicity.

Line 8: 'O' Line 8 specifies that oxygen is the atom to be calculated.

Line 9: Leave at least one extra blank line at the end of the input file.

Input example for a diatomic molecule:

Here is a sample input for a diatomic molecule

$ RunGauss

# test rhf/STO-3G opt

CO sto-3g

0 1

C

O 1 R

R 0.955

Only significant differences from the atom input file will be mentioned.

Line 3: '# test rhf/STO-3G opt' The 'rhf' stands for 'restricted Hartree
Fock'. The 'opt' specifies that the program is to find the correct geometry
for the molecule, as predicted by the specified ab initio method and basis set
(in this case the bond distance).

Lines 8-11 are called the Z-matrix. These lines specify the geometry of the
molecule and which parameters are to be optimized if an 'opt' keyword is on the
route card.

Line 8: 'C' This specifies that the first atom is a carbon atom.

Line 9: 'O 1 R' specifies that an oxygen atom is at a distance R from the
first atom (the carbon). R is defined (in Angstroms) on line 11. If an
optimization is being done, a new value for R representing the most stable
geometry will be given in the output file.

Input file for a polyatomic molecule:

Here is an input file for a formaldehyde molecule.

$RunGauss

# test MNDO pop=reg

Formaldehyde single point w/ populations

0 1

C

O 1 OC

H 1 HC 2 A

H 1 HC 2 A 3 180.0

OC 1.2

HC 1.08

A 120.0

Line 3: '# test MNDO pop=reg' The ab initio method and basis have been
replaced by a semiempirical method keyword 'MNDO'. The 'pop=reg' specifies a
Mulliken population analysis, but not as much information printed as with
'pop=full'.

Line 5: 'Formaldehyde single point w/ populations' Note that a calculation,
which is not a geometry optimization is referred to as a single point
calculation.

Line 8: 'C' The first atom is a carbon.

Line 9: 'O 1 OC' The second atom is an oxygen with a distance to the first
atom of OC.

Line 10: 'H 1 HC 2 A' The third atom is a hydrogen with a distance to the
first atom of HC and an angle between the third, first and second atoms of A
(in degrees).

Line 11: 'H 1 HC 2 A 3 180.0' The fourth atom is a hydrogen with a distance
to the first atom of HC and an angle between the third, first and second atoms
of A. The dihedral angle between the first, second, third and fourth atoms is
180 degrees (a planar molecule).

If an optimization were being done, the parameters OC, HC and A would be
optimized, but the molecule would be kept planar. Note that parameters can be
used more than once.

Additional atoms are added by adding lines like line 11 consisting of
distance, angle and dihedral angle specifications.

Gaussian does have provisions for entering geometries as x, y, z Cartesian
coordinates.

Geometry specifications sometimes uses points not on atomic centers out of
convenience or necessity. These are called dummy atoms. These will not be
covered in this guide.

Calculating frequencies:

Gaussian can calculate vibrational modes along with their frequencies and
force constants, using the 'FREQ' keyword. These calculations are only
meaningful if the molecule is at its equilibrium geometry for the given level
of theory. Also, geometry optimizations and frequency calculations cannot be
done in the same job. Therefore, to get a frequency calculation, first a
geometry optimization should be done then the optimized geometry must be used
to run a frequency calculation.

The output file:

At least one output file is always produced. It can have any filename, but
many systems are set up to use extensions '.lis' or '.out'. This is an ASCII
file which contains most of the results of the calculation, such as energies,
geometries, frequencies and population analysis. Many things are put in this
file that the user often ignores on any given calculation.

Checkpoint files:

When a subsequent calculation is to use results from a previous
calculation as
its inputs, these results can be kept in a special file to avoid having to type
them into the new input file. Many such result are put in a file called a
checkpoint file. It is a binary file. The use of a checkpoint file can be
specified using the correct options on line 2 and the route card.

Cube files:

Properties, such as electron density or spin density can be calculated for a
regular grid of points in space and saved as a cube file. This is a file with
both binary and ASCII formats, which is often used as an input for other
graphical visualization programs.

Cube file generation is prompted by usage of the 'CubeDensity' keyword and
specification of a grid of points.

Other files:

Gaussian has many other optional input and output files. Often these are
accessed as standard FORTRAN units according to the conventions of the specific
operating system being used.

List of ab initio keywords:

Note that an ab initio keyword must be accompanied by a basis set keyword in
the format 'ab_initio/basis'. All of these can be prefaced by R for
closed-shell restricted wave functions, U for unrestricted open-shell
wavefunctions or RO for restricted open-shell wavefunctions. This list is
provided for the sake of seeing what is available. Many of these have
additional options describing how to control the calculation which are listed
in the Gaussian User's Guide and Programmer's Reference.

HF - Hartree Fock (uses RHF for singlets and UHF for others)

RHF - restricted Hartree Fock

UHF - unrestricted Hartree Fock

ROHF - spin-restricted open-shell Hartree Fock

OSS - two open shell singlet wave function

GVB - generalized valence bond

CASSCF - complete active space MCSCF

MP2 - Moller-Plesset second order correlation energy correction

MP3 - Moller-Plesset third order correlation energy correction

MP4 - same as MP4SDTQ

MP4DQ - Moller-Plesset fourth order correlation energy correction with double
and quadruple substitutions.

MP4SDQ - Moller-Plesset fourth order correlation energy correction with single,
double and quadruple substitutions.

MP4SDTQ - Moller-Plesset fourth order correlation energy correction with single,
double, triple and quaduple substitutions.

CI - same as CISD

CIS - configuration interaction with single excitations

CID - configuration interaction with double excitations

CISD - configuration interaction with single and double excitations

QCISD - quadratic configuration interaction with single and double excitations

QCISD(T) - quadratic configuration interaction with single and double excitations
and triples contribution to the energy

List of basis sets available:

Note that a basis set must accompany an ab initio keyword. The '*' and '**'
indicate polarization functions (i.e. 6-31G**). The '+' and '++' indicate
diffuse functions. For other options and how to use these options, see the
Gaussian User's Guide and Programmer's Reference.

Basis sets available

basis	options	atoms
STO-3G	*	H - Xe
3-21G	* **	H - Cl
4-21G	* **
4-31G	* **	H - Ne
6-21G	* **
6-31G	+ ++ * **	H - Cl
LP-31G	* **
LP-41G	* **
6-311G	+ ++ * **	H - Ar
MC-311G	none	H - Ar
D95	+ ++ * **	H - Cl
D95V	+ ++ * **	H - Ne
SEC	+ ++ * **	H - Cl (same as SHC)
CEP-4G	+ ++ * **	H - Cl
CEP-31G	+ ++ * **	H - Cl
CEP-121G	+ ++ * **	H - Cl
LANLIMB	none	H - Bi (except lanthanides)
LANLIDZ	none	H - Bi (except lanthanides)

The GEN keyword allows the basis set to be read from the input file.

List of semiempirical keywords:

Note that semiempirical methods do not require a separate basis set. All of
these can be prefaced by R for closed-shell restricted wavefunctions, U for
unrestricted open-shell wavefunctions or RO for restricted open-shell
wavefunctions. This list is provided for the sake of seeing what is available.
Many of these have additional options describing how to control the calculation
which are listed in the Gaussian User's Guide and Programmer's Reference.

AM1 - Austin method one

CNDO - complete neglect of differential overlap

INDO - intermediate neglect of differential overlap

MINDO3 - modified intermediate neglect of differential overlap third
modification.

MNDO - modified neglect of differential overlap

List of keywords:

This is the list of what to calculate and what to print and how to manage the
calculation. This is not a comprehensive list. This list is provided for the
sake of seeing what is available. For other options and how to use these
options, see the Gaussian User's Guide and Programmer's Reference.

ANG - distances in Angstroms

AU - distances in bohrs

DEG - angles in degrees

RAD - angles in radians

CubeDensity - generate a cube file

Density - for cube file generation

direct - do integrals as needed (vice in a file on the disk)

InCore - do integrals in core memory

field - add a finite field to the calculation

freq - frequency determination

freq=noraman - frequency determination without Raman intensities

GFPRINT - put basis in output file

GFINPUT - put basis in output file in format for generalized input

IRC - follow a reaction path

LST - linear synchronous transit

NoFreeze - optimize all variables

opt - geometry optimization

Polar - calculate polarizability and hyperpolarizability, if possible

pop=none - no population analysis

pop=min - minimal printing of Mulliken population analysis

pop=reg - some printing of Mulliken population analysis

pop=full - full printing of Mulliken population analysis

pop=bonding - bonding population analysis

pop=no - natural orbital analysis

pop=noab - natural orbital analysis for separate alpha and beta spins

prop=grid - computes electrostatic potential

prop=field - computes electrostatic potential and field

prop=EFG - computes electrostatic potential, field and field gradients

punch - puts various information in a separate output file

ReadIsotopes - read in masses for each atom

Restart - restart optimization from a checkpoint file

TS - optimization of a transition state

An expanded version of this article will be published in
"Computational Chemistry: A Practical Guide for Applying Techniques
to Real World Problems" by David Young, which will be available from
John Wiley & Sons in the spring of 2001.

"

Hands-on: Samsung Galaxy Tab

Hands-on: Samsung Galaxy Tab: "

E assim que acabou a coletiva da Samsung aqui na IFA 2010, corri pro estande (que está mais para um… pavilhão inteiro) da Samsung para ver o Galaxy Tab, o simpático tablet de 7″ com Android 2.2. Se o iPad é um iPhone gigante, o Galaxy Tab é o irmão sarado do Galaxy S. Muitas fotos na sequência.

Na mão, o Galaxy Tab mostra potencial para os tablets com Android. Conectividade (3G + Wi-Fi) e capacidade de fazer ligações (algo que o iPad 3G ainda deixa de fora) tornam o tablet da Samsung uma central de comunicações. A tela é um pouco mais “dura” se comparar com o modo de deslize do iPad, e tem multitoque.

Estou curioso para ver qual será a resposta da LG nessa área, já que rumores de um tablet também com Android já circulam faz algum tempo (incluindo o mercado brasileiro).

Update: mais fotos dele lado a lado com o Galaxy S e com a câmera em funcionamento.

Hands-on: Samsung Galaxy Tab foi publicado no Zumo Blog: Tecnologia. Opinião. Inteligência.. Siga a gente no Twitter

"