mpqc - En ligne dans le Cloud

PROGRAMME:

Nom

mpqc - Le programme de chimie quantique massivement parallèle (MPQC)

SYNOPSIS

mpqc [Options] [nom de fichier]

DESCRIPTION

MPQC calcule les propriétés des molécules, ab initio, sur une grande variété d'ordinateurs
architectures.

Il peut calculer les énergies HartreeFock à coquille fermée et à coquille ouverte restreinte générale et
gradients, théorie des perturbations openshell du second ordre (OPT2[2]) et perturbation Zaveraged
théorie des énergies (ZAPT2) et théorie des perturbations de MoellerPlesset à coque fermée du second ordre
énergies et gradients. Il comprend également des méthodes d'optimisation des molécules dans les deux
Coordonnées cartésiennes ou internes.

MPQC est conçu à l'aide de techniques de programmation orientées objet et implémenté en C++
langage de programmation.

OPTIONS

MPQC peut recevoir des options suivies d'un nom de fichier d'entrée facultatif. Si le nom du fichier d'entrée
n'est pas donné, il sera par défaut 'mpqc.in'. Les options de ligne de commande suivantes sont
reconnu:

-o Donne le nom du fichier de sortie. La valeur par défaut est la console.

-i Convertir un simple fichier d'entrée en un fichier d'entrée orienté objet et écrire le résultat
à la sortie. Aucun calcul n'est fait.

-messagegrp
A ParsedKeyVal spécification d'un Groupe de messages objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé.

-groupe de mémoire
A ParsedKeyVal spécification d'un Groupe Mémoire objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé.

-threadgrp
A ParsedKeyVal spécification d'un FilGrp objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé.

-l Définit une limite sur le nombre de fonctions de base. La valeur par défaut est zéro, ce qui signifie qu'un
nombre illimité de fonctions de base.

-W Définit le répertoire de travail. La valeur par défaut est le répertoire actuel.

-c Vérifiez l'entrée et la sortie.

-v Imprimez le numéro de version.

