1 /* Orbitals.c */
2 /**********************************************************************************************************
3 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
4
5 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
8 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9
10 The above copyright notice and this permission notice shall be included in all copies or substantial portions
11 of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
16 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17 DEALINGS IN THE SOFTWARE.
18 ************************************************************************************************************/
19
20 #include "../../Config.h"
21 #include "GlobalOrb.h"
22 #include "../Utils/AtomsProp.h"
23 #include "../Utils/UtilsInterface.h"
24 #include "../Utils/Utils.h"
25 #include "../Utils/GabeditTextEdit.h"
26 #include "../Utils/Constants.h"
27 #include "../Spectrum/DOS.h"
28 #include "GeomDraw.h"
29 #include "GLArea.h"
30 #include "UtilsOrb.h"
31 #include "Basis.h"
32 #include "GeomOrbXYZ.h"
33 #include "AtomicOrbitals.h"
34 #include "StatusOrb.h"
35 #include "Orbitals.h"
36 /*
37 #include "OrbitalsDalton.h"
38 */
39 #include "OrbitalsGamess.h"
40 #include "OrbitalsMolpro.h"
41 #include "OrbitalsQChem.h"
42 #include "OrbitalsNWChem.h"
43 #include "OrbitalsMopac.h"
44 #include "OrbitalsOrca.h"
45 #include "OrbitalsNBO.h"
46 #include "wfx.h"
47
48 #define WIDTHSCR 0.56
49
50 static gint TypeSelOrbtmp = 1;
51 static gint NumSelOrbtmp = -1;
52 void create_iso_orbitals();
53 static gboolean sphericalBasis = FALSE;
54 static GtkWidget* winList = NULL;
55 /********************************************************************************/
56 static void resetViewOrbCoef(GtkWidget* textWidget);
57 /************************************************************************************************************/
getNumSelectOrb(gint numRow)58 static gint getNumSelectOrb(gint numRow)
59 {
60 gint n = -1;
61 gint i;
62 if(numRow<0) return -1;
63 for(i=0;i<NOrb;i++)
64 {
65 if(TypeSelOrb == 1 && strcmp(SymAlphaOrbitals[i],"DELETED")) n++;
66 else if( TypeSelOrb != 1 && strcmp(SymBetaOrbitals[i],"DELETED")) n++;
67 if(n==numRow) return i;
68 }
69 return -1;
70 }
71 /************************************************************************************************************/
getNumSelectRow(gint numOrb)72 static gint getNumSelectRow(gint numOrb)
73 {
74 gint numRow = -1;
75 gint i;
76 for(i=0;i<NOrb;i++)
77 {
78 if(TypeSelOrb == 1 && strcmp(SymAlphaOrbitals[i],"DELETED")) numRow++;
79 else if(TypeSelOrb != 1 && strcmp(SymBetaOrbitals[i],"DELETED")) numRow++;
80 if(i==numOrb) return numRow;
81 }
82 return -1;
83 }
84 /************************************************************************************************************/
destroyWinsList(GtkWidget * win)85 static void destroyWinsList(GtkWidget *win)
86 {
87 if(GTK_IS_WIDGET(win)) delete_child(win);
88 if(GTK_IS_WIDGET(win)) gtk_widget_destroy(win);
89 winList = NULL;
90 }
91 /************************************************************************************************************/
destroy_win_list()92 void destroy_win_list()
93 {
94 if(!winList) return;
95 destroyWinsList(winList);
96 }
97 /********************************************************************************/
selectRow(GtkWidget * list,gint row)98 static void selectRow(GtkWidget* list, gint row)
99 {
100 GtkWidget* textWidget = NULL;
101 GtkTreePath *path;
102 gchar* tmp = NULL;
103
104 if(row<0) return;
105 tmp = g_strdup_printf("%d",row);
106 path = gtk_tree_path_new_from_string (tmp);
107 g_free(tmp);
108 if(!list) return;
109 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), path);
110 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list), path, NULL, FALSE,0.5,0.5);
111 gtk_tree_path_free(path);
112 textWidget = g_object_get_data(G_OBJECT (list), "CoefOrbWidget");
113 if(textWidget) resetViewOrbCoef(textWidget);
114 }
115 /********************************************************************************/
free_orbitals()116 void free_orbitals()
117 {
118 gint i;
119 if(EnerAlphaOrbitals == EnerBetaOrbitals)
120 {
121 if(EnerAlphaOrbitals)
122 g_free(EnerAlphaOrbitals);
123 EnerAlphaOrbitals = NULL;
124 EnerBetaOrbitals = NULL;
125 }
126 else
127 {
128 if(EnerAlphaOrbitals)
129 g_free(EnerAlphaOrbitals);
130 EnerAlphaOrbitals = NULL;
131 if(EnerBetaOrbitals)
132 g_free(EnerBetaOrbitals);
133 EnerBetaOrbitals = NULL;
134 }
135 if(OccAlphaOrbitals == OccBetaOrbitals)
136 {
137 if(OccAlphaOrbitals)
138 g_free(OccAlphaOrbitals);
139 OccAlphaOrbitals = NULL;
140 OccBetaOrbitals = NULL;
141 }
142 else
143 {
144 if(OccAlphaOrbitals)
145 g_free(OccAlphaOrbitals);
146 OccAlphaOrbitals = NULL;
147 if(OccBetaOrbitals)
148 g_free(OccBetaOrbitals);
149 OccBetaOrbitals = NULL;
150
151 }
152 if(SymAlphaOrbitals == SymBetaOrbitals)
153 {
154 if(SymAlphaOrbitals)
155 {
156 for(i=0;i<NAlphaOrb;i++)
157 if(SymAlphaOrbitals[i])
158 g_free(SymAlphaOrbitals[i]);
159 g_free(SymAlphaOrbitals);
160 }
161 SymAlphaOrbitals = NULL;
162 SymBetaOrbitals = NULL;
163 }
164 else
165 {
166 if(SymAlphaOrbitals)
167 {
168 for(i=0;i<NAlphaOrb;i++)
169 if(SymAlphaOrbitals[i])
170 g_free(SymAlphaOrbitals[i]);
171 g_free(SymAlphaOrbitals);
172 }
173 SymAlphaOrbitals = NULL;
174 if(SymBetaOrbitals)
175 {
176 for(i=0;i<NBetaOrb;i++)
177 if(SymBetaOrbitals[i])
178 g_free(SymBetaOrbitals[i]);
179 g_free(SymBetaOrbitals);
180 }
181 SymBetaOrbitals = NULL;
182 }
183
184 if(CoefAlphaOrbitals == CoefBetaOrbitals)
185 {
186 if(CoefAlphaOrbitals)
187 {
188 for(i=0;i<NOrb;i++)
189 if(CoefAlphaOrbitals[i])
190 g_free(CoefAlphaOrbitals[i]);
191 g_free(CoefAlphaOrbitals);
192 }
193 CoefAlphaOrbitals = NULL;
194 CoefBetaOrbitals = NULL;
195 }
196 else
197 {
198 if(CoefAlphaOrbitals)
199 {
200 for(i=0;i<NOrb;i++)
201 if(CoefAlphaOrbitals[i])
202 g_free(CoefAlphaOrbitals[i]);
203 g_free(CoefAlphaOrbitals);
204 }
205 CoefAlphaOrbitals = NULL;
206 if(CoefBetaOrbitals)
207 {
208 for(i=0;i<NOrb;i++)
209 if(CoefBetaOrbitals[i])
210 g_free(CoefBetaOrbitals[i]);
211 g_free(CoefBetaOrbitals);
212 }
213 CoefBetaOrbitals = NULL;
214 }
215 set_status_label_info(_("Mol. Orb."),_("Nothing"));
216 NOrb = 0;
217 NAOrb = 0;
218 }
219 /********************************************************************************/
applyiso(GtkWidget * Win,gpointer data)220 static void applyiso(GtkWidget *Win,gpointer data)
221 {
222 GtkWidget* Entry =(GtkWidget*)g_object_get_data(G_OBJECT (Win), "Entry");
223 gchar* temp;
224 gdouble isovalue;
225
226 temp = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry)));
227 delete_first_spaces(temp);
228 delete_last_spaces(temp);
229 if(this_is_a_real(temp)) isovalue = atof(temp);
230 else
231 {
232 GtkWidget* message =Message(_("Error : one entry is not a float "),_("Error"),TRUE);
233 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
234 return;
235 }
236 if(fabs(isovalue)>fabs(limits.MinMax[1][3]) && fabs(isovalue)>fabs(limits.MinMax[0][3]))
237 {
238 gchar buffer[BSIZE];
239 sprintf(buffer,_("Error : The isovalue value should between %lf and %lf"),fabs(limits.MinMax[1][3]),fabs(limits.MinMax[0][3]));
240 GtkWidget* message = Message(buffer,_("Error"),TRUE);
241 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
242 return;
243 }
244 /*
245 if(isovalue<limits.MinMax[0][3])
246 {
247 GtkWidget* message = Message("Error : The minimal value should be smaller than the minimal value ",_("Error"),TRUE);
248 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
249 return;
250 }
251 */
252
253 delete_child(Win);
254 Define_Iso(fabs(isovalue));
255 glarea_rafresh(GLArea);
256 }
257
258 /********************************************************************************/
applygrid(GtkWidget * Win,gpointer data)259 void applygrid(GtkWidget *Win,gpointer data)
260 {
261 GtkWidget** entriestmp = NULL;
262 G_CONST_RETURN gchar* temp;
263 gchar* dump;
264 gint i;
265 gint j;
266 GridLimits limitstmp;
267 gint NumPointstmp[3];
268 GtkWidget *entries[3][6];
269 gdouble V[3][3];
270
271 if(GTK_IS_WIDGET(Win))
272 {
273 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
274 }
275 else return;
276
277 if(entriestmp==NULL) return;
278
279 for(i=0;i<3;i++)
280 for(j=0;j<6;j++)
281 entries[i][j] = entriestmp[i*6+j];
282
283 for(i=0;i<3;i++)
284 {
285 for(j=3;j<5;j++)
286 {
287 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
288 dump = NULL;
289 if(temp && strlen(temp)>0)
290 {
291 dump = g_strdup(temp);
292 delete_first_spaces(dump);
293 delete_last_spaces(dump);
294 }
295
296 if(dump && strlen(dump)>0 && this_is_a_real(dump))
297 {
298 limitstmp.MinMax[j-3][i] = atof(dump);
299 }
300 else
301 {
302 GtkWidget* message = Message(_("Error : one entry is not a float "),_("Error"),TRUE);
303 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
304 return;
305 }
306 if(dump) g_free(dump);
307 }
308 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
309 NumPointstmp[i] = atoi(temp);
310 if(NumPointstmp[i] <=2)
311 {
312 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
313 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
314 return;
315 }
316
317 }
318
319 for(i=0;i<3;i++)
320 {
321 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
322 {
323 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
324 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
325 return;
326 }
327 }
328 for(i=0;i<3;i++)
329 {
330 for(j=0;j<3;j++)
331 {
332 V[i][j] = 0;
333 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
334 dump = NULL;
335 if(temp && strlen(temp)>0)
336 {
337 dump = g_strdup(temp);
338 delete_first_spaces(dump);
339 delete_last_spaces(dump);
340 }
341
342 if(dump && strlen(dump)>0 && this_is_a_real(dump))
343 {
344 V[i][j] = atof(dump);
345 }
346 else
347 {
348 GtkWidget* message = Message(_("Error : one entry is not a float "),_("Error"),TRUE);
349 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
350 return;
351 }
352 if(dump) g_free(dump);
353 }
354 }
355
356 for(i=0;i<3;i++)
357 {
358 gdouble norm = 0.0;
359 for(j=0;j<3;j++)
360 norm += V[i][j]*V[i][j];
361 if(fabs(norm)<1e-8)
362 {
363 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
364 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
365 return;
366 }
367 for(j=0;j<3;j++)
368 V[i][j] /= sqrt(norm);
369 }
370 for(j=0;j<3;j++) originOfCube[j] = 0;
371 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
372 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
373 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
374
375 for(i=0;i<3;i++)
376 {
377 NumPoints[i] =NumPointstmp[i] ;
378 for(j=0;j<2;j++)
379 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
380 }
381 /* for(i=0;i<3;i++) printf("%f %f %d\n",limits.MinMax[0][i], limits.MinMax[1][i], NumPoints[i]); */
382
383
384 delete_child(Win);
385 TypeSelOrb = TypeSelOrbtmp;
386 NumSelOrb = NumSelOrbtmp;
387 /* printf("Define_Grid\n");*/
388 Define_Grid();
389 /* printf("create_iso_orbitals\n");*/
390 create_iso_orbitals();
391 }
392 /********************************************************************************/
applycutoff(GtkWidget * Win,gpointer data)393 static void applycutoff(GtkWidget *Win,gpointer data)
394 {
395 GtkWidget* entry =(GtkWidget*)g_object_get_data(G_OBJECT (Win), "Entry");
396 GtkWidget *alphalist = g_object_get_data(G_OBJECT (Win), "AlphaList");
397 GtkWidget *betalist = g_object_get_data(G_OBJECT (Win), "BetaList");
398 gchar* temp;
399 gdouble cutoff;
400 gint i,j;
401
402 temp = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
403 cutoff =fabs(atof(temp));
404 for(j=0;j<NAlphaOrb;j++)
405 for(i=0;i<NAOrb;i++)
406 if(fabs(CoefAlphaOrbitals[j][i])<cutoff) CoefAlphaOrbitals[j][i] = 0.0;
407 for(j=0;j<NBetaOrb;j++)
408 for(i=0;i<NAOrb;i++)
409 if(fabs(CoefBetaOrbitals[j][i])<cutoff) CoefBetaOrbitals[j][i] = 0.0;
410 delete_child(Win);
411 if(alphalist)
412 {
413 GtkWidget* textWidget = g_object_get_data(G_OBJECT (alphalist), "CoefOrbWidget");
414 if(textWidget) resetViewOrbCoef(textWidget);
415 }
416 if(betalist)
417 {
418 GtkWidget* textWidget = g_object_get_data(G_OBJECT (betalist), "CoefOrbWidget");
419 if(textWidget) resetViewOrbCoef(textWidget);
420 }
421 }
422 /********************************************************************************/
cut_ceof_orbitals_win(GtkWidget * parentWin)423 static void cut_ceof_orbitals_win(GtkWidget* parentWin)
424 {
425 GtkWidget *frame;
426 GtkWidget *vboxframe;
427 GtkWidget *entry;
428 GtkWidget *table;
429
430 GtkWidget *Win;
431 GtkWidget *hbox;
432 GtkWidget *vboxall;
433 GtkWidget *vboxwin;
434 GtkWidget *button;
435 GtkWidget *alphalist = g_object_get_data(G_OBJECT (parentWin), "AlphaList");
436 GtkWidget *betalist = g_object_get_data(G_OBJECT (parentWin), "BetaList");
437
438
439 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
440 gtk_window_set_title(GTK_WINDOW(Win),_("Cutoff molecular orbitals coefficients"));
441 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
442 gtk_container_set_border_width (GTK_CONTAINER (Win), 2);
443 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
444 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
445
446 add_glarea_child(Win,"cutoff coef");
447
448 vboxall = create_vbox(Win);
449 vboxwin = vboxall;
450 frame = gtk_frame_new (NULL);
451 gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
452 gtk_container_add (GTK_CONTAINER (vboxall), frame);
453 gtk_widget_show (frame);
454
455 vboxframe = create_vbox(frame);
456 table = gtk_table_new(1,3,FALSE);
457 gtk_container_add(GTK_CONTAINER(vboxframe),table);
458
459 add_label_at_table(table,"Cut off value",0,0,GTK_JUSTIFY_LEFT);
460 add_label_at_table(table,":",0,1,GTK_JUSTIFY_LEFT);
461 entry= gtk_entry_new ();
462 add_widget_table(table,entry,0,2);
463 gtk_entry_set_text(GTK_ENTRY( entry),"1e-6");
464 gtk_widget_show_all(frame);
465 g_object_set_data(G_OBJECT (Win), "Entry",entry);
466
467
468 g_object_set_data(G_OBJECT (Win), "AlphaList",alphalist);
469 g_object_set_data(G_OBJECT (Win), "BetaList",betalist);
470 /* buttons box */
471 hbox = create_hbox_false(vboxwin);
472 gtk_widget_realize(Win);
473
474 button = create_button(Win,_("Cancel"));
475 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
476 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
477 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, GTK_OBJECT(Win));
478 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,GTK_OBJECT(Win));
479 gtk_widget_show (button);
480
481 button = create_button(Win,_("OK"));
482 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
483 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
484 gtk_widget_grab_default(button);
485 gtk_widget_show (button);
486 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)applycutoff,GTK_OBJECT(Win));
487 g_signal_connect_swapped(G_OBJECT (entry), "activate", (GCallback) gtk_button_clicked, GTK_OBJECT (button));
488
489
490 /* Show all */
491 gtk_widget_show_all (Win);
492 }
493 /*************************************************************************************************/
resetViewOrbCoef(GtkWidget * textWidget)494 static void resetViewOrbCoef(GtkWidget* textWidget)
495 {
496 gchar buffer[BSIZE];
497 gchar buffer1[20];
498 gint nchar;
499 gint l;
500 gchar *XYZ[]={"x","y","z"};
501 gint j = NumSelOrbtmp;
502 gint i;
503 gint nC = 0;
504 gdouble** M = CoefAlphaOrbitals;
505 GtkTreeSelection *select;
506 GtkTreeIter iter;
507 GtkTreeModel* model = NULL;
508 GtkListStore *store = NULL;
509 G_CONST_RETURN gchar* entryText = NULL;
510 gdouble filter = 0.0;
511 GtkWidget* entry = NULL;
512
513 if(NumSelOrbtmp<0) return;
514
515 if(!textWidget) return;
516 if(!AOrb && !SAOrb ) return;
517 if(!GTK_IS_TREE_VIEW(textWidget)) return;
518
519 model = gtk_tree_view_get_model(GTK_TREE_VIEW(textWidget));
520 if(!model) return;
521 store = GTK_LIST_STORE(model);
522 if(!store) return;
523 gtk_list_store_clear(store);
524 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (textWidget));
525 gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
526
527
528 if(TypeSelOrbtmp != 1) M = CoefBetaOrbitals;
529
530 nchar=gabedit_text_get_length(GABEDIT_TEXT(textWidget));
531 gabedit_text_set_point(GABEDIT_TEXT(textWidget),0);
532 gabedit_text_forward_delete(GABEDIT_TEXT(textWidget),nchar);
533 gabedit_text_set_point(GABEDIT_TEXT(textWidget),0);
534
535 entry = g_object_get_data(G_OBJECT (textWidget), "EntryFilter");
536 if(GTK_IS_WIDGET(entry))
537 {
538 entryText = gtk_entry_get_text(GTK_ENTRY(entry));
539 filter = fabs(atof(entryText));
540 }
541
542 for( i=0;i<NAOrb;i++)
543 {
544 if(fabs(M[j][i])<filter) continue;
545 gtk_list_store_append(store, &iter);
546 if(AOrb) nC = AOrb[i].NumCenter;
547 else if(SAOrb) nC = SAOrb[i].NumCenter;
548 sprintf(buffer,"%s[%d]",GeomOrb[nC].Symb,nC+1);
549 gtk_list_store_set (store, &iter, 0, buffer, -1);
550
551 l=0;
552 if(AOrb) for(j=0;j<3;j++) l += AOrb[i].Gtf[0].l[j];
553 else if(SAOrb) for(j=0;j<3;j++) l += SAOrb[i].Stf[0].l[j];
554
555 sprintf(buffer1,"%c",GetSymmetry(l));
556 for(j=0;j<3;j++)
557 {
558 gint ll = 0;
559 if(AOrb ) ll = AOrb[i].Gtf[0].l[j];
560 else if(SAOrb) ll = SAOrb[i].Stf[0].l[j];
561 switch(ll)
562 {
563 case 0: break;
564 case 1: sprintf(buffer1+strlen(buffer1),"%s",XYZ[j]); break;
565 default :
566 if(AOrb)
567 sprintf(buffer1+strlen(buffer1),"%s%d",XYZ[j],AOrb[i].Gtf[0].l[j]);
568 else if(SAOrb)
569 sprintf(buffer1+strlen(buffer1),"%s%d",XYZ[j],SAOrb[i].Stf[0].l[j]);
570 }
571 }
572 sprintf(buffer,"%-12s",buffer1);
573 gtk_list_store_set (store, &iter, 1, buffer, -1);
574
575 j = NumSelOrbtmp;
576 sprintf(buffer,"%+9.6f",M[j][i]);
577 gtk_list_store_set (store, &iter, 2, buffer, -1);
578 }
579 }
580 /*************************************************************************************************/
eventDispatcher(GtkWidget * widget,GdkEventButton * event,gpointer user_data)581 static void eventDispatcher(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
582 {
583
584 GtkTreePath *path;
585 GtkTreeIter iter;
586 GtkTreeModel *model;
587 gint* type;
588 GtkWidget *gtklist = widget;
589 GtkWidget *otherlist = NULL;
590
591 if (!event) return;
592 if (((GdkEventButton *) event)->button != 1) return;
593
594 type = (gint*)g_object_get_data(G_OBJECT (widget), "Type");
595 TypeSelOrbtmp = *type;
596
597 otherlist = g_object_get_data(G_OBJECT (gtklist), "OtherList");
598 if(otherlist)
599 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (otherlist)));
600
601 if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))
602 && !gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, NULL, NULL, NULL, NULL)) {
603 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)));
604 }
605 if(gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, NULL, NULL, NULL))
606 {
607 if(path)
608 {
609 model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
610 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), path);
611 NumSelOrbtmp = getNumSelectOrb(atoi(gtk_tree_path_to_string(path)));
612 gtk_tree_model_get_iter (model, &iter, path);
613 gtk_tree_path_free(path);
614 if ((GdkEventButton *) event && ((GdkEventButton *) event)->type==GDK_2BUTTON_PRESS)
615 {
616 GtkWidget* button = g_object_get_data(G_OBJECT (widget), "ButtonOk");
617 gtk_button_clicked (GTK_BUTTON (button));
618 }
619 }
620 else NumSelOrbtmp = -1;
621 }
622 GTK_WIDGET_GET_CLASS(widget)->button_press_event(widget, event);
623 if(NumSelOrbtmp>=0)
624 {
625 GtkWidget* textWidget = g_object_get_data(G_OBJECT (gtklist), "CoefOrbWidget");
626 if(textWidget) resetViewOrbCoef(textWidget);
627 }
628 }
629 /********************************************************************************/
create_gtk_list_orbitals(gint N,gdouble * Energies,gdouble * Occ,gchar ** sym,gint * widall)630 GtkWidget* create_gtk_list_orbitals(gint N,gdouble* Energies,gdouble* Occ,gchar** sym, gint* widall)
631 {
632 gint i;
633 gint j;
634 GtkWidget* gtklist = NULL;
635 gint *Width = NULL;
636 gint NlistTitle = 4;
637 gchar* Titles[] = {"Nr","Energy","Occ.","Sym."};
638 gchar* List[4];
639 GtkListStore *store;
640 GtkTreeModel *model;
641 GtkCellRenderer *renderer;
642 GtkTreeViewColumn *column;
643 GtkTreeSelection *select;
644 GtkTreeIter iter;
645 GType* types;
646
647 Width = g_malloc(NlistTitle*sizeof(gint));
648
649 for (j=0;j<NlistTitle;j++) Width[j] = strlen(Titles[j]);
650
651 types = g_malloc(NlistTitle*sizeof(GType));
652 for (i=0;i<NlistTitle;i++) types[i] = G_TYPE_STRING;
653 store = gtk_list_store_newv (NlistTitle, types);
654 g_free(types);
655 model = GTK_TREE_MODEL (store);
656
657
658 Width[0] = (gint)(Width[0]*10);
659 Width[1] = (gint)(Width[1]*12);
660 Width[2] = (gint)(Width[2]*8);
661 Width[3] = (gint)(Width[3]*14);
662
663 *widall = 0;
664 for (j=0;j<NlistTitle;j++) *widall += Width[j];
665 *widall += 80;
666
667 gtklist = gtk_tree_view_new_with_model (model);
668 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (gtklist), TRUE);
669 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gtklist), TRUE);
670 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (gtklist), FALSE);
671
672 for (i=0;i<NlistTitle;i++)
673 {
674 column = gtk_tree_view_column_new ();
675 gtk_tree_view_column_set_title (column, Titles[i]);
676 renderer = gtk_cell_renderer_text_new ();
677 gtk_tree_view_column_pack_start (column, renderer, TRUE);
678 gtk_tree_view_column_set_min_width(column, Width[i]);
679 gtk_tree_view_column_set_attributes (column, renderer, "text", i, NULL);
680 gtk_tree_view_append_column (GTK_TREE_VIEW (gtklist), column);
681 }
682 g_free( Width);
683
684 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (gtklist));
685 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
686
687 for(i=0;i<N;i++)
688 {
689 if(strcmp(sym[i],"DELETED")==0)continue;
690 List[0] = g_strdup_printf("%i",i+1);
691 List[1] = g_strdup_printf("%lf",Energies[i]);
692 List[2] = g_strdup_printf("%lf",Occ[i]);
693 List[3] = g_strdup(sym[i]);
694
695 gtk_list_store_append(store, &iter);
696 for(j=0;j<4;j++) gtk_list_store_set (store, &iter, j, List[j], -1);
697
698 for(j=0;j<4;j++) g_free(List[j]);
699 }
700 g_signal_connect(gtklist, "button_press_event", G_CALLBACK(eventDispatcher), NULL);
701
702 return gtklist;
703
704 }
705 /********************************************************************************/
create_gtk_list_coef_orbitals(gint * widall)706 GtkWidget* create_gtk_list_coef_orbitals(gint* widall)
707 {
708 gint i;
709 gint j;
710 GtkWidget* gtklist = NULL;
711 gint *Width = NULL;
712 gint NlistTitle = 3;
713 gchar* titles[] = {"Atom","Type","Coeff."};
714 GtkListStore *store;
715 GtkTreeModel *model;
716 GtkCellRenderer *renderer;
717 GtkTreeViewColumn *column;
718 GType* types;
719
720 Width = g_malloc(NlistTitle*sizeof(gint));
721
722 for (j=0;j<NlistTitle;j++) Width[j] = strlen(titles[j]);
723
724 types = g_malloc(NlistTitle*sizeof(GType));
725 for (i=0;i<NlistTitle;i++) types[i] = G_TYPE_STRING;
726 store = gtk_list_store_newv (NlistTitle, types);
727 g_free(types);
728 model = GTK_TREE_MODEL (store);
729
730
731 Width[0] = (gint)(Width[0]*5);
732 Width[1] = (gint)(Width[1]*5);
733 Width[2] = (gint)(Width[2]*5);
734
735 *widall = 0;
736 for (j=0;j<NlistTitle;j++) *widall += Width[j];
737 *widall += 10;
738
739 gtklist = gtk_tree_view_new_with_model (model);
740 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (gtklist), TRUE);
741 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gtklist), TRUE);
742 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (gtklist), FALSE);
743
744 for (i=0;i<NlistTitle;i++)
745 {
746 column = gtk_tree_view_column_new ();
747 gtk_tree_view_column_set_title (column, titles[i]);
748 renderer = gtk_cell_renderer_text_new ();
749 gtk_tree_view_column_pack_start (column, renderer, TRUE);
750 gtk_tree_view_column_set_min_width(column, Width[i]);
751 gtk_tree_view_column_set_attributes (column, renderer, "text", i, NULL);
752 gtk_tree_view_append_column (GTK_TREE_VIEW (gtklist), column);
753 }
754 g_free( Width);
755
756 return gtklist;
757
758 }
759 /************************************************************************************************************/
changedEntryFilterCoef(GtkWidget * textWidget,gpointer data)760 static void changedEntryFilterCoef(GtkWidget *textWidget, gpointer data)
761 {
762 if(NumSelOrbtmp<0) return;
763 if(textWidget) resetViewOrbCoef(textWidget);
764 }
765
766 /********************************************************************************/
create_alpha_beta_lists(GtkWidget * noteBook,gint Type)767 GtkWidget* create_alpha_beta_lists(GtkWidget *noteBook, gint Type)
768 {
769 GtkWidget *frame;
770 GtkWidget *scr;
771 GtkWidget *hbox;
772 GtkWidget *gtklist;
773 gint i;
774 gint N;
775 gdouble* Energies;
776 gdouble* Occ;
777 gchar** sym;
778 static gint alphaType = 1;
779 static gint betaType = 2;
780 gint widall = 0;
781 gchar* labelAlpha = "Alpha Orbitals";
782 gchar* labelBeta = "Beta Orbitals";
783 gchar* label = labelAlpha;
784 GtkWidget *labelOnglet = NULL;
785 GtkWidget *labelMenu = NULL;
786 GtkWidget *textWidget = NULL;
787 GtkWidget *table = NULL;
788 GtkWidget *entry = NULL;
789 GtkWidget *vbox = NULL;
790 GtkWidget *hseparator = gtk_hseparator_new ();
791
792 N = NAlphaOrb;
793 if(Type != 1) N = NBetaOrb;
794 Energies = g_malloc(N*sizeof(gdouble));
795 Occ = g_malloc(N*sizeof(gdouble));
796 sym = g_malloc(N*sizeof(gchar*));
797
798 if(Type == 1)
799 {
800 label = labelAlpha;
801 for(i=0;i<N;i++)
802 {
803 Energies[i] = EnerAlphaOrbitals[i];
804 Occ[i] = OccAlphaOrbitals[i];
805 sym[i] = g_strdup(SymAlphaOrbitals[i]);
806 }
807 gtklist = create_gtk_list_orbitals(N,Energies,Occ,sym,&widall);
808 g_object_set_data(G_OBJECT (gtklist), "Type",&alphaType);
809 }
810 else
811 {
812 label = labelBeta;
813 for(i=0;i<N;i++)
814 {
815 Energies[i] = EnerBetaOrbitals[i];
816 Occ[i] = OccBetaOrbitals[i];
817 sym[i] = g_strdup(SymBetaOrbitals[i]);
818 }
819 gtklist = create_gtk_list_orbitals(N,Energies,Occ,sym,&widall);
820 g_object_set_data(G_OBJECT (gtklist), "Type",&betaType);
821 }
822
823 frame = gtk_frame_new (NULL);
824 gtk_container_set_border_width (GTK_CONTAINER (frame), 1);
825 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
826 labelOnglet = gtk_label_new(label);
827 labelMenu = gtk_label_new(label);
828 gtk_notebook_append_page_menu(GTK_NOTEBOOK(noteBook),frame, labelOnglet, labelMenu);
829 gtk_widget_show (frame);
830
831
832 vbox = gtk_vbox_new (FALSE, 0);
833 gtk_widget_show (vbox);
834 gtk_container_add (GTK_CONTAINER (frame), vbox);
835
836 hbox = gtk_hbox_new (TRUE, 0);
837 gtk_widget_show (hbox);
838 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
839
840 scr=gtk_scrolled_window_new(NULL,NULL);
841 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*WIDTHSCR));
842 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
843 gtk_box_pack_start(GTK_BOX (hbox), scr,TRUE, TRUE, 2);
844 gtk_container_add(GTK_CONTAINER(scr),gtklist);
845 set_base_style(gtklist,55000,55000,55000);
846
847 vbox = gtk_vbox_new (FALSE, 0);
848 gtk_widget_show (vbox);
849 gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
850
851 textWidget = create_gtk_list_coef_orbitals(&widall);
852 scr=gtk_scrolled_window_new(NULL,NULL);
853 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*WIDTHSCR));
854 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
855 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 2);
856 gtk_container_add(GTK_CONTAINER(scr),textWidget);
857 g_object_set_data(G_OBJECT (gtklist), "CoefOrbWidget",textWidget);
858 gtk_widget_set_size_request(textWidget,widall,(gint)(ScreenHeight*WIDTHSCR));
859
860 gtk_widget_show (hseparator);
861 gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, FALSE, 1);
862
863 table = gtk_table_new(1,3,FALSE);
864 add_label_at_table(table,"Filter",0,0,GTK_JUSTIFY_LEFT);
865 add_label_at_table(table,":",0,1,GTK_JUSTIFY_LEFT);
866 entry = gtk_entry_new ();
867 gtk_table_attach(GTK_TABLE(table),entry,2,3,0,1,
868 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
869 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
870 3,3);
871 gtk_entry_set_text(GTK_ENTRY( entry),"0.0");
872 gtk_box_pack_start(GTK_BOX (vbox), table,FALSE, FALSE, 2);
873 g_object_set_data(G_OBJECT (textWidget), "EntryFilter",entry);
874 g_signal_connect_swapped(G_OBJECT(entry),"changed", G_CALLBACK(changedEntryFilterCoef),textWidget);
875
876
877 for(i=0;i<N;i++)
878 g_free(sym[i]);
879 g_free(Energies);
880 g_free(Occ);
881 g_free(sym);
882
883 return gtklist;
884
885 }
886 /********************************************************************************/
getiso(GtkWidget * button,gpointer data)887 static void getiso(GtkWidget *button,gpointer data)
888 {
889 GtkWidget* Entry =(GtkWidget*)g_object_get_data(G_OBJECT (button), "Entry");
890 GtkWidget* EntryPercent =(GtkWidget*)g_object_get_data(G_OBJECT (button), "EntryPercent");
891 gchar* temp;
892 gdouble isovalue = 0.1;
893 gdouble percent = 100;
894 gboolean square = TRUE;
895 gdouble precision =1e-6;
896
897 temp = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryPercent)));
898 delete_first_spaces(temp);
899 delete_last_spaces(temp);
900 if(this_is_a_real(temp)) percent = fabs(atof(temp));
901 else
902 {
903 GtkWidget* message =Message(_("Error : one entry is not a float "),_("Error"),TRUE);
904 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
905 if(temp) g_free(temp);
906 return;
907 }
908 if(temp) g_free(temp);
909 if(percent<0) percent = 0;
910 if(percent>100) percent = 100;
911
912 if(
913 TypeGrid == GABEDIT_TYPEGRID_ELFSAVIN
914 || TypeGrid == GABEDIT_TYPEGRID_ELFBECKE
915 || TypeGrid == GABEDIT_TYPEGRID_FEDELECTROPHILIC
916 || TypeGrid == GABEDIT_TYPEGRID_FEDNUCLEOPHILIC
917 || TypeGrid == GABEDIT_TYPEGRID_FEDRADICAL
918 || TypeGrid == GABEDIT_TYPEGRID_EDENSITY
919 ) square = FALSE;
920
921 if(!compute_isovalue_percent_from_grid(grid, square, percent, precision, &isovalue)) return;
922 temp = g_strdup_printf("%f",isovalue);
923 gtk_entry_set_text(GTK_ENTRY(Entry),temp);
924 if(temp) g_free(temp);
925 }
926 /********************************************************************************/
create_iso_frame(GtkWidget * vboxall,gchar * title)927 GtkWidget *create_iso_frame( GtkWidget *vboxall,gchar* title)
928 {
929 GtkWidget *frame;
930 GtkWidget *vboxframe;
931 GtkWidget *Entry;
932 GtkWidget *EntryPercent;
933 gushort i;
934 gushort j;
935 GtkWidget *Table;
936 gdouble v;
937 GtkWidget* button;
938 #define NLIGNES 3
939 #define NCOLUMNS 3
940 gchar *strlabels[NLIGNES][NCOLUMNS];
941
942 strlabels[0][0] = g_strdup(_(" Min "));
943 strlabels[1][0] = g_strdup(_(" Max "));
944 strlabels[2][0] = g_strdup(_(" Value "));
945 strlabels[0][1] = g_strdup(" : ");
946 strlabels[1][1] = g_strdup(" : ");
947 strlabels[2][1] = g_strdup(" : ");
948
949 if(fabs(limits.MinMax[0][3])>1e6) strlabels[0][2] = g_strdup_printf(" %e ",limits.MinMax[0][3]);
950 else strlabels[0][2] = g_strdup_printf(" %lf ",limits.MinMax[0][3]);
951
952 if(fabs(limits.MinMax[1][3])>1e6) strlabels[1][2] = g_strdup_printf(" %e ",limits.MinMax[1][3]);
953 else strlabels[1][2] = g_strdup_printf(" %lf ",limits.MinMax[1][3]);
954 v = limits.MinMax[1][3]/4;
955 if(v>0.2 && fabs(limits.MinMax[1][3])>0.01 && fabs(limits.MinMax[0][3])<0.01) v= 0.01;
956 if(TypeGrid == GABEDIT_TYPEGRID_SAS) v = 0;
957 if(TypeGrid == GABEDIT_TYPEGRID_ELFSAVIN) v = 0.8;
958 if(TypeGrid == GABEDIT_TYPEGRID_ELFBECKE) v = 0.8;
959 if(TypeGrid == GABEDIT_TYPEGRID_FEDELECTROPHILIC) v *= 3;
960 if(TypeGrid == GABEDIT_TYPEGRID_FEDNUCLEOPHILIC) v *= 3;
961 if(TypeGrid == GABEDIT_TYPEGRID_FEDRADICAL) v *= 3;
962 if(TypeGrid == GABEDIT_TYPEGRID_NCI) v = 0.1;
963
964 strlabels[2][2] = g_strdup_printf("%lf",v);
965
966 frame = gtk_frame_new (title);
967 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
968 gtk_container_add (GTK_CONTAINER (vboxall), frame);
969 gtk_widget_show (frame);
970
971 vboxframe = create_vbox(frame);
972 Table = gtk_table_new(3,3,FALSE);
973 gtk_container_add(GTK_CONTAINER(vboxframe),Table);
974
975 for(i=0;i<3;i++)
976 for(j=0;j<3;j++)
977 if(i+j != 4)
978 add_label_at_table(Table,strlabels[i][j],i,(gushort)j,GTK_JUSTIFY_LEFT);
979 Entry= gtk_entry_new ();
980 add_widget_table(Table,Entry,(gushort)2,(gushort)2);
981 gtk_entry_set_text(GTK_ENTRY( Entry),strlabels[2][2]);
982
983 for(i=0;i<3;i++)
984 {
985 for(j=0;j<3;j++)
986 g_free(strlabels[i][j]);
987 }
988 gtk_box_pack_start (GTK_BOX (vboxframe), gtk_hseparator_new (), TRUE, TRUE, 0);
989 Table = gtk_table_new(1,3,FALSE);
990 gtk_box_pack_start (GTK_BOX (vboxframe), Table, TRUE, TRUE, 0);
991 EntryPercent= gtk_entry_new ();
992 gtk_widget_set_size_request(EntryPercent,60,-1);
993 add_widget_table(Table,EntryPercent,0,0);
994 gtk_entry_set_text(GTK_ENTRY( EntryPercent),"99");
995 g_object_set_data(G_OBJECT (frame), "EntryPercent",EntryPercent);
996 add_label_at_table(Table,"%",0,1,GTK_JUSTIFY_LEFT);
997 button = gtk_button_new_with_label(" Get Isovalue ");
998 g_object_set_data(G_OBJECT (frame), "ButtonGet",button);
999 gtk_table_attach(GTK_TABLE(Table),button,2,3,0,1,
1000 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1001 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1002 3,3);
1003
1004 gtk_widget_show_all(frame);
1005 g_object_set_data(G_OBJECT (frame), "Entry",Entry);
1006
1007 g_object_set_data(G_OBJECT (button), "EntryPercent",EntryPercent);
1008 g_object_set_data(G_OBJECT (button), "Entry",Entry);
1009 g_signal_connect(G_OBJECT(button), "clicked",(GCallback)getiso,GTK_OBJECT(Entry));
1010
1011 return frame;
1012 #undef NLIGNES
1013 #undef NCOLUMNS
1014 }
1015 /********************************************************************************/
reset_new_surface()1016 static void reset_new_surface()
1017 {
1018 newSurface = FALSE;
1019 }
1020 /********************************************************************************/
create_iso_orbitals()1021 void create_iso_orbitals()
1022 {
1023 GtkWidget *Win;
1024 GtkWidget *frame;
1025 GtkWidget *hbox;
1026 GtkWidget *vboxall;
1027 GtkWidget *vboxwin;
1028 GtkWidget *button;
1029 GtkWidget* Entry;
1030
1031
1032 /* printf("Begin create_iso_orbitals\n"); */
1033 if(!grid )
1034 {
1035 if( !CancelCalcul)
1036 Message(_("Grid not defined "),_("Error"),TRUE);
1037 return;
1038 }
1039 /* Principal Window */
1040 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1041 gtk_window_set_title(GTK_WINDOW(Win),_("Calculations of isosurfaces for an orbital"));
1042 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
1043 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
1044 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
1045 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
1046
1047 add_glarea_child(Win,"Iso surface ");
1048 g_signal_connect(G_OBJECT(Win),"delete_event",(GCallback)reset_new_surface,NULL);
1049
1050 vboxall = create_vbox(Win);
1051 vboxwin = vboxall;
1052 frame = create_iso_frame(vboxall,_("Iso-Value"));
1053 Entry = (GtkWidget*) g_object_get_data(G_OBJECT (frame), "Entry");
1054 g_object_set_data(G_OBJECT (Win), "Entry",Entry);
1055
1056
1057 /* buttons box */
1058 hbox = create_hbox_false(vboxwin);
1059 gtk_widget_realize(Win);
1060
1061 button = create_button(Win,_("Cancel"));
1062 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1063 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
1064 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, GTK_OBJECT(Win));
1065 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,GTK_OBJECT(Win));
1066 gtk_widget_show (button);
1067
1068 button = create_button(Win,_("OK"));
1069 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
1070 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1071 gtk_widget_grab_default(button);
1072 gtk_widget_show (button);
1073 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)applyiso,GTK_OBJECT(Win));
1074 g_signal_connect_swapped(G_OBJECT (Entry), "activate", (GCallback) gtk_button_clicked, GTK_OBJECT (button));
1075
1076
1077 /* Show all */
1078 gtk_widget_show_all (Win);
1079 }
1080 /********************************************************************************/
create_grid_orbitals()1081 void create_grid_orbitals()
1082 {
1083 TypeGrid = GABEDIT_TYPEGRID_ORBITAL;
1084 create_grid("Calculations of grid for an orbital");
1085 }
1086 /********************************************************************************/
create_alpha_dos(GtkWidget * parentWindow,gpointer data)1087 static void create_alpha_dos(GtkWidget *parentWindow,gpointer data)
1088 {
1089 gint n = NAlphaOrb;
1090 createDOSSpectrumFromEnergiesTable(parentWindow, EnerAlphaOrbitals, n);
1091 }
1092 /********************************************************************************/
create_beta_dos(GtkWidget * parentWindow,gpointer data)1093 static void create_beta_dos(GtkWidget *parentWindow,gpointer data)
1094 {
1095 gint n = NBetaOrb;
1096 createDOSSpectrumFromEnergiesTable(parentWindow, EnerBetaOrbitals, n);
1097 }
1098 /********************************************************************************/
create_all_dos(GtkWidget * parentWindow,gpointer data)1099 static void create_all_dos(GtkWidget *parentWindow,gpointer data)
1100 {
1101 gint i;
1102 gint n = NAlphaOrb + NBetaOrb;
1103 gdouble *energies = NULL;
1104 if(n<1)return;
1105 if(!EnerAlphaOrbitals && NAlphaOrb>0) return;
1106 if(!EnerBetaOrbitals && NBetaOrb>0) return;
1107 energies = g_malloc(n*sizeof(gdouble));
1108 for(i=0;i<NAlphaOrb;i++) energies[i] = EnerAlphaOrbitals[i];
1109 for(i=0;i<NBetaOrb;i++) energies[i+NAlphaOrb] = EnerBetaOrbitals[i];
1110 createDOSSpectrumFromEnergiesTable(parentWindow, energies, n);
1111 g_free(energies);
1112 }
1113 /********************************************************************************/
create_list_orbitals()1114 void create_list_orbitals()
1115 {
1116 GtkWidget *Win;
1117 GtkWidget *frame;
1118 GtkWidget *hbox;
1119 GtkWidget *vboxall;
1120 GtkWidget *vboxwin;
1121 GtkWidget *button;
1122 GtkWidget *noteBook = gtk_notebook_new();
1123 GtkWidget *alphalist = NULL;
1124 GtkWidget *betalist = NULL;
1125
1126 if(NAOrb<1)
1127 {
1128 Message(_("Sorry, Please load a file before\n"),_("Error"),TRUE);
1129 return;
1130 }
1131
1132 if(winList) destroyWinsList(winList);
1133
1134 /* Principal Window */
1135 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1136 gtk_window_set_title(GTK_WINDOW(Win),_("Orbitals"));
1137 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
1138 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
1139 gtk_window_set_default_size (GTK_WINDOW(Win),-1,(gint)(ScreenHeight*0.69));
1140 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
1141 /* gtk_window_set_modal (GTK_WINDOW (Win), TRUE);*/
1142
1143 add_glarea_child(Win,"Orbitals List ");
1144 g_signal_connect(G_OBJECT(Win),"delete_event",(GCallback)destroyWinsList,NULL);
1145
1146 vboxall = create_vbox(Win);
1147 vboxwin = vboxall;
1148
1149 frame = gtk_frame_new (NULL);
1150 gtk_container_set_border_width (GTK_CONTAINER (frame), 1);
1151 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
1152 gtk_container_add(GTK_CONTAINER(vboxall),frame);
1153 gtk_widget_show (frame);
1154 vboxall = create_vbox(frame);
1155 gtk_box_pack_start (GTK_BOX (vboxall), noteBook, TRUE, TRUE, 0);
1156 alphalist = create_alpha_beta_lists(noteBook, 1);
1157 betalist = create_alpha_beta_lists(noteBook, 2);
1158 g_object_set_data(G_OBJECT (alphalist), "OtherList",betalist);
1159 g_object_set_data(G_OBJECT (betalist), "OtherList",alphalist);
1160
1161 TypeSelOrbtmp = TypeSelOrb;
1162 NumSelOrbtmp = NumSelOrb;
1163
1164 gtk_widget_show_all(vboxall);
1165
1166 /* buttons box */
1167 hbox = create_hbox_false(vboxwin);
1168 gtk_widget_realize(Win);
1169
1170 button = create_button(Win,_("Close"));
1171 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1172 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1173 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)destroyWinsList, GTK_OBJECT(Win));
1174 gtk_widget_show (button);
1175
1176 button = create_button(Win,_("Cut MO Coef."));
1177 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1178 gtk_widget_show (button);
1179 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)cut_ceof_orbitals_win,GTK_OBJECT(Win));
1180
1181 button = create_button(Win,_("DOS Alpha"));
1182 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1183 gtk_widget_show (button);
1184 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)create_alpha_dos,GTK_OBJECT(Win));
1185
1186 button = create_button(Win,_("DOS Beta"));
1187 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1188 gtk_widget_show (button);
1189 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)create_beta_dos,GTK_OBJECT(Win));
1190
1191 button = create_button(Win,_("DOS All"));
1192 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1193 gtk_widget_show (button);
1194 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)create_all_dos,GTK_OBJECT(Win));
1195
1196 button = create_button(Win,_("OK"));
1197 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 2);
1198 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1199 gtk_widget_grab_default(button);
1200 gtk_widget_show (button);
1201 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)create_grid_orbitals,GTK_OBJECT(Win));
1202 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)destroyWinsList, GTK_OBJECT(Win));
1203
1204 g_object_set_data(G_OBJECT (alphalist), "ButtonOk",button);
1205 g_object_set_data(G_OBJECT (betalist), "ButtonOk",button);
1206 g_object_set_data(G_OBJECT (Win), "AlphaList",alphalist);
1207 g_object_set_data(G_OBJECT (Win), "BetaList",betalist);
1208
1209
1210
1211 gtk_widget_show (Win);
1212 /* fit_windows_position(PrincipalWindow, Win);*/
1213 /* Show all */
1214
1215 gtk_widget_show_all (Win);
1216
1217 if(TypeSelOrb == 1 && NumSelOrb > -1)
1218 {
1219 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (betalist)));
1220 selectRow(alphalist,getNumSelectRow(NumSelOrb));
1221 }
1222 if(TypeSelOrb == 2 && NumSelOrb > -1)
1223 {
1224 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (alphalist)));
1225 selectRow(betalist,getNumSelectRow(NumSelOrb));
1226 }
1227 winList = Win;
1228 }
1229 /********************************************************************************/
get_sym_orb(gchar * allstr)1230 gchar* get_sym_orb(gchar *allstr)
1231 {
1232 gchar* begin = NULL;
1233 gchar* end = NULL;
1234 begin = strstr(allstr,"(");
1235 if(begin)
1236 {
1237 end = strstr(begin+1,")");
1238 if(end)
1239 {
1240 gint l = end-begin;
1241 gint i;
1242 gchar *sym;
1243 if(l<=0)
1244 return g_strdup(_("Unknown"));
1245 sym = g_malloc(l*sizeof(gchar));
1246 for(i=0;i<l-1;i++)
1247 sym[i] = begin[i+1];
1248 sym[l-1] = '\0';
1249 return sym;
1250 }
1251 else
1252 return g_strdup(_("Unknown"));
1253 }
1254 else
1255 return g_strdup(_("Unknown"));
1256
1257 }
1258 /********************************************************************************/
save_geometry_gabedit_format(FILE * file)1259 static void save_geometry_gabedit_format(FILE* file)
1260 {
1261 gint j;
1262 fprintf(file,"[Atoms] Angs\n");
1263 for(j=0;j<nCenters;j++)
1264 {
1265 fprintf(file,"%s %d %d %lf %lf %lf\n",GeomOrb[j].Symb,j+1,(gint)GeomOrb[j].Prop.atomicNumber,
1266 BOHR_TO_ANG*GeomOrb[j].C[0],BOHR_TO_ANG*GeomOrb[j].C[1],BOHR_TO_ANG*GeomOrb[j].C[2]);
1267 }
1268 }
1269 /********************************************************************************/
save_mo_orbitals_gabedit_format(FILE * file)1270 static void save_mo_orbitals_gabedit_format(FILE* file)
1271 {
1272 gint i;
1273 gint j;
1274 fprintf(file,"[MO]\n");
1275 for(j=0;j<NAlphaOrb;j++)
1276 {
1277
1278 fprintf(file," Ene= %lf\n",EnerAlphaOrbitals[j]);
1279 fprintf(file," Spin= Alpha\n");
1280 fprintf(file," Occup= %lf\n",OccAlphaOrbitals[j]);
1281 fprintf(file," Sym= %s\n",SymAlphaOrbitals[j]);
1282 for(i=0;i<NAOrb;i++)
1283 fprintf(file," %d %lf\n",i+1, CoefAlphaOrbitals[j][i]);
1284 }
1285 for(j=0;j<NBetaOrb;j++)
1286 {
1287
1288 fprintf(file," Ene= %lf\n",EnerBetaOrbitals[j]);
1289 fprintf(file," Spin= Beta\n");
1290 fprintf(file," Occup= %lf\n",OccBetaOrbitals[j]);
1291 fprintf(file," Sym= %s\n",SymBetaOrbitals[j]);
1292 for(i=0;i<NAOrb;i++)
1293 fprintf(file," %d %lf\n",i+1, CoefBetaOrbitals[j][i]);
1294 }
1295 fprintf(file,"\n");
1296 }
1297 /********************************************************************************/
save_gabedit_orbitals(gchar * FileName)1298 static void save_gabedit_orbitals(gchar* FileName)
1299 {
1300 FILE *file;
1301 file = FOpen(FileName, "w");
1302 if(file == NULL)
1303 {
1304 gchar buffer[BSIZE];
1305 sprintf(buffer,_("Sorry, I can not create '%s' file\n"),FileName);
1306 Message(buffer,_("Error"),TRUE);
1307 return;
1308 }
1309 if(sphericalBasis)
1310 fprintf(file,"[Gabedit Format] Sphe\n");
1311 else
1312 fprintf(file,"[Gabedit Format]\n");
1313 save_geometry_gabedit_format(file);
1314 save_basis_gabedit_format(file);
1315 save_mo_orbitals_gabedit_format(file);
1316 save_ao_orbitals_gabedit_format(file);
1317 fclose(file);
1318 }
1319 /********************************************************************************/
read_last_orbitals_in_gaussian_file(gchar * fileName,gint itype)1320 gboolean read_last_orbitals_in_gaussian_file(gchar *fileName,gint itype)
1321 {
1322 gchar *t;
1323 gboolean OK;
1324 gchar *AtomCoord[5];
1325 FILE *fd;
1326 gint taille=BSIZE;
1327 gint i;
1328 gint numorb;
1329 gchar *pdest = NULL;
1330 gint NumOrb[5];
1331 gchar SymOrb[5][10];
1332 gdouble EnerOrb[5];
1333 gchar *dump1= g_malloc(20);
1334 gchar *dump2= g_malloc(20);
1335 gint ncart;
1336 gint n;
1337 /* gint k;*/
1338 gdouble **CoefOrbitals;
1339 gdouble *EnerOrbitals;
1340 gchar **SymOrbitals;
1341 gchar* tmp = NULL;
1342 gint NOcc = 0;
1343 gint nReadOrb = 0;
1344 gint nR = 0;
1345
1346 if ((!fileName) || (strcmp(fileName,"") == 0))
1347 {
1348 Message(_("Sorry No file selected\n"),_("Error"),TRUE);
1349 return FALSE;
1350 }
1351
1352 t=g_malloc(taille);
1353 fd = FOpen(fileName, "rb");
1354 if(fd ==NULL)
1355 {
1356 gchar buffer[BSIZE];
1357 sprintf(buffer,_("Sorry, I can not open '%s' file\n"),fileName);
1358 Message(buffer,_("Error"),TRUE);
1359 return FALSE;
1360 }
1361 for(i=0;i<5;i++)
1362 AtomCoord[i]=g_malloc(taille*sizeof(char));
1363
1364 CoefOrbitals = CreateTable2(NOrb);
1365 EnerOrbitals = g_malloc(NOrb*sizeof(gdouble));
1366 SymOrbitals = g_malloc(NOrb*sizeof(gchar*));
1367
1368 numorb =1;
1369 do
1370 {
1371 OK=FALSE;
1372 while(!feof(fd))
1373 {
1374 { char* e = fgets(t,taille,fd);}
1375 switch(itype)
1376 {
1377 case 1 :
1378 pdest = strstr( t, "Alpha Molecular Orbital Coefficients" );
1379 break;
1380 case 2 :
1381 pdest = strstr( t, "Beta Molecular Orbital Coefficients" );
1382 break;
1383 case 3:
1384 pdest = strstr( t, "Molecular Orbital Coefficients" );
1385 break;
1386 case 4:
1387 pdest = strstr( t, "Natural Orbital Coefficients" );
1388 break;
1389 }
1390 if ( pdest != NULL )
1391 {
1392 numorb++;
1393 OK = TRUE;
1394 break;
1395 }
1396 }
1397 if(!OK && (numorb == 1) )
1398 {
1399 if(itype==2 || itype==4)
1400 {
1401 gchar buffer[BSIZE];
1402 sprintf(buffer,_("Sorry, I can not read orbitals from '%s' file\n"),fileName);
1403 Message(buffer,_("Error"),TRUE);
1404 }
1405 FreeTable2(CoefOrbitals,NOrb);
1406 g_free(EnerOrbitals);
1407 g_free(SymOrbitals);
1408 return FALSE;
1409 }
1410 if(!OK)
1411 {
1412 /* Debug("End of read \n");*/
1413 fclose(fd);
1414 g_free(t);
1415 for(i=0;i<5;i++)
1416 g_free(AtomCoord[i]);
1417
1418 switch(itype)
1419 {
1420 case 1 :
1421 CoefAlphaOrbitals = CoefOrbitals;
1422 EnerAlphaOrbitals = EnerOrbitals;
1423
1424 SymAlphaOrbitals = SymOrbitals;
1425
1426 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
1427 for(i=0;i<NOcc;i++)
1428 OccAlphaOrbitals[i] = 1.0;
1429 for(i=NOcc;i<NOrb;i++)
1430 OccAlphaOrbitals[i] = 0.0;
1431
1432 NAlphaOcc = NOcc;
1433 NAlphaOrb = nReadOrb;
1434 break;
1435 case 2 :
1436 CoefBetaOrbitals = CoefOrbitals;
1437 EnerBetaOrbitals = EnerOrbitals;
1438 SymBetaOrbitals = SymOrbitals;
1439
1440 OccBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
1441 for(i=0;i<NOcc;i++)
1442 OccBetaOrbitals[i] = 1.0;
1443 for(i=NOcc;i<NOrb;i++)
1444 OccBetaOrbitals[i] = 0.0;
1445
1446 NBetaOcc = NOcc;
1447 NBetaOrb = nReadOrb;
1448 break;
1449 case 3 :
1450 CoefAlphaOrbitals = CoefOrbitals;
1451 EnerAlphaOrbitals = EnerOrbitals;
1452 SymAlphaOrbitals = SymOrbitals;
1453 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
1454 for(i=0;i<NOcc;i++)
1455 OccAlphaOrbitals[i] = 1.0;
1456 for(i=NOcc;i<NOrb;i++)
1457 OccAlphaOrbitals[i] = 0.0;
1458
1459 CoefBetaOrbitals = CoefOrbitals;
1460 EnerBetaOrbitals = EnerOrbitals;
1461 OccBetaOrbitals = OccAlphaOrbitals;
1462 SymBetaOrbitals = SymOrbitals;
1463 NAlphaOcc = NOcc;
1464 NBetaOcc = NOcc;
1465 NAlphaOrb = nReadOrb;
1466 NBetaOrb = nReadOrb;
1467 break;
1468 case 4 :
1469 CoefAlphaOrbitals = CoefOrbitals;
1470 EnerAlphaOrbitals = EnerOrbitals;
1471 SymAlphaOrbitals = SymOrbitals;
1472 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
1473 for(i=0;i<NOcc;i++)
1474 OccAlphaOrbitals[i] = 1.0;
1475 for(i=NOcc;i<NOrb;i++)
1476 OccAlphaOrbitals[i] = 0.0;
1477
1478 CoefBetaOrbitals = CoefOrbitals;
1479 EnerBetaOrbitals = EnerOrbitals;
1480 OccBetaOrbitals = OccAlphaOrbitals;
1481 SymBetaOrbitals = SymOrbitals;
1482 NAlphaOcc = NOcc;
1483 NBetaOcc = NOcc;
1484 NAlphaOrb = nReadOrb;
1485 NBetaOrb = nReadOrb;
1486 break;
1487 }
1488 return TRUE;
1489 }
1490
1491 NOcc = 0;
1492 ncart=NOrb/5;
1493 if(NOrb%5!=0) ncart++;
1494 nReadOrb = 0;
1495 nR = 5;
1496 for(n=0;n<ncart && nR==5;n++)
1497 {
1498 { char* e = fgets(t,taille,fd);}
1499 nR = sscanf(t,"%d %d %d %d %d",&NumOrb[0],&NumOrb[1],&NumOrb[2],&NumOrb[3],&NumOrb[4]);
1500 nReadOrb += nR;
1501 for(i=0;i<nR;i++) NumOrb[i]--;
1502 for(i=nR;i<5;i++) NumOrb[i]=NOrb-1;
1503 if(nR==0) break;
1504
1505 if(itype<4)
1506 {
1507 { char* e = fgets(t,taille,fd);}
1508 /* Debug("%d %d %d %d %d\n",NumOrb[0],NumOrb[1],NumOrb[2],NumOrb[3],NumOrb[4]);*/
1509 sscanf(t,"%s %s %s %s %s",SymOrb[0],SymOrb[1],SymOrb[2],SymOrb[3],SymOrb[4]);
1510 /* Debug("%s %s %s %s %s\n",SymOrb[0],SymOrb[1],SymOrb[2],SymOrb[3],SymOrb[4]);*/
1511 for(i=0;i<nR;i++)
1512 if(strstr(SymOrb[i],"O"))
1513 NOcc++;
1514 for(i=0;i<nR;i++)
1515 SymOrbitals[NumOrb[i]] = get_sym_orb(SymOrb[i]);
1516 }
1517 else
1518 {
1519 for(i=0;i<nR;i++)
1520 SymOrbitals[NumOrb[i]] = g_strdup("UNK");
1521 }
1522
1523
1524 { char* e = fgets(t,taille,fd);}
1525 sscanf(t,"%s %s %lf %lf %lf %lf %lf",dump1,dump2,
1526 &EnerOrb[0], &EnerOrb[1], &EnerOrb[2], &EnerOrb[3], &EnerOrb[4]);
1527
1528 for(i=0;i<nR;i++)
1529 EnerOrbitals[NumOrb[i]] = EnerOrb[i];
1530 if(itype>3)
1531 {
1532 for(i=0;i<nR;i++)
1533 if(EnerOrb[i]>0)
1534 NOcc++;
1535 }
1536
1537 for(i=0;i<NOrb;i++)
1538 {
1539 { char* e = fgets(t,taille,fd);}
1540 tmp = t + 20;
1541 /* k = sscanf(tmp,"%lf %lf %lf %lf %lf",&CoefOrbitals[NumOrb[0]][i],&CoefOrbitals[NumOrb[1]][i],*/
1542 sscanf(tmp,"%lf %lf %lf %lf %lf",&CoefOrbitals[NumOrb[0]][i],&CoefOrbitals[NumOrb[1]][i],
1543 &CoefOrbitals[NumOrb[2]][i],&CoefOrbitals[NumOrb[3]][i],&CoefOrbitals[NumOrb[4]][i]);
1544 }
1545 }
1546 /*
1547 Debug("End ncart\n");
1548 Debug("nR = %d\n",nR);
1549 */
1550 if(nR!=5)
1551 {
1552 for(i=nReadOrb;i<NOrb;i++)
1553 SymOrbitals[i] = g_strdup("DELETE");
1554 }
1555
1556 /*
1557 if(NOrb%5 !=0 && nR==5)
1558 {
1559 nReadOrb += NOrb%5;
1560 switch(NOrb%5)
1561 {
1562 case 1:
1563 fgets(t,taille,fd);
1564 sscanf(t,"%d",&NumOrb[0]);
1565 for(i=0;i<1;i++)
1566 NumOrb[i]--;
1567 if(itype<4)
1568 {
1569 fgets(t,taille,fd);
1570 sscanf(t,"%s",SymOrb[0]);
1571 if(strstr(SymOrb[0],"O"))
1572 NOcc++;
1573 SymOrbitals[NumOrb[0]] = get_sym_orb(SymOrb[0]);
1574 }
1575 else
1576 SymOrbitals[NumOrb[0]] = g_strdup("UNK");
1577
1578 fgets(t,taille,fd);
1579 sscanf(t,"%s %s %lf ",dump1,dump2,&EnerOrb[0]);
1580 EnerOrbitals[NumOrb[0]] = EnerOrb[0];
1581 if(itype>3)
1582 {
1583 for(i=0;i<1;i++)
1584 if(EnerOrb[i]>0)
1585 NOcc++;
1586 }
1587 for(i=0;i<NOrb;i++)
1588 {
1589 fgets(t,taille,fd);
1590 tmp = t + 20;
1591 k = sscanf(tmp,"%lf ",&CoefOrbitals[NumOrb[0]][i]);
1592 }
1593 break;
1594
1595 case 2:
1596 fgets(t,taille,fd);
1597 sscanf(t,"%d %d",&NumOrb[0],&NumOrb[1]);
1598 for(i=0;i<5;i++)
1599 NumOrb[i]--;
1600
1601 if(itype<4)
1602 {
1603 fgets(t,taille,fd);
1604 sscanf(t,"%s %s",SymOrb[0],SymOrb[1]);
1605 for(i=0;i<2;i++)
1606 if(strstr(SymOrb[i],"O"))
1607 NOcc++;
1608 for(i=0;i<2;i++)
1609 SymOrbitals[NumOrb[i]] = get_sym_orb(SymOrb[i]);
1610 }
1611 else
1612 {
1613 for(i=0;i<2;i++)
1614 SymOrbitals[NumOrb[i]] = g_utf8_strup("UNK");
1615 }
1616
1617 fgets(t,taille,fd);
1618 sscanf(t,"%s %s %lf %lf",dump1,dump2,&EnerOrb[0], &EnerOrb[1]);
1619 for(i=0;i<2;i++)
1620 EnerOrbitals[NumOrb[i]] = EnerOrb[i];
1621 if(itype>3)
1622 {
1623 for(i=0;i<2;i++)
1624 if(EnerOrb[i]>0)
1625 NOcc++;
1626 }
1627 for(i=0;i<NOrb;i++)
1628 {
1629 fgets(t,taille,fd);
1630 tmp = t + 20;
1631 k = sscanf(tmp,"%lf %lf ",&CoefOrbitals[NumOrb[0]][i],&CoefOrbitals[NumOrb[1]][i]);
1632 }
1633 break;
1634 case 3:
1635 fgets(t,taille,fd);
1636 sscanf(t,"%d %d %d",&NumOrb[0],&NumOrb[1],&NumOrb[2]);
1637 for(i=0;i<5;i++)
1638 NumOrb[i]--;
1639 if(itype<4)
1640 {
1641 fgets(t,taille,fd);
1642 sscanf(t,"%s %s %s",SymOrb[0],SymOrb[1],SymOrb[2]);
1643 for(i=0;i<3;i++)
1644 if(strstr(SymOrb[i],"O"))
1645 NOcc++;
1646 for(i=0;i<3;i++)
1647 SymOrbitals[NumOrb[i]] = get_sym_orb(SymOrb[i]);
1648 }
1649 else
1650 {
1651 for(i=0;i<3;i++)
1652 SymOrbitals[NumOrb[i]] = g_utf8_strup("UNK");
1653 }
1654
1655 fgets(t,taille,fd);
1656 sscanf(t,"%s %s %lf %lf %lf ",dump1,dump2,&EnerOrb[0], &EnerOrb[1], &EnerOrb[2]);
1657 for(i=0;i<3;i++)
1658 EnerOrbitals[NumOrb[i]] = EnerOrb[i];
1659 if(itype>3)
1660 {
1661 for(i=0;i<3;i++)
1662 if(EnerOrb[i]>0)
1663 NOcc++;
1664 }
1665 for(i=0;i<NOrb;i++)
1666 {
1667 fgets(t,taille,fd);
1668 tmp = t + 20;
1669 k = sscanf(tmp,"%lf %lf %lf ",&CoefOrbitals[NumOrb[0]][i],&CoefOrbitals[NumOrb[1]][i],&CoefOrbitals[NumOrb[2]][i]);
1670 }
1671 break;
1672 case 4:
1673 fgets(t,taille,fd);
1674 sscanf(t,"%d %d %d %d",&NumOrb[0],&NumOrb[1],&NumOrb[2],&NumOrb[3]);
1675 for(i=0;i<5;i++)
1676 NumOrb[i]--;
1677 if(itype<4)
1678 {
1679 fgets(t,taille,fd);
1680 sscanf(t,"%s %s %s %s",SymOrb[0],SymOrb[1],SymOrb[2],SymOrb[3]);
1681 for(i=0;i<4;i++)
1682 if(strstr(SymOrb[i],"O"))
1683 NOcc++;
1684 for(i=0;i<4;i++)
1685 SymOrbitals[NumOrb[i]] = get_sym_orb(SymOrb[i]);
1686 }
1687 else
1688 {
1689 for(i=0;i<4;i++)
1690 SymOrbitals[NumOrb[i]] = g_strdup("UNK");
1691 }
1692
1693 fgets(t,taille,fd);
1694 sscanf(t,"%s %s %lf %lf %lf %lf",dump1,dump2,
1695 &EnerOrb[0], &EnerOrb[1], &EnerOrb[2], &EnerOrb[3]);
1696 for(i=0;i<4;i++)
1697 EnerOrbitals[NumOrb[i]] = EnerOrb[i];
1698 if(itype>3)
1699 {
1700 for(i=0;i<4;i++)
1701 if(EnerOrb[i]>0)
1702 NOcc++;
1703 }
1704 for(i=0;i<NOrb;i++)
1705 {
1706 fgets(t,taille,fd);
1707 tmp = t + 20;
1708 k = sscanf(tmp,"%lf %lf %lf %lf",
1709 &CoefOrbitals[NumOrb[0]][i],&CoefOrbitals[NumOrb[1]][i],&CoefOrbitals[NumOrb[2]][i],&CoefOrbitals[NumOrb[3]][i]);
1710
1711 }
1712 }
1713
1714 }
1715 */
1716 }while(!feof(fd));
1717
1718 /* Debug("End of read \n"); */
1719 fclose(fd);
1720 g_free(t);
1721 for(i=0;i<5;i++)
1722 g_free(AtomCoord[i]);
1723
1724 CoefAlphaOrbitals = CoefOrbitals;
1725 EnerAlphaOrbitals = EnerOrbitals;
1726 return TRUE;
1727 }
1728 /********************************************************************************/
read_orbitals_in_gabedit_or_molden_file(gchar * fileName,gint itype)1729 gboolean read_orbitals_in_gabedit_or_molden_file(gchar *fileName,gint itype)
1730 {
1731 gchar *t;
1732 gboolean OK;
1733 gchar *AtomCoord[5];
1734 FILE *fd;
1735 gint taille=BSIZE;
1736 gint i;
1737 gint numorb;
1738 gchar *pdest;
1739 gint n = 0;
1740 gdouble **CoefOrbitals;
1741 gdouble *EnerOrbitals;
1742 gdouble *OccOrbitals;
1743 gchar **SymOrbitals;
1744 gint NOcc = 0;
1745 gint idump;
1746
1747
1748 if ((!fileName) || (strcmp(fileName,"") == 0))
1749 {
1750 Message(_("Sorry No file selected\n"),_("Error"),TRUE);
1751 return FALSE;
1752 }
1753
1754 t=g_malloc(taille);
1755 fd = FOpen(fileName, "rb");
1756 if(fd ==NULL)
1757 {
1758 gchar buffer[BSIZE];
1759 sprintf(buffer,_("Sorry, I can not open '%s' file\n"),fileName);
1760 Message(buffer,_("Error"),TRUE);
1761 return FALSE;
1762 }
1763
1764 for(i=0;i<5;i++)
1765 AtomCoord[i]=g_malloc(taille*sizeof(char));
1766
1767 CoefOrbitals = CreateTable2(NOrb);
1768 EnerOrbitals = g_malloc(NOrb*sizeof(gdouble));
1769 OccOrbitals = g_malloc(NOrb*sizeof(gdouble));
1770 SymOrbitals = g_malloc(NOrb*sizeof(gchar*));
1771
1772 /* printf(" NAOrb = %d\n",NOrb);*/
1773
1774 numorb =1;
1775 do
1776 {
1777 OK=FALSE;
1778 while(!feof(fd))
1779 {
1780 { char* e = fgets(t,taille,fd);}
1781 pdest = strstr( t, "[MO]" );
1782 if ( pdest != NULL )
1783 {
1784 numorb++;
1785 OK = TRUE;
1786 break;
1787 }
1788 }
1789 if(!OK && (numorb == 1) )
1790 {
1791 gchar buffer[BSIZE];
1792 sprintf(buffer,_("Sorry, I can not open '%s' file\n"),fileName);
1793 Message(buffer,_("Error"),TRUE);
1794 FreeTable2(CoefOrbitals,NOrb);
1795 g_free(EnerOrbitals);
1796 g_free(SymOrbitals);
1797 return FALSE;
1798 }
1799 if(!OK) goto end;
1800
1801 n = -1;
1802 while(!feof(fd))
1803 {
1804 gdouble e = 0.0;
1805 gdouble o = 0.0;
1806 gchar* begin = NULL;
1807 gchar* spin = NULL;
1808 gchar sym[BSIZE];
1809 gboolean begincoef = FALSE;
1810
1811 /*
1812 * Ene= -2.5353
1813 * Spin= Alpha
1814 * Occup= 2.000000
1815 */
1816 sym[0] = '\0';
1817 while(!feof(fd) && !begincoef)
1818 {
1819 { char* e = fgets(t,taille,fd);}
1820 if( this_is_a_backspace(t))
1821 {
1822 begincoef = FALSE;
1823 break;
1824 }
1825 if(atoi(t) != 0)
1826 {
1827 begincoef = TRUE;
1828 break;
1829 }
1830 begin = strstr(t,"=")+1;
1831 if(strstr(t,"Ene")!= 0) e = atof(begin);
1832 if( strstr(t,"Occ") != 0) o = atof(begin);
1833 if( strstr(t,"Spin") != 0) spin = g_strdup(begin);
1834 if( strstr(t,"Sym") != 0) sscanf(begin,"%s",sym);
1835 }
1836 if(!begincoef || feof(fd)) break;
1837 if(!spin) continue;
1838 if(strstr(spin,"Alpha") && itype == 2) continue;
1839 if(strstr(spin,"Beta") && itype == 1) continue;
1840
1841 n++;
1842 EnerOrbitals[n] = e;
1843 if(sym[0] != '\0') SymOrbitals[n] = g_strdup(sym);
1844 else SymOrbitals[n] = g_strdup(_("Unknown"));
1845
1846 OccOrbitals[n] = o;
1847
1848 if(o>0) NOcc++;
1849
1850 sscanf(t,"%d %lf",&idump,&CoefOrbitals[n][0]);
1851 for(i=1;i<NAOrb;i++)
1852 {
1853 { char* e = fgets(t,taille,fd);}
1854 sscanf(t,"%d %lf",&idump,&CoefOrbitals[n][i]);
1855 }
1856 if(n == NOrb-1) OK = FALSE;
1857 }
1858
1859 }while(!feof(fd));
1860
1861 end:
1862 /* Debug("End of read \n");*/
1863 fclose(fd);
1864 g_free(t);
1865 for(i=0;i<5;i++)
1866 g_free(AtomCoord[i]);
1867
1868 switch(itype)
1869 {
1870 case 1 :
1871 CoefAlphaOrbitals = CoefOrbitals;
1872 EnerAlphaOrbitals = EnerOrbitals;
1873 OccAlphaOrbitals = OccOrbitals;
1874 SymAlphaOrbitals = SymOrbitals;
1875 NAlphaOcc = NOcc;
1876 NAlphaOrb = n+1;
1877 break;
1878 case 2 :
1879 CoefBetaOrbitals = CoefOrbitals;
1880 EnerBetaOrbitals = EnerOrbitals;
1881 OccBetaOrbitals = OccOrbitals;
1882 SymBetaOrbitals = SymOrbitals;
1883 NBetaOcc = NOcc;
1884 NBetaOrb = n+1;
1885 break;
1886 case 3 :
1887 CoefAlphaOrbitals = CoefOrbitals;
1888 EnerAlphaOrbitals = EnerOrbitals;
1889 OccAlphaOrbitals = OccOrbitals;
1890 SymAlphaOrbitals = SymOrbitals;
1891 CoefBetaOrbitals = CoefOrbitals;
1892 EnerBetaOrbitals = EnerOrbitals;
1893 OccBetaOrbitals = OccOrbitals;
1894 SymBetaOrbitals = SymOrbitals;
1895 NAlphaOcc = NOcc;
1896 NBetaOcc = NOcc;
1897 NAlphaOrb = n+1;
1898 NBetaOrb = n+1;
1899 break;
1900 }
1901 if(n<0)
1902 return FALSE;
1903 else
1904 return TRUE;
1905 }
1906
1907 /********************************************************************************/
read_gauss_orbitals(gchar * FileName)1908 void read_gauss_orbitals(gchar* FileName)
1909 {
1910 gint typefile;
1911 gint typebasis;
1912 gboolean Ok = FALSE;
1913 gchar *t = NULL;
1914
1915
1916 typefile =get_type_file_orb(FileName);
1917 if(typefile==GABEDIT_TYPEFILE_UNKNOWN) return;
1918 if(typefile != GABEDIT_TYPEFILE_GAUSSIAN)
1919 {
1920 gchar buffer[BSIZE];
1921 sprintf(buffer,_("Sorry, I can not read this format in '%s' file\n"),FileName);
1922 Message(buffer,_("Error"),TRUE);
1923 return ;
1924 }
1925 free_data_all();
1926 t = get_name_file(FileName);
1927 set_status_label_info(_("File name"),t);
1928 g_free(t);
1929 set_status_label_info(_("File type"),"Gaussian");
1930 set_status_label_info(_("Mol. Orb."),_("Reading"));
1931
1932 free_orbitals();
1933 if(!gl_read_gaussn_file_geomi(FileName,-1))
1934 {
1935 set_status_label_info(_("File name"),_("Nothing"));
1936 set_status_label_info(_("File type"),_("Nothing"));
1937 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1938 return;
1939 }
1940
1941 set_status_label_info(_("Mol. Orb."),_("Reading"));
1942 InitializeAll();
1943 if(!DefineBasisType(FileName))
1944 {
1945 set_status_label_info(_("File name"),_("Nothing"));
1946 set_status_label_info(_("File type"),_("Nothing"));
1947 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1948 return;
1949 }
1950
1951 typebasis =get_type_basis_in_gaussian_file(FileName);
1952
1953 if(typebasis == 1)
1954 {
1955 DefineSphericalBasis();
1956 sphericalBasis = TRUE;
1957 }
1958 else
1959 {
1960 DefineCartBasis();
1961 sphericalBasis = FALSE;
1962 }
1963
1964 /* PrintAllBasis();*/
1965 NormaliseAllBasis();
1966 /* PrintAllBasis();*/
1967 DefineNOccs();
1968
1969
1970 Ok = read_last_orbitals_in_gaussian_file(FileName,1);
1971 if(Ok)
1972 {
1973 Ok = read_last_orbitals_in_gaussian_file(FileName,2);
1974 }
1975 else
1976 {
1977 Ok = read_last_orbitals_in_gaussian_file(FileName,3);
1978 }
1979 if(!Ok)
1980 Ok = read_last_orbitals_in_gaussian_file(FileName,4); /* Natural Orbitals */
1981 if(Ok)
1982 {
1983 /* PrintAllOrb(CoefAlphaOrbitals);*/
1984 set_status_label_info(_("Mol. Orb."),_("Ok"));
1985 glarea_rafresh(GLArea); /* for geometry*/
1986 NumSelOrb = NAlphaOcc-1;
1987 create_list_orbitals();
1988 }
1989 else
1990 {
1991 set_status_label_info(_("File name"),_("Nothing"));
1992 set_status_label_info(_("File type"),_("Nothing"));
1993 set_status_label_info(_("Mol. Orb."),_("Nothing"));
1994 }
1995
1996 }
1997 /********************************************************************************/
read_orbitals_from_fchk_gaussian_file(gchar * fileName)1998 gboolean read_orbitals_from_fchk_gaussian_file(gchar* fileName)
1999 {
2000 FILE* file;
2001 file = FOpen(fileName, "rb");
2002 gdouble* coefsAlpha = NULL;
2003 gdouble* coefsBeta = NULL;
2004 gdouble* energiesAlpha = NULL;
2005 gdouble* energiesBeta = NULL;
2006 gint nA = 0;
2007 gint nAOcc = 0;
2008 gint nB = 0;
2009 gint nBOcc = 0;
2010 gint nBasis;
2011 gint n,i,k,ib;
2012 if(file ==NULL)
2013 {
2014 Message(_("Sorry\nI can not open this file"),_("Error"),TRUE);
2015 return FALSE;
2016 }
2017 nAOcc = get_one_int_from_fchk_gaussian_file(file,"Number of alpha electrons ");
2018 nBOcc = get_one_int_from_fchk_gaussian_file(file,"Number of beta electrons ");
2019 /* printf("nBOcc=%d\n",nBOcc);*/
2020 nBasis = get_one_int_from_fchk_gaussian_file(file,"Number of basis functions ");
2021 if(nBasis<1)
2022 {
2023 Message(_("Sorry\nI can not read the number of basis functions"),_("Error"),TRUE);
2024 fclose(file);
2025 return FALSE;
2026 }
2027 energiesAlpha = get_array_real_from_fchk_gaussian_file(file, "Alpha Orbital Energies ", &nA);
2028 if(energiesAlpha)
2029 {
2030 coefsAlpha = get_array_real_from_fchk_gaussian_file(file, "Alpha MO coefficients ", &n);
2031 if(!coefsAlpha || n!=nBasis*nA)
2032 {
2033 Message(_("Sorry\nI can not read the alpha MO coefficients"),_("Error"),TRUE);
2034 if(energiesAlpha) g_free(energiesAlpha);
2035 if(coefsAlpha) g_free(coefsAlpha);
2036 fclose(file);
2037 return FALSE;
2038 }
2039 }
2040 rewind(file);
2041 energiesBeta = get_array_real_from_fchk_gaussian_file(file, "Beta Orbital Energies ", &nB);
2042 if(energiesBeta)
2043 {
2044 coefsBeta = get_array_real_from_fchk_gaussian_file(file, "Beta MO coefficients ", &n);
2045 if(!coefsBeta || n!=nBasis*nB)
2046 {
2047 Message(_("Sorry\nI can not read the alpha MO coefficients"),_("Error"),TRUE);
2048 if(energiesBeta) g_free(energiesBeta);
2049 if(coefsBeta) g_free(coefsBeta);
2050 fclose(file);
2051 return FALSE;
2052 }
2053 }
2054 fclose(file);
2055 NAlphaOcc = 0;
2056 NAlphaOrb = 0;
2057 NBetaOcc = 0;
2058 NBetaOrb = 0;
2059 NTotOcc = NOrb;
2060
2061 if(coefsAlpha && energiesAlpha && nA>0 && nA<=nBasis)
2062 {
2063 EnerAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2064 for(i=0;i<nA;i++) EnerAlphaOrbitals[i] = energiesAlpha[i];
2065 for(i=nA;i<NOrb;i++) EnerAlphaOrbitals[i] = 0.0;
2066
2067 CoefAlphaOrbitals = CreateTable2(NOrb);
2068
2069 k = 0;
2070 for(i=0;i<nA;i++)
2071 for(ib=0;ib<nA;ib++)
2072 CoefAlphaOrbitals[i][ib] = coefsAlpha[k++];
2073 for(i=nA;i<NOrb;i++)
2074 for(ib=0;ib<nA;ib++)
2075 CoefAlphaOrbitals[i][ib] = 0;
2076
2077 SymAlphaOrbitals = g_malloc(NOrb*sizeof(gchar*));
2078 for(i=0;i<nA;i++) SymAlphaOrbitals[i] = g_strdup("UNK");
2079 for(i=nA;i<NOrb;i++) SymAlphaOrbitals[i] = g_strdup("DELETE");
2080
2081 OccAlphaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2082 for(i=0;i<nAOcc;i++) OccAlphaOrbitals[i] = 1.0;
2083 for(i=nAOcc;i<NOrb;i++) OccAlphaOrbitals[i] = 0.0;
2084 NAlphaOcc = nAOcc;
2085 NAlphaOrb = nA;
2086 if(!energiesBeta && !coefsBeta && nB == 0 && nBOcc==nAOcc)
2087 {
2088 CoefBetaOrbitals = CoefAlphaOrbitals;
2089 EnerBetaOrbitals = EnerAlphaOrbitals;
2090 OccBetaOrbitals = OccAlphaOrbitals;
2091 SymBetaOrbitals = SymAlphaOrbitals;
2092 NBetaOcc = nAOcc;
2093 NBetaOrb = nA;
2094 }
2095 }
2096 if(coefsBeta && energiesBeta && nB>0 && nB<=nBasis)
2097 {
2098 EnerBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2099 for(i=0;i<nB;i++) EnerBetaOrbitals[i] = energiesBeta[i];
2100 for(i=nB;i<NOrb;i++) EnerBetaOrbitals[i] = 0.0;
2101
2102 CoefBetaOrbitals = CreateTable2(NOrb);
2103
2104 k = 0;
2105 for(i=0;i<nB;i++)
2106 for(ib=0;ib<nB;ib++)
2107 CoefBetaOrbitals[i][ib] = coefsBeta[k++];
2108 for(i=nB;i<NOrb;i++)
2109 for(ib=0;ib<nB;ib++)
2110 CoefBetaOrbitals[i][ib] = 0;
2111
2112 SymBetaOrbitals = g_malloc(NOrb*sizeof(gchar*));
2113 for(i=0;i<nB;i++) SymBetaOrbitals[i] = g_strdup("UNK");
2114 for(i=nB;i<NOrb;i++) SymBetaOrbitals[i] = g_strdup("DELETE");
2115
2116 OccBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2117 for(i=0;i<nBOcc;i++) OccBetaOrbitals[i] = 1.0;
2118 for(i=nBOcc;i<NOrb;i++) OccBetaOrbitals[i] = 0.0;
2119 NBetaOcc = nBOcc;/* bug fixed 03 Sep 2012 */
2120 NBetaOrb = nB;
2121 if(!energiesAlpha && !coefsAlpha && nA == 0 && nBOcc==nAOcc)
2122 {
2123 CoefAlphaOrbitals = CoefBetaOrbitals;
2124 EnerAlphaOrbitals = EnerBetaOrbitals;
2125 OccAlphaOrbitals = OccBetaOrbitals;
2126 SymAlphaOrbitals = SymBetaOrbitals;
2127 NAlphaOcc = nAOcc;
2128 NAlphaOrb = nB;
2129 }
2130 }
2131 if(energiesAlpha) g_free(energiesAlpha);
2132 if(coefsAlpha) g_free(coefsAlpha);
2133 if(energiesBeta) g_free(energiesBeta);
2134 if(coefsBeta) g_free(coefsBeta);
2135 NTotOcc = NOrb;
2136 return TRUE;
2137 }
2138 /********************************************************************************/
read_fchk_gauss_orbitals(gchar * fileName)2139 void read_fchk_gauss_orbitals(gchar* fileName)
2140 {
2141 gint typefile;
2142 gchar *t = NULL;
2143
2144
2145 typefile =get_type_file_orb(fileName);
2146 if(typefile==GABEDIT_TYPEFILE_UNKNOWN) return;
2147 if(typefile != GABEDIT_TYPEFILE_GAUSSIAN_FCHK)
2148 {
2149 gchar buffer[BSIZE];
2150 sprintf(buffer,_("Sorry, I can not read this format in '%s' file\n"),fileName);
2151 Message(buffer,_("Error"),TRUE);
2152 return ;
2153 }
2154 free_data_all();
2155 t = get_name_file(fileName);
2156 set_status_label_info(_("File name"),t);
2157 g_free(t);
2158 set_status_label_info(_("File type"),"Gaussian fchk");
2159 set_status_label_info(_("Mol. Orb."),_("Reading"));
2160
2161 free_orbitals();
2162 if(!gl_read_fchk_gaussn_file_geom(fileName))
2163 {
2164 set_status_label_info(_("File name"),_("Nothing"));
2165 set_status_label_info(_("File type"),_("Nothing"));
2166 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2167 return;
2168 }
2169
2170 set_status_label_info(_("Mol. Orb."),_("Reading"));
2171 InitializeAll();
2172 if(!readBasisFromGaussianFChk(fileName))
2173 {
2174 set_status_label_info(_("File name"),_("Nothing"));
2175 set_status_label_info(_("File type"),_("Nothing"));
2176 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2177 return;
2178 }
2179
2180 sphericalBasis = TRUE; /* Can be also cart or mixed */
2181 NormaliseAllBasis();
2182 if(read_orbitals_from_fchk_gaussian_file(fileName))
2183 {
2184 /* PrintAllOrb(CoefAlphaOrbitals);*/
2185 set_status_label_info(_("Mol. Orb."),_("Ok"));
2186 glarea_rafresh(GLArea); /* for geometry*/
2187 NumSelOrb = NAlphaOcc-1;
2188 create_list_orbitals();
2189 }
2190 else
2191 {
2192 set_status_label_info(_("File name"),_("Nothing"));
2193 set_status_label_info(_("File type"),_("Nothing"));
2194 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2195 }
2196 }
2197 /********************************************************************************/
read_gabedit_orbitals(gchar * FileName)2198 void read_gabedit_orbitals(gchar* FileName)
2199 {
2200 gint i;
2201 gint typefile;
2202 gint typebasis;
2203 gboolean OkAlpha = FALSE;
2204 gboolean OkBeta = FALSE;
2205 gchar* t = NULL;
2206
2207 typefile =get_type_file_orb(FileName);
2208
2209 if(typefile==GABEDIT_TYPEFILE_UNKNOWN)
2210 return;
2211
2212 if(typefile != GABEDIT_TYPEFILE_GABEDIT)
2213 {
2214 Message(_("Sorry, This file is not in Gabedit Format\n"),_("Error"),TRUE);
2215 return ;
2216 }
2217 free_data_all();
2218 t = get_name_file(FileName);
2219 set_status_label_info(_("File name"),t);
2220 g_free(t);
2221 set_status_label_info(_("File type"),"Gabedit");
2222 set_status_label_info(_("Mol. Orb."),_("Reading"));
2223 free_orbitals();
2224 if(!gl_read_gabedit_file_geom(FileName))
2225 {
2226 set_status_label_info(_("File name"),_("Nothing"));
2227 set_status_label_info(_("File type"),_("Nothing"));
2228 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2229 return;
2230 }
2231 InitializeAll();
2232 if(!DefineGabeditBasisType(FileName))
2233 {
2234 set_status_label_info(_("File name"),_("Nothing"));
2235 set_status_label_info(_("File type"),_("Nothing"));
2236 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2237 return;
2238 }
2239
2240 typebasis =get_type_basis_in_gabedit_file(FileName);
2241 if(typebasis == 1)
2242 {
2243 DefineSphericalBasis();
2244 sphericalBasis = TRUE;
2245 }
2246 else
2247 {
2248 DefineCartBasis();
2249 sphericalBasis = FALSE;
2250 }
2251 NormaliseAllBasis();
2252 /* PrintAllBasis();*/
2253
2254 DefineNOccs();
2255
2256 OkBeta = read_orbitals_in_gabedit_or_molden_file(FileName,2);/* if beta orbital*/
2257 OkAlpha = read_orbitals_in_gabedit_or_molden_file(FileName,1);
2258 if(!OkBeta && OkAlpha)
2259 {
2260 CoefBetaOrbitals = CoefAlphaOrbitals;
2261 EnerBetaOrbitals = EnerAlphaOrbitals;
2262 SymBetaOrbitals = SymAlphaOrbitals;
2263 NBetaOrb = NAlphaOrb;
2264
2265 OccBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2266 NBetaOcc = 0;
2267 for(i=0;i<NBetaOrb;i++)
2268 {
2269 if(OccAlphaOrbitals[i]>1.0)
2270 {
2271 NBetaOcc++;
2272 OccBetaOrbitals[i] = OccAlphaOrbitals[i]/2;
2273 OccAlphaOrbitals[i] = OccBetaOrbitals[i];
2274 }
2275 else
2276 OccBetaOrbitals[i] = 0.0;
2277 }
2278 if(NBetaOrb>0)
2279 OkBeta = TRUE;
2280 }
2281 if(OkAlpha || OkBeta)
2282 {
2283 read_gabedit_atomic_orbitals(FileName);
2284 set_status_label_info(_("Mol. Orb."),_("Ok"));
2285 glarea_rafresh(GLArea); /* for geometry*/
2286 NumSelOrb = NAlphaOcc-1;
2287 create_list_orbitals();
2288 }
2289 else
2290 {
2291 set_status_label_info(_("File name"),_("Nothing"));
2292 set_status_label_info(_("File type"),_("Nothing"));
2293 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2294 }
2295 DefineType();
2296 }
2297 /********************************************************************************/
read_molden_orbitals(gchar * FileName)2298 void read_molden_orbitals(gchar* FileName)
2299 {
2300 gint i;
2301 gint typefile;
2302 gint typebasis;
2303 gboolean OkAlpha = FALSE;
2304 gboolean OkBeta = FALSE;
2305 gchar *t = NULL;
2306
2307 typefile =get_type_file_orb(FileName);
2308
2309 if(typefile==GABEDIT_TYPEFILE_UNKNOWN)
2310 return;
2311 if(typefile != GABEDIT_TYPEFILE_MOLDEN)
2312 {
2313 Message(_("Sorry, This file is not in Molden Format\n"),_("Error"),TRUE);
2314 return ;
2315 }
2316 free_data_all();
2317 t = get_name_file(FileName);
2318 set_status_label_info(_("File name"),t);
2319 g_free(t);
2320 set_status_label_info(_("File type"),"Molden");
2321 set_status_label_info(_("Mol. Orb."),_("Reading"));
2322
2323 free_orbitals();
2324 if(!gl_read_molden_file_geom(FileName))
2325 {
2326 set_status_label_info(_("File name"),_("Nothing"));
2327 set_status_label_info(_("File type"),_("Nothing"));
2328 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2329 return;
2330 }
2331
2332 InitializeAll();
2333 if(!DefineMoldenBasisType(FileName))
2334 {
2335 set_status_label_info(_("File name"),_("Nothing"));
2336 set_status_label_info(_("File type"),_("Nothing"));
2337 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2338 return;
2339 }
2340 /*
2341 Debug("End define Basis Type NAOrb = %d \n",NAOrb);
2342 PrintBasis();
2343 Debug("End Print Basis\n");
2344 */
2345
2346 typebasis =get_type_basis_in_molden_file(FileName);
2347 /* printf("typebasis = %d\n",typebasis);*/
2348 if(typebasis == 1)
2349 {
2350 DefineSphericalBasis();
2351 sphericalBasis = TRUE;
2352 }
2353 else
2354 {
2355 DefineCartBasis();
2356 sphericalBasis = FALSE;
2357 }
2358
2359 /* Debug("End DefineBasis\n");*/
2360
2361 /* PrintAllBasis();*/
2362
2363 NormaliseAllBasis();
2364 /* Debug("Basis after normalisation\n");*/
2365 /* PrintAllBasis();*/
2366 /* Debug("Spherical basis(Norb=%d)\n",NAOrb);*/
2367 DefineNOccs();
2368
2369
2370 OkBeta = read_orbitals_in_gabedit_or_molden_file(FileName,2);/* if beta orbital*/
2371 /* Debug("Ok = %d\n",Ok);*/
2372 OkAlpha = read_orbitals_in_gabedit_or_molden_file(FileName,1);
2373 if(!OkBeta && OkAlpha)
2374 {
2375 CoefBetaOrbitals = CoefAlphaOrbitals;
2376 EnerBetaOrbitals = EnerAlphaOrbitals;
2377 SymBetaOrbitals = SymAlphaOrbitals;
2378 NBetaOrb = NAlphaOrb;
2379
2380 OccBetaOrbitals = g_malloc(NOrb*sizeof(gdouble));
2381 NBetaOcc = 0;
2382 for(i=0;i<NBetaOrb;i++)
2383 {
2384 if(OccAlphaOrbitals[i]>1.0)
2385 {
2386 NBetaOcc++;
2387 OccBetaOrbitals[i] = OccAlphaOrbitals[i]/2;
2388 OccAlphaOrbitals[i] = OccBetaOrbitals[i];
2389 }
2390 else
2391 OccBetaOrbitals[i] = 0.0;
2392 }
2393 if(NBetaOrb>0)
2394 OkBeta = TRUE;
2395 }
2396 /* Debug("NA = %d\n",NAlphaOcc);*/
2397 /* Debug("NB = %d\n",NBetaOcc);*/
2398 if(OkBeta || OkAlpha)
2399 {
2400 /*
2401 PrintAllOrb(CoefAlphaOrbitals);
2402 Debug("End Orb\n");
2403 */
2404 set_status_label_info(_("Mol. Orb."),_("Ok"));
2405 glarea_rafresh(GLArea); /* for geometry */
2406 NumSelOrb = NAlphaOcc-1;
2407 /* Debug("NumSelOrb = %d\n",NumSelOrb);*/
2408 create_list_orbitals();
2409 }
2410 else
2411 {
2412 set_status_label_info(_("File name"),_("Nothing"));
2413 set_status_label_info(_("File type"),_("Nothing"));
2414 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2415 }
2416 DefineType();
2417
2418 }
2419 /********************************************************************************/
read_wfx_orbitals(gchar * fileName)2420 void read_wfx_orbitals(gchar* fileName)
2421 {
2422 gint typefile;
2423 gchar *t = NULL;
2424
2425
2426 typefile =get_type_file_orb(fileName);
2427 if(typefile==GABEDIT_TYPEFILE_UNKNOWN) return;
2428 if(typefile != GABEDIT_TYPEFILE_WFX)
2429 {
2430 gchar buffer[BSIZE];
2431 sprintf(buffer,_("Sorry, I cannot read this format in '%s' file\n"),fileName);
2432 Message(buffer,_("Error"),TRUE);
2433 return ;
2434 }
2435 free_data_all();
2436 t = get_name_file(fileName);
2437 set_status_label_info(_("File name"),t);
2438 g_free(t);
2439 set_status_label_info(_("File type"),"Gaussian fchk");
2440 set_status_label_info(_("Mol. Orb."),_("Reading"));
2441
2442 free_orbitals();
2443 if(!gl_read_wfx_file_geom(fileName))
2444 {
2445 set_status_label_info(_("File name"),_("Nothing"));
2446 set_status_label_info(_("File type"),_("Nothing"));
2447 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2448 return;
2449 }
2450
2451 set_status_label_info(_("Mol. Orb."),_("Reading"));
2452 InitializeAll();
2453 if(!readBasisFromWFX(fileName))
2454 {
2455 set_status_label_info(_("File name"),_("Nothing"));
2456 set_status_label_info(_("File type"),_("Nothing"));
2457 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2458 return;
2459 }
2460
2461 sphericalBasis = FALSE; /* Can be also cart or mixed */
2462 //NormaliseAllBasis();
2463 if(read_orbitals_from_wfx_file(fileName))
2464 {
2465 /* PrintAllOrb(CoefAlphaOrbitals);*/
2466 set_status_label_info(_("Mol. Orb."),_("Ok"));
2467 glarea_rafresh(GLArea); /* for geometry*/
2468 NumSelOrb = NAlphaOcc-1;
2469 create_list_orbitals();
2470 }
2471 else
2472 {
2473 set_status_label_info(_("File name"),_("Nothing"));
2474 set_status_label_info(_("File type"),_("Nothing"));
2475 set_status_label_info(_("Mol. Orb."),_("Nothing"));
2476 }
2477 DefineType();
2478 }
2479 /********************************************************************************/
read_dalton_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2480 void read_dalton_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2481 {
2482 /* gchar *FileName;*/
2483
2484 if(response_id != GTK_RESPONSE_OK) return;
2485 /* FileName = gabedit_file_chooser_get_current_file(SelecFile);*/
2486 gtk_widget_hide(GTK_WIDGET(SelecFile));
2487 while( gtk_events_pending() ) gtk_main_iteration();
2488
2489 add_objects_for_new_grid();
2490 /* read_dalton_orbitals(FileName);*/
2491 }
2492 /********************************************************************************/
read_gamess_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2493 void read_gamess_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2494 {
2495 gchar *FileName;
2496
2497 if(response_id != GTK_RESPONSE_OK) return;
2498 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2499 gtk_widget_hide(GTK_WIDGET(SelecFile));
2500 while( gtk_events_pending() ) gtk_main_iteration();
2501
2502 add_objects_for_new_grid();
2503 read_gamess_orbitals(FileName);
2504 }
2505 /********************************************************************************/
read_nbo_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2506 void read_nbo_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2507 {
2508 gchar *FileName;
2509
2510 if(response_id != GTK_RESPONSE_OK) return;
2511 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2512 gtk_widget_hide(GTK_WIDGET(SelecFile));
2513 while( gtk_events_pending() ) gtk_main_iteration();
2514
2515 add_objects_for_new_grid();
2516 read_nbo_orbitals(FileName);
2517 }
2518 /********************************************************************************/
2519 /********************************************************************************/
read_orca_orbitals_sel_2mkl(GabeditFileChooser * SelecFile,gint response_id)2520 void read_orca_orbitals_sel_2mkl(GabeditFileChooser *SelecFile, gint response_id)
2521 {
2522 gchar *fileName;
2523
2524 if(response_id != GTK_RESPONSE_OK) return;
2525 fileName = gabedit_file_chooser_get_current_file(SelecFile);
2526 gtk_widget_hide(GTK_WIDGET(SelecFile));
2527 while( gtk_events_pending() ) gtk_main_iteration();
2528
2529 add_objects_for_new_grid();
2530 read_orca_orbitals_using_orca_2mkl(fileName);
2531 }
2532 /********************************************************************************/
read_orca_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2533 void read_orca_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2534 {
2535 gchar *fileName;
2536
2537 if(response_id != GTK_RESPONSE_OK) return;
2538 fileName = gabedit_file_chooser_get_current_file(SelecFile);
2539 gtk_widget_hide(GTK_WIDGET(SelecFile));
2540 while( gtk_events_pending() ) gtk_main_iteration();
2541
2542 add_objects_for_new_grid();
2543 read_orca_orbitals_from_output_file(fileName);
2544 }
2545 /********************************************************************************/
read_qchem_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2546 void read_qchem_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2547 {
2548 gchar *FileName;
2549
2550 if(response_id != GTK_RESPONSE_OK) return;
2551 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2552 gtk_widget_hide(GTK_WIDGET(SelecFile));
2553 while( gtk_events_pending() ) gtk_main_iteration();
2554
2555 add_objects_for_new_grid();
2556 read_qchem_orbitals(FileName);
2557 }
2558 /********************************************************************************/
read_nwchem_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2559 void read_nwchem_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2560 {
2561 gchar *FileName;
2562
2563 if(response_id != GTK_RESPONSE_OK) return;
2564 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2565 gtk_widget_hide(GTK_WIDGET(SelecFile));
2566 while( gtk_events_pending() ) gtk_main_iteration();
2567
2568 add_objects_for_new_grid();
2569 read_nwchem_orbitals(FileName);
2570 }
2571 /********************************************************************************/
read_mopac_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2572 void read_mopac_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2573 {
2574 gchar *FileName;
2575
2576 if(response_id != GTK_RESPONSE_OK) return;
2577 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2578 gtk_widget_hide(GTK_WIDGET(SelecFile));
2579 while( gtk_events_pending() ) gtk_main_iteration();
2580
2581 add_objects_for_new_grid();
2582 read_mopac_orbitals(FileName);
2583 }
2584 /********************************************************************************/
read_gauss_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2585 void read_gauss_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2586 {
2587 gchar *FileName;
2588
2589 if(response_id != GTK_RESPONSE_OK) return;
2590 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2591 gtk_widget_hide(GTK_WIDGET(SelecFile));
2592 while( gtk_events_pending() )
2593 gtk_main_iteration();
2594
2595 add_objects_for_new_grid();
2596 read_gauss_orbitals(FileName);
2597 }
2598 /********************************************************************************/
read_fchk_gauss_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2599 void read_fchk_gauss_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2600 {
2601 gchar *FileName;
2602
2603 if(response_id != GTK_RESPONSE_OK) return;
2604 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2605 gtk_widget_hide(GTK_WIDGET(SelecFile));
2606 while( gtk_events_pending() ) gtk_main_iteration();
2607
2608 add_objects_for_new_grid();
2609 read_fchk_gauss_orbitals(FileName);
2610 }
2611 /********************************************************************************/
read_molpro_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2612 void read_molpro_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2613 {
2614 gchar *FileName;
2615
2616 if(response_id != GTK_RESPONSE_OK) return;
2617 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2618 gtk_widget_hide(GTK_WIDGET(SelecFile));
2619 while( gtk_events_pending() )
2620 gtk_main_iteration();
2621
2622 add_objects_for_new_grid();
2623 read_molpro_orbitals(FileName);
2624 sphericalBasis = TRUE;
2625 }
2626 /********************************************************************************/
read_gabedit_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2627 void read_gabedit_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2628 {
2629 gchar *FileName;
2630
2631 if(response_id != GTK_RESPONSE_OK) return;
2632 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2633 gtk_widget_hide(GTK_WIDGET(SelecFile));
2634 while( gtk_events_pending() )
2635 gtk_main_iteration();
2636
2637 add_objects_for_new_grid();
2638 read_gabedit_orbitals(FileName);
2639 }
2640 /********************************************************************************/
save_gabedit_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2641 void save_gabedit_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2642 {
2643 gchar *FileName;
2644
2645 if(response_id != GTK_RESPONSE_OK) return;
2646 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2647 gtk_widget_hide(GTK_WIDGET(SelecFile));
2648 while( gtk_events_pending() )
2649 gtk_main_iteration();
2650
2651 save_gabedit_orbitals(FileName);
2652 }
2653 /********************************************************************************/
save_wfx_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2654 void save_wfx_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2655 {
2656 gchar *fileName;
2657
2658 if(response_id != GTK_RESPONSE_OK) return;
2659 fileName = gabedit_file_chooser_get_current_file(SelecFile);
2660 gtk_widget_hide(GTK_WIDGET(SelecFile));
2661 while( gtk_events_pending() ) gtk_main_iteration();
2662
2663 export_to_wfx_file(fileName, -1, 0, 1);
2664 }
2665 /********************************************************************************/
read_molden_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2666 void read_molden_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2667 {
2668 gchar *FileName;
2669
2670 if(response_id != GTK_RESPONSE_OK) return;
2671 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2672 gtk_widget_hide(GTK_WIDGET(SelecFile));
2673 while( gtk_events_pending() )
2674 gtk_main_iteration();
2675
2676 add_objects_for_new_grid();
2677 read_molden_orbitals(FileName);
2678 }
2679 /********************************************************************************/
read_wfx_orbitals_sel(GabeditFileChooser * SelecFile,gint response_id)2680 void read_wfx_orbitals_sel(GabeditFileChooser *SelecFile, gint response_id)
2681 {
2682 gchar *FileName;
2683
2684 if(response_id != GTK_RESPONSE_OK) return;
2685 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2686 gtk_widget_hide(GTK_WIDGET(SelecFile));
2687 while( gtk_events_pending() )
2688 gtk_main_iteration();
2689
2690 add_objects_for_new_grid();
2691 read_wfx_orbitals(FileName);
2692 }
2693
2694 /*******************************************************/
read_orbitals(gchar * fileName)2695 gboolean read_orbitals(gchar* fileName)
2696 {
2697 GabEditTypeFile fileType = get_type_file(fileName);
2698 if(fileType == GABEDIT_TYPEFILE_GAMESS) read_gamess_orbitals(fileName);
2699 else if(fileType == GABEDIT_TYPEFILE_FIREFLY) read_gamess_orbitals(fileName);
2700 else if(fileType == GABEDIT_TYPEFILE_GAUSSIAN) read_gauss_orbitals(fileName);
2701 else if(fileType == GABEDIT_TYPEFILE_GAUSSIAN_FCHK) read_fchk_gauss_orbitals(fileName);
2702 else if(fileType == GABEDIT_TYPEFILE_MOLPRO) read_molpro_orbitals(fileName);
2703 else if(fileType == GABEDIT_TYPEFILE_MOPAC) read_mopac_orbitals(fileName);
2704 else if(fileType == GABEDIT_TYPEFILE_MOPAC_AUX) read_mopac_orbitals(fileName);
2705 else if(fileType == GABEDIT_TYPEFILE_ORCA) read_orca_orbitals_from_output_file(fileName);
2706 else if(fileType == GABEDIT_TYPEFILE_NWCHEM) read_nwchem_orbitals(fileName);
2707 else if(fileType == GABEDIT_TYPEFILE_QCHEM) read_qchem_orbitals(fileName);
2708 else if(fileType == GABEDIT_TYPEFILE_GABEDIT) read_gabedit_orbitals(fileName);
2709 else if(fileType == GABEDIT_TYPEFILE_MOLDEN) read_molden_orbitals(fileName);
2710 else if(fileType == GABEDIT_TYPEFILE_UNKNOWN)
2711 {
2712 Message(
2713 _("Sorry, I cannot find the type of your file\n")
2714 ," Error ",TRUE);
2715 return FALSE;
2716 }
2717 return TRUE;
2718 }
2719 /*************************************************************************/
read_orbitals_sel(GabeditFileChooser * selecFile,gint response_id)2720 void read_orbitals_sel(GabeditFileChooser *selecFile, gint response_id)
2721 {
2722 gchar *fileName;
2723
2724 if(response_id != GTK_RESPONSE_OK) return;
2725 fileName = gabedit_file_chooser_get_current_file(selecFile);
2726 gtk_widget_hide(GTK_WIDGET(selecFile));
2727 while( gtk_events_pending() ) gtk_main_iteration();
2728
2729 add_objects_for_new_grid();
2730 read_orbitals(fileName);
2731 }
2732