1 /* CoulombOrbitals.c */
2 /**********************************************************************************************************
3 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
4
5 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
8 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9
10 The above copyright notice and this permission notice shall be included in all copies or substantial portions
11 of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
16 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17 DEALINGS IN THE SOFTWARE.
18 ************************************************************************************************************/
19
20
21 #include "../../Config.h"
22 #include "../Display/GlobalOrb.h"
23 #ifdef ENABLE_OMP
24 #include <omp.h>
25 #endif
26 #include "../Utils/Vector3d.h"
27 #include "../Utils/GTF.h"
28 #include "../Display/GLArea.h"
29 #include "../Display/Orbitals.h"
30 #include "../Display/OrbitalsMolpro.h"
31 #include "../Display/OrbitalsGamess.h"
32 #include "../Display/OrbitalsQChem.h"
33 #include "../Display/GeomOrbXYZ.h"
34 #include "../Display/BondsOrb.h"
35 #include "../Display/UtilsOrb.h"
36 #include "../Display/TriangleDraw.h"
37 #include "../Utils/Utils.h"
38 #include "../Utils/UtilsInterface.h"
39 #include "../Utils/Constants.h"
40 #include "../Utils/GabeditTextEdit.h"
41 #include "../Files/FileChooser.h"
42 #include "../Common/Windows.h"
43 #include "../Display/Vibration.h"
44 #include "../Display/ContoursPov.h"
45 #include "../Display/PlanesMappedPov.h"
46 #include "../Display/LabelsGL.h"
47 #include "../Display/StatusOrb.h"
48
49
50 #define WIDTHSCR 0.3
51 typedef gboolean (*FuncCompCoulomb)(gint N[],GridLimits limits, gint typeOrbi, gint i, gint typeOrbj, gint j,
52 gdouble* pInteg, gdouble* pNorm, gdouble* pNormj, gdouble* pOverlap);
53
54 /********************************************************************************/
55 /* <ii|delta(r_i,r_j)|jj>*/
compute_spatial_overlap_analytic(gint typeOrbi,gint i,gint typeOrbj,gint j,gdouble schwarzCutOff)56 gdouble compute_spatial_overlap_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j, gdouble schwarzCutOff)
57 {
58 gdouble** CoefI = CoefAlphaOrbitals;
59 gdouble** CoefJ = CoefAlphaOrbitals;
60 gint k,kp;
61 gint l,lp;
62 gdouble scal;
63 gchar tmp[BSIZE];
64 gint* p;
65 gint* q;
66 gdouble* cci;
67 gdouble* ccj;
68 gint kk;
69 gint ll;
70 gulong delta = 0;
71 gint pos = 0;
72 gdouble cc = 0;
73 gulong nAll = 0;
74 gdouble integ;
75 gint N;
76 gdouble pqrs;
77 gdouble* mnmn;
78 gulong nComp = 0;
79
80 integ = 0;
81
82 if(typeOrbi != typeOrbj )
83 {
84 /* stop calculation */
85 CancelCalcul = TRUE;
86 return integ ;
87 }
88 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
89 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
90
91 N = NAOrb*(NAOrb+1)/2;
92 if(N<1)return -1.0;
93 mnmn = g_malloc(N*sizeof(gdouble));
94 p = g_malloc(N*sizeof(gint));
95 q = g_malloc(N*sizeof(gint));
96 cci = g_malloc(N*sizeof(gdouble));
97 ccj = g_malloc(N*sizeof(gdouble));
98
99
100 sprintf(tmp,_("Computing of <%d %d|delta(ri,rj)| %d %d>.... Please wait"),i+1,i+1,j+1,j+1);
101 setTextInProgress(tmp);
102
103 kk = 0;
104 for(k=0;k<NAOrb;k++)
105 for(kp=k;kp<NAOrb;kp++)
106 {
107 p[kk] = k;
108 q[kk] = kp;
109 cci[kk] = 2*CoefI[i][k]*CoefI[i][kp]/((k==kp)?2:1);
110 ccj[kk] = 2*CoefJ[j][k]*CoefJ[j][kp]/((k==kp)?2:1);
111 mnmn[kk] = 0.0;
112 kk++;
113 }
114 scal = 0.01;
115 delta = (gint)(N*(N+1.0)/2.0*scal);
116 if(delta<1) delta = N*(N+1)/20;
117 if(delta<1) delta = 1;
118 pos = delta;
119 /* printf("delta = %ld\n",delta);*/
120 progress_orb_txt(0,"tmp",TRUE);
121
122 /* For do a Schwarz screening */
123 #ifdef ENABLE_OMP
124 #ifdef G_OS_WIN32
125 setTextInProgress(_("Computing of spatial integrale, pleasse wait..."));
126 #endif
127 #pragma omp parallel for private(k,kp,kk,pqrs) reduction(+:integ,nAll,nComp,pos)
128 #endif
129 for(kk=0;kk<N;kk++)
130 {
131 k = p[kk];
132 kp = q[kk];
133 pqrs = overlap4CGTF(&AOrb[k],&AOrb[kp],&AOrb[k],&AOrb[kp]);
134 integ += (cci[kk]*ccj[kk])*pqrs;
135 mnmn[kk] = sqrt(fabs(pqrs));
136 nAll++;
137 nComp++;
138 if(nAll>=pos)
139 {
140 pos += delta;
141 #ifdef ENABLE_OMP
142 #ifndef G_OS_WIN32
143 #pragma omp critical
144 progress_orb_txt(scal,tmp,FALSE);
145 #endif
146 #else
147 progress_orb_txt(scal,tmp,FALSE);
148 #endif
149 }
150 }
151 #ifdef ENABLE_OMP
152 #ifdef G_OS_WIN32
153 setTextInProgress(_("Computing of spatial integrale, pleasse wait..."));
154 #endif
155 #pragma omp parallel for private(k,kp,l,lp,kk,ll,pqrs,cc) reduction(+:integ,nAll,nComp,pos)
156 #endif
157 for(kk=0;kk<N;kk++)
158 {
159 k = p[kk];
160 kp = q[kk];
161 if(!CancelCalcul)
162 for(ll=0;ll<kk;ll++)
163 {
164 if(!CancelCalcul)
165 {
166 l = p[ll];
167 lp = q[ll];
168 nAll++;
169 if(nAll>=pos)
170 {
171 pos += delta;
172 #ifdef ENABLE_OMP
173 #ifndef G_OS_WIN32
174 #pragma omp critical
175 progress_orb_txt(scal,tmp,FALSE);
176 #endif
177 #else
178 progress_orb_txt(scal,tmp,FALSE);
179 #endif
180 }
181 cc = (cci[kk]*ccj[ll]+cci[ll]*ccj[kk]);
182 if(fabs(cc*mnmn[kk]*mnmn[ll])>=schwarzCutOff)
183 {
184 pqrs = overlap4CGTF(&AOrb[k],&AOrb[kp],&AOrb[l],&AOrb[lp]);
185 integ += cc*pqrs;
186 nComp++;
187 }
188 }
189 }
190 }
191 sprintf(tmp,"# of all <pq|rs> = %ld, # of computed <pq|rs> %ld\n",nAll, nComp);
192 progress_orb_txt(0,tmp,TRUE);
193 g_free(mnmn);
194 g_free(p);
195 g_free(q);
196 g_free(cci);
197 g_free(ccj);
198 return integ;
199 }
200 /********************************************************************************/
compute_transition_matrix_analytic(gint typeOrbi,gint i,gint typeOrbj,gint j,gdouble integ[])201 void compute_transition_matrix_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j, gdouble integ[])
202 {
203 gint k;
204 gint l;
205 gdouble** CoefI = CoefAlphaOrbitals;
206 gdouble** CoefJ = CoefAlphaOrbitals;
207 gdouble s = 0;
208
209 integ[0] = 0;
210 integ[1] = 0;
211 integ[2] = 0;
212
213 if(typeOrbi != typeOrbj ) return;
214 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
215 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
216 s = 0;
217 #ifdef ENABLE_OMP
218 printf("# proc = %d\n", omp_get_num_procs ());
219 #pragma omp parallel for private(k) reduction(+:s)
220 #endif
221 for(k=0;k<NAOrb;k++)
222 s += CoefI[i][k]*CoefJ[j][k]*CGTFxyzCGTF(&AOrb[k],&AOrb[k],1,0,0);
223 s = 0;
224 integ[0] += s;
225 #ifdef ENABLE_OMP
226 #pragma omp parallel for private(k) reduction(+:s)
227 #endif
228 for(k=0;k<NAOrb;k++)
229 s += CoefI[i][k]*CoefJ[j][k]*CGTFxyzCGTF(&AOrb[k],&AOrb[k],0,1,0);
230 integ[1] += s;
231 s = 0;
232 #ifdef ENABLE_OMP
233 #pragma omp parallel for private(k) reduction(+:s)
234 #endif
235 for(k=0;k<NAOrb;k++)
236 s += CoefI[i][k]*CoefJ[j][k]*CGTFxyzCGTF(&AOrb[k],&AOrb[k],0,0,1);
237 integ[2] += s;
238
239 s = 0;
240 #ifdef ENABLE_OMP
241 #pragma omp parallel for private(k,l) reduction(+:s)
242 #endif
243 for(k=0;k<NAOrb;k++)
244 for(l=k+1;l<NAOrb;l++)
245 s += (CoefI[i][k]*CoefJ[j][l]+CoefI[i][l]*CoefJ[j][k])*CGTFxyzCGTF(&AOrb[k],&AOrb[l],1,0,0);
246 integ[0] += s;
247
248 s = 0;
249 #ifdef ENABLE_OMP
250 #pragma omp parallel for private(k,l) reduction(+:s)
251 #endif
252 for(k=0;k<NAOrb;k++)
253 for(l=k+1;l<NAOrb;l++)
254 s += (CoefI[i][k]*CoefJ[j][l]+CoefI[i][l]*CoefJ[j][k])*CGTFxyzCGTF(&AOrb[k],&AOrb[l],0,1,0);
255 integ[1] += s;
256
257 s = 0;
258 #ifdef ENABLE_OMP
259 #pragma omp parallel for private(k,l) reduction(+:s)
260 #endif
261 for(k=0;k<NAOrb;k++)
262 for(l=k+1;l<NAOrb;l++)
263 s += (CoefI[i][k]*CoefJ[j][l]+CoefI[i][l]*CoefJ[j][k])*CGTFxyzCGTF(&AOrb[k],&AOrb[l],0,0,1);
264 integ[2] += s;
265 }
266 /********************************************************************************/
get_overlap_analytic(gint typeOrbi,gint i,gint typeOrbj,gint j)267 gdouble get_overlap_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j)
268 {
269 gint k;
270 gint l;
271 gdouble v=0.0;
272 gdouble** CoefI = CoefAlphaOrbitals;
273 gdouble** CoefJ = CoefAlphaOrbitals;
274
275 if(typeOrbi != typeOrbj ) return 0.0;
276 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
277 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
278 #ifdef ENABLE_OMP
279 #pragma omp parallel for private(k) reduction(+:v)
280 #endif
281 for(k=0;k<NAOrb;k++)
282 v += CoefI[i][k]*CoefJ[j][k]*overlapCGTF(&AOrb[k],&AOrb[k]);
283 #ifdef ENABLE_OMP
284 #pragma omp parallel for private(k,l) reduction(+:v)
285 #endif
286 for(k=0;k<NAOrb;k++)
287 for(l=k+1;l<NAOrb;l++)
288 v += (CoefI[i][k]*CoefJ[j][l]+CoefI[i][l]*CoefJ[j][k])*overlapCGTF(&AOrb[k],&AOrb[l]);
289
290 return v;
291 }
292 /********************************************************************************/
293 /*
294 gdouble get_coulomb_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j)
295 {
296 gint k,kp;
297 gint l,lp;
298 gdouble v=0.0;
299 gdouble** CoefI = CoefAlphaOrbitals;
300 gdouble** CoefJ = CoefAlphaOrbitals;
301 gdouble d,eri;
302 gdouble scal;
303
304 gint N = NAOrb*(NAOrb+1)/2;
305 gint* p = g_malloc(N*sizeof(gint));
306 gint* q = g_malloc(N*sizeof(gint));
307 gint* dpq = g_malloc(N*sizeof(gint));
308 gdouble* cci = g_malloc(N*sizeof(gdouble));
309 gdouble* ccj = g_malloc(N*sizeof(gdouble));
310 gint kk;
311 gint ll;
312 gint dkkll;
313
314 scal = (gdouble)1.01/N;
315
316 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
317 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
318 kk = 0;
319 for(k=0;k<NAOrb;k++)
320 for(kp=k;kp<NAOrb;kp++)
321 {
322 p[kk] = k;
323 q[kk] = kp;
324 dpq[kk] =(k==kp)?2:1;
325 cci[kk] = CoefI[i][k]*CoefI[i][kp];
326 ccj[kk] = CoefJ[j][k]*CoefJ[j][kp];
327 kk++;
328 }
329
330 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
331 for(kk=0;kk<N;kk++)
332 {
333 k = p[kk];
334 kp = q[kk];
335 progress_orb(scal,GABEDIT_PROGORB_COMPINTEG,FALSE);
336 if(CancelCalcul)
337 {
338 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
339 break;
340 }
341 if(fabs(cci[kk])<1e-12 && fabs(ccj[kk])<1e-12 )continue;
342 if(!CancelCalcul)
343 for(ll=kk;ll<N;ll++)
344 {
345 l = p[ll];
346 lp = q[ll];
347 if(CancelCalcul) break;
348 if(fabs(cci[ll])<1e-12 && fabs(ccj[ll])<1e-12 )continue;
349 dkkll=(kk==ll)?2:1;
350 d = dpq[kk]*dpq[ll]*dkkll;
351 eri = ERICGTF(&AOrb[k],&AOrb[kp],&AOrb[l],&AOrb[lp]);
352 v += 4*(cci[kk]*ccj[ll]+cci[ll]*ccj[kk])*eri/d;
353 }
354 }
355 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
356 g_free(p);
357 g_free(q);
358 g_free(dpq);
359 g_free(cci);
360 g_free(ccj);
361 if(CancelCalcul) return -1.0;
362
363 return v;
364 }
365 */
366 /********************************************************************************/
367 /*
368 gdouble get_coulomb_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j)
369 {
370 gint k,kp;
371 gint l,lp;
372 gdouble v=0.0;
373 gdouble** CoefI = CoefAlphaOrbitals;
374 gdouble** CoefJ = CoefAlphaOrbitals;
375 gdouble a,b,eri;
376 gdouble scal;
377 scal = (gdouble)2.02/NAOrb/(NAOrb+1);
378 gdouble cci = 0;
379 gdouble ccj = 0;
380
381 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
382 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
383 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
384 for(k=0;k<NAOrb;k++)
385 for(kp=k;kp<NAOrb;kp++)
386 {
387 cci = CoefI[i][k]*CoefI[i][kp];
388 progress_orb(scal,GABEDIT_PROGORB_COMPINTEG,FALSE);
389 if(CancelCalcul)
390 {
391 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
392 break;
393 }
394 if(fabs(cci)<1e-12)continue;
395 a=(k==kp)?1:2;
396 if(!CancelCalcul)
397 for(l=0;l<NAOrb;l++)
398 for(lp=l;lp<NAOrb;lp++)
399 {
400 if(CancelCalcul) break;
401 ccj = CoefJ[j][l]*CoefJ[j][lp];
402 if(fabs(ccj)<1e-12)continue;
403 b=(l==lp)?1:2;
404 eri = ERICGTF(&AOrb[k],&AOrb[kp],&AOrb[l],&AOrb[lp]);
405 v += cci*ccj*eri*a*b;
406 }
407 }
408 progress_orb(0,GABEDIT_PROGORB_COMPINTEG,TRUE);
409 if(CancelCalcul) return -1.0;
410
411 return v;
412 }
413 */
414 /********************************************************************************/
get_coulomb_analytic(gint typeOrbi,gint i,gint typeOrbj,gint j,gdouble schwarzCutOff)415 gdouble get_coulomb_analytic(gint typeOrbi, gint i, gint typeOrbj, gint j, gdouble schwarzCutOff)
416 {
417 gint k,kp;
418 gint l,lp;
419 gdouble v=0.0;
420 gdouble** CoefI = CoefAlphaOrbitals;
421 gdouble** CoefJ = CoefAlphaOrbitals;
422 gdouble eri = 0;
423 gdouble scal;
424 gchar tmp[BSIZE];
425
426 gint N = NAOrb*(NAOrb+1)/2;
427 gint* p = g_malloc(N*sizeof(gint));
428 gint* q = g_malloc(N*sizeof(gint));
429 gdouble* cci = g_malloc(N*sizeof(gdouble));
430 gdouble* ccj = g_malloc(N*sizeof(gdouble));
431 gdouble* mnmn = g_malloc(N*sizeof(gdouble));
432 gint kk;
433 gint ll;
434 gulong delta = 0;
435 gint pos = 0;
436 TTABLES** Ttables = NULL;
437 gdouble cc = 0;
438 gdouble ccmn = 0;
439 gulong nAll = 0;
440 gulong nComp = 0;
441
442 if(N<1)return -1.0;
443
444 setTextInProgress(_("Creation of T1 and T2 tables... Please wait"));
445 Ttables = createTTables(AOrb, NAOrb, 1e-9);
446 if(!Ttables) return -1.0;
447
448
449 sprintf(tmp,_("Computing of <%d %d|1/r12| %d %d>.... Please wait"),i+1,i+1,j+1,j+1);
450
451 if(typeOrbi == 2) CoefI = CoefBetaOrbitals;
452 if(typeOrbj == 2) CoefJ = CoefBetaOrbitals;
453 kk = 0;
454 for(k=0;k<NAOrb;k++)
455 for(kp=k;kp<NAOrb;kp++)
456 {
457 p[kk] = k;
458 q[kk] = kp;
459 cci[kk] = 2*CoefI[i][k]*CoefI[i][kp]/((k==kp)?2:1);
460 ccj[kk] = 2*CoefJ[j][k]*CoefJ[j][kp]/((k==kp)?2:1);
461 mnmn[kk] = 0.0;
462 kk++;
463 }
464
465 scal = 0.01;
466 delta = (gint)(N*(N+1.0)/2.0*scal);
467 if(delta<1) delta = N*(N+1)/20;
468 if(delta<1) delta = 1;
469 pos = delta;
470 /* printf("delta = %ld\n",delta);*/
471 progress_orb_txt(0,_("Computing of 2 centers Coulomb integrals... Please wait"),TRUE);
472
473 /* For do a Schwarz screening */
474 #ifdef ENABLE_OMP
475 #ifdef G_OS_WIN32
476 setTextInProgress(_("Computing of eri, pleasse wait..."));
477 #endif
478 #pragma omp parallel for private(k,kp,kk,eri) reduction(+:v,nAll,nComp,pos)
479 #endif
480 for(kk=0;kk<N;kk++)
481 {
482 k = p[kk];
483 kp = q[kk];
484 eri = ERICTABLES(k,kp,k,kp,Ttables);
485 v += (cci[kk]*ccj[kk])*eri;
486 mnmn[kk] = sqrt(fabs(eri));
487 nAll++;
488 nComp++;
489 if(nAll>=pos)
490 {
491 pos += delta;
492 #ifdef ENABLE_OMP
493 #ifndef G_OS_WIN32
494 #pragma omp critical
495 progress_orb_txt(scal,tmp,FALSE);
496 #endif
497 #else
498 progress_orb_txt(scal,tmp,FALSE);
499 #endif
500 }
501 }
502 #ifdef ENABLE_OMP
503 #ifdef G_OS_WIN32
504 setTextInProgress(_("Computing of eri, pleasse wait..."));
505 #endif
506 #pragma omp parallel for private(k,kp,l,lp,kk,ll,eri,cc,ccmn) reduction(+:v,nAll,nComp,pos)
507 #endif
508 for(kk=0;kk<N;kk++)
509 {
510 k = p[kk];
511 kp = q[kk];
512 if(!CancelCalcul)
513 for(ll=0;ll<kk;ll++)
514 {
515 if(!CancelCalcul)
516 {
517 l = p[ll];
518 lp = q[ll];
519 nAll++;
520 if(nAll>=pos)
521 {
522 pos += delta;
523 #ifdef ENABLE_OMP
524 #ifndef G_OS_WIN32
525 #pragma omp critical
526 progress_orb_txt(scal,tmp,FALSE);
527 #endif
528 #else
529 progress_orb_txt(scal,tmp,FALSE);
530 #endif
531 }
532 cc = (cci[kk]*ccj[ll]+cci[ll]*ccj[kk]);
533 /* Schwarz screening */
534 ccmn = cc*mnmn[kk]*mnmn[ll];
535 if(fabs(ccmn)<schwarzCutOff)
536 {
537 continue;
538 }
539 eri = ERICTABLES(k,kp,l,lp,Ttables);
540 v += cc*eri;
541 nComp++;
542 }
543 }
544 }
545 sprintf(tmp,_("# of all ERI = %ld, # of computed ERI = %ld"),nAll, nComp);
546 freeTTables(NAOrb,Ttables);
547 progress_orb_txt(0,tmp,TRUE);
548 g_free(p);
549 g_free(q);
550 g_free(cci);
551 g_free(ccj);
552 g_free(mnmn);
553 if(CancelCalcul) return -1.0;
554
555 return v;
556 }
557 /********************************************************************************/
get_num_of_selected_orbitals(GtkWidget * gtklist,gint * n)558 static gint* get_num_of_selected_orbitals(GtkWidget *gtklist, gint* n)
559 {
560 gint* numOrbs = NULL;
561
562 *n = 0;
563 if (gtklist == NULL) return NULL;
564 if(!GTK_IS_TREE_VIEW(gtklist)) return NULL;
565 {
566 GtkTreeSelection *selection;
567 GtkTreeModel *model;
568 GList *selected_rows = NULL;
569 GList *row;
570 GtkTreePath *path = NULL;
571 gint* indices = NULL;
572 gint i = 0;
573
574 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(gtklist));
575 if(selection) selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
576 *n = gtk_tree_selection_count_selected_rows(selection);
577 if(*n<1) return numOrbs;
578 numOrbs = g_malloc(*n*sizeof(gint));
579
580 i =0;
581 for (row = g_list_first (selected_rows); row != NULL; row = g_list_next (row))
582 {
583 path = (GtkTreePath *)(row->data);
584 indices = gtk_tree_path_get_indices(path);
585 numOrbs[i++] = indices[0];
586 if(i>=*n) break;
587 }
588 }
589 return numOrbs;
590 }
591 /********************************************************************************/
numeriButtonClicked(GtkWidget * numericButton,gpointer data)592 static void numeriButtonClicked(GtkWidget *numericButton,gpointer data)
593 {
594 GtkWidget* frameGrid = g_object_get_data (G_OBJECT (numericButton), "FrameGrid");
595 GtkWidget* labelSchwarz = g_object_get_data (G_OBJECT (numericButton), "LabelSchwarz");
596 GtkWidget* entrySchwarz = g_object_get_data (G_OBJECT (numericButton), "EntrySchwarz");
597 gboolean checked = GTK_TOGGLE_BUTTON (numericButton)->active;
598 if(GTK_IS_WIDGET(frameGrid))gtk_widget_set_sensitive(frameGrid, checked);
599 if(GTK_IS_WIDGET(labelSchwarz)) gtk_widget_set_sensitive(labelSchwarz, !checked);
600 if(GTK_IS_WIDGET(entrySchwarz))gtk_widget_set_sensitive(entrySchwarz, !checked);
601 }
602 /********************************************************************************/
apply_coulomb_orbitals(GtkWidget * Win,gpointer data)603 static void apply_coulomb_orbitals(GtkWidget *Win,gpointer data)
604 {
605 GtkWidget** entriestmp = NULL;
606 G_CONST_RETURN gchar* temp;
607 gchar* dump;
608 gint i;
609 gint j;
610 GridLimits limitstmp;
611 gint NumPointstmp[3];
612 GtkWidget *entries[3][6];
613 gdouble V[3][3];
614 GtkWidget* alphaList = g_object_get_data (G_OBJECT (Win), "AlphaList");
615 GtkWidget* betaList = g_object_get_data (G_OBJECT (Win), "BetaList");
616 GtkWidget* numericButton = g_object_get_data (G_OBJECT (Win), "NumericButton");
617 GtkWidget* entrySchwarz = g_object_get_data (G_OBJECT (Win), "EntrySchwarz");
618 gint* numAlphaOrbs = NULL;
619 gint* numBetaOrbs = NULL;
620 gint nAlpha = 0;
621 gint nBeta = 0;
622 gdouble integ, normi, normj, overlap;
623 gchar* result = NULL;
624 FuncCompCoulomb compute_coulomb = compute_coulomb_integrale_iijj_poisson;
625 gboolean numeric = FALSE;
626 gdouble schwarzCutOff = 1e-8;
627
628 if(GTK_IS_WIDGET(Win))
629 {
630 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
631 }
632 else return;
633
634 if(entriestmp==NULL) return;
635 if(!GTK_IS_WIDGET(numericButton)) return;
636
637 numeric = GTK_TOGGLE_BUTTON (numericButton)->active;
638 if(!numeric)
639 {
640 if(!GTK_IS_WIDGET(entrySchwarz)) return;
641 schwarzCutOff = atof(gtk_entry_get_text(GTK_ENTRY(entrySchwarz)));
642 }
643 destroy_win_list();
644 if(numeric)
645 {
646 for(i=0;i<3;i++)
647 for(j=0;j<6;j++)
648 entries[i][j] = entriestmp[i*6+j];
649
650 for(i=0;i<3;i++)
651 {
652 for(j=3;j<5;j++)
653 {
654 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
655 dump = NULL;
656 if(temp && strlen(temp)>0)
657 {
658 dump = g_strdup(temp);
659 delete_first_spaces(dump);
660 delete_last_spaces(dump);
661 }
662
663 if(dump && strlen(dump)>0 && this_is_a_real(dump))
664 {
665 limitstmp.MinMax[j-3][i] = atof(dump);
666 }
667 else
668 {
669 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
670 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
671 return;
672 }
673 if(dump) g_free(dump);
674 }
675 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
676 NumPointstmp[i] = atoi(temp);
677 if(NumPointstmp[i] <=2)
678 {
679 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
680 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
681 return;
682 }
683
684 }
685
686 for(i=0;i<3;i++)
687 {
688 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
689 {
690 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
691 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
692 return;
693 }
694 }
695 for(i=0;i<3;i++)
696 {
697 for(j=0;j<3;j++)
698 {
699 V[i][j] = 0;
700 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
701 dump = NULL;
702 if(temp && strlen(temp)>0)
703 {
704 dump = g_strdup(temp);
705 delete_first_spaces(dump);
706 delete_last_spaces(dump);
707 }
708
709 if(dump && strlen(dump)>0 && this_is_a_real(dump))
710 {
711 V[i][j] = atof(dump);
712 }
713 else
714 {
715 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
716 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
717 return;
718 }
719 if(dump) g_free(dump);
720 }
721 }
722
723 for(i=0;i<3;i++)
724 {
725 gdouble norm = 0.0;
726 for(j=0;j<3;j++)
727 norm += V[i][j]*V[i][j];
728 if(fabs(norm)<1e-8)
729 {
730 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
731 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
732 return;
733 }
734 for(j=0;j<3;j++)
735 V[i][j] /= sqrt(norm);
736 }
737 for(j=0;j<3;j++) originOfCube[j] = 0;
738 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
739 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
740 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
741
742 for(i=0;i<3;i++)
743 {
744 NumPoints[i] =NumPointstmp[i] ;
745 for(j=0;j<2;j++)
746 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
747 }
748 } /* end if numeric */
749
750 CancelCalcul = FALSE;
751 /* printf("DirName = %s\n",dirName);*/
752 numAlphaOrbs = get_num_of_selected_orbitals(alphaList, &nAlpha);
753 numBetaOrbs = get_num_of_selected_orbitals(betaList, &nBeta);
754 if(nAlpha+nBeta<1)
755 {
756 GtkWidget* message = Message(_("Error : You should select at last one orbital"),_("Error"),TRUE);
757 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
758 return;
759 }
760 else if(nAlpha+nBeta==1)
761 {
762 gint i = -1;
763 gint typeOrb = -1;
764 delete_child(Win);
765 if(nAlpha==1 && numAlphaOrbs)
766 {
767 typeOrb = 1;
768 i = numAlphaOrbs[0];
769 }
770 else if(nBeta==1 && numBetaOrbs)
771 {
772 typeOrb = 2;
773 i = numBetaOrbs[0];
774 }
775 if(i>-1 && typeOrb>0)
776 {
777 gint ii = i+1;
778 if(numeric)
779 {
780 if(compute_coulomb(
781 NumPoints,limits,
782 typeOrb, i, typeOrb, i,
783 &integ, &normi, &normj, &overlap)
784 )
785 result = g_strdup_printf(
786 "<%d|%d> = %lf\n"
787 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
788 ii,ii,normi,
789 ii,ii,ii,ii,integ);
790 else
791 result = g_strdup_printf("Canceled? !\n If not see your terminal ");
792 }
793 else
794 {
795 setTextInProgress(_("Analytic computing of coulomb integral"));
796 integ = get_coulomb_analytic(typeOrb, i, typeOrb, i, schwarzCutOff);
797 normi = get_overlap_analytic(typeOrb, i, typeOrb, i);
798 result = g_strdup_printf(
799 "<%d|%d> = %lf\n"
800 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
801 ii,ii,normi,
802 ii,ii,ii,ii,integ);
803 }
804 }
805 }
806 else
807 {
808 gint typeOrbi = 1;
809 gint typeOrbj = 1;
810 delete_child(Win);
811 if(numAlphaOrbs)
812 for(i=0;i<nAlpha;i++)
813 for(j=i+1;j<nAlpha;j++)
814 {
815 gchar* tmp = NULL;
816 gint ii = numAlphaOrbs[i];
817 gint jj = numAlphaOrbs[j];
818 if(CancelCalcul) break;
819 if(numeric && compute_coulomb(
820 NumPoints,limits,
821 typeOrbi, ii, typeOrbj, jj,
822 &integ, &normi, &normj, &overlap)
823 )
824 {
825 ii++;
826 jj++;
827 tmp = g_strdup_printf(
828 "<%d|%d> = %lf\n"
829 "<%d|%d> = %lf\n"
830 "<%d|%d> = %lf\n"
831 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
832 ii,ii,normi,
833 jj,jj,normj,
834 ii,jj,overlap,
835 ii,ii,jj,jj,
836 integ);
837 }
838 else if(!numeric)
839 {
840 setTextInProgress(_("Analytic computing of coulomb integral"));
841 integ = get_coulomb_analytic(typeOrbi, ii, typeOrbj, jj, schwarzCutOff);
842 normi = get_overlap_analytic(typeOrbi, ii, typeOrbi, ii);
843 normj = get_overlap_analytic(typeOrbj, jj, typeOrbj, jj);
844 overlap = get_overlap_analytic(typeOrbi, ii, typeOrbj, jj);
845 ii++;
846 jj++;
847 tmp = g_strdup_printf(
848 "<%d|%d> = %lf\n"
849 "<%d|%d> = %lf\n"
850 "<%d|%d> = %lf\n"
851 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
852 ii,ii,normi,
853 jj,jj,normj,
854 ii,jj,overlap,
855 ii,ii,jj,jj,
856 integ);
857 }
858 if(tmp)
859 {
860 gchar* old = result;
861 if(old)
862 {
863 result = g_strdup_printf("%s%s",old,tmp);
864 g_free(old);
865 }
866 else result = g_strdup_printf("%s",tmp);
867
868 }
869 }
870 typeOrbi = 2;
871 typeOrbj = 2;
872 if(numBetaOrbs)
873 for(i=0;i<nBeta;i++)
874 for(j=i+1;j<nBeta;j++)
875 {
876 gchar* tmp = NULL;
877 gint ii = numBetaOrbs[i];
878 gint jj = numBetaOrbs[j];
879 if(CancelCalcul) break;
880 if(numeric && compute_coulomb(
881 NumPoints,limits,
882 typeOrbi, ii, typeOrbj, jj,
883 &integ, &normi, &normj, &overlap)
884 )
885 {
886 ii++;
887 jj++;
888 tmp = g_strdup_printf(
889 "<%d|%d> = %lf\n"
890 "<%d|%d> = %lf\n"
891 "<%d|%d> = %lf\n"
892 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
893 ii,ii,normi,
894 jj,jj,normj,
895 ii,jj,overlap,
896 ii,ii,jj,jj,
897 integ);
898 }
899 else if(!numeric)
900 {
901 setTextInProgress(_("Analytic computing of coulomb integral"));
902 integ = get_coulomb_analytic(typeOrbi, ii, typeOrbj, jj, schwarzCutOff);
903 normi = get_overlap_analytic(typeOrbi, ii, typeOrbi, ii);
904 normj = get_overlap_analytic(typeOrbj, jj, typeOrbj, jj);
905 overlap = get_overlap_analytic(typeOrbi, ii, typeOrbj, jj);
906 ii++;
907 jj++;
908 tmp = g_strdup_printf(
909 "<%d|%d> = %lf\n"
910 "<%d|%d> = %lf\n"
911 "<%d|%d> = %lf\n"
912 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
913 ii,ii,normi,
914 jj,jj,normj,
915 ii,jj,overlap,
916 ii,ii,jj,jj,
917 integ);
918 }
919 if(tmp)
920 {
921 gchar* old = result;
922 if(old)
923 {
924 result = g_strdup_printf("%s%s",old,tmp);
925 g_free(old);
926 }
927 else result = g_strdup_printf("%s",tmp);
928
929 }
930 }
931 typeOrbi = 1;
932 typeOrbj = 2;
933 if(numAlphaOrbs && numBetaOrbs)
934 for(i=0;i<nAlpha;i++)
935 for(j=0;j<nBeta;j++)
936 {
937 gchar* tmp = NULL;
938 gint ii = numAlphaOrbs[i];
939 gint jj = numBetaOrbs[j];
940 if(CancelCalcul) break;
941 if(numeric && compute_coulomb(
942 NumPoints,limits,
943 typeOrbi, ii, typeOrbj, jj,
944 &integ, &normi, &normj, &overlap)
945 )
946 {
947 ii++;
948 jj++;
949 tmp = g_strdup_printf(
950 "<%d|%d> = %lf\n"
951 "<%d|%d> = %lf\n"
952 "<%d|%d> = %lf\n"
953 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
954 ii,ii,normi,
955 jj,jj,normj,
956 ii,jj,overlap,
957 ii,ii,jj,jj,
958 integ);
959 }
960 else if(!numeric)
961 {
962 setTextInProgress(_("Analytic computing of coulomb integral"));
963 integ = get_coulomb_analytic(typeOrbi, ii, typeOrbj, jj, schwarzCutOff);
964 normi = get_overlap_analytic(typeOrbi, ii, typeOrbi, ii);
965 normj = get_overlap_analytic(typeOrbj, jj, typeOrbj, jj);
966 overlap = get_overlap_analytic(typeOrbi, ii, typeOrbj, jj);
967 ii++;
968 jj++;
969 tmp = g_strdup_printf(
970 "<%d|%d> = %lf\n"
971 "<%d|%d> = %lf\n"
972 "<%d|%d> = %lf\n"
973 "<%d %d|1/r12|%d %d> = %0.12lf Hartree\n",
974 ii,ii,normi,
975 jj,jj,normj,
976 ii,jj,overlap,
977 ii,ii,jj,jj,
978 integ);
979 }
980 if(tmp)
981 {
982 gchar* old = result;
983 if(old)
984 {
985 result = g_strdup_printf("%s%s",old,tmp);
986 g_free(old);
987 }
988 else result = g_strdup_printf("%s",tmp);
989
990 }
991 }
992 }
993
994 if(result && !CancelCalcul)
995 {
996 GtkWidget* message = MessageTxt(result,_("Result"));
997 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
998 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
999 }
1000
1001 /*
1002 printf("Selected alpha orbitals : ");
1003 for(i=0;i<nAlpha;i++)
1004 printf("%d ",numAlphaOrbs[i]);
1005 printf("\n");
1006 printf("Selected beta orbitals : ");
1007 for(i=0;i<nBeta;i++)
1008 printf("%d ",numBetaOrbs[i]);
1009 printf("\n");
1010 */
1011 set_label_title(NULL,0,0);
1012 if(numAlphaOrbs) g_free(numAlphaOrbs);
1013 if(numBetaOrbs) g_free(numBetaOrbs);
1014 if(CancelCalcul) CancelCalcul = FALSE;
1015 }
1016 /********************************************************************************/
select_row(GtkWidget * list,gint row)1017 static void select_row(GtkWidget* list, gint row)
1018 {
1019 GtkTreePath *path;
1020 gchar* tmp = g_strdup_printf("%d",row);
1021
1022 path = gtk_tree_path_new_from_string (tmp);
1023 g_free(tmp);
1024 if(!list) return;
1025 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), path);
1026 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list), path, NULL, FALSE,0.5,0.5);
1027 gtk_tree_path_free(path);
1028 }
1029 /********************************************************************************/
new_gtk_list_orbitals(gint N,gdouble * Energies,gdouble * Occ,gchar ** sym,gint * widall)1030 static GtkWidget* new_gtk_list_orbitals(gint N,gdouble* Energies,gdouble* Occ,gchar** sym, gint* widall)
1031 {
1032 gint i;
1033 gint j;
1034 GtkWidget* gtklist = NULL;
1035 gint *Width = NULL;
1036 gint NlistTitle = 4;
1037 gchar* Titles[] = {"Nr","Energy","Occ.","Sym."};
1038 gchar* List[4];
1039 GtkListStore *store;
1040 GtkTreeModel *model;
1041 GtkCellRenderer *renderer;
1042 GtkTreeViewColumn *column;
1043 GtkTreeSelection *select;
1044 GtkTreeIter iter;
1045 GType* types;
1046
1047 Width = g_malloc(NlistTitle*sizeof(gint));
1048
1049 for (j=0;j<NlistTitle;j++) Width[j] = strlen(Titles[j]);
1050
1051 types = g_malloc(NlistTitle*sizeof(GType));
1052 for (i=0;i<NlistTitle;i++) types[i] = G_TYPE_STRING;
1053 store = gtk_list_store_newv (NlistTitle, types);
1054 g_free(types);
1055 model = GTK_TREE_MODEL (store);
1056
1057
1058 Width[0] = (gint)(Width[0]*10);
1059 Width[1] = (gint)(Width[1]*12);
1060 Width[2] = (gint)(Width[2]*8);
1061 Width[3] = (gint)(Width[3]*14);
1062
1063 *widall = 0;
1064 for (j=0;j<NlistTitle;j++) *widall += Width[j];
1065 *widall += 60;
1066
1067 gtklist = gtk_tree_view_new_with_model (model);
1068 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (gtklist), TRUE);
1069 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gtklist), TRUE);
1070 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (gtklist), FALSE);
1071
1072 for (i=0;i<NlistTitle;i++)
1073 {
1074 column = gtk_tree_view_column_new ();
1075 gtk_tree_view_column_set_title (column, Titles[i]);
1076 renderer = gtk_cell_renderer_text_new ();
1077 gtk_tree_view_column_pack_start (column, renderer, TRUE);
1078 gtk_tree_view_column_set_min_width(column, Width[i]);
1079 gtk_tree_view_column_set_attributes (column, renderer, "text", i, NULL);
1080 gtk_tree_view_append_column (GTK_TREE_VIEW (gtklist), column);
1081 }
1082 g_free( Width);
1083
1084 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (gtklist));
1085 gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
1086
1087 for(i=0;i<N;i++)
1088 {
1089 if(strcmp(sym[i],"DELETED")==0)continue;
1090 List[0] = g_strdup_printf("%i",i+1);
1091 List[1] = g_strdup_printf("%lf",Energies[i]);
1092 List[2] = g_strdup_printf("%lf",Occ[i]);
1093 List[3] = g_strdup(sym[i]);
1094
1095 gtk_list_store_append(store, &iter);
1096 for(j=0;j<4;j++) gtk_list_store_set (store, &iter, j, List[j], -1);
1097
1098 for(j=0;j<4;j++) g_free(List[j]);
1099 }
1100 return gtklist;
1101
1102 }
1103 /********************************************************************************/
new_alpha_list(GtkWidget * hboxall)1104 static GtkWidget* new_alpha_list(GtkWidget *hboxall)
1105 {
1106 GtkWidget *frame;
1107 GtkWidget *scr;
1108 GtkWidget *vbox;
1109 GtkWidget *gtklist;
1110 gint i;
1111 gint N;
1112 gdouble* Energies;
1113 gdouble* Occ;
1114 gchar** sym;
1115 static gint type = 1;
1116 gint widall = 0;
1117
1118 N = NAlphaOrb;
1119 Energies = g_malloc(N*sizeof(gdouble));
1120 Occ = g_malloc(N*sizeof(gdouble));
1121 sym = g_malloc(N*sizeof(gchar*));
1122
1123 for(i=0;i<N;i++)
1124 {
1125 Energies[i] = EnerAlphaOrbitals[i];
1126 Occ[i] = OccAlphaOrbitals[i];
1127 sym[i] = g_strdup(SymAlphaOrbitals[i]);
1128 }
1129
1130 gtklist = new_gtk_list_orbitals(N,Energies,Occ,sym,&widall);
1131 g_object_set_data(G_OBJECT (gtklist), "Type",&type);
1132 frame = gtk_frame_new (_("Alpha Orbitals"));
1133 gtk_container_set_border_width (GTK_CONTAINER (frame), 1);
1134 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
1135 gtk_box_pack_start (GTK_BOX (hboxall), frame, TRUE, TRUE, 0);
1136 gtk_widget_show (frame);
1137 vbox = create_vbox(frame);
1138 scr=gtk_scrolled_window_new(NULL,NULL);
1139 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*WIDTHSCR));
1140 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1141 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 1);
1142 gtk_container_add(GTK_CONTAINER(scr),gtklist);
1143
1144 set_base_style(gtklist,55000,55000,55000);
1145
1146
1147 for(i=0;i<N;i++) g_free(sym[i]);
1148 g_free(Energies);
1149 g_free(Occ);
1150 g_free(sym);
1151
1152 g_object_set_data(G_OBJECT (hboxall), "AlphaList",gtklist);
1153
1154 return frame;
1155
1156 }
1157 /********************************************************************************/
new_beta_list(GtkWidget * hboxall)1158 static GtkWidget* new_beta_list(GtkWidget *hboxall)
1159 {
1160 GtkWidget *frame;
1161 GtkWidget *scr;
1162 GtkWidget *vbox;
1163 GtkWidget *gtklist;
1164 gint i;
1165 gint N;
1166 gdouble* Energies;
1167 gdouble* Occ;
1168 gchar** sym;
1169 static gint type = 2;
1170 gint widall = 0;
1171
1172 N = NBetaOrb;
1173 Energies = g_malloc(N*sizeof(gdouble));
1174 Occ = g_malloc(N*sizeof(gdouble));
1175 sym = g_malloc(N*sizeof(gchar*));
1176
1177 for(i=0;i<N;i++)
1178 {
1179 Energies[i] = EnerBetaOrbitals[i];
1180 Occ[i] = OccBetaOrbitals[i];
1181 sym[i] = g_strdup(SymBetaOrbitals[i]);
1182 }
1183
1184 gtklist = new_gtk_list_orbitals(N,Energies,Occ,sym,&widall);
1185 g_object_set_data(G_OBJECT (gtklist), "Type",&type);
1186 frame = gtk_frame_new (_("Beta Orbitals"));
1187 gtk_container_set_border_width (GTK_CONTAINER (frame), 1);
1188 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
1189 gtk_box_pack_start (GTK_BOX (hboxall), frame, TRUE, TRUE, 0);
1190 gtk_widget_show (frame);
1191 vbox = create_vbox(frame);
1192 scr=gtk_scrolled_window_new(NULL,NULL);
1193 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1194 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*WIDTHSCR));
1195 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 1);
1196 gtk_container_add(GTK_CONTAINER(scr),gtklist);
1197 set_base_style(gtklist,55000,55000,55000);
1198 gtk_widget_show (scr);
1199 gtk_widget_show (gtklist);
1200
1201 for(i=0;i<N;i++) g_free(sym[i]);
1202 g_free(Energies);
1203 g_free(Occ);
1204 g_free(sym);
1205 g_object_set_data(G_OBJECT (hboxall), "BetaList",gtklist);
1206 return frame;
1207 }
1208 /********************************************************************************/
create_orbitals_list(GtkWidget * vboxall)1209 static GtkWidget *create_orbitals_list( GtkWidget *vboxall)
1210 {
1211 GtkWidget *hbox;
1212 hbox = gtk_hbox_new (TRUE, 0);
1213 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
1214 new_alpha_list(hbox);
1215 new_beta_list(hbox);
1216 return hbox;
1217 }
1218 /********************************************************************************/
coulomb_orbitals_dlg()1219 void coulomb_orbitals_dlg()
1220 {
1221 GtkWidget *Win;
1222 GtkWidget *frameGrid;
1223 GtkWidget *frameMethod;
1224 GtkWidget *alphaList;
1225 GtkWidget *betaList;
1226 GtkWidget *hbox;
1227 GtkWidget *vboxall;
1228 GtkWidget *vboxwin;
1229 GtkWidget *button;
1230 GtkWidget *label;
1231 GtkWidget** entries;
1232 GtkWidget* numericButton = NULL;
1233 GtkWidget* vbox = NULL;
1234 GtkWidget* entrySchwarz = NULL;
1235 GtkWidget* table = NULL;
1236
1237 if(!GeomOrb)
1238 {
1239 Message(_("Sorry, Please load a file before\n"),_("Error"),TRUE);
1240 return;
1241 }
1242 if(!CoefAlphaOrbitals)
1243 {
1244 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
1245 return;
1246 }
1247 if(!AOrb && !SAOrb)
1248 {
1249 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
1250 return;
1251 }
1252
1253 if(!AOAvailable &&(TypeGrid == GABEDIT_TYPEGRID_DDENSITY || TypeGrid == GABEDIT_TYPEGRID_ADENSITY))
1254 {
1255 Message(_("Sorry, No atomic orbitals available.\nPlease use a gabedit file for load : \n"
1256 "Geometry, Molecular and Atomic Orbitals\n"),_("Error"),TRUE);
1257 return;
1258 }
1259
1260 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1261 gtk_window_set_title(GTK_WINDOW(Win),"Comlomb energy <ii|1/r12|jj>");
1262 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
1263 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
1264 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
1265 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
1266
1267 add_glarea_child(Win,"Grid ");
1268
1269 vboxall = create_vbox(Win);
1270 vboxwin = vboxall;
1271
1272
1273 hbox = gtk_hbox_new (TRUE, 0);
1274 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
1275 label = gtk_label_new("");
1276 gtk_label_set_markup(GTK_LABEL(label), "<span foreground=\"#FF0000\"><big>Use mouse + the Ctrl key (or the shift key) to select several orbitals</big></span>\n");
1277 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1278
1279 hbox = create_orbitals_list(vboxall);
1280 alphaList = g_object_get_data (G_OBJECT (hbox), "AlphaList");
1281 g_object_set_data (G_OBJECT (Win), "AlphaList",alphaList);
1282 betaList = g_object_get_data (G_OBJECT (hbox), "BetaList");
1283 g_object_set_data (G_OBJECT (Win), "BetaList",betaList);
1284
1285 gtk_box_pack_start (GTK_BOX (vboxall), gtk_hseparator_new(), TRUE, TRUE, 5);
1286
1287 frameMethod = gtk_frame_new(_("Method"));
1288 gtk_box_pack_start (GTK_BOX (vboxall), frameMethod, TRUE, TRUE, 2);
1289 vbox = create_vbox(frameMethod);
1290 gtk_widget_show_all (vbox);
1291
1292 table = gtk_table_new(2,2,FALSE);
1293 gtk_container_add(GTK_CONTAINER(vbox),table);
1294 gtk_widget_show (table);
1295
1296 numericButton = gtk_check_button_new_with_label (
1297 _("Numerical computing of the Coulomb integral (Large box is recommended)"));
1298 gtk_table_attach(GTK_TABLE(table),numericButton,0,0+2,0,0+1,
1299 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1300 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
1301 1,1);
1302 g_signal_connect(G_OBJECT(numericButton), "clicked",(GCallback)numeriButtonClicked,NULL);
1303 g_object_set_data (G_OBJECT (Win), "NumericButton",numericButton);
1304
1305 label = gtk_label_new(_(" Schwarz cutoff : "));
1306 gtk_table_attach(GTK_TABLE(table),label,0,0+1,1,1+1,
1307 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
1308 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
1309 1,1);
1310 g_object_set_data (G_OBJECT (Win), "LabelSchwarz",label);
1311 g_object_set_data (G_OBJECT (numericButton), "LabelSchwarz",label);
1312 entrySchwarz = gtk_entry_new();
1313 gtk_entry_set_text(GTK_ENTRY(entrySchwarz),"1e-8");
1314 gtk_table_attach(GTK_TABLE(table),entrySchwarz,1,1+1,1,1+1,
1315 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1316 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
1317 1,1);
1318 g_object_set_data (G_OBJECT (Win), "EntrySchwarz",entrySchwarz);
1319 g_object_set_data (G_OBJECT (numericButton), "EntrySchwarz",entrySchwarz);
1320
1321
1322 frameGrid = create_grid_frame(vboxall,"Box & Grid");
1323 entries = (GtkWidget**) g_object_get_data (G_OBJECT (frameGrid), "Entries");
1324 g_object_set_data (G_OBJECT (Win), "Entries",entries);
1325 g_object_set_data (G_OBJECT (Win), "FrameGrid",frameGrid);
1326 g_object_set_data (G_OBJECT (numericButton), "FrameGrid",frameGrid);
1327 gtk_widget_set_sensitive(frameGrid, GTK_TOGGLE_BUTTON (numericButton)->active);
1328
1329 if(!AOrb && SAOrb)
1330 {
1331 gtk_button_clicked (GTK_BUTTON (numericButton));
1332 gtk_widget_set_sensitive(numericButton, FALSE);
1333 }
1334
1335 hbox = create_hbox_false(vboxwin);
1336 gtk_widget_realize(Win);
1337
1338 button = create_button(Win,_("OK"));
1339 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
1340 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1341 gtk_widget_grab_default(button);
1342 gtk_widget_show (button);
1343 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)apply_coulomb_orbitals,G_OBJECT(Win));
1344
1345 button = create_button(Win,_("Cancel"));
1346 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1347 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
1348 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, G_OBJECT(Win));
1349 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,G_OBJECT(Win));
1350 gtk_widget_show (button);
1351
1352 gtk_widget_show_all (Win);
1353 if(NAlphaOcc-1>=0)
1354 {
1355 select_row(alphaList,NAlphaOcc-1);
1356 if(NAlphaOcc+1<=NOrb) select_row(alphaList,NAlphaOcc);
1357 }
1358 else
1359 {
1360 select_row(alphaList,0);
1361 if(2<=NOrb) select_row(alphaList,1);
1362 }
1363 }
1364 /********************************************************************************/
compute_overlap_matrix(gint typeOrb)1365 void compute_overlap_matrix(gint typeOrb)
1366 {
1367 gint i,j,k,l;
1368 gchar* result = NULL;
1369 gdouble** matrix = NULL;
1370 gdouble** CoefI = CoefAlphaOrbitals;
1371 gdouble** CoefJ = CoefAlphaOrbitals;
1372 gchar* tmp = NULL;
1373 gdouble o;
1374 gint nAll = 0;
1375 gint delta = 0;
1376 gint pos = 0;
1377 gdouble scal;
1378 gchar str[BSIZE];
1379 if(typeOrb != 1)
1380 {
1381 CoefI = CoefBetaOrbitals;
1382 CoefJ = CoefBetaOrbitals;
1383 }
1384
1385 if(NAOrb<1)
1386 {
1387 GtkWidget* message = Message(_("Error : You should read orbitals"),_("Error"),TRUE);
1388 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1389 return;
1390 }
1391 if(!AOrb && !SAOrb)
1392 {
1393 GtkWidget* message = Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
1394 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1395 return;
1396 }
1397 if(!AOrb && SAOrb)
1398 {
1399 GtkWidget* message = Message(_("Sorry, That does not work with Slater basis set\n"),_("Error"),TRUE);
1400 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1401 return;
1402 }
1403 destroy_win_list();
1404 sprintf(str,_("Computing of overlap matrix between orbitals... Please wait"));
1405 setTextInProgress(str);
1406
1407 scal = 0.01;
1408 delta = (gint)(NAOrb*(NAOrb+1)/2*scal);
1409 if(delta<1) delta = 1;
1410 pos = delta;
1411
1412 matrix = g_malloc(NAOrb*sizeof(gdouble*));
1413 for(i=0;i<NAOrb;i++)
1414 {
1415 matrix[i] = g_malloc((i+1)*sizeof(gdouble));
1416 for(j=0;j<=i;j++) matrix[i][j] = 0;
1417 }
1418 progress_orb_txt(0,str,TRUE);
1419 for(k=0;k<NAOrb;k++)
1420 {
1421 if(CancelCalcul) break;
1422 o = overlapCGTF(&AOrb[k],&AOrb[k]);
1423 nAll++;
1424 /* printf("k=%d o = %lf\n",k,o);*/
1425 for(i=0;i<NAOrb;i++)
1426 for(j=0;j<=i;j++)
1427 matrix[i][j] += CoefI[i][k]*CoefJ[j][k]*o;
1428 if(nAll>=pos)
1429 {
1430 pos += delta;
1431 progress_orb_txt(scal,str,FALSE);
1432 }
1433 }
1434 for(k=0;k<NAOrb;k++)
1435 {
1436 /* printf("---->k=%d \n",k);*/
1437 for(l=k+1;l<NAOrb;l++)
1438 {
1439 if(CancelCalcul) break;
1440 o = overlapCGTF(&AOrb[k],&AOrb[l]);
1441 nAll++;
1442 for(i=0;i<NAOrb;i++)
1443 for(j=0;j<=i;j++)
1444 matrix[i][j] += (CoefI[i][k]*CoefJ[j][l]+CoefI[i][l]*CoefJ[j][k])*o;
1445 if(nAll>=pos)
1446 {
1447 pos += delta;
1448 progress_orb_txt(scal,str,FALSE);
1449 }
1450 }
1451 if(CancelCalcul) break;
1452 }
1453
1454 progress_orb_txt(0," ",TRUE);
1455
1456 result = g_malloc(NAOrb*(NAOrb+1)/2*100*sizeof(gchar));
1457 tmp = g_malloc(BSIZE*sizeof(gchar));
1458 if(typeOrb == 1) sprintf(result," Alpha overlap matrix\n");
1459 else sprintf(result," Beta overlap matrix\n");
1460
1461 setTextInProgress(_("Preparation of text to show... Please wait"));
1462 for(i=0;i<NAOrb;i++)
1463 for(j=0;j<=i;j++)
1464 {
1465 if(CancelCalcul) break;
1466 sprintf(tmp,"<%d|%d> = %lf\n",i+1,j+1,matrix[i][j]);
1467 strcat(result,tmp);
1468 if(CancelCalcul) break;
1469 }
1470 g_free(tmp);
1471 progress_orb_txt(0," ",TRUE);
1472 if(result && !CancelCalcul)
1473 {
1474 GtkWidget* message = MessageTxt(result,_("Overlap matrix"));
1475 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1476 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
1477 }
1478 if(matrix)
1479 {
1480 for(i=0;i<NAOrb;i++)
1481 if(matrix[i]) g_free(matrix[i]);
1482 g_free(matrix);
1483 }
1484 g_free(result);
1485 }
1486 /********************************************************************************/
compute_transition_matrix(gint N[],GridLimits limits,gint typeOrbi,gint ii,gint typeOrbj,gint jj,gdouble * integ,gdouble * pNormi,gdouble * pNormj,gdouble * pOverlap,gboolean numeric)1487 gchar* compute_transition_matrix(gint N[],GridLimits limits, gint typeOrbi, gint ii, gint typeOrbj, gint jj,
1488 gdouble* integ, gdouble* pNormi, gdouble* pNormj, gdouble* pOverlap, gboolean numeric)
1489 {
1490 gchar* tmp = NULL;
1491 gdouble m = 0;
1492 if(numeric &&
1493 compute_transition_matrix_numeric( NumPoints,limits, typeOrbi, ii, typeOrbj, jj,
1494 integ, pNormi, pNormj, pOverlap)
1495 )
1496 {
1497 ii++;
1498 jj++;
1499 m = sqrt(integ[0]*integ[0]+integ[1]*integ[1]+integ[2]*integ[2]);
1500 tmp = g_strdup_printf(
1501 "<%d|%d> = %lf\n"
1502 "<%d|%d> = %lf\n"
1503 "<%d|%d> = %lf\n"
1504 "<%d|vec r|%d> = %lf %lf %lf au (Magnitude=%lf)\n"
1505 "<%d|vec r|%d> = %lf %lf %lf Debye (Magnitude=%lf)\n\n",
1506 ii,ii,*pNormi,
1507 jj,jj,*pNormj,
1508 ii,jj,*pOverlap,
1509 ii,jj, integ[0], integ[1], integ[2], m,
1510 ii,jj, integ[0]*AUTODEB, integ[1]*AUTODEB, integ[2]*AUTODEB, m*AUTODEB
1511 );
1512 }
1513 else if(!numeric)
1514 {
1515 setTextInProgress(_("Analytic computing of coulomb integral"));
1516 compute_transition_matrix_analytic(typeOrbi, ii, typeOrbj, jj, integ);
1517 *pNormi = get_overlap_analytic(typeOrbi, ii, typeOrbi, ii);
1518 *pNormj = get_overlap_analytic(typeOrbj, jj, typeOrbj, jj);
1519 *pOverlap = get_overlap_analytic(typeOrbi, ii, typeOrbj, jj);
1520 ii++;
1521 jj++;
1522 m = sqrt(integ[0]*integ[0]+integ[1]*integ[1]+integ[2]*integ[2]);
1523 tmp = g_strdup_printf(
1524 "<%d|%d> = %lf\n"
1525 "<%d|%d> = %lf\n"
1526 "<%d|%d> = %lf\n"
1527 "<%d|vec r|%d> = %lf %lf %lf au (Magnitude=%lf)\n"
1528 "<%d|vec r|%d> = %lf %lf %lf Debye (Magnitude=%lf)\n\n",
1529 ii,ii,*pNormi,
1530 jj,jj,*pNormj,
1531 ii,jj,*pOverlap,
1532 ii,jj, integ[0], integ[1], integ[2], m,
1533 ii,jj, integ[0]*AUTODEB, integ[1]*AUTODEB, integ[2]*AUTODEB, m*AUTODEB
1534 );
1535 }
1536 return tmp;
1537 }
1538 /********************************************************************************/
apply_transition_matrix(GtkWidget * Win,gpointer data)1539 static void apply_transition_matrix(GtkWidget *Win,gpointer data)
1540 {
1541 GtkWidget** entriestmp = NULL;
1542 G_CONST_RETURN gchar* temp;
1543 gchar* dump;
1544 gint i;
1545 gint j;
1546 GridLimits limitstmp;
1547 gint NumPointstmp[3];
1548 GtkWidget *entries[3][6];
1549 gdouble V[3][3];
1550 GtkWidget* alphaList = g_object_get_data (G_OBJECT (Win), "AlphaList");
1551 GtkWidget* betaList = g_object_get_data (G_OBJECT (Win), "BetaList");
1552 GtkWidget* numericButton = g_object_get_data (G_OBJECT (Win), "NumericButton");
1553 gint* numAlphaOrbs = NULL;
1554 gint* numBetaOrbs = NULL;
1555 gint nAlpha = 0;
1556 gint nBeta = 0;
1557 gdouble integ[3], normi, normj, overlap;
1558 gchar* result = NULL;
1559 gboolean numeric = FALSE;
1560
1561 if(GTK_IS_WIDGET(Win))
1562 {
1563 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
1564 }
1565 else return;
1566
1567 if(entriestmp==NULL) return;
1568 if(!GTK_IS_WIDGET(numericButton)) return;
1569
1570 numeric = GTK_TOGGLE_BUTTON (numericButton)->active;
1571 destroy_win_list();
1572 if(numeric)
1573 {
1574 for(i=0;i<3;i++)
1575 for(j=0;j<6;j++)
1576 entries[i][j] = entriestmp[i*6+j];
1577
1578 for(i=0;i<3;i++)
1579 {
1580 for(j=3;j<5;j++)
1581 {
1582 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
1583 dump = NULL;
1584 if(temp && strlen(temp)>0)
1585 {
1586 dump = g_strdup(temp);
1587 delete_first_spaces(dump);
1588 delete_last_spaces(dump);
1589 }
1590
1591 if(dump && strlen(dump)>0 && this_is_a_real(dump))
1592 {
1593 limitstmp.MinMax[j-3][i] = atof(dump);
1594 }
1595 else
1596 {
1597 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
1598 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1599 return;
1600 }
1601 if(dump) g_free(dump);
1602 }
1603 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
1604 NumPointstmp[i] = atoi(temp);
1605 if(NumPointstmp[i] <=2)
1606 {
1607 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
1608 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1609 return;
1610 }
1611
1612 }
1613
1614 for(i=0;i<3;i++)
1615 {
1616 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
1617 {
1618 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
1619 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1620 return;
1621 }
1622 }
1623 for(i=0;i<3;i++)
1624 {
1625 for(j=0;j<3;j++)
1626 {
1627 V[i][j] = 0;
1628 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
1629 dump = NULL;
1630 if(temp && strlen(temp)>0)
1631 {
1632 dump = g_strdup(temp);
1633 delete_first_spaces(dump);
1634 delete_last_spaces(dump);
1635 }
1636
1637 if(dump && strlen(dump)>0 && this_is_a_real(dump))
1638 {
1639 V[i][j] = atof(dump);
1640 }
1641 else
1642 {
1643 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
1644 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1645 return;
1646 }
1647 if(dump) g_free(dump);
1648 }
1649 }
1650
1651 for(i=0;i<3;i++)
1652 {
1653 gdouble norm = 0.0;
1654 for(j=0;j<3;j++)
1655 norm += V[i][j]*V[i][j];
1656 if(fabs(norm)<1e-8)
1657 {
1658 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
1659 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1660 return;
1661 }
1662 for(j=0;j<3;j++)
1663 V[i][j] /= sqrt(norm);
1664 }
1665 for(j=0;j<3;j++) originOfCube[j] = 0;
1666 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
1667 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
1668 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
1669
1670 for(i=0;i<3;i++)
1671 {
1672 NumPoints[i] =NumPointstmp[i] ;
1673 for(j=0;j<2;j++)
1674 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
1675 }
1676 } /* end if numeric */
1677
1678 CancelCalcul = FALSE;
1679 /* printf("DirName = %s\n",dirName);*/
1680 numAlphaOrbs = get_num_of_selected_orbitals(alphaList, &nAlpha);
1681 numBetaOrbs = get_num_of_selected_orbitals(betaList, &nBeta);
1682 if(nAlpha+nBeta<1)
1683 {
1684 GtkWidget* message = Message(_("Error : You should select at last one orbital"),_("Error"),TRUE);
1685 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
1686 return;
1687 }
1688 else if(nAlpha+nBeta==1)
1689 {
1690 gint i = -1;
1691 gint typeOrb = -1;
1692 delete_child(Win);
1693 if(nAlpha==1 && numAlphaOrbs)
1694 {
1695 typeOrb = 1;
1696 i = numAlphaOrbs[0];
1697 }
1698 else if(nBeta==1 && numBetaOrbs)
1699 {
1700 typeOrb = 2;
1701 i = numBetaOrbs[0];
1702 }
1703 if(i>-1 && typeOrb>0)
1704 {
1705 result = compute_transition_matrix(
1706 NumPoints,limits,
1707 typeOrb, i, typeOrb, i,
1708 integ, &normi, &normj, &overlap, numeric);
1709 }
1710 }
1711 else
1712 {
1713 gint typeOrbi = 1;
1714 gint typeOrbj = 1;
1715 delete_child(Win);
1716 if(numAlphaOrbs)
1717 for(i=0;i<nAlpha;i++)
1718 for(j=i+1;j<nAlpha;j++)
1719 {
1720 gchar* tmp = NULL;
1721 gint ii = numAlphaOrbs[i];
1722 gint jj = numAlphaOrbs[j];
1723 if(CancelCalcul) break;
1724 tmp = compute_transition_matrix(
1725 NumPoints,limits,
1726 typeOrbi, ii, typeOrbj, jj,
1727 integ, &normi, &normj, &overlap, numeric);
1728 if(tmp)
1729 {
1730 gchar* old = result;
1731 if(old)
1732 {
1733 result = g_strdup_printf("%s%s",old,tmp);
1734 g_free(old);
1735 }
1736 else result = g_strdup_printf("%s",tmp);
1737
1738 }
1739 }
1740 typeOrbi = 2;
1741 typeOrbj = 2;
1742 if(numBetaOrbs)
1743 for(i=0;i<nBeta;i++)
1744 for(j=i+1;j<nBeta;j++)
1745 {
1746 gchar* tmp = NULL;
1747 gint ii = numBetaOrbs[i];
1748 gint jj = numBetaOrbs[j];
1749 if(CancelCalcul) break;
1750 tmp = compute_transition_matrix(
1751 NumPoints,limits,
1752 typeOrbi, ii, typeOrbj, jj,
1753 integ, &normi, &normj, &overlap, numeric);
1754 if(tmp)
1755 {
1756 gchar* old = result;
1757 if(old)
1758 {
1759 result = g_strdup_printf("%s%s",old,tmp);
1760 g_free(old);
1761 }
1762 else result = g_strdup_printf("%s",tmp);
1763
1764 }
1765 }
1766 typeOrbi = 1;
1767 typeOrbj = 2;
1768 if(numAlphaOrbs && numBetaOrbs)
1769 for(i=0;i<nAlpha;i++)
1770 for(j=0;j<nBeta;j++)
1771 {
1772 gchar* tmp = NULL;
1773 gint ii = numAlphaOrbs[i];
1774 gint jj = numBetaOrbs[j];
1775 if(CancelCalcul) break;
1776 tmp = compute_transition_matrix(
1777 NumPoints,limits,
1778 typeOrbi, ii, typeOrbj, jj,
1779 integ, &normi, &normj, &overlap, numeric);
1780 if(tmp)
1781 {
1782 gchar* old = result;
1783 if(old)
1784 {
1785 result = g_strdup_printf("%s%s",old,tmp);
1786 g_free(old);
1787 }
1788 else result = g_strdup_printf("%s",tmp);
1789
1790 }
1791 }
1792 }
1793
1794 if(result && !CancelCalcul)
1795 {
1796 GtkWidget* message = MessageTxt(result,_("Result"));
1797 gtk_window_set_default_size (GTK_WINDOW(message),(gint)(ScreenWidth*0.8),-1);
1798 gtk_widget_set_size_request(message,(gint)(ScreenWidth*0.45),-1);
1799 /* gtk_window_set_modal (GTK_WINDOW (message), TRUE);*/
1800 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
1801 }
1802
1803 /*
1804 printf("Selected alpha orbitals : ");
1805 for(i=0;i<nAlpha;i++)
1806 printf("%d ",numAlphaOrbs[i]);
1807 printf("\n");
1808 printf("Selected beta orbitals : ");
1809 for(i=0;i<nBeta;i++)
1810 printf("%d ",numBetaOrbs[i]);
1811 printf("\n");
1812 */
1813 set_label_title(NULL,0,0);
1814 if(numAlphaOrbs) g_free(numAlphaOrbs);
1815 if(numBetaOrbs) g_free(numBetaOrbs);
1816 if(CancelCalcul) CancelCalcul = FALSE;
1817 }
1818 /********************************************************************************/
transition_matrix_orbitals_dlg()1819 void transition_matrix_orbitals_dlg()
1820 {
1821 GtkWidget *Win;
1822 GtkWidget *frameGrid;
1823 GtkWidget *frameMethod;
1824 GtkWidget *alphaList;
1825 GtkWidget *betaList;
1826 GtkWidget *hbox;
1827 GtkWidget *vboxall;
1828 GtkWidget *vboxwin;
1829 GtkWidget *button;
1830 GtkWidget *label;
1831 GtkWidget** entries;
1832 GtkWidget* numericButton = NULL;
1833 GtkWidget* vbox = NULL;
1834 GtkWidget* table = NULL;
1835
1836 if(!GeomOrb)
1837 {
1838 Message(_("Sorry, Please load a file before\n"),_("Error"),TRUE);
1839 return;
1840 }
1841 if(!CoefAlphaOrbitals)
1842 {
1843 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
1844 return;
1845 }
1846 if(!AOrb && !SAOrb)
1847 {
1848 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
1849 return;
1850 }
1851
1852 if(!AOAvailable &&(TypeGrid == GABEDIT_TYPEGRID_DDENSITY || TypeGrid == GABEDIT_TYPEGRID_ADENSITY))
1853 {
1854 Message(_("Sorry, No atomic orbitals available.\nPlease use a gabedit file for load : \n"
1855 "Geometry, Molecular and Atomic Orbitals\n"),_("Error"),TRUE);
1856 return;
1857 }
1858
1859 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1860 gtk_window_set_title(GTK_WINDOW(Win),"transition matrix element <i|vec r|j>");
1861 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
1862 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
1863 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
1864 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
1865
1866 add_glarea_child(Win,"Grid ");
1867
1868 vboxall = create_vbox(Win);
1869 vboxwin = vboxall;
1870
1871
1872 hbox = gtk_hbox_new (TRUE, 0);
1873 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
1874 label = gtk_label_new("");
1875 gtk_label_set_markup(GTK_LABEL(label), "<span foreground=\"#FF0000\"><big>Use mouse + the Ctrl key (or the shift key) to select several orbitals</big></span>\n");
1876 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1877
1878 hbox = create_orbitals_list(vboxall);
1879 alphaList = g_object_get_data (G_OBJECT (hbox), "AlphaList");
1880 g_object_set_data (G_OBJECT (Win), "AlphaList",alphaList);
1881 betaList = g_object_get_data (G_OBJECT (hbox), "BetaList");
1882 g_object_set_data (G_OBJECT (Win), "BetaList",betaList);
1883
1884 gtk_box_pack_start (GTK_BOX (vboxall), gtk_hseparator_new(), TRUE, TRUE, 5);
1885
1886 frameMethod = gtk_frame_new(_("Method"));
1887 gtk_box_pack_start (GTK_BOX (vboxall), frameMethod, TRUE, TRUE, 2);
1888 vbox = create_vbox(frameMethod);
1889 gtk_widget_show_all (vbox);
1890
1891 table = gtk_table_new(2,2,FALSE);
1892 gtk_container_add(GTK_CONTAINER(vbox),table);
1893 gtk_widget_show (table);
1894
1895 numericButton = gtk_check_button_new_with_label (
1896 _("Numerical computing (Large box is recommended)"));
1897 gtk_table_attach(GTK_TABLE(table),numericButton,0,0+2,0,0+1,
1898 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1899 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
1900 1,1);
1901 g_signal_connect(G_OBJECT(numericButton), "clicked",(GCallback)numeriButtonClicked,NULL);
1902 g_object_set_data (G_OBJECT (Win), "NumericButton",numericButton);
1903
1904 frameGrid = create_grid_frame(vboxall,"Box & Grid");
1905 entries = (GtkWidget**) g_object_get_data (G_OBJECT (frameGrid), "Entries");
1906 g_object_set_data (G_OBJECT (Win), "Entries",entries);
1907 g_object_set_data (G_OBJECT (Win), "FrameGrid",frameGrid);
1908 g_object_set_data (G_OBJECT (numericButton), "FrameGrid",frameGrid);
1909 gtk_widget_set_sensitive(frameGrid, GTK_TOGGLE_BUTTON (numericButton)->active);
1910
1911 if(!AOrb && SAOrb)
1912 {
1913 gtk_button_clicked (GTK_BUTTON (numericButton));
1914 gtk_widget_set_sensitive(numericButton, FALSE);
1915 }
1916
1917 hbox = create_hbox_false(vboxwin);
1918 gtk_widget_realize(Win);
1919
1920 button = create_button(Win,_("OK"));
1921 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
1922 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1923 gtk_widget_grab_default(button);
1924 gtk_widget_show (button);
1925 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)apply_transition_matrix,G_OBJECT(Win));
1926
1927 button = create_button(Win,_("Cancel"));
1928 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1929 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
1930 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, G_OBJECT(Win));
1931 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,G_OBJECT(Win));
1932 gtk_widget_show (button);
1933
1934 gtk_widget_show_all (Win);
1935 if(NAlphaOcc-1>=0)
1936 {
1937 select_row(alphaList,NAlphaOcc-1);
1938 if(NAlphaOcc+1<=NOrb) select_row(alphaList,NAlphaOcc);
1939 }
1940 else
1941 {
1942 select_row(alphaList,0);
1943 if(2<=NOrb) select_row(alphaList,1);
1944 }
1945 }
1946 /********************************************************************************/
compute_spatial_overlapiijj(gint N[],GridLimits limits,gint typeOrbi,gint ii,gint typeOrbj,gint jj,gdouble * integ,gdouble * pNormi,gdouble * pNormj,gdouble * pOverlap,gboolean numeric,gdouble schwarzCutOff)1947 gchar* compute_spatial_overlapiijj(gint N[],GridLimits limits, gint typeOrbi, gint ii, gint typeOrbj, gint jj,
1948 gdouble* integ, gdouble* pNormi, gdouble* pNormj, gdouble* pOverlap, gboolean numeric, gdouble schwarzCutOff)
1949 {
1950 gchar* tmp = NULL;
1951 if(numeric)
1952 {
1953 if(!compute_spatial_overlapiijj_numeric(N, limits, typeOrbi, ii, typeOrbj, jj,
1954 integ, pNormi, pNormj, pOverlap)) return tmp;
1955 if(CancelCalcul) return tmp;
1956 ii++;
1957 jj++;
1958 tmp = g_strdup_printf(
1959 "<%d|%d> = %lf\n"
1960 "<%d|%d> = %lf\n"
1961 "<%d|%d> = %lf\n"
1962 "<%d %d|delta(ri,rj)|%d %d> = %0.12lf\n",
1963 ii,ii,*pNormi,
1964 jj,jj,*pNormj,
1965 ii,jj,*pOverlap,
1966 ii,ii,jj,jj, *integ
1967 );
1968 }
1969 else if(!numeric)
1970 {
1971 setTextInProgress(_("Analytic computing of spatial overlap <ii|delta(ri,rj)|jj> integral"));
1972 *integ = compute_spatial_overlap_analytic(typeOrbi, ii, typeOrbj, jj,schwarzCutOff);
1973 if(CancelCalcul) return tmp;
1974 *pNormi = get_overlap_analytic(typeOrbi, ii, typeOrbi, ii);
1975 *pNormj = get_overlap_analytic(typeOrbj, jj, typeOrbj, jj);
1976 *pOverlap = get_overlap_analytic(typeOrbi, ii, typeOrbj, jj);
1977 ii++;
1978 jj++;
1979 tmp = g_strdup_printf(
1980 "<%d|%d> = %lf\n"
1981 "<%d|%d> = %lf\n"
1982 "<%d|%d> = %lf\n"
1983 "<%d %d|delta(ri,rj)|%d %d> = %0.12lf\n",
1984 ii,ii,*pNormi,
1985 jj,jj,*pNormj,
1986 ii,jj,*pOverlap,
1987 ii,ii,jj,jj, *integ
1988 );
1989 }
1990 return tmp;
1991 }
1992 /********************************************************************************/
apply_spatial_overlapiijj(GtkWidget * Win,gpointer data)1993 static void apply_spatial_overlapiijj(GtkWidget *Win,gpointer data)
1994 {
1995 GtkWidget** entriestmp = NULL;
1996 G_CONST_RETURN gchar* temp;
1997 gchar* dump;
1998 gint i;
1999 gint j;
2000 GridLimits limitstmp;
2001 gint NumPointstmp[3];
2002 GtkWidget *entries[3][6];
2003 gdouble V[3][3];
2004 GtkWidget* alphaList = NULL;
2005 GtkWidget* betaList = NULL;
2006 GtkWidget* numericButton = NULL;
2007 GtkWidget* entrySchwarz = NULL;
2008 gint* numAlphaOrbs = NULL;
2009 gint* numBetaOrbs = NULL;
2010 gint nAlpha = 0;
2011 gint nBeta = 0;
2012 gdouble integ[3], normi, normj, overlap;
2013 gchar* result = NULL;
2014 gboolean numeric = FALSE;
2015 gdouble schwarzCutOff;
2016
2017 if(GTK_IS_WIDGET(Win))
2018 {
2019 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
2020 alphaList = g_object_get_data (G_OBJECT (Win), "AlphaList");
2021 betaList = g_object_get_data (G_OBJECT (Win), "BetaList");
2022 numericButton = g_object_get_data (G_OBJECT (Win), "NumericButton");
2023 entrySchwarz = g_object_get_data (G_OBJECT (Win), "EntrySchwarz");
2024 }
2025 else return;
2026
2027 if(entriestmp==NULL) return;
2028 if(!GTK_IS_WIDGET(numericButton)) return;
2029
2030 if(!GTK_IS_WIDGET(entrySchwarz)) return;
2031 temp = gtk_entry_get_text(GTK_ENTRY(entrySchwarz));
2032 schwarzCutOff = atof(temp);
2033
2034 numeric = GTK_TOGGLE_BUTTON (numericButton)->active;
2035 destroy_win_list();
2036 if(numeric)
2037 {
2038 for(i=0;i<3;i++)
2039 for(j=0;j<6;j++)
2040 entries[i][j] = entriestmp[i*6+j];
2041
2042 for(i=0;i<3;i++)
2043 {
2044 for(j=3;j<5;j++)
2045 {
2046 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
2047 dump = NULL;
2048 if(temp && strlen(temp)>0)
2049 {
2050 dump = g_strdup(temp);
2051 delete_first_spaces(dump);
2052 delete_last_spaces(dump);
2053 }
2054
2055 if(dump && strlen(dump)>0 && this_is_a_real(dump))
2056 {
2057 limitstmp.MinMax[j-3][i] = atof(dump);
2058 }
2059 else
2060 {
2061 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
2062 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2063 return;
2064 }
2065 if(dump) g_free(dump);
2066 }
2067 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
2068 NumPointstmp[i] = atoi(temp);
2069 if(NumPointstmp[i] <=2)
2070 {
2071 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
2072 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2073 return;
2074 }
2075
2076 }
2077
2078 for(i=0;i<3;i++)
2079 {
2080 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
2081 {
2082 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
2083 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2084 return;
2085 }
2086 }
2087 for(i=0;i<3;i++)
2088 {
2089 for(j=0;j<3;j++)
2090 {
2091 V[i][j] = 0;
2092 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
2093 dump = NULL;
2094 if(temp && strlen(temp)>0)
2095 {
2096 dump = g_strdup(temp);
2097 delete_first_spaces(dump);
2098 delete_last_spaces(dump);
2099 }
2100
2101 if(dump && strlen(dump)>0 && this_is_a_real(dump))
2102 {
2103 V[i][j] = atof(dump);
2104 }
2105 else
2106 {
2107 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
2108 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2109 return;
2110 }
2111 if(dump) g_free(dump);
2112 }
2113 }
2114
2115 for(i=0;i<3;i++)
2116 {
2117 gdouble norm = 0.0;
2118 for(j=0;j<3;j++)
2119 norm += V[i][j]*V[i][j];
2120 if(fabs(norm)<1e-8)
2121 {
2122 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
2123 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2124 return;
2125 }
2126 for(j=0;j<3;j++)
2127 V[i][j] /= sqrt(norm);
2128 }
2129 for(j=0;j<3;j++) originOfCube[j] = 0;
2130 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
2131 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
2132 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
2133
2134 for(i=0;i<3;i++)
2135 {
2136 NumPoints[i] =NumPointstmp[i] ;
2137 for(j=0;j<2;j++)
2138 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
2139 }
2140 } /* end if numeric */
2141
2142 CancelCalcul = FALSE;
2143 /* printf("DirName = %s\n",dirName);*/
2144 numAlphaOrbs = get_num_of_selected_orbitals(alphaList, &nAlpha);
2145 numBetaOrbs = get_num_of_selected_orbitals(betaList, &nBeta);
2146 if(nAlpha+nBeta<1)
2147 {
2148 GtkWidget* message = Message(_("Error : You should select at last one orbital"),_("Error"),TRUE);
2149 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2150 return;
2151 }
2152 else if(nAlpha+nBeta==1)
2153 {
2154 gint i = -1;
2155 gint typeOrb = -1;
2156 delete_child(Win);
2157 if(nAlpha==1 && numAlphaOrbs)
2158 {
2159 typeOrb = 1;
2160 i = numAlphaOrbs[0];
2161 }
2162 else if(nBeta==1 && numBetaOrbs)
2163 {
2164 typeOrb = 2;
2165 i = numBetaOrbs[0];
2166 }
2167 if(i>-1 && typeOrb>0)
2168 {
2169 result = compute_spatial_overlapiijj(
2170 NumPoints,limits,
2171 typeOrb, i, typeOrb, i,
2172 integ, &normi, &normj, &overlap, numeric, schwarzCutOff);
2173 }
2174 }
2175 else
2176 {
2177 gint typeOrbi = 1;
2178 gint typeOrbj = 1;
2179 delete_child(Win);
2180 if(numAlphaOrbs)
2181 for(i=0;i<nAlpha;i++)
2182 for(j=i+1;j<nAlpha;j++)
2183 {
2184 gchar* tmp = NULL;
2185 gint ii = numAlphaOrbs[i];
2186 gint jj = numAlphaOrbs[j];
2187 if(CancelCalcul) break;
2188 tmp = compute_spatial_overlapiijj(
2189 NumPoints,limits,
2190 typeOrbi, ii, typeOrbj, jj,
2191 integ, &normi, &normj, &overlap, numeric, schwarzCutOff);
2192 if(tmp)
2193 {
2194 gchar* old = result;
2195 if(old)
2196 {
2197 result = g_strdup_printf("%s%s",old,tmp);
2198 g_free(old);
2199 }
2200 else result = g_strdup_printf("%s",tmp);
2201
2202 }
2203 }
2204 typeOrbi = 2;
2205 typeOrbj = 2;
2206 if(numBetaOrbs)
2207 for(i=0;i<nBeta;i++)
2208 for(j=i+1;j<nBeta;j++)
2209 {
2210 gchar* tmp = NULL;
2211 gint ii = numBetaOrbs[i];
2212 gint jj = numBetaOrbs[j];
2213 if(CancelCalcul) break;
2214 tmp = compute_spatial_overlapiijj(
2215 NumPoints,limits,
2216 typeOrbi, ii, typeOrbj, jj,
2217 integ, &normi, &normj, &overlap, numeric,schwarzCutOff);
2218 if(tmp)
2219 {
2220 gchar* old = result;
2221 if(old)
2222 {
2223 result = g_strdup_printf("%s%s",old,tmp);
2224 g_free(old);
2225 }
2226 else result = g_strdup_printf("%s",tmp);
2227
2228 }
2229 }
2230 typeOrbi = 1;
2231 typeOrbj = 2;
2232 if(numAlphaOrbs && numBetaOrbs)
2233 for(i=0;i<nAlpha;i++)
2234 for(j=0;j<nBeta;j++)
2235 {
2236 gchar* tmp = NULL;
2237 gint ii = numAlphaOrbs[i];
2238 gint jj = numBetaOrbs[j];
2239 if(CancelCalcul) break;
2240 tmp = compute_spatial_overlapiijj(
2241 NumPoints,limits,
2242 typeOrbi, ii, typeOrbj, jj,
2243 integ, &normi, &normj, &overlap, numeric,schwarzCutOff);
2244 if(tmp)
2245 {
2246 gchar* old = result;
2247 if(old)
2248 {
2249 result = g_strdup_printf("%s%s",old,tmp);
2250 g_free(old);
2251 }
2252 else result = g_strdup_printf("%s",tmp);
2253
2254 }
2255 }
2256 }
2257
2258 if(result && !CancelCalcul)
2259 {
2260 GtkWidget* message = MessageTxt(result,_("Result"));
2261 gtk_window_set_default_size (GTK_WINDOW(message),(gint)(ScreenWidth*0.8),-1);
2262 gtk_widget_set_size_request(message,(gint)(ScreenWidth*0.45),-1);
2263 /* gtk_window_set_modal (GTK_WINDOW (message), TRUE);*/
2264 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
2265 }
2266
2267 /*
2268 printf("Selected alpha orbitals : ");
2269 for(i=0;i<nAlpha;i++)
2270 printf("%d ",numAlphaOrbs[i]);
2271 printf("\n");
2272 printf("Selected beta orbitals : ");
2273 for(i=0;i<nBeta;i++)
2274 printf("%d ",numBetaOrbs[i]);
2275 printf("\n");
2276 */
2277 set_label_title(NULL,0,0);
2278 if(numAlphaOrbs) g_free(numAlphaOrbs);
2279 if(numBetaOrbs) g_free(numBetaOrbs);
2280 if(CancelCalcul) CancelCalcul = FALSE;
2281 }
2282 /********************************************************************************/
spatial_overlapiijj_orbitals_dlg()2283 void spatial_overlapiijj_orbitals_dlg()
2284 {
2285 GtkWidget *Win;
2286 GtkWidget *frameGrid;
2287 GtkWidget *frameMethod;
2288 GtkWidget *alphaList;
2289 GtkWidget *betaList;
2290 GtkWidget *hbox;
2291 GtkWidget *vboxall;
2292 GtkWidget *vboxwin;
2293 GtkWidget *button;
2294 GtkWidget *label;
2295 GtkWidget** entries;
2296 GtkWidget* numericButton = NULL;
2297 GtkWidget* vbox = NULL;
2298 GtkWidget* table = NULL;
2299 GtkWidget* entrySchwarz = NULL;
2300
2301 if(!GeomOrb)
2302 {
2303 Message(_("Sorry, Please load a file before\n"),_("Error"),TRUE);
2304 return;
2305 }
2306 if(!CoefAlphaOrbitals)
2307 {
2308 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
2309 return;
2310 }
2311 if(!AOrb && !SAOrb)
2312 {
2313 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
2314 return;
2315 }
2316
2317 if(!AOAvailable &&(TypeGrid == GABEDIT_TYPEGRID_DDENSITY || TypeGrid == GABEDIT_TYPEGRID_ADENSITY))
2318 {
2319 Message(_("Sorry, No atomic orbitals available.\nPlease use a gabedit file for load : \n"
2320 "Geometry, Molecular and Atomic Orbitals\n"),_("Error"),TRUE);
2321 return;
2322 }
2323
2324 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2325 gtk_window_set_title(GTK_WINDOW(Win),"Spatial Overlap element <ii|delta(ri,rj)|jj>");
2326 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
2327 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
2328 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
2329 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
2330
2331 add_glarea_child(Win,"Grid ");
2332
2333 vboxall = create_vbox(Win);
2334 vboxwin = vboxall;
2335
2336
2337 hbox = gtk_hbox_new (TRUE, 0);
2338 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
2339 label = gtk_label_new("");
2340 gtk_label_set_markup(GTK_LABEL(label), "<span foreground=\"#FF0000\"><big>Use mouse + the Ctrl key (or the shift key) to select several orbitals</big></span>\n");
2341 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
2342
2343 hbox = create_orbitals_list(vboxall);
2344 alphaList = g_object_get_data (G_OBJECT (hbox), "AlphaList");
2345 g_object_set_data (G_OBJECT (Win), "AlphaList",alphaList);
2346 betaList = g_object_get_data (G_OBJECT (hbox), "BetaList");
2347 g_object_set_data (G_OBJECT (Win), "BetaList",betaList);
2348
2349 gtk_box_pack_start (GTK_BOX (vboxall), gtk_hseparator_new(), TRUE, TRUE, 5);
2350
2351 frameMethod = gtk_frame_new(_("Method"));
2352 gtk_box_pack_start (GTK_BOX (vboxall), frameMethod, TRUE, TRUE, 2);
2353 vbox = create_vbox(frameMethod);
2354 gtk_widget_show_all (vbox);
2355
2356 table = gtk_table_new(2,2,FALSE);
2357 gtk_container_add(GTK_CONTAINER(vbox),table);
2358 gtk_widget_show (table);
2359
2360 numericButton = gtk_check_button_new_with_label (
2361 _("Numerical computing (Large box is recommended)"));
2362 gtk_table_attach(GTK_TABLE(table),numericButton,0,0+2,0,0+1,
2363 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
2364 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
2365 1,1);
2366 g_signal_connect(G_OBJECT(numericButton), "clicked",(GCallback)numeriButtonClicked,NULL);
2367 g_object_set_data (G_OBJECT (Win), "NumericButton",numericButton);
2368
2369 label = gtk_label_new(_(" Schwarz cutoff : "));
2370 gtk_table_attach(GTK_TABLE(table),label,0,0+1,1,1+1,
2371 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
2372 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
2373 1,1);
2374 g_object_set_data (G_OBJECT (Win), "LabelSchwarz",label);
2375 g_object_set_data (G_OBJECT (numericButton), "LabelSchwarz",label);
2376 entrySchwarz = gtk_entry_new();
2377 gtk_entry_set_text(GTK_ENTRY(entrySchwarz),"1e-8");
2378 gtk_table_attach(GTK_TABLE(table),entrySchwarz,1,1+1,1,1+1,
2379 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
2380 (GtkAttachOptions)(GTK_FILL | GTK_SHRINK),
2381 1,1);
2382 g_object_set_data (G_OBJECT (Win), "EntrySchwarz",entrySchwarz);
2383 g_object_set_data (G_OBJECT (numericButton), "EntrySchwarz",entrySchwarz);
2384
2385 frameGrid = create_grid_frame(vboxall,"Box & Grid");
2386 entries = (GtkWidget**) g_object_get_data (G_OBJECT (frameGrid), "Entries");
2387 g_object_set_data (G_OBJECT (Win), "Entries",entries);
2388 g_object_set_data (G_OBJECT (Win), "FrameGrid",frameGrid);
2389 g_object_set_data (G_OBJECT (numericButton), "FrameGrid",frameGrid);
2390 gtk_widget_set_sensitive(frameGrid, GTK_TOGGLE_BUTTON (numericButton)->active);
2391
2392 if(!AOrb && SAOrb)
2393 {
2394 gtk_button_clicked (GTK_BUTTON (numericButton));
2395 gtk_widget_set_sensitive(numericButton, FALSE);
2396 }
2397
2398 hbox = create_hbox_false(vboxwin);
2399 gtk_widget_realize(Win);
2400
2401 button = create_button(Win,_("OK"));
2402 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
2403 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2404 gtk_widget_grab_default(button);
2405 gtk_widget_show (button);
2406 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)apply_spatial_overlapiijj,G_OBJECT(Win));
2407
2408 button = create_button(Win,_("Cancel"));
2409 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2410 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
2411 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, G_OBJECT(Win));
2412 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,G_OBJECT(Win));
2413 gtk_widget_show (button);
2414
2415 gtk_widget_show_all (Win);
2416 if(NAlphaOcc-1>=0)
2417 {
2418 select_row(alphaList,NAlphaOcc-1);
2419 if(NAlphaOcc+1<=NOrb) select_row(alphaList,NAlphaOcc);
2420 }
2421 else
2422 {
2423 select_row(alphaList,0);
2424 if(2<=NOrb) select_row(alphaList,1);
2425 }
2426 }
2427 /********************************************************************************/
compute_spatial_overlapij(gint N[],GridLimits limits,gint typeOrbi,gint ii,gint typeOrbj,gint jj,gdouble * integ,gdouble * pNormi,gdouble * pNormj,gdouble * pOverlap)2428 gchar* compute_spatial_overlapij(gint N[],GridLimits limits, gint typeOrbi, gint ii, gint typeOrbj, gint jj,
2429 gdouble* integ, gdouble* pNormi, gdouble* pNormj, gdouble* pOverlap)
2430 {
2431 gchar* tmp = NULL;
2432 if(!compute_spatial_overlapij_numeric(N, limits, typeOrbi, ii, typeOrbj, jj,
2433 integ, pNormi, pNormj, pOverlap)) return tmp;
2434 if(CancelCalcul) return tmp;
2435 ii++;
2436 jj++;
2437 tmp = g_strdup_printf(
2438 "<%d|%d> = %lf\n"
2439 "<%d|%d> = %lf\n"
2440 "<%d|%d> = %lf\n"
2441 "< |%d| | |%d|> = %0.12lf\n",
2442 ii,ii,*pNormi,
2443 jj,jj,*pNormj,
2444 ii,jj,*pOverlap,
2445 ii,jj, *integ
2446 );
2447 return tmp;
2448 }
2449 /********************************************************************************/
apply_spatial_overlapij(GtkWidget * Win,gpointer data)2450 static void apply_spatial_overlapij(GtkWidget *Win,gpointer data)
2451 {
2452 GtkWidget** entriestmp = NULL;
2453 G_CONST_RETURN gchar* temp;
2454 gchar* dump;
2455 gint i;
2456 gint j;
2457 GridLimits limitstmp;
2458 gint NumPointstmp[3];
2459 GtkWidget *entries[3][6];
2460 gdouble V[3][3];
2461 GtkWidget* alphaList = NULL;
2462 GtkWidget* betaList = NULL;
2463 gint* numAlphaOrbs = NULL;
2464 gint* numBetaOrbs = NULL;
2465 gint nAlpha = 0;
2466 gint nBeta = 0;
2467 gdouble integ[3], normi, normj, overlap;
2468 gchar* result = NULL;
2469
2470 if(GTK_IS_WIDGET(Win))
2471 {
2472 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
2473 alphaList = g_object_get_data (G_OBJECT (Win), "AlphaList");
2474 betaList = g_object_get_data (G_OBJECT (Win), "BetaList");
2475 }
2476 else return;
2477
2478 if(entriestmp==NULL) return;
2479
2480 destroy_win_list();
2481
2482 for(i=0;i<3;i++)
2483 for(j=0;j<6;j++)
2484 entries[i][j] = entriestmp[i*6+j];
2485
2486 for(i=0;i<3;i++)
2487 {
2488 for(j=3;j<5;j++)
2489 {
2490 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
2491 dump = NULL;
2492 if(temp && strlen(temp)>0)
2493 {
2494 dump = g_strdup(temp);
2495 delete_first_spaces(dump);
2496 delete_last_spaces(dump);
2497 }
2498
2499 if(dump && strlen(dump)>0 && this_is_a_real(dump))
2500 {
2501 limitstmp.MinMax[j-3][i] = atof(dump);
2502 }
2503 else
2504 {
2505 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
2506 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2507 return;
2508 }
2509 if(dump) g_free(dump);
2510 }
2511 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
2512 NumPointstmp[i] = atoi(temp);
2513 if(NumPointstmp[i] <=2)
2514 {
2515 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
2516 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2517 return;
2518 }
2519
2520 }
2521
2522 for(i=0;i<3;i++)
2523 {
2524 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
2525 {
2526 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
2527 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2528 return;
2529 }
2530 }
2531 for(i=0;i<3;i++)
2532 {
2533 for(j=0;j<3;j++)
2534 {
2535 V[i][j] = 0;
2536 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
2537 dump = NULL;
2538 if(temp && strlen(temp)>0)
2539 {
2540 dump = g_strdup(temp);
2541 delete_first_spaces(dump);
2542 delete_last_spaces(dump);
2543 }
2544
2545 if(dump && strlen(dump)>0 && this_is_a_real(dump))
2546 {
2547 V[i][j] = atof(dump);
2548 }
2549 else
2550 {
2551 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
2552 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2553 return;
2554 }
2555 if(dump) g_free(dump);
2556 }
2557 }
2558
2559 for(i=0;i<3;i++)
2560 {
2561 gdouble norm = 0.0;
2562 for(j=0;j<3;j++)
2563 norm += V[i][j]*V[i][j];
2564 if(fabs(norm)<1e-8)
2565 {
2566 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
2567 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2568 return;
2569 }
2570 for(j=0;j<3;j++)
2571 V[i][j] /= sqrt(norm);
2572 }
2573 for(j=0;j<3;j++) originOfCube[j] = 0;
2574 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
2575 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
2576 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
2577
2578 for(i=0;i<3;i++)
2579 {
2580 NumPoints[i] =NumPointstmp[i] ;
2581 for(j=0;j<2;j++)
2582 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
2583 }
2584
2585 CancelCalcul = FALSE;
2586 /* printf("DirName = %s\n",dirName);*/
2587 numAlphaOrbs = get_num_of_selected_orbitals(alphaList, &nAlpha);
2588 numBetaOrbs = get_num_of_selected_orbitals(betaList, &nBeta);
2589 if(nAlpha+nBeta<1)
2590 {
2591 GtkWidget* message = Message(_("Error : You should select at last one orbital"),_("Error"),TRUE);
2592 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2593 return;
2594 }
2595 else if(nAlpha+nBeta==1)
2596 {
2597 gint i = -1;
2598 gint typeOrb = -1;
2599 delete_child(Win);
2600 if(nAlpha==1 && numAlphaOrbs)
2601 {
2602 typeOrb = 1;
2603 i = numAlphaOrbs[0];
2604 }
2605 else if(nBeta==1 && numBetaOrbs)
2606 {
2607 typeOrb = 2;
2608 i = numBetaOrbs[0];
2609 }
2610 if(i>-1 && typeOrb>0)
2611 {
2612 result = compute_spatial_overlapij( NumPoints,limits, typeOrb, i, typeOrb, i, integ, &normi, &normj, &overlap);
2613 }
2614 }
2615 else
2616 {
2617 gint typeOrbi = 1;
2618 gint typeOrbj = 1;
2619 delete_child(Win);
2620 if(numAlphaOrbs)
2621 for(i=0;i<nAlpha;i++)
2622 for(j=i+1;j<nAlpha;j++)
2623 {
2624 gchar* tmp = NULL;
2625 gint ii = numAlphaOrbs[i];
2626 gint jj = numAlphaOrbs[j];
2627 if(CancelCalcul) break;
2628 tmp = compute_spatial_overlapij( NumPoints,limits, typeOrbi, ii, typeOrbj, jj, integ, &normi, &normj, &overlap);
2629 if(tmp)
2630 {
2631 gchar* old = result;
2632 if(old)
2633 {
2634 result = g_strdup_printf("%s%s",old,tmp);
2635 g_free(old);
2636 }
2637 else result = g_strdup_printf("%s",tmp);
2638
2639 }
2640 }
2641 typeOrbi = 2;
2642 typeOrbj = 2;
2643 if(numBetaOrbs)
2644 for(i=0;i<nBeta;i++)
2645 for(j=i+1;j<nBeta;j++)
2646 {
2647 gchar* tmp = NULL;
2648 gint ii = numBetaOrbs[i];
2649 gint jj = numBetaOrbs[j];
2650 if(CancelCalcul) break;
2651 tmp = compute_spatial_overlapij( NumPoints,limits, typeOrbi, ii, typeOrbj, jj, integ, &normi, &normj, &overlap);
2652 if(tmp)
2653 {
2654 gchar* old = result;
2655 if(old)
2656 {
2657 result = g_strdup_printf("%s%s",old,tmp);
2658 g_free(old);
2659 }
2660 else result = g_strdup_printf("%s",tmp);
2661
2662 }
2663 }
2664 typeOrbi = 1;
2665 typeOrbj = 2;
2666 if(numAlphaOrbs && numBetaOrbs)
2667 for(i=0;i<nAlpha;i++)
2668 for(j=0;j<nBeta;j++)
2669 {
2670 gchar* tmp = NULL;
2671 gint ii = numAlphaOrbs[i];
2672 gint jj = numBetaOrbs[j];
2673 if(CancelCalcul) break;
2674 tmp = compute_spatial_overlapij( NumPoints,limits, typeOrbi, ii, typeOrbj, jj, integ, &normi, &normj, &overlap);
2675 if(tmp)
2676 {
2677 gchar* old = result;
2678 if(old)
2679 {
2680 result = g_strdup_printf("%s%s",old,tmp);
2681 g_free(old);
2682 }
2683 else result = g_strdup_printf("%s",tmp);
2684
2685 }
2686 }
2687 }
2688
2689 if(result && !CancelCalcul)
2690 {
2691 GtkWidget* message = MessageTxt(result,_("Result"));
2692 gtk_window_set_default_size (GTK_WINDOW(message),(gint)(ScreenWidth*0.8),-1);
2693 gtk_widget_set_size_request(message,(gint)(ScreenWidth*0.45),-1);
2694 /* gtk_window_set_modal (GTK_WINDOW (message), TRUE);*/
2695 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
2696 }
2697
2698 /*
2699 printf("Selected alpha orbitals : ");
2700 for(i=0;i<nAlpha;i++)
2701 printf("%d ",numAlphaOrbs[i]);
2702 printf("\n");
2703 printf("Selected beta orbitals : ");
2704 for(i=0;i<nBeta;i++)
2705 printf("%d ",numBetaOrbs[i]);
2706 printf("\n");
2707 */
2708 set_label_title(NULL,0,0);
2709 if(numAlphaOrbs) g_free(numAlphaOrbs);
2710 if(numBetaOrbs) g_free(numBetaOrbs);
2711 if(CancelCalcul) CancelCalcul = FALSE;
2712 }
2713 /********************************************************************************/
spatial_overlapij_orbitals_dlg()2714 void spatial_overlapij_orbitals_dlg()
2715 {
2716 GtkWidget *Win;
2717 GtkWidget *frameGrid;
2718 GtkWidget *alphaList;
2719 GtkWidget *betaList;
2720 GtkWidget *hbox;
2721 GtkWidget *vboxall;
2722 GtkWidget *vboxwin;
2723 GtkWidget *button;
2724 GtkWidget *label;
2725 GtkWidget** entries;
2726
2727 if(!GeomOrb)
2728 {
2729 Message(_("Sorry, Please load a file before\n"),_("Error"),TRUE);
2730 return;
2731 }
2732 if(!CoefAlphaOrbitals)
2733 {
2734 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
2735 return;
2736 }
2737 if(!AOrb && !SAOrb)
2738 {
2739 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
2740 return;
2741 }
2742
2743 if(!AOAvailable &&(TypeGrid == GABEDIT_TYPEGRID_DDENSITY || TypeGrid == GABEDIT_TYPEGRID_ADENSITY))
2744 {
2745 Message(_("Sorry, No atomic orbitals available.\nPlease use a gabedit file for load : \n"
2746 "Geometry, Molecular and Atomic Orbitals\n"),_("Error"),TRUE);
2747 return;
2748 }
2749
2750 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2751 gtk_window_set_title(GTK_WINDOW(Win),"Spatial Overlap element < |i| | |j|>");
2752 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
2753 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
2754 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
2755 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
2756
2757 add_glarea_child(Win,"Grid ");
2758
2759 vboxall = create_vbox(Win);
2760 vboxwin = vboxall;
2761
2762
2763 hbox = gtk_hbox_new (TRUE, 0);
2764 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
2765 label = gtk_label_new("");
2766 gtk_label_set_markup(GTK_LABEL(label), "<span foreground=\"#FF0000\"><big>Use mouse + the Ctrl key (or the shift key) to select several orbitals</big></span>\n");
2767 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
2768
2769 hbox = create_orbitals_list(vboxall);
2770 alphaList = g_object_get_data (G_OBJECT (hbox), "AlphaList");
2771 g_object_set_data (G_OBJECT (Win), "AlphaList",alphaList);
2772 betaList = g_object_get_data (G_OBJECT (hbox), "BetaList");
2773 g_object_set_data (G_OBJECT (Win), "BetaList",betaList);
2774
2775 gtk_box_pack_start (GTK_BOX (vboxall), gtk_hseparator_new(), TRUE, TRUE, 5);
2776
2777 frameGrid = create_grid_frame(vboxall,"Box & Grid");
2778 entries = (GtkWidget**) g_object_get_data (G_OBJECT (frameGrid), "Entries");
2779 g_object_set_data (G_OBJECT (Win), "Entries",entries);
2780 g_object_set_data (G_OBJECT (Win), "FrameGrid",frameGrid);
2781 gtk_widget_set_sensitive(frameGrid, TRUE);
2782
2783 hbox = create_hbox_false(vboxwin);
2784 gtk_widget_realize(Win);
2785
2786 button = create_button(Win,_("OK"));
2787 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
2788 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2789 gtk_widget_grab_default(button);
2790 gtk_widget_show (button);
2791 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)apply_spatial_overlapij,G_OBJECT(Win));
2792
2793 button = create_button(Win,_("Cancel"));
2794 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2795 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
2796 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, G_OBJECT(Win));
2797 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,G_OBJECT(Win));
2798 gtk_widget_show (button);
2799
2800 gtk_widget_show_all (Win);
2801 if(NAlphaOcc-1>=0)
2802 {
2803 select_row(alphaList,NAlphaOcc-1);
2804 if(NAlphaOcc+1<=NOrb) select_row(alphaList,NAlphaOcc);
2805 }
2806 else
2807 {
2808 select_row(alphaList,0);
2809 if(2<=NOrb) select_row(alphaList,1);
2810 }
2811 }
2812 /************************************************************************************************************/
setPartialChargesToCalculated(GtkWidget * win)2813 static void setPartialChargesToCalculated(GtkWidget *win)
2814 {
2815 gint i;
2816 gdouble* charges = NULL;
2817 if(GTK_IS_WIDGET(win)) charges = g_object_get_data(G_OBJECT (win), "Charges");
2818 if(!charges) return;
2819 for(i=0;i<nCenters;i++)
2820 GeomOrb[i].partialCharge = charges[i];
2821 glarea_rafresh(GLArea);
2822 }
2823 /************************************************************************************************************/
destroyCalculatedChargesDlg(GtkWidget * win)2824 static void destroyCalculatedChargesDlg(GtkWidget *win)
2825 {
2826 gdouble* charges = NULL;
2827 if(GTK_IS_WIDGET(win)) charges = g_object_get_data(G_OBJECT (win), "Charges");
2828 if(charges)
2829 g_free(charges);
2830 if(GTK_IS_WIDGET(win)) delete_child(win);
2831 if(GTK_IS_WIDGET(win)) gtk_widget_destroy(win);
2832 }
2833 /********************************************************************************/
showCalculatedChargesDlg(gchar * message,gchar * title,gdouble * charges)2834 static GtkWidget* showCalculatedChargesDlg(gchar *message,gchar *title,gdouble* charges)
2835 {
2836 GtkWidget *dlgWin = NULL;
2837 GtkWidget *frame;
2838 GtkWidget *vboxframe;
2839 GtkWidget *txtWid;
2840 GtkWidget *button;
2841
2842
2843 dlgWin = gtk_dialog_new();
2844 gtk_widget_realize(GTK_WIDGET(dlgWin));
2845
2846 gtk_window_set_title(GTK_WINDOW(dlgWin),title);
2847 gtk_window_set_position(GTK_WINDOW(dlgWin),GTK_WIN_POS_CENTER);
2848 gtk_window_set_modal (GTK_WINDOW (dlgWin), TRUE);
2849 gtk_window_set_transient_for(GTK_WINDOW(dlgWin),GTK_WINDOW(PrincipalWindow));
2850
2851 g_signal_connect(G_OBJECT(dlgWin), "delete_event", (GCallback)destroyCalculatedChargesDlg, NULL);
2852 frame = gtk_frame_new (NULL);
2853 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2854
2855 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
2856 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dlgWin)->vbox), frame,TRUE,TRUE,0);
2857
2858 gtk_widget_show (frame);
2859
2860 vboxframe = create_vbox(frame);
2861 txtWid = create_text_widget(vboxframe,NULL,&frame);
2862 if(message) gabedit_text_insert (GABEDIT_TEXT(txtWid), NULL, NULL, NULL,message,-1);
2863
2864 gtk_box_set_homogeneous (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), FALSE);
2865
2866 button = create_button(dlgWin,_("Partial charges of molecule <= Calculated charges"));
2867 gtk_box_pack_end (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), button, FALSE, TRUE, 5);
2868 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2869 gtk_widget_grab_default(button);
2870 g_signal_connect_swapped(G_OBJECT(button), "clicked", (GCallback)setPartialChargesToCalculated, GTK_OBJECT(dlgWin));
2871
2872 button = create_button(dlgWin,"Close");
2873 gtk_box_pack_end (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), button, FALSE, TRUE, 5);
2874 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2875 gtk_widget_grab_default(button);
2876 g_signal_connect_swapped(G_OBJECT(button), "clicked", (GCallback)destroyCalculatedChargesDlg, GTK_OBJECT(dlgWin));
2877
2878 add_button_windows(title,dlgWin);
2879 gtk_window_set_default_size (GTK_WINDOW(dlgWin), (gint)(ScreenHeight*0.6), (gint)(ScreenHeight*0.5));
2880 gtk_widget_show_all(dlgWin);
2881 g_object_set_data(G_OBJECT (dlgWin), "Charges",charges);
2882 return dlgWin;
2883 }
2884 /********************************************************************************/
compute_mulliken_charges()2885 void compute_mulliken_charges()
2886 {
2887 gint i,k,l;
2888 gchar* result = NULL;
2889 gdouble* charges = NULL;
2890 gchar* tmp = NULL;
2891 gdouble o;
2892 gint nAll = 0;
2893 gint delta = 0;
2894 gint pos = 0;
2895 gdouble scal;
2896 gchar str[BSIZE];
2897 gint kk=0;
2898
2899 if(nCenters<1) return;
2900 if(!AOrb && (!SAOrb || !SOverlaps)) return;
2901
2902 destroy_win_list();
2903 sprintf(str,_("Computing of mulliken charges... Please wait"));
2904 setTextInProgress(str);
2905
2906 scal = 0.01;
2907 delta = (gint)(NAOrb*(NAOrb+1)/2*scal);
2908 if(delta<1) delta = 1;
2909 pos = delta;
2910
2911 charges = g_malloc(nCenters*sizeof(gdouble));
2912 for(i=0;i<nCenters;i++) charges[i] = GeomOrb[i].nuclearCharge;
2913 progress_orb_txt(0,str,TRUE);
2914 kk = 0;
2915 for(k=0;k<NAOrb;k++)
2916 {
2917 gint ic = (AOrb)?AOrb[k].NumCenter:SAOrb[k].NumCenter;
2918 for(l=0;l<=k;l++)
2919 {
2920 gint jc = (AOrb)?AOrb[l].NumCenter:SAOrb[l].NumCenter;
2921 gint fact = 1;
2922 if(CancelCalcul) break;
2923 if(AOrb) o = overlapCGTF(&AOrb[k],&AOrb[l])*fact;
2924 else o = SOverlaps[kk++]*fact;
2925 /* printf("k=%d o = %lf\n",k,o);*/
2926 for(i=0;i<NAlphaOcc;i++) charges[ic] -= OccAlphaOrbitals[i]*CoefAlphaOrbitals[i][k]*CoefAlphaOrbitals[i][l]*o;
2927 for(i=0;i<NBetaOcc;i++) charges[ic] -= OccBetaOrbitals[i]*CoefBetaOrbitals[i][k]*CoefBetaOrbitals[i][l]*o;
2928 if(k!=l)
2929 {
2930 for(i=0;i<NAlphaOcc;i++) charges[jc] -= OccAlphaOrbitals[i]*CoefAlphaOrbitals[i][k]*CoefAlphaOrbitals[i][l]*o;
2931 for(i=0;i<NBetaOcc;i++) charges[jc] -= OccBetaOrbitals[i]*CoefBetaOrbitals[i][k]*CoefBetaOrbitals[i][l]*o;
2932 }
2933 nAll++;
2934 if(nAll>=pos)
2935 {
2936 pos += delta;
2937 progress_orb_txt(scal,str,FALSE);
2938 }
2939 }
2940 }
2941 progress_orb_txt(0," ",TRUE);
2942
2943 result = g_malloc(nCenters*100*sizeof(gchar));
2944 tmp = g_malloc(BSIZE*sizeof(gchar));
2945 sprintf(result," Mulliken charges\n");
2946
2947 setTextInProgress(_("Preparation of text to show... Please wait"));
2948 for(i=0;i<nCenters;i++)
2949 {
2950 if(CancelCalcul) break;
2951 sprintf(tmp,"Atom# %d : %lf\n",i+1,charges[i]);
2952 strcat(result,tmp);
2953 if(CancelCalcul) break;
2954 }
2955 g_free(tmp);
2956 progress_orb_txt(0," ",TRUE);
2957 if(result && !CancelCalcul)
2958 {
2959 GtkWidget* message = showCalculatedChargesDlg(result,"Mulliken charges",charges);
2960 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
2961 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
2962 }
2963 g_free(result);
2964 }
2965 /************************************************************************************************************/
setBondOrdersToCalculated(GtkWidget * win)2966 static void setBondOrdersToCalculated(GtkWidget *win)
2967 {
2968 gint i;
2969 gint j;
2970 gdouble* bondOrders = NULL;
2971 if(GTK_IS_WIDGET(win)) bondOrders = g_object_get_data(G_OBJECT (win), "BondOrders");
2972 if(!bondOrders) return;
2973 freeBondsOrb();
2974 if(nCenters<1) return ;
2975 for(i = 0;i<nCenters;i++)
2976 {
2977 for(j=i+1;j<nCenters;j++)
2978 {
2979 gint ii = i*nCenters + j - i*(i+1)/2;
2980 if(i>j) ii = j*nCenters + i - j*(j+1)/2;
2981 if((gint)(bondOrders[ii]+0.5)==1)
2982 {
2983 BondType* A=g_malloc(sizeof(BondType));
2984 A->n1 = i;
2985 A->n2 = j;
2986 A->bondType = GABEDIT_BONDTYPE_SINGLE;
2987 BondsOrb = g_list_append(BondsOrb,A);
2988 }
2989 else if((gint)(bondOrders[ii]+0.5)==2)
2990 {
2991 BondType* A=g_malloc(sizeof(BondType));
2992 A->n1 = i;
2993 A->n2 = j;
2994 A->bondType = GABEDIT_BONDTYPE_DOUBLE;
2995 BondsOrb = g_list_append(BondsOrb,A);
2996 }
2997 else if((gint)(bondOrders[ii]+0.5)==3)
2998 {
2999 BondType* A=g_malloc(sizeof(BondType));
3000 A->n1 = i;
3001 A->n2 = j;
3002 A->bondType = GABEDIT_BONDTYPE_TRIPLE;
3003 BondsOrb = g_list_append(BondsOrb,A);
3004 }
3005 else
3006 if(ShowHBondOrb && hbonded(i,j))
3007 {
3008 BondType* A=g_malloc(sizeof(BondType));
3009 A->n1 = i;
3010 A->n2 = j;
3011 A->bondType = GABEDIT_BONDTYPE_HYDROGEN;
3012 BondsOrb = g_list_append(BondsOrb,A);
3013 }
3014 }
3015 }
3016 RebuildGeom = TRUE;
3017 glarea_rafresh(GLArea);
3018 }
3019 /************************************************************************************************************/
destroyCalculatedBondOrdersDlg(GtkWidget * win)3020 static void destroyCalculatedBondOrdersDlg(GtkWidget *win)
3021 {
3022 gdouble* bondOrders = NULL;
3023 if(GTK_IS_WIDGET(win)) bondOrders = g_object_get_data(G_OBJECT (win), "BondOrders");
3024 if(bondOrders) g_free(bondOrders);
3025 if(GTK_IS_WIDGET(win)) delete_child(win);
3026 if(GTK_IS_WIDGET(win)) gtk_widget_destroy(win);
3027 }
3028 /********************************************************************************/
showCalculatedBondOrdersDlg(gchar * message,gchar * title,gdouble * bondOrders)3029 static GtkWidget* showCalculatedBondOrdersDlg(gchar *message,gchar *title,gdouble* bondOrders)
3030 {
3031 GtkWidget *dlgWin = NULL;
3032 GtkWidget *frame;
3033 GtkWidget *vboxframe;
3034 GtkWidget *txtWid;
3035 GtkWidget *button;
3036
3037
3038 dlgWin = gtk_dialog_new();
3039 gtk_widget_realize(GTK_WIDGET(dlgWin));
3040
3041 gtk_window_set_title(GTK_WINDOW(dlgWin),title);
3042 gtk_window_set_position(GTK_WINDOW(dlgWin),GTK_WIN_POS_CENTER);
3043 gtk_window_set_modal (GTK_WINDOW (dlgWin), TRUE);
3044 gtk_window_set_transient_for(GTK_WINDOW(dlgWin),GTK_WINDOW(PrincipalWindow));
3045
3046 g_signal_connect(G_OBJECT(dlgWin), "delete_event", (GCallback)destroyCalculatedBondOrdersDlg, NULL);
3047 frame = gtk_frame_new (NULL);
3048 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3049
3050 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
3051 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(dlgWin)->vbox), frame,TRUE,TRUE,0);
3052
3053 gtk_widget_show (frame);
3054
3055 vboxframe = create_vbox(frame);
3056 txtWid = create_text_widget(vboxframe,NULL,&frame);
3057 if(message) gabedit_text_insert (GABEDIT_TEXT(txtWid), NULL, NULL, NULL,message,-1);
3058
3059 gtk_box_set_homogeneous (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), FALSE);
3060
3061 button = create_button(dlgWin,_("Multiple bonds <= Calculated bondOrders"));
3062 gtk_box_pack_end (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), button, FALSE, TRUE, 5);
3063 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
3064 gtk_widget_grab_default(button);
3065 g_signal_connect_swapped(G_OBJECT(button), "clicked", (GCallback)setBondOrdersToCalculated, GTK_OBJECT(dlgWin));
3066
3067 button = create_button(dlgWin,"Close");
3068 gtk_box_pack_end (GTK_BOX( GTK_DIALOG(dlgWin)->action_area), button, FALSE, TRUE, 5);
3069 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
3070 gtk_widget_grab_default(button);
3071 g_signal_connect_swapped(G_OBJECT(button), "clicked", (GCallback)destroyCalculatedBondOrdersDlg, GTK_OBJECT(dlgWin));
3072
3073 add_button_windows(title,dlgWin);
3074 gtk_window_set_default_size (GTK_WINDOW(dlgWin), (gint)(ScreenHeight*0.6), (gint)(ScreenHeight*0.5));
3075 gtk_widget_show_all(dlgWin);
3076 g_object_set_data(G_OBJECT (dlgWin), "BondOrders",bondOrders);
3077 return dlgWin;
3078 }
3079 /********************************************************************************/
compute_bondOrders()3080 void compute_bondOrders()
3081 {
3082 gint i,j,k,l,m;
3083 gchar* result = NULL;
3084 gdouble* bondOrders = NULL;
3085 gchar* tmp = NULL;
3086 gdouble o;
3087 gint nAll = 0;
3088 gint delta = 0;
3089 gint pos = 0;
3090 gdouble scal;
3091 gchar str[BSIZE];
3092 gdouble** S = NULL;
3093 gdouble** Pa = NULL;
3094 gdouble** Pb = NULL;
3095 gdouble** PS = NULL;
3096 gint n2 = nCenters*(nCenters+1)/2;
3097 gint kk;
3098
3099 if(nCenters<1) return;
3100 if(!AOrb && (!SAOrb || !SOverlaps)) return;
3101
3102 destroy_win_list();
3103 sprintf(str,_("Computing of bond order matrix... Please wait"));
3104 setTextInProgress(str);
3105
3106 scal = 0.01;
3107 delta = (gint)(NAOrb*(NAOrb+1)/2*scal);
3108 if(delta<1) delta = 1;
3109 pos = delta;
3110
3111 bondOrders = g_malloc(n2*sizeof(gdouble));
3112 for(i=0;i<n2;i++) bondOrders[i] = 0;
3113
3114 S = g_malloc(NAOrb*sizeof(gdouble*));
3115 for(i=0;i<NAOrb;i++) S[i] = g_malloc(NAOrb*sizeof(gdouble));
3116 for(i=0;i<NAOrb;i++)
3117 for(j=0;j<NAOrb;j++) S[i][j] = 0;
3118
3119 Pa = g_malloc(NAOrb*sizeof(gdouble*));
3120 for(i=0;i<NAOrb;i++) Pa[i] = g_malloc(NAOrb*sizeof(gdouble));
3121 for(i=0;i<NAOrb;i++)
3122 for(j=0;j<NAOrb;j++) Pa[i][j] = 0;
3123
3124 Pb = g_malloc(NAOrb*sizeof(gdouble*));
3125 for(i=0;i<NAOrb;i++) Pb[i] = g_malloc(NAOrb*sizeof(gdouble));
3126 for(i=0;i<NAOrb;i++)
3127 for(j=0;j<NAOrb;j++) Pb[i][j] = 0;
3128
3129 PS = g_malloc(NAOrb*sizeof(gdouble*));
3130 for(i=0;i<NAOrb;i++) PS[i] = g_malloc(NAOrb*sizeof(gdouble));
3131 for(i=0;i<NAOrb;i++)
3132 for(j=0;j<NAOrb;j++) PS[i][j] = 0;
3133
3134 progress_orb_txt(0,str,TRUE);
3135 kk = 0;
3136 for(k=0;k<NAOrb;k++)
3137 {
3138 for(l=0;l<=k;l++)
3139 {
3140 double s = 0;
3141 if(CancelCalcul) break;
3142 if(AOrb) o = overlapCGTF(&AOrb[k],&AOrb[l]);
3143 else o = SOverlaps[kk++];
3144 S[k][l] = o;
3145 if(k!=l) S[l][k] = S[k][l];
3146
3147 s = 0;
3148 for(i=0;i<NAOrb;i++)
3149 s += OccAlphaOrbitals[i]*CoefAlphaOrbitals[i][k]*CoefAlphaOrbitals[i][l];
3150 Pa[k][l] += s;
3151 if(k!=l) Pa[l][k] += s;
3152 s = 0;
3153 for(i=0;i<NAOrb;i++)
3154 s += OccBetaOrbitals[i]*CoefBetaOrbitals[i][k]*CoefBetaOrbitals[i][l];
3155 Pb[k][l] += s;
3156 if(k!=l) Pb[l][k] += s;
3157 nAll++;
3158 if(nAll>=pos)
3159 {
3160 pos += delta;
3161 progress_orb_txt(scal,str,FALSE);
3162 }
3163 }
3164 }
3165 for(k=0;k<NAOrb;k++)
3166 for(l=0;l<NAOrb;l++)
3167 {
3168 PS[k][l] = 0;
3169 for(m=0;m<NAOrb;m++) PS[k][l] += Pa[k][m]*S[m][l];
3170 }
3171
3172 /*
3173 printf("Density matrix alpha\n");
3174 for(k=0;k<NAOrb;k++) {for(l=0;l<=k;l++) printf("%f ",PS[k][l]); printf("\n");}
3175 */
3176
3177 double s1 = 0;
3178 for(k=0;k<NAOrb;k++)
3179 {
3180 gint i = (AOrb)?AOrb[k].NumCenter:SAOrb[k].NumCenter;
3181 for(l=0;l<NAOrb;l++)
3182 {
3183 gint j = (AOrb)?AOrb[l].NumCenter:SAOrb[l].NumCenter;
3184 gint ii = i*nCenters + j - i*(i+1)/2;
3185 if(i>j) ii = j*nCenters + i - j*(j+1)/2;
3186 bondOrders[ii] += PS[k][l]*PS[l][k];
3187 }
3188 /* printf(" k %d %f\n",i, PS[k][k]);*/
3189 s1 += PS[k][k];
3190 }
3191 /* printf(" s1 = %f\n",s1);*/
3192 for(k=0;k<NAOrb;k++)
3193 for(l=0;l<NAOrb;l++)
3194 {
3195 PS[k][l] = 0;
3196 for(m=0;m<NAOrb;m++) PS[k][l] += Pb[k][m]*S[m][l];
3197 }
3198
3199 /*
3200 printf("Density matrix beta\n");
3201 for(k=0;k<NAOrb;k++) {for(l=0;l<=k;l++) printf("%f ",2*PS[k][l]); printf("\n");}
3202 */
3203
3204 double s2 = 0;
3205 for(k=0;k<NAOrb;k++)
3206 {
3207 gint i = (AOrb)?AOrb[k].NumCenter:SAOrb[k].NumCenter;
3208 for(l=0;l<NAOrb;l++)
3209 {
3210 gint j = (AOrb)?AOrb[l].NumCenter:SAOrb[l].NumCenter;
3211 gint ii = i*nCenters + j - i*(i+1)/2;
3212 if(i>j) ii = j*nCenters + i - j*(j+1)/2;
3213 bondOrders[ii] += PS[k][l]*PS[l][k];
3214 }
3215 /* printf(" k %d %f\n",i, PS[k][k]);*/
3216 s2 += PS[k][k];
3217 }
3218 /* printf(" s2 = %f\n",s2);*/
3219 progress_orb_txt(0," ",TRUE);
3220 for(i=0;i<NAOrb;i++) g_free(S[i]);
3221 g_free(S);
3222 for(i=0;i<NAOrb;i++) g_free(Pa[i]);
3223 g_free(Pa);
3224 for(i=0;i<NAOrb;i++) g_free(Pb[i]);
3225 g_free(Pb);
3226 for(i=0;i<NAOrb;i++) g_free(PS[i]);
3227 g_free(PS);
3228
3229 result = g_malloc(n2*100*sizeof(gchar));
3230 tmp = g_malloc(BSIZE*sizeof(gchar));
3231 sprintf(result," BondOrders\n");
3232
3233 setTextInProgress(_("Preparation of text to show... Please wait"));
3234 for(i=0;i<nCenters;i++)
3235 for(j=i+1;j<nCenters;j++)
3236 {
3237 gint ii = i*nCenters + j - i*(i+1)/2;
3238 if(i>j) ii = j*nCenters + i - j*(j+1)/2;
3239 if(CancelCalcul) break;
3240 sprintf(tmp,"Bond %d-%d : %lf\n",i+1,j+1,bondOrders[ii]);
3241 strcat(result,tmp);
3242 if(CancelCalcul) break;
3243 }
3244 g_free(tmp);
3245 progress_orb_txt(0," ",TRUE);
3246 if(result && !CancelCalcul)
3247 {
3248 GtkWidget* message = showCalculatedBondOrdersDlg(result,"Bond orders ",bondOrders);
3249 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3250 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
3251 }
3252 g_free(result);
3253 }
3254 /********************************************************************************/
messageErrorTrans(gchar * fileName)3255 static void messageErrorTrans(gchar* fileName)
3256 {
3257 gchar buffer[BSIZE];
3258 sprintf(buffer,_("Sorry, I can not read transition properties from '%s' file\n"),fileName);
3259 Message(buffer,_("Error"),TRUE);
3260 }
3261 /********************************************************************************/
3262 /*
3263 static gboolean read_tansition_properties(GabeditFileChooser *SelecFile, gint response_id)
3264 {
3265 gchar t[BSIZE];
3266 gchar type1[20];
3267 gchar type2[20];
3268 gint i1;
3269 gint i2;
3270 gdouble coef;
3271 gboolean OK = TRUE;
3272 gint numberOfTransitions = 0;
3273 gint* fromI = NULL;
3274 gint* toI = NULL;
3275 gchar** fromType = NULL;
3276 gchar** toType = NULL;
3277 gdouble* coefficients = NULL;
3278 gchar *FileName;
3279 FILE *fd;
3280 int ne = 0;
3281
3282 if(response_id != GTK_RESPONSE_OK) return FALSE;
3283 FileName = gabedit_file_chooser_get_current_file(SelecFile);
3284
3285 fd = FOpen(FileName, "rb");
3286 if(!fd) return FALSE;
3287
3288 while(!feof(fd))
3289 {
3290 if(!fgets(t,BSIZE,fd))break;
3291 ne = sscanf(t,"%d %s %d %s %lf",&i1,type1, &i2, type2, &coef);
3292 if(ne==5 && i1<=NAOrb && i2<=NAOrb && i1>0 && i2>0)
3293 {
3294 numberOfTransitions++;
3295 coefficients = g_realloc(coefficients, numberOfTransitions*sizeof(gdouble));
3296 fromI = g_realloc(fromI, numberOfTransitions*sizeof(gint));
3297 toI = g_realloc(toI, numberOfTransitions*sizeof(gint));
3298 fromType = g_realloc(fromType, numberOfTransitions*sizeof(gchar*));
3299 toType = g_realloc(toType, numberOfTransitions*sizeof(gchar*));
3300 coefficients[numberOfTransitions-1] = coef;
3301 fromI[numberOfTransitions-1] = i1;
3302 toI[numberOfTransitions-1] = i2;
3303 fromType[numberOfTransitions-1] = g_strdup(type1);
3304 toType[numberOfTransitions-1] = g_strdup(type2);
3305 printf("t=%s\n",t);
3306 }
3307 else { OK= FALSE; break;}
3308 }
3309
3310 if(numberOfTransitions>0 && OK)
3311 {
3312 //createIRSpectrumWin(numberOfFrequencies, frequencies, intensities);
3313 }
3314 else
3315 {
3316 OK = FALSE;
3317 messageErrorTrans(FileName);
3318 }
3319
3320
3321 if(coefficients) g_free(coefficients);
3322 if(fromType)
3323 {
3324 gint i;
3325 for(i=0;i<numberOfTransitions;i++) if(fromType[i]) g_free(fromType[i]);
3326 g_free(fromType);
3327 }
3328 if(toType)
3329 {
3330 gint i;
3331 for(i=0;i<numberOfTransitions;i++) if(toType[i]) g_free(toType[i]);
3332 g_free(toType);
3333 }
3334 if(fromI) g_free(fromI);
3335 if(toI) g_free(toI);
3336
3337 fclose(fd);
3338 return OK;
3339 }
3340 */
3341 /********************************************************************************/
3342 /*
3343 void lambda_diagnostic_dlg()
3344 {
3345 GtkWidget* filesel =
3346 file_chooser_open(read_tansition_properties,
3347 _("Read transition properties from a sample file(5columns : num1 type(alpha or beta) num2 type coffeifient)"),
3348 GABEDIT_TYPEFILE_TXT,GABEDIT_TYPEWIN_OTHER);
3349
3350 gtk_window_set_modal (GTK_WINDOW (filesel), TRUE);
3351 }
3352 */
3353 /********************************************************************************/
apply_lambda_diagnostic(GtkWidget * Win,gpointer data)3354 static void apply_lambda_diagnostic(GtkWidget *Win,gpointer data)
3355 {
3356 GtkWidget** entriestmp = NULL;
3357 G_CONST_RETURN gchar* temp;
3358 gchar* dump;
3359 gint i;
3360 gint j;
3361 GridLimits limitstmp;
3362 gint NumPointstmp[3];
3363 GtkWidget *entries[3][6];
3364 gdouble V[3][3];
3365 GtkWidget* buttonFileSelector = NULL;
3366 gdouble integ[3], normi, normj, overlap;
3367 gchar* result = NULL;
3368
3369 gchar t[BSIZE];
3370 gchar type1[20];
3371 gchar type2[20];
3372 gint i1;
3373 gint i2;
3374 gdouble coef;
3375 gboolean OK = TRUE;
3376 gint numberOfTransitions = 0;
3377 gint* fromI = NULL;
3378 gint* toI = NULL;
3379 gint* fromType = NULL;
3380 gint* toType = NULL;
3381 gdouble* coefficients = NULL;
3382 gchar *FileName;
3383 FILE *fd;
3384 int ne = 0;
3385
3386 if(GTK_IS_WIDGET(Win))
3387 {
3388 entriestmp = (GtkWidget **)g_object_get_data(G_OBJECT (Win), "Entries");
3389 buttonFileSelector = g_object_get_data (G_OBJECT (Win), "ButtonFileSelector");
3390 }
3391 else return;
3392
3393 if(entriestmp==NULL) return;
3394 if(!buttonFileSelector) return;
3395
3396 for(i=0;i<3;i++)
3397 for(j=0;j<6;j++)
3398 entries[i][j] = entriestmp[i*6+j];
3399
3400 for(i=0;i<3;i++)
3401 {
3402 for(j=3;j<5;j++)
3403 {
3404 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
3405 dump = NULL;
3406 if(temp && strlen(temp)>0)
3407 {
3408 dump = g_strdup(temp);
3409 delete_first_spaces(dump);
3410 delete_last_spaces(dump);
3411 }
3412
3413 if(dump && strlen(dump)>0 && this_is_a_real(dump))
3414 {
3415 limitstmp.MinMax[j-3][i] = atof(dump);
3416 }
3417 else
3418 {
3419 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
3420 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3421 return;
3422 }
3423 if(dump) g_free(dump);
3424 }
3425 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][5]));
3426 NumPointstmp[i] = atoi(temp);
3427 if(NumPointstmp[i] <=2)
3428 {
3429 GtkWidget* message = Message(_("Error : The number of points should be > 2. "),_("Error"),TRUE);
3430 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3431 return;
3432 }
3433
3434 }
3435
3436 for(i=0;i<3;i++)
3437 {
3438 if( limitstmp.MinMax[0][i]> limitstmp.MinMax[1][i])
3439 {
3440 GtkWidget* message = Message(_("Error : The minimal value should be smaller than the maximal value "),_("Error"),TRUE);
3441 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3442 return;
3443 }
3444 }
3445 for(i=0;i<3;i++)
3446 {
3447 for(j=0;j<3;j++)
3448 {
3449 V[i][j] = 0;
3450 temp = gtk_entry_get_text(GTK_ENTRY(entries[i][j]));
3451 dump = NULL;
3452 if(temp && strlen(temp)>0)
3453 {
3454 dump = g_strdup(temp);
3455 delete_first_spaces(dump);
3456 delete_last_spaces(dump);
3457 }
3458
3459 if(dump && strlen(dump)>0 && this_is_a_real(dump))
3460 {
3461 V[i][j] = atof(dump);
3462 }
3463 else
3464 {
3465 GtkWidget* message = Message(_("Error : an entry is not a float "),_("Error"),TRUE);
3466 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3467 return;
3468 }
3469 if(dump) g_free(dump);
3470 }
3471 }
3472
3473 for(i=0;i<3;i++)
3474 {
3475 gdouble norm = 0.0;
3476 for(j=0;j<3;j++)
3477 norm += V[i][j]*V[i][j];
3478 if(fabs(norm)<1e-8)
3479 {
3480 GtkWidget* message = Message(_("Error : the norm is equal to 0 "),_("Error"),TRUE);
3481 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3482 return;
3483 }
3484 for(j=0;j<3;j++)
3485 V[i][j] /= sqrt(norm);
3486 }
3487 for(j=0;j<3;j++) originOfCube[j] = 0;
3488 for(j=0;j<3;j++) firstDirection[j] = V[0][j];
3489 for(j=0;j<3;j++) secondDirection[j] = V[1][j];
3490 for(j=0;j<3;j++) thirdDirection[j] = V[2][j];
3491
3492 for(i=0;i<3;i++)
3493 {
3494 NumPoints[i] =NumPointstmp[i] ;
3495 for(j=0;j<2;j++)
3496 limits.MinMax[j][i] =limitstmp.MinMax[j][i];
3497 }
3498
3499 CancelCalcul = FALSE;
3500 /* printf("DirName = %s\n",dirName);*/
3501 FileName = gabedit_file_chooser_get_current_file(GABEDIT_FILE_CHOOSER(buttonFileSelector));
3502
3503 fd = FOpen(FileName, "rb");
3504 if(!fd)
3505 {
3506 GtkWidget* message = Message(_("I cannot open the data file "),_("Error"),TRUE);
3507 gtk_window_set_modal (GTK_WINDOW (message), TRUE);
3508 return;
3509 }
3510
3511
3512 while(!feof(fd))
3513 {
3514 gdouble scale = 1.0;
3515 if(!fgets(t,BSIZE,fd))break;
3516 ne = sscanf(t,"%d %s %d %s %lf",&i1,type1, &i2, type2, &coef);
3517 if(ne!=5 ) { ne = sscanf(t,"%d %d %lf",&i1, &i2, &coef); ne=5; sprintf(type1,"A"); sprintf(type2,"A"); scale = sqrt(2.0);}
3518 if(ne==5 && i1<=NAOrb && i2<=NAOrb && i1>0 && i2>0)
3519 {
3520 numberOfTransitions++;
3521 coefficients = g_realloc(coefficients, numberOfTransitions*sizeof(gdouble));
3522 fromI = g_realloc(fromI, numberOfTransitions*sizeof(gint));
3523 toI = g_realloc(toI, numberOfTransitions*sizeof(gint));
3524 fromType = g_realloc(fromType, numberOfTransitions*sizeof(gchar*));
3525 toType = g_realloc(toType, numberOfTransitions*sizeof(gchar*));
3526 coefficients[numberOfTransitions-1] = coef*scale;
3527 fromI[numberOfTransitions-1] = i1-1;
3528 toI[numberOfTransitions-1] = i2-1;
3529 fromType[numberOfTransitions-1] = 1;
3530 toType[numberOfTransitions-1] = 1;
3531 if(strstr(type1,"B") || strstr(type1,"b")) fromType[numberOfTransitions-1] = 2;
3532 if(strstr(type2,"B") || strstr(type2,"b")) toType[numberOfTransitions-1] = 2;
3533 printf("t=%s\n",t);
3534 }
3535 else { OK= FALSE; break;}
3536 }
3537 if(numberOfTransitions==0 || !OK)
3538 {
3539 messageErrorTrans(FileName);
3540 if(coefficients) g_free(coefficients);
3541 if(fromType) g_free(fromType);
3542 if(toType) g_free(toType);
3543 if(fromI) g_free(fromI);
3544 if(toI) g_free(toI);
3545 return;
3546 }
3547 fclose(fd);
3548
3549 /* computing */
3550 {
3551 gint typeOrbi = 1;
3552 gint typeOrbj = 1;
3553 gdouble lambda = 0.0;
3554 gdouble sum = 0.0;
3555 gdouble cc = 0.0;
3556 gchar* old;
3557 delete_child(Win);
3558 for(i=0;i<numberOfTransitions;i++)
3559 {
3560 gchar* tmp = NULL;
3561 gint ii = fromI[i];
3562 gint jj = toI[i];
3563 typeOrbi = fromType[i];
3564 typeOrbj = toType[i];
3565 if(CancelCalcul) break;
3566 tmp = compute_spatial_overlapij( NumPoints,limits, typeOrbi, ii, typeOrbj, jj, integ, &normi, &normj, &overlap);
3567 if(tmp)
3568 {
3569 old = result;
3570 if(old)
3571 {
3572 result = g_strdup_printf("%s%s",old,tmp);
3573 g_free(old);
3574 }
3575 else result = g_strdup_printf("%s",tmp);
3576
3577 }
3578 cc = coefficients[i]*coefficients[i];
3579 sum += cc;
3580 lambda += *integ*cc;
3581 }
3582 if(sum>0) lambda /= sum;
3583 /* put result in result variable */
3584 old = result;
3585 if(old)
3586 {
3587 result = g_strdup_printf("%s\nSum = %f\nLambda = %f\n",old,sum,lambda);
3588 g_free(old);
3589 }
3590 else result = g_strdup_printf("Sum = %f\nLambda = %f\n",sum,lambda);
3591 }
3592
3593 if(result && !CancelCalcul)
3594 {
3595 GtkWidget* message = MessageTxt(result,_("Result"));
3596 gtk_window_set_default_size (GTK_WINDOW(message),(gint)(ScreenWidth*0.8),-1);
3597 gtk_widget_set_size_request(message,(gint)(ScreenWidth*0.45),-1);
3598 /* gtk_window_set_modal (GTK_WINDOW (message), TRUE);*/
3599 gtk_window_set_transient_for(GTK_WINDOW(message),GTK_WINDOW(PrincipalWindow));
3600 }
3601
3602 set_label_title(NULL,0,0);
3603 if(CancelCalcul) CancelCalcul = FALSE;
3604 if(coefficients) g_free(coefficients);
3605 if(fromType) g_free(fromType);
3606 if(toType) g_free(toType);
3607 if(fromI) g_free(fromI);
3608 if(toI) g_free(toI);
3609
3610 }
3611 /***************************************************************************/
help_trans_prop()3612 static void help_trans_prop()
3613 {
3614 gchar temp[BSIZE];
3615 GtkWidget* win;
3616 sprintf(temp,
3617 _(" Lambda is calculated as in M.J.G. Peach et al. J. Chem. Phys. 128, 044118 (2008).\n\n"
3618 " You must select the file containing the transition properties. \n\n"
3619 " The text file must contain 5 columns by line.\n"
3620 " First column : an integer. The electron is excited from this orbital.\n"
3621 " second column : a character B or A. The spin of electron.\n"
3622 " Third column : an integer. The electron is excited to this orbital.\n"
3623 " Forth column : a character B or A. The spin of electron.\n"
3624 " Fifth column : a float. The largest coefficients in the CI expansion.\n\n"
3625 " Example :\n"
3626 " 5 B 6 B 0.401\n"
3627 " 4 A 7 B 0.205\n\n"
3628 " A text file with 3 columns by line is also accepted.\n"
3629 " Example :\n"
3630 " 5 6 0.401\n"
3631 " 4 7 0.205\n\n"
3632 )
3633 );
3634 win = Message(temp,_(" Info "),FALSE);
3635 gtk_window_set_modal (GTK_WINDOW (win), TRUE);
3636 }
3637 /********************************************************************************/
lambda_diagnostic_dlg()3638 void lambda_diagnostic_dlg()
3639 {
3640 GtkWidget *Win;
3641 GtkWidget *frameGrid;
3642 GtkWidget *hbox;
3643 GtkWidget *vboxall;
3644 GtkWidget *vboxwin;
3645 GtkWidget *button;
3646 /* GtkWidget *label;*/
3647 GtkWidget** entries;
3648 GtkWidget *buttonFileSelector;
3649 G_CONST_RETURN gchar* temp;
3650 static gboolean first = TRUE;
3651
3652 if(!GeomOrb)
3653 {
3654 Message(_("Sorry, Please read the MO before\n"),_("Error"),TRUE);
3655 return;
3656 }
3657 if(!CoefAlphaOrbitals)
3658 {
3659 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
3660 return;
3661 }
3662 if(!AOrb && !SAOrb)
3663 {
3664 Message(_("Sorry, Please load the MO before\n"),_("Error"),TRUE);
3665 return;
3666 }
3667
3668 if(!AOAvailable &&(TypeGrid == GABEDIT_TYPEGRID_DDENSITY || TypeGrid == GABEDIT_TYPEGRID_ADENSITY))
3669 {
3670 Message(_("Sorry, No atomic orbitals available.\nPlease use a gabedit file for load : \n"
3671 "Geometry, Molecular and Atomic Orbitals\n"),_("Error"),TRUE);
3672 return;
3673 }
3674
3675 Win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
3676 gtk_window_set_title(GTK_WINDOW(Win),"Lambda diagnostic");
3677 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
3678 gtk_container_set_border_width (GTK_CONTAINER (Win), 5);
3679 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(PrincipalWindow));
3680 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
3681
3682 add_glarea_child(Win,"Grid ");
3683
3684 vboxall = create_vbox(Win);
3685 vboxwin = vboxall;
3686
3687
3688 hbox = gtk_hbox_new (FALSE, 0);
3689 gtk_box_pack_start (GTK_BOX (vboxall), hbox, TRUE, TRUE, 0);
3690 /*
3691 label = gtk_label_new(_("File containing the transition properties :"));
3692 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
3693 */
3694 buttonFileSelector = gtk_file_chooser_button_new(_("select the file containing the transition properties(5columns : num1 type(alpha or beta) num2 type coefficient)"),
3695 GTK_FILE_CHOOSER_ACTION_OPEN);
3696 g_object_set_data (G_OBJECT (Win), "ButtonFileSelector",buttonFileSelector);
3697 gtk_box_pack_start (GTK_BOX (hbox), buttonFileSelector, TRUE, TRUE, 5);
3698 button = create_button(Win,_("Help"));
3699 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
3700 gtk_widget_show (button);
3701 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)help_trans_prop,G_OBJECT(Win));
3702
3703 gtk_box_pack_start (GTK_BOX (vboxall), gtk_hseparator_new(), TRUE, TRUE, 5);
3704
3705 frameGrid = create_grid_frame(vboxall,"Box & Grid");
3706 entries = (GtkWidget**) g_object_get_data (G_OBJECT (frameGrid), "Entries");
3707 if(first)
3708 {
3709 temp = gtk_entry_get_text(GTK_ENTRY(entries[3]));
3710 if(temp && strlen(temp)>0)
3711 {
3712 gchar* newval = g_strdup_printf("%f",atof(temp)*5);
3713 gtk_entry_set_text(GTK_ENTRY(entries[3]),newval);
3714 }
3715 first = FALSE;
3716 }
3717 g_object_set_data (G_OBJECT (Win), "Entries",entries);
3718 g_object_set_data (G_OBJECT (Win), "FrameGrid",frameGrid);
3719 gtk_widget_set_sensitive(frameGrid, TRUE);
3720
3721 hbox = create_hbox_false(vboxwin);
3722 gtk_widget_realize(Win);
3723
3724 button = create_button(Win,_("OK"));
3725 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
3726 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
3727 gtk_widget_grab_default(button);
3728 gtk_widget_show (button);
3729 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)apply_lambda_diagnostic,G_OBJECT(Win));
3730
3731 button = create_button(Win,_("Cancel"));
3732 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
3733 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, TRUE, 3);
3734 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child, G_OBJECT(Win));
3735 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)gtk_widget_destroy,G_OBJECT(Win));
3736 gtk_widget_show (button);
3737
3738 gtk_widget_show_all (Win);
3739 }
3740