-w Imprimez les informations de garantie (il n'y a pas de garantie).

-d Si un objet débogueur a été fourni en entrée, lancez le débogueur dès que
MPQC est démarré.

-h Imprimez une liste d'options.

-f Le nom d'un fichier d'entrée orienté objet. La valeur par défaut est mpqc.in. Ça ne peut pas être
utilisé si un autre fichier d'entrée est spécifié. Cette option est dépréciée, car les deux entrées
les formats de fichier peuvent être lus en donnant le nom du fichier d'entrée sur la ligne de commande sans
tous les drapeaux d'option.

Certains environnements MPI ne transmettent pas la ligne de commande aux programmes esclaves, mais la fournissent lorsque
MPI_Init est appelé. Pour que MPQC appelle MPI_Init au démarrage, au lieu de quand un
MPIMessageGrpMPIMessageGrp est créé, nommez l'exécutable mpqc-mpi.

ENVIRONNEMENT VARIABLES

MPQC examine quatre variables environnementales pour configurer la communication et rechercher les fichiers de bibliothèque.
Les bibliothèques et utilitaires spécifiques à la machine pour exécuter des programmes en parallèle peuvent regarder d'autres
variables d'environnement aussi. Les quatre qui s'appliquent sur toutes les plateformes sont :

SCLIBDIR
Le nom du répertoire de la bibliothèque.

MESSAGEGRP
A ParsedKeyVal spécification d'un Groupe de messages objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé. Voir le Groupe de messages documentation de classe pour plus d'informations.

MÉMOIREGRP
A ParsedKeyVal spécification d'un Groupe Mémoire objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé et le Groupe de messages utilisé.

FILETAGERP
A ParsedKeyVal spécification d'un FilGrp objet. La valeur par défaut dépend de la façon dont
MPQC a été compilé.

Par défaut, MPQC essaie de trouver d'abord les fichiers de bibliothèque dans le sous-répertoire lib du
répertoire d'installation puis le répertoire du code source. Si les fichiers de bibliothèque ne peuvent pas être
trouvé, MPQC doit être informé du nouvel emplacement avec la variable d'environnement SCLIBDIR.

Les trois autres mots-clés spécifient des objets. Cela se fait en donnant un mini ParsedKeyVal contribution
dans une chaîne. L'objet est anonyme, c'est-à-dire qu'aucun mot-clé ne lui est associé. Voici
un exemple:

setenv MESSAGEGRP 'ShmMessageGrp>:(n = 4)'

PARTAGÉ MÉMOIRE MULTIPROCESSEUR avec SYSV IPC

Par défaut, MPQC s'exécutera sur un seul processeur. Pour préciser davantage, vous pouvez donner un ShmMessageGrp
objet sur la ligne de commande. Ce qui suit exécuterait mpqc dans quatre processus :

mpqc -messagegrp 'ShmMessageGrp>:(n = 4)' fichier_entrée

Alternativement, le ShmMessageGrp object peut être donné comme variable d'environnement :

setenv MESSAGEGRP 'ShmMessageGrp>:(n = 4)'
fichier_entrée mpqc

Si MPQC devait mourir de manière inattendue, des segments de mémoire partagée et des sémaphores seront laissés sur le
machine. Ceux-ci doivent être rapidement nettoyés ou d'autres tâches peuvent être empêchées de s'exécuter
avec succès. Pour voir si l'une de ces ressources vous est allouée, utilisez la commande ipcs.
La sortie ressemblera à quelque chose comme:

Statut IPC de /dev/kmem au mercredi 13 mars 14:42:18 1996
T ID KEY MODE GROUPE DE PROPRIÉTAIRES
Files d'attente de messages :
La memoire partagée:
m 288800 0x00000000 --rw------- utilisateur cljanss
Sémaphores :
s 390 0x00000000 --ra------- utilisateur cljanss
s 391 0x00000000 --ra------- utilisateur cljanss

Pour supprimer les ressources IPC utilisées par cljanss dans l'exemple ci-dessus sur IRIX, tapez :

ipcrm-m 288800
ipcrm-s 390
ipcrm-s 391

Et sous Linux, tapez :

ipcrm shm 288800
ipcrm sem 390
ipcrm sem 391

PARTAGÉ MÉMOIRE MULTIPROCESSEUR avec POSIX FILS

Par défaut, MPQC s'exécutera avec un seul thread. Pour préciser davantage, vous pouvez donner un
PthreadThreadGrp objet sur la ligne de commande. MPQC n'est pas parallélisé à un aussi grand
étendue avec les threads comme c'est le cas avec le modèle de mémoire distribuée plus conventionnel, donc vous
pourrait ne pas obtenir les meilleures performances en utilisant cette technique. D'autre part la surcharge mémoire
est plus faible et aucune communication interprocessus n'est nécessaire.

Ce qui suit exécuterait MPQC dans quatre threads :

mpqc -threadgrp 'PthreadThreadGrp>:(num_threads = 4)' input_file

Alternativement, le PthreadThreadGrp object peut être donné comme variable d'environnement :

setenv THREADGRP 'PthreadThreadGrp>:(n = 4)'
fichier_entrée mpqc

PARTAGÉ OR DISTRIBUÉ MÉMOIRE MULTIPROCESSEUR avec Propriétés Mitelman

A MPIMessageGrpMPIMessageGrp L'objet est utilisé pour s'exécuter à l'aide de MPI. Le nombre de nœuds utilisés est déterminé par
le temps d'exécution MPI et n'est pas spécifié comme données d'entrée pour MPIMessageGrpMPIMessageGrp.

mpqc -messagegrp 'MPIMessageGrpMPIMessageGrp>:()' fichier_entrée

Alternativement, le MPIMessageGrpMPIMessageGrp object peut être donné comme variable d'environnement :

setenv MESSAGEGRP 'MPIMessageGrpMPIMessageGrp>:()'
fichier_entrée mpqc

Généralement, une commande spéciale est nécessaire pour démarrer les travaux MPI ; généralement, il est nommé mpirun.

CONTRIBUTION

MPQC prend en charge deux formats d'entrée. L'entrée principale est un format orienté objet qui
donne aux utilisateurs l'accès à toutes les options MPQC. Le second format permet d'accéder à un sous-ensemble de
MPQCs, mais est plus intuitif et plus facile à apprendre. Les nouveaux utilisateurs sont invités à
commencer par le format simplifié. MPQC peut être utilisé pour convertir le format simplifié au format
format entièrement orienté objet avec l'option -i.

Simple Entrée

Le format d'entrée simple se compose de mots-clés suivis d'un ':' suivi d'une valeur. Les
les mots-clés sont sensibles à la casse. Les valeurs peuvent être modifiées par les options trouvées entre parenthèses.
Par exemple, l'entrée suivante effectue une optimisation de l'eau en utilisant la densité
théorie fonctionnelle avec la fonctionnelle d'échange-corrélation B3LYP :

% B3LYP optimisation de l'eau
optimiser : oui
méthode : KS (xc = B3LYP)
base : 3-21G*
molécule:
O 0.172 0.000 0.000
0.745 0.000 0.754
H 0.745 0.000 -0.754

Les commentaires commencent par un % et se poursuivent jusqu'à la fin de la ligne. Noms d'ensembles de base contenant
les caractères spéciaux, tels qu'un espace ou des parenthèses, doivent être entre guillemets à l'intérieur d'une paire de doubles
devis. Les mots-clés acceptés sont :

molécule
Donne les types et coordonnées des atomes. Les options suivantes peuvent être utilisées

bohème
Les coordonnées sont données en Bohr.

angstrom
Les coordonnées sont données en Angstroms.

charge
Cette option peut être donnée après un quadruple « élément xyz ». Cela remplacera le
charge sur l'atome. Par exemple, (charge = 0) peut être donné pour les atomes fantômes dans un
calcul de correction de contrepoids.

multiplicité
Donne la multiplicité de la molécule. La valeur par défaut est 1.

optimiser
Si oui, alors une optimisation sera effectuée. La valeur par défaut est non. Ce qui suit
des options peuvent être données.

cartésien
Utilisez les coordonnées cartésiennes.

interne
Utilisez les coordonnées internes.

redondant
Utilisez des coordonnées internes redondantes.

pente
Si oui, alors un calcul de gradient sera effectué. La valeur par défaut est non.

fréquences
Si oui, alors les fréquences seront obtenues. La valeur par défaut est non.

charge
Spécifie la charge sur la molécule. La valeur par défaut est 0.

méthode
Spécifie la méthode. Il n'y a pas de valeur par défaut et les valeurs possibles sont :

HF
Hartree-Fock. HF non restreint est utilisé si multiplicité > 1

FRH
Hartree-Fock restreint.

UHF
Hartree-Fock sans restriction.

KS
Kohn-Sham. KS non restreint est utilisé si multiplicité > 1

RKS
Kohn-Sham restreint.

Royaume-Uni
Kohn-Sham sans restriction.

MP2
Théorie des perturbations de Moeller-Plesset du second ordre. Uniquement disponible pour la multiplicité =
1.

ZAPT2
Théorie des perturbations à moyenne Z. Uniquement disponible pour multiplicité > 1. Pas de dégradé,
une optimisation ou des fréquences sont possibles.

Les options suivantes sont valides avec les méthodes KS, RKS et UKS :

grille
Spécifie la grille à utiliser pour les intégrations numériques. Les valeurs suivantes peuvent être
étant donné:

xgrossier

grossier

moyenne

fin

xbien

ultrafine

xc
Spécifie la fonction de corrélation d'échange. Il n'y a pas de défaut. Voir le tableau dans
le StdDenFonctionnel documentation de classe pour les valeurs possibles.

base
Spécifie l'ensemble de base. Il n'y a pas de défaut. Voir le tableau dans le GaussianBasisSet
documentation de classe pour les ensembles de base disponibles.

recommencer
Définissez sur yes pour redémarrer une optimisation. La valeur par défaut est non.

point de contrôle
Définissez sur no pour ne pas enregistrer les fichiers de point de contrôle lors d'une optimisation. La valeur par défaut est oui.

symétrie
Spécifie le symbole Schoenflies du groupe ponctuel de la molécule. La valeur par défaut est
auto, ce qui amènera le programme à trouver le sous-groupe abélien d'ordre le plus élevé du
molécule.

doc
Donne le nombre d'orbitales doublement occupées dans chaque représentation irréductible
dans une liste entre parenthèses. La symétrie doit être spécifiée et non automatique. La méthode
doit être restreint.

soc
Donne le nombre d'orbitales occupées simples dans chaque représentation irréductible
dans une liste entre parenthèses. La symétrie doit être spécifiée et non automatique. La méthode
doit être restreint.

Alpha
Donne le nombre d'orbitales occupées alpha dans chaque représentation irréductible
dans une liste entre parenthèses. La symétrie doit être spécifiée et non automatique. La méthode
doit être illimité.

bêta
Donne le nombre d'orbitales occupées bêta dans chaque représentation irréductible dans
une liste entre parenthèses. La symétrie doit être spécifiée et non automatique. La méthode doit
être sans restriction.

gelé_docc
Donne le nombre d'orbitales de noyau gelées. Il peut s'agir d'un seul entier ou d'un
liste entre parenthèses donnant les orbitales de noyau gelées dans chaque représentation irréductible.
Dans ce dernier cas la symétrie doit être donnée et non automatique.

congelé_uocc
Donne le nombre d'orbitales virtuelles gelées. Il peut s'agir d'un seul entier ou d'un
liste entre parenthèses donnant les orbitales virtuelles figées dans chaque irréductible
représentation. Dans ce dernier cas la symétrie doit être donnée et non automatique.

Orienté objet Entrée

MPQC est un programme orienté objet qui permet directement à l'utilisateur de spécifier des objets qui
MPQC manipule ensuite pour obtenir des énergies, des propriétés, etc. Cela rend l'entrée très
flexible, mais très complexe. Cependant, la plupart des calculs devraient être assez similaires à celui
des exemples donnés plus loin dans ce chapitre. La meilleure façon de commencer est d'utiliser l'un des
les exemples de fichiers d'entrée et modifiez-les pour répondre à vos besoins.

MPQC commence par créer un ParsedKeyVal objet qui analyse le fichier d'entrée spécifié sur
la ligne de commande. Le format du fichier d'entrée est documenté dans . C'est fondamentalement un libre
entrée de format qui associe des mots-clés et des regroupements logiques de mots-clés avec des valeurs. Les
les valeurs peuvent être des scalaires, des tableaux ou des objets.

Les mots-clés reconnus par MPQC commencent par le préfixe mpqc. C'est-à-dire qu'ils doivent être imbriqués
entre un mpqc:( et un ). Alternativement, chaque mot-clé peut être individuellement préfixé par
mpqc :. Les mots-clés principaux sont donnés ci-dessous. Certains des mots-clés spécifient des objets, dans
auquel cas l'objet nécessitera plus ParsedKeyVal saisir. Ces objets sont créés à partir de
l'entrée en utilisant leur ParsedKeyVal constructeurs. Ces constructeurs sont documentés avec
la documentation du code source de la classe.

taupe
C'est le mot-clé le plus important pour MPQC. Il précise le MoléculaireÉnergie objet.
C'est un objet qui sait calculer l'énergie d'une molécule. Les
spécialisations de MoléculaireÉnergie qui sont les plus couramment utilisés sont CLKS, HSOSKS, UKS,
CLHF, HSOSHF, UHF et MBPT2.

opter
Ce mot-clé doit être spécifié pour les optimisations. Il précise un Optimiser objet.
Habituellement, QNewtonOpt est le mieux pour trouver des minima et EFCOpt est le meilleur pour la transition
États.

fréq
Ce mot-clé doit être spécifié pour calculer les fréquences. Il précise un
Fréquences moléculaires objet.

fil
Ceci spécifie un objet de type FilGrp qui peut être utilisé à profit sur
machines multiprocesseurs à mémoire partagée pour certains types de calculs. Ce mot-clé
peut être annulé en donnant FilGrp dans l'environnement ou la ligne de commande. Voir le
section sur l'exécution de MPQC pour plus d'informations.

point de contrôle
La valeur de ce mot-clé est booléenne. Si vrai, alors les optimisations seront
vérifié après chaque itération. Le fichier de point de contrôle suffisant est .ckpt. Le défaut
est au point de contrôle.

état de sauvegarde
La valeur de ce mot-clé est booléenne. Si vrai, alors les états de l'optimiseur et
les objets de fonction d'onde seront enregistrés une fois le calcul terminé. Le fichier de sortie
le suffixe est .wfn. La valeur par défaut est d'enregistrer l'état.

recommencer
La valeur de ce mot-clé est booléenne. Si vrai, mpqc tentera de redémarrer le
calcul. Si le fichier de point de contrôle n'est pas trouvé, le calcul continuera comme si
la valeur était fausse. La valeur par défaut est true.

fichier_redémarrage
Cela donne le nom d'un fichier à partir duquel les informations de redémarrage sont lues. Si le fichier
le nom se termine par .wfn le MoléculaireÉnergie l'objet sera restauré. Sinon, le Optimiser
l'objet sera restauré. Le nom de fichier par défaut est formé en ajoutant .ckpt au
nom du fichier d'entrée avec l'extension supprimée.

faire_énergie
La valeur de ce mot-clé est booléenne. Si vrai, un calcul d'énergie en un seul point sera
être fait pour le MoléculaireÉnergie objet donné avec le mot-clé taupe. La valeur par défaut est
vrai.

faire_gradient
La valeur de ce mot-clé est booléenne. Si vrai, un calcul de gradient à un seul point
sera fait pour le MoléculaireÉnergie objet donné avec le mot-clé taupe. Le défaut
c'est faux.

optimiser
La valeur de ce mot-clé est booléenne. Si vrai et que le mot-clé opt a été défini sur une valeur valide
valeur, une optimisation sera effectuée. La valeur par défaut est true.

écriture_pdb
La valeur de ce mot-clé est booléenne. Si vrai un fichier PDB avec le moléculaire
les coordonnées seront écrites.

nom de fichier
La valeur de ce mot-clé est une chaîne qui donne un nom à partir duquel point de contrôle et
d'autres noms de fichiers sont construits. La valeur par défaut est le nom de base du fichier d'entrée.

print_timings
Si cela est vrai, les informations de chronométrage sont imprimées à la fin de l'analyse. La valeur par défaut est
vrai.

Il existe également des mots-clés utilitaires qui indiquent à mpqc des détails techniques sur la manière de procéder.
le calcul:

déboguer
Ce mot-clé facultatif donne un Debugger objet qui peut être utilisé pour aider à trouver le problème
si MPQC rencontre une erreur catastrophique.

kit de matrice
Ce mot-clé facultatif donne un SCMatrixKit spécialisation qui sert à produire
matrices du type souhaité. La valeur par défaut est un ReplSCMatrixKit qui réplique
matrices sur tous les nœuds. Les autres choix ne sont pas complètement testés.

EXEMPLES

Cet exemple d'entrée effectue un calcul Hartree-Fock sur l'eau. Voici l'intégralité
entrée, suivie d'une ventilation avec des descriptions.

% Cette entrée effectue un calcul Hartree-Fock sur l'eau.
moléculeMolécule>: (
symétrie = C2V
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
MôleCLHF>: (
molécule = $:molécule
base = $:base
)
)

Nous commençons par un commentaire descriptif. Les commentaires commencent par un %. Tout du % au
la fin de la ligne est ignorée.

% Cette entrée effectue un calcul Hartree-Fock sur l'eau.

Maintenant, mettons en place un Molécule objet. Le nom de l'objet vient en premier, c'est la molécule.
Ensuite, entre parenthèses angulaires, vient le type de la molécule, qui est la classe MoléculeL’
le mot-clé et le nom de la classe sont suivis d'un : puis de plusieurs éléments d'entrée regroupés
entre une paire de parenthèses correspondantes. Ces parenthèses contiennent les informations qui
sera donné à Molécule ValClé constructeur.

moléculeMolécule>: (

Le groupe ponctuel de la molécule est nécessaire. Ceci est fait en attribuant une symétrie à un cas
symbole Schoenflies insensible qui est utilisé pour initialiser un Groupe de points objet. un abélien
groupe de points doit être utilisé.

symétrie = C2V

L'unité par défaut pour les coordonnées cartésiennes est Bohr. Vous pouvez spécifier d'autres unités en
unité assignée à une chaîne qui sera utilisée pour initialiser un Unités objet.

unité = angström

Enfin, les atomes et les coordonnées sont donnés. Cela peut être donné dans le tableau des raccourcis
syntaxe ci-dessous. Les en-têtes du tableau sont les mots-clés entre la première paire de
supports. Ceux-ci sont suivis d'un = et d'une autre paire de crochets contenant les données.
La première donnée est affectée au premier élément du tableau qui correspond à la
premier titre, atome. La deuxième donnée est affectée au premier élément du tableau
associé au deuxième titre, à la géométrie, etc. Ici, la deuxième donnée est en fait
un vecteur : les coordonnées x, y et z du premier atome.

{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)

Ensuite, un objet d'ensemble de base est donné.

baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)

Maintenant, nous allons donner le corps principal de l'entrée. Tous les mots-clés suivants seront regroupés dans
la section mpqc de l'entrée (c'est-à-dire que chaque mot-clé sera préfixé par mpqc:).

