1 /* DeMonKeywords.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 <stdlib.h>
21 #include <ctype.h>
22 #include <math.h>
23 #include <string.h>
24
25 #include "../../Config.h"
26 #include "../Common/Global.h"
27 #include "../DeMon/DeMonTypes.h"
28 #include "../DeMon/DeMonGlobal.h"
29 #include "../DeMon/DeMonMolecule.h"
30 #include "../DeMon/DeMonBasis.h"
31 #include "../DeMon/DeMonGuess.h"
32 #include "../Utils/Utils.h"
33 #include "../Utils/UtilsInterface.h"
34 #include "../Utils/GabeditTextEdit.h"
35 #include "../Common/Windows.h"
36 #include "../Utils/Constants.h"
37
38 static GtkWidget* comboSCF = NULL;
39 static GtkWidget* combovxc = NULL;
40 static GtkWidget* comboMethod = NULL;
41 static GtkWidget* comboTypeMethod = NULL;
42 static GtkWidget* comboExcited = NULL;
43 static GtkWidget* combotight = NULL;
44 static GtkWidget* combogrid = NULL;
45 static GtkWidget* combodiis = NULL;
46 static GtkWidget* entryShift = NULL;
47 static GtkWidget* entryMixing = NULL;
48 static GtkWidget* entryscfmaxit = NULL;
49 static void setDeMonMethods();
50 /*************************************************************************************************************/
51 static gchar* listJobView[] = {
52 "Single Point Energy",
53 "Geometry optimization",
54 "Frequencies",
55 "Frequencies + Thermo",
56 "Transition state",
57 "Equilibrium structure search + Frequencies",
58 "Equilibrium structure search + Frequencies + Thermo",
59 "Transition state + Frequencies",
60 };
61 static gchar* listJobReal[] = {
62 "SP",
63 "Optimization\n",
64 "Frequencies\n",
65 "Frequencies\nThermo\n",
66 "OptTS\n",
67 "Optimization\nFrequencies\n",
68 "Optimization\nFrequencies\nThermo\n",
69 "OptTS NumFreq\n",
70 };
71 static guint numberOfJobs = G_N_ELEMENTS (listJobView);
72 static gchar selectedJob[BSIZE]="SP";
73 /*************************************************************************************************************/
74 static gchar* listSCFView[] = { "default","unrestricted", "restricted"};
75 static gchar* listSCFReal[] = { "DEF", "TRUE", "FALSE"};
76 static guint numberOfSCF = G_N_ELEMENTS (listSCFView);
77 static gchar selectedSCF[BSIZE]="DEF";
78 /*************************************************************************************************************/
79 static gchar* listtightView[] = {
80 "Tighten : Default",
81 "No Tighten : The SCF convergence criteria will not be adjusted during an optimization. ",
82 };
83 static gchar* listtightReal[] = {
84 "NONE",
85 "NOTIGHTEN",
86 };
87 static guint numberOftight = G_N_ELEMENTS (listtightView);
88 static gchar selectedtight[BSIZE]="NONE";
89 /*************************************************************************************************************/
90 static gchar* listvxcView[] = {
91 "AUXIS : Default. The auxiliary function density is used for the calculation of the exchange-correlation energy and matrix elements of the potential.",
92 "BASIS : The orbital density is used for the calculation of the exchange-correlation energy and matrix elements of the potential.",
93 };
94 static gchar* listvxcReal[] = {
95 "AUXIS",
96 "BASIS",
97 };
98 static guint numberOfvxc = G_N_ELEMENTS (listvxcView);
99 static gchar selectedvxc[BSIZE]="AUXIS";
100 /*************************************************************************************************************/
101 static gchar* listdiisView[] = {
102 "ON : Default. The DIIS procedure is switched on.",
103 "OFF : The DIIS procedure is switched off. ",
104 };
105 static gchar* listdiisReal[] = {
106 "NONE",
107 "DIIS OFF \n",
108 };
109 static guint numberOfdiis = G_N_ELEMENTS (listdiisView);
110 static gchar selecteddiis[BSIZE]="NONE";
111 /*************************************************************************************************************/
112 static gchar* listTypeMethodsView[] =
113 {
114 "Local and gradient corrected functionals",
115 "Hybrid functionals",
116 "Meta-GGA and hybrid meta-GGA's",
117 };
118 static gchar* listTypeMethodsReal[] =
119 {
120 "DFT",
121 "Hybrid",
122 "Meta-GGA",
123 };
124 static guint numberOfTypeMethods = G_N_ELEMENTS (listTypeMethodsView);
125 static gchar selectedTypeMethod[BSIZE]="HF";
126 /*************************************************************************************************************/
127 static gchar* listHFMethodsView[] =
128 {
129 "HF",
130 };
131 static gchar* listHFMethodsReal[] =
132 {
133 "HF",
134 };
135 static guint numberOfHFMethods = G_N_ELEMENTS (listHFMethodsView);
136 /*************************************************************************************************************/
137
138 static gchar* listDFTMethodsView[] =
139 {
140 "VWN Dirac exchange with local VWN correlation.",
141 "PZ81 Dirac exchange with local PZ81 correlation.",
142 "PW92 Dirac exchange with local PW92 correlation.",
143 "PW86 PW86 GGA exchange with P86 GGA correlation.",
144 "BLYP B88 GGA exchange with LYP GGA correlation.",
145 "OLYP HC01 GGA exchange with LYP GGA correlation.",
146 "PW91 PW91 GGA exchange and correlation.",
147 "PW91SSF PW91 with full spin scaling function.",
148 "PBE PBE GGA exchange and correlation.",
149 "PBESSF PBE with full spin scaling function.",
150 "PBESOL PBE GGA exchange and correlation for solids.",
151 "XALPHA X_alpha calculation."
152 };
153 static gchar* listDFTMethodsReal[] =
154 {
155 "VWN\n",
156 "PZ81\n",
157 "PW92\n",
158 "PW86\n",
159 "BLYP\n",
160 "OLYP\n",
161 "PW91\n",
162 "PW91SSF\n",
163 "PBE\n",
164 "PBESSF\n",
165 "PBESOL\n",
166 "XALPHA\n",
167 };
168 static guint numberOfDFTMethods = G_N_ELEMENTS (listDFTMethodsView);
169 /*************************************************************************************************************/
170 static gchar* listHybridMethodsView[] =
171 {
172 "B3LYP The popular B3LYP functional (20% HF exchange)",
173 "M06L Minnesota Functional ver.6 (local functional, 0% HF exchange) (BASIS ONLY)",
174 "M06 Minnesota Functional ver.6 (Global hybrid functional, 27% HF exchange) (BASIS ONLY)",
175 "M062X Minnesota Functional ver.6 (Global hybrid functional, 54% HF exchange) (BASIS ONLY)",
176 "M06HF Minnesota Functional ver.6 (Global hybrid functional, 100% HF exchange) (BASIS ONLY)",
177 "M11L Minnesota Functional ver.11 (local functional, 0% HF exchange) (BASIS ONLY)",
178 "MN12 Minnesota Functional ver.12 (local functional, 0% HF exchange) (BASIS ONLY)",
179 };
180 static gchar* listHybridMethodsReal[] =
181 {
182 "B3LYP\n",
183 "M06L\n",
184 "M06\n",
185 "M062X\n",
186 "M06HF\n",
187 "M11L\n",
188 "MN12\n",
189
190 };
191 static guint numberOfHybridMethods = G_N_ELEMENTS (listHybridMethodsView);
192 /*************************************************************************************************************/
193 static gchar* listMetaGGAMethodsView[] =
194 {
195 "PKZB PKZB meta-GGA exchange and correlation. (BASIS ONLY)",
196 "TPSS TPSS meta-GGA exchange and correlation. (BASIS ONLY)",
197 };
198 static gchar* listMetaGGAMethodsReal[] =
199 {
200 "PKZB\n",
201 "TPSS\n",
202 };
203 static guint numberOfMetaGGAMethods = G_N_ELEMENTS (listMetaGGAMethodsView);
204 /*************************************************************************************************************/
205 static gchar* listDHybridMethodsView[] =
206 {
207 "B2PLYP The new mixture of MP2 and DFT from Grimme",
208 "RI-B2PLYP B2PLYP with RI applied to the MP2 part",
209 };
210 static gchar* listDHybridMethodsReal[] =
211 {
212 "B2PLYP",
213 "RI-B2PLYP",
214 };
215 static guint numberOfDHybridMethods = G_N_ELEMENTS (listDHybridMethodsView);
216 /*************************************************************************************************************/
217 static gchar* listMP2MethodsView[] =
218 {
219 "MP2",
220 "RI-MP2",
221 };
222 static gchar* listMP2MethodsReal[] =
223 {
224 "MP2",
225 "RI-MP2",
226 };
227 static guint numberOfMP2Methods = G_N_ELEMENTS (listMP2MethodsView);
228 /*************************************************************************************************************/
229 static gchar* listHighLevelSingleRefMethodsView[] =
230 {
231 "CCSD Coupled cluster singles and doubles",
232 "CCSD(T) Same with perturbative triples correction",
233 };
234 static gchar* listHighLevelSingleRefMethodsReal[] =
235 {
236 "CCSD",
237 "CCSD(T)",
238 };
239 static guint numberOfHighLevelSingleRefMethods = G_N_ELEMENTS (listHighLevelSingleRefMethodsView);
240 /*************************************************************************************************************/
241 static gchar* listSemiEmpMethodsView[] =
242 {
243 "AM1",
244 "PM3",
245 };
246 static gchar* listSemiEmpMethodsReal[] =
247 {
248 "AM1",
249 "PM3",
250 };
251 static guint numberOfSemiEmpMethods = G_N_ELEMENTS (listSemiEmpMethodsView);
252 /*************************************************************************************************************/
253 static gchar selectedMethod[BSIZE]="HF";
254 static gchar** listMethodsView = listHybridMethodsView;
255 static gchar** listMethodsReal = listHybridMethodsReal;
256 static guint numberOfMethods = G_N_ELEMENTS (listHybridMethodsView);
257 /*************************************************************************************************************/
258 static gchar* listScfConvergenceView[] = {
259 "Default",
260 "LooseSCF : loose SCF convergence",
261 "TightSCF : tight SCF convergence",
262 "VeryTightSCF :very tight SCF convergence",
263 };
264 static gchar* listScfConvergenceReal[] = {
265 "NONE",
266 "TOL=1.E-6",
267 "TOL=1.E-8",
268 "TOL=1.E-10",
269
270 };
271 static guint numberOfScfConvergence = G_N_ELEMENTS (listScfConvergenceView);
272 static gchar selectedScfConvergence[BSIZE]="NONE";
273 /*************************************************************************************************************/
274 static gchar* listgridView[] = {
275 "Adaptive : Default",
276 "Medium : Medium grid accuracy is requested",
277 "Coarse : Coarse grid accuracy is requested.",
278 "Fine : Fine grid accuracy is requested.",
279 };
280 static gchar* listgridReal[] = {
281 "NONE",
282 "GRID FIXED MEDIUM\n",
283 "GRID FIXED COARSE\n",
284 "GRID FIXED FINE\n",
285
286 };
287 static guint numberOfgrid = G_N_ELEMENTS (listgridView);
288 static gchar selectedgrid[BSIZE]="NONE";
289 /*************************************************************************************************************/
290 static gchar* listNothingExcitedView[] =
291 {
292 "Nothing",
293 };
294 static gchar* listNothingExcitedReal[] =
295 {
296 "NONE",
297 };
298 static guint numberOfNothingExcited = G_N_ELEMENTS (listNothingExcitedView);
299 /*************************************************************************************************************/
300 static gchar* listSemiEmpExcitedView[] =
301 {
302 "Nothing",
303 "CIS",
304 };
305 static gchar* listSemiEmpExcitedReal[] =
306 {
307 "NONE",
308 "CIS",
309 };
310 static guint numberOfSemiEmpExcited = G_N_ELEMENTS (listSemiEmpExcitedView);
311 /*************************************************************************************************************/
312 static gchar* listHFExcitedView[] =
313 {
314 "Nothing",
315 "CIS",
316 "CIS(D)",
317 };
318 static gchar* listHFExcitedReal[] =
319 {
320 "NONE",
321 "CIS",
322 "CIS(D)",
323 };
324 static guint numberOfHFExcited = G_N_ELEMENTS (listHFExcitedView);
325 /*************************************************************************************************************/
326 static gchar* listDFTExcitedView[] =
327 {
328 "Nothing",
329 "TD-DFT",
330 };
331 static gchar* listDFTExcitedReal[] =
332 {
333 "NONE",
334 "TD-DFT",
335 };
336 static guint numberOfDFTExcited = G_N_ELEMENTS (listDFTExcitedView);
337 /*************************************************************************************************************/
338 static gchar selectedExcited[BSIZE]="NONE";
339 static gchar** listExcitedView = listNothingExcitedView;
340 static gchar** listExcitedReal = listNothingExcitedReal;
341 static guint numberOfExcited = G_N_ELEMENTS (listNothingExcitedView);
342 /*************************************************************************************************************/
putDeMonExcitedInfoInTextEditor()343 static void putDeMonExcitedInfoInTextEditor()
344 {
345 gchar buffer[BSIZE];
346 if(!strcmp(selectedExcited,"NONE"))return;
347 sprintf(buffer,"Excitation ");
348 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, buffer, -1);
349
350 /*
351 sprintf(buffer," nroots %d # the number of excited states to be calculated.\n",8);
352 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
353 sprintf(buffer," maxdim %d # the maximum dimension of the expansion space in the Davidson procedure.\n",30);
354 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
355 */
356 sprintf(buffer," # TDA TammDanCoff true Tamm-Dancoff approximation for non-hybride\n");
357 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
358 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n",-1);
359 }
360 /*************************************************************************************************************/
setDeMonExcited()361 static void setDeMonExcited()
362 {
363 GtkTreeIter iter;
364 GtkTreeIter iter0;
365 gint i;
366
367 if(strcmp(selectedTypeMethod,"HF")==0)
368 {
369 listExcitedView = listHFExcitedView;
370 listExcitedReal = listHFExcitedReal;
371 numberOfExcited = numberOfHFExcited;
372 }
373 else
374 if(strcmp(selectedTypeMethod,"DFT")==0)
375 {
376 listExcitedView = listDFTExcitedView;
377 listExcitedReal = listDFTExcitedReal;
378 numberOfExcited = numberOfDFTExcited;
379 }
380 else
381 if(strcmp(selectedTypeMethod,"Hybrid")==0)
382 {
383 listExcitedView = listDFTExcitedView;
384 listExcitedReal = listDFTExcitedReal;
385 numberOfExcited = numberOfDFTExcited;
386 }
387 else
388 if(strcmp(selectedTypeMethod,"Meta-GGA")==0)
389 {
390 listExcitedView = listDFTExcitedView;
391 listExcitedReal = listDFTExcitedReal;
392 numberOfExcited = numberOfDFTExcited;
393 }
394 else
395 if(strcmp(selectedTypeMethod,"D-Hybrid")==0)
396 {
397 listExcitedView = listDFTExcitedView;
398 listExcitedReal = listDFTExcitedReal;
399 numberOfExcited = numberOfDFTExcited;
400 }
401 else
402 if(strcmp(selectedTypeMethod,"SemiEmp")==0 && strstr(selectedMethod,"/S"))
403 {
404 listExcitedView = listSemiEmpExcitedView;
405 listExcitedReal = listSemiEmpExcitedReal;
406 numberOfExcited = numberOfSemiEmpExcited;
407 }
408 else
409 {
410 listExcitedView = listNothingExcitedView;
411 listExcitedReal = listNothingExcitedReal;
412 numberOfExcited = numberOfNothingExcited;
413 }
414
415 if (comboExcited && gtk_combo_box_get_active_iter (GTK_COMBO_BOX(comboExcited), &iter))
416 {
417 GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(comboExcited));
418 GtkTreeStore *store = GTK_TREE_STORE(model);
419 gtk_tree_store_clear(store);
420
421 for(i=0;i<numberOfExcited;i++)
422 {
423 gtk_tree_store_append (store, &iter, NULL);
424 if(i==0) iter0 = iter;
425 gtk_tree_store_set (store, &iter, 0, listExcitedView[i], -1);
426 }
427 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (comboExcited), &iter0);
428 }
429
430 }
431 /************************************************************************************************************/
traitementExcited(GtkComboBox * combobox,gpointer d)432 static void traitementExcited (GtkComboBox *combobox, gpointer d)
433 {
434 GtkTreeIter iter;
435 gchar* data = NULL;
436 gchar* res = NULL;
437 gint i;
438 gboolean ri = FALSE;
439 GtkWidget* wid;
440
441 if (gtk_combo_box_get_active_iter (combobox, &iter))
442 {
443 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
444 gtk_tree_model_get (model, &iter, 0, &data, -1);
445 }
446 else return;
447 for(i=0;i<numberOfExcited;i++)
448 {
449 if(strcmp((gchar*)data,listExcitedView[i])==0) res = listExcitedReal[i];
450 }
451 if(res) sprintf(selectedExcited,"%s",res);
452 ri = !strcmp(selectedExcited,"CIS(D)");
453 if(strstr(selectedExcited,"TD") && !strcmp(selectedTypeMethod,"D-Hybrid"))
454 {
455 ri = TRUE;
456 }
457 if(!strstr(selectedExcited,"NONE"))
458 {
459 wid = g_object_get_data(G_OBJECT (combobox), "LabelAuxBasis1");
460 if(wid) gtk_widget_set_sensitive(wid, ri);
461 wid = g_object_get_data(G_OBJECT (combobox), "LabelAuxBasis2");
462 if(wid) gtk_widget_set_sensitive(wid, ri);
463 wid = g_object_get_data(G_OBJECT (combobox), "ComboAuxBasis");
464 if(wid) gtk_widget_set_sensitive(wid, ri);
465 }
466 }
467 /********************************************************************************************************/
create_list_excited()468 static GtkWidget *create_list_excited()
469 {
470 GtkTreeIter iter;
471 GtkTreeStore *store;
472 GtkTreeModel *model;
473 GtkWidget *combobox;
474 GtkCellRenderer *renderer;
475 gint i;
476 GtkTreeIter iter0;
477
478 store = gtk_tree_store_new (1,G_TYPE_STRING);
479
480
481 for(i=0;i<numberOfExcited;i++)
482 {
483 gtk_tree_store_append (store, &iter, NULL);
484 if(i==0) iter0 = iter;
485 gtk_tree_store_set (store, &iter, 0, listExcitedView[i], -1);
486 }
487
488 model = GTK_TREE_MODEL (store);
489 combobox = gtk_combo_box_new_with_model (model);
490 /*
491 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
492 */
493 g_object_unref (model);
494 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementExcited), NULL);
495 renderer = gtk_cell_renderer_text_new ();
496 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
497 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
498
499 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
500
501 return combobox;
502 }
503 /********************************************************************************************************/
treatmenttight(GtkComboBox * combobox,gpointer d)504 static void treatmenttight (GtkComboBox *combobox, gpointer d)
505 {
506 GtkTreeIter iter;
507 gchar* data = NULL;
508 gchar* res = NULL;
509 gint i;
510
511
512 /* gchar* s;*/
513 if (gtk_combo_box_get_active_iter (combobox, &iter))
514 {
515 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
516 gtk_tree_model_get (model, &iter, 0, &data, -1);
517 }
518 for(i=0;i<numberOftight;i++)
519 {
520 if(strcmp((gchar*)data,listtightView[i])==0) res = listtightReal[i];
521 }
522 if(res) sprintf(selectedtight,"%s",res);
523 else sprintf(selectedtight,"NONE");
524
525 }
526 /********************************************************************************************************/
traitementScfConvergence(GtkComboBox * combobox,gpointer d)527 static void traitementScfConvergence (GtkComboBox *combobox, gpointer d)
528 {
529 GtkTreeIter iter;
530 gchar* data = NULL;
531 gchar* res = NULL;
532 gint i;
533
534
535 /* gchar* s;*/
536 if (gtk_combo_box_get_active_iter (combobox, &iter))
537 {
538 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
539 gtk_tree_model_get (model, &iter, 0, &data, -1);
540 }
541 for(i=0;i<numberOfScfConvergence;i++)
542 {
543 if(strcmp((gchar*)data,listScfConvergenceView[i])==0) res = listScfConvergenceReal[i];
544 }
545 if(res) sprintf(selectedScfConvergence,"%s",res);
546 else sprintf(selectedScfConvergence,"Default");
547
548 }
549 /********************************************************************************************************/
create_list_tight()550 static GtkWidget *create_list_tight()
551 {
552 GtkTreeIter iter;
553 GtkTreeStore *store;
554 GtkTreeModel *model;
555 GtkWidget *combobox;
556 GtkCellRenderer *renderer;
557 gint i;
558 GtkTreeIter iter0;
559
560 store = gtk_tree_store_new (1,G_TYPE_STRING);
561
562 for(i=0;i<numberOftight;i++)
563 {
564 gtk_tree_store_append (store, &iter, NULL);
565 if(i==0) iter0 = iter;
566 gtk_tree_store_set (store, &iter, 0, listtightView[i], -1);
567 }
568
569 model = GTK_TREE_MODEL (store);
570 combobox = gtk_combo_box_new_with_model (model);
571 /*
572 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
573 */
574 g_object_unref (model);
575 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(treatmenttight), NULL);
576 renderer = gtk_cell_renderer_text_new ();
577 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
578 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
579
580 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
581
582 return combobox;
583 }
584 /************************************************************************************************************/
addDeMontightToTable(GtkWidget * table,gint i)585 GtkWidget* addDeMontightToTable(GtkWidget *table, gint i)
586 {
587 GtkWidget* combotight = NULL;
588
589
590 add_label_table(table,_("SCF Tighten"),(gushort)i,0);
591 add_label_table(table,":",(gushort)i,1);
592 combotight = create_list_tight();
593
594 return combotight;
595 }
596 /************************************************************************************************************/
create_list_scfconvergence()597 static GtkWidget *create_list_scfconvergence()
598 {
599 GtkTreeIter iter;
600 GtkTreeStore *store;
601 GtkTreeModel *model;
602 GtkWidget *combobox;
603 GtkCellRenderer *renderer;
604 gint i;
605 GtkTreeIter iter0;
606
607 store = gtk_tree_store_new (1,G_TYPE_STRING);
608
609 for(i=0;i<numberOfScfConvergence;i++)
610 {
611 gtk_tree_store_append (store, &iter, NULL);
612 if(i==0) iter0 = iter;
613 gtk_tree_store_set (store, &iter, 0, listScfConvergenceView[i], -1);
614 }
615
616 model = GTK_TREE_MODEL (store);
617 combobox = gtk_combo_box_new_with_model (model);
618 /*
619 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
620 */
621 g_object_unref (model);
622 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementScfConvergence), NULL);
623 renderer = gtk_cell_renderer_text_new ();
624 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
625 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
626
627 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
628
629 return combobox;
630 }
631 /************************************************************************************************************/
addDeMonScfConvergenceToTable(GtkWidget * table,gint i)632 GtkWidget* addDeMonScfConvergenceToTable(GtkWidget *table, gint i)
633 {
634 GtkWidget* comboScfConvergence = NULL;
635
636
637 add_label_table(table,_("SCF convergence"),(gushort)i,0);
638 add_label_table(table,":",(gushort)i,1);
639 comboScfConvergence = create_list_scfconvergence();
640
641 return comboScfConvergence;
642 }
643 /*************************************************************************************************************/
treatmentdiis(GtkComboBox * combobox,gpointer d)644 static void treatmentdiis (GtkComboBox *combobox, gpointer d)
645 {
646 GtkTreeIter iter;
647 gchar* data = NULL;
648 gchar* res = NULL;
649 gint i;
650
651
652 /* gchar* s;*/
653 if (gtk_combo_box_get_active_iter (combobox, &iter))
654 {
655 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
656 gtk_tree_model_get (model, &iter, 0, &data, -1);
657 }
658 for(i=0;i<numberOfdiis;i++)
659 {
660 if(strcmp((gchar*)data,listdiisView[i])==0) res = listdiisReal[i];
661 }
662 if(res) sprintf(selecteddiis,"%s",res);
663 else sprintf(selecteddiis,"Default");
664
665 }
666 /********************************************************************************************************/
create_list_diis()667 static GtkWidget *create_list_diis()
668 {
669 GtkTreeIter iter;
670 GtkTreeStore *store;
671 GtkTreeModel *model;
672 GtkWidget *combobox;
673 GtkCellRenderer *renderer;
674 gint i;
675 GtkTreeIter iter0;
676
677 store = gtk_tree_store_new (1,G_TYPE_STRING);
678
679 for(i=0;i<numberOfdiis;i++)
680 {
681 gtk_tree_store_append (store, &iter, NULL);
682 if(i==0) iter0 = iter;
683 gtk_tree_store_set (store, &iter, 0, listdiisView[i], -1);
684 }
685
686 model = GTK_TREE_MODEL (store);
687 combobox = gtk_combo_box_new_with_model (model);
688 /*
689 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
690 */
691 g_object_unref (model);
692 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(treatmentdiis), NULL);
693 renderer = gtk_cell_renderer_text_new ();
694 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
695 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
696
697 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
698
699 return combobox;
700 }
701 /************************************************************************************************************/
addDeMondiisToTable(GtkWidget * table,gint i)702 GtkWidget* addDeMondiisToTable(GtkWidget *table, gint i)
703 {
704 GtkWidget* combodiis = NULL;
705
706
707 add_label_table(table,_("DIIS"),(gushort)i,0);
708 add_label_table(table,":",(gushort)i,1);
709 combodiis = create_list_diis();
710
711 return combodiis;
712 }
713 /*************************************************************************************************************/
treatmentgrid(GtkComboBox * combobox,gpointer d)714 static void treatmentgrid (GtkComboBox *combobox, gpointer d)
715 {
716 GtkTreeIter iter;
717 gchar* data = NULL;
718 gchar* res = NULL;
719 gint i;
720
721
722 /* gchar* s;*/
723 if (gtk_combo_box_get_active_iter (combobox, &iter))
724 {
725 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
726 gtk_tree_model_get (model, &iter, 0, &data, -1);
727 }
728 for(i=0;i<numberOfgrid;i++)
729 {
730 if(strcmp((gchar*)data,listgridView[i])==0) res = listgridReal[i];
731 }
732 if(res) sprintf(selectedgrid,"%s",res);
733 else sprintf(selectedgrid,"Default");
734
735 }
736 /********************************************************************************************************/
create_list_grid()737 static GtkWidget *create_list_grid()
738 {
739 GtkTreeIter iter;
740 GtkTreeStore *store;
741 GtkTreeModel *model;
742 GtkWidget *combobox;
743 GtkCellRenderer *renderer;
744 gint i;
745 GtkTreeIter iter0;
746
747 store = gtk_tree_store_new (1,G_TYPE_STRING);
748
749 for(i=0;i<numberOfgrid;i++)
750 {
751 gtk_tree_store_append (store, &iter, NULL);
752 if(i==0) iter0 = iter;
753 gtk_tree_store_set (store, &iter, 0, listgridView[i], -1);
754 }
755
756 model = GTK_TREE_MODEL (store);
757 combobox = gtk_combo_box_new_with_model (model);
758 /*
759 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
760 */
761 g_object_unref (model);
762 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(treatmentgrid), NULL);
763 renderer = gtk_cell_renderer_text_new ();
764 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
765 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
766
767 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
768
769 return combobox;
770 }
771 /************************************************************************************************************/
addDeMongridToTable(GtkWidget * table,gint i)772 GtkWidget* addDeMongridToTable(GtkWidget *table, gint i)
773 {
774 GtkWidget* combogrid = NULL;
775
776
777 add_label_table(table,_("Grid"),(gushort)i,0);
778 add_label_table(table,":",(gushort)i,1);
779 combogrid = create_list_grid();
780
781 return combogrid;
782 }
783 /*************************************************************************************************************/
calculWord(gchar * view)784 static gchar* calculWord(gchar* view)
785 {
786 gint i;
787 for(i=0;i<numberOfJobs;i++)
788 {
789 if(strcmp(view,listJobView[i])==0)return listJobReal[i];
790 }
791 return NULL;
792 }
793 /*************************************************************************************************************/
putDeMonJobTypeInfoInTextEditor()794 static void putDeMonJobTypeInfoInTextEditor()
795 {
796 if(!strcmp(selectedJob,"SP"))return;
797 else
798 {
799 gchar buffer[BSIZE];
800 sprintf(buffer,"%s",selectedJob);
801 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, buffer, -1);
802 }
803 }
804 /*************************************************************************************************************/
putDeMonSCFKeywordsInfoInTextEditor()805 static void putDeMonSCFKeywordsInfoInTextEditor()
806 {
807 G_CONST_RETURN gchar *entrytext1;
808 gint maxit=100;
809 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, "SCFTYP ", -1);
810
811 if(strcmp(selectedSCF,"DEF"))
812 {
813 //if(!strcmp(selectedSCF,"TRUE"))
814 if(strcmp(selectedSCF,"TRUE"))
815 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "R",-1);
816 else
817 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "U",-1);
818 if(
819 !strcmp(selectedTypeMethod,"DFT")
820 || !strcmp(selectedTypeMethod,"Hybrid")
821 || !strcmp(selectedTypeMethod,"Meta-GGA")
822 || !strcmp(selectedTypeMethod,"D-Hybrid")
823 )
824 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "KS ",-1);
825 else
826 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "HF ",-1);
827
828 }
829 if( strcmp(selectedScfConvergence,"NONE")!=0 )
830 {
831 gchar buffer[BSIZE];
832 sprintf(buffer,"%s ",selectedScfConvergence);
833 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
834 }
835 if( strcmp(selectedtight,"NONE")!=0 )
836 {
837 gchar buffer[BSIZE];
838 sprintf(buffer,"%s ",selectedtight);
839 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
840 }
841 entrytext1 = gtk_entry_get_text(GTK_ENTRY(entryscfmaxit));
842 maxit=atoi(entrytext1);
843 if (maxit==0)maxit=100;
844 gchar buffer[BSIZE];
845 sprintf(buffer,"MAX=%d ",maxit);
846 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
847 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n",-1);
848 }
849 /************************************************************************************************************/
putDeMonDiisInfoInTextEditor()850 static void putDeMonDiisInfoInTextEditor()
851 {
852 if( strcmp(selecteddiis,"NONE")==0 ) return;
853 {
854 gchar buffer[BSIZE];
855 sprintf(buffer,"%s",selecteddiis);
856 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
857 }
858 }
859 /************************************************************************************************************/
putDeMonGridInfoInTextEditor()860 static void putDeMonGridInfoInTextEditor()
861 {
862 if( strcmp(selectedgrid,"NONE")==0 ) return;
863 {
864 gchar buffer[BSIZE];
865 sprintf(buffer,"%s",selectedgrid);
866 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
867 }
868 }
869 /************************************************************************************************************/
putDeMonMethodInfoInTextEditor()870 static void putDeMonMethodInfoInTextEditor()
871 {
872 gchar buffer[BSIZE];
873 sprintf(buffer,"%s",selectedMethod);
874 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, buffer,-1);
875 }
876 /************************************************************************************************************/
putDeMonvxcInfoInTextEditor()877 static void putDeMonvxcInfoInTextEditor()
878 {
879 gchar buffer[BSIZE];
880 sprintf(buffer,"%s",selectedvxc);
881 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, "VXCTYP ", -1);
882 if( strcmp(selectedvxc,"AUXIS")==0 )
883 {
884 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "AUXIS ",-1);
885 gchar buffer[BSIZE];
886 sprintf(buffer,"%s",selectedMethod);
887 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, buffer,-1);
888 }
889 else
890 {
891 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "BASIS ",-1);
892 gchar buffer[BSIZE];
893 sprintf(buffer,"%s",selectedMethod);
894 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, buffer,-1);
895 }
896 }
897 /*************************************************************************************************************/
putDeMonShiftInfoInTextEditor()898 void putDeMonShiftInfoInTextEditor()
899 {
900 G_CONST_RETURN gchar *entrytext;
901 gfloat shift=0.0;
902 entrytext = gtk_entry_get_text(GTK_ENTRY(entryShift));
903 shift=atof(entrytext);
904 if (shift!=0)
905 {
906 gchar buffer[BSIZE];
907 sprintf(buffer,"SHIFT %f \n",shift);
908 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
909 }
910 }
911 /*************************************************************************************************************/
putDeMonMixingInfoInTextEditor()912 void putDeMonMixingInfoInTextEditor()
913 {
914 G_CONST_RETURN gchar *entrytext;
915 gfloat mixing=-0.3;
916 entrytext = gtk_entry_get_text(GTK_ENTRY(entryMixing));
917 mixing=atof(entrytext);
918 if (mixing!=0)
919 {
920 gchar buffer[BSIZE];
921 sprintf(buffer,"MIXING %f \n",mixing);
922 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
923 }
924 }
925 /*************************************************************************************************************/
putDeMonKeywordsInfoInTextEditor()926 void putDeMonKeywordsInfoInTextEditor()
927 {
928 //gabedit_text_insert (GABEDIT_TEXT(text), NULL, &demonColorFore.keyWord, &demonColorBack.keyWord, "! ",-1);
929 putDeMonJobTypeInfoInTextEditor();
930 putDeMonSCFKeywordsInfoInTextEditor();
931 putDeMonvxcInfoInTextEditor();
932 putDeMonDiisInfoInTextEditor();
933 putDeMonShiftInfoInTextEditor();
934 putDeMonMixingInfoInTextEditor();
935 putDeMonGridInfoInTextEditor();
936 putDeMonGuessInfoInTextEditor();
937 putDeMonBasisInfoInTextEditor();
938 putDeMonAuxBasisInTextEditor();
939 putDeMonExcitedInfoInTextEditor();
940 }
941 /************************************************************************************************************/
traitementJobType(GtkComboBox * combobox,gpointer d)942 static void traitementJobType (GtkComboBox *combobox, gpointer d)
943 {
944 GtkTreeIter iter;
945 gchar* data = NULL;
946 gchar* res = NULL;
947
948 if (gtk_combo_box_get_active_iter (combobox, &iter))
949 {
950 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
951 gtk_tree_model_get (model, &iter, 0, &data, -1);
952 }
953 else return;
954 res = calculWord(data);
955 if(res) sprintf(selectedJob,"%s",res);
956 else sprintf(selectedJob,"SP");
957
958 }
959 /********************************************************************************************************/
create_list_jobtype()960 static GtkWidget *create_list_jobtype()
961 {
962 GtkTreeIter iter;
963 GtkTreeStore *store;
964 GtkTreeModel *model;
965 GtkWidget *combobox;
966 GtkCellRenderer *renderer;
967 gint i;
968 GtkTreeIter iter0;
969
970 store = gtk_tree_store_new (1,G_TYPE_STRING);
971
972 for(i=0;i<numberOfJobs;i++)
973 {
974 gtk_tree_store_append (store, &iter, NULL);
975 if(i==0) iter0 = iter;
976 gtk_tree_store_set (store, &iter, 0, listJobView[i], -1);
977 }
978
979 model = GTK_TREE_MODEL (store);
980 combobox = gtk_combo_box_new_with_model (model);
981 /*
982 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
983 */
984 g_object_unref (model);
985 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementJobType), NULL);
986 renderer = gtk_cell_renderer_text_new ();
987 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
988 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
989
990 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
991
992 return combobox;
993 }
994 /************************************************************************************************************/
setDeMonSCFMethod(gboolean okRHF)995 void setDeMonSCFMethod(gboolean okRHF)
996 {
997 GtkTreeIter iter;
998 GtkTreeIter iter0;
999 gint i;
1000 /* gchar* s;*/
1001 if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(comboSCF), &iter))
1002 {
1003 GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(comboSCF));
1004 GtkTreeStore *store = GTK_TREE_STORE(model);
1005 gint k = 0;
1006 gtk_tree_store_clear(store);
1007 for(i=0;i<numberOfSCF;i++)
1008 {
1009 if(!okRHF)
1010 if(strcmp(listSCFView[i],"restricted")==0)continue;
1011 gtk_tree_store_append (store, &iter, NULL);
1012 if(k==0) iter0 = iter;
1013 k++;
1014 gtk_tree_store_set (store, &iter, 0, listSCFView[i], -1);
1015 }
1016 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (comboSCF), &iter0);
1017 }
1018 }
1019 /************************************************************************************************************/
traitementSCF(GtkComboBox * combobox,gpointer d)1020 static void traitementSCF (GtkComboBox *combobox, gpointer d)
1021 {
1022 GtkTreeIter iter;
1023 gchar* data = NULL;
1024 gchar* res = NULL;
1025 gint i;
1026 /* gchar* s;*/
1027 if (gtk_combo_box_get_active_iter (combobox, &iter))
1028 {
1029 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
1030 gtk_tree_model_get (model, &iter, 0, &data, -1);
1031 }
1032 else return;
1033 for(i=0;i<numberOfSCF;i++)
1034 {
1035 if(strcmp((gchar*)data,listSCFView[i])==0) res = listSCFReal[i];
1036 }
1037 if(res) sprintf(selectedSCF,"%s",res);
1038 else sprintf(selectedSCF,"DEF");
1039
1040 }
1041 /********************************************************************************************************/
treatmentvxc(GtkComboBox * combobox,gpointer d)1042 static void treatmentvxc (GtkComboBox *combobox, gpointer d)
1043 {
1044 GtkTreeIter iter;
1045 gchar* data = NULL;
1046 gchar* res = NULL;
1047 gint i;
1048
1049
1050 /* gchar* s;*/
1051 if (gtk_combo_box_get_active_iter (combobox, &iter))
1052 {
1053 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
1054 gtk_tree_model_get (model, &iter, 0, &data, -1);
1055 }
1056 for(i=0;i<numberOfvxc;i++)
1057 {
1058 if(strcmp((gchar*)data,listvxcView[i])==0) res = listvxcReal[i];
1059 }
1060 if(res) sprintf(selectedvxc,"%s",res);
1061 else sprintf(selectedvxc,"Default");
1062
1063 }
1064 /********************************************************************************************************/
create_list_vxc()1065 static GtkWidget *create_list_vxc()
1066 {
1067 GtkTreeIter iter;
1068 GtkTreeStore *store;
1069 GtkTreeModel *model;
1070 GtkWidget *combobox;
1071 GtkCellRenderer *renderer;
1072 gint i;
1073 GtkTreeIter iter0;
1074
1075 store = gtk_tree_store_new (1,G_TYPE_STRING);
1076
1077 for(i=0;i<numberOfvxc;i++)
1078 {
1079 gtk_tree_store_append (store, &iter, NULL);
1080 if(i==0) iter0 = iter;
1081 gtk_tree_store_set (store, &iter, 0, listvxcView[i], -1);
1082 }
1083
1084 model = GTK_TREE_MODEL (store);
1085 combobox = gtk_combo_box_new_with_model (model);
1086 /*
1087 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1088 */
1089 g_object_unref (model);
1090 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(treatmentvxc), NULL);
1091 renderer = gtk_cell_renderer_text_new ();
1092 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1093 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
1094
1095 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
1096
1097 return combobox;
1098 }
1099 /************************************************************************************************************/
addDeMonvxcToTable(GtkWidget * table,gint i)1100 GtkWidget* addDeMonvxcToTable(GtkWidget *table, gint i)
1101 {
1102 GtkWidget* combovxc = NULL;
1103
1104
1105 add_label_table(table,_("VXCTYP"),(gushort)i,0);
1106 add_label_table(table,":",(gushort)i,1);
1107 combovxc = create_list_vxc();
1108
1109 return combovxc;
1110 }
1111 /************************************************************************************************************/
create_list_scf()1112 static GtkWidget *create_list_scf()
1113 {
1114 GtkTreeIter iter;
1115 GtkTreeStore *store;
1116 GtkTreeModel *model;
1117 GtkWidget *combobox;
1118 GtkCellRenderer *renderer;
1119 gint i;
1120 GtkTreeIter iter0;
1121
1122 store = gtk_tree_store_new (1,G_TYPE_STRING);
1123
1124 for(i=0;i<numberOfSCF;i++)
1125 {
1126 gtk_tree_store_append (store, &iter, NULL);
1127 if(i==0) iter0 = iter;
1128 gtk_tree_store_set (store, &iter, 0, listSCFView[i], -1);
1129 }
1130
1131 model = GTK_TREE_MODEL (store);
1132 combobox = gtk_combo_box_new_with_model (model);
1133 /*
1134 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1135 */
1136 g_object_unref (model);
1137 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementSCF), NULL);
1138 renderer = gtk_cell_renderer_text_new ();
1139 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1140 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
1141
1142 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
1143
1144 return combobox;
1145 }
1146 /************************************************************************************************************/
setDeMonMethods()1147 static void setDeMonMethods()
1148 {
1149 GtkTreeIter iter;
1150 GtkTreeIter iter0;
1151 gint i;
1152
1153 if(strcmp(selectedTypeMethod,"HF")==0)
1154 {
1155 listMethodsView = listHFMethodsView;
1156 listMethodsReal = listHFMethodsReal;
1157 numberOfMethods = numberOfHFMethods;
1158 }
1159 else
1160 if(strcmp(selectedTypeMethod,"DFT")==0)
1161 {
1162 listMethodsView = listDFTMethodsView;
1163 listMethodsReal = listDFTMethodsReal;
1164 numberOfMethods = numberOfDFTMethods;
1165 }
1166 else
1167 if(strcmp(selectedTypeMethod,"Hybrid")==0)
1168 {
1169 listMethodsView = listHybridMethodsView;
1170 listMethodsReal = listHybridMethodsReal;
1171 numberOfMethods = numberOfHybridMethods;
1172 }
1173 else
1174 if(strcmp(selectedTypeMethod,"Meta-GGA")==0)
1175 {
1176 listMethodsView = listMetaGGAMethodsView;
1177 listMethodsReal = listMetaGGAMethodsReal;
1178 numberOfMethods = numberOfMetaGGAMethods;
1179 }
1180
1181 else
1182 if(strcmp(selectedTypeMethod,"D-Hybrid")==0)
1183 {
1184 listMethodsView = listDHybridMethodsView;
1185 listMethodsReal = listDHybridMethodsReal;
1186 numberOfMethods = numberOfDHybridMethods;
1187 }
1188 else
1189 if(strcmp(selectedTypeMethod,"MP2")==0)
1190 {
1191 listMethodsView = listMP2MethodsView;
1192 listMethodsReal = listMP2MethodsReal;
1193 numberOfMethods = numberOfMP2Methods;
1194 }
1195 else
1196 if(strcmp(selectedTypeMethod,"HL-SR")==0)
1197 {
1198 listMethodsView = listHighLevelSingleRefMethodsView;
1199 listMethodsReal = listHighLevelSingleRefMethodsReal;
1200 numberOfMethods = numberOfHighLevelSingleRefMethods;
1201 }
1202 else
1203 if(strcmp(selectedTypeMethod,"SemiEmp")==0)
1204 {
1205 listMethodsView = listSemiEmpMethodsView;
1206 listMethodsReal = listSemiEmpMethodsReal;
1207 numberOfMethods = numberOfSemiEmpMethods;
1208 }
1209 else
1210 {
1211 listMethodsView = listHFMethodsView;
1212 listMethodsReal = listHFMethodsReal;
1213 numberOfMethods = numberOfHFMethods;
1214 }
1215
1216 if (comboMethod && gtk_combo_box_get_active_iter (GTK_COMBO_BOX(comboMethod), &iter))
1217 {
1218 GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(comboMethod));
1219 GtkTreeStore *store = GTK_TREE_STORE(model);
1220 gtk_tree_store_clear(store);
1221
1222 for(i=0;i<numberOfMethods;i++)
1223 {
1224 gtk_tree_store_append (store, &iter, NULL);
1225 if(i==0) iter0 = iter;
1226 gtk_tree_store_set (store, &iter, 0, listMethodsView[i], -1);
1227 }
1228 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (comboMethod), &iter0);
1229 }
1230
1231 }
1232 /************************************************************************************************************/
traitementTypeMethod(GtkComboBox * combobox,gpointer d)1233 static void traitementTypeMethod (GtkComboBox *combobox, gpointer d)
1234 {
1235 GtkTreeIter iter;
1236 gchar* data = NULL;
1237 gchar* res = NULL;
1238 gint i;
1239 /* gchar* s;*/
1240 if (gtk_combo_box_get_active_iter (combobox, &iter))
1241 {
1242 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
1243 gtk_tree_model_get (model, &iter, 0, &data, -1);
1244 }
1245 else return;
1246 for(i=0;i<numberOfTypeMethods;i++)
1247 {
1248 if(strcmp((gchar*)data,listTypeMethodsView[i])==0) res = listTypeMethodsReal[i];
1249 }
1250 if(res) sprintf(selectedTypeMethod,"%s",res);
1251 else sprintf(selectedSCF,"HF");
1252
1253 setDeMonMethods();
1254 }
1255 /********************************************************************************************************/
create_list_type_methods()1256 static GtkWidget *create_list_type_methods()
1257 {
1258 GtkTreeIter iter;
1259 GtkTreeStore *store;
1260 GtkTreeModel *model;
1261 GtkWidget *combobox;
1262 GtkCellRenderer *renderer;
1263 gint i;
1264 GtkTreeIter iter0;
1265
1266 store = gtk_tree_store_new (1,G_TYPE_STRING);
1267
1268 for(i=0;i<numberOfTypeMethods;i++)
1269 {
1270 gtk_tree_store_append (store, &iter, NULL);
1271 if(i==0) iter0 = iter;
1272 gtk_tree_store_set (store, &iter, 0, listTypeMethodsView[i], -1);
1273 }
1274
1275 model = GTK_TREE_MODEL (store);
1276 combobox = gtk_combo_box_new_with_model (model);
1277 /*
1278 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1279 */
1280 g_object_unref (model);
1281 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementTypeMethod), NULL);
1282 renderer = gtk_cell_renderer_text_new ();
1283 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1284 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
1285
1286 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
1287
1288 return combobox;
1289 }
1290 /*************************************************************************************************************/
traitementMethod(GtkComboBox * combobox,gpointer d)1291 static void traitementMethod (GtkComboBox *combobox, gpointer d)
1292 {
1293 GtkTreeIter iter;
1294 gchar* data = NULL;
1295 gchar* res = NULL;
1296 gint i;
1297 GtkWidget* wid;
1298 gboolean ri = FALSE;
1299
1300 if (gtk_combo_box_get_active_iter (combobox, &iter))
1301 {
1302 GtkTreeModel* model = gtk_combo_box_get_model(combobox);
1303 gtk_tree_model_get (model, &iter, 0, &data, -1);
1304 }
1305 else return;
1306 for(i=0;i<numberOfMethods;i++)
1307 {
1308 if(strcmp((gchar*)data,listMethodsView[i])==0) res = listMethodsReal[i];
1309 }
1310 if(res) sprintf(selectedMethod,"%s",res);
1311 else sprintf(selectedMethod,"HF");
1312 if(strstr(selectedMethod,"RI")) ri = TRUE;
1313
1314 ri = TRUE;// activate it in all cases
1315
1316 wid = g_object_get_data(G_OBJECT (combobox), "LabelAuxBasis1");
1317 if(wid) gtk_widget_set_sensitive(wid, ri);
1318 wid = g_object_get_data(G_OBJECT (combobox), "LabelAuxBasis2");
1319 if(wid) gtk_widget_set_sensitive(wid, ri);
1320 wid = g_object_get_data(G_OBJECT (combobox), "ComboAuxBasis");
1321 if(wid) gtk_widget_set_sensitive(wid, ri);
1322 setDeMonExcited();
1323 }
1324 /********************************************************************************************************/
create_list_methods()1325 static GtkWidget *create_list_methods()
1326 {
1327 GtkTreeIter iter;
1328 GtkTreeStore *store;
1329 GtkTreeModel *model;
1330 GtkWidget *combobox;
1331 GtkCellRenderer *renderer;
1332 gint i;
1333 GtkTreeIter iter0;
1334
1335 store = gtk_tree_store_new (1,G_TYPE_STRING);
1336
1337
1338 for(i=0;i<numberOfMethods;i++)
1339 {
1340 gtk_tree_store_append (store, &iter, NULL);
1341 if(i==0) iter0 = iter;
1342 gtk_tree_store_set (store, &iter, 0, listMethodsView[i], -1);
1343 }
1344
1345 model = GTK_TREE_MODEL (store);
1346 combobox = gtk_combo_box_new_with_model (model);
1347 /*
1348 gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1349 */
1350 g_object_unref (model);
1351 g_signal_connect (G_OBJECT(combobox), "changed", G_CALLBACK(traitementMethod), NULL);
1352 renderer = gtk_cell_renderer_text_new ();
1353 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1354 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL);
1355
1356 gtk_combo_box_set_active_iter(GTK_COMBO_BOX (combobox), &iter0);
1357
1358 return combobox;
1359 }
1360 /************************************************************************************************************/
createDeMonKeywordsFrame(GtkWidget * win,GtkWidget * box)1361 void createDeMonKeywordsFrame(GtkWidget *win, GtkWidget *box)
1362 {
1363 GtkWidget* frame;
1364 GtkWidget* vboxFrame;
1365 GtkWidget* comboBasis;
1366 GtkWidget* sep;
1367 GtkWidget* combo = NULL;
1368 GtkWidget* comboScfConvergence = NULL;
1369 gint l=0;
1370 gint c=0;
1371 gint ncases=1;
1372 GtkWidget *table = gtk_table_new(10,3,FALSE);
1373
1374 comboMethod = NULL;
1375 comboTypeMethod = NULL;
1376 comboExcited = NULL;
1377
1378 listMethodsView = listHybridMethodsView;
1379 listMethodsReal = listHybridMethodsReal;
1380 numberOfMethods = numberOfHybridMethods;
1381
1382 frame = gtk_frame_new (_("Job Specification:"));
1383 gtk_widget_show (frame);
1384 gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
1385 gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
1386
1387 vboxFrame = gtk_vbox_new (FALSE, 3);
1388 gtk_widget_show (vboxFrame);
1389 gtk_container_add (GTK_CONTAINER (frame), vboxFrame);
1390 gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);
1391
1392 /*------------------ Job Type -----------------------------------------*/
1393 l=0;
1394 c = 0; ncases=1;
1395 add_label_table(table,_("Job Type"),l,c);
1396 c = 1; ncases=1;
1397 add_label_table(table,":",l,c);
1398 combo = create_list_jobtype();
1399 c = 2; ncases=1;
1400 gtk_table_attach(GTK_TABLE(table),combo,c,c+ncases,l,l+1,
1401 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1402 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1403 2,2);
1404 /*------------------ SCF Type -----------------------------------------*/
1405 l++;
1406 c = 0; ncases=1;
1407 add_label_table(table,_("SCF Type"),l,c);
1408 c = 1; ncases=1;
1409 add_label_table(table,":",l,c);
1410 combo = create_list_scf();
1411 comboSCF=combo;
1412 c = 2; ncases=1;
1413 gtk_table_attach(GTK_TABLE(table),combo,c,c+ncases,l,l+1,
1414 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1415 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1416 2,2);
1417 /*------------------ SCF Tighten -----------------------------------------*/
1418 l++;
1419 c = 0; ncases=1;
1420 add_label_table(table,_("SCF Tighten"),l,c);
1421 c = 1; ncases=1;
1422 add_label_table(table,":",l,c);
1423 combotight = create_list_tight();
1424 c = 2; ncases=1;
1425 gtk_table_attach(GTK_TABLE(table),combotight,c,c+ncases,l,l+1,
1426 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1427 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1428 2,2);
1429 /*------------------ SCF Max Iter ------------------------------------------------*/
1430 l++;
1431 c = 0; ncases=1;
1432 add_label_table(table,_("SCF Max Iterations"),l,c);
1433 c = 1; ncases=1;
1434 add_label_table(table,":",l,c);
1435 entryscfmaxit = gtk_entry_new();
1436 gtk_entry_set_text(GTK_ENTRY(entryscfmaxit),"100");
1437 c = 2; ncases=1;
1438 gtk_table_attach(GTK_TABLE(table),entryscfmaxit,c,c+ncases,l,l+1,
1439 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1440 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1441 2,2);
1442 /*------------------ SCF Convergence -----------------------------------------*/
1443 l++;
1444 c = 0; ncases=1;
1445 add_label_table(table,_("SCF Convergence"),l,c);
1446 c = 1; ncases=1;
1447 add_label_table(table,":",l,c);
1448 comboScfConvergence = create_list_scfconvergence();
1449 c = 2; ncases=1;
1450 gtk_table_attach(GTK_TABLE(table),comboScfConvergence,c,c+ncases,l,l+1,
1451 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1452 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1453 2,2);
1454
1455 /*------------------ VXCTYP ------------------------------------------------*/
1456 l++;
1457 c = 0; ncases=1;
1458 add_label_table(table,_("VXCTYP"),l,c);
1459 c = 1; ncases=1;
1460 add_label_table(table,":",l,c);
1461 combovxc = create_list_vxc();
1462 c = 2; ncases=1;
1463 gtk_table_attach(GTK_TABLE(table),combovxc,c,c+ncases,l,l+1,
1464 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1465 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1466 2,2);
1467 /*------------------ DIIS ------------------------------------------------*/
1468 l++;
1469 c = 0; ncases=1;
1470 add_label_table(table,_("DIIS"),l,c);
1471 c = 1; ncases=1;
1472 add_label_table(table,":",l,c);
1473 combodiis = create_list_diis();
1474 c = 2; ncases=1;
1475 gtk_table_attach(GTK_TABLE(table),combodiis,c,c+ncases,l,l+1,
1476 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1477 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1478 2,2);
1479 /*------------------ Grid ------------------------------------------------*/
1480 l++;
1481 c = 0; ncases=1;
1482 add_label_table(table,_("Grid"),l,c);
1483 c = 1; ncases=1;
1484 add_label_table(table,":",l,c);
1485 combogrid = create_list_grid();
1486 c = 2; ncases=1;
1487 gtk_table_attach(GTK_TABLE(table),combogrid,c,c+ncases,l,l+1,
1488 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1489 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1490 2,2);
1491 /*------------------ Shift ------------------------------------------------*/
1492 l++;
1493 c = 0; ncases=1;
1494 add_label_table(table,_("Shift"),l,c);
1495 c = 1; ncases=1;
1496 add_label_table(table,":",l,c);
1497 entryShift = gtk_entry_new();
1498 gtk_entry_set_text(GTK_ENTRY(entryShift),"0.0");
1499 c = 2; ncases=1;
1500 gtk_table_attach(GTK_TABLE(table),entryShift,c,c+ncases,l,l+1,
1501 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1502 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1503 2,2);
1504 /*------------------ MIXING ------------------------------------------------*/
1505 l++;
1506 c = 0; ncases=1;
1507 add_label_table(table,_("Mixing"),l,c);
1508 c = 1; ncases=1;
1509 add_label_table(table,":",l,c);
1510 entryMixing = gtk_entry_new();
1511 gtk_entry_set_text(GTK_ENTRY(entryMixing),"-0.3");
1512 c = 2; ncases=1;
1513 gtk_table_attach(GTK_TABLE(table),entryMixing,c,c+ncases,l,l+1,
1514 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1515 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1516 2,2);
1517 /*------------------ Method Type -----------------------------------------*/
1518 l++;
1519 c = 0; ncases=1;
1520 add_label_table(table,_("Type of method"),l,c);
1521 c = 1; ncases=1;
1522 add_label_table(table,":",l,c);
1523 combo = create_list_type_methods();
1524 comboTypeMethod = combo;
1525 c = 2; ncases=1;
1526 gtk_table_attach(GTK_TABLE(table),combo,c,c+ncases,l,l+1,
1527 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1528 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1529 2,2);
1530 /*------------------ Method -----------------------------------------*/
1531 l++;
1532 c = 0; ncases=1;
1533 add_label_table(table,_("Method"),l,c);
1534 c = 1; ncases=1;
1535 add_label_table(table,":",l,c);
1536 combo = create_list_methods();
1537 comboMethod = combo;
1538 c = 2; ncases=1;
1539 gtk_table_attach(GTK_TABLE(table),combo,c,c+ncases,l,l+1,
1540 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1541 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1542 2,2);
1543 setDeMonMethods();
1544 /*------------------ Excited states -----------------------------------------*/
1545 l++;
1546 c = 0; ncases=1;
1547 add_label_table(table,_("Excited states"),l,c);
1548 c = 1; ncases=1;
1549 add_label_table(table,":",l,c);
1550 combo = create_list_excited();
1551 comboExcited = combo;
1552 c = 2; ncases=1;
1553 gtk_table_attach(GTK_TABLE(table),combo,c,c+ncases,l,l+1,
1554 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1555 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1556 2,2);
1557 setDeMonExcited();
1558 /*------------------ separator -----------------------------------------*/
1559 l++;
1560 sep = gtk_hseparator_new ();;
1561 c = 0; ncases=3;
1562 gtk_table_attach(GTK_TABLE(table),sep,c,c+ncases,l,l+1,
1563 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1564 (GtkAttachOptions) (GTK_FILL | GTK_SHRINK),
1565 2,2);
1566 /*------------------ basis -----------------------------------------*/
1567 l++;
1568 comboBasis = addDeMonBasisToTable(table, l+1);
1569 addDeMonTypeBasisToTable(table, l, comboBasis);
1570 l++;
1571 /*------------------ aux basis -----------------------------------------*/
1572 l++;
1573 addDeMonAuxBasisToTable(table, l, comboMethod, comboExcited);
1574 setDeMonMethods(); /* For activate sensitive aux basis */
1575 }
1576