Gaussian16源码（gaussian16安装）
本文目录一览：
- 1、初学gaussian，请教一下，混合溶剂怎么设置
- 2、哪里能搞到Gaussian09的源代码 source code
- 3、linux gaussian怎么安装linda
- 4、如何判断Gaussian计算正常结束？Gaussian收敛标准是什么
- 5、彩色图像分割源码
- 6、gaussview16安装好后不能打开
初学gaussian，请教一下，混合溶剂怎么设置
就可以得到收敛的结果（当然也有麻烦的.这通常用于不是在初始猜测而是在平衡结构收敛的几何优化,会提示L508错误. 修改坐标. 11 试着改用DIIS之外其它方法(SCF=SD或SCF=SSD).如果每一步都要用到小的步长,有些系统写2GB会出错.如果这个还不收敛：opt=(TS. 2. 加大循环步数还不能解决的（循环步数有人说超过200再不收敛. 8 一些程序通过减小积分精度加速SCF,这时最好检查一下初始构型,保证它最小. 3.对于使用弥散函数,用guess=read读初始波函数. 4 尝试改变初始构型首先略微减小键长,得到的收敛波函数作为初始猜测进行计算,可改成10,或者构型稍微变一下,收敛标准就会放松或者忽略收敛标准,若出错（L913错误）解决方法. 不做对称性检查 iop(2/. 自旋多重度错误 b. 对于SCF不收敛.这并不总是实用的,有两种可能,Conver选项给出更多的控制.比较常见的方法有HF,还没有找到过渡态）这有几种可能性,opt(maxstep=1),可以在后续计算中使用guess=read读初始猜测;）,CCSD等方法用. 优化过渡态只能做一个STEP 原因是负本征数目不对 添加 iop（1/,某次循环前和循环后的电荷密度差别小于一定的标准,比如相应的阴离子. 2)对角化哈密顿量,省却最大循环50.应当测试这个方法获得的波函. 预备知识：SCF=NoVarAcc,相对越难找. 如果SCF计算收敛失败.在一定的情况下.其实经验上也是过渡态的本征虚频越小,这很可能是你的初始构型太差了,得到这个构型下的能量,重复步骤2）经过一定次数的循环后,和你预计的差别过大,这时可能重新算一下. 如CH4的角度给到109,接着的比较小,得到新的轨道能级和占据,但值得一试. 2． 检查是否有初始文件错误常见初级错误.因此,然后再优化构型,看Guess关键词. 变量没有赋值或多重赋值 d,长程作用或者低能量激发态的体系. 4． 分子对称性改变 a,-1 b,以防止和最高占据轨道之间的混合,GVB,但在极少数情况下SCF=DM更快,再做SCF,这个计算会慢;13=1）这样忽略不收敛. 7 对开壳层体系,默认的是如果出现多于一个的情况就停止优化计算,但优化的时候往往出现两个或者更多的情况,应该加opt(notrustupdate) 7． 在CI（组态）方法中如QCISD(T). 分子描述一行内两次参考同一原子,但200步应该也差不多了）.更多的SCF迭代(SCF(MaxCycle=N). 9 改变模型或方法可以考虑改变模型方法,MPn等. 2. 3)产生新的电荷分布和哈密顿量,首先产生一个轨道占据的初始猜测. 2 增加最大循环步数 Gaussian默认的最大循环步数为64 (SCF=DM或SCF=QC方法则为512),calchffc)计算HF力常数,noeigentest表示优化时不坐此检测,所以更换基组并不在所有的情况下都适用. 如果计算中采用的是Hartree-Fock方法或者其他的混合形式的交换相关势（如B3LYP）,造成两个原子距离过近 g,并且正好不是稳定点(使用Stable关键字),得到scf收敛的波函数；二是构型变化太大,继续往下做,当然有时候需要自己判断是不是接近真实的过渡态.（或者对于过渡态优化： a； or opt=(TS. Gaussian不收敛的可能原因及对策,考虑减小优化步长有时对于能量振荡的情况也是有用的,实际上优化过渡态的时候出现两个三个很正常的,以增加收敛的到基态的可能性： 1 由于体系有很多能量相近的能级. c,有时会有用,增加迭代数量总是使得计算时间和使用更高理论级别差不多,但是收敛的机会更大. 5 尝试能级移动Level shifting (SCF=Vshift) 如果不收敛的原因是波函数的震荡行为,过渡态只有一个负值,再加也不会有用了. 修改坐标,我们称之为收敛,即还没有找到极小值点. 放松对称性判据 Symm=loose d. 10 关闭DIIS外推(SCF=NoDIIS),CASSCF： 1. 用G03时的出错 opt=ts 必须加FC (force constant) 写法. 无法写大的Scratch文件RWF a,而且需要用stable关键字来测试结果是否波函数稳定. 如果计算采用QCISD计算（不好计算FC）则写为QCISD opt=(TS,但是作为普遍的经验规则?这里是我们强烈推荐的首选方法. 看一下能量的收敛的情况,MCSCF,可以写2000MB 10. 改变计算方法 MP2=Direct可以少占硬盘空间 c,通常有以下的解决方法,我们可以采用level shifting的方法,会有两种不收敛的情况、阳离子体系或单重态体系,通常是因为在相近的能量上的泰的混合.) 对于 (L502,只要加大循环的步数（opt(maxcycle=200)）,loc2,modRedundant) (最好写这个) b.同时进行更多的迭代(SCF=(MaxCycle=N)).SCF=Sleazy放松收敛标准. 改变键长,继续优化,……,对QCISD;11）=1或者noeigentest (eigentest 是表示优化过渡态检测分子振动的本征值,眼看有收敛的趋势,其中N是迭代数), L508.3?,精度更高的方法更难收敛,然后优化构型,CCSD(T),以达到收敛的目的,由前一个波函得到用于大基组计算的初始猜测(Guess=Read自动进行),则gaussian给出convergence failure的警告. 分子描述后面没有空行 f. 给出精确的.这很少有帮助,很可能结构不合理） d;16=2) 则保持新的对称性来计算 5． Opt时收敛的问题 a,且变化已经很小了. 对于L9999快达到收敛时,你首先会采取哪些技巧呢,只是第一个一般负的很大,若势能面太平缓：一是在某一步的SCF不收敛(L502错误).一是查看能量. scf=(noincfock;22=20) 用以上的命令行将强制Gaussian采用EDIIS的算法,size1. 键角小于等于0度. 二面角判断错误,一般是缩小一点,接下来用作开壳层计算的初始猜测、对称性确定的角度和二面角. 1 考虑使用更小的基组由于一定的基组对应于一定精度和速度.Level shifting的含义是人工的升高非占据轨道的能级,省却情况做64个cycle迭代(G03缺省128 cycles) a, calcHFFC) (用HF计算FC) 9,但是更加稳定,这虽然不一定绝对正确. 增加叠代次数 SCFCYC=N （对小分子作计算时最好不要增加,不会影响过渡态的搜寻：N≤512 8． 优化过渡态 opt=TS (给出过渡态) opt=qst2 (给出反应物和产物) opt=qst3 (给出反应物和产物和过渡态) a. 修改坐标. 劈裂RWF文件 %rwf=loc1. 限制最大硬盘 maxdisk=N GB,maxcyc=1025) iop(5/. 变量赋值为整数 c. 3,或者构型优化没有找到最后结果（L9999错误）;8=10) 默认30（下一个结构和该结构的差别0,CID方法中.此关键字将大大增加计算时间.在Gaussian中此方法的关键词为SCF=Vshift 6 使用强制的收敛方法SCF=QC SCF=QC通常最佳,不收敛的原因仅仅是因为最大循环步数不够,强制高对称性或放松对称性 b,但除此之外.考虑使用不同理论级别的计算,这往往时不必要的.47122 c.改变模型方法通常也会收敛性质,size2,****MB.精度比较低的方法产生的计算结果可以作为高精度计算的初始猜测,使之合理 b,尝试收敛到同一分子的闭壳层离子,接下来再对结构作一点改变：#P QCISD(maxcyc=N) 注,conver=11.方法是首先用小基组进行计算,再从头优化,可能就可以解决问题了： 1,如果循环次数超过这个数目则会汇报convergence failure. 如果以上过程不能收敛,实际上是在规定的步数内没有完成优化, L9999)出错的对策对于一个优化计算. 使用scf=qc,locN首先,导致计算不收敛:计算时保存chk文件. FOPT出错 原因是变量数与分子自由度数不相等,或低级算法计算.在命令行里也增加了最大循环数. iop(1/.,自洽循环中,或参考原子共线 3． SCF(自洽场)不收敛则一般是L502错误,这样的情况下. 3 放宽收敛标准如果接近SCF但未达到,则可以尝试一下的方法进行改进,优化不知道到哪里去了,我们必须理解收敛是什么意思. 对于优化不收敛,它的过程是先做一个SCF计算.对于这种情况.在自洽场(SCF)计算中,使之合理 b,即L9999错误,接下来略微增加键长.此算法计算量更大. 可用POPT 或直接用OPT 11. 计算相同体系的其他电子态, calcFc) or opt=(TS. 增加叠代次数optcyc=N 6． 优化过渡态.选项Guess=Read定义初始猜测从Gaussian计算生成的checkpoint文件中读取. 4, 1)然后根据此轨道占据构造电荷密度和哈密顿量.可以通过设置maxcyc来增大最大循环步数. iop（5/. 改变初始猜 Guess=Huckel 或其他的,发现能量在振荡了.通常. 使用小基组,阳离子比阴离子更容易收敛;16=1) （最好加这个选项） iop(2/.不要忘记给计算额外增加一千个左右的迭代,则不好找到.添加电子可以给出更合理的虚轨道,看运气和经验了）,必须使用高积分精度,大于等于180度 e.,可能正在单调减小
哪里能搞到Gaussian09的源代码 source code
正对自己的平台，使用源码编译，执行效率比较高。
我对比测试的是G09A01 和G03D02 目前流出的D02是别同通过source code编译的，
D02计算速度明显快很多的...
linux gaussian怎么安装linda
一、 背景介绍
Gaussian是目前计算化学领域内最流行、应用范围最广的商业化量子化学计算程序包。它最早是由美国卡内基梅隆大学的约翰·波普（John A Pople, 1998年诺贝尔化学奖）在60年度末、70年代初主导开发的。其名称来自于该软件中所使用的高斯型基组。最初，Gaussian的著作权属于约翰·波普供职的卡内基梅隆大学；1986年，约翰·波普进入美国西北大学后，其版权由Gaussian,Inc.公司所持有。Gaussian软件的出现降低了量子化学计算的门槛，使得从头计算方法可以广泛使用，从而极大地推动了其在方法学上的进展。
到目前为止，Gaussian已经推出了12个版本，包括Gaussian70、Gaussian76、Gaussian80、Gaussian82、Gaussian86、Gaussian88、Gaussian90、Gaussian92、Gaussian92/DFT、Gaussian94、Gaussian98、Gaussian03等，其版本数字也是该版本发布的年份。其中，每个版本发布后，还陆续发布了一些这些版本的修订版。目前最新的版本是Gaussian03 Revision D.01/D.02。
Gaussian程序是用FORTRAN语言编写的，它从量子力学的基本原理出发，可计算能量、分子结构、分子体系的振动频率以及大量从这些基本计算方法中导出的分子性质。它能用于研究不同条件下的分子和反应，包括稳定的粒子和实验上难以观测的化合物，例如瞬时的反应中间物和过渡结构。
Gaussian的并行模式是采用OpenMP来实现的。OPENMP的并行实现是针对共享内存的机器的，实现方法简单。因此Gaussian在共享内存的机器上，能获得很好的性能。对于跨节点的计算，Gaussian使用TCP Linda软件来实现。TCP Linda是一个虚拟共享内存的并行执行环境，它可以把一个通过网络连接的分布式内存的机群或工作站虚拟成共享内存环境，从而使像Gaussian这样的用OPENMP实现并行的程序能够在分布式内存的机器上运行。
二、 软件的安装设置
1、将压缩包解开
# tar zxf OPT-900N.taz //g03 E01以上版本支持上海处理器 （可以查看文件日期在2007年以后的）
2、准备环境变量文件g03.sh
放入g03源代码目录，如/home/users/mjhe/g03/
#cat g03.sh
g03root="/home/users/mjhe"
GAUSS_SCRDIR="/scratch"
export g03root GAUSS_SCRDIR
. $g03root/g03/bsd/g03.profile
3、准备运行脚本
放入算例目录，如g03test
cat g03.pbs
###########################################################################
# Script for submitting parallel Gaussian 03 jobs to Dawning cluster.
# Lines that begin with #PBS are PBS directives (not comments).
# True comments begin with "# " (i,e., # followed by a space).
###########################################################################
#PBS -S /bin/bash
#PBS -N gaussian
#PBS -j oe
#PBS -l nodes=1:ppn=8
##PBS -l walltime=860:00:00
#PBS -V
##PBS -q middle
#############################################################################
# -S: shell the job will run under
# -o: name of the queue error filename
# -j: merges stdout and stderr to the same file
# -l: resources required by the job: number of nodes and processors per node
# -l: resources required by the job: maximun job time length
#############################################################################
INFILE=$file
# Define variable "jobname".
jobname=`echo $INFILE | awk -F. '{printf $1}'`
username=`whoami`
# Define the location where Gaussian was installed and run a setup script, g03.profile.
g03root="/data/users/ceszhcy/"
GAUSS_SCRDIR="/state/partition1/tmp/"
export g03root GAUSS_SCRDIR
. $g03root/g03/bsd/g03.profile
# Make a directory in scr and copy .com and .g03 file to there.
GAUSS_RUNDIR=${GAUSS_SCRDIR}/${username}.${PBS_JOBID}
if [ ! -a $GAUSS_RUNDIR ]; then
echo "Scratch directory $GAUSS_RUNDIR created."
mkdir -p $GAUSS_RUNDIR
fi
cp $PBS_O_WORKDIR/${jobname}.* $GAUSS_RUNDIR
ORIG_PBS_O_WORKDIR=${PBS_O_WORKDIR}
cd $PBS_O_WORKDIR
# Setup for Gaussian 03:
# =======================
# Make a scratch directory if it doesn't already exist.
GAUSS_SCRDIR=${GAUSS_SCRDIR}/${username}.${PBS_JOBID}/${jobname}
if [ ! -a $GAUSS_SCRDIR ]; then
echo "Scratch directory $GAUSS_SCRDIR created."
mkdir -p $GAUSS_SCRDIR
fi
export GAUSS_SCRDIR
echo "Using $GAUSS_SCRDIR for temporary Gaussian 03 files."
# Define node list
cat $PBS_NODEFILE|uniq $GAUSS_SCRDIR/tsnet.nodes
NODE_NUM=`cat $PBS_NODEFILE|uniq |wc -l`
NP=`cat $PBS_NODEFILE|wc -l`
nodes=`cat $PBS_NODEFILE |uniq| awk '{printf("%s,",$1)}'`
sharecpu=`expr $NP / $NODE_NUM`
G03_NODEFILE="$GAUSS_SCRDIR/tsnet.nodes"
GAUSS_LFLAGS=" -mp 2 -nodefile $G03_NODEFILE"
export GAUSS_LFLAGS
echo pbs nodefile:
cat $G03_NODEFILE
#Run a Gaussian command file, water03.com, redirecting output to a file, water03.log
cd $GAUSS_RUNDIR
echo "%NProcShared=$sharecpu" ${jobname}.Input.${PBS_JOBID}
if [ $NODE_NUM -ne 1 ];
then
echo "%LindaWorker=$nodes" ${jobname}.Input.${PBS_JOBID}
fi
grep -v nproc $INFILE |grep -v NProcShared |grep -v LindaWorker ${jobname}.Input.${PBS_JOBID}
echo "Starting Gaussian run at" `date`
if [ $NODE_NUM -eq 1 ];
then
time g03 ${jobname}.Input.${PBS_JOBID} $GAUSS_RUNDIR/${jobname}.log
fi
else
time g03l ${jobname}.Input.${PBS_JOBID} $GAUSS_RUNDIR/${jobname}.log
fi
#time g03 ${jobname}.Input.${PBS_JOBID} ${jobname}.log
echo "Finished Gaussian run at" `date`
PBS_O_WORKDIR=${ORIG_PBS_O_WORKDIR}
echo $PBS_O_WORKDIR
mv $GAUSS_RUNDIR/${jobname}.* $PBS_O_WORKDIR
mv $GAUSS_SCRDIR/*.chk $PBS_O_WORKDIR
echo "$GAUSS_SCRDIR"
rm -Rf $GAUSS_SCRDIR
4、测试安装是否成功
准备算例test397.com
在算例目录下修改g03.pbs，然后执行qsub g03.pbs -v file=test397.com
cd ~/g03test
qsub g03.pbs -v file=test397.com
5、其他
三、 注意事项
1、本文命令、代码和超链接采用斜体五号字表示
2、算例文件名必须有两部分组成，前缀+后缀，中间用 . 隔开
3、需要修改一下两个文件以适应linda并行时的配置情况：
#vi /data2/home/test/g03/linda7.2/opteron-linux-I8/bin/LindaLauncher
/mf/giovanni/static/g03/linda7.2/opteron-linux-I8/bin/cLindaLauncher
#vi /data2/home/test//g03/ntsnet
/mf/giovanni/static/g03/linda7.2/opteron-linux-I8/bin/true_ntsnet
4、在所以参与计算的节点根目录上增加/scratch/，并设置开放的权限
mkdir /scratch
chmod 777 /scratch
5、其他
四、 参考文献
1 量子化学计算程序包GAUSSIAN 王涛 上海超级计算中心 上海 201203 twang@ssc.net.cn
如何判断Gaussian计算正常结束？Gaussian收敛标准是什么
首先,我们必须理解收敛是什么意思.在自洽场(SCF)计算中,自洽循环中,首先产生一个轨道占据的初始猜测,
1)然后根据此轨道占据构造电荷密度和哈密顿量.
2)对角化哈密顿量,得到新的轨道能级和占据.
3)产生新的电荷分布和哈密顿量,重复步骤2）
经过一定次数的循环后,某次循环前和循环后的电荷密度差别小于一定的标准,我们称之为收敛.
如果以上过程不能收敛,则gaussian给出convergence failure的警告.
如果SCF计算收敛失败,你首先会采取哪些技巧呢?这里是我们强烈推荐的首选方法.
1 考虑使用更小的基组
由于一定的基组对应于一定精度和速度,所以更换基组并不在所有的情况下都适用.方法是首先用小基组进行计算,由前一个波函得到用于大基组计算的初始猜测(Guess=Read自动进行).
2 增加最大循环步数
Gaussian默认的最大循环步数为64 (SCF=DM或SCF=QC方法则为512),如果循环次数超过这个数目则会汇报convergence failure.在一定的情况下,不收敛的原因仅仅是因为最大循环步数不够.可以通过设置maxcyc来增大最大循环步数.更多的SCF迭代(SCF(MaxCycle=N),其中N是迭代数).这很少有帮助,但值得一试.
3 放宽收敛标准
如果接近SCF但未达到,收敛标准就会放松或者忽略收敛标准.这通常用于不是在初始猜测而是在平衡结构收敛的几何优化.SCF=Sleazy放松收敛标准,Conver选项给出更多的控制.
4 尝试改变初始构型
首先略微减小键长,接下来略微增加键长,接下来再对结构作一点改变.
5 尝试能级移动Level shifting (SCF=Vshift)
如果不收敛的原因是波函数的震荡行为,通常是因为在相近的能量上的泰的混合.对于这种情况,我们可以采用level shifting的方法.Level shifting的含义是人工的升高非占据轨道的能级,以防止和最高占据轨道之间的混合,以达到收敛的目的.在Gaussian中此方法的关键词为SCF=Vshift
6 使用强制的收敛方法SCF=QC
SCF=QC通常最佳,但在极少数情况下SCF=DM更快.此关键字将大大增加计算时间,但是收敛的机会更大.不要忘记给计算额外增加一千个左右的迭代.应当测试这个方法获得的波函,保证它最小,并且正好不是稳定点(使用Stable关键字).
7 对开壳层体系,尝试收敛到同一分子的闭壳层离子,接下来用作开壳层计算的初始猜测.添加电子可以给出更合理的虚轨道,但是作为普遍的经验规则,阳离子比阴离子更容易收敛.选项Guess=Read定义初始猜测从Gaussian计算生成的checkpoint文件中读取.
8 一些程序通过减小积分精度加速SCF.对于使用弥散函数,长程作用或者低能量激发态的体系,必须使用高积分精度：SCF=NoVarAcc.
9 改变模型或方法
可以考虑改变模型方法.比较常见的方法有HF,GVB,MCSCF,CASSCF,MPn等.改变模型方法通常也会收敛性质.通常,精度更高的方法更难收敛.精度比较低的方法产生的计算结果可以作为高精度计算的初始猜测.考虑使用不同理论级别的计算.这并不总是实用的,但除此之外,增加迭代数量总是使得计算时间和使用更高理论级别差不多.
10 关闭DIIS外推(SCF=NoDIIS).同时进行更多的迭代(SCF=(MaxCycle=N)).
11 试着改用DIIS之外其它方法(SCF=SD或SCF=SSD).
Gaussian不收敛的可能原因及对策：
1 由于体系有很多能量相近的能级,导致计算不收敛.
如果计算中采用的是Hartree-Fock方法或者其他的混合形式的交换相关势（如B3LYP）,则可以尝试一下的方法进行改进.
scf=(noincfock,conver=11,maxcyc=1025) iop(5/22=20)
用以上的命令行将强制Gaussian采用EDIIS的算法.此算法计算量更大,但是更加稳定.在命令行里也增加了最大循环数,以增加收敛的到基态的可能性.
2． 检查是否有初始文件错误
常见初级错误：
a. 自旋多重度错误
b. 变量赋值为整数
c. 变量没有赋值或多重赋值
d. 键角小于等于0度,大于等于180度
e. 分子描述后面没有空行
f. 二面角判断错误,造成两个原子距离过近
g. 分子描述一行内两次参考同一原子,或参考原子共线
3． SCF(自洽场)不收敛
则一般是L502错误,省却情况做64个cycle迭代(G03缺省128 cycles)
a. 修改坐标,使之合理
b. 改变初始猜 Guess=Huckel 或其他的,看Guess关键词.
c. 增加叠代次数 SCFCYC=N （对小分子作计算时最好不要增加,很可能结构不合理）
d. iop（5/13=1）这样忽略不收敛,继续往下做.
4． 分子对称性改变
a. 修改坐标,强制高对称性或放松对称性
b. 给出精确的、对称性确定的角度和二面角. 如CH4的角度给到109.47122
c. 放松对称性判据 Symm=loose
d. 不做对称性检查 iop(2/16=1) （最好加这个选项）
iop(2/16=2) 则保持新的对称性来计算
5． Opt时收敛的问题
a. 修改坐标,使之合理
b. 增加叠代次数optcyc=N
6． 优化过渡态,若势能面太平缓,则不好找到.
iop(1/8=10) 默认30（下一个结构和该结构的差别0.3Å）,可改成10.如果每一步都要用到小的步长,应该加opt(notrustupdate)
7． 在CI（组态）方法中
如QCISD(T),CCSD(T),CID方法中,省却最大循环50,若出错（L913错误）
解决方法：#P QCISD(maxcyc=N) 注：N≤512
8． 优化过渡态
opt=TS (给出过渡态)
opt=qst2 (给出反应物和产物)
opt=qst3 (给出反应物和产物和过渡态)
a. 用G03时的出错 opt=ts 必须加FC (force constant)
写法：opt=(TS, calcFc)
or opt=(TS,calchffc)计算HF力常数,对QCISD,CCSD等方法用；
or opt=(TS,modRedundant) (最好写这个)
b. 如果计算采用QCISD计算（不好计算FC）
则写为QCISD opt=(TS, calcHFFC) (用HF计算FC)
9. 无法写大的Scratch文件RWF
a. 劈裂RWF文件 %rwf=loc1,size1,loc2,size2,……..,locN,-1
b. 改变计算方法 MP2=Direct可以少占硬盘空间
c. 限制最大硬盘 maxdisk=N GB,****MB,有些系统写2GB会出错,可以写2000MB
10. FOPT出错 原因是变量数与分子自由度数不相等. 可用POPT 或直接用OPT
11. 优化过渡态只能做一个STEP 原因是负本征数目不对 添加 iop（1/11）=1或者noeigentest (eigentest 是表示优化过渡态检测分子振动的本征值,过渡态只有一个负值,但优化的时候往往出现两个或者更多的情况,默认的是如果出现多于一个的情况就停止优化计算,这往往时不必要的,noeigentest表示优化时不坐此检测,实际上优化过渡态的时候出现两个三个很正常的,只是第一个一般负的很大,接着的比较小,不会影响过渡态的搜寻,当然有时候需要自己判断是不是接近真实的过渡态.其实经验上也是过渡态的本征虚频越小,相对越难找.)
对于 (L502, L508, L9999)出错的对策
对于一个优化计算,它的过程是先做一个SCF计算,得到这个构型下的能量,然后优化构型,再做SCF,然后再优化构型.因此,会有两种不收敛的情况：一是在某一步的SCF不收敛(L502错误),或者构型优化没有找到最后结果（L9999错误）.
预备知识:计算时保存chk文件,可以在后续计算中使用guess=read读初始猜测.
对于SCF不收敛,通常有以下的解决方法：
1. 使用小基组,或低级算法计算,得到scf收敛的波函数,用guess=read读初始波函数.
2. 使用scf=qc,这个计算会慢,而且需要用stable关键字来测试结果是否波函数稳定.如果这个还不收敛,会提示L508错误.
3. 改变键长,一般是缩小一点,有时会有用.
4. 计算相同体系的其他电子态,比如相应的阴离子、阳离子体系或单重态体系,得到的收敛波函数作为初始猜测进行计算.
对于优化不收敛,即L9999错误,实际上是在规定的步数内没有完成优化,即还没有找到极小值点.（或者对于过渡态优化,还没有找到过渡态）
这有几种可能性：
1. 看一下能量的收敛的情况,可能正在单调减小,眼看有收敛的趋势,这样的情况下,只要加大循环的步数（opt(maxcycle=200)）,可能就可以解决问题了.
2. 加大循环步数还不能解决的（循环步数有人说超过200再不收敛,再加也不会有用了,这虽然不一定绝对正确,但200步应该也差不多了）,有两种可能.一是查看能量,发现能量在振荡了,且变化已经很小了,这时可能重新算一下,或者构型稍微变一下,继续优化,就可以得到收敛的结果（当然也有麻烦的,看运气和经验了）；二是构型变化太大,和你预计的差别过大,这很可能是你的初始构型太差了,优化不知道到哪里去了,这时最好检查一下初始构型,再从头优化.
3. 对于L9999快达到收敛时,考虑减小优化步长有时对于能量振荡的情况也是有用的,opt(maxstep=1).(flyingheart )
彩色图像分割源码
你说的是什么东西的彩色图像分割源码啊?说清楚了我帮你查
=======================================
OpenCV学习笔记（三）人脸检测的代码分析
OpenCV学习笔记（三）人脸检测的代码分析
一、预备知识：
1、动态内存存储及操作函数
CvMemStorage
typedef struct CvMemStorage
{
struct CvMemBlock* bottom;/* first allocated block */
struct CvMemBlock* top; /* the current memory block - top of the stack */
struct CvMemStorage* parent; /* borrows new blocks from */
int block_size; /* block size */
int free_space; /* free space in the top block (in bytes) */
} CvMemStorage;
内存存储器是一个可用来存储诸如序列，轮廓，图形,子划分等动态增长数据结构的底层结构。它是由一系列以同等大小的内存块构成，呈列表型 ---bottom 域指的是列首，top 域指的是当前指向的块但未必是列尾.在bottom和top之间所有的块(包括bottom, 不包括top）被完全占据了空间；在 top和列尾之间所有的块（包括块尾，不包括top)则是空的；而top块本身则被占据了部分空间 -- free_space 指的是top块剩余的空字节数。新分配的内存缓冲区（或显示的通过 cvMemStorageAlloc 函数分配，或隐示的通过 cvSeqPush, cvGraphAddEdge等高级函数分配）总是起始于当前块（即top块)的剩余那部分，如果剩余那部分能满足要求（够分配的大小）。分配后，free_space 就减少了新分配的那部分内存大小，外加一些用来保存适当列型的附加大小。当top块的剩余空间无法满足被分配的块（缓冲区）大小时，top块的下一个存储块被置为当前块（新的top块） -- free_space 被置为先前分配的整个块的大小。如果已经不存在空的存储块（即：top块已是列尾），则必须再分配一个新的块（或从parent那继承,见 cvCreateChildMemStorage)并将该块加到列尾上去。于是，存储器（memory storage)就如同栈（Stack)那样, bottom指向栈底，(top, free_space)对指向栈顶。栈顶可通过 cvSaveMemStoragePos保存，通过 cvRestoreMemStoragePos 恢复指向， 通过 cvClearStorage 重置。
CvMemBlock
内存存储块结构
typedef struct CvMemBlock
{
struct CvMemBlock* prev;
struct CvMemBlock* next;
} CvMemBlock;
CvMemBlock 代表一个单独的内存存储块结构。 内存存储块中的实际数据存储在 header块 之后(即：存在一个头指针 head 指向的块 header ，该块不存储数据）,于是，内存块的第 i 个字节可以通过表达式 ((char*)(mem_block_ptr+1))[i] 获得。然而，通常没必要直接去获得存储结构的域。
CvMemStoragePos
内存存储块地址
typedef struct CvMemStoragePos
{
CvMemBlock* top;
int free_space;
} CvMemStoragePos;
该结构（如以下所说）保存栈顶的地址，栈顶可以通过 cvSaveMemStoragePos 保存，也可以通过 cvRestoreMemStoragePos 恢复。
________________________________________
cvCreateMemStorage
创建内存块
CvMemStorage* cvCreateMemStorage( int block_size=0 );
block_size：存储块的大小以字节表示。如果大小是 0 byte, 则将该块设置成默认值 当前默认大小为64k.
函数 cvCreateMemStorage 创建一内存块并返回指向块首的指针。起初，存储块是空的。头部（即：header)的所有域值都为 0，除了 block_size 外.
________________________________________
cvCreateChildMemStorage
创建子内存块
CvMemStorage* cvCreateChildMemStorage( CvMemStorage* parent );
parent 父内存块
函数 cvCreateChildMemStorage 创建一类似于普通内存块的子内存块，除了内存分配/释放机制不同外。当一个子存储块需要一个新的块加入时，它就试图从parent 那得到这样一个块。如果 parent 中 还未被占据空间的那些块中的第一个块是可获得的，就获取第一个块（依此类推），再将该块从 parent 那里去除。如果不存在这样的块，则 parent 要么分配一个，要么从它自己 parent (即：parent 的 parent) 那借个过来。换句话说，完全有可能形成一个链或更为复杂的结构，其中的内存存储块互为 child/ parent 关系（父子关系）。当子存储结构被释放或清除，它就把所有的块还给各自的 parent. 在其他方面，子存储结构同普通存储结构一样。
子存储结构在下列情况中是非常有用的。想象一下，如果用户需要处理存储在某个块中的动态数据，再将处理的结果存放在该块中。在使用了最简单的方法处理后，临时数据作为输入和输出数据被存放在了同一个存储块中，于是该存储块看上去就类似下面处理后的样子： Dynamic data processing without using child storage. 结果，在存储块中，出现了垃圾（临时数据）。然而，如果在开始处理数据前就先建立一个子存储块，将临时数据写入子存储块中并在最后释放子存储块，那么最终在 源/目的存储块 （source / destination storage) 中就不会出现垃圾, 于是该存储块看上去应该是如下形式：Dynamic data processing using a child storage.
cvReleaseMemStorage
释放内存块
void cvReleaseMemStorage( CvMemStorage** storage );
storage: 指向被释放了的存储块的指针
函数 cvReleaseMemStorage 释放所有的存储（内存）块 或者 将它们返回给各自的 parent（如果需要的话）。 接下来再释放 header块（即：释放头指针 head 指向的块 = free(head)）并清除指向该块的指针（即：head = NULL)。在释放作为 parent 的块之前，先清除各自的 child 块。
cvClearMemStorage
清空内存存储块
void cvClearMemStorage( CvMemStorage* storage );
storage:存储存储块
函数 cvClearMemStorage 将存储块的 top 置到存储块的头部（注：清空存储块中的存储内容）。该函数并不释放内存（仅清空内存）。假使该内存块有一个父内存块（即：存在一内存块与其有父子关系），则函数就将所有的块返回给其 parent.
cvMemStorageAlloc
在存储块中分配以内存缓冲区
void* cvMemStorageAlloc( CvMemStorage* storage, size_t size );
storage：内存块.
size：缓冲区的大小.
函数 cvMemStorageAlloc 在存储块中分配一内存缓冲区。该缓冲区的大小不能超过内存块的大小，否则就会导致运行时错误。缓冲区的地址被调整为CV_STRUCT_ALIGN 字节 （当前为 sizeof(double)).
cvMemStorageAllocString
在存储块中分配一文本字符串
typedef struct CvString
{
int len;
char* ptr;
}
CvString;
CvString cvMemStorageAllocString( CvMemStorage* storage, const char* ptr, int len=-1 );
storage：存储块
ptr：字符串
len：字符串的长度（不计算'\0'）。如果参数为负数，函数就计算该字符串的长度。
函数 cvMemStorageAlloString 在存储块中创建了一字符串的拷贝。它返回一结构，该结构包含字符串的长度（该长度或通过用户传递，或通过计算得到）和指向被拷贝了的字符串的指针。
cvSaveMemStoragePos
保存内存块的位置（地址）
void cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
storage：内存块.
pos：内存块顶部位置。
函数 cvSaveMemStoragePos 将存储块的当前位置保存到参数 pos 中。 函数 cvRestoreMemStoragePos 可进一步获取该位置（地址）。
cvRestoreMemStoragePos
恢复内存存储块的位置
void cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
storage：内存块.
pos：新的存储块的位置
函数 cvRestoreMemStoragePos 通过参数 pos 恢复内存块的位置。该函数和函数 cvClearMemStorage 是释放被占用内存块的唯一方法。注意：没有什么方法可去释放存储块中被占用的部分内存。
2、分类器结构及操作函数：
CvHaarFeature
#define CV_HAAR_FEATURE_MAX 3
typedef struct CvHaarFeature
{
int tilted;
struct
{
CvRect r;
float weight;
} rect[CV_HAAR_FEATURE_MAX];
}
CvHaarFeature;
一个 harr 特征由 2－3 个具有相应权重的矩形组成
titled ：/* 0 means up-right feature, 1 means 45--rotated feature */
rect[CV_HAAR_FEATURE_MAX]; /* 2-3 rectangles with weights of opposite signs and with absolute values inversely proportional to the areas of the rectangles. if rect[2].weight !=0, then the feature consists of 3 rectangles, otherwise it consists of 2 */
CvHaarClassifier
typedef struct CvHaarClassifier
{
int count;
CvHaarFeature* haar_feature;
float* threshold;
int* left;
int* right;
float* alpha;
}
CvHaarClassifier;
/* a single tree classifier (stump in the simplest case) that returns the response for the feature at the particular image location (i.e. pixel sum over subrectangles of the window) and gives out a value depending on the responce */
int count; /* number of nodes in the decision tree */
/* these are "parallel" arrays. Every index i corresponds to a node of the decision tree (root has 0-th index).
left[i] - index of the left child (or negated index if the left child is a leaf)
right[i] - index of the right child (or negated index if the right child is a leaf)
threshold[i] - branch threshold. if feature responce is = threshold, left branch is chosen, otherwise right branch is chosed.
alpha[i] - output value correponding to the leaf. */
CvHaarStageClassifier
typedef struct CvHaarStageClassifier
{
int count; /* number of classifiers in the battery */
float threshold; /* threshold for the boosted classifier */
CvHaarClassifier* classifier; /* array of classifiers */
/* these fields are used for organizing trees of stage classifiers,
rather than just stright cascades */
int next;
int child;
int parent;
}
CvHaarStageClassifier;
/* a boosted battery of classifiers(=stage classifier): the stage classifier returns 1 if the sum of the classifiers' responces is greater than threshold and 0 otherwise */
int count; /* number of classifiers in the battery */
float threshold; /* threshold for the boosted classifier */
CvHaarClassifier* classifier; /* array of classifiers */
/* these fields are used for organizing trees of stage classifiers, rather than just stright cascades */
CvHaarClassifierCascade
typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;
typedef struct CvHaarClassifierCascade
{
int flags;
int count;
CvSize orig_window_size;
CvSize real_window_size;
double scale;
CvHaarStageClassifier* stage_classifier;
CvHidHaarClassifierCascade* hid_cascade;
}
CvHaarClassifierCascade;
/* cascade or tree of stage classifiers */
int flags; /* signature */
int count; /* number of stages */
CvSize orig_window_size; /* original object size (the cascade is trained for) */
/* these two parameters are set by cvSetImagesForHaarClassifierCascade */
CvSize real_window_size; /* current object size */
double scale; /* current scale */
CvHaarStageClassifier* stage_classifier; /* array of stage classifiers */
CvHidHaarClassifierCascade* hid_cascade; /* hidden optimized representation of the cascade, created by cvSetImagesForHaarClassifierCascade */
所有的结构都代表一个级联boosted Haar分类器。级联有下面的等级结构：
Cascade:
Stage1:
Classifier11:
Feature11
Classifier12:
Feature12
...
Stage2:
Classifier21:
Feature21
...
...
整个等级可以手工构建，也可以利用函数cvLoadHaarClassifierCascade从已有的磁盘文件或嵌入式基中导入。
特征检测用到的函数：
cvLoadHaarClassifierCascade
从文件中装载训练好的级联分类器或者从OpenCV中嵌入的分类器数据库中导入
CvHaarClassifierCascade* cvLoadHaarClassifierCascade(
const char* directory,
CvSize orig_window_size );
directory ：训练好的级联分类器的路径
orig_window_size：级联分类器训练中采用的检测目标的尺寸。因为这个信息没有在级联分类器中存储，所有要单独指出。
函数 cvLoadHaarClassifierCascade 用于从文件中装载训练好的利用海尔特征的级联分类器，或者从OpenCV中嵌入的分类器数据库中导入。分类器的训练可以应用函数haartraining(详细察看opencv/apps/haartraining)
函数 已经过时了。现在的目标检测分类器通常存储在 XML 或 YAML 文件中,而不是通过路径导入。从文件中导入分类器，可以使用函数 cvLoad 。
cvReleaseHaarClassifierCascade
释放haar classifier cascade。
void cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade );
cascade ：双指针类型指针指向要释放的cascade. 指针由函数声明。
函数 cvReleaseHaarClassifierCascade 释放cascade的动态内存，其中cascade的动态内存或者是手工创建，或者通过函数 cvLoadHaarClassifierCascade 或 cvLoad分配。
cvHaarDetectObjects
检测图像中的目标
typedef struct CvAvgComp
{
CvRect rect; /* bounding rectangle for the object (average rectangle of a group) */
int neighbors; /* number of neighbor rectangles in the group */
}
CvAvgComp;
CvSeq* cvHaarDetectObjects( const CvArr* image,
CvHaarClassifierCascade* cascade,
CvMemStorage* storage,
double scale_factor=1.1,
int min_neighbors=3, int flags=0,
CvSize min_size=cvSize(0,0) );
image 被检图像
cascade harr 分类器级联的内部标识形式
storage 用来存储检测到的一序列候选目标矩形框的内存区域。
scale_factor 在前后两次相继的扫描中，搜索窗口的比例系数。例如1.1指将搜索窗口依次扩大10%。
min_neighbors 构成检测目标的相邻矩形的最小个数(缺省－1)。如果组成检测目标的小矩形的个数和小于min_neighbors-1 都会被排除。如果min_neighbors 为 0, 则函数不做任何操作就返回所有的被检候选矩形框，这种设定值一般用在用户自定义对检测结果的组合程序上。
flags 操作方式。当前唯一可以定义的操作方式是 CV_HAAR_DO_CANNY_PRUNING。如果被设定，函数利用Canny边缘检测器来排除一些边缘很少或者很多的图像区域，因为这样的区域一般不含被检目标。人脸检测中通过设定阈值使用了这种方法，并因此提高了检测速度。
min_size 检测窗口的最小尺寸。缺省的情况下被设为分类器训练时采用的样本尺寸(人脸检测中缺省大小是~20×20)。
函数 cvHaarDetectObjects 使用针对某目标物体训练的级联分类器在图像中找到包含目标物体的矩形区域，并且将这些区域作为一序列的矩形框返回。函数以不同比例大小的扫描窗口对图像进行几次搜索(察看cvSetImagesForHaarClassifierCascade)。 每次都要对图像中的这些重叠区域利用cvRunHaarClassifierCascade进行检测。 有时候也会利用某些继承（heuristics）技术以减少分析的候选区域，例如利用 Canny 裁减 （prunning）方法。 函数在处理和收集到候选的方框(全部通过级联分类器各层的区域)之后，接着对这些区域进行组合并且返回一系列各个足够大的组合中的平均矩形。调节程序中的缺省参数(scale_factor=1.1, min_neighbors=3, flags=0)用于对目标进行更精确同时也是耗时较长的进一步检测。为了能对视频图像进行更快的实时检测，参数设置通常是：scale_factor=1.2, min_neighbors=2, flags=CV_HAAR_DO_CANNY_PRUNING, min_size=minimum possible face size (例如, 对于视频会议的图像区域).
cvSetImagesForHaarClassifierCascade
为隐藏的cascade(hidden cascade)指定图像
void cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
const CvArr* sum, const CvArr* sqsum,
const CvArr* tilted_sum, double scale );
cascade 隐藏 Harr 分类器级联 （Hidden Haar classifier cascade）, 由函数 cvCreateHidHaarClassifierCascade生成
sum 32－比特，单通道图像的积分图像（Integral (sum) 单通道 image of 32-比特 integer format）. 这幅图像以及随后的两幅用于对快速特征的评价和亮度/对比度的归一化。 它们都可以利用函数 cvIntegral从8-比特或浮点数 单通道的输入图像中得到。
sqsum 单通道64比特图像的平方和图像
tilted_sum 单通道32比特整数格式的图像的倾斜和（Tilted sum）
scale cascade的窗口比例. 如果 scale=1, 就只用原始窗口尺寸检测 (只检测同样尺寸大小的目标物体) - 原始窗口尺寸在函数cvLoadHaarClassifierCascade中定义 (在 "default_face_cascade"中缺省为24x24), 如果scale=2, 使用的窗口是上面的两倍 (在face cascade中缺省值是48x48 )。 这样尽管可以将检测速度提高四倍，但同时尺寸小于48x48的人脸将不能被检测到。
函数 cvSetImagesForHaarClassifierCascade 为hidden classifier cascade 指定图像 and/or 窗口比例系数。 如果图像指针为空，会继续使用原来的图像(i.e. NULLs 意味这"不改变图像")。比例系数没有 "protection" 值,但是原来的值可以通过函数 cvGetHaarClassifierCascadeScale 重新得到并使用。这个函数用于对特定图像中检测特定目标尺寸的cascade分类器的设定。函数通过cvHaarDetectObjects进行内部调用，但当需要在更低一层的函数cvRunHaarClassifierCascade中使用的时候，用户也可以自行调用。
cvRunHaarClassifierCascade
在给定位置的图像中运行 cascade of boosted classifier
int cvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade,
CvPoint pt, int start_stage=0 );
cascade Haar 级联分类器
pt 待检测区域的左上角坐标。待检测区域大小为原始窗口尺寸乘以当前设定的比例系数。当前窗口尺寸可以通过cvGetHaarClassifierCascadeWindowSize重新得到。
start_stage 级联层的初始下标值（从0开始计数）。函数假定前面所有每层的分类器都已通过。这个特征通过函数cvHaarDetectObjects内部调用，用于更好的处理器高速缓冲存储器。
函数 cvRunHaarHaarClassifierCascade 用于对单幅图片的检测。在函数调用前首先利用 cvSetImagesForHaarClassifierCascade设定积分图和合适的比例系数 (= 窗口尺寸)。当分析的矩形框全部通过级联分类器每一层的时返回正值(这是一个候选目标)，否则返回0或负值。
二、例程分析：
例子:利用级联的Haar classifiers寻找检测目标(e.g. faces).
#include "cv.h"
#include "highgui.h"
//读取训练好的分类器。
CvHaarClassifierCascade* load_object_detector( const char* cascade_path )
{
return (CvHaarClassifierCascade*)cvLoad( cascade_path );
}
void detect_and_draw_objects( IplImage* image,
CvHaarClassifierCascade* cascade,
int do_pyramids )
{
IplImage* small_image = image;
CvMemStorage* storage = cvCreateMemStorage(0); //创建动态内存
CvSeq* faces;
int i, scale = 1;
/* if the flag is specified, down-scale the 输入图像 to get a
performance boost w/o loosing quality (perhaps) */
if( do_pyramids )
{
small_image = cvCreateImage( cvSize(image-width/2,image-height/2), IPL_DEPTH_8U, 3 );
cvPyrDown( image, small_image, CV_GAUSSIAN_5x5 );//函数 cvPyrDown 使用 Gaussian 金字塔分解对输入图像向下采样。首先它对输入图像用指定滤波器进行卷积，然后通过拒绝偶数的行与列来下采样图像。
scale = 2;
}
/* use the fastest variant */
faces = cvHaarDetectObjects( small_image, cascade, storage, 1.2, 2, CV_HAAR_DO_CANNY_PRUNING );
/* draw all the rectangles */
for( i = 0; i faces-total; i++ )
{
/* extract the rectanlges only */
CvRect face_rect = *(CvRect*)cvGetSeqElem( faces, i, 0 );
cvRectangle( image, cvPoint(face_rect.x*scale,face_rect.y*scale),
cvPoint((face_rect.x+face_rect.width)*scale,
(face_rect.y+face_rect.height)*scale),
CV_RGB(255,0,0), 3 );
}
if( small_image != image )
cvReleaseImage( small_image );
cvReleaseMemStorage( storage ); //释放动态内存
}
/* takes image filename and cascade path from the command line */
int main( int argc, char** argv )
{
IplImage* image;
if( argc==3 (image = cvLoadImage( argv[1], 1 )) != 0 )
{
CvHaarClassifierCascade* cascade = load_object_detector(argv[2]);
detect_and_draw_objects( image, cascade, 1 );
cvNamedWindow( "test", 0 );
cvShowImage( "test", image );
cvWaitKey(0);
cvReleaseHaarClassifierCascade( cascade );
cvReleaseImage( image );
}
return 0;
}
gaussview16安装好后不能打开
更新显卡驱动解决。
G16在windows下的ubuntun子系统安装好了，当时输入g16感觉安装成功。但是重新进入系统键入g16碰到了文件夹的权限问题，运行不下去。
当把运行缓存的文件夹设置：chmod 777 -R XXX/temp
解决了开始运行启动，但立刻碰到标题出现的提示，一大堆，Problem with file /home/zjm/gaussian/g16/l1.exe omode 33279 compare 7*Error: segmentation violatio
吓死宝宝了。不过体会到不要被很长很长的报错吓到，真的有价值的就是几个关键地方：开头与结尾的总结行语言。把出现的错误复制到百度寻找答案，发现很多菜鸟入门都挨了这一刀。
感谢给出了解决方案。原来gaussian软件在使用过程中，谁安装就只能谁使用。我ls -l 查看了安装目录gaussian的所有者及所有权信息，发现是root,而不是我的用户名，但是sudo su以root身份也运行不了g16,把GASSIAN所有权改为chmod 777 运行g16就出现题目报错问题。估计安装时，我是以root身份安装，在路径设置，变量设置时到/hone/user/.bashrc目录下。不妥之处，期待高手指正。
sudo chown user XXX/gaussian
sudo chmod 700 -R XXX/gaussian
键入g16 out,运行成功
我的收获是ls -l命令查看所有权，chmod修改
chown改变所有者。高斯运行的缓存文件夹及安装目录的所有权会影响程序开始的执行，这些不是程序本身编译问题。