mpqc : (

Ensuite, nous donnons le mot-clé mole qui fournit une spécialisation de la MoléculaireÉnergie
classer. Dans ce cas, nous allons faire un calcul Hartree-Fock en coquille fermée. C'est fait avec
un objet de type CLHF. Les mots-clés qui CLHF accepte sont donnés avec la documentation
pour CLHF classe, généralement dans la description du constructeur const RefKeyVal& pour le
classer. Aussi avec le CLHF la documentation est une liste de classes parentes. Chacun des parents
les classes peuvent également avoir une entrée. Cette entrée est incluse avec le reste de l'entrée pour le
classe enfant.

MôleCLHF>: (

La ligne suivante spécifie la molécule à utiliser. Il y a deux choses à noter, d'abord que
il s'agit en fait d'une référence à la spécification complète de la molécule ailleurs dans l'entrée
déposer. Le $ indique qu'il s'agit d'une référence et le mot-clé suivant le $ est le
emplacement réel de la molécule. Le : devant le mot-clé signifie que le mot-clé est
pas par rapport à l'emplacement actuel dans l'entrée, mais plutôt par rapport à la racine du
arbre de mots-clés. Ainsi, cette ligne saisit la molécule qui a été spécifiée ci-dessus. Les
objet molécule aurait pu être placé ici, mais fréquemment il est nécessaire que plusieurs
les objets se réfèrent exactement au même objet et cela ne peut être fait qu'à l'aide de références.

Le deuxième point est que si vous regardez la documentation de CLHF, vous verrez qu'il
ne lit pas le mot-clé molécule. Cependant, si vous suivez ses classes parentes jusqu'à
MoléculaireÉnergie, vous constaterez que la molécule est bien lue.

molécule = $:molécule

Tout comme nous avons donné la molécule, spécifiez l'ensemble de base avec le mot-clé de base comme suit :

base = $:base

Maintenant, nous fermons les parenthèses que nous avons ouvertes ci-dessus et nous avons terminé.

)
)

