1 /* GeomOrbXYZ.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
21 #include "../../Config.h"
22 #include "GlobalOrb.h"
23 #include "UtilsOrb.h"
24 #include "../Utils/AtomsProp.h"
25 #include "../Utils/Vector3d.h"
26 #include "../Utils/UtilsInterface.h"
27 #include "../Utils/Transformation.h"
28 #include "../Utils/Constants.h"
29 #include "../Geometry/GeomGlobal.h"
30 #include "../Geometry/OpenBabel.h"
31 #include "../Utils/Utils.h"
32 #include "../Utils/UtilsGL.h"
33 #include "GLArea.h"
34 #include "StatusOrb.h"
35 #include "AtomicOrbitals.h"
36 #include "BondsOrb.h"
37
38 #ifdef G_OS_WIN32
39 #include <fcntl.h>
40 #include <io.h>
41 #else
42 #include <unistd.h>
43 #endif
44
45 #define MAXNAME 6
46 #define MAXATOMTYPE 4
47 #define MAXRESIDUENAME 4
48 #define MAXSYMBOL 2
49
50 typedef struct _OldGeometry
51 {
52 gint numberOfAtoms;
53 gchar** symbols;
54 gdouble* X;
55 gdouble* Y;
56 gdouble* Z;
57 }OldGeometry;
58 static OldGeometry oldGeometry = {0,NULL,NULL,NULL,NULL};
59
60 /***************************************************************************************/
free_old_geometry()61 static void free_old_geometry()
62 {
63 gint i;
64 if(oldGeometry.numberOfAtoms==0)return;
65 if(oldGeometry.X) g_free(oldGeometry.X);
66 if(oldGeometry.Y) g_free(oldGeometry.Y);
67 if(oldGeometry.Z) g_free(oldGeometry.Z);
68 for(i=0;i<oldGeometry.numberOfAtoms;i++)
69 if(oldGeometry.symbols[i])g_free(oldGeometry.symbols[i]);
70 if(oldGeometry.symbols) g_free(oldGeometry.symbols);
71 oldGeometry.numberOfAtoms = 0;
72 oldGeometry.X = NULL;
73 oldGeometry.Y = NULL;
74 oldGeometry.Z = NULL;
75 oldGeometry.symbols = NULL;
76 }
77 /***************************************************************************************/
reset_old_geometry()78 void reset_old_geometry()
79 {
80 gint i;
81 free_old_geometry();
82 if(nCenters<1) return;
83 oldGeometry.numberOfAtoms = nCenters;
84 oldGeometry.X = g_malloc(oldGeometry.numberOfAtoms*sizeof(gdouble));
85 oldGeometry.Y = g_malloc(oldGeometry.numberOfAtoms*sizeof(gdouble));
86 oldGeometry.Z = g_malloc(oldGeometry.numberOfAtoms*sizeof(gdouble));
87 oldGeometry.symbols = g_malloc(oldGeometry.numberOfAtoms*sizeof(gchar*));
88 for(i=0;i<oldGeometry.numberOfAtoms;i++)
89 {
90 oldGeometry.X[i] = GeomOrb[i].C[0];
91 oldGeometry.Y[i] = GeomOrb[i].C[1];
92 oldGeometry.Z[i] = GeomOrb[i].C[2];
93 oldGeometry.symbols[i] = g_strdup(GeomOrb[i].Symb);
94 }
95
96 }
97 /***************************************************************************************/
this_is_a_new_geometry()98 gboolean this_is_a_new_geometry()
99 {
100 gint i;
101 if(oldGeometry.numberOfAtoms<1) return TRUE;
102 if(oldGeometry.numberOfAtoms != nCenters) return TRUE;
103 for(i=0;i<oldGeometry.numberOfAtoms;i++)
104 if(strcmp(GeomOrb[i].Symb,oldGeometry.symbols[i]) != 0) return TRUE;
105
106 for(i=0;i<oldGeometry.numberOfAtoms;i++)
107 if(fabs(GeomOrb[i].C[0]-oldGeometry.X[i])>1e-6) return TRUE;
108 for(i=0;i<oldGeometry.numberOfAtoms;i++)
109 if(fabs(GeomOrb[i].C[1]-oldGeometry.Y[i])>1e-6) return TRUE;
110 for(i=0;i<oldGeometry.numberOfAtoms;i++)
111 if(fabs(GeomOrb[i].C[2]-oldGeometry.Z[i])>1e-6) return TRUE;
112
113 return FALSE;
114 }
115 /***************************************************************************************/
free_geometry()116 void free_geometry()
117 {
118 gint i;
119 set_status_label_info(_("File name"),_("Nothing"));
120 set_status_label_info(_("File type"),_("Nothing"));
121 set_status_label_info(_("Geometry"),_("Nothing"));
122 init_dipole();
123 reset_old_geometry();
124 if(!GeomOrb)
125 {
126 nCenters = 0;
127 return;
128 }
129 free_atomic_orbitals();
130 for(i=0;i<nCenters;i++)
131 if(GeomOrb[i].Symb)
132 g_free(GeomOrb[i].Symb);
133 g_free(GeomOrb);
134 GeomOrb = NULL;
135 nCenters = 0;
136 }
137 /*****************************************/
get_cube_length()138 gdouble get_cube_length()
139 {
140 gint i,j;
141 gdouble min;
142 gdouble max;
143
144 min = GeomOrb[0].C[0];
145 max = GeomOrb[0].C[0];
146 for(i=0;i<nCenters;i++)
147 {
148 for(j=0;j<3;j++)
149 {
150 if(min>GeomOrb[i].C[j])
151 min = GeomOrb[i].C[j];
152 if(max<GeomOrb[i].C[j])
153 max = GeomOrb[i].C[j];
154 }
155 }
156 return (max -min );
157 }
158 /*****************************************/
reset_grid_limits()159 void reset_grid_limits()
160 {
161 gint i;
162 gdouble t = get_cube_length();
163 if(fabs(t)<1e-10)
164 t = 5.0;
165 for(i=0;i<3;i++)
166 limits.MinMax[0][i] = -t;
167 for(i=0;i<3;i++)
168 limits.MinMax[1][i] = t;
169 }
170 /*****************************************/
171
create_xyz_gl_spheres_list()172 void create_xyz_gl_spheres_list()
173 {
174 V4d Specular = {1.0f,1.0f,1.0f,1.0f};
175 V4d Diffuse = {0.0f,0.0f,0.0f,1.0f};
176 V4d Ambiant = {0.0f,0.0f,0.0f,1.0f};
177 int i;
178 int k;
179 for(i=0;i<nCenters;i++)
180 {
181 Diffuse[0] = GeomOrb[i].Prop.color.red/(gdouble)65535;
182 Diffuse[1] = GeomOrb[i].Prop.color.green/(gdouble)65535;
183 Diffuse[2] = GeomOrb[i].Prop.color.blue/(gdouble)65535;
184 for(k=0;k<3;k++)
185 Ambiant[k] = Diffuse[k]*0.8;
186
187 GeomOrb[i].Sphere = Sphere_Get_List(
188 i+1,GeomOrb[i].Prop.radii,
189 Specular,Diffuse,Ambiant);
190 }
191 }
192
193 /*****************************************/
GetNumType(char * Symb)194 gint GetNumType(char *Symb)
195 {
196 gint i;
197 for(i=0;i<nCenters;i++)
198 {
199 if(!strcmp(Symb,GeomOrb[i].Symb))
200 return GeomOrb[i].NumType;
201 }
202 return -1;
203 }
204 /*****************************************/
DefineType()205 void DefineType()
206 {
207 gint i,j;
208 gint OK;
209 Ntype =1;
210 GeomOrb[0].NumType=0;
211 for(i=1;i<nCenters;i++)
212 {
213 OK =1;
214 for(j=0;j<i;j++)
215 {
216 if(!strcmp(GeomOrb[i].Symb,GeomOrb[j].Symb))
217 {
218 GeomOrb[i].NumType= GeomOrb[j].NumType;
219 OK =0;
220 break;
221 }
222 }
223 if(OK)
224 {
225 GeomOrb[i].NumType= Ntype;
226 Ntype++;
227 }
228 }
229 /*
230 Debug("Types = ");
231 for(i=0;i<nCenters;i++)
232 Debug("%d ", GeomOrb[i].NumType);
233 Debug("\n");
234 */
235 }
236 /*****************************************/
PrintGeomOrb()237 void PrintGeomOrb()
238 {
239 gint i,j;
240 Debug("Geometry(in au)\n");
241 Debug("===============\n\n");
242 for(i=0;i<nCenters;i++)
243 {
244 Debug("%3s ",GeomOrb[i].Symb);
245 for(j=0;j<3;j++)
246 Debug("%9.6f ",GeomOrb[i].C[j]);
247 Debug("\n");
248 }
249 }
250 /******************************************************************************************************************/
gl_read_molden_gabedit_geom_conv_file(gchar * fileName,gint geometryNumber,GabEditTypeFile type)251 gboolean gl_read_molden_gabedit_geom_conv_file(gchar *fileName, gint geometryNumber, GabEditTypeFile type)
252 {
253 gchar* t;
254 gboolean OK;
255 gchar* AtomCoord[5];
256 FILE *file;
257 gint i;
258 gint j;
259 gint l;
260 gint numgeom;
261 gchar *pdest;
262 gint nn;
263 gchar* tmp;
264
265
266 free_data_all();
267 tmp = get_name_file(fileName);
268 set_status_label_info(_("File name"),tmp);
269 g_free(tmp);
270 if(type == GABEDIT_TYPEFILE_GABEDIT) set_status_label_info(_("File type"),"Gabedit");
271 if(type == GABEDIT_TYPEFILE_MOLDEN) set_status_label_info(_("File type"),"Molden");
272
273 file = FOpen(fileName, "rb");
274
275 if(file ==NULL)
276 {
277 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
278 Message(t,_("Error"),TRUE);
279 g_free(t);
280 set_status_label_info(_("Geometry"),_("Nothing"));
281 return FALSE;
282 }
283 t = g_malloc(BSIZE*sizeof(gchar));
284 for(i=0;i<5;i++) AtomCoord[i] = g_malloc(BSIZE*sizeof(gchar));
285
286 numgeom =0;
287 OK=TRUE;
288 while(!feof(file))
289 {
290 if(!fgets(t, BSIZE,file))break;
291 pdest = strstr( t, "[GEOMETRIES]");
292 if(pdest && strstr(t,"ZMAT"))
293 {
294 if(type == GABEDIT_TYPEFILE_MOLDEN)
295 sprintf(t,_("Sorry\nMolden file with ZMAT coordinate is not supported by Gabedit"));
296 if(type == GABEDIT_TYPEFILE_GABEDIT)
297 sprintf(t,_("Sorry\nGabedit file with ZMAT coordinate is not supported by Gabedit"));
298
299 Message(t,_("Error"),TRUE);
300 g_free(t);
301 set_status_label_info(_("Geometry"),_("Nothing"));
302 return FALSE;
303 }
304 if (pdest)
305 {
306 while(!feof(file))
307 {
308 if(!fgets(t, BSIZE,file))break;
309
310 str_delete_n(t);
311 delete_last_spaces(t);
312 delete_first_spaces(t);
313 if(!isInteger(t))break;
314 numgeom++;
315 if(numgeom == geometryNumber)
316 {
317 nn = atoi(t);
318 if(nn<1)break;
319 GeomOrb=g_malloc(nn*sizeof(TypeGeomOrb));
320 if(!fgets(t, BSIZE,file))break; /* title */
321 for(j=0; j<nn; j++)
322 {
323 if(!fgets(t, BSIZE,file))break;
324 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
325 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
326 l=strlen(AtomCoord[0]);
327 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
328 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
329 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1])*ANG_TO_BOHR;
330 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
331 GeomOrb[j].partialCharge = 0.0;
332 GeomOrb[j].variable = TRUE;
333 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
334 }
335 nCenters = nn;
336 OK = TRUE;
337 break;
338 }
339 else
340 {
341 nn = atoi(t);
342 if(!fgets(t, BSIZE,file)) break;
343 for(i=0; i<nn; i++)
344 if(!fgets(t, BSIZE,file))break;
345 if(i!=nn) { OK = FALSE; break;}
346 }
347 if(!OK) break;
348 }
349 }
350 if(!OK) break;
351 }
352
353 fclose(file);
354 g_free(t);
355 for(i=0;i<5;i++) g_free(AtomCoord[i]);
356 if(nCenters == 0 ) { if(GeomOrb) g_free(GeomOrb); }
357 else DefineType();
358
359 buildBondsOrb();
360 reset_grid_limits();
361 init_atomic_orbitals();
362 set_status_label_info(_("Geometry"),"Ok");
363 RebuildGeom = TRUE;
364 if(this_is_a_new_geometry()) free_objects_all();
365 glarea_rafresh(GLArea);
366 return TRUE;
367 }
368 /*********************************************************************/
gl_read_xyz_file_geomi(gchar * fileName,gint geometryNumber)369 gboolean gl_read_xyz_file_geomi(gchar *fileName,gint geometryNumber)
370 {
371 gchar* t;
372 gboolean OK;
373 gchar* AtomCoord[5];
374 FILE *file;
375 gint i;
376 gint j;
377 gint l;
378 gint numgeom;
379 gint nn;
380 gchar* tmp;
381
382
383 free_data_all();
384 tmp = get_name_file(fileName);
385 set_status_label_info(_("File name"),tmp);
386 g_free(tmp);
387 set_status_label_info(_("File type"),"XYZ");
388
389 file = FOpen(fileName, "rb");
390
391 if(file ==NULL)
392 {
393 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
394 Message(t,_("Error"),TRUE);
395 g_free(t);
396 set_status_label_info(_("Geometry"),_("Nothing"));
397 return FALSE;
398 }
399 t = g_malloc(BSIZE*sizeof(gchar));
400 for(i=0;i<5;i++) AtomCoord[i] = g_malloc(BSIZE*sizeof(gchar));
401
402 numgeom =0;
403 OK=TRUE;
404 while(!feof(file))
405 {
406 if(!fgets(t, BSIZE,file))break;
407
408 str_delete_n(t);
409 delete_last_spaces(t);
410 delete_first_spaces(t);
411 if(!isInteger(t))break;
412 numgeom++;
413 if(numgeom == geometryNumber)
414 {
415 nn = atoi(t);
416 if(nn<1)break;
417 GeomOrb=g_malloc(nn*sizeof(TypeGeomOrb));
418 if(!fgets(t, BSIZE,file))break; /* title */
419 for(j=0; j<nn; j++)
420 {
421 if(!fgets(t, BSIZE,file))break;
422 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
423 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
424 l=strlen(AtomCoord[0]);
425 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
426 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
427 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1])*ANG_TO_BOHR;
428 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
429 GeomOrb[j].partialCharge = 0.0;
430 GeomOrb[j].variable = TRUE;
431 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
432 }
433 nCenters = nn;
434 OK = TRUE;
435 break;
436 }
437 else
438 {
439 nn = atoi(t);
440 if(!fgets(t, BSIZE,file)) break;
441 for(i=0; i<nn; i++)
442 if(!fgets(t, BSIZE,file))break;
443 if(i!=nn) { OK = FALSE; break;}
444 }
445 if(!OK) break;
446 }
447
448 fclose(file);
449 g_free(t);
450 for(i=0;i<5;i++) g_free(AtomCoord[i]);
451 if(nCenters == 0 ) { if(GeomOrb) g_free(GeomOrb); }
452 else DefineType();
453
454 buildBondsOrb();
455 reset_grid_limits();
456 init_atomic_orbitals();
457 set_status_label_info(_("Geometry"),"Ok");
458 RebuildGeom = TRUE;
459 if(this_is_a_new_geometry()) free_objects_all();
460 glarea_rafresh(GLArea);
461 return TRUE;
462 }
463 /********************************************************************************/
gl_read_xyz_file(gchar * FileName)464 gboolean gl_read_xyz_file(gchar* FileName)
465 {
466 gchar *t;
467 gchar *tmp=NULL;
468 gboolean OK;
469 gchar *AtomCoord[5];
470 FILE *fd;
471 guint taille=BSIZE;
472 guint i;
473 gint j;
474 gint l;
475 gdouble scal;
476 gint n;
477
478 for(i=0;i<5;i++)
479 AtomCoord[i]=g_malloc(taille*sizeof(char));
480
481
482 if ((!FileName) || (strcmp(FileName,"") == 0))
483 {
484 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
485 return FALSE ;
486 }
487
488
489 t=g_malloc(taille);
490 fd = FOpen(FileName, "rb");
491 OK=TRUE;
492 if(fd!=NULL)
493 {
494 { char* e = fgets(t,taille,fd);}
495 n = atoi(t);
496 if(n < 1)
497 {
498 OK=FALSE;
499 Message(_("Sorry\n this is not a XYZ file"),_("Error"),TRUE);
500 goto end;
501 }
502 free_data_all();
503 /* nCenters = n;*/
504 if(OK) GeomOrb=g_malloc(n*sizeof(TypeGeomOrb));
505 tmp = get_name_file(FileName);
506 set_status_label_info(_("File name"),tmp);
507 g_free(tmp);
508 set_status_label_info(_("File type"),"XYZ");
509 set_status_label_info(_("Geometry"),_("Reading"));
510
511 init_dipole();
512 progress_orb(0,GABEDIT_PROGORB_READGEOM,TRUE);
513 scal = (gdouble)1.01/n;
514 { char* e = fgets(t,taille,fd);}
515 j=-1;
516 while(!feof(fd) && OK && (j<(gint)n))
517 {
518
519 j++;
520 if(j>=(gint)n) break;
521 progress_orb(scal,GABEDIT_PROGORB_READGEOM,FALSE);
522 { char* e = fgets(t,taille,fd);}
523 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
524 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
525 l=strlen(AtomCoord[0]);
526 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
527 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
528
529 GeomOrb[j].C[0] = atof(ang_to_bohr(AtomCoord[1]));
530 GeomOrb[j].C[1] = atof(ang_to_bohr(AtomCoord[2]));
531 GeomOrb[j].C[2] = atof(ang_to_bohr(AtomCoord[3]));
532 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
533 GeomOrb[j].partialCharge = 0.0;
534 GeomOrb[j].variable = TRUE;
535 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
536 }
537 fclose(fd);
538
539 nCenters = n;
540 if(nCenters>10000)
541 {
542 TypeGeom = GABEDIT_TYPEGEOM_WIREFRAME;
543 RebuildGeom = TRUE;
544 }
545 else
546 {
547 }
548
549 }
550 end:
551 g_free(t);
552 for(i=0;i<5;i++)
553 g_free(AtomCoord[i]);
554 if(OK)
555 {
556 RebuildGeom = TRUE;
557 if(this_is_a_new_geometry()) free_objects_all();
558 buildBondsOrb();
559 glarea_rafresh(GLArea);
560 reset_grid_limits();
561 init_atomic_orbitals();
562 set_status_label_info(_("Geometry"),_("Ok"));
563 }
564 return OK;
565 }
566 /********************************************************************************/
gl_read_xyz_file_sel(GabeditFileChooser * SelecFile,gint response_id)567 void gl_read_xyz_file_sel(GabeditFileChooser *SelecFile, gint response_id)
568 {
569 gchar *FileName;
570
571 if(response_id != GTK_RESPONSE_OK) return;
572 FileName = gabedit_file_chooser_get_current_file(SelecFile);
573 gtk_widget_hide(GTK_WIDGET(SelecFile));
574 while( gtk_events_pending() )
575 gtk_main_iteration();
576
577 add_objects_for_new_grid();
578 gl_read_xyz_file(FileName);
579 }
580 /********************************************************************************/
get_symb_atom(gchar * symb)581 static gchar* get_symb_atom(gchar* symb)
582 {
583 gchar* S;
584 gchar Forbidden[]={'0','1','2','3','4','5','6','7','8','9'};
585
586 if(strlen(symb)==1)
587 S = g_strdup(symb);
588 else
589 {
590 gint Ok = 1;
591 gint i;
592 for(i=0;i<10;i++)
593 if(symb[1]== Forbidden[i])
594 {
595 Ok =0;
596 break;
597 }
598 if(Ok==1)
599 {
600 S = g_strdup_printf("%c%c",toupper(symb[0]),symb[1]);
601 }
602 else
603 S = g_strdup_printf("%c",toupper(symb[0]));
604 }
605 if(!test_atom_define(S))
606 S = g_strdup_printf("%c",toupper(symb[0]));
607
608
609 return S;
610 }
611 /*************************************************************************************/
read_atom_pdb_file(gchar * line,gchar * listFields[])612 static gboolean read_atom_pdb_file(gchar* line,gchar* listFields[])
613 {
614 gint i;
615 gint k = 0;
616 if(strlen(line)<54)
617 return FALSE;
618
619 /* 0 -> Atom Type */
620 k = 0;
621 for(i=0;i<MAXATOMTYPE;i++)
622 listFields[k][i] = line[13+i-1];
623 listFields[k][MAXATOMTYPE] = '\0';
624 if(isdigit(listFields[k][0]))
625 {
626 gchar c0 = listFields[k][0];
627 for(i=0;i<MAXATOMTYPE-1;i++)
628 listFields[k][i] = listFields[k][i+1];
629 listFields[k][MAXATOMTYPE-1] = c0;
630 }
631
632 /* 1-> Residue Name */
633 k = 1;
634 for(i=0;i<MAXRESIDUENAME;i++)
635 listFields[k][i] = line[17+i-1];
636 listFields[k][MAXRESIDUENAME] = '\0';
637
638 /* 2-> Residue Number */
639 k = 2;
640 for(i=0;i<4;i++)
641 listFields[k][i] = line[23+i-1];
642 listFields[k][4] = '\0';
643 /* 3-> x */
644 k = 3;
645 for(i=0;i<8;i++)
646 listFields[k][i] = line[31+i-1];
647 listFields[k][8] = '\0';
648
649 /* 4-> y */
650 k = 4;
651 for(i=0;i<8;i++)
652 listFields[k][i] = line[39+i-1];
653 listFields[k][8] = '\0';
654
655 /* 5-> z */
656 k = 5;
657 for(i=0;i<8;i++)
658 listFields[k][i] = line[47+i-1];
659 listFields[k][8] = '\0';
660
661 /* 6-> Symbol */
662 k = 6;
663 if(strlen(line)>=78)
664 {
665 for(i=0;i<2;i++)
666 {
667 listFields[k][i] = line[76+i];
668 }
669 listFields[k][2] = '\0';
670 if(listFields[k][1]==' ')
671 listFields[k][1] = '\0';
672 if(listFields[k][0]==' ')
673 listFields[k][0] = '\0';
674 }
675 else
676 listFields[k][0] = '\0';
677 /* 7-> Charge */
678 k = 7;
679 if(strlen(line)>=80)
680 {
681 for(i=0;i<(gint)strlen(line)-79+1;i++)
682 listFields[k][i] = line[79+i-1];
683
684 listFields[k][strlen(line)-79+1] = '\0';
685
686 if(listFields[k][strlen(line)-79]=='\n')
687 listFields[k][strlen(line)-79]='\0';
688
689 }
690 else
691 listFields[k][0] = '\0';
692
693 for(i=0;i<8;i++)
694 {
695 delete_last_spaces(listFields[i]);
696 delete_first_spaces(listFields[i]);
697 }
698 return TRUE;
699
700 }
701 /********************************************************************************/
gl_read_pdb_file(gchar * FileName)702 gboolean gl_read_pdb_file(gchar* FileName)
703 {
704 gchar *t;
705 gchar *tmp=NULL;
706 gboolean OK;
707 FILE *fd;
708 guint taille=BSIZE;
709 guint i;
710 gint j;
711 gchar *listFields[8];
712
713 if ((!FileName) || (strcmp(FileName,"") == 0))
714 {
715 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
716 return FALSE ;
717 }
718
719
720 fd = FOpen(FileName, "rb");
721 if(fd==NULL)
722 {
723 gchar* tmp = g_strdup_printf(_("Sorry\n I can not open %s file"), FileName);
724 Message(tmp,_("Error"),TRUE);
725 g_free(tmp);
726 return FALSE ;
727 }
728 for(i=0;i<8;i++) listFields[i]=g_malloc(taille*sizeof(gchar));
729 t=g_malloc(taille*sizeof(gchar));
730 OK=TRUE;
731 free_data_all();
732 tmp = get_name_file(FileName);
733 set_status_label_info(_("File name"),tmp);
734 g_free(tmp);
735 set_status_label_info(_("File type"),"pdb");
736 set_status_label_info(_("Geometry"),_("Reading"));
737 init_dipole();
738 j=0;
739 GeomOrb= NULL;
740 while(!feof(fd))
741 {
742 if(!fgets(t,taille,fd)) break;
743 sscanf(t,"%s",listFields[0]);
744 if(strcmp(listFields[0],"HETATM")!=0 && strcmp(listFields[0],"ATOM")!=0) continue;
745 if(!strcmp(t,"END")) break;
746 if(!read_atom_pdb_file(t,listFields)) continue;
747 /* 0 -> Atom Type 1-> Residue Name 2-> Residue Number
748 * 3-> x 4-> y 5-> z 6-> Symbol 7-> Charge */
749
750 GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
751 if(strlen(listFields[6])<=0)
752 {
753 /* printf("PPPP listFields[6] = %s\n",listFields[6]);*/
754 GeomOrb[j].Symb= get_symb_atom(listFields[0]);
755 }
756 else GeomOrb[j].Symb= g_strdup(listFields[6]);
757
758 GeomOrb[j].C[0] = atof(ang_to_bohr(listFields[3]));
759 GeomOrb[j].C[1] = atof(ang_to_bohr(listFields[4]));
760 GeomOrb[j].C[2] = atof(ang_to_bohr(listFields[5]));
761 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
762 GeomOrb[j].partialCharge = 0.0;
763 GeomOrb[j].variable = TRUE;
764 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
765 j++;
766 }
767 if(j!=0)
768 {
769 nCenters = j;
770 readBondsPDB(fd);
771 }
772 fclose(fd);
773
774 OK = FALSE;
775 if(j!=0) OK = TRUE;
776
777 if(OK)
778 {
779 nCenters = j;
780 if(nCenters>1000)
781 {
782 TypeGeom = GABEDIT_TYPEGEOM_WIREFRAME;
783 RebuildGeom = TRUE;
784 }
785 }
786 else
787 {
788 nCenters = 0;
789 set_status_label_info(_("Geometry"),_("Nothing"));
790 }
791 g_free(t);
792 for(i=0;i<8;i++) g_free(listFields[i]);
793 if(OK)
794 {
795 RebuildGeom = TRUE;
796 if(this_is_a_new_geometry()) free_objects_all();
797 /* buildBondsOrb();*/
798 glarea_rafresh(GLArea);
799 reset_grid_limits();
800 init_atomic_orbitals();
801 set_status_label_info(_("Geometry"),_("Ok"));
802 }
803 return OK;
804 }
805 /********************************************************************************/
gl_read_pdb_file_sel(GabeditFileChooser * SelecFile,gint response_id)806 void gl_read_pdb_file_sel(GabeditFileChooser *SelecFile, gint response_id)
807 {
808 gchar *FileName;
809
810 if(response_id != GTK_RESPONSE_OK) return;
811 FileName = gabedit_file_chooser_get_current_file(SelecFile);
812 gtk_widget_hide(GTK_WIDGET(SelecFile));
813 while( gtk_events_pending() ) gtk_main_iteration();
814
815 add_objects_for_new_grid();
816 gl_read_pdb_file(FileName);
817 }
818 /*************************************************************************************/
read_hin_numbers_of_atoms(FILE * file,int * natoms,int * nresidues)819 static void read_hin_numbers_of_atoms(FILE* file, int* natoms, int* nresidues)
820 {
821 guint taille = BSIZE;
822 gchar t[BSIZE];
823 gchar dump[BSIZE];
824
825 *natoms = 0;
826 *nresidues = 0;
827
828
829 fseek(file, 0L, SEEK_SET);
830 while(!feof(file))
831 {
832 if(!fgets(t,taille,file)) break;
833 sscanf(t,"%s",dump);
834 g_strdup(dump);
835 if(!strcmp(dump,"ATOM")) (*natoms)++;
836 if(!strcmp(dump,"RES")) (*nresidues)++;
837 }
838 }
839 /*************************************************************************************/
read_atom_hin_file(FILE * file,gchar * listFields[])840 static gboolean read_atom_hin_file(FILE* file,gchar* listFields[])
841 {
842 guint taille = BSIZE;
843 gchar t[BSIZE];
844 gchar dump[BSIZE];
845 gint i;
846
847 if(!fgets(t,taille,file)) return FALSE;
848 sscanf(t,"%s",dump);
849 g_strdup(dump);
850 if(strcmp(dump,"ATOM")!=0)
851 {
852 if(strcmp(dump,"RES")==0)
853 {
854 sscanf(t,"%s %s %s",dump,dump,listFields[1]);
855 sprintf(listFields[0],"Unknown");
856 }
857 else
858 return FALSE;
859 }
860 else
861 {
862 /* 0 -> Atom Type PDB Style*/
863 /* 1 -> Atom Symbol*/
864 /* 2 -> Atom Type Amber*/
865 /* 3 -> Atom Charge*/
866 /* 4 -> x*/
867 /* 5 -> y*/
868 /* 6 -> z*/
869 sscanf(t,"%s %s %s %s %s %s %s %s %s %s",dump,dump,listFields[0],listFields[1],listFields[2],dump,listFields[3],listFields[4],listFields[5],listFields[6]);
870 }
871 for(i=0;i<6;i++)
872 {
873 delete_last_spaces(listFields[i]);
874 delete_first_spaces(listFields[i]);
875 }
876 return TRUE;
877
878 }
879 /********************************************************************************/
gl_read_hin_file(gchar * FileName)880 gboolean gl_read_hin_file(gchar* FileName)
881 {
882 gchar *t;
883 gchar *tmp=NULL;
884 gboolean OK;
885 FILE *fd;
886 guint taille=BSIZE;
887 guint i;
888 gint j;
889 gchar *listFields[8];
890 int natoms = 0;
891 int nresidues = 0;
892
893 if ((!FileName) || (strcmp(FileName,"") == 0))
894 {
895 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
896 return FALSE ;
897 }
898
899 fd = FOpen(FileName, "rb");
900
901 if(fd==NULL)
902 {
903 gchar* tmp = g_strdup_printf(_("Sorry\n I can not open %s file"), FileName);
904 Message(tmp,_("Error"),TRUE);
905 g_free(tmp);
906 return FALSE ;
907 }
908 read_hin_numbers_of_atoms(fd,&natoms, &nresidues);
909 if(natoms<1)
910 {
911 gchar* tmp = g_strdup_printf(_("Sorry\n I can not read grometry from %s file"), FileName);
912 Message(tmp,_("Error"),TRUE);
913 g_free(tmp);
914 return FALSE ;
915 }
916
917 OK=TRUE;
918 for(i=0;i<8;i++) listFields[i]=g_malloc(taille*sizeof(gchar));
919 t=g_malloc(taille*sizeof(gchar));
920
921 free_data_all();
922 tmp = get_name_file(FileName);
923 set_status_label_info(_("File name"),tmp);
924 g_free(tmp);
925 set_status_label_info(_("File type"),"Hyperchem");
926 set_status_label_info(_("Geometry"),_("Reading"));
927 init_dipole();
928 j=0;
929
930 GeomOrb=g_malloc(natoms*sizeof(TypeGeomOrb));
931 fseek(fd, 0L, SEEK_SET);
932 j = 0;
933 i = -1; /* number residu */
934 while(!feof(fd))
935 {
936 if(!read_atom_hin_file(fd,listFields))continue;
937 if(strcmp(listFields[0],"Unknown")==0)
938 {
939 i++;
940 continue;
941 }
942 /* 0 -> Atom Type PDB Style*/
943 /* 1 -> Atom Symbol*/
944 /* 2 -> Atom Type Amber*/
945 /* 3 -> Atom Charge*/
946 /* 4 -> x*/
947 /* 5 -> y*/
948 /* 6 -> z*/
949 /* printf("%s %s %s %s %s %s %s \n",listFields[0],listFields[1],listFields[2],listFields[3],listFields[4],listFields[5],listFields[6]);*/
950 GeomOrb[j].Symb= g_strdup(listFields[1]);
951
952 GeomOrb[j].C[0] = atof(ang_to_bohr(listFields[4]));
953 GeomOrb[j].C[1] = atof(ang_to_bohr(listFields[5]));
954 GeomOrb[j].C[2] = atof(ang_to_bohr(listFields[6]));
955 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
956 GeomOrb[j].partialCharge = atof(listFields[3]);
957 GeomOrb[j].variable = TRUE;
958 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
959 j++;
960 if(j>=natoms)break;
961 }
962 OK = TRUE;
963 if(natoms!=j) OK = FALSE;
964
965 if(OK)
966 {
967 nCenters = natoms;
968 if(nCenters>10000)
969 {
970 TypeGeom = GABEDIT_TYPEGEOM_WIREFRAME;
971 RebuildGeom = TRUE;
972 }
973 readBondsHIN(fd);
974 }
975 else
976 {
977 nCenters = 0;
978 set_status_label_info(_("Geometry"),_("Nothing"));
979 }
980 fclose(fd);
981 g_free(t);
982 for(i=0;i<8;i++) g_free(listFields[i]);
983 if(OK)
984 {
985 RebuildGeom = TRUE;
986 if(this_is_a_new_geometry()) free_objects_all();
987 /* buildBondsOrb();*/
988 glarea_rafresh(GLArea);
989 reset_grid_limits();
990 init_atomic_orbitals();
991 set_status_label_info(_("Geometry"),_("Ok"));
992 }
993 return OK;
994 }
995 /********************************************************************************/
gl_read_hin_file_sel(GabeditFileChooser * SelecFile,gint response_id)996 void gl_read_hin_file_sel(GabeditFileChooser *SelecFile, gint response_id)
997 {
998 gchar *FileName;
999
1000 if(response_id != GTK_RESPONSE_OK) return;
1001 FileName = gabedit_file_chooser_get_current_file(SelecFile);
1002 gtk_widget_hide(GTK_WIDGET(SelecFile));
1003 while( gtk_events_pending() ) gtk_main_iteration();
1004
1005 add_objects_for_new_grid();
1006 gl_read_hin_file(FileName);
1007 }
1008 /*****************************************************************************************/
conversion_to_hin_and_read(GtkWidget * wid,gpointer data)1009 static void conversion_to_hin_and_read(GtkWidget *wid,gpointer data)
1010 {
1011 gchar *fout = g_strdup_printf("%s%stmp%sfout",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
1012 gchar *ferr = g_strdup_printf("%s%stmp%sferr",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
1013 gchar *outputFileName = g_strdup_printf("%s%stmp%sgeom.hin",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
1014 G_CONST_RETURN gchar* inputFileName;
1015 gchar inputFileType[100];
1016 gchar outputFileType[] ="hin" ;
1017 GtkWidget* entryFileName = NULL;
1018 GtkWidget* entryFileType = NULL;
1019 G_CONST_RETURN gchar* t0;
1020 gchar* t;
1021 gchar* strout;
1022 gchar* strerr;
1023 G_CONST_RETURN gchar* babelCommand =get_open_babel_command();
1024
1025 GtkWidget *Win = (GtkWidget *)data;
1026 if(!this_is_an_object((GtkObject*)Win)) return;
1027
1028 entryFileName = g_object_get_data (G_OBJECT (Win), "EntryFileName");
1029 entryFileType = g_object_get_data (G_OBJECT (Win), "EntryCombo");
1030
1031 if(!this_is_an_object((GtkObject*)entryFileName)) return;
1032 if(!this_is_an_object((GtkObject*)entryFileType)) return;
1033
1034 inputFileName = gtk_entry_get_text(GTK_ENTRY(entryFileName));
1035
1036 t0 = gtk_entry_get_text(GTK_ENTRY(entryFileType));
1037 sscanf(t0,"%s",inputFileType);
1038 if(strstr(t0,"Automatic")) t = g_strdup_printf("%s %s %s", babelCommand, inputFileName, outputFileName);
1039 else t = g_strdup_printf("%s -i%s %s -o%s %s", babelCommand, inputFileType, inputFileName, outputFileType, outputFileName);
1040
1041 unlink(fout);
1042 unlink(ferr);
1043 run_local_command(fout,ferr,t,FALSE);
1044 strout = cat_file(fout,FALSE);
1045 strerr = cat_file(ferr,FALSE);
1046 if(strout)
1047 {
1048 Message(strout, _("Info"), TRUE);
1049 g_free(strout);
1050 }
1051 if(strerr)
1052 {
1053 Message(strerr, _("Error"), TRUE);
1054 g_free(strerr);
1055 }
1056 else
1057 {
1058 gl_read_hin_file(outputFileName);
1059 }
1060 unlink(fout);
1061 unlink(ferr);
1062 unlink(outputFileName);
1063 g_free(fout);
1064 g_free(ferr);
1065 g_free(t);
1066 g_free(outputFileName);
1067 }
1068 /********************************************************************************/
gl_create_babel_read_dialogue()1069 void gl_create_babel_read_dialogue()
1070 {
1071 GtkWidget* okButton = create_babel_read_save_dialogue(TRUE);
1072 GtkWidget* win = g_object_get_data (G_OBJECT (okButton), "Window");
1073
1074 g_signal_connect(G_OBJECT(okButton), "clicked", G_CALLBACK(conversion_to_hin_and_read),win);
1075 g_signal_connect_swapped(G_OBJECT(okButton), "clicked",G_CALLBACK(delete_child),GTK_OBJECT(win));
1076 }
1077 /********************************************************************************/
gl_read_molden_or_gabedit_file_geom(gchar * FileName,gint type)1078 gboolean gl_read_molden_or_gabedit_file_geom(gchar *FileName,gint type)
1079 {
1080 gchar *t;
1081 gchar *tmp;
1082 gchar *AtomCoord[5];
1083 FILE *fd;
1084 guint taille=BSIZE;
1085 guint idummy;
1086 gint iz;
1087 guint i;
1088 gint j=0;
1089 gint l;
1090 gboolean Angs = FALSE;
1091 gchar title[BSIZE];
1092 gchar titleCap[BSIZE];
1093 gchar tCap[BSIZE];
1094 gchar message[BSIZE];
1095
1096 if(type == 0)
1097 {
1098 sprintf(title,"[Molden Format]");
1099 sprintf(message,"Sorry\nThis file is not a molden type file");
1100 }
1101 else
1102 {
1103 sprintf(title,"[Gabedit Format]");
1104 sprintf(message,"Sorry\nThis file is not a gabedit type file");
1105 }
1106
1107 sprintf(titleCap,"%s",title);
1108 uppercase(titleCap);
1109
1110 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
1111
1112 if ((!FileName) || (strcmp(FileName,"") == 0))
1113 {
1114 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
1115 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1116 return FALSE;
1117 }
1118
1119 t=g_malloc(taille*sizeof(gchar));
1120 fd = FOpen(FileName, "rb");
1121 if(fd ==NULL)
1122 {
1123 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
1124 g_free(t);
1125 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1126 return FALSE;
1127 }
1128 if(type==0)
1129 {
1130 gboolean ok = FALSE;
1131 while(!feof(fd))
1132 {
1133 if(!fgets(t,taille,fd)) break;
1134 uppercase(t);
1135 if(strstr( t, "[MOLDEN FORMAT]" ))
1136 {
1137 ok = TRUE;
1138 break;
1139 }
1140 }
1141 if(ok) sprintf(tCap,"%s",t);
1142 else sprintf(tCap,"ERROR");
1143 }
1144 else{
1145 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1146 sprintf(tCap,"%s",t);
1147 }
1148 uppercase(tCap);
1149
1150 if(!strstr(tCap,titleCap))
1151 {
1152 Message(message,_("Error"),TRUE);
1153 g_free(t);
1154 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1155 return FALSE;
1156 }
1157
1158 free_data_all();
1159 tmp = get_name_file(FileName);
1160 set_status_label_info(_("File name"),tmp);
1161 g_free(tmp);
1162 if(type == 0)
1163 set_status_label_info(_("File type"),"Molden");
1164 else
1165 set_status_label_info(_("File type"),"Gabedit");
1166 set_status_label_info(_("Geometry"),_("Reading"));
1167 j = 0;
1168 while(!feof(fd))
1169 {
1170 { char* e = fgets(t,taille,fd);}
1171 uppercase(t);
1172 if( !strstr( t, "[ATOMS" ) )
1173 continue;
1174 if( strstr( t, "ANGS" ))
1175 Angs = TRUE;
1176 else
1177 Angs = FALSE;
1178
1179 j = 0;
1180 if(GeomOrb)
1181 g_free(GeomOrb);
1182 GeomOrb = NULL;
1183 while( !feof(fd) )
1184 {
1185 gint n = 0;
1186 { char* e = fgets(t,taille,fd);}
1187 n = sscanf(t,"%s %d %d %s %s %s",
1188 AtomCoord[0],&idummy,&iz,
1189 AtomCoord[1],AtomCoord[2],AtomCoord[3]);
1190 if(n<6) break;
1191 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
1192 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
1193
1194 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
1195 l=strlen(AtomCoord[0]);
1196 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
1197
1198 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
1199 if(!test_atom_define(GeomOrb[j].Symb))
1200 {
1201 GeomOrb[j].Symb = get_symbol_using_z(iz);
1202 }
1203
1204 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
1205 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
1206 GeomOrb[j].partialCharge = 0.0;
1207 GeomOrb[j].variable = TRUE;
1208 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
1209 j++;
1210 }
1211 break;
1212 }
1213
1214 nCenters = j;
1215 fclose(fd);
1216 g_free(t);
1217 for(i=0;i<5;i++)
1218 g_free(AtomCoord[i]);
1219 if(Angs)
1220 for(j=0;j<nCenters;j++)
1221 for(i=0;i<3;i++)
1222 GeomOrb[j].C[i] *=ANG_TO_BOHR;
1223
1224 if(nCenters == 0 )
1225 {
1226 if(GeomOrb) g_free(GeomOrb);
1227 set_status_label_info(_("Geometry"),_("Nothing"));
1228 return FALSE;
1229 }
1230 else
1231 {
1232 DefineType();
1233 /* PrintGeomOrb();*/
1234 }
1235 buildBondsOrb();
1236 reset_grid_limits();
1237 init_atomic_orbitals();
1238 set_status_label_info(_("Geometry"),_("Ok"));
1239 return TRUE;
1240 }
1241 /********************************************************************************/
gl_read_molden_file_geom(gchar * FileName)1242 gboolean gl_read_molden_file_geom(gchar *FileName)
1243 {
1244 if( gl_read_molden_or_gabedit_file_geom(FileName,0))
1245 {
1246 RebuildGeom = TRUE;
1247 if(this_is_a_new_geometry()) free_objects_all();
1248 glarea_rafresh(GLArea);
1249 return TRUE;
1250 }
1251 return FALSE;
1252 }
1253 /********************************************************************************/
gl_read_gabedit_file_geom(gchar * FileName)1254 gboolean gl_read_gabedit_file_geom(gchar *FileName)
1255 {
1256 if(gl_read_molden_or_gabedit_file_geom(FileName,1))
1257 {
1258 RebuildGeom = TRUE;
1259 if(this_is_a_new_geometry()) free_objects_all();
1260 glarea_rafresh(GLArea);
1261 return TRUE;
1262 }
1263 return FALSE;
1264 }
1265 /********************************************************************************/
gl_read_molpro_file_geom_pos(gchar * FileName,long int pos)1266 gboolean gl_read_molpro_file_geom_pos(gchar *FileName,long int pos)
1267 {
1268 gchar t[BSIZE];
1269 gchar *tmp = NULL;
1270 gboolean OK;
1271 gchar *AtomCoord[5];
1272 gchar AtomCharge[100];
1273 FILE *fd;
1274 guint taille=BSIZE;
1275 guint idummy;
1276 guint i;
1277 gint j=0;
1278 gint l;
1279 long int n=-1;
1280 gint kk;
1281 gchar dum[100];
1282
1283 for(i=0;i<5;i++)
1284 AtomCoord[i]=g_malloc(taille*sizeof(char));
1285
1286 fd = FOpen(FileName, "rb");
1287 if(fd ==NULL)
1288 {
1289 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
1290 for(i=0;i<5;i++)
1291 g_free(AtomCoord[i]);
1292 return FALSE;
1293 }
1294
1295 free_data_all();
1296 tmp = get_name_file(FileName);
1297 set_status_label_info(_("File name"),tmp);
1298 g_free(tmp);
1299 set_status_label_info(_("File type"),"Molpro");
1300 set_status_label_info(_("Geometry"),_("Reading"));
1301 OK=FALSE;
1302 n=-1;
1303 while(!feof(fd))
1304 {
1305 n++;
1306 { char* e = fgets(t,taille,fd);}
1307 if (n==pos)
1308 {
1309 { char* e = fgets(t,taille,fd);}
1310 { char* e = fgets(t,taille,fd);}
1311 { char* e = fgets(t,taille,fd);}
1312 OK = TRUE;
1313 break;
1314 }
1315 }
1316 if(!OK)
1317 {
1318 Message(_("Sorry\nI can not read geometry in this file"),_("Error"),TRUE);
1319 fclose(fd);
1320 for(i=0;i<5;i++)
1321 g_free(AtomCoord[i]);
1322 set_status_label_info(_("File name"),_("Nothing"));
1323 set_status_label_info(_("File type"),_("Nothing"));
1324 set_status_label_info(_("Geometry"),_("Nothing"));
1325 return FALSE;
1326 }
1327
1328 j=-1;
1329 while(!feof(fd) )
1330 {
1331 { char* e = fgets(t,taille,fd);}
1332 if ( !strcmp(t,"\n"))
1333 break;
1334 j++;
1335 if(GeomOrb==NULL)
1336 GeomOrb=g_malloc(sizeof(TypeGeomOrb));
1337 else
1338 GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
1339
1340 /*
1341 kk = sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCoord[1],AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
1342 if(kk==7) sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCoord[1],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1343 */
1344 kk = sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCharge,AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
1345 if(kk==7) sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCharge,dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1346
1347 for(i=0;i<(gint)strlen(AtomCoord[0]);i++) if(isdigit(AtomCoord[0][i])) AtomCoord[0][i] = ' ';
1348 delete_all_spaces(AtomCoord[0]);
1349
1350 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
1351 l=strlen(AtomCoord[0]);
1352 if (l==2)
1353 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
1354
1355 if (atoi(AtomCharge) == 0)
1356 sprintf(AtomCoord[0],"X");
1357
1358 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
1359 for(i=0;i<3;i++)
1360 GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
1361
1362 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
1363 GeomOrb[j].partialCharge = 0.0;
1364 GeomOrb[j].variable = TRUE;
1365 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
1366 }
1367
1368 nCenters = j+1;
1369 fclose(fd);
1370 for(i=0;i<5;i++)
1371 g_free(AtomCoord[i]);
1372 if(nCenters == 0 )
1373 g_free(GeomOrb);
1374 else
1375 {
1376 DefineType();
1377 /* PrintGeomOrb();*/
1378 }
1379 RebuildGeom = TRUE;
1380 buildBondsOrb();
1381 reset_grid_limits();
1382 init_atomic_orbitals();
1383 set_status_label_info(_("Geometry"),_("Ok"));
1384 return TRUE;
1385 }
1386 /********************************************************************************/
gl_read_dalton_file_geomi(gchar * FileName,gint num)1387 gboolean gl_read_dalton_file_geomi(gchar *FileName,gint num)
1388 {
1389 gchar *t;
1390 gchar *tmp = NULL;
1391 gboolean OK;
1392 gchar *AtomCoord[5];
1393 FILE *fd;
1394 guint taille=BSIZE;
1395 guint i;
1396 gint j=0;
1397 gint l;
1398 guint numgeom;
1399 gchar dum[100];
1400 gint kk;
1401 long int geompos = 0;
1402
1403 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
1404
1405 if ((!FileName) || (strcmp(FileName,"") == 0))
1406 {
1407 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
1408 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1409 return FALSE ;
1410 }
1411
1412 t=g_malloc(taille);
1413 fd = FOpen(FileName, "rb");
1414 if(fd ==NULL)
1415 {
1416 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
1417 g_free(t);
1418 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1419 return FALSE;
1420 }
1421
1422 free_data_all();
1423 tmp = get_name_file(FileName);
1424 set_status_label_info(_("File name"),tmp);
1425 g_free(tmp);
1426 set_status_label_info(_("File type"),"Dalton");
1427 numgeom =1;
1428 do
1429 {
1430 set_status_label_info(_("Geometry"),_("Reading"));
1431 OK=FALSE;
1432 while(!feof(fd))
1433 {
1434 { char* e = fgets(t,taille,fd);}
1435 if ( strstr(t,"geometry (au)"))
1436 {
1437 { char* e = fgets(t,taille,fd);}
1438 { char* e = fgets(t,taille,fd);}
1439 numgeom++;
1440 OK = TRUE;
1441 break;
1442 }
1443 }
1444 if(!OK && (numgeom == 1) )
1445 {
1446 Message(_("Sorry\nI can not read geometry from this file"),_("Error"),TRUE);
1447 fclose(fd);
1448 g_free(t);
1449 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1450 set_status_label_info(_("File name"),_("Nothing"));
1451 set_status_label_info(_("File type"),_("Nothing"));
1452 set_status_label_info(_("Geometry"),_("Nothing"));
1453 return FALSE;
1454 }
1455 if(!OK)break;
1456
1457 j=-1;
1458 while(!feof(fd) )
1459 {
1460 { char* e = fgets(t,taille,fd);}
1461 if ( !strcmp(t,"\n"))
1462 {
1463 geompos = ftell(fd);
1464 get_dipole_from_dalton_output_file(fd);
1465 fseek(fd, geompos, SEEK_SET);
1466 break;
1467 }
1468 j++;
1469 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
1470 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
1471
1472 kk = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
1473 if(kk==5) sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1474
1475 for(i=0;i<(gint)strlen(AtomCoord[0]);i++) if(isdigit(AtomCoord[0][i])) AtomCoord[0][i] = ' ';
1476 delete_all_spaces(AtomCoord[0]);
1477 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
1478 l=strlen(AtomCoord[0]);
1479 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
1480 /*
1481 printf("j = %d symb = %s %s %s %s \n",j, AtomCoord[0], AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1482 */
1483
1484 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
1485 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
1486
1487 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
1488 GeomOrb[j].partialCharge = 0.0;
1489 GeomOrb[j].variable = TRUE;
1490 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
1491 }
1492 if(num >0 && (gint)numgeom-1 == num) break;
1493
1494 }while(!feof(fd));
1495
1496 nCenters = j+1;
1497 fclose(fd);
1498 g_free(t);
1499 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1500 if(nCenters == 0 ) g_free(GeomOrb);
1501 else
1502 {
1503 DefineType();
1504 /* PrintGeomOrb();*/
1505 }
1506 RebuildGeom = TRUE;
1507 buildBondsOrb();
1508 reset_grid_limits();
1509 init_atomic_orbitals();
1510 set_status_label_info(_("Geometry"),_("Ok"));
1511 return TRUE;
1512 }
1513 /********************************************************************************/
gl_get_charges_from_gaussian_output_file(FILE * fd,gint N)1514 void gl_get_charges_from_gaussian_output_file(FILE* fd,gint N)
1515 {
1516 guint taille=BSIZE;
1517 gchar t[BSIZE];
1518 gchar dump[BSIZE];
1519 gchar d[BSIZE];
1520 gchar* pdest;
1521 gint i;
1522 gint ngrad=0;
1523
1524
1525 while(!feof(fd) )
1526 {
1527 pdest = NULL;
1528 { char* e = fgets(t,taille,fd);}
1529 pdest = strstr( t, "Total atomic charges");
1530 if(!pdest) /* Gaussian 03 */
1531 pdest = strstr( t, "atomic charges");
1532 if(!pdest) /* Gaussian 09D */
1533 pdest = strstr( t, "Mulliken charges and spin densities:");
1534 if(!pdest) /* Gaussian 09D */
1535 pdest = strstr( t, "Mulliken charges:");
1536
1537
1538 if(pdest)
1539 {
1540 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1541 else
1542 break;
1543
1544 for(i=0;i<N;i++)
1545 {
1546 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1547 else
1548 break;
1549 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
1550 {
1551 GeomOrb[i].partialCharge = atof(d);
1552 }
1553 }
1554 break;
1555 }
1556 else
1557 {
1558 pdest = strstr( t, "GradGradGrad" );
1559 if(pdest)
1560 {
1561 ngrad++;
1562 }
1563 if(ngrad>2)
1564 break;
1565 }
1566
1567 }
1568 }
1569 /********************************************************************************/
gl_get_natural_charges_from_gaussian_output_file(FILE * fd,gint N)1570 void gl_get_natural_charges_from_gaussian_output_file(FILE* fd,gint N)
1571 {
1572 guint taille=BSIZE;
1573 gchar t[BSIZE];
1574 gchar dump[BSIZE];
1575 gchar d[BSIZE];
1576 gchar* pdest;
1577 gint i;
1578 gint ngrad =0;
1579
1580
1581
1582 while(!feof(fd) )
1583 {
1584 pdest = NULL;
1585 { char* e = fgets(t,taille,fd);}
1586 pdest = strstr( t, "Summary of Natural Population Analysis:");
1587 if(!pdest) /* Gaussian 03 */
1588 pdest = strstr( t, "Summary of Natural Population Analysis:");
1589
1590 if(pdest)
1591 {
1592 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1593 else break;
1594 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1595 else break;
1596 if(!strstr(t,"Natural Population"))break;
1597 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1598 else break;
1599 if(!strstr(t,"Natural"))break;
1600 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1601 else break;
1602 if(!strstr(t,"Charge"))break;
1603 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1604 else break;
1605 if(!strstr(t,"-------------"))break;
1606
1607 for(i=0;i<N;i++)
1608 {
1609 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1610 else break;
1611 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
1612 {
1613 GeomOrb[i].partialCharge = atof(d);
1614 }
1615 }
1616 break;
1617 }
1618 else
1619 {
1620 pdest = strstr( t, "GradGradGrad" );
1621 if(pdest)
1622 {
1623 ngrad++;
1624 }
1625 if(ngrad>2)
1626 break;
1627 }
1628
1629 }
1630 }
1631 /********************************************************************************/
gl_get_esp_charges_from_gaussian_output_file(FILE * fd,gint N)1632 void gl_get_esp_charges_from_gaussian_output_file(FILE* fd,gint N)
1633 {
1634 guint taille=BSIZE;
1635 gchar t[BSIZE];
1636 gchar dump[BSIZE];
1637 gchar d[BSIZE];
1638 gchar* pdest;
1639 gint i;
1640 gint ngrad=0;
1641
1642
1643 while(!feof(fd) )
1644 {
1645 pdest = NULL;
1646 { char* e = fgets(t,taille,fd);}
1647 pdest = strstr( t, "Charges from ESP fit");
1648 if(!pdest) /* Gaussian 03 */
1649 pdest = strstr( t, "harges from ESP");
1650
1651 if(pdest)
1652 {
1653 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1654 else break;
1655 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1656 else break;
1657
1658 for(i=0;i<N;i++)
1659 {
1660 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
1661 else break;
1662 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
1663 {
1664 GeomOrb[i].partialCharge = atof(d);
1665 }
1666 }
1667 break;
1668 }
1669 else
1670 {
1671 pdest = strstr( t, "GradGradGrad" );
1672 if(pdest)
1673 {
1674 ngrad++;
1675 }
1676 if(ngrad>2)
1677 break;
1678 }
1679
1680 }
1681 }
1682 /********************************************************************************/
gl_get_charges_from_gamess_output_file(FILE * fd,gint N)1683 void gl_get_charges_from_gamess_output_file(FILE* fd,gint N)
1684 {
1685 guint taille=BSIZE;
1686 gchar t[BSIZE];
1687 gchar dump[BSIZE];
1688 gchar d[BSIZE];
1689 gchar* pdest;
1690 gint i;
1691
1692
1693 while(!feof(fd) )
1694 {
1695 pdest = NULL;
1696 if(!fgets(t,taille,fd)) break;
1697 pdest = strstr( t, "TOTAL MULLIKEN AND LOWDIN ATOMIC POPULATIONS");
1698
1699 if(pdest)
1700 {
1701 if(!fgets(t,taille,fd)) break;
1702 for(i=0;i<N;i++)
1703 {
1704 if(!fgets(t,taille,fd)) break;
1705 if(sscanf(t,"%s %s %s %s %s %s",dump, dump ,dump, dump, dump, d)==6)
1706 {
1707 GeomOrb[i].partialCharge = atof(d);
1708 }
1709 else break;
1710 }
1711 break;
1712 }
1713 }
1714 }
1715 /********************************************************************************/
gl_read_gamess_file_geomi(gchar * FileName,gint num)1716 gboolean gl_read_gamess_file_geomi(gchar *FileName,gint num)
1717 {
1718 gchar *t;
1719 gchar *tmp = NULL;
1720 gboolean OK;
1721 gchar *AtomCoord[5];
1722 FILE *fd;
1723 guint taille=BSIZE;
1724 guint i;
1725 gint j=0;
1726 gint l;
1727 guint numgeom;
1728 gchar dum[100];
1729 gint uni=1;
1730 long geompos = 0;
1731
1732 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
1733
1734 if ((!FileName) || (strcmp(FileName,"") == 0))
1735 {
1736 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
1737 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1738 return FALSE ;
1739 }
1740
1741 t=g_malloc(taille);
1742
1743 #ifdef G_OS_WIN32
1744 fd = FOpen(FileName, "rb");
1745 #else
1746 fd = FOpen(FileName, "rb");
1747 #endif
1748
1749 if(fd ==NULL)
1750 {
1751 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
1752 g_free(t);
1753 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1754 return FALSE;
1755 }
1756
1757 init_dipole();
1758 free_data_all();
1759 tmp = get_name_file(FileName);
1760 set_status_label_info(_("File name"),tmp);
1761 g_free(tmp);
1762 set_status_label_info(_("File type"),"Gamess");
1763 numgeom =1;
1764 do
1765 {
1766 set_status_label_info(_("Geometry"),_("Reading"));
1767 OK=FALSE;
1768 while(!feof(fd))
1769 {
1770 if(!fgets(t,taille,fd))break;
1771 if ( strstr(t,"COORDINATES (BOHR)"))
1772 {
1773 { char* e = fgets(t,taille,fd);}
1774 numgeom++;
1775 OK = TRUE;
1776 uni = 0;
1777 break;
1778 }
1779 if ( strstr(t,"COORDINATES OF ALL ATOMS ARE (ANGS)"))
1780 {
1781 { char* e = fgets(t,taille,fd);}
1782 { char* e = fgets(t,taille,fd);}
1783 numgeom++;
1784 uni=1;
1785 if((gint)numgeom-1 == num ) { OK = TRUE; break; }
1786 if(num<0 ) { OK = TRUE; break; }
1787 }
1788 }
1789 if(!OK && (numgeom == 1) )
1790 {
1791 Message(_("Sorry\nI can not read geometry from this file"),_("Error"),TRUE);
1792 fclose(fd);
1793 g_free(t);
1794 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1795 set_status_label_info(_("File name"),_("Nothing"));
1796 set_status_label_info(_("File type"),_("Nothing"));
1797 set_status_label_info(_("Geometry"),_("Nothing"));
1798 return FALSE;
1799 }
1800 if(!OK)break;
1801
1802 j=-1;
1803 while(!feof(fd) )
1804 {
1805 { char* e = fgets(t,taille,fd);}
1806 if ( !strcmp(t,"\n")) break;
1807 if ( !strcmp(t,"\r\n")) break;
1808 j++;
1809 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
1810 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
1811
1812 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1813
1814 for(i=0;i<(gint)strlen(AtomCoord[0]);i++) if(isdigit(AtomCoord[0][i])) AtomCoord[0][i] = ' ';
1815 delete_all_spaces(AtomCoord[0]);
1816 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
1817 l=strlen(AtomCoord[0]);
1818 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
1819 /*
1820 printf("j = %d symb = %s %s %s %s \n",j, AtomCoord[0], AtomCoord[1], AtomCoord[2],AtomCoord[3]);
1821 */
1822
1823 /* GeomOrb[j].Symb=g_strdup(AtomCoord[0]);*/
1824 GeomOrb[j].Symb=get_symbol_using_z(atoi(dum));
1825 for(i=0;i<3;i++)
1826 {
1827 GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
1828 if(uni==1)GeomOrb[j].C[i] *= ANG_TO_BOHR;
1829 }
1830
1831 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
1832 GeomOrb[j].partialCharge = 0.0;
1833 GeomOrb[j].variable = TRUE;
1834 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
1835 }
1836 if(num >0 && (gint)numgeom-1 == num) break;
1837 if(num<0) geompos = ftell(fd);
1838 }while(!feof(fd));
1839
1840 nCenters = j+1;
1841 printf("nCenters=%d\n",nCenters);
1842
1843 if ( nCenters >0)
1844 {
1845 long int gp = 0;
1846 if(num<0) fseek(fd, geompos, SEEK_SET);
1847 fseek(fd, geompos, SEEK_SET);
1848 gp = ftell(fd);
1849 get_dipole_from_gamess_output_file(fd);
1850 fseek(fd, gp, SEEK_SET);
1851 gl_get_charges_from_gamess_output_file(fd,nCenters);
1852 /* PrintGeomOrb();*/
1853 }
1854
1855 fclose(fd);
1856 g_free(t);
1857 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1858 if(nCenters == 0 ) g_free(GeomOrb);
1859 else
1860 {
1861 DefineType();
1862 /* PrintGeomOrb();*/
1863 }
1864 RebuildGeom = TRUE;
1865 buildBondsOrb();
1866 reset_grid_limits();
1867 init_atomic_orbitals();
1868 set_status_label_info(_("Geometry"),_("Ok"));
1869 return TRUE;
1870 }
1871 /********************************************************************************/
gl_get_charges_from_mpqc_output_file(FILE * fd,gint N)1872 void gl_get_charges_from_mpqc_output_file(FILE* fd,gint N)
1873 {
1874 guint taille=BSIZE;
1875 gchar t[BSIZE];
1876 gchar dump[BSIZE];
1877 gchar d[BSIZE];
1878 gint i;
1879 gboolean OK = FALSE;
1880
1881
1882 fseek(fd, 0L, SEEK_SET);
1883 OK = FALSE;
1884 while(!feof(fd) )
1885 {
1886 if(!fgets(t,taille,fd))break;
1887 if(strstr(t, "Natural Population Analysis"))
1888 {
1889 OK = TRUE;
1890 break;
1891 }
1892 }
1893 if(!OK) return;
1894
1895 OK = FALSE;
1896 while(!feof(fd) )
1897 {
1898 if(!fgets(t,taille,fd))break;
1899 if(strstr(t, "atom") && strstr(t, "charge"))
1900 {
1901 OK = TRUE;
1902 break;
1903 }
1904 }
1905 if(!OK) return;
1906 for(i=0;i<N && !feof(fd) ;i++)
1907 {
1908 if(!fgets(t,taille,fd)) break;
1909 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
1910 {
1911 GeomOrb[i].partialCharge = atof(d);
1912 }
1913 }
1914 if(i==N) return;
1915 for(i=0;i<N;i++)
1916 {
1917 GeomOrb[i].partialCharge = 0.0;
1918 }
1919
1920 return;
1921 }
1922 /********************************************************************************/
gl_read_mpqc_file_geomi(gchar * fileName,gint numGeometry)1923 gboolean gl_read_mpqc_file_geomi(gchar *fileName,gint numGeometry)
1924 {
1925 gchar *t;
1926 gchar *tmp = NULL;
1927 gboolean OK;
1928 gchar *AtomCoord[5];
1929 FILE *fd;
1930 guint taille=BSIZE;
1931 guint idummy;
1932 guint i;
1933 gint j=0;
1934 gint l;
1935 guint numGeom;
1936 gdouble tmpReal;
1937
1938 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
1939
1940 fd = FOpen(fileName, "rb");
1941
1942 free_data_all();
1943 tmp = get_name_file(fileName);
1944 set_status_label_info(_("File name"),tmp);
1945 g_free(tmp);
1946 set_status_label_info(_("File type"),"MPQC");
1947
1948 t=g_malloc(taille);
1949
1950 numGeom = 0;
1951 do
1952 {
1953 gboolean unitOfOutAng = FALSE;
1954 OK=FALSE;
1955 set_status_label_info(_("Geometry"),_("Reading"));
1956 while(!feof(fd))
1957 {
1958 if(!fgets(t,taille,fd)) break;
1959 if (strstr(t,"<Molecule>"))
1960 {
1961 gboolean OkUnit = FALSE;
1962 do{
1963 if(!fgets(t,taille,fd))break;
1964 if(strstr(t,"unit"))
1965 {
1966 OkUnit = TRUE;
1967 if(strstr(t,"angstrom"))unitOfOutAng=TRUE;
1968 break;
1969 };
1970
1971 }while(!feof(fd));
1972 if(!OkUnit) break;
1973 numGeom++;
1974 if((gint)numGeom == numGeometry )
1975 {
1976 OK = TRUE;
1977 break;
1978 }
1979 if(numGeometry<0 )
1980 {
1981 OK = TRUE;
1982 break;
1983 }
1984 }
1985 }
1986 if(!OK && (numGeom == 0) )
1987 {
1988 g_free(t);
1989 t = g_strdup_printf(_("Sorry\nI can read Geometry from %s file "),fileName);
1990 Message(t,_("Error"),TRUE);
1991 g_free(t);
1992 for(i=0;i<5;i++) g_free(AtomCoord[i]);
1993 return FALSE;
1994 }
1995 if(!OK) break;
1996 OK = FALSE;
1997 while(!feof(fd) )
1998 {
1999 if(!fgets(t,taille,fd))break;
2000 if ( !(strstr(t,"atoms") && strstr(t,"geometry"))) continue;
2001 OK = TRUE;
2002 break;
2003 }
2004 if(!OK)
2005 {
2006 g_free(t);
2007 t = g_strdup_printf(_("Sorry\nI can read Geometry from %s file "),fileName);
2008 Message(t,_("Error"),TRUE);
2009 g_free(t);
2010 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2011 return FALSE;
2012 }
2013
2014 j=-1;
2015 while(!feof(fd) )
2016 {
2017 if(!fgets(t,taille,fd))break;
2018 if(strstr(t,"}"))break;
2019 j++;
2020
2021 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2022 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2023
2024 for(i=0;i<strlen(t);i++) if(t[i]=='[' || t[i] ==']') t[i]=' ';
2025 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
2026 for(i=1;i<=3;i++)
2027 {
2028 tmpReal = atof(AtomCoord[i]);
2029 sprintf(AtomCoord[i],"%lf",tmpReal);
2030 }
2031
2032 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2033
2034 l=strlen(AtomCoord[0]);
2035
2036 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2037
2038 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
2039 for(i=0;i<3;i++)
2040 if(unitOfOutAng)
2041 GeomOrb[j].C[i]=atof(ang_to_bohr(AtomCoord[i+1]));
2042 else
2043 GeomOrb[j].C[i]=atof(AtomCoord[i+1]);
2044
2045 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2046 GeomOrb[j].partialCharge = 0.0;
2047 GeomOrb[j].variable = TRUE;
2048 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2049 }
2050
2051 if(numGeometry<0) continue;
2052 if(OK) break;
2053 }while(!feof(fd));
2054
2055 nCenters = j+1;
2056 if(numGeometry<0) gl_get_charges_from_mpqc_output_file(fd,nCenters);
2057 fclose(fd);
2058 g_free(t);
2059 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2060 if(nCenters == 0 ) g_free(GeomOrb);
2061 else DefineType();
2062
2063 buildBondsOrb();
2064 reset_grid_limits();
2065 init_atomic_orbitals();
2066 set_status_label_info(_("Geometry"),_("Ok"));
2067 RebuildGeom = TRUE;
2068 return TRUE;
2069 }
2070 /********************************************************************************/
gl_read_molcas_file_geomi(gchar * FileName,gint num)2071 gboolean gl_read_molcas_file_geomi(gchar *FileName,gint num)
2072 {
2073 gchar *t;
2074 gchar *tmp = NULL;
2075 gboolean OK;
2076 gchar *AtomCoord[5];
2077 FILE *file;
2078 guint taille=BSIZE;
2079 guint idummy;
2080 guint i;
2081 gint j=0;
2082 gint l;
2083 guint numgeom;
2084
2085
2086 if ((!FileName) || (strcmp(FileName,"") == 0))
2087 {
2088 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
2089 return FALSE ;
2090 }
2091
2092
2093 t=g_malloc(taille);
2094 file = FOpen(FileName, "rb");
2095 if(file ==NULL)
2096 {
2097 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
2098 g_free(t);
2099 return FALSE;
2100 }
2101
2102 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
2103
2104 free_data_all();
2105 tmp = get_name_file(FileName);
2106 set_status_label_info(_("File name"),tmp);
2107 g_free(tmp);
2108 set_status_label_info(_("File type"),"Molcas");
2109 numgeom =1;
2110 do
2111 {
2112 set_status_label_info(_("Geometry"),_("Reading"));
2113 OK=FALSE;
2114 while(!feof(file))
2115 {
2116 { char* e = fgets(t,BSIZE,file);}
2117 if (strstr(t," Cartesian coordinates:"))
2118 {
2119 { char* e = fgets(t,taille,file);}
2120 { char* e = fgets(t,taille,file);}
2121 { char* e = fgets(t,taille,file);}
2122 numgeom++;
2123 OK = TRUE;
2124 break;
2125 }
2126 }
2127 if(!OK && (numgeom == 1) )
2128 {
2129 Message(_("Sorry\nI can not read geometry in this file"),_("Error"),TRUE);
2130 fclose(file);
2131 g_free(t);
2132 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2133 set_status_label_info(_("File name"),_("Nothing"));
2134 set_status_label_info(_("File type"),_("Nothing"));
2135 set_status_label_info(_("Geometry"),_("Nothing"));
2136 return FALSE;
2137 }
2138 if(!OK)break;
2139
2140 j=-1;
2141 while(!feof(file) )
2142 {
2143 { char* e = fgets(t,taille,file);}
2144 if ( !strcmp(t,"\n"))
2145 {
2146 /*
2147 long int geompos = 0;
2148 geompos = ftell(fd);
2149 get_dipole_from_molcas_output_file(fd);
2150 fseek(fd, geompos, SEEK_SET);
2151 */
2152 break;
2153 }
2154 j++;
2155 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2156 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2157
2158 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1], AtomCoord[2],AtomCoord[3]);
2159
2160 for(i=0;i<(gint)strlen(AtomCoord[0]);i++) if(isdigit(AtomCoord[0][i])) AtomCoord[0][i] = ' ';
2161 delete_all_spaces(AtomCoord[0]);
2162
2163 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2164 l=strlen(AtomCoord[0]); if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2165
2166 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
2167 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
2168 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2169 GeomOrb[j].partialCharge = 0.0;
2170 GeomOrb[j].variable = TRUE;
2171 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2172 }
2173 if(num >0 && (gint)numgeom-1 == num) break;
2174
2175 }while(!feof(file));
2176
2177 nCenters = j+1;
2178 fclose(file);
2179 g_free(t);
2180 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2181 if(nCenters == 0 ) g_free(GeomOrb);
2182 else
2183 {
2184 DefineType();
2185 /* PrintGeomOrb();*/
2186 }
2187 RebuildGeom = TRUE;
2188 buildBondsOrb();
2189 reset_grid_limits();
2190 init_atomic_orbitals();
2191 set_status_label_info(_("Geometry"),_("Ok"));
2192 return TRUE;
2193 }
2194 /********************************************************************************/
gl_read_molpro_file_geomi(gchar * FileName,gint num)2195 gboolean gl_read_molpro_file_geomi(gchar *FileName,gint num)
2196 {
2197 gchar *t;
2198 gchar *tmp = NULL;
2199 gboolean OK;
2200 gchar *AtomCoord[5];
2201 gchar AtomCharge[100];
2202 FILE *fd;
2203 guint taille=BSIZE;
2204 guint idummy;
2205 guint i;
2206 gint j=0;
2207 gint l;
2208 guint numgeom;
2209 gchar dum[100];
2210 gint kk;
2211
2212 for(i=0;i<5;i++)
2213 AtomCoord[i]=g_malloc(taille*sizeof(char));
2214
2215 if ((!FileName) || (strcmp(FileName,"") == 0))
2216 {
2217 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
2218 for(i=0;i<5;i++)
2219 g_free(AtomCoord[i]);
2220 return FALSE ;
2221 }
2222
2223 t=g_malloc(taille);
2224 fd = FOpen(FileName, "rb");
2225 if(fd ==NULL)
2226 {
2227 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
2228 g_free(t);
2229 for(i=0;i<5;i++)
2230 g_free(AtomCoord[i]);
2231 return FALSE;
2232 }
2233
2234 free_data_all();
2235 tmp = get_name_file(FileName);
2236 set_status_label_info(_("File name"),tmp);
2237 g_free(tmp);
2238 set_status_label_info(_("File type"),"Molpro");
2239 numgeom =1;
2240 do
2241 {
2242 set_status_label_info(_("Geometry"),_("Reading"));
2243 OK=FALSE;
2244 while(!feof(fd))
2245 {
2246 { char* e = fgets(t,taille,fd);}
2247 if ( !strcmp(t," ATOMIC COORDINATES\n"))
2248 {
2249 { char* e = fgets(t,taille,fd);}
2250 { char* e = fgets(t,taille,fd);}
2251 { char* e = fgets(t,taille,fd);}
2252 numgeom++;
2253 OK = TRUE;
2254 break;
2255 }
2256 }
2257 if(!OK && (numgeom == 1) )
2258 {
2259 Message(_("Sorry\nI can not read geometry in this file"),_("Error"),TRUE);
2260 fclose(fd);
2261 g_free(t);
2262 for(i=0;i<5;i++)
2263 g_free(AtomCoord[i]);
2264 set_status_label_info(_("File name"),_("Nothing"));
2265 set_status_label_info(_("File type"),_("Nothing"));
2266 set_status_label_info(_("Geometry"),_("Nothing"));
2267 return FALSE;
2268 }
2269 if(!OK)break;
2270
2271 j=-1;
2272 while(!feof(fd) )
2273 {
2274 { char* e = fgets(t,taille,fd);}
2275 if ( !strcmp(t,"\n"))
2276 {
2277 long int geompos = 0;
2278 geompos = ftell(fd);
2279 get_dipole_from_molpro_output_file(fd);
2280 fseek(fd, geompos, SEEK_SET);
2281 break;
2282 }
2283 j++;
2284 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2285 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2286
2287 /*
2288 kk = sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCoord[1],AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
2289 if(kk==7) sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCoord[1],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
2290 */
2291 kk = sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCharge,AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
2292 if(kk==7) sscanf(t,"%d %s %s %s %s %s %s",&idummy, AtomCoord[0],AtomCharge,dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
2293
2294 for(i=0;i<(gint)strlen(AtomCoord[0]);i++) if(isdigit(AtomCoord[0][i])) AtomCoord[0][i] = ' ';
2295 delete_all_spaces(AtomCoord[0]);
2296 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2297 l=strlen(AtomCoord[0]);
2298 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2299 if (atoi(AtomCharge) == 0)
2300 sprintf(AtomCoord[0],"X");
2301
2302 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
2303 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
2304
2305 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2306 GeomOrb[j].partialCharge = 0.0;
2307 GeomOrb[j].variable = TRUE;
2308 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2309 }
2310 if(num >0 && (gint)numgeom-1 == num) break;
2311
2312 }while(!feof(fd));
2313
2314 nCenters = j+1;
2315 fclose(fd);
2316 g_free(t);
2317 for(i=0;i<5;i++)
2318 g_free(AtomCoord[i]);
2319 if(nCenters == 0 )
2320 g_free(GeomOrb);
2321 else
2322 {
2323 DefineType();
2324 /* PrintGeomOrb();*/
2325 }
2326 RebuildGeom = TRUE;
2327 buildBondsOrb();
2328 reset_grid_limits();
2329 init_atomic_orbitals();
2330 set_status_label_info(_("Geometry"),_("Ok"));
2331 return TRUE;
2332 }
2333
2334 /********************************************************************************/
gl_read_gaussn_file_geomi_str(gchar * FileName,gint num,gchar * str)2335 gboolean gl_read_gaussn_file_geomi_str(gchar *FileName,gint num,gchar* str)
2336 {
2337 gchar *t;
2338 gchar *tmp = NULL;
2339 gboolean OK;
2340 gchar *AtomCoord[5];
2341 FILE *fd;
2342 guint taille=BSIZE;
2343 guint idummy;
2344 guint i;
2345 gint j=0;
2346 gint l;
2347 guint numgeom;
2348 gchar *pdest;
2349 guint itype=0;
2350 long int geompos = 0;
2351
2352 for(i=0;i<5;i++)
2353 AtomCoord[i]=g_malloc(taille*sizeof(char));
2354
2355 fd = FOpen(FileName, "rb");
2356
2357 free_data_all();
2358 tmp = get_name_file(FileName);
2359 set_status_label_info(_("File name"),tmp);
2360 g_free(tmp);
2361 set_status_label_info(_("File type"),"Gaussian");
2362
2363 t=g_malloc(taille);
2364
2365 numgeom =1;
2366 do
2367 {
2368 set_status_label_info(_("Geometry"),_("Reading"));
2369 OK=FALSE;
2370 while(!feof(fd))
2371 {
2372 { char* e = fgets(t,taille,fd);}
2373 if (strstr( t,str))
2374 {
2375 { char* e = fgets(t,taille,fd);}
2376 { char* e = fgets(t,taille,fd);}
2377 { char* e = fgets(t,taille,fd);}
2378
2379 if(strstr( t, "Type" ))
2380 itype=1;
2381 else
2382 itype=0;
2383 { char* e = fgets(t,taille,fd);}
2384 numgeom++;
2385 OK = TRUE;
2386 break;
2387 }
2388 }
2389 if(!OK && (numgeom == 1) )
2390 {
2391 fclose(fd);
2392 g_free(t);
2393 for(i=0;i<5;i++)
2394 g_free(AtomCoord[i]);
2395 set_status_label_info(_("File name"),_("Nothing"));
2396 set_status_label_info(_("File type"),_("Nothing"));
2397 set_status_label_info(_("Geometry"),_("Nothing"));
2398 return FALSE;
2399 }
2400 if(!OK)break;
2401
2402 j=-1;
2403 while(!feof(fd) )
2404 {
2405 { char* e = fgets(t,taille,fd);}
2406 if (strstr( t, "----------------------------------" ) )
2407 {
2408 geompos = ftell(fd);
2409 get_dipole_from_gaussian_output_file(fd);
2410 fseek(fd, geompos, SEEK_SET);
2411 gl_get_charges_from_gaussian_output_file(fd,j+1);
2412 gl_get_natural_charges_from_gaussian_output_file(fd,j+1);
2413 fseek(fd, geompos, SEEK_SET);
2414 gl_get_esp_charges_from_gaussian_output_file(fd,j+1);
2415 fseek(fd, geompos, SEEK_SET);
2416 break;
2417 }
2418 j++;
2419 if(GeomOrb==NULL)
2420 GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2421 else
2422 GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2423
2424 if(itype==0)
2425 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
2426 else
2427 sscanf(t,"%d %s %d %s %s %s",&idummy,AtomCoord[0],&idummy,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
2428
2429 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2430 l=strlen(AtomCoord[0]);
2431 if (l==2)
2432 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2433
2434 GeomOrb[j].Symb=g_strdup(symb_atom_get((guint)atoi(AtomCoord[0])));
2435 for(i=0;i<3;i++)
2436 GeomOrb[j].C[i]=atof(ang_to_bohr(AtomCoord[i+1]));
2437
2438 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2439 GeomOrb[j].partialCharge = 0.0;
2440 GeomOrb[j].variable = TRUE;
2441 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2442 /* Debug("%s %lf %lf %lf \n",GeomOrb[j].Symb,GeomOrb[j].C[0],GeomOrb[j].C[1],GeomOrb[j].C[2]);*/
2443 }
2444 if(num >0 && (gint)numgeom-1 == num)
2445 break;
2446
2447 }while(!feof(fd));
2448
2449 nCenters = j+1;
2450 fclose(fd);
2451 g_free(t);
2452 for(i=0;i<5;i++)
2453 g_free(AtomCoord[i]);
2454 if(nCenters == 0 )
2455 g_free(GeomOrb);
2456 else
2457 {
2458 DefineType();
2459 /* PrintGeomOrb();*/
2460 }
2461 buildBondsOrb();
2462 reset_grid_limits();
2463 init_atomic_orbitals();
2464 set_status_label_info(_("Geometry"),_("Ok"));
2465 RebuildGeom = TRUE;
2466 if(this_is_a_new_geometry()) free_objects_all();
2467 glarea_rafresh(GLArea);
2468 return TRUE;
2469 }
2470 /********************************************************************************/
gl_read_gaussn_file_geomi(gchar * FileName,gint num)2471 gboolean gl_read_gaussn_file_geomi(gchar *FileName,gint num)
2472 {
2473
2474
2475
2476 FILE* fd;
2477 if ((!FileName) || (strcmp(FileName,"") == 0))
2478 {
2479 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
2480 return FALSE;
2481 }
2482 fd = FOpen(FileName, "rb");
2483 if(fd ==NULL)
2484 {
2485 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
2486 return FALSE;
2487 }
2488 fclose(fd);
2489
2490
2491 if(gl_read_gaussn_file_geomi_str(FileName,num,"Standard orientation:"))
2492 return TRUE;
2493 if(gl_read_gaussn_file_geomi_str(FileName,num,"Input orientation:"))
2494 return TRUE;
2495 /* for calculation with nosym option */
2496 if(!gl_read_gaussn_file_geomi_str(FileName,num,"Z-Matrix orientation:"))
2497 {
2498 Message(_("Sorry\nI can not read geometry in this file"),_("Error"),TRUE);
2499 return FALSE;
2500 }
2501 return TRUE;
2502
2503 }
2504 /********************************************************************************/
gl_read_fchk_gaussn_file_geom(gchar * fileName)2505 gboolean gl_read_fchk_gaussn_file_geom(gchar *fileName)
2506 {
2507 FILE *file;
2508 gint i,j;
2509 gint n;
2510 gchar* tmp = NULL;
2511 gdouble* coords = NULL;
2512 gdouble* charges = NULL;
2513 gdouble* dipole = NULL;
2514 gint* z = NULL;
2515 gdouble* zn = NULL;
2516
2517 file = FOpen(fileName, "rb");
2518 if(file ==NULL)
2519 {
2520 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
2521 return FALSE;
2522 }
2523
2524 j = get_one_int_from_fchk_gaussian_file(file,"Number of atoms ");
2525 if(j<1)
2526 {
2527 Message(_("Sorry\nI can not the number of atoms from this file"),_("Error"),TRUE);
2528 return FALSE;
2529 }
2530 z = get_array_int_from_fchk_gaussian_file(file, "Atomic numbers ", &n);
2531 if(n!=j)
2532 {
2533 Message(_("Sorry\nI can not read the atomic numbers from this file"),_("Error"),TRUE);
2534 return FALSE;
2535 }
2536 coords = get_array_real_from_fchk_gaussian_file(file, "Current cartesian coordinates ", &n);
2537 if(n!=3*j)
2538 {
2539 Message(_("Sorry\nI can not read the current cartesian coordinates from this file"),_("Error"),TRUE);
2540 return FALSE;
2541 }
2542 free_data_all();
2543 tmp = get_name_file(fileName);
2544 set_status_label_info(_("File name"),tmp);
2545 g_free(tmp);
2546 set_status_label_info(_("File type"),"Gaussian fchk");
2547 set_status_label_info(_("Geometry"),_("Reading"));
2548 rewind(file);
2549 nCenters = j;
2550
2551 GeomOrb=g_malloc(nCenters*sizeof(TypeGeomOrb));
2552 for(j=0;j<nCenters;j++)
2553 {
2554 GeomOrb[j].Symb=g_strdup(symb_atom_get(z[j]));
2555 for(i=0;i<3;i++) GeomOrb[j].C[i]=coords[j*3+i];
2556 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2557 GeomOrb[j].partialCharge = 0.0;
2558 GeomOrb[j].variable = TRUE;
2559 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2560 }
2561 if(z) g_free(z);
2562 if(coords) g_free(coords);
2563 z = NULL;
2564 coords = NULL;
2565 rewind(file);
2566 charges = get_array_real_from_fchk_gaussian_file(file, "NPA Charges ", &n);
2567 if(n==nCenters && charges)
2568 {
2569 for(j=0;j<nCenters;j++)
2570 GeomOrb[j].partialCharge = charges[j];
2571
2572 }
2573 else
2574 {
2575 rewind(file);
2576 charges = get_array_real_from_fchk_gaussian_file(file, "ESP Charges ", &n);
2577 if(n==nCenters && charges)
2578 {
2579 for(j=0;j<nCenters;j++)
2580 GeomOrb[j].partialCharge = charges[j];
2581 }
2582 else
2583 {
2584 rewind(file);
2585 charges = get_array_real_from_fchk_gaussian_file(file, "Mulliken Charges ", &n);
2586 if(n==nCenters && charges)
2587 {
2588 for(j=0;j<nCenters;j++)
2589 GeomOrb[j].partialCharge = charges[j];
2590 }
2591 if(charges) g_free(charges);
2592 }
2593 }
2594 rewind(file);
2595 zn = get_array_real_from_fchk_gaussian_file(file, "Nuclear charges ", &n);
2596 if(zn && n== j)
2597 {
2598 for(j=0;j<nCenters;j++)
2599 GeomOrb[j].nuclearCharge = zn[j];
2600 }
2601 if(zn)g_free(zn);
2602 if(n!=j)
2603 {
2604 Message(_("Sorry\nI can not read the atomic numbers from this file"),_("Error"),TRUE);
2605 return FALSE;
2606 }
2607 dipole = get_array_real_from_fchk_gaussian_file(file, "Dipole Moment ", &n);
2608 init_dipole();
2609 if(n==3)
2610 {
2611 for(i=0;i<3;i++) Dipole.value[i] = dipole[i] / AUTODEB;
2612 Dipole.def = TRUE;
2613
2614 }
2615 if(dipole) g_free(dipole);
2616 fclose(file);
2617 if(nCenters == 0 ) g_free(GeomOrb);
2618 else DefineType();
2619 buildBondsOrb();
2620 reset_grid_limits();
2621 init_atomic_orbitals();
2622 set_status_label_info(_("Geometry"),_("Ok"));
2623 RebuildGeom = TRUE;
2624 if(this_is_a_new_geometry()) free_objects_all();
2625 glarea_rafresh(GLArea);
2626 return TRUE;
2627 }
2628 /********************************************************************************/
gl_get_esp_charges_from_mopac_output_file(FILE * fd)2629 void gl_get_esp_charges_from_mopac_output_file(FILE* fd)
2630 {
2631 guint taille=BSIZE;
2632 gchar *t = g_malloc(BSIZE*sizeof(gchar));
2633 gchar* pdest;
2634
2635 init_dipole();
2636
2637 while(!feof(fd) )
2638 {
2639 pdest = NULL;
2640 init_dipole();
2641 if(!fgets(t,taille,fd)) break;
2642 pdest = strstr( t, "ELECTROSTATIC POTENTIAL CHARGES");
2643
2644 if(pdest)
2645 {
2646 gint j;
2647 gchar dum1[100];
2648 gchar dum2[100];
2649 gchar dum3[100];
2650
2651 if(!fgets(t,taille,fd)) break;
2652 if(!fgets(t,taille,fd)) break;
2653 for(j=0;j<nCenters;j++)
2654 {
2655 if(!fgets(t,taille,fd)) break;
2656 sscanf(t,"%s %s %s",dum1,dum2,dum3);
2657 GeomOrb[j].partialCharge=atof(dum3);
2658 }
2659 break;
2660 }
2661 }
2662 g_free(t);
2663 }
2664 /********************************************************************************/
gl_get_charges_from_mopac_output_file(FILE * fd)2665 void gl_get_charges_from_mopac_output_file(FILE* fd)
2666 {
2667 guint taille=BSIZE;
2668 gchar *t = g_malloc(BSIZE*sizeof(gchar));
2669 gchar* pdest;
2670
2671 init_dipole();
2672
2673 while(!feof(fd) )
2674 {
2675 pdest = NULL;
2676 init_dipole();
2677 { char* e = fgets(t,taille,fd);}
2678 pdest = strstr( t, "TYPE CHARGE");
2679
2680 if(pdest)
2681 {
2682 gint j;
2683 gchar dum1[100];
2684 gchar dum2[100];
2685 gchar dum3[100];
2686
2687 for(j=0;j<nCenters;j++)
2688 {
2689 if(!fgets(t,taille,fd)) break;
2690 sscanf(t,"%s %s %s",dum1,dum2,dum3);
2691 GeomOrb[j].partialCharge=atof(dum3);
2692 }
2693 break;
2694 }
2695 }
2696 g_free(t);
2697 }
2698 /********************************************************************************/
gl_read_mopac_output_file_geomi(gchar * fileName,gint numgeometry)2699 gboolean gl_read_mopac_output_file_geomi(gchar *fileName, gint numgeometry)
2700 {
2701 gchar *t;
2702 gchar *tmp;
2703 gchar *AtomCoord[5];
2704 FILE *fd;
2705 guint taille=BSIZE;
2706 guint idummy;
2707 guint i;
2708 gint j=0;
2709 gint l;
2710 gint numgeom;
2711 gchar *pdest;
2712 long int geomposok = 0;
2713 gchar tmp1[100];
2714 gchar tmp2[100];
2715 /* gboolean OK = FALSE;*/
2716
2717 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
2718
2719 t=g_malloc(taille*sizeof(gchar));
2720 fd = FOpen(fileName, "rb");
2721 if(fd ==NULL)
2722 {
2723 g_free(t);
2724 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
2725 Message(t,_("Error"),TRUE);
2726 g_free(t);
2727 return FALSE;
2728 }
2729 free_data_all();
2730 tmp = get_name_file(fileName);
2731 set_status_label_info(_("File name"),tmp);
2732 g_free(tmp);
2733 set_status_label_info(_("File type"),"Mopac");
2734 set_status_label_info(_("Geometry"),_("Reading"));
2735 numgeom =0;
2736 /* OK=FALSE;*/
2737 while(!feof(fd))
2738 {
2739 if(!fgets(t,taille,fd))break;
2740 pdest = strstr( t, "ATOM CHEMICAL X Y Z");
2741 if(pdest)
2742 {
2743 if(!fgets(t,taille,fd)) {pdest=0;break;}
2744 if(!fgets(t,taille,fd)) {pdest=0;break;}
2745 }
2746 if ( pdest )
2747 {
2748 numgeom++;
2749 geomposok = ftell(fd);
2750 if(numgeom == numgeometry )
2751 {
2752 /* OK = TRUE;*/
2753 break;
2754 }
2755 /*
2756 if(numgeometry<0)
2757 {
2758 OK = TRUE;
2759 }
2760 */
2761 }
2762 }
2763 if(numgeom == 0)
2764 {
2765 g_free(t);
2766 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),fileName);
2767 Message(t,_("Error"),TRUE);
2768 g_free(t);
2769 set_status_label_info(_("File name"),_("Nothing"));
2770 set_status_label_info(_("File type"),_("Nothing"));
2771 set_status_label_info(_("Geometry"),_("Nothing"));
2772 return FALSE;
2773 }
2774 init_dipole();
2775 for(i=0;i<3;i++) Dipole.value[i] = 0;
2776 j=-1;
2777 fseek(fd, geomposok, SEEK_SET);
2778 while(!feof(fd) )
2779 {
2780 gint ii;
2781 if(!fgets(t,taille,fd))break;
2782 if(0==sscanf(t,"%d",&ii))break;
2783 if(this_is_a_backspace(t))
2784 {
2785 if(numgeometry<0)
2786 {
2787 nCenters = j+1;
2788 fseek(fd, 0, SEEK_SET);
2789 gl_get_charges_from_mopac_output_file(fd);
2790 fseek(fd, 0, SEEK_SET);
2791 gl_get_esp_charges_from_mopac_output_file(fd);
2792 fseek(fd, 0, SEEK_SET);
2793 get_dipole_from_mopac_output_file(fd);
2794 }
2795 break;
2796 }
2797 j++;
2798 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2799 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2800 for(ii=0;ii<strlen(t);ii++) if(t[ii]=='*') t[ii]=' ';
2801 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
2802 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2803 l=strlen(AtomCoord[0]);
2804 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2805 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
2806 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
2807
2808
2809 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
2810 for(i=0;i<3;i++)
2811 {
2812 GeomOrb[j].C[i]=atof((AtomCoord[i+1]))*ANG_TO_BOHR;
2813 }
2814
2815 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2816 GeomOrb[j].partialCharge = 0.0;
2817 GeomOrb[j].variable = TRUE;
2818 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2819 }
2820 fclose(fd);
2821 nCenters = j+1;
2822 if(nCenters >0)
2823 DefineType();
2824
2825 RebuildGeom = TRUE;
2826 buildBondsOrb();
2827 reset_grid_limits();
2828 init_atomic_orbitals();
2829 set_status_label_info(_("Geometry"),_("Ok"));
2830 g_free(t);
2831 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2832 return TRUE;
2833 }
2834 /********************************************************************************/
gl_read_mopac_aux_file_geomi(gchar * fileName,gint numgeometry)2835 gboolean gl_read_mopac_aux_file_geomi(gchar *fileName, gint numgeometry)
2836 {
2837 gchar *t;
2838 gchar *tmp;
2839 gboolean OK;
2840 gchar *AtomCoord[5];
2841 FILE *fd;
2842 guint taille=BSIZE;
2843 guint i;
2844 gint j=0;
2845 gint l;
2846 gint numgeom;
2847 gchar *pdest;
2848 long int geomposok = 0;
2849 gchar** elements = NULL;
2850 gint nElements = 0;
2851 gchar** nuclearCharges = NULL;
2852 gint nNuclearCharges = 0;
2853 gchar** partialCharges = NULL;
2854 gint nPartialCharges = 0;
2855
2856 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
2857
2858 t=g_malloc(taille*sizeof(gchar));
2859 fd = FOpen(fileName, "rb");
2860 if(fd ==NULL)
2861 {
2862 g_free(t);
2863 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
2864 Message(t,_("Error"),TRUE);
2865 g_free(t);
2866 return FALSE;
2867 }
2868 OK=FALSE;
2869 elements = get_one_block_from_aux_mopac_file(fd, "ATOM_EL[", &nElements);
2870 if(elements) OK = TRUE;
2871 if(!OK)
2872 {
2873 g_free(t);
2874 t = g_strdup_printf(_("Sorry\nI can not read the atom symbols in %s file "),fileName);
2875 Message(t,_("Error"),TRUE);
2876 g_free(t);
2877 fclose(fd);
2878 return FALSE;
2879 }
2880 geomposok = ftell(fd);
2881 nuclearCharges = get_one_block_from_aux_mopac_file(fd, "ATOM_CORE[", &nNuclearCharges);
2882 if(!nuclearCharges) fseek(fd, geomposok, SEEK_SET);
2883
2884 numgeom =0;
2885 free_data_all();
2886 tmp = get_name_file(fileName);
2887 set_status_label_info(_("File name"),tmp);
2888 g_free(tmp);
2889 set_status_label_info(_("File type"),"Mopac");
2890 set_status_label_info(_("Geometry"),_("Reading"));
2891 while(!feof(fd))
2892 {
2893 if(!fgets(t,taille,fd))break;
2894 if(numgeometry<0)
2895 pdest = strstr( t, "ATOM_X_OPT:ANGSTROMS");
2896 else
2897 pdest = strstr( t, "ATOM_X_UPDATED:ANGSTROMS");
2898 if ( pdest )
2899 {
2900 numgeom++;
2901 geomposok = ftell(fd);
2902 if(numgeom == numgeometry )
2903 {
2904 OK = TRUE;
2905 break;
2906 }
2907 if(numgeometry<0)
2908 {
2909 OK = TRUE;
2910 }
2911 }
2912 }
2913 if(numgeom == 0)
2914 {
2915 free_one_string_table(elements, nElements);
2916 g_free(t);
2917 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),fileName);
2918 Message(t,_("Error"),TRUE);
2919 g_free(t);
2920 set_status_label_info(_("File name"),_("Nothing"));
2921 set_status_label_info(_("File type"),_("Nothing"));
2922 set_status_label_info(_("Geometry"),_("Nothing"));
2923 fclose(fd);
2924 return FALSE;
2925 }
2926
2927 init_dipole();
2928 for(i=0;i<3;i++) Dipole.value[i] = 0;
2929 j=-1;
2930 fseek(fd, geomposok, SEEK_SET);
2931 while(!feof(fd) )
2932 {
2933 if(!fgets(t,taille,fd))break;
2934 if(strstr( t, "[")
2935 || strstr(t,"HEAT_OF_FORM_UPDATED")
2936 || strstr( t, "####################################")
2937 ||this_is_a_backspace(t))
2938 {
2939 break;
2940 }
2941 if(j+1>nElements)break;
2942 j++;
2943 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
2944 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
2945
2946 sscanf(t,"%s %s %s",AtomCoord[1],AtomCoord[2],AtomCoord[3]);
2947 if(j<nElements) sprintf(AtomCoord[0],"%s",elements[j]);
2948 else sprintf(AtomCoord[0],"X");
2949 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
2950 l=strlen(AtomCoord[0]);
2951 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
2952 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
2953 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
2954
2955 GeomOrb[j].Symb=g_strdup(AtomCoord[0]);
2956 for(i=0;i<3;i++)
2957 {
2958 GeomOrb[j].C[i]=atof((AtomCoord[i+1]))*ANG_TO_BOHR;
2959 }
2960
2961 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
2962 GeomOrb[j].partialCharge = 0.0;
2963 if(nuclearCharges && nNuclearCharges>j) GeomOrb[j].nuclearCharge = atof(nuclearCharges[j]);
2964 else GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
2965 }
2966 nCenters = j+1;
2967 if(nCenters >0)
2968 DefineType();
2969
2970 if(numgeometry<0)
2971 {
2972 fseek(fd, geomposok, SEEK_SET);
2973 partialCharges = get_one_block_from_aux_mopac_file(fd, "ATOM_CHARGES[", &nPartialCharges);
2974 if(partialCharges)
2975 {
2976 for(j=0;j<nCenters;j++)
2977 if(j<nPartialCharges) GeomOrb[j].partialCharge=atof(partialCharges[j]);
2978 free_one_string_table(partialCharges, nPartialCharges);
2979 }
2980 }
2981 fclose(fd);
2982
2983 g_free(t);
2984 free_one_string_table(elements, nElements);
2985 free_one_string_table(nuclearCharges, nNuclearCharges);
2986 for(i=0;i<5;i++) g_free(AtomCoord[i]);
2987 buildBondsOrb();
2988 reset_grid_limits();
2989 init_atomic_orbitals();
2990 set_status_label_info(_("Geometry"),_("Ok"));
2991 RebuildGeom = TRUE;
2992 if(this_is_a_new_geometry()) free_objects_all();
2993 glarea_rafresh(GLArea);
2994 return TRUE;
2995 }
2996 /********************************************************************************/
gl_read_wfx_file_geom(gchar * fileName)2997 gboolean gl_read_wfx_file_geom(gchar *fileName)
2998 {
2999 gint k;
3000 gint j;
3001 gchar t[BSIZE];
3002 gchar** symbols = NULL;
3003 gdouble* coordinates = NULL;
3004 gint nSymbols,nCoordinates;
3005 FILE* file = FOpen(fileName, "rb");
3006 gdouble* nuclearCharges = NULL;
3007 gint nNuclearCharges;
3008 gchar* tmp = NULL;
3009
3010 if(file ==NULL)
3011 {
3012 sprintf(t,"Sorry\nI can not open %s file ",fileName);
3013 Message(t,_("Error"),TRUE);
3014 return FALSE;
3015 }
3016 symbols = get_one_block_from_wfx_file(file,"Nuclear Name",&nSymbols);
3017 //fprintf(stderr,"nSymb = %d\n",nSymbols);
3018 if(!symbols || nSymbols<1)
3019 {
3020 sprintf(t,"Sorry\nI cannot read symbol from %s file ",fileName);
3021 Message(t,_("Error"),TRUE);
3022 fclose(file);
3023 if(symbols) free_one_string_table(symbols, nSymbols);
3024 return FALSE;
3025 }
3026 rewind(file);
3027 coordinates = get_one_block_real_from_wfx_file(file,"Nuclear Cartesian Coordinates",&nCoordinates);
3028 //fprintf(stderr,"nC = %d\n",nCoordinates);
3029 if(!coordinates || nCoordinates<3)
3030 {
3031 sprintf(t,"Sorry\nI cannot read coordinates from %s file ",fileName);
3032 Message(t,_("Error"),TRUE);
3033 fclose(file);
3034 if(symbols) free_one_string_table(symbols, nSymbols);
3035 if(coordinates) g_free(coordinates);
3036 return FALSE;
3037 }
3038 if(nCoordinates!=3*nSymbols)
3039 {
3040 sprintf(t,"Sorry\nI cannot read geomtry from %s file",fileName);
3041 Message(t,_("Error"),TRUE);
3042 fclose(file);
3043 if(symbols) free_one_string_table(symbols, nSymbols);
3044 if(coordinates) g_free(coordinates);
3045 return FALSE;
3046 }
3047
3048 rewind(file);
3049 nuclearCharges = get_one_block_real_from_wfx_file(file,"Nuclear Charges",&nNuclearCharges);
3050 fclose(file);
3051
3052 free_data_all();
3053 tmp = get_name_file(fileName);
3054 set_status_label_info(_("File name"),tmp);
3055 g_free(tmp);
3056 set_status_label_info(_("File type"),"WFX");
3057 set_status_label_info(_("Geometry"),_("Reading"));
3058
3059 if(GeomOrb==NULL) GeomOrb=g_malloc(nSymbols*sizeof(TypeGeomOrb));
3060 else GeomOrb=g_realloc(GeomOrb,nSymbols*sizeof(TypeGeomOrb));
3061
3062 for(j=0;j<nSymbols;j++)
3063 {
3064 gint i,l;
3065
3066 for(k=0;k<(gint)strlen(symbols[j]);k++) if(isdigit(symbols[j][k])) symbols[j][k] = ' ';
3067 delete_all_spaces(symbols[j]);
3068
3069 symbols[j][0]=toupper(symbols[j][0]);
3070 l=strlen(symbols[j]);
3071 if (l==2) symbols[j][1]=tolower(symbols[j][1]);
3072 if(l==1)sprintf(t,"%c",symbols[j][0]);
3073 else sprintf(t,"%c%c",symbols[j][0],symbols[j][1]);
3074 //fprintf(stderr,"t=%s\n", t);
3075
3076 GeomOrb[j].Symb=g_strdup(t);
3077 for(i=0;i<3;i++) GeomOrb[j].C[i]=coordinates[3*j+i];
3078 //fprintf(stderr,"XYZ0 = %f %f %f\n", GeomOrb[j].C[0], GeomOrb[j].C[1], GeomOrb[j].C[2]);
3079 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3080 GeomOrb[j].partialCharge = 0.0;
3081 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
3082 if(nuclearCharges && nNuclearCharges>j) GeomOrb[j].nuclearCharge = nuclearCharges[j];
3083 //fprintf(stderr,"XYZ = %f %f %f\n", GeomOrb[j].C[0], GeomOrb[j].C[1], GeomOrb[j].C[2]);
3084 }
3085 nCenters = nSymbols;
3086 if(nCenters >0) DefineType();
3087 if(symbols) free_one_string_table(symbols, nSymbols);
3088 //fprintf(stderr,"End free symbols");
3089 if(coordinates) g_free(coordinates);
3090 //fprintf(stderr,"End free coordinates");
3091 if(nuclearCharges) g_free(nuclearCharges);
3092 //fprintf(stderr,"End free nuclearCharges");
3093 init_dipole();
3094 Dipole.value[0] = Dipole.value[1] = Dipole.value[2] = 0;
3095
3096 buildBondsOrb();
3097 reset_grid_limits();
3098 init_atomic_orbitals();
3099 set_status_label_info(_("Geometry"),_("Ok"));
3100 RebuildGeom = TRUE;
3101 if(this_is_a_new_geometry()) free_objects_all();
3102 glarea_rafresh(GLArea);
3103 return TRUE;
3104 }
3105 /********************************************************************************/
gl_get_charges_from_orca_output_file(FILE * fd,gint N)3106 void gl_get_charges_from_orca_output_file(FILE* fd,gint N)
3107 {
3108 guint taille=BSIZE;
3109 gchar t[BSIZE];
3110 gchar dump[BSIZE];
3111 gchar d[BSIZE];
3112 gchar* pdest;
3113 gint i;
3114
3115
3116 for(i=0;i<N;i++)
3117 GeomOrb[i].partialCharge = 0.0;
3118
3119 while(!feof(fd) )
3120 {
3121 pdest = NULL;
3122 { char* e = fgets(t,taille,fd);}
3123 if(strstr(t,"GEOMETRY OPTIMIZATION CYCLE")) break;
3124 pdest = strstr( t, "MULLIKEN ATOMIC CHARGES");
3125
3126 if(pdest)
3127 {
3128 gboolean OK = FALSE;
3129 while(!feof(fd) )
3130 {
3131 if(!fgets(t,taille,fd)) break;
3132 if(strstr(t,"----------------"))
3133 {
3134 OK = TRUE;
3135 break;
3136 }
3137 }
3138 if(!OK) break;
3139
3140 for(i=0;i<N;i++)
3141 {
3142 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
3143 else break;
3144 if(sscanf(t,"%s %s %s %s",dump,dump,dump,d)==4)
3145 {
3146 GeomOrb[i].partialCharge = atof(d);
3147 }
3148 }
3149 break;
3150 }
3151 }
3152 }
3153 /********************************************************************************/
gl_read_orca_file_geomi(gchar * FileName,gint num)3154 gboolean gl_read_orca_file_geomi(gchar *FileName,gint num)
3155 {
3156 gchar *t;
3157 gchar *tmp = NULL;
3158 /* gboolean OK;*/
3159 gchar *AtomCoord[5];
3160 FILE *fd;
3161 guint taille=BSIZE;
3162 guint i;
3163 gint j=0;
3164 gint l;
3165 guint numgeom;
3166 gchar *pdest;
3167 long int geomposok = 0;
3168 long int geompos = 0;
3169 gchar dum[BSIZE];
3170 gdouble mass;
3171 gdouble nucCharge;
3172
3173 for(i=0;i<5;i++)
3174 AtomCoord[i]=g_malloc(taille*sizeof(char));
3175
3176 fd = FOpen(FileName, "rb");
3177
3178 free_data_all();
3179 tmp = get_name_file(FileName);
3180 set_status_label_info(_("File name"),tmp);
3181 g_free(tmp);
3182 set_status_label_info(_("File type"),"Orca");
3183
3184 t=g_malloc(taille);
3185
3186 numgeom =0;
3187 set_status_label_info(_("Geometry"),_("Reading"));
3188 /* OK=FALSE;*/
3189
3190 while(!feof(fd))
3191 {
3192 if(!fgets(t,taille,fd))break;
3193 pdest = strstr( t, "CARTESIAN COORDINATES (A.U.)");
3194 if(pdest)
3195 {
3196 if(!fgets(t,taille,fd))break;
3197 if(!fgets(t,taille,fd))break;
3198 }
3199 if (strstr( t, "FRAG") && strstr( t, "MASS") )
3200 {
3201 numgeom++;
3202 geomposok = ftell(fd);
3203 if(numgeom == num )
3204 {
3205 /* OK = TRUE;*/
3206 break;
3207 }
3208 /*
3209 if(num<0)
3210 {
3211 OK = TRUE;
3212 }
3213 */
3214 }
3215 }
3216 if(numgeom == 0)
3217 {
3218 fclose(fd);
3219 g_free(t);
3220 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3221 set_status_label_info(_("File name"),_("Nothing"));
3222 set_status_label_info(_("File type"),_("Nothing"));
3223 set_status_label_info(_("Geometry"),_("Nothing"));
3224 return FALSE;
3225 }
3226 j=-1;
3227 fseek(fd, geomposok, SEEK_SET);
3228 while(!feof(fd) )
3229 {
3230 { char* e = fgets(t,taille,fd);}
3231 pdest = strstr( t, "----------------------------------" );
3232 if(!pdest) pdest = strstr( t, "due to ECP");
3233 if (pdest || this_is_a_backspace(t))
3234 {
3235 geompos = ftell(fd);
3236 get_dipole_from_orca_output_file(fd);
3237 fseek(fd, geompos, SEEK_SET);
3238 gl_get_charges_from_orca_output_file(fd,j+1);
3239 fseek(fd, geompos, SEEK_SET);
3240 break;
3241 }
3242 j++;
3243 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
3244 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
3245
3246 //printf("t=%s\n",t);
3247 //sscanf(t,"%s %s %lf %s %lf %s %s %s",dum,AtomCoord[0],&nucCharge,dum,&mass,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3248 sscanf(t,"%s %s %s %s %lf %s %s %s",dum,AtomCoord[0],AtomCoord[4],dum,&mass,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3249 nucCharge = atof(AtomCoord[4]);
3250
3251 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
3252 l=strlen(AtomCoord[0]);
3253 if (l==2)
3254 {
3255 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
3256 if(isdigit(AtomCoord[0][1]))l=1;
3257 }
3258 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
3259 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
3260 /* if(!strcmp(t,"-")) sprintf(t,"X");*/
3261 if(!strcmp(t,"-")) { j--; continue;}
3262
3263 GeomOrb[j].Symb=g_strdup(t);
3264 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1]);
3265
3266 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3267 GeomOrb[j].Prop.masse = mass;
3268 GeomOrb[j].partialCharge = 0.0;
3269 GeomOrb[j].variable = TRUE;
3270 GeomOrb[j].nuclearCharge = nucCharge;
3271 }
3272
3273 nCenters = j+1;
3274 fclose(fd);
3275 g_free(t);
3276 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3277 if(nCenters == 0 ) g_free(GeomOrb);
3278 else
3279 {
3280 DefineType();
3281 }
3282 buildBondsOrb();
3283 reset_grid_limits();
3284 init_atomic_orbitals();
3285 set_status_label_info(_("Geometry"),_("Ok"));
3286 RebuildGeom = TRUE;
3287 if(this_is_a_new_geometry()) free_objects_all();
3288 glarea_rafresh(GLArea);
3289 return TRUE;
3290 }
3291 /********************************************************************************/
gl_read_orca_file_hessian(gchar * FileName)3292 gboolean gl_read_orca_file_hessian(gchar *FileName)
3293 {
3294 gchar *t;
3295 gchar *tmp = NULL;
3296 /* gboolean OK;*/
3297 gchar *AtomCoord[5];
3298 FILE *fd;
3299 guint taille=BSIZE;
3300 guint i;
3301 gint j=0;
3302 gint l;
3303 /* guint numgeom;*/
3304 gchar *pdest;
3305 long int geomposok = 0;
3306 long int geompos = 0;
3307 gchar dum[BSIZE];
3308 gdouble mass;
3309 gdouble nucCharge;
3310 gint nAtoms = 0;
3311
3312 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
3313
3314 fd = FOpen(FileName, "rb");
3315
3316 free_data_all();
3317 tmp = get_name_file(FileName);
3318 set_status_label_info(_("File name"),tmp);
3319 g_free(tmp);
3320 set_status_label_info(_("File type"),"Orca");
3321
3322 t=g_malloc(taille*sizeof(gchar));
3323
3324 /* numgeom =0;*/
3325 set_status_label_info(_("Geometry"),_("Reading"));
3326 /* OK=FALSE;*/
3327
3328 while(!feof(fd))
3329 {
3330 if(!fgets(t,taille,fd))break;
3331 if(strstr( t, "$atoms"))
3332 {
3333 if(!fgets(t,taille,fd))break;
3334 sscanf(t,"%d",&nAtoms);
3335 break;
3336 }
3337 }
3338 if(nAtoms == 0)
3339 {
3340 fclose(fd);
3341 g_free(t);
3342 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3343 set_status_label_info(_("File name"),_("Nothing"));
3344 set_status_label_info(_("File type"),_("Nothing"));
3345 set_status_label_info(_("Geometry"),_("Nothing"));
3346 return FALSE;
3347 }
3348 /* printf("nAtoms = %d\n",nAtoms);*/
3349 GeomOrb=g_malloc(nAtoms*sizeof(TypeGeomOrb));
3350 for(j=0;j<nAtoms;j++)
3351 {
3352 { char* e = fgets(t,taille,fd);}
3353 sscanf(t,"%s %lf %s %s %s",AtomCoord[0],&mass,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3354 /* printf("t=%s\n",t);*/
3355 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
3356 l=strlen(AtomCoord[0]);
3357 if (l==2)
3358 {
3359 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
3360 if(isdigit(AtomCoord[0][1]))l=1;
3361 }
3362 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
3363 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
3364
3365 GeomOrb[j].Symb=g_strdup(t);
3366 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1]);
3367
3368 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3369 GeomOrb[j].Prop.masse = mass;
3370 GeomOrb[j].partialCharge = 0.0;
3371 GeomOrb[j].variable = TRUE;
3372 GeomOrb[j].nuclearCharge = 1.0;
3373 }
3374 fseek(fd, 0, SEEK_SET);
3375 get_dipole_from_orca_output_file(fd);
3376 fseek(fd, geompos, SEEK_SET);
3377 gl_get_charges_from_orca_output_file(fd,nAtoms);
3378 fseek(fd, geompos, SEEK_SET);
3379 fclose(fd);
3380 g_free(t);
3381 nCenters = nAtoms;
3382 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3383 if(nCenters == 0 ) g_free(GeomOrb);
3384 else
3385 {
3386 DefineType();
3387 }
3388 buildBondsOrb();
3389 reset_grid_limits();
3390 //printf("end reset_grid_limits\n");
3391 init_atomic_orbitals();
3392 set_status_label_info(_("Geometry"),_("Ok"));
3393 RebuildGeom = TRUE;
3394 if(this_is_a_new_geometry()) free_objects_all();
3395 //printf("end free_objects_all\n");
3396 glarea_rafresh(GLArea);
3397 return TRUE;
3398 }
3399 /********************************************************************************/
gl_get_charges_from_qchem_output_file(FILE * fd,gint N)3400 void gl_get_charges_from_qchem_output_file(FILE* fd,gint N)
3401 {
3402 guint taille=BSIZE;
3403 gchar t[BSIZE];
3404 gchar dump[BSIZE];
3405 gchar d[BSIZE];
3406 gchar* pdest;
3407 gint i;
3408 gint ngrad=0;
3409
3410
3411 while(!feof(fd) )
3412 {
3413 pdest = NULL;
3414 { char* e = fgets(t,taille,fd);}
3415 pdest = strstr( t, "Mulliken Net Atomic Charges");
3416
3417 if(pdest)
3418 {
3419 gboolean OK = FALSE;
3420 while(!feof(fd) )
3421 {
3422 if(!fgets(t,taille,fd)) break;
3423 if(strstr(t,"----------------"))
3424 {
3425 OK = TRUE;
3426 break;
3427 }
3428 }
3429 if(!OK) break;
3430
3431 for(i=0;i<N;i++)
3432 {
3433 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
3434 else break;
3435 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
3436 {
3437 GeomOrb[i].partialCharge = atof(d);
3438 }
3439 }
3440 break;
3441 }
3442 else
3443 {
3444 pdest = strstr( t, "GradGradGrad" );
3445 if(pdest)
3446 {
3447 ngrad++;
3448 }
3449 if(ngrad>2)
3450 break;
3451 }
3452
3453 }
3454 }
3455 /********************************************************************************/
gl_read_qchem_file_geomi(gchar * FileName,gint num)3456 gboolean gl_read_qchem_file_geomi(gchar *FileName,gint num)
3457 {
3458 gchar *t;
3459 gchar *tmp = NULL;
3460 gboolean OK;
3461 gchar *AtomCoord[5];
3462 FILE *fd;
3463 guint taille=BSIZE;
3464 guint idummy;
3465 guint i;
3466 gint j=0;
3467 gint l;
3468 guint numgeom;
3469 gchar *pdest;
3470 long geompos = 0;
3471
3472 for(i=0;i<5;i++)
3473 AtomCoord[i]=g_malloc(taille*sizeof(char));
3474
3475 fd = FOpen(FileName, "rb");
3476
3477 free_data_all();
3478 tmp = get_name_file(FileName);
3479 set_status_label_info(_("File name"),tmp);
3480 g_free(tmp);
3481 set_status_label_info(_("File type"),"Q-Chem");
3482
3483 t=g_malloc(taille);
3484
3485 numgeom =1;
3486 do
3487 {
3488 set_status_label_info(_("Geometry"),_("Reading"));
3489 OK=FALSE;
3490 while(!feof(fd))
3491 {
3492 if(!fgets(t,taille,fd))break;
3493 pdest = NULL;
3494 if (strstr( t,"Atom") && strstr( t,"X") && strstr( t,"Y") && strstr( t,"Z") )
3495 {
3496 if(!fgets(t,taille,fd))break;
3497 pdest = strstr( t,"----------------------------------");
3498 }
3499 if (pdest)
3500 {
3501 numgeom++;
3502 OK = TRUE;
3503 break;
3504 }
3505 }
3506 if(!OK && (numgeom == 1) )
3507 {
3508 fclose(fd);
3509 g_free(t);
3510 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3511 set_status_label_info(_("File name"),_("Nothing"));
3512 set_status_label_info(_("File type"),_("Nothing"));
3513 set_status_label_info(_("Geometry"),_("Nothing"));
3514 return FALSE;
3515 }
3516 if(!OK)break;
3517
3518 j=-1;
3519 while(!feof(fd) )
3520 {
3521 { char* e = fgets(t,taille,fd);}
3522 pdest = strstr( t, "----------------------------------" );
3523 if (pdest)
3524 {
3525 geompos = ftell(fd);
3526 get_dipole_from_qchem_output_file(fd);
3527 fseek(fd, geompos, SEEK_SET);
3528 gl_get_charges_from_qchem_output_file(fd,j+1);
3529 fseek(fd, geompos, SEEK_SET);
3530 break;
3531 }
3532 j++;
3533 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
3534 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
3535
3536 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3537
3538 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
3539 l=strlen(AtomCoord[0]);
3540 if (l==2)
3541 {
3542 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
3543 if(isdigit(AtomCoord[0][1]))l=1;
3544 }
3545 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
3546 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
3547
3548 GeomOrb[j].Symb=g_strdup(t);
3549 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(ang_to_bohr(AtomCoord[i+1]));
3550
3551 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3552 GeomOrb[j].partialCharge = 0.0;
3553 GeomOrb[j].variable = TRUE;
3554 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
3555 }
3556 if(num >0 && (gint)numgeom-1 == num) break;
3557 }while(!feof(fd));
3558
3559 nCenters = j+1;
3560 fclose(fd);
3561 g_free(t);
3562 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3563 if(nCenters == 0 ) g_free(GeomOrb);
3564 else
3565 {
3566 DefineType();
3567 }
3568 buildBondsOrb();
3569 reset_grid_limits();
3570 init_atomic_orbitals();
3571 set_status_label_info(_("Geometry"),_("Ok"));
3572 RebuildGeom = TRUE;
3573 if(this_is_a_new_geometry()) free_objects_all();
3574 glarea_rafresh(GLArea);
3575 return TRUE;
3576 }
3577 /********************************************************************************/
gl_get_charges_from_nwchem_output_file(FILE * fd,gint N)3578 void gl_get_charges_from_nwchem_output_file(FILE* fd,gint N)
3579 {
3580 guint taille=BSIZE;
3581 gchar t[BSIZE];
3582 gchar d3[BSIZE];
3583 gchar d4[BSIZE];
3584 gchar d[BSIZE];
3585 gchar* pdest;
3586 gint i;
3587
3588
3589 for(i=0;i<N;i++)
3590 GeomOrb[i].partialCharge = 0.0;
3591
3592 while(!feof(fd) )
3593 {
3594 pdest = NULL;
3595 { char* e = fgets(t,taille,fd);}
3596 pdest = strstr( t, "Atom Charge Shell Charges");
3597
3598 if(pdest)
3599 {
3600 gboolean OK = FALSE;
3601 while(!feof(fd) )
3602 {
3603 if(!fgets(t,taille,fd)) break;
3604 if(strstr(t,"----------------"))
3605 {
3606 OK = TRUE;
3607 break;
3608 }
3609 }
3610 if(!OK) break;
3611
3612 for(i=0;i<N;i++)
3613 {
3614 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
3615 else break;
3616 if(sscanf(t,"%s %s %s %s",d,d,d3,d4)==4)
3617 {
3618 GeomOrb[i].partialCharge = atof(d3)-atof(d4);
3619 }
3620 }
3621 break;
3622 }
3623 }
3624 }
3625 /********************************************************************************/
gl_read_nwchem_file_geomi(gchar * FileName,gint num)3626 gulong gl_read_nwchem_file_geomi(gchar *FileName,gint num)
3627 {
3628 gchar *t;
3629 gchar *tmp = NULL;
3630 gboolean OK;
3631 gchar *AtomCoord[5];
3632 FILE *fd;
3633 guint taille=BSIZE;
3634 guint idummy;
3635 guint i;
3636 gint j=0;
3637 gint l;
3638 guint numgeom;
3639 gchar *pdest;
3640 long geompos = 0;
3641 gboolean ang = FALSE;
3642 gulong line = 0;
3643 gulong lineg = 0;
3644
3645 for(i=0;i<5;i++)
3646 AtomCoord[i]=g_malloc(taille*sizeof(char));
3647
3648 fd = FOpen(FileName, "rb");
3649
3650 free_data_all();
3651 tmp = get_name_file(FileName);
3652 set_status_label_info(_("File name"),tmp);
3653 g_free(tmp);
3654 set_status_label_info(_("File type"),"NWChem");
3655
3656 t=g_malloc(taille);
3657
3658 numgeom =1;
3659 do
3660 {
3661 set_status_label_info(_("Geometry"),_("Reading"));
3662 OK=FALSE;
3663 while(!feof(fd))
3664 {
3665 line++;
3666 if(!fgets(t,taille,fd))break;
3667 if(strstr(t,"Output coordinates in angstroms")) ang = TRUE;
3668 if(strstr(t,"Output coordinates in a.u.")) ang = FALSE;
3669 pdest = strstr( t, "Charge X Y Z");
3670 if(pdest)
3671 {
3672 line++;
3673 if(!fgets(t,taille,fd))break;
3674 pdest = strstr( t, "--------------");
3675 }
3676 if (pdest)
3677 {
3678 lineg = line;
3679 numgeom++;
3680 OK = TRUE;
3681 break;
3682 }
3683 }
3684 if(!OK && (numgeom == 1) )
3685 {
3686 fclose(fd);
3687 g_free(t);
3688 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3689 set_status_label_info(_("File name"),_("Nothing"));
3690 set_status_label_info(_("File type"),_("Nothing"));
3691 set_status_label_info(_("Geometry"),_("Nothing"));
3692 return 0;
3693 }
3694 if(!OK)break;
3695
3696 j=-1;
3697 while(!feof(fd) )
3698 {
3699 line++;
3700 { char* e = fgets(t,taille,fd);}
3701 if(this_is_a_backspace(t))
3702 {
3703 geompos = ftell(fd);
3704 get_dipole_from_nwchem_output_file(fd);
3705 fseek(fd, geompos, SEEK_SET);
3706 gl_get_charges_from_nwchem_output_file(fd,j+1);
3707 fseek(fd, geompos, SEEK_SET);
3708 break;
3709 }
3710 j++;
3711 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
3712 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
3713
3714 sscanf(t,"%d %s %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3715
3716 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
3717 l=strlen(AtomCoord[0]);
3718 if (l==2)
3719 {
3720 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
3721 if(isdigit(AtomCoord[0][1]))l=1;
3722 }
3723 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
3724 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
3725
3726 /* HERE
3727 GeomOrb[j].Symb=get_symbol_using_z((int)(atof(AtomCoord[4])+0.5));
3728 */
3729 GeomOrb[j].Symb=g_strdup(t);
3730 if(ang)
3731 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(ang_to_bohr(AtomCoord[i+1]));
3732 else
3733 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1]);
3734
3735 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3736 GeomOrb[j].partialCharge = 0.0;
3737 GeomOrb[j].variable = TRUE;
3738 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
3739 }
3740 if(num >0 && (gint)numgeom-1 == num) break;
3741 }while(!feof(fd));
3742
3743 nCenters = j+1;
3744 fclose(fd);
3745 g_free(t);
3746 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3747 if(nCenters == 0 ) g_free(GeomOrb);
3748 else
3749 {
3750 DefineType();
3751 }
3752 buildBondsOrb();
3753 reset_grid_limits();
3754 init_atomic_orbitals();
3755 set_status_label_info(_("Geometry"),_("Ok"));
3756 RebuildGeom = TRUE;
3757 if(this_is_a_new_geometry()) free_objects_all();
3758 glarea_rafresh(GLArea);
3759 return lineg;
3760 }
3761 /********************************************************************************/
gl_get_charges_from_psicode_output_file(FILE * fd,gint N)3762 void gl_get_charges_from_psicode_output_file(FILE* fd,gint N)
3763 {
3764 guint taille=BSIZE;
3765 gchar t[BSIZE];
3766 gchar d3[BSIZE];
3767 gchar d4[BSIZE];
3768 gchar d[BSIZE];
3769 gchar* pdest;
3770 gint i;
3771
3772
3773 for(i=0;i<N;i++)
3774 GeomOrb[i].partialCharge = 0.0;
3775
3776 while(!feof(fd) )
3777 {
3778 pdest = NULL;
3779 { char* e = fgets(t,taille,fd);}
3780 pdest = strstr( t, "Atom Charge Shell Charges");
3781
3782 if(pdest)
3783 {
3784 gboolean OK = FALSE;
3785 while(!feof(fd) )
3786 {
3787 if(!fgets(t,taille,fd)) break;
3788 if(strstr(t,"----------------"))
3789 {
3790 OK = TRUE;
3791 break;
3792 }
3793 }
3794 if(!OK) break;
3795
3796 for(i=0;i<N;i++)
3797 {
3798 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
3799 else break;
3800 if(sscanf(t,"%s %s %s %s",d,d,d3,d4)==4)
3801 {
3802 GeomOrb[i].partialCharge = atof(d3)-atof(d4);
3803 }
3804 }
3805 break;
3806 }
3807 }
3808 }
3809 /********************************************************************************/
gl_read_psicode_file_geomi(gchar * FileName,gint num)3810 gulong gl_read_psicode_file_geomi(gchar *FileName,gint num)
3811 {
3812 gchar *t;
3813 gchar *tmp = NULL;
3814 gboolean OK;
3815 gchar *AtomCoord[5];
3816 FILE *fd;
3817 guint taille=BSIZE;
3818 guint idummy;
3819 guint i;
3820 gint j=0;
3821 gint l;
3822 guint numgeom;
3823 gchar *pdest;
3824 long geompos = 0;
3825 gboolean ang = TRUE;
3826 gulong line = 0;
3827 gulong lineg = 0;
3828
3829 for(i=0;i<5;i++)
3830 AtomCoord[i]=g_malloc(taille*sizeof(char));
3831
3832 fd = FOpen(FileName, "rb");
3833
3834 free_data_all();
3835 tmp = get_name_file(FileName);
3836 set_status_label_info(_("File name"),tmp);
3837 g_free(tmp);
3838 set_status_label_info(_("File type"),"Psicode");
3839
3840 t=g_malloc(taille*sizeof(gchar));
3841
3842 numgeom =1;
3843 do
3844 {
3845 set_status_label_info(_("Geometry"),_("Reading"));
3846 OK=FALSE;
3847 while(!feof(fd))
3848 {
3849 line++;
3850 if(!fgets(t,taille,fd))break;
3851 pdest = strstr( t, "Geometry (in Angstrom),");
3852 if(pdest)
3853 {
3854 if(!fgets(t,taille,fd))break;
3855 if(!fgets(t,taille,fd))break;
3856 pdest = strstr( t, "Center X Y Z");
3857 }
3858 if(pdest)
3859 {
3860 line++;
3861 if(!fgets(t,taille,fd))break;
3862 pdest = strstr( t, "--------------");
3863 }
3864 if (pdest)
3865 {
3866 lineg = line;
3867 numgeom++;
3868 OK = TRUE;
3869 break;
3870 }
3871 }
3872 if(!OK && (numgeom == 1) )
3873 {
3874 fclose(fd);
3875 g_free(t);
3876 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3877 set_status_label_info(_("File name"),_("Nothing"));
3878 set_status_label_info(_("File type"),_("Nothing"));
3879 set_status_label_info(_("Geometry"),_("Nothing"));
3880 return 0;
3881 }
3882 if(!OK)break;
3883
3884 j=-1;
3885 while(!feof(fd) )
3886 {
3887 line++;
3888 { char* e = fgets(t,taille,fd);}
3889 if(this_is_a_backspace(t))
3890 {
3891 geompos = ftell(fd);
3892 get_dipole_from_psicode_output_file(fd);
3893 fseek(fd, geompos, SEEK_SET);
3894 gl_get_charges_from_psicode_output_file(fd,j+1);
3895 fseek(fd, geompos, SEEK_SET);
3896 break;
3897 }
3898 j++;
3899 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
3900 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
3901
3902 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
3903
3904 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
3905 l=strlen(AtomCoord[0]);
3906 if (l==2)
3907 {
3908 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
3909 if(isdigit(AtomCoord[0][1]))l=1;
3910 }
3911 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
3912 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
3913
3914 GeomOrb[j].Symb=g_strdup(t);
3915 if(ang)
3916 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(ang_to_bohr(AtomCoord[i+1]));
3917 else
3918 for(i=0;i<3;i++) GeomOrb[j].C[i]=atof(AtomCoord[i+1]);
3919
3920 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
3921 GeomOrb[j].partialCharge = 0.0;
3922 GeomOrb[j].variable = TRUE;
3923 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
3924 }
3925 if(num >0 && (gint)numgeom-1 == num) break;
3926 }while(!feof(fd));
3927
3928 nCenters = j+1;
3929 fclose(fd);
3930 g_free(t);
3931 for(i=0;i<5;i++) g_free(AtomCoord[i]);
3932 if(nCenters == 0 ) g_free(GeomOrb);
3933 else
3934 {
3935 DefineType();
3936 }
3937 buildBondsOrb();
3938 reset_grid_limits();
3939 init_atomic_orbitals();
3940 set_status_label_info(_("Geometry"),_("Ok"));
3941 RebuildGeom = TRUE;
3942 if(this_is_a_new_geometry()) free_objects_all();
3943 glarea_rafresh(GLArea);
3944 return lineg;
3945 }
3946 /********************************************************************************/
goToLine(FILE * file,char * nextString)3947 static gboolean goToLine(FILE* file,char* nextString)
3948 {
3949 static char t[BSIZE];
3950 while(!feof(file))
3951 {
3952 if(!fgets(t,BSIZE,file))break;
3953 if (strstr(t,nextString)) return TRUE;
3954 }
3955 return FALSE;
3956 }
3957 /********************************************************************************/
gl_read_geom_nbo_file(gchar * fileName)3958 static gboolean gl_read_geom_nbo_file(gchar *fileName)
3959 {
3960 gchar *tmp = NULL;
3961 FILE *file;
3962 gint i;
3963 gint k;
3964 gint j=0;
3965 gint uni=1;
3966 gint z = 0;
3967 static gchar t[BSIZE];
3968 gint nAtoms, nShell, nExp;
3969
3970 if ((!fileName) || (strcmp(fileName,"") == 0))
3971 {
3972 Message(_("Sorry\n No file selected"),_("Error"),TRUE);
3973 return FALSE;
3974 }
3975
3976 file = FOpen(fileName, "rb");
3977 if(file == NULL)
3978 {
3979 Message(_("Sorry\nI cannot open this file"),_("Error"),TRUE);
3980 return FALSE;
3981 }
3982 if(!goToLine(file,"--------")) return FALSE;
3983 if(!fgets(t,BSIZE,file)) return FALSE;
3984 sscanf(t,"%d %d %d",&nAtoms,&nShell,&nExp);
3985 if(!goToLine(file,"--------")) return FALSE;
3986 free_data_all();
3987 init_dipole();
3988 GeomOrb=g_malloc(nAtoms*sizeof(TypeGeomOrb));
3989 uni = 1;
3990
3991 tmp = get_name_file(fileName);
3992 set_status_label_info(_("File name"),tmp);
3993 g_free(tmp);
3994 set_status_label_info(_("File type"),"NBO");
3995 set_status_label_info(_("Geometry"),_("Reading"));
3996
3997 gint ix = 0;
3998 j = 0;
3999 for(k=0;k<nAtoms;k++)
4000 {
4001 if(!fgets(t,BSIZE,file)) break;
4002 sscanf(t,"%d",&z);
4003 if(z<=0)
4004 {
4005 ix++;
4006 continue;
4007 }
4008 sscanf(t,"%d %lf %lf %lf",&z, &GeomOrb[j].C[0], &GeomOrb[j].C[1], &GeomOrb[j].C[2]);
4009 GeomOrb[j].Symb=get_symbol_using_z(z);
4010 if(uni==1) for(i=0;i<3;i++) GeomOrb[j].C[i] *= ANG_TO_BOHR;
4011 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
4012 GeomOrb[j].partialCharge = 0;
4013 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
4014 GeomOrb[j].variable = TRUE;
4015 j++;
4016
4017 }
4018 nAtoms -= ix;
4019 nCenters = 0;
4020 if(k==nAtoms+ix) nCenters = nAtoms;
4021 fclose(file);
4022 if(nCenters == 0 )
4023 {
4024 g_free(GeomOrb);
4025 sprintf(t,_("Sorry, I can not read this format from '%s' file\n"),fileName);
4026 Message(t,_("Error"),TRUE);
4027 set_status_label_info(_("File name"),_("Nothing"));
4028 set_status_label_info(_("File type"),_("Nothing"));
4029 set_status_label_info(_("Mol. Orb."),_("Nothing"));
4030 RebuildGeom = TRUE;
4031 return FALSE;
4032 }
4033 else
4034 {
4035 /* DefineType();*/
4036 gint i;
4037 Ntype =nCenters;
4038 for(i=0;i<nCenters;i++)
4039 {
4040 GeomOrb[i].NumType = i;
4041 /*
4042 Type[i].Symb=g_strdup(GeomOrb[i].Symb);
4043 Type[i].N=GetNelectrons(GeomOrb[i].Symb);
4044 */
4045 }
4046 buildBondsOrb();
4047 RebuildGeom = TRUE;
4048 reset_grid_limits();
4049 init_atomic_orbitals();
4050 return TRUE;
4051 }
4052 return TRUE;
4053 }
4054 /********************************************************************************/
gl_get_charges_from_aimall_file(FILE * fd,gint N)4055 static void gl_get_charges_from_aimall_file(FILE* fd,gint N)
4056 {
4057 guint taille=BSIZE;
4058 gchar t[BSIZE];
4059 gchar dump[BSIZE];
4060 gchar d[BSIZE];
4061 gchar* pdest;
4062 gint i;
4063
4064
4065 while(!feof(fd) )
4066 {
4067 pdest = NULL;
4068 if(!fgets(t,taille,fd)) break;
4069 pdest = strstr( t, "Atom A q(A)");
4070 if(pdest)
4071 {
4072 if(!fgets(t,taille,fd)) break;
4073 for(i=0;i<N;i++)
4074 {
4075 if(!fgets(t,taille,fd)) break;
4076 if(sscanf(t,"%s %s",dump, d)==2)
4077 {
4078 GeomOrb[i].partialCharge = atof(d);
4079 }
4080 else break;
4081 }
4082 break;
4083 }
4084 }
4085 }
4086 /********************************************************************************/
gl_read_aimall_file(gchar * fileName)4087 static gboolean gl_read_aimall_file(gchar *fileName)
4088 {
4089 gchar *t;
4090 /* gboolean OK;*/
4091 gchar *AtomCoord[5];
4092 FILE *fd;
4093 guint taille=BSIZE;
4094 guint i;
4095 gint j=0;
4096 gint l;
4097 gchar dum[100];
4098 gint uni=0;
4099
4100 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
4101
4102 t=g_malloc(taille);
4103 fd = FOpen(fileName, "rb");
4104 if(fd ==NULL)
4105 {
4106 g_free(t);
4107 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
4108 Message(t,_("Error"),TRUE);
4109 g_free(t);
4110 return FALSE;
4111 }
4112 /* OK=FALSE;*/
4113 while(!feof(fd))
4114 {
4115 { char* e = fgets(t,taille,fd);}
4116 if ( strstr(t,"Atom Charge X Y Z"))
4117 {
4118 { char* e = fgets(t,taille,fd);}
4119 /* OK = TRUE;*/
4120 break;
4121 }
4122 }
4123
4124 j=-1;
4125 while(!feof(fd) )
4126 {
4127 { char* e = fgets(t,taille,fd);}
4128 if(this_is_a_backspace(t))
4129 {
4130 gl_get_charges_from_aimall_file(fd,j+1);
4131 break;
4132 }
4133 j++;
4134
4135 if(GeomOrb==NULL) GeomOrb=g_malloc(sizeof(TypeGeomOrb));
4136 else GeomOrb=g_realloc(GeomOrb,(j+1)*sizeof(TypeGeomOrb));
4137
4138 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
4139 {
4140 gint k;
4141 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
4142 delete_all_spaces(AtomCoord[0]);
4143 }
4144 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
4145 l=strlen(AtomCoord[0]);
4146 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
4147 GeomOrb[j].Symb=get_symbol_using_z(atoi(dum));
4148 for(i=0;i<3;i++)
4149 {
4150 GeomOrb[j].C[i]=atof((AtomCoord[i+1]));
4151 if(uni==1)GeomOrb[j].C[i] *= ANG_TO_BOHR;
4152 }
4153
4154 GeomOrb[j].Prop = prop_atom_get(GeomOrb[j].Symb);
4155 GeomOrb[j].partialCharge = 0.0;
4156 GeomOrb[j].variable = TRUE;
4157 GeomOrb[j].nuclearCharge = get_atomic_number_from_symbol(GeomOrb[j].Symb);
4158 }
4159
4160
4161 nCenters = j+1;
4162
4163 if ( nCenters >0)
4164 {
4165 gl_get_charges_from_aimall_file(fd,nCenters);
4166 /* PrintGeomOrb();*/
4167 }
4168
4169 fclose(fd);
4170 g_free(t);
4171 for(i=0;i<5;i++) g_free(AtomCoord[i]);
4172 if(nCenters == 0 ) g_free(GeomOrb);
4173 else
4174 {
4175 DefineType();
4176 /* PrintGeomOrb();*/
4177 }
4178 RebuildGeom = TRUE;
4179 buildBondsOrb();
4180 reset_grid_limits();
4181 init_atomic_orbitals();
4182 set_status_label_info(_("Geometry"),_("Ok"));
4183 return TRUE;
4184 }
4185 /********************************************************************************/
gl_read_aimall_file_sel(GabeditFileChooser * SelecFile,gint response_id)4186 void gl_read_aimall_file_sel(GabeditFileChooser *SelecFile, gint response_id)
4187 {
4188 gchar *FileName;
4189
4190 if(response_id != GTK_RESPONSE_OK) return;
4191 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4192 gtk_widget_hide(GTK_WIDGET(SelecFile));
4193 while( gtk_events_pending() ) gtk_main_iteration();
4194
4195 add_objects_for_new_grid();
4196 gl_read_aimall_file(FileName);
4197 }
4198 /********************************************************/
gl_read_first_dalton_file(GabeditFileChooser * SelecFile,gint response_id)4199 void gl_read_first_dalton_file(GabeditFileChooser *SelecFile, gint response_id)
4200 {
4201 gchar *FileName;
4202 if(response_id != GTK_RESPONSE_OK) return;
4203 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4204 gtk_widget_hide(GTK_WIDGET(SelecFile));
4205 while( gtk_events_pending() ) gtk_main_iteration();
4206
4207 add_objects_for_new_grid();
4208 gl_read_dalton_file_geomi(FileName,1);
4209 RebuildGeom = TRUE;
4210 if(this_is_a_new_geometry()) free_objects_all();
4211 glarea_rafresh(GLArea);
4212 }
4213 /********************************************************/
gl_read_last_dalton_file(GabeditFileChooser * SelecFile,gint response_id)4214 void gl_read_last_dalton_file(GabeditFileChooser *SelecFile, gint response_id)
4215 {
4216 gchar *FileName;
4217 if(response_id != GTK_RESPONSE_OK) return;
4218 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4219 gtk_widget_hide(GTK_WIDGET(SelecFile));
4220 while( gtk_events_pending() )
4221 gtk_main_iteration();
4222 add_objects_for_new_grid();
4223 gl_read_dalton_file_geomi(FileName,-1);
4224 RebuildGeom = TRUE;
4225 if(this_is_a_new_geometry()) free_objects_all();
4226 glarea_rafresh(GLArea);
4227 }
4228 /********************************************************/
gl_read_first_gamess_file(GabeditFileChooser * SelecFile,gint response_id)4229 void gl_read_first_gamess_file(GabeditFileChooser *SelecFile, gint response_id)
4230 {
4231 gchar *FileName;
4232 if(response_id != GTK_RESPONSE_OK) return;
4233 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4234 gtk_widget_hide(GTK_WIDGET(SelecFile));
4235 while( gtk_events_pending() ) gtk_main_iteration();
4236
4237 add_objects_for_new_grid();
4238 gl_read_gamess_file_geomi(FileName,1);
4239 RebuildGeom = TRUE;
4240 if(this_is_a_new_geometry()) free_objects_all();
4241 glarea_rafresh(GLArea);
4242 }
4243 /********************************************************/
gl_read_last_gamess_file(GabeditFileChooser * SelecFile,gint response_id)4244 void gl_read_last_gamess_file(GabeditFileChooser *SelecFile, gint response_id)
4245 {
4246 gchar *FileName;
4247 if(response_id != GTK_RESPONSE_OK) return;
4248 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4249 gtk_widget_hide(GTK_WIDGET(SelecFile));
4250 while( gtk_events_pending() )
4251 gtk_main_iteration();
4252 add_objects_for_new_grid();
4253 gl_read_gamess_file_geomi(FileName,-1);
4254 RebuildGeom = TRUE;
4255 if(this_is_a_new_geometry()) free_objects_all();
4256 glarea_rafresh(GLArea);
4257 }
4258 /********************************************************/
gl_read_first_gauss_file(GabeditFileChooser * SelecFile,gint response_id)4259 void gl_read_first_gauss_file(GabeditFileChooser *SelecFile, gint response_id)
4260 {
4261 gchar *FileName;
4262 if(response_id != GTK_RESPONSE_OK) return;
4263 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4264 gtk_widget_hide(GTK_WIDGET(SelecFile));
4265 while( gtk_events_pending() ) gtk_main_iteration();
4266
4267 add_objects_for_new_grid();
4268 gl_read_gaussn_file_geomi(FileName,1);
4269 RebuildGeom = TRUE;
4270 if(this_is_a_new_geometry()) free_objects_all();
4271 glarea_rafresh(GLArea);
4272 }
4273 /********************************************************/
gl_read_last_gauss_file(GabeditFileChooser * SelecFile,gint response_id)4274 void gl_read_last_gauss_file(GabeditFileChooser *SelecFile, gint response_id)
4275 {
4276 gchar *FileName;
4277 if(response_id != GTK_RESPONSE_OK) return;
4278 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4279 gtk_widget_hide(GTK_WIDGET(SelecFile));
4280 while( gtk_events_pending() )
4281 gtk_main_iteration();
4282 add_objects_for_new_grid();
4283 gl_read_gaussn_file_geomi(FileName,-1);
4284 RebuildGeom = TRUE;
4285 if(this_is_a_new_geometry()) free_objects_all();
4286 glarea_rafresh(GLArea);
4287 }
4288 /********************************************************/
gl_read_fchk_gauss_file(GabeditFileChooser * SelecFile,gint response_id)4289 gboolean gl_read_fchk_gauss_file(GabeditFileChooser *SelecFile, gint response_id)
4290 {
4291 gchar *FileName;
4292 if(response_id != GTK_RESPONSE_OK) return FALSE;
4293 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4294 gtk_widget_hide(GTK_WIDGET(SelecFile));
4295 while( gtk_events_pending() ) gtk_main_iteration();
4296 add_objects_for_new_grid();
4297 if(gl_read_fchk_gaussn_file_geom(FileName))
4298 {
4299 RebuildGeom = TRUE;
4300 if(this_is_a_new_geometry()) free_objects_all();
4301 glarea_rafresh(GLArea);
4302 return TRUE;
4303 }
4304 glarea_rafresh(GLArea);
4305 return FALSE;
4306 }
4307 /********************************************************/
gl_read_first_molcas_file(GabeditFileChooser * SelecFile,gint response_id)4308 void gl_read_first_molcas_file(GabeditFileChooser *SelecFile, gint response_id)
4309 {
4310 gchar *FileName;
4311 if(response_id != GTK_RESPONSE_OK) return;
4312 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4313 gtk_widget_hide(GTK_WIDGET(SelecFile));
4314 while( gtk_events_pending() ) gtk_main_iteration();
4315 add_objects_for_new_grid();
4316 gl_read_molcas_file_geomi(FileName,1);
4317 RebuildGeom = TRUE;
4318 if(this_is_a_new_geometry()) free_objects_all();
4319 glarea_rafresh(GLArea);
4320 }
4321 /********************************************************/
gl_read_last_molcas_file(GabeditFileChooser * SelecFile,gint response_id)4322 void gl_read_last_molcas_file(GabeditFileChooser *SelecFile, gint response_id)
4323 {
4324 gchar *FileName;
4325 if(response_id != GTK_RESPONSE_OK) return;
4326 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4327 gtk_widget_hide(GTK_WIDGET(SelecFile));
4328 while( gtk_events_pending() ) gtk_main_iteration();
4329 add_objects_for_new_grid();
4330 gl_read_molcas_file_geomi(FileName,-1);
4331 RebuildGeom = TRUE;
4332 if(this_is_a_new_geometry()) free_objects_all();
4333 glarea_rafresh(GLArea);
4334 }
4335 /********************************************************/
gl_read_first_molpro_file(GabeditFileChooser * SelecFile,gint response_id)4336 void gl_read_first_molpro_file(GabeditFileChooser *SelecFile, gint response_id)
4337 {
4338 gchar *FileName;
4339 if(response_id != GTK_RESPONSE_OK) return;
4340 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4341 gtk_widget_hide(GTK_WIDGET(SelecFile));
4342 while( gtk_events_pending() )
4343 gtk_main_iteration();
4344 add_objects_for_new_grid();
4345 gl_read_molpro_file_geomi(FileName,1);
4346 RebuildGeom = TRUE;
4347 if(this_is_a_new_geometry()) free_objects_all();
4348 glarea_rafresh(GLArea);
4349 }
4350 /********************************************************/
gl_read_last_molpro_file(GabeditFileChooser * SelecFile,gint response_id)4351 void gl_read_last_molpro_file(GabeditFileChooser *SelecFile, gint response_id)
4352 {
4353 gchar *FileName;
4354 if(response_id != GTK_RESPONSE_OK) return;
4355 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4356 gtk_widget_hide(GTK_WIDGET(SelecFile));
4357 while( gtk_events_pending() )
4358 gtk_main_iteration();
4359 add_objects_for_new_grid();
4360 gl_read_molpro_file_geomi(FileName,-1);
4361 RebuildGeom = TRUE;
4362 if(this_is_a_new_geometry()) free_objects_all();
4363 glarea_rafresh(GLArea);
4364 }
4365 /********************************************************/
gl_read_first_mpqc_file(GabeditFileChooser * SelecFile,gint response_id)4366 void gl_read_first_mpqc_file(GabeditFileChooser *SelecFile, gint response_id)
4367 {
4368 gchar *fileName;
4369 if(response_id != GTK_RESPONSE_OK) return;
4370 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4371 gtk_widget_hide(GTK_WIDGET(SelecFile));
4372 while( gtk_events_pending() )
4373 gtk_main_iteration();
4374 add_objects_for_new_grid();
4375 gl_read_mpqc_file_geomi(fileName,1);
4376 RebuildGeom = TRUE;
4377 if(this_is_a_new_geometry()) free_objects_all();
4378 glarea_rafresh(GLArea);
4379 }
4380 /********************************************************/
gl_read_last_mpqc_file(GabeditFileChooser * SelecFile,gint response_id)4381 void gl_read_last_mpqc_file(GabeditFileChooser *SelecFile, gint response_id)
4382 {
4383 gchar *fileName;
4384 if(response_id != GTK_RESPONSE_OK) return;
4385 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4386 gtk_widget_hide(GTK_WIDGET(SelecFile));
4387 while( gtk_events_pending() )
4388 gtk_main_iteration();
4389 add_objects_for_new_grid();
4390 gl_read_mpqc_file_geomi(fileName,-1);
4391 RebuildGeom = TRUE;
4392 if(this_is_a_new_geometry()) free_objects_all();
4393 glarea_rafresh(GLArea);
4394 }
4395 /********************************************************/
gl_read_first_mopac_output_file(GabeditFileChooser * SelecFile,gint response_id)4396 void gl_read_first_mopac_output_file(GabeditFileChooser *SelecFile, gint response_id)
4397 {
4398 gchar *FileName;
4399 if(response_id != GTK_RESPONSE_OK) return;
4400 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4401 gtk_widget_hide(GTK_WIDGET(SelecFile));
4402 while( gtk_events_pending() ) gtk_main_iteration();
4403
4404 add_objects_for_new_grid();
4405 gl_read_mopac_output_file_geomi(FileName,1);
4406 RebuildGeom = TRUE;
4407 if(this_is_a_new_geometry()) free_objects_all();
4408 glarea_rafresh(GLArea);
4409 }
4410 /********************************************************/
gl_read_last_mopac_output_file(GabeditFileChooser * SelecFile,gint response_id)4411 void gl_read_last_mopac_output_file(GabeditFileChooser *SelecFile, gint response_id)
4412 {
4413 gchar *FileName;
4414 if(response_id != GTK_RESPONSE_OK) return;
4415 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4416 gtk_widget_hide(GTK_WIDGET(SelecFile));
4417 while( gtk_events_pending() )
4418 gtk_main_iteration();
4419 add_objects_for_new_grid();
4420 gl_read_mopac_output_file_geomi(FileName,-1);
4421 RebuildGeom = TRUE;
4422 if(this_is_a_new_geometry()) free_objects_all();
4423 glarea_rafresh(GLArea);
4424 }
4425 /********************************************************/
gl_read_first_mopac_aux_file(GabeditFileChooser * SelecFile,gint response_id)4426 void gl_read_first_mopac_aux_file(GabeditFileChooser *SelecFile, gint response_id)
4427 {
4428 gchar *FileName;
4429 if(response_id != GTK_RESPONSE_OK) return;
4430 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4431 gtk_widget_hide(GTK_WIDGET(SelecFile));
4432 while( gtk_events_pending() ) gtk_main_iteration();
4433
4434 add_objects_for_new_grid();
4435 gl_read_mopac_aux_file_geomi(FileName,1);
4436 RebuildGeom = TRUE;
4437 if(this_is_a_new_geometry()) free_objects_all();
4438 glarea_rafresh(GLArea);
4439 }
4440 /********************************************************/
gl_read_last_mopac_aux_file(GabeditFileChooser * SelecFile,gint response_id)4441 void gl_read_last_mopac_aux_file(GabeditFileChooser *SelecFile, gint response_id)
4442 {
4443 gchar *FileName;
4444 if(response_id != GTK_RESPONSE_OK) return;
4445 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4446 gtk_widget_hide(GTK_WIDGET(SelecFile));
4447 while( gtk_events_pending() )
4448 gtk_main_iteration();
4449 add_objects_for_new_grid();
4450 gl_read_mopac_aux_file_geomi(FileName,-1);
4451 RebuildGeom = TRUE;
4452 if(this_is_a_new_geometry()) free_objects_all();
4453 glarea_rafresh(GLArea);
4454 }
4455 /********************************************************/
gl_read_wfx_file(GabeditFileChooser * SelecFile,gint response_id)4456 void gl_read_wfx_file(GabeditFileChooser *SelecFile, gint response_id)
4457 {
4458 gchar *FileName;
4459 if(response_id != GTK_RESPONSE_OK) return;
4460 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4461 gtk_widget_hide(GTK_WIDGET(SelecFile));
4462 while( gtk_events_pending() ) gtk_main_iteration();
4463
4464 add_objects_for_new_grid();
4465 gl_read_wfx_file_geom(FileName);
4466 RebuildGeom = TRUE;
4467 if(this_is_a_new_geometry()) free_objects_all();
4468 glarea_rafresh(GLArea);
4469 }
4470 /********************************************************/
gl_read_first_orca_file(GabeditFileChooser * SelecFile,gint response_id)4471 void gl_read_first_orca_file(GabeditFileChooser *SelecFile, gint response_id)
4472 {
4473 gchar *FileName;
4474 if(response_id != GTK_RESPONSE_OK) return;
4475 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4476 gtk_widget_hide(GTK_WIDGET(SelecFile));
4477 while( gtk_events_pending() ) gtk_main_iteration();
4478
4479 add_objects_for_new_grid();
4480 gl_read_orca_file_geomi(FileName,1);
4481 RebuildGeom = TRUE;
4482 if(this_is_a_new_geometry()) free_objects_all();
4483 glarea_rafresh(GLArea);
4484 }
4485 /********************************************************/
gl_read_last_orca_file(GabeditFileChooser * SelecFile,gint response_id)4486 void gl_read_last_orca_file(GabeditFileChooser *SelecFile, gint response_id)
4487 {
4488 gchar *FileName;
4489 if(response_id != GTK_RESPONSE_OK) return;
4490 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4491 gtk_widget_hide(GTK_WIDGET(SelecFile));
4492 while( gtk_events_pending() )
4493 gtk_main_iteration();
4494 add_objects_for_new_grid();
4495 gl_read_orca_file_geomi(FileName,-1);
4496 RebuildGeom = TRUE;
4497 if(this_is_a_new_geometry()) free_objects_all();
4498 glarea_rafresh(GLArea);
4499 }
4500 /********************************************************/
gl_read_hessian_orca_file(GabeditFileChooser * SelecFile,gint response_id)4501 void gl_read_hessian_orca_file(GabeditFileChooser *SelecFile, gint response_id)
4502 {
4503 gchar *FileName;
4504 if(response_id != GTK_RESPONSE_OK) return;
4505 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4506 gtk_widget_hide(GTK_WIDGET(SelecFile));
4507 while( gtk_events_pending() )
4508 gtk_main_iteration();
4509 add_objects_for_new_grid();
4510 gl_read_orca_file_hessian(FileName);
4511 RebuildGeom = TRUE;
4512 if(this_is_a_new_geometry()) free_objects_all();
4513 glarea_rafresh(GLArea);
4514 }
4515 /********************************************************/
gl_read_first_qchem_file(GabeditFileChooser * SelecFile,gint response_id)4516 void gl_read_first_qchem_file(GabeditFileChooser *SelecFile, gint response_id)
4517 {
4518 gchar *FileName;
4519 if(response_id != GTK_RESPONSE_OK) return;
4520 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4521 gtk_widget_hide(GTK_WIDGET(SelecFile));
4522 while( gtk_events_pending() ) gtk_main_iteration();
4523
4524 add_objects_for_new_grid();
4525 gl_read_qchem_file_geomi(FileName,1);
4526 RebuildGeom = TRUE;
4527 if(this_is_a_new_geometry()) free_objects_all();
4528 glarea_rafresh(GLArea);
4529 }
4530 /********************************************************/
gl_read_last_qchem_file(GabeditFileChooser * SelecFile,gint response_id)4531 void gl_read_last_qchem_file(GabeditFileChooser *SelecFile, gint response_id)
4532 {
4533 gchar *FileName;
4534 if(response_id != GTK_RESPONSE_OK) return;
4535 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4536 gtk_widget_hide(GTK_WIDGET(SelecFile));
4537 while( gtk_events_pending() )
4538 gtk_main_iteration();
4539 add_objects_for_new_grid();
4540 gl_read_qchem_file_geomi(FileName,-1);
4541 RebuildGeom = TRUE;
4542 if(this_is_a_new_geometry()) free_objects_all();
4543 glarea_rafresh(GLArea);
4544 }
4545 /********************************************************/
gl_read_first_nwchem_file(GabeditFileChooser * SelecFile,gint response_id)4546 void gl_read_first_nwchem_file(GabeditFileChooser *SelecFile, gint response_id)
4547 {
4548 gchar *FileName;
4549 if(response_id != GTK_RESPONSE_OK) return;
4550 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4551 gtk_widget_hide(GTK_WIDGET(SelecFile));
4552 while( gtk_events_pending() ) gtk_main_iteration();
4553
4554 add_objects_for_new_grid();
4555 gl_read_nwchem_file_geomi(FileName,1);
4556 RebuildGeom = TRUE;
4557 if(this_is_a_new_geometry()) free_objects_all();
4558 glarea_rafresh(GLArea);
4559 }
4560 /********************************************************/
gl_read_nbo_file(GabeditFileChooser * SelecFile,gint response_id)4561 void gl_read_nbo_file(GabeditFileChooser *SelecFile, gint response_id)
4562 {
4563 gchar *FileName;
4564 if(response_id != GTK_RESPONSE_OK) return;
4565 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4566 gtk_widget_hide(GTK_WIDGET(SelecFile));
4567 while( gtk_events_pending() ) gtk_main_iteration();
4568
4569 add_objects_for_new_grid();
4570 gl_read_geom_nbo_file(FileName);
4571 RebuildGeom = TRUE;
4572 if(this_is_a_new_geometry()) free_objects_all();
4573 glarea_rafresh(GLArea);
4574 }
4575 /********************************************************/
gl_read_last_nwchem_file(GabeditFileChooser * SelecFile,gint response_id)4576 void gl_read_last_nwchem_file(GabeditFileChooser *SelecFile, gint response_id)
4577 {
4578 gchar *FileName;
4579 if(response_id != GTK_RESPONSE_OK) return;
4580 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4581 gtk_widget_hide(GTK_WIDGET(SelecFile));
4582 while( gtk_events_pending() )
4583 gtk_main_iteration();
4584 add_objects_for_new_grid();
4585 gl_read_nwchem_file_geomi(FileName,-1);
4586 RebuildGeom = TRUE;
4587 if(this_is_a_new_geometry()) free_objects_all();
4588 glarea_rafresh(GLArea);
4589 }
4590 /********************************************************/
gl_read_last_psicode_file(GabeditFileChooser * SelecFile,gint response_id)4591 void gl_read_last_psicode_file(GabeditFileChooser *SelecFile, gint response_id)
4592 {
4593 gchar *FileName;
4594 if(response_id != GTK_RESPONSE_OK) return;
4595 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4596 gtk_widget_hide(GTK_WIDGET(SelecFile));
4597 while( gtk_events_pending() )
4598 gtk_main_iteration();
4599 add_objects_for_new_grid();
4600 gl_read_psicode_file_geomi(FileName,-1);
4601 RebuildGeom = TRUE;
4602 if(this_is_a_new_geometry()) free_objects_all();
4603 glarea_rafresh(GLArea);
4604 }
4605 /********************************************************/
gl_read_first_psicode_file(GabeditFileChooser * SelecFile,gint response_id)4606 void gl_read_first_psicode_file(GabeditFileChooser *SelecFile, gint response_id)
4607 {
4608 gchar *FileName;
4609 if(response_id != GTK_RESPONSE_OK) return;
4610 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4611 gtk_widget_hide(GTK_WIDGET(SelecFile));
4612 while( gtk_events_pending() ) gtk_main_iteration();
4613
4614 add_objects_for_new_grid();
4615 gl_read_psicode_file_geomi(FileName,1);
4616 RebuildGeom = TRUE;
4617 if(this_is_a_new_geometry()) free_objects_all();
4618 glarea_rafresh(GLArea);
4619 }
4620 /*******************************************************/
gl_read_molden_file(GabeditFileChooser * SelecFile,gint response_id)4621 void gl_read_molden_file(GabeditFileChooser *SelecFile, gint response_id)
4622 {
4623 gchar *FileName;
4624 if(response_id != GTK_RESPONSE_OK) return;
4625 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4626 gtk_widget_hide(GTK_WIDGET(SelecFile));
4627 while( gtk_events_pending() )
4628 gtk_main_iteration();
4629 add_objects_for_new_grid();
4630 gl_read_molden_file_geom(FileName);
4631 }
4632 /*******************************************************/
gl_read_gabedit_file(GabeditFileChooser * SelecFile,gint response_id)4633 void gl_read_gabedit_file(GabeditFileChooser *SelecFile, gint response_id)
4634 {
4635 gchar *FileName;
4636 if(response_id != GTK_RESPONSE_OK) return;
4637 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4638 gtk_widget_hide(GTK_WIDGET(SelecFile));
4639 while( gtk_events_pending() )
4640 gtk_main_iteration();
4641 add_objects_for_new_grid();
4642 gl_read_gabedit_file_geom(FileName);
4643 }
4644 /*******************************************************/
gl_read_geom_any_file(gchar * fileName)4645 gboolean gl_read_geom_any_file(gchar* fileName)
4646 {
4647 GabEditTypeFile fileType = get_type_file(fileName);
4648 gboolean Ok = FALSE;
4649 if(fileType == GABEDIT_TYPEFILE_XYZ) Ok = gl_read_xyz_file(fileName);
4650 else if(fileType == GABEDIT_TYPEFILE_PDB) Ok = gl_read_pdb_file(fileName);
4651 else if(fileType == GABEDIT_TYPEFILE_HIN) Ok = gl_read_hin_file(fileName);
4652 else if(fileType == GABEDIT_TYPEFILE_AIMALL) Ok = gl_read_aimall_file(fileName);
4653 else if(fileType == GABEDIT_TYPEFILE_DALTON) Ok = gl_read_dalton_file_geomi(fileName,-1);
4654 else if(fileType == GABEDIT_TYPEFILE_GAMESS) Ok = gl_read_gamess_file_geomi(fileName,-1);
4655 else if(fileType == GABEDIT_TYPEFILE_FIREFLY) Ok = gl_read_gamess_file_geomi(fileName,-1);
4656 else if(fileType == GABEDIT_TYPEFILE_GAUSSIAN) Ok = gl_read_gaussn_file_geomi(fileName,-1);
4657 else if(fileType == GABEDIT_TYPEFILE_MOLCAS) Ok = gl_read_molcas_file_geomi(fileName,-1);
4658 else if(fileType == GABEDIT_TYPEFILE_MOLPRO) Ok = gl_read_molpro_file_geomi(fileName,-1);
4659 else if(fileType == GABEDIT_TYPEFILE_MOPAC) Ok = gl_read_mopac_output_file_geomi(fileName,-1);
4660 else if(fileType == GABEDIT_TYPEFILE_MOPAC_AUX) Ok = gl_read_mopac_aux_file_geomi(fileName,-1);
4661 else if(fileType == GABEDIT_TYPEFILE_MPQC) Ok = gl_read_mpqc_file_geomi(fileName,-1);
4662 else if(fileType == GABEDIT_TYPEFILE_ORCA) Ok = gl_read_orca_file_geomi(fileName,-1);
4663 else if(fileType == GABEDIT_TYPEFILE_QCHEM) Ok = gl_read_qchem_file_geomi(fileName,-1);
4664 else if(fileType == GABEDIT_TYPEFILE_NWCHEM) Ok = (0!=gl_read_nwchem_file_geomi(fileName,-1));
4665 else if(fileType == GABEDIT_TYPEFILE_GABEDIT) Ok = gl_read_gabedit_file_geom(fileName);
4666 else if(fileType == GABEDIT_TYPEFILE_MOLDEN) Ok = gl_read_molden_file_geom(fileName);
4667 else if(fileType == GABEDIT_TYPEFILE_WFX) Ok = gl_read_wfx_file_geom(fileName);
4668 else if(fileType == GABEDIT_TYPEFILE_GAUSSIAN_FCHK) Ok = gl_read_fchk_gaussn_file_geom(fileName);
4669 else if(
4670 fileType == GABEDIT_TYPEFILE_ORCAINPUT||
4671 fileType == GABEDIT_TYPEFILE_FIREFLYINPUT||
4672 fileType == GABEDIT_TYPEFILE_GAMESSINPUT||
4673 fileType == GABEDIT_TYPEFILE_QCHEMINPUT||
4674 fileType == GABEDIT_TYPEFILE_NWCHEMINPUT||
4675 fileType == GABEDIT_TYPEFILE_MOPACINPUT||
4676 fileType == GABEDIT_TYPEFILE_MPQCINPUT||
4677 fileType == GABEDIT_TYPEFILE_GAUSSIANINPUT||
4678 fileType == GABEDIT_TYPEFILE_MOLCASINPUT||
4679 fileType == GABEDIT_TYPEFILE_MOLPROINPUT
4680 )
4681 {
4682 Message(
4683 _(
4684 "Sorry, I cannot read this file here\n"
4685 "You can read it from the 'Draw Geometry' window, save it in hin and read it from this window 'Display window'\n"
4686 )
4687 ,_("Error"),TRUE);
4688 return FALSE;
4689 }
4690 else if(fileType == GABEDIT_TYPEFILE_UNKNOWN)
4691 {
4692 Message(
4693 _(
4694 "Sorry, I cannot find the type of your file\n"
4695 " Try to read it using openbabel\n"
4696 )
4697 ,_("Error"),TRUE);
4698 return FALSE;
4699 }
4700 RebuildGeom = TRUE;
4701 if(this_is_a_new_geometry()) free_objects_all();
4702 glarea_rafresh(GLArea);
4703 return Ok;
4704 }
4705 /*************************************************************************/
gl_read_geom_any_file_sel(GabeditFileChooser * selecFile,gint response_id)4706 void gl_read_geom_any_file_sel(GabeditFileChooser *selecFile, gint response_id)
4707 {
4708 gchar *fileName;
4709
4710 if(response_id != GTK_RESPONSE_OK) return;
4711 fileName = gabedit_file_chooser_get_current_file(selecFile);
4712 gtk_widget_hide(GTK_WIDGET(selecFile));
4713 while( gtk_events_pending() ) gtk_main_iteration();
4714
4715 add_objects_for_new_grid();
4716 gl_read_geom_any_file(fileName);
4717 }
4718