1 /* OrbitalsGamess.c */
2 /**********************************************************************************************************
3 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
4
5 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
8 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9
10 The above copyright notice and this permission notice shall be included in all copies or substantial portions
11 of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
16 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17 DEALINGS IN THE SOFTWARE.
18 ************************************************************************************************************/
19
20 #include "../../Config.h"
21 #include "GlobalOrb.h"
22 #include "../Utils/AtomsProp.h"
23 #include "../Utils/UtilsInterface.h"
24 #include "../Utils/Utils.h"
25 #include "../Utils/Constants.h"
26 #include "../Geometry/GeomGlobal.h"
27 #include "GeomDraw.h"
28 #include "GLArea.h"
29 #include "UtilsOrb.h"
30 #include "Basis.h"
31 #include "GeomOrbXYZ.h"
32 #include "AtomicOrbitals.h"
33 #include "StatusOrb.h"
34 #include "Basis.h"
35 #include "Orbitals.h"
36 #include "GeomOrbXYZ.h"
37 #include "BondsOrb.h"
38
39 /********************************************************************************/
40 typedef enum
41 {
42 GABEDIT_ORBLOCALTYPE_BOYS=0,
43 GABEDIT_ORBLOCALTYPE_EDMISTON,
44 GABEDIT_ORBLOCALTYPE_PIPEK,
45 GABEDIT_ORBLOCALTYPE_UNKNOWN
46 } GabEditOrbLocalType;
47
48 static gchar* titlesLocalOrb[GABEDIT_ORBLOCALTYPE_PIPEK+1]=
49 {
50 "BOYS ORBITAL LOCALIZATION",
51 "EDMISTON-RUEDENBERG ENERGY LOCALIZATION",
52 "MOLECULAR ORBITALS LOCALIZED BY THE POPULATION METHOD"
53 };
54
55 typedef enum
56 {
57 GABEDIT_ORBTYPE_ALPHA = 0,
58 GABEDIT_ORBTYPE_BETA,
59 GABEDIT_ORBTYPE_MOLECULAR,
60 GABEDIT_ORBTYPE_MCSCF,
61 GABEDIT_ORBTYPE_EIGENVECTORS,
62 GABEDIT_ORBTYPE_BOYS_ALPHA,
63 GABEDIT_ORBTYPE_BOYS_BETA,
64 GABEDIT_ORBTYPE_BOYS,
65 GABEDIT_ORBTYPE_EDMISTON_ALPHA,
66 GABEDIT_ORBTYPE_EDMISTON_BETA,
67 GABEDIT_ORBTYPE_EDMISTON,
68 GABEDIT_ORBTYPE_PIPEK_ALPHA,
69 GABEDIT_ORBTYPE_PIPEK_BETA,
70 GABEDIT_ORBTYPE_PIPEK,
71 } GabEditOrbType;
72 static gchar* titlesOrb[GABEDIT_ORBTYPE_PIPEK+1]=
73 {
74 "----- ALPHA SET -----",
75 "----- BETA SET -----",
76 "MOLECULAR ORBITALS",
77 "MCSCF OPTIMIZED ORBITALS",
78 "EIGENVECTORS",
79 "***** ALPHA ORBITAL LOCALIZATION *****",
80 "****** BETA ORBITAL LOCALIZATION *****",
81 "THE BOYS LOCALIZED ORBITALS ARE",
82 "***** ALPHA ORBITAL LOCALIZATION *****",
83 "****** BETA ORBITAL LOCALIZATION *****",
84 "EDMISTON-RUEDENBERG ENERGY LOCALIZED ORBITALS",
85 "***** ALPHA ORBITAL LOCALIZATION *****",
86 "****** BETA ORBITAL LOCALIZATION *****",
87 "THE PIPEK-MEZEY POPULATION LOCALIZED ORBITALS ARE"
88 };
89 /********************************************************************************/
90 static gboolean sphericalBasis = FALSE;
91 /********************************************************************************/
get_charges_from_gamess_output_file(FILE * fd,gint N)92 static void get_charges_from_gamess_output_file(FILE* fd,gint N)
93 {
94 guint taille=BSIZE;
95 gchar t[BSIZE];
96 gchar dump[BSIZE];
97 gchar d[BSIZE];
98 gchar* pdest;
99 gint i;
100
101
102 while(!feof(fd) )
103 {
104 pdest = NULL;
105 if(!fgets(t,taille,fd)) break;
106 pdest = strstr( t, "TOTAL MULLIKEN AND LOWDIN ATOMIC POPULATIONS");
107
108 if(pdest)
109 {
110 if(!fgets(t,taille,fd)) break;
111 for(i=0;i<N;i++)
112 {
113 if(!fgets(t,taille,fd)) break;
114 if(sscanf(t,"%s %s %s %s %s %s",dump, dump ,dump, dump, dump, d)==6)
115 {
116 GeomOrb[i].partialCharge = atof(d);
117 }
118 else break;
119 }
120 break;
121 }
122 }
123 }
124 /********************************************************************************/
read_geomorb_gamess_file_geom(gchar * FileName)125 static gint* read_geomorb_gamess_file_geom(gchar *FileName)
126 {
127 gchar *t;
128 gchar *tmp = NULL;
129 gboolean OK;
130 gchar *AtomCoord[5];
131 FILE *fd;
132 guint taille=BSIZE;
133 guint i;
134 gint j=0;
135 guint numgeom;
136 gchar dum[100];
137 gint uni=1;
138 gint* znuc=NULL;
139 long geompos=0;
140
141 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
142
143 if ((!FileName) || (strcmp(FileName,"") == 0))
144 {
145 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
146 for(i=0;i<5;i++) g_free(AtomCoord[i]);
147 return NULL;
148 }
149
150 t=g_malloc(taille);
151 fd = FOpen(FileName, "rb");
152 if(fd ==NULL)
153 {
154 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
155 g_free(t);
156 for(i=0;i<5;i++) g_free(AtomCoord[i]);
157 return NULL;
158 }
159
160 init_dipole();
161 free_data_all();
162 tmp = get_name_file(FileName);
163 set_status_label_info(_("File name"),tmp);
164 g_free(tmp);
165 set_status_label_info(_("File type"),"Gamess");
166 numgeom =1;
167 do
168 {
169 set_status_label_info(_("Geometry"),_("Reading"));
170 OK=FALSE;
171 while(!feof(fd))
172 {
173 if(!fgets(t,taille,fd))break;
174 if ( strstr(t,"COORDINATES (BOHR)"))
175 {
176 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
177 numgeom++;
178 OK = TRUE;
179 uni = 0;
180 break;
181 }
182 if ( strstr(t,"COORDINATES OF ALL ATOMS ARE (ANGS)"))
183 {
184 { char* e = fgets(t,taille,fd);}
185 { char* e = fgets(t,taille,fd);}
186 numgeom++;
187 uni=1;
188 OK = TRUE;
189 break;
190 }
191 }
192 if(!OK && (numgeom == 1) )
193 {
194 Message(_("Sorry\nI can not read geometry from this file"),_("Error"),TRUE);
195 fclose(fd);
196 g_free(t);
197 for(i=0;i<5;i++) g_free(AtomCoord[i]);
198 set_status_label_info(_("File name"),_("Nothing"));
199 set_status_label_info(_("File type"),_("Nothing"));
200 set_status_label_info(_("Geometry"),_("Nothing"));
201 return NULL;
202 }
203 if(!OK)break;
204
205 j=-1;
206 while(!feof(fd) )
207 {
208 { char* e = fgets(t,taille,fd);}
209 if ( !strcmp(t,"\n"))
210 {
211 break;
212 }
213 if ( !strcmp(t,"\r\n")) break;
214 j++;
215 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
216 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
217 if(znuc==NULL) znuc=g_malloc(sizeof(gint));
218 else znuc=g_realloc(znuc,(j+1)*sizeof(gint));
219
220 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
221
222 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
223 znuc[j]=atoi(dum);
224 for(i=0;i<3;i++)
225 {
226 GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
227 if(uni==1) GeomOrb[j].C[i] *= ANG_TO_BOHR;
228 }
229
230 /* GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);*/ /* not here*/
231 }
232 geompos = ftell(fd);
233
234 }while(!feof(fd));
235
236 nCenters = j+1;
237 if(nCenters>0)
238 {
239 fseek(fd, geompos, SEEK_SET);
240 get_dipole_from_gamess_output_file(fd);
241 fseek(fd, geompos, SEEK_SET);
242 get_charges_from_gamess_output_file(fd,nCenters);
243 }
244 fclose(fd);
245 g_free(t);
246 for(i=0;i<5;i++) g_free(AtomCoord[i]);
247 if(nCenters == 0 )
248 {
249 g_free(GeomOrb);
250 g_free(znuc);
251 znuc = NULL;
252 }
253 else
254 {
255 DefineType();
256 /* PrintGeomOrb();*/
257 }
258 buildBondsOrb();
259 RebuildGeom = FALSE;
260 return znuc;
261 }
262 /********************************************************************************/
DefineGamessCartBasis()263 static void DefineGamessCartBasis()
264 {
265 gint i,j,k,n;
266 gint l1,l2,l3;
267 gint L;
268 gint *l[3]={NULL,NULL,NULL};
269 gint m;
270
271 NAOrb = 0;
272 for(i=0;i<nCenters;i++)
273 {
274 for(j=0;j<Type[GeomOrb[i].NumType].Norb;j++)
275 {
276 L=Type[GeomOrb[i].NumType].Ao[j].L;
277 NAOrb += (L+1)*(L+2)/2;
278 }
279 }
280
281 AOrb = g_malloc(NAOrb*sizeof(CGTF));
282 if(SAOrb) g_free(SAOrb);
283 SAOrb = NULL;
284
285 k=-1;
286 for(i=0;i<nCenters;i++)
287 for(j=0;j<Type[GeomOrb[i].NumType].Norb;j++)
288 {
289 L = Type[GeomOrb[i].NumType].Ao[j].L;
290
291 for(m=0;m<3;m++)
292 {
293 if(l[m])
294 g_free(l[m]);
295 l[m] = g_malloc((L+1)*(L+2)/2*sizeof(gint));
296 }
297 switch(L)
298 {
299 case 1 :
300 m=0;
301 l[0][m] = 1;l[1][m] = 0;l[2][m] = 0; /* X */
302 m++;
303 l[0][m] = 0;l[1][m] = 1;l[2][m] = 0; /* Y */
304 m++;
305 l[0][m] = 0;l[1][m] = 0;l[2][m] = 1; /* Z */
306 break;
307 case 2 :
308 m=0;
309 l[0][m] = 2;l[1][m] = 0;l[2][m] = 0; /* XX */
310 m++;
311 l[0][m] = 0;l[1][m] = 2;l[2][m] = 0; /* YY */
312 m++;
313 l[0][m] = 0;l[1][m] = 0;l[2][m] = 2; /* ZZ */
314 m++;
315 l[0][m] = 1;l[1][m] = 1;l[2][m] = 0; /* XY */
316 m++;
317 l[0][m] = 1;l[1][m] = 0;l[2][m] = 1; /* XZ */
318 m++;
319 l[0][m] = 0;l[1][m] = 1;l[2][m] = 1; /* YZ */
320 break;
321 case 3 :
322 m=0;
323 l[0][m] = 3;l[1][m] = 0;l[2][m] = 0; /* XXX */
324 m++;
325 l[0][m] = 0;l[1][m] = 3;l[2][m] = 0; /* YYY */
326 m++;
327 l[0][m] = 0;l[1][m] = 0;l[2][m] = 3; /* ZZZ */
328 m++;
329 l[0][m] = 2;l[1][m] = 1;l[2][m] = 0; /* XXY */
330 m++;
331 l[0][m] = 2;l[1][m] = 0;l[2][m] = 1; /* XXZ */
332 m++;
333 l[0][m] = 1;l[1][m] = 2;l[2][m] = 0; /* YYX */
334 m++;
335 l[0][m] = 0;l[1][m] = 2;l[2][m] = 1; /* YYZ */
336 m++;
337 l[0][m] = 1;l[1][m] = 0;l[2][m] = 2; /* ZZX */
338 m++;
339 l[0][m] = 0;l[1][m] = 1;l[2][m] = 2; /* ZZY */
340 m++;
341 l[0][m] = 1;l[1][m] = 1;l[2][m] = 1; /* XYZ */
342 break;
343 case 4 :
344 m=0; l[0][m] = 4;l[1][m] = 0;l[2][m] = 0; /* XXXX */
345 m++; l[0][m] = 0;l[1][m] = 4;l[2][m] = 0; /* YYYY */
346 m++; l[0][m] = 0;l[1][m] = 0;l[2][m] = 4; /* ZZZZ */
347 m++; l[0][m] = 3;l[1][m] = 1;l[2][m] = 0; /* XXXY */
348 m++; l[0][m] = 3;l[1][m] = 0;l[2][m] = 1; /* XXXZ */
349 m++; l[0][m] = 1;l[1][m] = 3;l[2][m] = 0; /* YYYX */
350 m++; l[0][m] = 0;l[1][m] = 3;l[2][m] = 1; /* YYYZ */
351 m++; l[0][m] = 1;l[1][m] = 0;l[2][m] = 3; /* ZZZX */
352 m++; l[0][m] = 0;l[1][m] = 1;l[2][m] = 3; /* ZZZY */
353 m++; l[0][m] = 2;l[1][m] = 2;l[2][m] = 0; /* XXYY */
354 m++; l[0][m] = 2;l[1][m] = 0;l[2][m] = 2; /* XXZZ */
355 m++; l[0][m] = 0;l[1][m] = 2;l[2][m] = 2; /* YYZZ */
356 m++; l[0][m] = 2;l[1][m] = 1;l[2][m] = 1; /* XXYZ */
357 m++; l[0][m] = 1;l[1][m] = 2;l[2][m] = 1; /* YYXZ */
358 m++; l[0][m] = 1;l[1][m] = 1;l[2][m] = 2; /* ZZXY */
359 break;
360 default :
361 m=0;
362 for(l3=Type[GeomOrb[i].NumType].Ao[j].L;l3>=0;l3--)
363 for(l2=Type[GeomOrb[i].NumType].Ao[j].L-l3;l2>=0;l2--)
364 {
365 l1 = Type[GeomOrb[i].NumType].Ao[j].L-l2-l3;
366 l[0][m] = l1;
367 l[1][m] = l2;
368 l[2][m] = l3;
369 m++;
370 }
371 }
372 for(m=0;m<(L+1)*(L+2)/2;m++)
373 {
374 l1 = l[0][m];
375 l2 = l[1][m];
376 l3 = l[2][m];
377 k++;
378 AOrb[k].numberOfFunctions=Type[GeomOrb[i].NumType].Ao[j].N;
379 AOrb[k].NumCenter = i;
380 AOrb[k].Gtf =g_malloc(AOrb[k].numberOfFunctions*sizeof(GTF));
381 for(n=0;n<AOrb[k].numberOfFunctions;n++)
382 {
383 AOrb[k].Gtf[n].Ex = Type[GeomOrb[i].NumType].Ao[j].Ex[n];
384 AOrb[k].Gtf[n].Coef = Type[GeomOrb[i].NumType].Ao[j].Coef[n];
385 AOrb[k].Gtf[n].C[0] = GeomOrb[i].C[0];
386 AOrb[k].Gtf[n].C[1] = GeomOrb[i].C[1];
387 AOrb[k].Gtf[n].C[2] = GeomOrb[i].C[2];
388 AOrb[k].Gtf[n].l[0] = l1;
389 AOrb[k].Gtf[n].l[1] = l2;
390 AOrb[k].Gtf[n].l[2] = l3;
391 }
392
393 }
394 }
395
396 NOrb = NAOrb;
397 DefineAtomicNumOrb();
398 /* DefineNorb();*/
399 }
400 /********************************************************************************/
read_basis_from_a_gamess_output_file(gchar * FileName,gint * nrs)401 static gchar** read_basis_from_a_gamess_output_file(gchar *FileName, gint* nrs)
402 {
403 gchar **strbasis;
404 gchar *t;
405 FILE *fd;
406 gint taille=BSIZE;
407 gint nrows=0;
408 gboolean OK = FALSE;
409
410 if ((!FileName) || (strcmp(FileName,"") == 0))
411 {
412 Message(_("Sorry No file selected\n"),_("Error"),TRUE);
413 return NULL;
414 }
415
416 fd = FOpen(FileName, "rb");
417 if(fd ==NULL)
418 {
419 gchar buffer[BSIZE];
420 sprintf(buffer,_("Sorry, I can not open '%s' file\n"),FileName);
421 Message(buffer,_("Error"),TRUE);
422 return NULL;
423 }
424
425 t=g_malloc(taille*sizeof(gchar));
426 while(!feof(fd))
427 {
428 if(!fgets(t,taille,fd))break;
429 if(strstr(t,"ATOMIC BASIS SET"))
430 {
431 OK = TRUE;
432 break;
433 }
434 }
435 if(OK)
436 {
437 OK = FALSE;
438 while(!feof(fd))
439 {
440 if(!fgets(t,taille,fd))break;
441 if(strstr(t,"SHELL TYPE"))
442 if(strstr(t,"EXPONENT"))
443 {
444 OK = TRUE;
445 break;
446 }
447 }
448 }
449 if(!OK)
450 {
451 g_free(t);
452 Message(_("Sorry I can read basis from this file\n"),_("Error"),TRUE);
453 return NULL;
454 }
455 { char* e = fgets(t,taille,fd);}
456
457 strbasis=g_malloc(sizeof(gchar*));
458 while(!feof(fd))
459 {
460 { char* e = fgets(t,taille,fd);}
461 if(strstr(t,"TOTAL NUMBER OF")) break;
462 nrows++;
463 strbasis = g_realloc(strbasis,nrows*sizeof(gchar*));
464 strbasis[nrows-1] = g_strdup(t);
465 }
466 if(nrows == 0)
467 {
468 g_free(t);
469 g_free(strbasis);
470 Message(_("Sorry I can read basis in this file\n"),_("Error"),TRUE);
471 return NULL;
472 }
473
474 /*
475 Debug("End of read \n");
476 Debug("Atomic basis nrows = %d \n",nrows);
477 for(i=0;i<nrows;i++)
478 {
479 Debug("%s",strbasis[i]);
480 }
481 */
482
483 fclose(fd);
484 g_free(t);
485 *nrs = nrows;
486 return strbasis;
487 }
488 /**********************************************/
get_num_type_from_symbol(gchar * symbol)489 static gint get_num_type_from_symbol(gchar* symbol)
490 {
491 gint k;
492 for(k=0;k<nCenters;k++)
493 {
494 if(strcmp(symbol,GeomOrb[k].Symb)==0)
495 return (gint)GeomOrb[k].NumType;
496 }
497 return -1;
498 }
499 /**********************************************/
addOneBasis(gint i,gint j,gchar * shell,gint ncont,gdouble * ex,gdouble * coef)500 static gboolean addOneBasis(gint i,gint j,gchar *shell,gint ncont, gdouble* ex, gdouble* coef)
501 {
502 gint jj;
503 Type[i].Ao[j].N = ncont;
504 Type[i].Ao[j].Ex=g_malloc(Type[i].Ao[j].N*sizeof(gdouble));
505 Type[i].Ao[j].Coef=g_malloc(Type[i].Ao[j].N*sizeof(gdouble));
506 for(jj=0;jj<Type[i].Ao[j].N;jj++)
507 {
508 Type[i].Ao[j].Ex[jj] = ex[jj];
509 Type[i].Ao[j].Coef[jj] = coef[jj];
510 }
511 switch(shell[0])
512 {
513 /* L =SP with Gamess */
514 case 'l' :
515 case 'L' :
516 case 's' :
517 case 'S' : Type[i].Ao[j].L=0;break;
518 case 'p' :
519 case 'P' : Type[i].Ao[j].L=1;break;
520 case 'd' :
521 case 'D' : Type[i].Ao[j].L=2;break;
522 case 'f' :
523 case 'F' : Type[i].Ao[j].L=3;break;
524 case 'g' :
525 case 'G' : Type[i].Ao[j].L=4;break;
526 case 'h' :
527 case 'H' : Type[i].Ao[j].L=5;break;
528 case 'i' :
529 case 'I' : Type[i].Ao[j].L=6;break;
530 case 'j' :
531 case 'J' : Type[i].Ao[j].L=7;break;
532 case 'k' :
533 case 'K' : Type[i].Ao[j].L=8;break;
534
535 default : return FALSE;
536 }
537 return TRUE;
538 }
539 /**********************************************/
DefineGamessBasisType(gchar ** strbasis,gint nrows)540 static gboolean DefineGamessBasisType(gchar** strbasis, gint nrows)
541 {
542 gchar sym[50];
543 gchar shell[10];
544 gchar t[10];
545 gint i;
546 gint j;
547 gint nconts;
548 gint k;
549 gdouble *ex=NULL;
550 gdouble *coef1=NULL;
551 gdouble *coef2=NULL;
552 gchar* temp[10];
553 gint ne;
554 gboolean Ok;
555 gint jj;
556
557 if(Ntype<1) return FALSE;
558 if(nrows<1) return FALSE;
559 ex = g_malloc(nrows*sizeof(gdouble));
560 coef1 = g_malloc(nrows*sizeof(gdouble));
561 coef2 = g_malloc(nrows*sizeof(gdouble));
562 for(i=0;i<10;i++) temp[i] = g_malloc(BSIZE*sizeof(gchar));
563
564 /*
565 for(k=0;k<nCenters;k++)
566 {
567 printf("%s %d\n",GeomOrb[k].Symb,GeomOrb[k].NumType);
568 }
569 */
570
571 Type = g_malloc(Ntype*sizeof(TYPE));
572 for(i=0;i<Ntype;i++)
573 {
574 Type[i].Ao = NULL;
575 Type[i].Norb=0;
576 }
577 for(k=0;k<nCenters;k++)
578 {
579 sprintf(sym,"%s",GeomOrb[k].Symb);
580 i = GeomOrb[k].NumType;
581 /* printf("numType = %d\n",k);*/
582 Type[i].Symb=g_strdup(sym);
583 Type[i].N=GetNelectrons(sym);
584 }
585 /* set number of basis by type */
586 i = -1;
587 sprintf(shell,"S");
588 nconts=-1;
589 Ok = TRUE;
590 for(k=0;k<nrows;k++)
591 {
592 if(this_is_a_backspace(strbasis[k])&&i==-1)continue;
593 if(this_is_a_backspace(strbasis[k]))
594 {
595 gint j = Type[i].Norb;
596 if(strcmp(shell,"L")==0) Type[i].Norb+=2;
597 else Type[i].Norb++;
598 if(Type[i].Ao == NULL)
599 Type[i].Ao=g_malloc(Type[i].Norb*sizeof(AO));
600 else
601 Type[i].Ao=g_realloc(Type[i].Ao,Type[i].Norb*sizeof(AO));
602 for(jj=j;jj< Type[i].Norb;jj++)
603 {
604 Type[i].Ao[jj].Ex = NULL;
605 Type[i].Ao[jj].Coef = NULL;
606 }
607
608
609 if(!addOneBasis(i,j,shell,nconts, ex, coef1))
610 {
611 Ok = FALSE;
612 break;
613 }
614 if(strcmp(shell,"L")==0)
615 {
616 if(!addOneBasis(i,j+1,"P",nconts, ex, coef2))
617 {
618 Ok = FALSE;
619 break;
620 }
621 }
622
623 /*
624 printf("shell =%s ",shell);
625 printf("nconts =%d\n",nconts);
626 */
627 nconts=0;
628 continue;
629 }
630 sscanf(strbasis[k],"%s",t);
631 if(!isdigit(t[0])) /* symbol of atom*/
632 {
633 /*
634 for(i=1;i<strlen(t);i++)
635 if(isdigit(t[i])) t[i] = ' ';
636 delete_last_spaces(t);
637 */
638
639 i=get_num_type_from_symbol(t);
640 if(i<0)
641 {
642 Ok = FALSE;
643 break;
644 }
645 /* printf("symb =%s i = %d\n",t,i);*/
646 Type[i].Norb=0;
647 nconts=0;
648 k++;
649 continue;
650 }
651 sscanf(strbasis[k],"%s %s",t,shell);
652 if(strstr(strbasis[k],"(") && strstr(strbasis[k],")"))
653 {
654 gchar dum1[BSIZE];
655 gchar dum2[BSIZE];
656 for(j=0;j<strlen(strbasis[k]);j++)
657 {
658 if(strbasis[k][j]==')') strbasis[k][j]=' ';
659 if(strbasis[k][j]=='(') strbasis[k][j]=' ';
660 }
661 ne = sscanf(strbasis[k],"%s %s %s %s %s %s %s %s",t,shell,temp[3],temp[0],dum1, temp[1],dum2, temp[2]);
662 if(ne==8) ne = 6;
663 else if(ne==6) ne = 5;
664 }
665 else
666 ne = sscanf(strbasis[k],"%s %s %s %s %s %s",t,shell,temp[3],temp[0],temp[1],temp[2]);
667 if(ne<5)
668 {
669 Ok = FALSE;
670 break;
671 }
672 for(j=0;j<ne-3;j++)
673 {
674 gchar* d=strstr(temp[j],"D");
675 if(d) *d='e';
676 }
677 if(ne>=4) ex[nconts]=atof(temp[0]);
678 if(ne>=5) coef1[nconts]=atof(temp[1]);
679 if(ne==6) coef2[nconts]=atof(temp[2]);
680 nconts++;
681
682 }
683 if(!Ok)
684 {
685 if(Type)
686 for(i=0;i<Ntype;i++)
687 {
688 if(Type[i].Ao != NULL)
689 {
690 for(j=0;j<Type[i].Norb;j++)
691 {
692 if(Type[i].Ao[j].Ex != NULL) g_free(Type[i].Ao[j].Ex);
693 if(Type[i].Ao[j].Coef != NULL) g_free(Type[i].Ao[j].Coef);
694 }
695 g_free(Type[i].Ao);
696 }
697 }
698
699 if(Type) g_free(Type);
700 if(ex) g_free(ex);
701 if(coef1) g_free(coef1);
702 if(coef2) g_free(coef2);
703 for(j=0;j<10;j++) g_free(temp[j]);
704 return FALSE;
705 }
706 if(ex) g_free(ex);
707 if(coef1) g_free(coef1);
708 if(coef2) g_free(coef2);
709 for(j=0;j<10;j++) g_free(temp[j]);
710
711 return TRUE;
712 }
713 /********************************************************************************/
get_number_of_ecp_core_electrons(gchar * FileName)714 static gint get_number_of_ecp_core_electrons(gchar* FileName)
715 {
716 gchar *t;
717 FILE *file;
718 gint ne = 0;
719
720 if ((!FileName) || (strcmp(FileName,"") == 0)) return ne;
721
722 t=g_malloc(BSIZE*sizeof(gchar));
723 file = FOpen(FileName, "rb");
724 if(file ==NULL) return ne;
725
726 while(!feof(file))
727 {
728 if(!fgets(t,BSIZE,file))break;
729 if(strstr(t,"ECP") && strstr(t,"REMOVES") &&strstr(t,"CORE") &&strstr(t,"ELECTRONS"))
730 {
731 gchar* equal=strstr(t,"REMOVES");
732 if(equal) ne=atoi(equal+strlen("REMOVES"));
733 }
734 if(strstr(t,"NUMBER OF OCCUPIED ORBITALS") && strstr(t,"KEPT"))/* recent version of GAMESS-US */
735 {
736 ne = 0;
737 break;
738 }
739 }
740 if(t!=NULL) g_free(t);
741 if(file) fclose(file);
742 return ne;
743 }
744 /********************************************************************************/
get_number_of_occuped_orbitals(gchar * FileName,gint * nAlpha,gint * nBeta)745 static void get_number_of_occuped_orbitals(gchar* FileName, gint* nAlpha, gint* nBeta)
746 {
747 gchar *t;
748 FILE *file;
749 gchar *tag=NULL;
750 gint necore = 0;
751
752 *nAlpha=-1;
753 *nBeta=-1;
754 if ((!FileName) || (strcmp(FileName,"") == 0)) return;
755
756 t=g_malloc(BSIZE*sizeof(gchar));
757 file = FOpen(FileName, "rb");
758 if(file ==NULL) return;
759
760 tag=g_strdup_printf("NUMBER OF OCCUPIED ORBITALS ");
761 while(!feof(file))
762 {
763 if(!fgets(t,BSIZE,file))break;
764 if(strstr(t,tag))
765 {
766 gchar* equal=strstr(t,"=");
767 if(equal) *nAlpha=atoi(equal+1);
768 if(!fgets(t,BSIZE,file))break;
769 equal=strstr(t,"=");
770 if(equal) *nBeta=atoi(equal+1);
771 }
772
773 }
774 if(tag!=NULL) g_free(tag);
775 if(t!=NULL) g_free(t);
776 if(file) fclose(file);
777 necore = get_number_of_ecp_core_electrons(FileName);
778 *nAlpha -= necore/2;
779 *nBeta -= necore/2;
780 if(*nAlpha<0) *nAlpha= 0;
781 if(*nBeta<0) *nBeta= 0;
782 }
783 /********************************************************************************/
get_local_orbital_type(gchar * fileName)784 static GabEditOrbLocalType get_local_orbital_type(gchar *fileName)
785 {
786 gchar *t;
787 FILE *file;
788 gint taille=BSIZE;
789
790 if ((!fileName) || (strcmp(fileName,"") == 0)) return GABEDIT_ORBLOCALTYPE_UNKNOWN;
791
792 t=g_malloc(taille);
793 file = FOpen(fileName, "rb");
794 if(file ==NULL) return GABEDIT_ORBLOCALTYPE_UNKNOWN;
795 while(!feof(file))
796 {
797 GabEditOrbLocalType i;
798 if(!fgets(t,taille,file))break;
799 for(i=GABEDIT_ORBLOCALTYPE_BOYS;i<=GABEDIT_ORBLOCALTYPE_PIPEK;i++)
800 {
801 if(strstr( t,titlesLocalOrb[i]))
802 {
803 g_free(t);
804 return i;
805 }
806 }
807 }
808 g_free(t);
809 return GABEDIT_ORBLOCALTYPE_UNKNOWN;
810 }
811 /********************************************************************************/
read_last_orbitals_in_gamess_file(gchar * fileName,GabEditOrbType itype,gint nAlpha,gint nBeta)812 static gboolean read_last_orbitals_in_gamess_file(gchar *fileName,GabEditOrbType itype, gint nAlpha, gint nBeta)
813 {
814 gchar *t;
815 gboolean OK;
816 gchar *dum[5];
817 FILE *fd;
818 gint taille=BSIZE;
819 gint i;
820 gint numorb;
821 gchar *pdest = NULL;
822 gint NumOrb[5];
823 gchar SymOrb[5][10];
824 gdouble EnerOrb[5];
825 gint ncart;
826 gint n;
827 gint k,k1,k2,k3;
828 gint j;
829 gdouble **CoefOrbitals;
830 gdouble *EnerOrbitals;
831 gchar **SymOrbitals;
832 gchar* tmp = NULL;
833 gint ibegin = 0;
834
835 if ((!fileName) || (strcmp(fileName,"") == 0))
836 {
837 Message(_("Sorry No file selected\n"),_("Error"),TRUE);
838 return FALSE;
839 }
840
841 t=g_malloc(taille);
842 fd = FOpen(fileName, "rb");
843 if(fd ==NULL)
844 {
845 gchar buffer[BSIZE];
846 sprintf(buffer,_("Sorry, I can not open '%s' file\n"),fileName);
847 Message(buffer,_("Error"),TRUE);
848 return FALSE;
849 }
850 for(i=0;i<5;i++) dum[i]=g_malloc(BSIZE*sizeof(gchar));
851
852 /* Debug("Norb = %d\n",NOrb);*/
853 CoefOrbitals = CreateTable2(NOrb);
854 EnerOrbitals = g_malloc(NOrb*sizeof(gdouble));
855 SymOrbitals = g_malloc(NOrb*sizeof(gchar*));
856
857 numorb =1;
858 do
859 {
860 OK=FALSE;
861 while(!feof(fd))
862 {
863 if(!fgets(t,taille,fd))break;
864 switch(itype)
865 {
866 case GABEDIT_ORBTYPE_ALPHA :
867 pdest = strstr( t, titlesOrb[itype]);
868 break;
869 case GABEDIT_ORBTYPE_BETA :
870 pdest = strstr( t, titlesOrb[itype]);
871 break;
872 case GABEDIT_ORBTYPE_MOLECULAR:
873 pdest = strstr( t, titlesOrb[itype] );
874 if(pdest)
875 {
876 gchar b1[100];
877 if(sscanf(t,"%s %s %s",b1,b1,b1)!=2) pdest = NULL;
878 }
879 break;
880 case GABEDIT_ORBTYPE_MCSCF:
881 pdest = strstr( t,titlesOrb[itype]);
882 break;
883 case GABEDIT_ORBTYPE_EIGENVECTORS:
884 pdest = strstr( t, titlesOrb[itype] );
885 if(pdest)
886 {
887 gchar dump1[BSIZE];
888 gchar dump2[BSIZE];
889 gint k = sscanf(t,"%s %s",dump1,dump2);
890 if(k!=1 || strcmp(dump1,titlesOrb[itype])!=0) pdest=NULL;
891 }
892 break;
893 case GABEDIT_ORBTYPE_BOYS_ALPHA:
894 pdest = strstr( t,titlesOrb[itype]);
895 break;
896 case GABEDIT_ORBTYPE_BOYS_BETA:
897 pdest = strstr( t,titlesOrb[itype]);
898 break;
899 case GABEDIT_ORBTYPE_BOYS:
900 pdest = strstr( t,titlesOrb[itype]);
901 break;
902 case GABEDIT_ORBTYPE_EDMISTON_ALPHA:
903 pdest = strstr( t,titlesOrb[itype]);
904 break;
905 case GABEDIT_ORBTYPE_EDMISTON_BETA:
906 pdest = strstr( t,titlesOrb[itype]);
907 break;
908 case GABEDIT_ORBTYPE_EDMISTON:
909 pdest = strstr( t,titlesOrb[itype]);
910 break;
911 case GABEDIT_ORBTYPE_PIPEK_ALPHA:
912 pdest = strstr( t,titlesOrb[itype]);
913 break;
914 case GABEDIT_ORBTYPE_PIPEK_BETA:
915 pdest = strstr( t,titlesOrb[itype]);
916 break;
917 case GABEDIT_ORBTYPE_PIPEK:
918 pdest = strstr( t,titlesOrb[itype]);
919 break;
920 }
921 if ( pdest != NULL )
922 {
923 numorb++;
924 OK = TRUE;
925 break;
926 }
927 }
928 if(!OK && (numorb == 1) )
929 {
930 if(
931 itype==GABEDIT_ORBTYPE_BETA ||
932 itype==GABEDIT_ORBTYPE_EIGENVECTORS ||
933 itype==GABEDIT_ORBTYPE_BOYS_BETA ||
934 itype==GABEDIT_ORBTYPE_EDMISTON_BETA ||
935 itype==GABEDIT_ORBTYPE_PIPEK_BETA
936 )
937 {
938 gchar buffer[BSIZE];
939 sprintf(buffer,_("Sorry, I can not read orbitals from '%s' file\n"),fileName);
940 Message(buffer,_("Error"),TRUE);
941 }
942 FreeTable2(CoefOrbitals,NOrb);
943 g_free(EnerOrbitals);
944 g_free(SymOrbitals);
945 fclose(fd);
946 g_free(t);
947 return FALSE;
948 }
949 if(!OK)
950 {
951 /* Debug("End of read \n");*/
952 fclose(fd);
953 g_free(t);
954 for(i=0;i<5;i++) g_free(dum[i]);
955
956 switch(itype)
957 {
958 case GABEDIT_ORBTYPE_ALPHA :
959 case GABEDIT_ORBTYPE_BOYS_ALPHA:
960 case GABEDIT_ORBTYPE_EDMISTON_ALPHA:
961 case GABEDIT_ORBTYPE_PIPEK_ALPHA:
962 CoefAlphaOrbitals = CoefOrbitals;
963 EnerAlphaOrbitals = EnerOrbitals;
964
965 SymAlphaOrbitals = SymOrbitals;
966
967 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
968 for(i=0;i<nAlpha;i++) OccAlphaOrbitals[i] = 1.0;
969 for(i=nAlpha;i<NOrb;i++) OccAlphaOrbitals[i] = 0.0;
970
971 NAlphaOcc = nAlpha;
972 NAlphaOrb = NOrb;
973 break;
974
975 case GABEDIT_ORBTYPE_BETA :
976 case GABEDIT_ORBTYPE_BOYS_BETA:
977 case GABEDIT_ORBTYPE_EDMISTON_BETA:
978 case GABEDIT_ORBTYPE_PIPEK_BETA:
979 CoefBetaOrbitals = CoefOrbitals;
980 EnerBetaOrbitals = EnerOrbitals;
981 SymBetaOrbitals = SymOrbitals;
982
983 OccBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
984 for(i=0;i<nBeta;i++) OccBetaOrbitals[i] = 1.0;
985 for(i=nBeta;i<NOrb;i++) OccBetaOrbitals[i] = 0.0;
986
987 NBetaOcc = nBeta;
988 NBetaOrb = NOrb;
989 break;
990
991 case GABEDIT_ORBTYPE_MOLECULAR:
992 case GABEDIT_ORBTYPE_MCSCF:
993 case GABEDIT_ORBTYPE_EIGENVECTORS:
994 case GABEDIT_ORBTYPE_BOYS:
995 case GABEDIT_ORBTYPE_EDMISTON:
996 case GABEDIT_ORBTYPE_PIPEK:
997 CoefAlphaOrbitals = CoefOrbitals;
998 EnerAlphaOrbitals = EnerOrbitals;
999 SymAlphaOrbitals = SymOrbitals;
1000 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
1001 for(i=0;i<nAlpha;i++) OccAlphaOrbitals[i] = 1.0;
1002 for(i=nAlpha;i<NOrb;i++) OccAlphaOrbitals[i] = 0.0;
1003
1004 CoefBetaOrbitals = CoefOrbitals;
1005 EnerBetaOrbitals = EnerOrbitals;
1006 OccBetaOrbitals = OccAlphaOrbitals;
1007 SymBetaOrbitals = SymOrbitals;
1008 NAlphaOcc = nAlpha;
1009 NBetaOcc = nBeta;
1010 NAlphaOrb = NOrb;
1011 NBetaOrb = NOrb;
1012 break;
1013 }
1014 return TRUE;
1015 }
1016 switch(itype)
1017 {
1018 case GABEDIT_ORBTYPE_BOYS_ALPHA:
1019 case GABEDIT_ORBTYPE_BOYS_BETA:
1020 while(!feof(fd))
1021 {
1022 if(!fgets(t,taille,fd))break;
1023 if(strstr(t,titlesOrb[GABEDIT_ORBTYPE_BOYS]))
1024 {
1025 { char* e = fgets(t,taille,fd);}
1026 break;
1027 }
1028 }
1029 break;
1030 case GABEDIT_ORBTYPE_EDMISTON_ALPHA:
1031 case GABEDIT_ORBTYPE_EDMISTON_BETA:
1032 while(!feof(fd))
1033 {
1034 if(!fgets(t,taille,fd))break;
1035 if(strstr(t,titlesOrb[GABEDIT_ORBTYPE_EDMISTON]))
1036 {
1037 { char* e = fgets(t,taille,fd);}
1038 break;
1039 }
1040 }
1041 break;
1042 case GABEDIT_ORBTYPE_PIPEK_ALPHA:
1043 case GABEDIT_ORBTYPE_PIPEK_BETA:
1044 while(!feof(fd))
1045 {
1046 if(!fgets(t,taille,fd))break;
1047 if(strstr(t,titlesOrb[GABEDIT_ORBTYPE_PIPEK]))
1048 {
1049 { char* e = fgets(t,taille,fd);}
1050 break;
1051 }
1052 }
1053 break;
1054 case GABEDIT_ORBTYPE_ALPHA :
1055 case GABEDIT_ORBTYPE_BETA :
1056 { char* e = fgets(t,taille,fd);}
1057 { char* e = fgets(t,taille,fd);}
1058 { char* e = fgets(t,taille,fd);}
1059 { char* e = fgets(t,taille,fd);}
1060 { char* e = fgets(t,taille,fd);}
1061 break;
1062 case GABEDIT_ORBTYPE_MOLECULAR:
1063 case GABEDIT_ORBTYPE_MCSCF:
1064 case GABEDIT_ORBTYPE_EIGENVECTORS:
1065 /* error message of version */
1066 while(!feof(fd))
1067 {
1068 if(!fgets(t,taille,fd))break;
1069 {
1070 gint d;
1071 gint k = sscanf(t,"%d",&d);
1072 if(k==1 && d>0) {ibegin=1;break;}
1073 }
1074 }
1075 break;
1076 case GABEDIT_ORBTYPE_BOYS:
1077 case GABEDIT_ORBTYPE_EDMISTON:
1078 case GABEDIT_ORBTYPE_PIPEK:
1079 { char* e = fgets(t,taille,fd);}
1080 }
1081
1082 ncart=NOrb/5;
1083 if(NOrb%5>0) ncart++;
1084 gint no=0;
1085 for(n=0;n<ncart;n++)
1086 {
1087 if(ibegin ==0) {if(!fgets(t,taille,fd))break;}
1088 else ibegin = 0;
1089 k1 = sscanf(t,"%d %d %d %d %d",&NumOrb[0],&NumOrb[1],&NumOrb[2],&NumOrb[3],&NumOrb[4]);
1090 for(i=0;i<k1;i++) NumOrb[i]--;
1091 for(i=0;i<k1;i++)
1092 {
1093 if(NumOrb[i]<0 || NumOrb[i]>NOrb-1) break;
1094 }
1095 if(k1<1)
1096 {
1097 break;
1098 }
1099
1100 { char* e = fgets(t,taille,fd);}
1101 k2 = sscanf(t,"%lf %lf %lf %lf %lf", &EnerOrb[0], &EnerOrb[1], &EnerOrb[2], &EnerOrb[3], &EnerOrb[4]);
1102 for(i=0;i<k2;i++) EnerOrbitals[NumOrb[i]] = EnerOrb[i];
1103 if(k2>0)
1104 {
1105 { char* e = fgets(t,taille,fd);}
1106 /* Debug("%d %d %d %d %d\n",NumOrb[0],NumOrb[1],NumOrb[2],NumOrb[3],NumOrb[4]);*/
1107 k3 = sscanf(t,"%s %s %s %s %s",SymOrb[0],SymOrb[1],SymOrb[2],SymOrb[3],SymOrb[4]);
1108 /* Debug("%s %s %s %s %s\n",SymOrb[0],SymOrb[1],SymOrb[2],SymOrb[3],SymOrb[4]);*/
1109
1110 for(i=0;i<k3;i++) SymOrbitals[NumOrb[i]] = g_strdup(SymOrb[i]);
1111 }
1112 else
1113 {
1114 for(i=0;i<k1;i++) EnerOrbitals[NumOrb[i]] = 0.0;
1115 if(
1116 itype==GABEDIT_ORBTYPE_BOYS_ALPHA
1117 || itype==GABEDIT_ORBTYPE_BOYS_BETA
1118 || itype==GABEDIT_ORBTYPE_BOYS
1119 )
1120 for(i=0;i<k1;i++) SymOrbitals[NumOrb[i]] = g_strdup("BOYS");
1121 else
1122 if(
1123 itype==GABEDIT_ORBTYPE_EDMISTON_ALPHA
1124 || itype==GABEDIT_ORBTYPE_EDMISTON_BETA
1125 || itype==GABEDIT_ORBTYPE_EDMISTON
1126 )
1127 for(i=0;i<k1;i++) SymOrbitals[NumOrb[i]] = g_strdup("EDMISTON-RUEDENBERG");
1128
1129 else
1130 if(
1131 itype==GABEDIT_ORBTYPE_PIPEK_ALPHA
1132 || itype==GABEDIT_ORBTYPE_PIPEK_BETA
1133 || itype==GABEDIT_ORBTYPE_PIPEK
1134 )
1135 for(i=0;i<k1;i++) SymOrbitals[NumOrb[i]] = g_strdup("PIPEK-MEZEY");
1136 else for(i=0;i<k1;i++) SymOrbitals[NumOrb[i]] = g_strdup("UNK");
1137 k3 = k1;
1138 }
1139 for(i=0;i<NOrb;i++)
1140 {
1141 { char* e = fgets(t,taille,fd);}
1142 tmp = t + 17;
1143 k = sscanf(tmp,"%s %s %s %s %s",dum[0], dum[1], dum[2], dum[3], dum[4]);
1144 for(j=0;j<k;j++) CoefOrbitals[NumOrb[j]][i]=atof(dum[j]);
1145 }
1146 { char* e = fgets(t,taille,fd);}
1147 no+=k3;
1148 if(k3<5)break;
1149 }
1150 if(no<NOrb)
1151 {
1152 for(j=no;j<NOrb;j++)
1153 {
1154 EnerOrbitals[j]=0;
1155 SymOrbitals[j] = g_strdup("DELETED");
1156 for(i=0;i<NOrb;i++)
1157 {
1158 CoefOrbitals[j][i]=0.0;
1159 }
1160 }
1161 }
1162 /* Debug("End ncart\n"); */
1163
1164 }while(!feof(fd));
1165
1166 /* Debug("End of read \n"); */
1167 fclose(fd);
1168 g_free(t);
1169 for(i=0;i<5;i++) g_free(dum[i]);
1170
1171 CoefAlphaOrbitals = CoefOrbitals;
1172 EnerAlphaOrbitals = EnerOrbitals;
1173 return TRUE;
1174 }
1175 /********************************************************************************/
read_gamess_orbitals(gchar * FileName)1176 void read_gamess_orbitals(gchar* FileName)
1177 {
1178 gint typefile;
1179 /* gint typebasis=1;*/ /* Gamess print OM in cartezian presentation even ISPHER=0 or 1 or -1 */
1180 gchar *t = NULL;
1181 gint nrs;
1182 gchar** strbasis=NULL;
1183 gint i;
1184 gint* znuc;
1185 gboolean Ok;
1186 gint nAlpha;
1187 gint nBeta;
1188 GabEditOrbLocalType typeLocal;
1189
1190
1191 typefile =get_type_file_orb(FileName);
1192 if(typefile==GABEDIT_TYPEFILE_UNKNOWN) return;
1193
1194
1195 if(typefile != GABEDIT_TYPEFILE_GAMESS)
1196 {
1197 gchar buffer[BSIZE];
1198 sprintf(buffer,_("Sorry, I can not read this format from '%s' file\n"),FileName);
1199 Message(buffer,_("Error"),TRUE);
1200 return ;
1201 }
1202
1203 free_data_all();
1204 t = get_name_file(FileName);
1205 set_status_label_info(_("File name"),t);
1206 g_free(t);
1207 set_status_label_info(_("File type"),"Gamess");
1208 set_status_label_info(_("Mol. Orb."),_("Reading"));
1209
1210 free_orbitals();
1211
1212 /* typebasis =get_type_basis_in_gamess_file(FileName);
1213 if(typebasis == -1)
1214 {
1215 gchar buffer[BSIZE];
1216 sprintf(buffer,
1217 "Sorry, Gabedit does not support spherical basis with contaminant cartezian function\n\n"
1218 "Use ISPHER=-1 or ISPHER=1 in CONTROL block"
1219 );
1220 Message(buffer,_("Error"),TRUE);
1221 set_status_label_info(_("File name"),_("Nothing"));
1222 set_status_label_info(_("File type"),_("Nothing"));
1223 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1224 return;
1225 }
1226 */
1227
1228 znuc = read_geomorb_gamess_file_geom(FileName);
1229 if(znuc==NULL)
1230 {
1231 free_geometry();
1232 set_status_label_info(_("File name"),_("Nothing"));
1233 set_status_label_info(_("File type"),_("Nothing"));
1234 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1235 return;
1236 }
1237 strbasis=read_basis_from_a_gamess_output_file(FileName, &nrs);
1238 if(strbasis==NULL)
1239 {
1240 printf("strbasis=NULL\n");
1241 if(GeomOrb)
1242 {
1243 init_atomic_orbitals();
1244 for(i=0;i<nCenters;i++) GeomOrb[i].Prop = prop_atom_get("H");
1245 free_geometry();
1246 }
1247 set_status_label_info(_("File name"),_("Nothing"));
1248 set_status_label_info(_("File type"),_("Nothing"));
1249 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1250 return;
1251 }
1252
1253 set_status_label_info(_("Mol. Orb."),_("Reading"));
1254 InitializeAll();
1255 if(!DefineGamessBasisType(strbasis,nrs))
1256 {
1257 gchar buffer[BSIZE];
1258 sprintf(buffer,_("Sorry, I can not read basis from '%s' file\n"),FileName);
1259 Message(buffer,_("Error"),TRUE);
1260 set_status_label_info(_("File name"),_("Nothing"));
1261 set_status_label_info(_("File type"),_("Nothing"));
1262 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1263 return;
1264 }
1265 for(i=0;i<Ntype;i++)
1266 if(Type[i].Ao == NULL)
1267 {
1268 gchar buffer[BSIZE];
1269 sprintf(buffer,_("Sorry, I can not read '%s' file, problem with basis set \n"),FileName);
1270 Message(buffer,_("Error"),TRUE);
1271 return;
1272 }
1273 /* reset symbol of atoms */
1274 if(GeomOrb)
1275 for(i=0;i<nCenters;i++)
1276 {
1277 if(GeomOrb[i].Symb) g_free(GeomOrb[i].Symb);
1278 GeomOrb[i].Symb=get_symbol_using_z(znuc[i]);
1279 GeomOrb[i].Prop = prop_atom_get(GeomOrb[i].Symb);
1280 GeomOrb[i].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[i].Symb);
1281 GeomOrb[i].variable = TRUE;
1282 /* printf("%s %i %f\n",GeomOrb[i].Symb,i,GeomOrb[i].nuclearCharge);*/
1283 }
1284 /*DefineType();*/
1285 buildBondsOrb();
1286 RebuildGeom = TRUE;
1287 reset_grid_limits();
1288 init_atomic_orbitals();
1289 set_status_label_info(_("Geometry"),_("Ok"));
1290 glarea_rafresh(GLArea); /* for geometry*/
1291
1292
1293 /*
1294 if(typebasis == 0)
1295 {
1296 DefineGamessSphericalBasis();
1297 sphericalBasis = TRUE;
1298 }
1299 else
1300 */
1301 {
1302 DefineGamessCartBasis();
1303 sphericalBasis = FALSE;
1304 }
1305
1306 /* PrintAllBasis();*/
1307 NormaliseAllBasis();
1308 /* PrintAllBasis();*/
1309 DefineNOccs();
1310
1311 get_number_of_occuped_orbitals(FileName, &nAlpha, &nBeta);
1312 printf("Number of ALPHA occ = %d\n",nAlpha);
1313 printf("Number of BETA occ = %d\n",nBeta);
1314 printf("NOrb = %d\n",NOrb);
1315
1316 typeLocal = get_local_orbital_type(FileName);
1317 if(typeLocal!=GABEDIT_ORBLOCALTYPE_UNKNOWN)
1318 {
1319 if(typeLocal==GABEDIT_ORBLOCALTYPE_BOYS)
1320 {
1321 Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_BOYS_ALPHA,nAlpha,nBeta);
1322 if(Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_BOYS_BETA, nAlpha, nBeta);
1323 else Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_BOYS, nAlpha, nBeta);
1324
1325 }
1326 else
1327 if(typeLocal==GABEDIT_ORBLOCALTYPE_EDMISTON)
1328 {
1329 Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_EDMISTON_ALPHA,nAlpha,nBeta);
1330 if(Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_EDMISTON_BETA, nAlpha, nBeta);
1331 else Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_EDMISTON, nAlpha, nBeta);
1332 }
1333 else
1334 {
1335 Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_PIPEK_ALPHA,nAlpha,nBeta);
1336 if(Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_PIPEK_BETA, nAlpha, nBeta);
1337 else Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_PIPEK, nAlpha, nBeta);
1338
1339 }
1340
1341 }
1342 else
1343 {
1344 Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_ALPHA,nAlpha,nBeta);
1345 if(Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_BETA, nAlpha, nBeta);
1346 else
1347 {
1348 if(!Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_MOLECULAR, nAlpha, nBeta);
1349 if(!Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_MCSCF, nAlpha, nBeta);
1350 if(!Ok) Ok = read_last_orbitals_in_gamess_file(FileName,GABEDIT_ORBTYPE_EIGENVECTORS, nAlpha, nBeta);
1351 }
1352 }
1353
1354 if(Ok)
1355 {
1356 /*PrintAllOrb(CoefAlphaOrbitals);*/
1357 set_status_label_info(_("Mol. Orb."),_("Ok"));
1358 glarea_rafresh(GLArea); /* for geometry*/
1359 NumSelOrb = NAlphaOcc-1;
1360 create_list_orbitals();
1361 }
1362 else
1363 {
1364 free_orbitals();
1365 set_status_label_info(_("File name"),_("Nothing"));
1366 set_status_label_info(_("File type"),_("Nothing"));
1367 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1368 }
1369
1370 }
1371