Échantillon Orienté objet Entrée Fichiers

Le moyen le plus simple de démarrer avec mpqc est de commencer avec l'un des exemples d'entrées les plus
correspond presque à votre problème. Tous les exemples d'entrées montrés ici peuvent être trouvés dans le
répertoire src/bin/mpqc/samples.

Fléchette Hartree Énergie
L'entrée suivante calculera l'énergie Hartree-Fock de l'eau.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C2V
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
mémoire = 16000000
)
)

MP2 Énergie
L'entrée suivante calculera l'énergie MP2 de l'eau.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C2V
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% méthode de calcul de l'énergie de la molécule
MôleMBPT2>: (
molécule = $:molécule
base = $:base
mémoire = 16000000
% fonction d'onde de référence
référenceCLHF>: (
molécule = $:molécule
base = $:base
mémoire = 16000000
)
)
)

Fléchette Hartree Optimization
L'entrée suivante optimisera la géométrie de l'eau en utilisant la méthode quasi-Newton.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C2V
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '6-31G*'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
)
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
)
% objet optimiseur pour la géométrie moléculaire
opterQNewtonOpt>: (
fonction = $..:mole
mettre à jourMise à jour BFGS> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Optimization avec a Calculé Guess Toile de jute
L'entrée suivante optimisera la géométrie de l'eau en utilisant la méthode quasi-Newton. Les
supposer que Hessian sera calculé à un niveau théorique inférieur.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C2V
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '6-31G*'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
)
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
deviner_hessianFinDispMoléculaireHesse>: (
molécule = $:molécule
only_totally_symmetric = oui
remove_cubic_terms = non
point de contrôle = non
énergieCLHF>: (
molécule = $:molécule
mémoire = 16000000
baseGaussianBasisSet>: (
nom = '3-21G'
molécule = $:molécule
)
)
)
)
% objet optimiseur pour la géométrie moléculaire
opterQNewtonOpt>: (
fonction = $..:mole
mettre à jourMise à jour BFGS> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Optimization En utilisant de Newton Méthode
L'entrée suivante optimisera la géométrie de l'eau en utilisant la méthode de Newton. Les
Hessian sera calculé à chaque étape de l'optimisation. Cependant, le recalcul de Hesse
ne vaut généralement pas le coût; essayez d'utiliser le Hessian calculé comme un Hessian deviné pour un
méthode quasi-Newton avant de recourir à une optimisation Newton.

% Emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = c2v
unité = angström
{ géométrie des atomes } = {
O [ 0.00000000 0.00000000 0.36937294 ]
H [ 0.78397590 0.00000000 -0.18468647 ]
H [ -0.78397590 0.00000000 -0.18468647 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '3-21G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
redémarrer = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
)
do_energy = non
do_gradient = non
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
mémoire = 16000000
couleur = $..: couleur
fonction devinette_ondeCLHF>: (
molécule = $:molécule
total_charge = 0
baseGaussianBasisSet>: (
molécule = $:molécule
nom = 'STO-3G'
)
mémoire = 16000000
)
toile de juteFinDispMoléculaireHesse>: (
only_totally_symmetric = oui
remove_cubic_terms = non
point de contrôle = non
)
)
optimiser = oui
% objet optimiseur pour la géométrie moléculaire
opter : (
print_hessian = oui
max_itérations = 20
fonction = $..:mole
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Fléchette Hartree Fréquences
L'entrée suivante calculera les fréquences Hartree-Fock par déplacements finis. UNE
une analyse thermodynamique sera également effectuée. Si une entrée d'optimisation est également fournie,
alors l'optimisation sera exécutée en premier, puis les fréquences.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C1
{ géométrie des atomes } = {
O [ 0.0000000000 0.0000000000 0.8072934188 ]
H [ 1.4325589285 0.0000000000 -0.3941980761 ]
H [ -1.4325589285 0.0000000000 -0.3941980761 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
mémoire = 16000000
)
% d'entrée de fréquence de vibration
fréqFréquences moléculaires>: (
molécule = $:molécule
)
)

Don Coordonnées et a Guess Toile de jute
L'exemple suivant montre plusieurs fonctionnalités qui sont vraiment indépendantes. La variable
les coordonnées sont explicitement données, plutôt que générées automatiquement. C'est surtout
utile lorsqu'une supposition Hessian doit être fournie, comme c'est le cas ici. Cette toile de jute, telle que donnée par
l'utilisateur, n'est pas complet et le QNewtonOpt l'objet remplira les valeurs manquantes en utilisant
une devinette la toile de jute fournie par le MoléculaireÉnergie objet. De plus, les coordonnées fixes sont
donné dans cet exemple d'entrée.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C1
{ géométrie des atomes } = {
H [ 0.088 2.006 1.438 ]
O [ 0.123 3.193 0.000 ]
H [ 0.088 2.006 -1.438 ]
O [ 4.502 5.955 -0.000 ]
H [ 2.917 4.963 -0.000 ]
H [ 3.812 7.691 -0.000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
)
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
extra_bonds = [ 2 5 ]
)
% les utilisent à la place des coordonnées générées
variableEnsembleIntCoor> : [
<StreSimpleCo>:( atomes = [ 2 5 ] )
<BendSimpleCo>:( atomes = [ 2 5 4 ] )
: ( atomes = [ 5 2 1 3 ] )
<SommeIntCoor>: (
couleur : [
<StreSimpleCo>:( atomes = [ 1 2 ] )
<StreSimpleCo>:( atomes = [ 2 3 ] )
]
coef = [ 1.0 1.0 ]
)
<SommeIntCoor>: (
couleur : [
<StreSimpleCo>:( atomes = [ 4 5 ] )
<StreSimpleCo>:( atomes = [ 4 6 ] )
]
coef = [ 1.0 1.0 ]
)
<BendSimpleCo>:( atomes = [ 1 2 3 ] )
<BendSimpleCo>:( atomes = [ 5 4 6 ] )
]
% ceux-ci sont de toute façon fixés par symétrie,
fixéEnsembleIntCoor> : [
<SommeIntCoor>: (
couleur : [
<StreSimpleCo>:( atomes = [ 1 2 ] )
<StreSimpleCo>:( atomes = [ 2 3 ] )
]
coef = [ 1.0 -1.0 ]
)
<SommeIntCoor>: (
couleur : [
<StreSimpleCo>:( atomes = [ 4 5 ] )
<StreSimpleCo>:( atomes = [ 4 6 ] )
]
coef = [ 1.0 -1.0 ]
)
<TorsSimpleCo>:( atomes = [ 2 5 4 6] )
:( atomes = [ 3 2 6 4 ] )
:( atomes = [ 1 2 6 4 ] )
]
)
% objet optimiseur pour la géométrie moléculaire
opterQNewtonOpt>: (
fonction = $..:mole
mettre à jourMise à jour BFGS> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
% donne une estimation partielle de la toile de jute en coordonnées internes
% les éléments manquants seront remplis automatiquement
toile de jute = [
[0.0109261670]
[ -0.0004214845 0.0102746106 ]
[ -0.0008600592 0.0030051330 0.0043149957 ]
[0.0 0.0 0.0]
[0.0 0.0 0.0]
[0.0 0.0 0.0]
[0.0 0.0 0.0]
]
)
)

Optimization avec a Hydrogène lien
Le générateur automatique de coordonnées internes échouera s'il ne trouve pas assez de données redondantes
coordonnées internes. Dans ce cas, le générateur de coordonnées internes doit être explicitement
créé dans l'entrée et donné des informations de connectivité supplémentaires, comme indiqué ci-dessous.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = C1
{ géométrie des atomes } = {
H [ 0.088 2.006 1.438 ]
O [ 0.123 3.193 0.000 ]
H [ 0.088 2.006 -1.438 ]
O [ 4.502 5.955 -0.000 ]
H [ 2.917 4.963 -0.000 ]
H [ 3.812 7.691 -0.000 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = 'STO-3G'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
)
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
% donnent un générateur de coordonnées interne qui connaît le
% de liaison hydrogène entre les atomes 2 et 5
GénérateurIntCoorGen>: (
molécule = $:molécule
extra_bonds = [ 2 5 ]
)
)
% objet optimiseur pour la géométrie moléculaire
opterQNewtonOpt>: (
fonction = $..:mole
mettre à jourMise à jour BFGS> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Parfaitement fixé Coordonner Optimization
Cet exemple montre comment corriger de manière sélective les coordonnées internes dans une optimisation. Tout
nombre de coordonnées linéairement indépendantes peut être donnée. Ces coordonnées doivent rester
linéairement indépendant tout au long de l'optimisation, une condition qui pourrait ne pas être vérifiée puisque
les coordonnées peuvent être non linéaires.

Par défaut, les valeurs des coordonnées fixes initiales sont issues de la géométrie cartésienne
donné par le Molécule objet; cependant, la molécule sera déplacée vers l'intérieur
valeurs de coordonnées données avec les coordonnées internes fixes si le mot-clé have_fixed_values
est défini sur true, comme illustré dans cet exemple. Dans ce cas, la géométrie cartésienne initiale
doit être raisonnablement proche de la géométrie initiale souhaitée et toutes les variables
les coordonnées seront gelées à leurs valeurs d'origine pendant le déplacement initial.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = CS
{ géométrie des atomes } = {
H [ 3.04 -0.69 -1.59 ]
H [ 3.04 -0.69 1.59 ]
N [ 2.09 -0.48 -0.00 ]
C [ -0.58 -0.15 0.00 ]
H [ -1.17 1.82 0.00 ]
H [ -1.41 -1.04 -1.64 ]
H [ -1.41 -1.04 1.64 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '4-31G*'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
have_fixed_values ​​= oui
fixéEnsembleIntCoor> : [
: ( valeur = -0.1
label = 'N-inversion'
atomes = [4 3 2 1] )
]
)
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
)
% objet optimiseur pour la géométrie moléculaire
opterQNewtonOpt>: (
max_itérations = 20
fonction = $..:mole
mettre à jourMise à jour BFGS> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Transition Région Optimization
Cet exemple montre une optimisation de l'état de transition de la N-inversion en mode utilisation
Suivant. La géométrie initiale a été obtenue en faisant quelques optimisations de coordonnées fixes
le long de la coordonnée d'inversion.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = CS
{ géométrie des atomes } = {
H [ 3.045436 -0.697438 -1.596748 ]
H [ 3.045436 -0.697438 1.596748 ]
N [ 2.098157 -0.482779 -0.000000 ]
C [ -0.582616 -0.151798 0.000000 ]
H [ -1.171620 1.822306 0.000000 ]
H [ -1.417337 -1.042238 -1.647529 ]
H [ -1.417337 -1.042238 1.647529 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '4-31G*'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
suivi = [ 'N-inversion' 4 3 2 1 ]
)
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
)
% objet optimiseur pour la géométrie moléculaire
opterEFCOpt>: (
transition_state = oui
mode_suivant = oui
max_itérations = 20
fonction = $..:mole
mettre à jourPowellMise à jour> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Transition Région Optimization avec a Calculé Guess Toile de jute
Cet exemple montre une optimisation de l'état de transition de la N-inversion en mode utilisation
Suivant. La géométrie initiale a été obtenue en faisant quelques optimisations de coordonnées fixes
le long de la coordonnée d'inversion. Une estimation approximative Hessian sera calculée, ce qui rend
l'optimisation converge beaucoup plus rapidement dans ce cas.

% emacs devrait utiliser -*- ValClé -*-mode
% spécification de molécule
moléculeMolécule>: (
symétrie = CS
{ géométrie des atomes } = {
H [ 3.045436 -0.697438 -1.596748 ]
H [ 3.045436 -0.697438 1.596748 ]
N [ 2.098157 -0.482779 -0.000000 ]
C [ -0.582616 -0.151798 0.000000 ]
H [ -1.171620 1.822306 0.000000 ]
H [ -1.417337 -1.042238 -1.647529 ]
H [ -1.417337 -1.042238 1.647529 ]
}
)
% spécification de l'ensemble de base
baseGaussianBasisSet>: (
nom = '4-31G*'
molécule = $:molécule
)
mpqc : (
point de contrôle = non
état de sauvegarde = non
% de coordonnées moléculaires pour l'optimisation
coorSymmMolecularCoor>: (
molécule = $:molécule
GénérateurIntCoorGen>: (
molécule = $:molécule
)
suivi = [ 'N-inversion' 4 3 2 1 ]
)
% méthode de calcul de l'énergie de la molécule
MôleCLHF>: (
molécule = $:molécule
base = $:base
couleur = $..: couleur
mémoire = 16000000
deviner_hessianFinDispMoléculaireHesse>: (
molécule = $:molécule
only_totally_symmetric = oui
remove_cubic_terms = non
point de contrôle = non
énergieCLHF>: (
molécule = $:molécule
mémoire = 16000000
baseGaussianBasisSet>: (
nom = '3-21G'
molécule = $:molécule
)
)
)
)
% objet optimiseur pour la géométrie moléculaire
opterEFCOpt>: (
transition_state = oui
mode_suivant = oui
max_itérations = 20
fonction = $..:mole
mettre à jourPowellMise à jour> : ()
convergence : (
cartésien = oui
énergie = $..:..:mole
)
)
)

Utiliser mpqc en ligne en utilisant les services onworks.net