1 /* GeomZmatrix.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 <gtk/gtk.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <math.h>
28
29 #include "../Common/Global.h"
30 #include "../Utils/Constants.h"
31 #include "../Common/Help.h"
32 #include "../Utils/UtilsInterface.h"
33 #include "../Utils/Utils.h"
34 #include "../Geometry/GeomGlobal.h"
35 #include "../Utils/AtomsProp.h"
36 #include "../Geometry/Fragments.h"
37 #include "../Geometry/DrawGeom.h"
38 #include "../Files/ListeFiles.h"
39 #include "../Common/Windows.h"
40 #include "../Geometry/InterfaceGeom.h"
41 #include "../Gaussian/Gaussian.h"
42 #include "../Molpro/Molpro.h"
43 #include "../Geometry/GeomConversion.h"
44 #include "../Common/StockIcons.h"
45
46 #undef Factor
47
48 typedef enum
49 {
50 E_NUMBER=0,
51 E_SYMBOL,
52 E_MMTYPE,
53 E_PDBTYPE,
54 E_RESIDUE,
55 E_R,
56 E_NUMBER_R,
57 E_ANGLE,
58 E_NUMBER_ANGLE,
59 E_DIHEDRAL,
60 E_NUMBER_DIHEDRAL,
61 E_CHARGE,
62 E_LAYER
63 } GabeditEntryType;
64
65 static GtkWidget *FenetreTable;
66
67 static gint LineSelectedV=-1;
68 static GtkWidget *listv;
69 static GtkWidget *EntryV[NUMBER_LIST_ZMATRIX];
70 static gint LineSelected=-1;
71 static GtkWidget *list;
72 static GtkWidget *Entry[NUMBER_LIST_ZMATRIX];
73 static gboolean DestroyDialog;
74 static gint NCr;
75 static gboolean InEdit= FALSE;
76 static gint LineSelectedOld = -1;
77 static gdouble labelWidth = 0.15;
78 static gdouble entryWidth = 0.20;
79
80 gchar** getListMMTypes(gint* nlist);
81 gchar** getListPDBTypes(gchar* residueName, gint* nlist);
82 /********************************************************************************/
83 static void clearList(GtkWidget* myList);
84 static void removeFromList(GtkWidget* myList, gint ligne);
85 static void insertToList(GtkWidget* myList, gint ligne, gchar* texts[], gint nColumns);
86 static void appendToList(GtkWidget* myList, gchar* texts[], gint nColumns);
87 static gint get_info_one_center(gchar* t, gchar* info[]);
88 static void set_center(gchar* info[]);
89 static gboolean TestVariablesCreated(gchar *NewName,gint j);
90 static void append_list_geom();
91 static gint testav(gchar *t);
92 static void append_list_variables();
93 /********************************************************************************/
94 static void DialogueAdd();
95 static void DialogueEdit();
96 static void DialogueDelete();
97 void create_window_save_zmat();
98 static void DialogueTransInVar();
99 static void trans_allRGeom_to_variables();
100 static void trans_allAngleGeom_to_variables();
101 static void trans_allDihedralGeom_to_variables();
102 static void TransConstVar(gboolean vr, gboolean va, gboolean vd);
103 static void MultiByA0();
104 static void DivideByA0();
105 /********************************************************************************/
106 static void DialogueAddV();
107 static void DialogueEditV();
108 static void DialogueDeleteV();
109 static void DialogueTransInConst();
110 static void TransVarConst();
111 /********************************************************************************/
clearList(GtkWidget * myList)112 static void clearList(GtkWidget* myList)
113 {
114 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
115 GtkListStore *store = GTK_LIST_STORE (model);
116 gtk_list_store_clear(store);
117 }
118 /********************************************************************************/
removeFromList(GtkWidget * myList,gint ligne)119 static void removeFromList(GtkWidget* myList, gint ligne)
120 {
121 GtkTreeModel *model;
122 GtkListStore *store;
123 GtkTreeIter iter;
124 gchar* tmp;
125
126 if(ligne<0) return;
127
128 tmp = g_strdup_printf("%d",ligne);
129
130 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
131 store = GTK_LIST_STORE (model);
132
133 if(gtk_tree_model_get_iter_from_string (model, &iter, tmp))
134 {
135 gtk_list_store_remove(store, &iter);
136 }
137 g_free(tmp);
138 }
139 /********************************************************************************/
insertToList(GtkWidget * myList,gint ligne,gchar * texts[],gint nColumns)140 static void insertToList(GtkWidget* myList, gint ligne, gchar* texts[], gint nColumns)
141 {
142 GtkTreeModel *model;
143 GtkListStore *store;
144 GtkTreeIter iter;
145 gint k;
146 gint Nc = ligne;
147
148 if(ligne<0) ligne = 0;
149
150 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
151 store = GTK_LIST_STORE (model);
152
153 gtk_list_store_insert(store, &iter, ligne);
154 for(k=0;k<nColumns;k++)
155 {
156 gboolean ed = TRUE;
157 if(myList == list && k==0 ) ed=FALSE;
158 if(myList == list && Nc<1 && k>4 && k<11) ed=FALSE;
159 if(myList == list && Nc<2 && k>6 && k<11) ed=FALSE;
160 if(myList == list && Nc<3 && k>8 && k<11) ed=FALSE;
161 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
162 g_free(texts[k]);
163 }
164 }
165 /********************************************************************************/
appendToList(GtkWidget * myList,gchar * texts[],gint nColumns)166 static void appendToList(GtkWidget* myList, gchar* texts[], gint nColumns)
167 {
168 GtkTreeModel *model;
169 GtkListStore *store;
170 GtkTreeIter iter;
171 gint k;
172 gint Nc = NcentersZmat -1;
173
174 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
175 store = GTK_LIST_STORE (model);
176
177 gtk_list_store_append(store, &iter);
178 for(k=0;k<nColumns;k++)
179 {
180 gboolean ed = TRUE;
181 if(myList == list && k==0 ) ed=FALSE;
182 if(myList == list && Nc<1 && k>4 && k<11) ed=FALSE;
183 if(myList == list && Nc<2 && k>6 && k<11) ed=FALSE;
184 if(myList == list && Nc<3 && k>8 && k<11) ed=FALSE;
185 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
186 g_free(texts[k]);
187 }
188 }
189 /********************************************************************************/
changeNameVariableInGeometry(gchar * oldName,gchar * newName)190 static void changeNameVariableInGeometry(gchar* oldName, gchar* newName)
191 {
192 gint i;
193 gint k=-1;
194 for(i=0;i<NcentersZmat;i++)
195 {
196 if(i>0 && !strcmp(Geom[i].R,oldName))
197 {
198 if(Geom[i].R) g_free(Geom[i].R);
199 Geom[i].R = g_strdup(newName);
200 k = 0;
201 }
202 if(i>1 && !strcmp(Geom[i].Angle,oldName))
203 {
204 if(Geom[i].Angle) g_free(Geom[i].Angle);
205 Geom[i].Angle = g_strdup(newName);
206 k = 0;
207 }
208 if(i>2 && !strcmp(Geom[i].Dihedral,oldName))
209 {
210 if(Geom[i].Dihedral) g_free(Geom[i].Dihedral);
211 Geom[i].Dihedral = g_strdup(newName);
212 k=0;
213 }
214 }
215 if(k==0)
216 {
217 clearList(list);
218 append_list_geom();
219 }
220 }
221 /********************************************************************************/
editedVariable(GtkCellRendererText * cell,gchar * path_string,gchar * new_text,gpointer data)222 static void editedVariable (GtkCellRendererText *cell, gchar *path_string,
223 gchar *new_text, gpointer data)
224 {
225 GtkTreeModel *model = GTK_TREE_MODEL (data);
226 GtkTreeIter iter;
227 GtkTreePath *path = NULL;
228 gint numCol = 0;
229 gint Nc = -1;
230 numCol = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),"NumColumn"));
231 gchar* oldName = NULL;
232 if(numCol==0)
233 {
234 Nc = -1;
235 if(!variable_name_valid(new_text))
236 {
237 show_forbidden_characters();
238 return;
239 }
240 if ( !strcmp(new_text, "")) return;
241 Nc = atoi(path_string);
242 if(TestVariablesCreated(new_text,Nc) )
243 {
244 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Error"),TRUE);
245 return;
246 }
247 }
248 if(numCol==1)
249 {
250 if(!test(new_text))
251 {
252 gchar* message=g_strdup_printf(_("Sorry %s is not a number \n"),new_text);
253 MessageGeom(message,_("Error"),TRUE);
254 g_free(message);
255 return;
256 }
257 if ( !strcmp(new_text, "")) return;
258 Nc = atoi(path_string);
259 if(test(new_text) && !testpointeE(new_text) )
260 new_text=g_strdup_printf("%s.0",new_text);
261 }
262 if(Nc<0)return;
263 if(numCol==0)
264 {
265 oldName = Variables[Nc].Name;
266 Variables[Nc].Name=g_strdup(new_text);
267 }
268 if(numCol==1)
269 {
270 if(Variables[Nc].Value) g_free(Variables[Nc].Value);
271 Variables[Nc].Value=g_strdup(new_text);
272 }
273
274 /* printf("%s\n",path_string);*/
275
276 path = gtk_tree_path_new_from_string (path_string);
277 gtk_tree_model_get_iter (model, &iter, path);
278 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
279
280 gtk_tree_path_free (path);
281 if(numCol==0 && oldName)
282 {
283 changeNameVariableInGeometry(oldName, new_text);
284 g_free(oldName);
285 }
286 if(numCol==1 && GeomDrawingArea != NULL) rafresh_drawing();
287 }
288 /*****************************************************************************/
get_distance_zmatrix(gint ai,gint aj)289 static gchar* get_distance_zmatrix(gint ai, gint aj)
290 {
291 gdouble cosph,sinph,costh,sinth,coskh,sinkh;
292 gdouble cosa,sina,cosd,sind;
293 gdouble dist,angle,dihed;
294 gdouble xpd,ypd,zpd,xqd,yqd,zqd;
295 gdouble xa,ya,za,xb,yb,zb;
296 gdouble rbc,xyb,yza,temp;
297 gdouble xpa,ypa,zqa;
298 gdouble xd,yd,zd;
299 gboolean flag;
300 gint i, na, nb, nc;
301 gdouble *X = NULL;
302 gdouble *Y = NULL;
303 gdouble *Z = NULL;
304 gint amax = aj;
305
306 if (NcentersZmat <= 1) return NULL;
307 if (ai < 0) return NULL;
308 if (aj < 0) return NULL;
309 if (ai > aj) amax = ai;
310 if (amax > NcentersZmat-1) return NULL;
311
312
313 X = g_malloc(NcentersZmat*sizeof(gdouble));
314 Y = g_malloc(NcentersZmat*sizeof(gdouble));
315 Z = g_malloc(NcentersZmat*sizeof(gdouble));
316
317 for (i = 0; i <(gint)NcentersZmat; i++) X[i] = Y[i] = Z[i] = 0;
318
319 /* Atom #1 */
320 X[0] = 0;
321 Y[0] = 0;
322 Z[0] = 0;
323
324 /* Atom #2 */
325 if(!test(Geom[1].R)) X[1] = get_value_variableZmat(Geom[1].R);
326 else X[1] = atof(Geom[1].R);
327 Y[1] = 0;
328 Z[1] = 0;
329 if (NcentersZmat == 2 && amax<2)
330 {
331 gdouble r = X[1];
332 g_free(X);
333 g_free(Y);
334 g_free(Z);
335 return g_strdup_printf("%f",r);
336 }
337
338 /* Atom #3 */
339 if(!test(Geom[2].R)) dist = get_value_variableZmat(Geom[2].R);
340 else dist = atof(Geom[2].R);
341
342 if(!test(Geom[2].Angle)) angle = get_value_variableZmat(Geom[2].Angle);
343 else angle = atof(Geom[2].Angle);
344
345 angle *= DEG_TO_RAD;
346
347 cosa = cos(angle);
348 sina = sin(angle);
349 if( atoi (Geom[2].NAngle) == 2 ) X[2] = X[0] + cosa*dist;
350 else X[2] = X[1] - cosa*dist;
351
352 Y[2] = sina*dist;
353 Z[2] = 0.0;
354
355 if(amax<3)
356 {
357 gdouble r = (X[ai]-X[aj])*(X[ai]-X[aj])+(Y[ai]-Y[aj])*(Y[ai]-Y[aj])+(Z[ai]-Z[aj])*(Z[ai]-Z[aj]);
358 r = sqrt(r);
359 g_free(X);
360 g_free(Y);
361 g_free(Z);
362 return g_strdup_printf("%f",r);
363 }
364 for (i = 3; i <(gint)NcentersZmat; i++)
365 {
366 if(i>amax)break;
367 if(!test(Geom[i].R)) dist = get_value_variableZmat(Geom[i].R);
368 else dist = atof(Geom[i].R);
369
370 if(!test(Geom[i].Angle)) angle = get_value_variableZmat(Geom[i].Angle);
371 else angle = atof(Geom[i].Angle) ;
372
373 if(!test(Geom[i].Dihedral)) dihed = get_value_variableZmat(Geom[i].Dihedral);
374 else dihed = atof(Geom[i].Dihedral) ;
375
376 angle *= DEG_TO_RAD;
377 dihed *= DEG_TO_RAD;
378
379 na = atoi(Geom[i].NR)-1;
380 nb = atoi(Geom[i].NAngle)-1;
381 nc = atoi(Geom[i].NDihedral)-1;
382
383 xb = X[nb] - X[na];
384 yb = Y[nb] - Y[na];
385 zb = Z[nb] - Z[na];
386
387 rbc = xb*xb + yb*yb + zb*zb;
388 if( rbc < 0.0001 )
389 {
390 g_free(X);
391 g_free(Y);
392 g_free(Z);
393 printf("Warning : rbc < 0.0001 in get_distance_zmatrix\n");
394 return NULL;
395 }
396 rbc = 1.0/sqrt(rbc);
397
398 cosa = cos(angle);
399 sina = sin(angle);
400
401
402 if( fabs(cosa) >= 0.999999 )
403 {
404 /* Colinear */
405 temp = dist*rbc*cosa;
406 X[i] = X[na] + temp*xb;
407 Y[i] = Y[na] + temp*yb;
408 Z[i] = Z[na] + temp*zb;
409 }
410 else
411 {
412 xa = X[nc] - X[na];
413 ya = Y[nc] - Y[na];
414 za = Z[nc] - Z[na];
415
416 sind = -sin(dihed);
417 cosd = cos(dihed);
418
419 xd = dist*cosa;
420 yd = dist*sina*cosd;
421 zd = dist*sina*sind;
422
423 xyb = sqrt(xb*xb + yb*yb);
424 if( xyb < 0.1 )
425 {
426 /* Rotate about y-axis! */
427 temp = za; za = -xa; xa = temp;
428 temp = zb; zb = -xb; xb = temp;
429 xyb = sqrt(xb*xb + yb*yb);
430 flag = TRUE;
431 }
432 else flag = FALSE;
433
434 costh = xb/xyb;
435 sinth = yb/xyb;
436 xpa = costh*xa + sinth*ya;
437 ypa = costh*ya - sinth*xa;
438
439 sinph = zb*rbc;
440 cosph = sqrt(1.0 - sinph*sinph);
441 zqa = cosph*za - sinph*xpa;
442
443 yza = sqrt(ypa*ypa + zqa*zqa);
444
445 if( yza > 1.0E-10 )
446 {
447 coskh = ypa/yza;
448 sinkh = zqa/yza;
449
450 ypd = coskh*yd - sinkh*zd;
451 zpd = coskh*zd + sinkh*yd;
452 }
453 else
454 {
455 /* coskh = 1.0; */
456 /* sinkh = 0.0; */
457 ypd = yd;
458 zpd = zd;
459 }
460
461 xpd = cosph*xd - sinph*zpd;
462 zqd = cosph*zpd + sinph*xd;
463 xqd = costh*xpd - sinth*ypd;
464 yqd = costh*ypd + sinth*xpd;
465
466 if( flag )
467 {
468 /* Rotate about y-axis! */
469 X[i] = X[na] - zqd;
470 Y[i] = Y[na] + yqd;
471 Z[i] = Z[na] + xqd;
472 }
473 else
474 {
475 X[i] =X[na] + xqd;
476 Y[i] =Y[na] + yqd;
477 Z[i] =Z[na] + zqd;
478 }
479 }
480 }
481 {
482 gdouble r = (X[ai]-X[aj])*(X[ai]-X[aj])+(Y[ai]-Y[aj])*(Y[ai]-Y[aj])+(Z[ai]-Z[aj])*(Z[ai]-Z[aj]);
483 r = sqrt(r);
484 g_free(X);
485 g_free(Y);
486 g_free(Z);
487 return g_strdup_printf("%f",r);
488 }
489 }
490 /*****************************************************************************/
get_angle_zmatrix(gint ai,gint aj,gint ak)491 static gchar* get_angle_zmatrix(gint ai, gint aj, gint ak)
492 {
493 gdouble cosph,sinph,costh,sinth,coskh,sinkh;
494 gdouble cosa,sina,cosd,sind;
495 gdouble dist,angle,dihed;
496 gdouble xpd,ypd,zpd,xqd,yqd,zqd;
497 gdouble xa,ya,za,xb,yb,zb;
498 gdouble rbc,xyb,yza,temp;
499 gdouble xpa,ypa,zqa;
500 gdouble xd,yd,zd;
501 gboolean flag;
502 gint i, na, nb, nc;
503 gdouble *X = NULL;
504 gdouble *Y = NULL;
505 gdouble *Z = NULL;
506 gint amax = ak;
507 gchar* t = NULL;
508
509 if (NcentersZmat <= 1) return NULL;
510 if (ai < 0) return NULL;
511 if (aj < 0) return NULL;
512 if (ak < 0) return NULL;
513 if (ai > amax) amax = ai;
514 if (aj > amax) amax = aj;
515 if (amax > NcentersZmat-1) return NULL;
516
517
518 X = g_malloc(NcentersZmat*sizeof(gdouble));
519 Y = g_malloc(NcentersZmat*sizeof(gdouble));
520 Z = g_malloc(NcentersZmat*sizeof(gdouble));
521
522 for (i = 0; i <(gint)NcentersZmat; i++) X[i] = Y[i] = Z[i] = 0;
523
524 /* Atom #1 */
525 X[0] = 0;
526 Y[0] = 0;
527 Z[0] = 0;
528
529 /* Atom #2 */
530 if(!test(Geom[1].R)) X[1] = get_value_variableZmat(Geom[1].R);
531 else X[1] = atof(Geom[1].R);
532 Y[1] = 0;
533 Z[1] = 0;
534
535 /* Atom #3 */
536 if(!test(Geom[2].R)) dist = get_value_variableZmat(Geom[2].R);
537 else dist = atof(Geom[2].R);
538
539 if(!test(Geom[2].Angle)) angle = get_value_variableZmat(Geom[2].Angle);
540 else angle = atof(Geom[2].Angle);
541
542 angle *= DEG_TO_RAD;
543
544 cosa = cos(angle);
545 sina = sin(angle);
546 if( atoi (Geom[2].NAngle) == 2 ) X[2] = X[0] + cosa*dist;
547 else X[2] = X[1] - cosa*dist;
548
549 Y[2] = sina*dist;
550 Z[2] = 0.0;
551
552 if(amax<3)
553 {
554 Point A;
555 Point B;
556
557 A.C[0]=X[ai]-X[aj];
558 A.C[1]=Y[ai]-Y[aj];
559 A.C[2]=Z[ai]-Z[aj];
560
561 B.C[0]=X[ak]-X[aj];
562 B.C[1]=Y[ak]-Y[aj];
563 B.C[2]=Z[ak]-Z[aj];
564
565 g_free(X);
566 g_free(Y);
567 g_free(Z);
568 t = get_angle_vectors(A,B);
569 if(t)
570 {
571 gchar* a = g_strdup_printf("%0.6lf",atof(t));
572 g_free(t);
573 return a;
574 }
575 return NULL;
576 }
577 for (i = 3; i <(gint)NcentersZmat; i++)
578 {
579 if(i>amax)break;
580 if(!test(Geom[i].R)) dist = get_value_variableZmat(Geom[i].R);
581 else dist = atof(Geom[i].R);
582
583 if(!test(Geom[i].Angle)) angle = get_value_variableZmat(Geom[i].Angle);
584 else angle = atof(Geom[i].Angle) ;
585
586 if(!test(Geom[i].Dihedral)) dihed = get_value_variableZmat(Geom[i].Dihedral);
587 else dihed = atof(Geom[i].Dihedral) ;
588
589 angle *= DEG_TO_RAD;
590 dihed *= DEG_TO_RAD;
591
592 na = atoi(Geom[i].NR)-1;
593 nb = atoi(Geom[i].NAngle)-1;
594 nc = atoi(Geom[i].NDihedral)-1;
595
596 xb = X[nb] - X[na];
597 yb = Y[nb] - Y[na];
598 zb = Z[nb] - Z[na];
599
600 rbc = xb*xb + yb*yb + zb*zb;
601 if( rbc < 0.0001 )
602 {
603 g_free(X);
604 g_free(Y);
605 g_free(Z);
606 printf("Warning : rbc < 0.0001 in get_distance_zmatrix\n");
607 return NULL;
608 }
609 rbc = 1.0/sqrt(rbc);
610
611 cosa = cos(angle);
612 sina = sin(angle);
613
614
615 if( fabs(cosa) >= 0.999999 )
616 {
617 /* Colinear */
618 temp = dist*rbc*cosa;
619 X[i] = X[na] + temp*xb;
620 Y[i] = Y[na] + temp*yb;
621 Z[i] = Z[na] + temp*zb;
622 }
623 else
624 {
625 xa = X[nc] - X[na];
626 ya = Y[nc] - Y[na];
627 za = Z[nc] - Z[na];
628
629 sind = -sin(dihed);
630 cosd = cos(dihed);
631
632 xd = dist*cosa;
633 yd = dist*sina*cosd;
634 zd = dist*sina*sind;
635
636 xyb = sqrt(xb*xb + yb*yb);
637 if( xyb < 0.1 )
638 {
639 /* Rotate about y-axis! */
640 temp = za; za = -xa; xa = temp;
641 temp = zb; zb = -xb; xb = temp;
642 xyb = sqrt(xb*xb + yb*yb);
643 flag = TRUE;
644 }
645 else flag = FALSE;
646
647 costh = xb/xyb;
648 sinth = yb/xyb;
649 xpa = costh*xa + sinth*ya;
650 ypa = costh*ya - sinth*xa;
651
652 sinph = zb*rbc;
653 cosph = sqrt(1.0 - sinph*sinph);
654 zqa = cosph*za - sinph*xpa;
655
656 yza = sqrt(ypa*ypa + zqa*zqa);
657
658 if( yza > 1.0E-10 )
659 {
660 coskh = ypa/yza;
661 sinkh = zqa/yza;
662
663 ypd = coskh*yd - sinkh*zd;
664 zpd = coskh*zd + sinkh*yd;
665 }
666 else
667 {
668 /* coskh = 1.0; */
669 /* sinkh = 0.0; */
670 ypd = yd;
671 zpd = zd;
672 }
673
674 xpd = cosph*xd - sinph*zpd;
675 zqd = cosph*zpd + sinph*xd;
676 xqd = costh*xpd - sinth*ypd;
677 yqd = costh*ypd + sinth*xpd;
678
679 if( flag )
680 {
681 /* Rotate about y-axis! */
682 X[i] = X[na] - zqd;
683 Y[i] = Y[na] + yqd;
684 Z[i] = Z[na] + xqd;
685 }
686 else
687 {
688 X[i] =X[na] + xqd;
689 Y[i] =Y[na] + yqd;
690 Z[i] =Z[na] + zqd;
691 }
692 }
693 }
694 {
695 Point A;
696 Point B;
697
698 A.C[0]=X[ai]-X[aj];
699 A.C[1]=Y[ai]-Y[aj];
700 A.C[2]=Z[ai]-Z[aj];
701
702 B.C[0]=X[ak]-X[aj];
703 B.C[1]=Y[ak]-Y[aj];
704 B.C[2]=Z[ak]-Z[aj];
705
706 g_free(X);
707 g_free(Y);
708 g_free(Z);
709 t = get_angle_vectors(A,B);
710 if(t)
711 {
712 gchar* a = g_strdup_printf("%0.6lf",atof(t));
713 g_free(t);
714 return a;
715 }
716 return NULL;
717 }
718 }
719 /*****************************************************************************/
get_dihedral_zmatrix(gint ai,gint aj,gint ak,gint al)720 static gchar* get_dihedral_zmatrix(gint ai, gint aj, gint ak, gint al)
721 {
722 gdouble cosph,sinph,costh,sinth,coskh,sinkh;
723 gdouble cosa,sina,cosd,sind;
724 gdouble dist,angle,dihed;
725 gdouble xpd,ypd,zpd,xqd,yqd,zqd;
726 gdouble xa,ya,za,xb,yb,zb;
727 gdouble rbc,xyb,yza,temp;
728 gdouble xpa,ypa,zqa;
729 gdouble xd,yd,zd;
730 gboolean flag;
731 gint i, na, nb, nc;
732 gdouble *X = NULL;
733 gdouble *Y = NULL;
734 gdouble *Z = NULL;
735 gint amax = al;
736
737 if (NcentersZmat <= 1) return NULL;
738 if (ai < 0) return NULL;
739 if (aj < 0) return NULL;
740 if (ak < 0) return NULL;
741 if (al < 0) return NULL;
742 if (ai > amax) amax = ai;
743 if (aj > amax) amax = aj;
744 if (ak > amax) amax = ak;
745 if (amax > NcentersZmat-1) return NULL;
746
747
748 X = g_malloc(NcentersZmat*sizeof(gdouble));
749 Y = g_malloc(NcentersZmat*sizeof(gdouble));
750 Z = g_malloc(NcentersZmat*sizeof(gdouble));
751
752 for (i = 0; i <(gint)NcentersZmat; i++) X[i] = Y[i] = Z[i] = 0;
753
754 /* Atom #1 */
755 X[0] = 0;
756 Y[0] = 0;
757 Z[0] = 0;
758
759 /* Atom #2 */
760 if(!test(Geom[1].R)) X[1] = get_value_variableZmat(Geom[1].R);
761 else X[1] = atof(Geom[1].R);
762 Y[1] = 0;
763 Z[1] = 0;
764
765 /* Atom #3 */
766 if(!test(Geom[2].R)) dist = get_value_variableZmat(Geom[2].R);
767 else dist = atof(Geom[2].R);
768
769 if(!test(Geom[2].Angle)) angle = get_value_variableZmat(Geom[2].Angle);
770 else angle = atof(Geom[2].Angle);
771
772 angle *= DEG_TO_RAD;
773
774 cosa = cos(angle);
775 sina = sin(angle);
776 if( atoi (Geom[2].NAngle) == 2 ) X[2] = X[0] + cosa*dist;
777 else X[2] = X[1] - cosa*dist;
778
779 Y[2] = sina*dist;
780 Z[2] = 0.0;
781
782 for (i = 3; i <(gint)NcentersZmat; i++)
783 {
784 if(i>amax)break;
785 if(!test(Geom[i].R)) dist = get_value_variableZmat(Geom[i].R);
786 else dist = atof(Geom[i].R);
787
788 if(!test(Geom[i].Angle)) angle = get_value_variableZmat(Geom[i].Angle);
789 else angle = atof(Geom[i].Angle) ;
790
791 if(!test(Geom[i].Dihedral)) dihed = get_value_variableZmat(Geom[i].Dihedral);
792 else dihed = atof(Geom[i].Dihedral) ;
793
794 angle *= DEG_TO_RAD;
795 dihed *= DEG_TO_RAD;
796
797 na = atoi(Geom[i].NR)-1;
798 nb = atoi(Geom[i].NAngle)-1;
799 nc = atoi(Geom[i].NDihedral)-1;
800
801 xb = X[nb] - X[na];
802 yb = Y[nb] - Y[na];
803 zb = Z[nb] - Z[na];
804
805 rbc = xb*xb + yb*yb + zb*zb;
806 if( rbc < 0.0001 )
807 {
808 g_free(X);
809 g_free(Y);
810 g_free(Z);
811 printf("Warning : rbc < 0.0001 in get_distance_zmatrix\n");
812 return NULL;
813 }
814 rbc = 1.0/sqrt(rbc);
815
816 cosa = cos(angle);
817 sina = sin(angle);
818
819
820 if( fabs(cosa) >= 0.999999 )
821 {
822 /* Colinear */
823 temp = dist*rbc*cosa;
824 X[i] = X[na] + temp*xb;
825 Y[i] = Y[na] + temp*yb;
826 Z[i] = Z[na] + temp*zb;
827 }
828 else
829 {
830 xa = X[nc] - X[na];
831 ya = Y[nc] - Y[na];
832 za = Z[nc] - Z[na];
833
834 sind = -sin(dihed);
835 cosd = cos(dihed);
836
837 xd = dist*cosa;
838 yd = dist*sina*cosd;
839 zd = dist*sina*sind;
840
841 xyb = sqrt(xb*xb + yb*yb);
842 if( xyb < 0.1 )
843 {
844 /* Rotate about y-axis! */
845 temp = za; za = -xa; xa = temp;
846 temp = zb; zb = -xb; xb = temp;
847 xyb = sqrt(xb*xb + yb*yb);
848 flag = TRUE;
849 }
850 else flag = FALSE;
851
852 costh = xb/xyb;
853 sinth = yb/xyb;
854 xpa = costh*xa + sinth*ya;
855 ypa = costh*ya - sinth*xa;
856
857 sinph = zb*rbc;
858 cosph = sqrt(1.0 - sinph*sinph);
859 zqa = cosph*za - sinph*xpa;
860
861 yza = sqrt(ypa*ypa + zqa*zqa);
862
863 if( yza > 1.0E-10 )
864 {
865 coskh = ypa/yza;
866 sinkh = zqa/yza;
867
868 ypd = coskh*yd - sinkh*zd;
869 zpd = coskh*zd + sinkh*yd;
870 }
871 else
872 {
873 /* coskh = 1.0; */
874 /* sinkh = 0.0; */
875 ypd = yd;
876 zpd = zd;
877 }
878
879 xpd = cosph*xd - sinph*zpd;
880 zqd = cosph*zpd + sinph*xd;
881 xqd = costh*xpd - sinth*ypd;
882 yqd = costh*ypd + sinth*xpd;
883
884 if( flag )
885 {
886 /* Rotate about y-axis! */
887 X[i] = X[na] - zqd;
888 Y[i] = Y[na] + yqd;
889 Z[i] = Z[na] + xqd;
890 }
891 else
892 {
893 X[i] =X[na] + xqd;
894 Y[i] =Y[na] + yqd;
895 Z[i] =Z[na] + zqd;
896 }
897 }
898 }
899 {
900 Point A;
901 Point B;
902 Point V1;
903 Point V2;
904 Point W1;
905 gdouble angle;
906 gdouble dihsgn;
907
908 V1.C[0]=X[ai]-X[aj];
909 V1.C[1]=Y[ai]-Y[aj];
910 V1.C[2]=Z[ai]-Z[aj];
911
912 V2.C[0]=X[ak]-X[aj];
913 V2.C[1]=Y[ak]-Y[aj];
914 V2.C[2]=Z[ak]-Z[aj];
915
916 A = get_produit_vectoriel(V1,V2);
917
918 V1.C[0]=X[al]-X[ak];
919 V1.C[1]=Y[al]-Y[ak];
920 V1.C[2]=Z[al]-Z[ak];
921
922 V2.C[0]=X[aj]-X[ak];
923 V2.C[1]=Y[aj]-Y[ak];
924 V2.C[2]=Z[aj]-Z[ak];
925
926 B = get_produit_vectoriel(V2,V1);
927
928 angle = atof(get_angle_vectors(A,B));
929
930 W1 = get_produit_vectoriel(A,B);
931 if (get_module(W1)<1e-5 ) dihsgn = 1.0e0;
932 else
933 {
934 dihsgn = get_scalaire(W1,V2);
935 if (dihsgn>0) dihsgn = -1.0e0;
936 else dihsgn = 1.0e0;
937 }
938 angle *=dihsgn;
939 return g_strdup_printf("%f",angle);
940 }
941 }
942 /********************************************************************************/
set_text_column(GtkTreeModel * model,gchar * path_string,gchar * text,gint n)943 static void set_text_column (GtkTreeModel *model , gchar *path_string, gchar *text, gint n)
944 {
945 GtkTreeIter iter;
946 GtkTreePath *path = NULL;
947 path = gtk_tree_path_new_from_string (path_string);
948 gtk_tree_model_get_iter (model, &iter, path);
949 gtk_list_store_set (GTK_LIST_STORE (model), &iter, n, text, -1);
950 gtk_tree_path_free (path);
951 }
952 /********************************************************************************/
reset_r_value(gint Nc,gchar * val)953 static gboolean reset_r_value(gint Nc, gchar* val)
954 {
955 gint numvar = testav(Geom[Nc].R);
956 if(numvar>=0){
957 if(Variables[numvar].Value) g_free(Variables[numvar].Value);
958 Variables[numvar].Value = val;
959 clearList(listv);
960 append_list_variables();
961 return FALSE;
962 }
963 else
964 {
965 if(Geom[Nc].R) g_free(Geom[Nc].R);
966 Geom[Nc].R = val;
967 return TRUE;
968 }
969 }
970 /********************************************************************************/
reset_angle_value(gint Nc,gchar * val)971 static gboolean reset_angle_value(gint Nc, gchar* val)
972 {
973 gint numvar = testav(Geom[Nc].Angle);
974 if(numvar>=0){
975 if(Variables[numvar].Value) g_free(Variables[numvar].Value);
976 Variables[numvar].Value = val;
977 clearList(listv);
978 append_list_variables();
979 return FALSE;
980 }
981 else
982 {
983 if(Geom[Nc].Angle) g_free(Geom[Nc].Angle);
984 Geom[Nc].Angle = val;
985 return TRUE;
986 }
987 }
988 /********************************************************************************/
reset_dihedral_value(gint Nc,gchar * val)989 static gboolean reset_dihedral_value(gint Nc, gchar* val)
990 {
991 gint numvar = testav(Geom[Nc].Dihedral);
992 if(numvar>=0){
993 if(Variables[numvar].Value) g_free(Variables[numvar].Value);
994 Variables[numvar].Value = val;
995 clearList(listv);
996 append_list_variables();
997 return FALSE;
998 }
999 else
1000 {
1001 if(Geom[Nc].Dihedral) g_free(Geom[Nc].Dihedral);
1002 Geom[Nc].Dihedral = val;
1003 return TRUE;
1004 }
1005 }
1006 /********************************************************************************/
selectedCell(GtkCellRenderer * renderer,GtkCellEditable * editable,gchar * path_string,gpointer user_data)1007 static void selectedCell (GtkCellRenderer *renderer, GtkCellEditable *editable, gchar *path_string, gpointer user_data)
1008 {
1009 gint numCol = 0;
1010 numCol = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(renderer),"NumColumn"));
1011 gint Nc = -1;
1012 Nc = atoi(path_string);
1013 if(Nc<0) return;
1014 if((numCol==E_R || numCol==E_NUMBER_R) && Nc>0)
1015 {
1016 NSA[0] = Nc+1;
1017 NSA[1] = atoi(Geom[Nc].NR);
1018 NSA[2] = -1;
1019 NSA[3] = -1;
1020 if(GeomDrawingArea != NULL) rafresh_drawing();
1021 }
1022 else if((numCol==E_ANGLE || numCol==E_NUMBER_ANGLE) && Nc>1)
1023 {
1024 NSA[0] = Nc+1;
1025 NSA[1] = atoi(Geom[Nc].NR);
1026 NSA[2] = atoi(Geom[Nc].NAngle);
1027 NSA[3] = -1;
1028 if(GeomDrawingArea != NULL) rafresh_drawing();
1029 }
1030 else if((numCol==E_DIHEDRAL || numCol==E_NUMBER_DIHEDRAL) && Nc>2)
1031 {
1032 NSA[0] = Nc+1;
1033 NSA[1] = atoi(Geom[Nc].NR);
1034 NSA[2] = atoi(Geom[Nc].NAngle);
1035 NSA[3] = atoi(Geom[Nc].NDihedral);
1036 if(GeomDrawingArea != NULL) rafresh_drawing();
1037 }
1038 }
1039 /********************************************************************************/
editedGeom(GtkCellRendererText * cell,gchar * path_string,gchar * new_text,gpointer data)1040 static void editedGeom (GtkCellRendererText *cell, gchar *path_string,
1041 gchar *new_text, gpointer data)
1042 {
1043 GtkTreeModel *model = GTK_TREE_MODEL (data);
1044 GtkTreeIter iter;
1045 GtkTreePath *path = NULL;
1046 gint numCol = 0;
1047 gint Nc = -1;
1048 numCol = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),"NumColumn"));
1049 if(numCol==E_NUMBER) return;
1050 if(!new_text) return;
1051 /* symbol */
1052 if(numCol==E_SYMBOL)
1053 {
1054 gint nc = strlen(new_text);
1055 if(nc<1)return;
1056 new_text[0]=toupper(new_text[0]);
1057 if(nc>1)new_text[1]=tolower(new_text[1]);
1058 if(!test_atom_define(new_text))
1059 {
1060 gchar* message=g_strdup_printf(_("Sorry %s is not a symbol for an atom \n"),new_text);
1061 MessageGeom(message,_("Error"),TRUE);
1062 g_free(message);
1063 return;
1064 }
1065 Nc = atoi(path_string);
1066 if(Geom[Nc].Symb) g_free(Geom[Nc].Symb);
1067 Geom[Nc].Symb = g_strdup(new_text);
1068 path = gtk_tree_path_new_from_string (path_string);
1069 gtk_tree_model_get_iter (model, &iter, path);
1070 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1071 gtk_tree_path_free (path);
1072 if(GeomDrawingArea != NULL) rafresh_drawing();
1073 return;
1074 }
1075 /* MM Type */
1076 if(numCol==E_MMTYPE)
1077 {
1078 gint nc = strlen(new_text);
1079 if(nc<1)return;
1080 Nc = atoi(path_string);
1081 if(Geom[Nc].mmType) g_free(Geom[Nc].mmType);
1082 Geom[Nc].mmType = g_strdup(new_text);
1083 path = gtk_tree_path_new_from_string (path_string);
1084 gtk_tree_model_get_iter (model, &iter, path);
1085 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1086 gtk_tree_path_free (path);
1087 if(GeomDrawingArea != NULL) rafresh_drawing();
1088 return;
1089 }
1090 /* PDB Type */
1091 if(numCol==E_PDBTYPE)
1092 {
1093 gint nc = strlen(new_text);
1094 if(nc<1)return;
1095 Nc = atoi(path_string);
1096 if(Geom[Nc].pdbType) g_free(Geom[Nc].pdbType);
1097 Geom[Nc].pdbType = g_strdup(new_text);
1098 path = gtk_tree_path_new_from_string (path_string);
1099 gtk_tree_model_get_iter (model, &iter, path);
1100 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1101 gtk_tree_path_free (path);
1102 if(GeomDrawingArea != NULL) rafresh_drawing();
1103 return;
1104 }
1105 /* Residue Name */
1106 if(numCol==E_RESIDUE)
1107 {
1108 gint nc = strlen(new_text);
1109 if(nc<1)return;
1110 Nc = atoi(path_string);
1111 if(strcmp(Geom[Nc].Residue,new_text))
1112 {
1113 if(Geom[Nc].Residue) g_free(Geom[Nc].Residue);
1114 Geom[Nc].Residue = g_strdup(new_text);
1115 gint k;
1116 Geom[Nc].ResidueNumber = -1;
1117 for(k=0;k<(gint)NcentersZmat;k++)
1118 {
1119 if(Nc != k && !strcmp(Geom[Nc].Residue,Geom[k].Residue))
1120 {
1121 Geom[Nc].ResidueNumber = Geom[k].ResidueNumber;
1122 break;
1123 }
1124 }
1125 if(Geom[Nc].ResidueNumber == -1)
1126 {
1127 for(k=0;k<(gint)NcentersZmat;k++)
1128 {
1129 if(Geom[Nc].ResidueNumber<Geom[k].ResidueNumber)
1130 Geom[Nc].ResidueNumber = Geom[k].ResidueNumber;
1131 }
1132 Geom[Nc].ResidueNumber += 1;
1133 }
1134 }
1135 path = gtk_tree_path_new_from_string (path_string);
1136 gtk_tree_model_get_iter (model, &iter, path);
1137 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1138 gtk_tree_path_free (path);
1139 if(GeomDrawingArea != NULL) rafresh_drawing();
1140 return;
1141 }
1142
1143 /* R, Angle or Dihedral */
1144 if(numCol==E_R || numCol==E_ANGLE || numCol==E_DIHEDRAL)
1145 {
1146 gint nc = strlen(new_text);
1147 if(nc<1)return;
1148 Nc = atoi(path_string);
1149 if(testav(new_text)<-1)
1150 {
1151 gchar* message=g_strdup_printf(_("Sorry\n %s \nis not a number \nand is not a variable "),new_text);
1152 MessageGeom(message,_("Error"),TRUE);
1153 g_free(message);
1154 return;
1155 }
1156 if(test(new_text) && !testpointeE(new_text) )
1157 new_text=g_strdup_printf("%s.0",new_text);
1158 if(test(new_text) && atof(new_text)<0 && numCol==E_R)
1159 {
1160 gchar* message=g_strdup_printf(_("Sorry : The distance can not be negative"));
1161 MessageGeom(message,_("Error"),TRUE);
1162 g_free(message);
1163 return;
1164 }
1165 if(test(new_text) && fabs(atof(new_text))<0.01 && numCol==E_R)
1166 {
1167 gchar* message=g_strdup_printf(_("Sorry : The distance can not be <0.01"));
1168 MessageGeom(message,_("Error"),TRUE);
1169 g_free(message);
1170 return;
1171 }
1172
1173 if(numCol==E_R)
1174 {
1175 if(Geom[Nc].R) g_free(Geom[Nc].R);
1176 Geom[Nc].R = g_strdup(new_text);
1177 }
1178 if(numCol==E_ANGLE)
1179 {
1180 if(Geom[Nc].Angle) g_free(Geom[Nc].Angle);
1181 Geom[Nc].Angle = g_strdup(new_text);
1182 }
1183 if(numCol==E_DIHEDRAL)
1184 {
1185 if(Geom[Nc].Dihedral) g_free(Geom[Nc].Dihedral);
1186 Geom[Nc].Dihedral = g_strdup(new_text);
1187 }
1188 path = gtk_tree_path_new_from_string (path_string);
1189 gtk_tree_model_get_iter (model, &iter, path);
1190 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1191 gtk_tree_path_free (path);
1192 if(GeomDrawingArea != NULL) rafresh_drawing();
1193 return;
1194 }
1195 /* NR, NAngle, NDihedral */
1196 if(numCol==E_NUMBER_R || numCol==E_NUMBER_ANGLE || numCol==E_NUMBER_DIHEDRAL)
1197 {
1198 gint nc = strlen(new_text);
1199 gint N = -1;
1200 gint NR = -1;
1201 gint NA = -1;
1202 gint ND = -1;
1203 if(nc<1)return;
1204 Nc = atoi(path_string);
1205 if(!isInteger(new_text))
1206 {
1207 gchar* message=g_strdup_printf(_("Sorry\n %s \nis not an integer "),new_text);
1208 MessageGeom(message,_("Error"),TRUE);
1209 g_free(message);
1210 return;
1211 }
1212 N = atoi(new_text);
1213 if(N<1 || N>=Nc+1)
1214 {
1215 gchar* message=g_strdup_printf(_("Sorry\n %s \nis not an integer between 1 and %d"),new_text,Nc);
1216 MessageGeom(message,_("Error"),TRUE);
1217 g_free(message);
1218 return;
1219 }
1220 if( numCol==E_NUMBER_R && N == atoi(Geom[Nc].NR)) return;
1221 if( numCol==E_NUMBER_ANGLE && N == atoi(Geom[Nc].NAngle)) return;
1222 if( numCol==E_NUMBER_DIHEDRAL && N == atoi(Geom[Nc].NDihedral)) return;
1223
1224 if( numCol==E_NUMBER_R) NR = N;
1225 if( numCol==E_NUMBER_R && ((Nc>1 && N==atoi(Geom[Nc].NAngle)) || (Nc>2 && N==atoi(Geom[Nc].NDihedral))))
1226 {
1227 gchar* message=NULL;
1228 if((Nc>1 && N==atoi(Geom[Nc].NAngle)))
1229 {
1230 NA = atoi(Geom[Nc].NR);
1231 message=g_strdup_printf(
1232 _(
1233 "Because a multiple references to a center on the same card\n"
1234 "I set NA to %d\n"
1235 )
1236 ,NA
1237 );
1238 }
1239 if(Nc>2 && N==atoi(Geom[Nc].NDihedral))
1240 {
1241 ND = atoi(Geom[Nc].NR);
1242 message=g_strdup_printf(
1243 _(
1244 "Because a multiple references to a center on the same card\n"
1245 "I set ND to %d\n"
1246 )
1247 ,ND
1248 );
1249 }
1250 MessageGeom(message,_("Error"),TRUE);
1251 g_free(message);
1252 }
1253 if( numCol==E_NUMBER_ANGLE) NA = N;
1254 if( numCol==E_NUMBER_ANGLE && ((Nc>0 && N==atoi(Geom[Nc].NR)) || (Nc>2 && N==atoi(Geom[Nc].NDihedral))))
1255 {
1256 gchar* message= NULL;
1257 if(Nc>0 && N==atoi(Geom[Nc].NR))
1258 {
1259 NR = atoi(Geom[Nc].NAngle);
1260 message=g_strdup_printf(
1261 _(
1262 "Because a multiple references to a center on the same card\n"
1263 "I set NR to %d\n"
1264 )
1265 ,NR
1266 );
1267 }
1268 if(Nc>2 && N==atoi(Geom[Nc].NDihedral))
1269 {
1270 ND = atoi(Geom[Nc].NAngle);
1271 message=g_strdup_printf(
1272 "Because a multiple references to a center on the same card\n"
1273 "I set ND to %d\n",ND
1274 );
1275 }
1276 MessageGeom(message,_("Error"),TRUE);
1277 g_free(message);
1278 }
1279 if( numCol==E_NUMBER_DIHEDRAL) ND = N;
1280 if( numCol==E_NUMBER_DIHEDRAL && ( (Nc>1 && N==atoi(Geom[Nc].NAngle)) || (Nc>0 && N==atoi(Geom[Nc].NR))))
1281 {
1282 gchar* message=NULL;
1283 if(Nc>1 && N==atoi(Geom[Nc].NAngle))
1284 {
1285 NA = atoi(Geom[Nc].NDihedral);
1286 message=g_strdup_printf(
1287 _(
1288 "Because a multiple references to a center on the same card\n"
1289 "I set NA to %d\n"
1290 )
1291 ,NA
1292 );
1293 }
1294 if(Nc>0 && N==atoi(Geom[Nc].NR))
1295 {
1296 NR = atoi(Geom[Nc].NDihedral);
1297 message=g_strdup_printf(
1298 _(
1299 "Because a multiple references to a center on the same card\n"
1300 "I set NR to %d\n"
1301 )
1302 ,NR
1303 );
1304 }
1305 MessageGeom(message,_("Error"),TRUE);
1306 g_free(message);
1307 }
1308
1309 if( numCol==E_NUMBER_R)
1310 {
1311 gchar* dist = NULL;
1312 gchar* angle = NULL;
1313 gchar* dih = NULL;
1314 dist = get_distance_zmatrix(NR-1, Nc);
1315 if(NA>0) angle = get_angle_zmatrix(NA-1,NR-1, Nc);
1316 else if(Nc>=2) angle = get_angle_zmatrix(atoi(Geom[Nc].NAngle)-1,NR-1, Nc);
1317 if(ND>0) dih = get_dihedral_zmatrix(ND-1,atoi(Geom[Nc].NAngle)-1,NR-1,Nc);
1318 else if(Nc>=3) dih = get_dihedral_zmatrix(atoi(Geom[Nc].NDihedral)-1,atoi(Geom[Nc].NAngle)-1, NR-1, Nc);
1319
1320 if(dist)
1321 {
1322 if(reset_r_value(Nc, dist))
1323 set_text_column (model , path_string, dist,2*(numCol-1));
1324 }
1325 if(angle)
1326 {
1327 if(reset_angle_value(Nc, angle))
1328 set_text_column (model , path_string, angle,2*(numCol+1));
1329 }
1330 if(dih)
1331 {
1332 if(reset_dihedral_value(Nc, dih))
1333 set_text_column (model , path_string, dih,2*(numCol+3));
1334 }
1335
1336 if(Geom[Nc].NR) g_free(Geom[Nc].NR);
1337 Geom[Nc].NR = g_strdup(new_text);
1338 if(NA>0)
1339 {
1340 if(Geom[Nc].NAngle) g_free(Geom[Nc].NAngle);
1341 Geom[Nc].NAngle = g_strdup_printf("%d",NA);
1342 set_text_column (model , path_string, Geom[Nc].NAngle,2*(numCol+2));
1343 }
1344 if(ND>0)
1345 {
1346 if(Geom[Nc].NDihedral) g_free(Geom[Nc].NDihedral);
1347 Geom[Nc].NDihedral = g_strdup_printf("%d",ND);
1348 set_text_column (model , path_string, Geom[Nc].NDihedral,2*(numCol+4));
1349 }
1350 }
1351 if( numCol==E_NUMBER_ANGLE)
1352 {
1353 gchar* dist = NULL;
1354 gchar* angle = NULL;
1355 gchar* dih = NULL;
1356 if(NR>0) dist = get_distance_zmatrix(NR-1, Nc);
1357 if(NR>0) angle = get_angle_zmatrix (NA-1, NR-1, Nc);
1358 else angle = get_angle_zmatrix (NA-1, atoi(Geom[Nc].NR)-1, Nc);
1359 if(ND>0) dih = get_dihedral_zmatrix(ND-1,NA-1,atoi(Geom[Nc].NR)-1, Nc);
1360 else
1361 if(Nc>=3)
1362 {
1363 if(NR>0) dih = get_dihedral_zmatrix(atoi(Geom[Nc].NDihedral)-1, NA-1,NR-1, Nc);
1364 else dih = get_dihedral_zmatrix(atoi(Geom[Nc].NDihedral)-1, NA-1,atoi(Geom[Nc].NR)-1, Nc);
1365 }
1366
1367 if(dist)
1368 {
1369 if(reset_r_value(Nc, dist))
1370 set_text_column (model , path_string, dist,2*(numCol-3));
1371 }
1372 if(angle)
1373 {
1374 if(reset_angle_value(Nc, angle))
1375 set_text_column (model , path_string, angle,2*(numCol-1));
1376 }
1377 if(dih)
1378 {
1379 if(reset_dihedral_value(Nc, dih))
1380 set_text_column (model , path_string, dih,2*(numCol+1));
1381 }
1382
1383 if(Geom[Nc].NAngle) g_free(Geom[Nc].NAngle);
1384 Geom[Nc].NAngle = g_strdup(new_text);
1385 if(NR>0)
1386 {
1387 if(Geom[Nc].NR) g_free(Geom[Nc].NR);
1388 Geom[Nc].NR = g_strdup_printf("%d",NR);
1389 set_text_column (model , path_string, Geom[Nc].NR,2*(numCol-2));
1390 }
1391 if(ND>0)
1392 {
1393 if(Geom[Nc].NDihedral) g_free(Geom[Nc].NDihedral);
1394 Geom[Nc].NDihedral = g_strdup_printf("%d",ND);
1395 set_text_column (model , path_string, Geom[Nc].NDihedral,2*(numCol+2));
1396 }
1397 }
1398 if( numCol==E_NUMBER_DIHEDRAL)
1399 {
1400 gchar* dist = NULL;
1401 gchar* angle = NULL;
1402 gchar* dih = NULL;
1403 if(NR>0) dist = get_distance_zmatrix(NR-1, Nc);
1404 if(NR>0) angle = get_angle_zmatrix (atoi(Geom[Nc].NAngle)-1, NR-1, Nc);
1405 if(NA>0 && NR<0) angle = get_angle_zmatrix (NA-1, atoi(Geom[Nc].NR)-1, Nc);
1406 if(NA>0) dih = get_dihedral_zmatrix(ND-1,NA-1,atoi(Geom[Nc].NR)-1, Nc);
1407 if(NR>0) dih = get_dihedral_zmatrix(ND-1,atoi(Geom[Nc].NAngle)-1,NR-1,Nc);
1408 if(NR<0 && NA<0) dih = get_dihedral_zmatrix(ND-1,atoi(Geom[Nc].NAngle)-1,atoi(Geom[Nc].NR)-1,Nc);
1409
1410 if(dist)
1411 {
1412 if(reset_r_value(Nc, dist))
1413 set_text_column (model , path_string, dist,2*(numCol-5));
1414 }
1415 if(angle)
1416 {
1417 if(reset_angle_value(Nc, angle))
1418 set_text_column (model , path_string, angle,2*(numCol-3));
1419 }
1420 if(dih)
1421 {
1422 if(reset_dihedral_value(Nc, dih))
1423 set_text_column (model , path_string, dih,2*(numCol-1));
1424 }
1425
1426 if(Geom[Nc].NDihedral) g_free(Geom[Nc].NDihedral);
1427 Geom[Nc].NDihedral = g_strdup(new_text);
1428 if(NA>0)
1429 {
1430 if(Geom[Nc].NAngle) g_free(Geom[Nc].NAngle);
1431 Geom[Nc].NAngle = g_strdup_printf("%d",NA);
1432 set_text_column (model , path_string, Geom[Nc].NAngle,2*(numCol-2));
1433 }
1434 if(NR>0)
1435 {
1436 if(Geom[Nc].NR) g_free(Geom[Nc].NR);
1437 Geom[Nc].NR = g_strdup_printf("%d",NR);
1438 set_text_column (model , path_string, Geom[Nc].NR,2*(numCol-4));
1439 }
1440 }
1441 set_text_column (model , path_string, new_text,2*numCol);
1442 if(GeomDrawingArea != NULL) rafresh_drawing();
1443 return;
1444 }
1445 /* Charge */
1446 if(numCol==E_CHARGE)
1447 {
1448 gint nc = strlen(new_text);
1449 gchar* txt = NULL;
1450 if(nc<1)return;
1451 Nc = atoi(path_string);
1452 if(!test(new_text))
1453 {
1454 gchar* message=g_strdup_printf(_("Sorry %s is not a number \n"),new_text);
1455 MessageGeom(message,_("Error"),TRUE);
1456 g_free(message);
1457 return;
1458 }
1459 if(test(new_text) && !testpointeE(new_text) )
1460 txt=g_strdup_printf("%s.0",new_text);
1461 else
1462 txt=g_strdup_printf("%s",new_text);
1463 if(Geom[Nc].Charge) g_free(Geom[Nc].Charge);
1464 Geom[Nc].Charge = g_strdup(txt);
1465 path = gtk_tree_path_new_from_string (path_string);
1466 gtk_tree_model_get_iter (model, &iter, path);
1467 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, txt, -1);
1468 gtk_tree_path_free (path);
1469 if(GeomDrawingArea != NULL) rafresh_drawing();
1470 if(txt) g_free(txt);
1471 return;
1472 }
1473 /* Layer */
1474 if(numCol==E_LAYER)
1475 {
1476 gint nc = strlen(new_text);
1477 gint i;
1478 if(nc<1)return;
1479 new_text[0] = toupper(new_text[0]);
1480 for(i=1;i<nc;i++) new_text[i] = tolower(new_text[i]);
1481 Nc = atoi(path_string);
1482 if(!(!strcmp(new_text,"High")
1483 || !strcmp(new_text,"Medium")
1484 ||!strcmp(new_text,"Low")
1485 || !strcmp(new_text," ")))
1486 {
1487 gchar* message=g_strdup_printf(_("Sorry The layer should be High, Medium, Low or one space \n"));
1488 MessageGeom(message,_("Error"),TRUE);
1489 g_free(message);
1490 return;
1491 }
1492 if(Geom[Nc].Layer) g_free(Geom[Nc].Layer);
1493 Geom[Nc].Layer = g_strdup(new_text);
1494 path = gtk_tree_path_new_from_string (path_string);
1495 gtk_tree_model_get_iter (model, &iter, path);
1496 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1497 gtk_tree_path_free (path);
1498 if(GeomDrawingArea != NULL) rafresh_drawing();
1499 return;
1500 }
1501 }
1502 /********************************************************************************/
set_sensitive_option(GtkUIManager * manager,gchar * path,gboolean sensitive)1503 static void set_sensitive_option(GtkUIManager *manager, gchar* path, gboolean sensitive)
1504 {
1505 GtkWidget *wid = gtk_ui_manager_get_widget (manager, path);
1506 if(GTK_IS_WIDGET(wid)) gtk_widget_set_sensitive(wid, sensitive);
1507 }
1508 /**********************************************************************************/
show_menu_popup(GtkUIManager * manager,gchar * menuName,guint button,guint32 time)1509 static gboolean show_menu_popup(GtkUIManager *manager, gchar* menuName, guint button, guint32 time)
1510 {
1511 GtkWidget *menu = gtk_ui_manager_get_widget (manager, menuName);
1512 if (GTK_IS_MENU (menu))
1513 {
1514 gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, time);
1515 return TRUE;
1516 }
1517 return FALSE;
1518 }
1519 /********************************************************************************/
activate_action_xyz_geom(GtkAction * action)1520 static void activate_action_xyz_geom (GtkAction *action)
1521 {
1522 const gchar *name = gtk_action_get_name (action);
1523
1524 if(!strcmp(name, "Edit")) DialogueEdit();
1525 else if(!strcmp(name, "New")) DialogueAdd();
1526 else if(!strcmp(name, "Delete")) DialogueDelete();
1527 else if(!strcmp(name, "Draw")) draw_geometry(NULL, NULL);
1528 else if(!strcmp(name, "Save")) create_window_save_zmat();
1529 else if(!strcmp(name, "All")) DialogueTransInVar();
1530 else if(!strcmp(name, "AllR")) trans_allRGeom_to_variables();
1531 else if(!strcmp(name, "AllAngles")) trans_allAngleGeom_to_variables();
1532 else if(!strcmp(name, "AllDihedrals")) trans_allDihedralGeom_to_variables();
1533 else if(!strcmp(name, "OneAtom")) TransConstVar(TRUE,TRUE,TRUE);
1534 else if(!strcmp(name, "OneR")) TransConstVar(TRUE,FALSE,FALSE);
1535 else if(!strcmp(name, "OneAngle")) TransConstVar(FALSE,TRUE,FALSE);
1536 else if(!strcmp(name, "OneDihedral")) TransConstVar(FALSE,FALSE,TRUE);
1537 else if(!strcmp(name, "MultiplyBya0")) MultiByA0();
1538 else if(!strcmp(name, "DivideBya0")) DivideByA0();
1539 else if(!strcmp(name, "ToXYZ")) conversion_zmat_to_xyz();
1540 }
1541 /*--------------------------------------------------------------------*/
1542 static GtkActionEntry gtkActionEntriesZMatGeom[] =
1543 {
1544 {"Edit", NULL, "_Edit", NULL, "Edit", G_CALLBACK (activate_action_xyz_geom) },
1545 {"New", GABEDIT_STOCK_NEW, "_New", NULL, "New", G_CALLBACK (activate_action_xyz_geom) },
1546 {"Delete", GABEDIT_STOCK_CUT, "_Delete", NULL, "Delete", G_CALLBACK (activate_action_xyz_geom) },
1547 {"Draw", GABEDIT_STOCK_DRAW, "D_raw", NULL, "Draw", G_CALLBACK (activate_action_xyz_geom) },
1548 {"Save", GABEDIT_STOCK_SAVE, "_Save", NULL, "Save", G_CALLBACK (activate_action_xyz_geom) },
1549 {"All", NULL, "_All=>", NULL, "All=>", G_CALLBACK (activate_action_xyz_geom) },
1550 {"AllR", NULL, "All _R =>", NULL, "All R=>", G_CALLBACK (activate_action_xyz_geom) },
1551 {"AllAngles", NULL, "All _Angles =>", NULL, "All Angles =>", G_CALLBACK (activate_action_xyz_geom) },
1552 {"AllDihedrals", NULL, "All _Dihedral =>", NULL, "All Dihedral =>", G_CALLBACK (activate_action_xyz_geom) },
1553 {"OneAtom", NULL, "_One atom=>", NULL, "One atom=>", G_CALLBACK (activate_action_xyz_geom) },
1554 {"OneR", NULL, "_One R=>", NULL, "One R=>", G_CALLBACK (activate_action_xyz_geom) },
1555 {"OneAngle", NULL, "_One Angle=>", NULL, "One Angle=>", G_CALLBACK (activate_action_xyz_geom) },
1556 {"OneDihedral", NULL, "_One Dihedral=>", NULL, "One Dihedral=>", G_CALLBACK (activate_action_xyz_geom) },
1557 {"MultiplyBya0", GABEDIT_STOCK_A0P, "M_ultiply by a0", NULL, "Multiply by a0", G_CALLBACK (activate_action_xyz_geom) },
1558 {"DivideBya0", GABEDIT_STOCK_A0D, "D_ivide by a0", NULL, "D_ivide by a0", G_CALLBACK (activate_action_xyz_geom) },
1559 {"ToXYZ", NULL, "to _XYZ", NULL, "to XYZ", G_CALLBACK (activate_action_xyz_geom) },
1560 };
1561 static guint numberOfGtkActionEntriesZMatGeom = G_N_ELEMENTS (gtkActionEntriesZMatGeom);
1562 /********************************************************************************/
1563 /* XML description of the menus for the test app. The parser understands
1564 * a subset of the Bonobo UI XML format, and uses GMarkup for parsing */
1565 static const gchar *uiMenuZMatGeomInfo =
1566 " <popup name=\"MenuZMatGeom\">\n"
1567 " <separator name=\"sepMenuPopNew\" />\n"
1568 " <menuitem name=\"Edit\" action=\"Edit\" />\n"
1569 " <menuitem name=\"New\" action=\"New\" />\n"
1570 " <menuitem name=\"Delete\" action=\"Delete\" />\n"
1571 " <separator name=\"sepMenuPopDraw\" />\n"
1572 " <menuitem name=\"Draw\" action=\"Draw\" />\n"
1573 " <separator name=\"sepMenuPopSave\" />\n"
1574 " <menuitem name=\"Save\" action=\"Save\" />\n"
1575 " <separator name=\"sepMenuPopSave\" />\n"
1576 " <menuitem name=\"Save\" action=\"Save\" />\n"
1577 " <separator name=\"sepMenuPopAll\" />\n"
1578 " <menuitem name=\"All\" action=\"All\" />\n"
1579 " <menuitem name=\"AllR\" action=\"AllR\" />\n"
1580 " <menuitem name=\"AllAngles\" action=\"AllAngles\" />\n"
1581 " <menuitem name=\"AllDihedrals\" action=\"AllDihedrals\" />\n"
1582 " <menuitem name=\"OneAtom\" action=\"OneAtom\" />\n"
1583 " <menuitem name=\"OneR\" action=\"OneR\" />\n"
1584 " <menuitem name=\"OneAngle\" action=\"OneAngle\" />\n"
1585 " <menuitem name=\"OneDihedral\" action=\"OneDihedral\" />\n"
1586 " <separator name=\"sepMenuPopMul\" />\n"
1587 " <menuitem name=\"MultiplyBya0\" action=\"MultiplyBya0\" />\n"
1588 " <menuitem name=\"DivideBya0\" action=\"DivideBya0\" />\n"
1589 " <separator name=\"sepMenuPopZmat\" />\n"
1590 " <menuitem name=\"ToXYZ\" action=\"ToXYZ\" />\n"
1591 " </popup>\n"
1592 ;
1593 /*******************************************************************************************************************************/
newMenuZMatGeom(GtkWidget * win)1594 static GtkUIManager *newMenuZMatGeom(GtkWidget* win)
1595 {
1596 GtkActionGroup *actionGroup = NULL;
1597 GtkUIManager *manager = NULL;
1598 GError *error = NULL;
1599 static gchar* menuName = "/MenuZMatGeom";
1600
1601 manager = gtk_ui_manager_new ();
1602 g_signal_connect_swapped (win, "destroy", G_CALLBACK (g_object_unref), manager);
1603
1604 actionGroup = gtk_action_group_new ("GabeditListOfProject");
1605 gtk_action_group_set_translation_domain(actionGroup,GETTEXT_PACKAGE);
1606 gtk_action_group_add_actions (actionGroup, gtkActionEntriesZMatGeom, numberOfGtkActionEntriesZMatGeom, NULL);
1607
1608 gtk_ui_manager_insert_action_group (manager, actionGroup, 0);
1609
1610 gtk_window_add_accel_group (GTK_WINDOW (win), gtk_ui_manager_get_accel_group (manager));
1611 if (!gtk_ui_manager_add_ui_from_string (manager, uiMenuZMatGeomInfo, -1, &error))
1612 {
1613 g_message ("building menus failed: %s", error->message);
1614 g_error_free (error);
1615 }
1616 g_object_set_data(G_OBJECT(manager),"MenuName", menuName);
1617 return manager;
1618 }
1619 /********************************************************************************/
activate_action_zmat_variables(GtkAction * action)1620 static void activate_action_zmat_variables (GtkAction *action)
1621 {
1622 const gchar *name = gtk_action_get_name (action);
1623 if(!strcmp(name, "Edit")) DialogueEditV();
1624 else if(!strcmp(name, "New")) DialogueAddV();
1625 else if(!strcmp(name, "Delete")) DialogueDeleteV();
1626 else if(!strcmp(name, "All")) DialogueTransInConst();
1627 else if(!strcmp(name, "One")) TransVarConst();
1628 }
1629 /*--------------------------------------------------------------------*/
1630 static GtkActionEntry gtkActionEntriesZMatVariables[] =
1631 {
1632 {"Edit", NULL, "_Edit", NULL, "Edit", G_CALLBACK (activate_action_zmat_variables) },
1633 {"New", GABEDIT_STOCK_NEW, "_New", NULL, "New", G_CALLBACK (activate_action_zmat_variables) },
1634 {"Delete", GABEDIT_STOCK_CUT, "_Delete", NULL, "Delete", G_CALLBACK (activate_action_zmat_variables) },
1635 {"All", NULL, "<=_All", NULL, "<=All", G_CALLBACK (activate_action_zmat_variables) },
1636 {"One", NULL, "<=_One", NULL, "<=One", G_CALLBACK (activate_action_zmat_variables) },
1637 };
1638 static guint numberOfGtkActionEntriesZMatVariables = G_N_ELEMENTS (gtkActionEntriesZMatVariables);
1639 /********************************************************************************/
1640 /* XML description of the menus for the test app. The parser understands
1641 * a subset of the Bonobo UI XML format, and uses GMarkup for parsing */
1642 static const gchar *uiMenuZMatVariablesInfo =
1643 " <popup name=\"MenuZMatVariables\">\n"
1644 " <separator name=\"sepMenuPopNew\" />\n"
1645 " <menuitem name=\"Edit\" action=\"Edit\" />\n"
1646 " <menuitem name=\"New\" action=\"New\" />\n"
1647 " <menuitem name=\"Delete\" action=\"Delete\" />\n"
1648 " <separator name=\"sepMenuPopAll\" />\n"
1649 " <menuitem name=\"All\" action=\"All\" />\n"
1650 " <menuitem name=\"One\" action=\"One\" />\n"
1651 " </popup>\n"
1652 ;
1653 /*******************************************************************************************************************************/
newMenuZMatVariables(GtkWidget * win)1654 static GtkUIManager *newMenuZMatVariables(GtkWidget* win)
1655 {
1656 GtkActionGroup *actionGroup = NULL;
1657 GtkUIManager *manager = NULL;
1658 GError *error = NULL;
1659 static gchar* menuName = "/MenuZMatVariables";
1660
1661 manager = gtk_ui_manager_new ();
1662 g_signal_connect_swapped (win, "destroy", G_CALLBACK (g_object_unref), manager);
1663
1664 actionGroup = gtk_action_group_new ("GabeditListOfProject");
1665 gtk_action_group_set_translation_domain(actionGroup,GETTEXT_PACKAGE);
1666 gtk_action_group_add_actions (actionGroup, gtkActionEntriesZMatVariables, numberOfGtkActionEntriesZMatVariables, NULL);
1667
1668 gtk_ui_manager_insert_action_group (manager, actionGroup, 0);
1669
1670 gtk_window_add_accel_group (GTK_WINDOW (win), gtk_ui_manager_get_accel_group (manager));
1671 if (!gtk_ui_manager_add_ui_from_string (manager, uiMenuZMatVariablesInfo, -1, &error))
1672 {
1673 g_message ("building menus failed: %s", error->message);
1674 g_error_free (error);
1675 }
1676 g_object_set_data(G_OBJECT(manager),"MenuName", menuName);
1677 return manager;
1678 }
1679
1680 /********************************************************************************/
event_dispatcher(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1681 static void event_dispatcher(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
1682 {
1683
1684 GtkTreePath *path;
1685 gint row = -1;
1686 GtkUIManager *manager = NULL;
1687 gchar* menuName = NULL;
1688
1689 if (!event) return;
1690 if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))
1691 && !gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
1692 event->x, event->y, NULL, NULL, NULL, NULL)) {
1693 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)));
1694 }
1695 if(gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, NULL, NULL, NULL))
1696 {
1697 if(path)
1698 {
1699 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), path);
1700 row = atoi(gtk_tree_path_to_string(path));
1701 gtk_tree_path_free(path);
1702 }
1703 }
1704 manager = GTK_UI_MANAGER(user_data);
1705 menuName = g_object_get_data(G_OBJECT(manager),"MenuName");
1706 if(strstr(menuName,"Geom"))
1707 {
1708 LineSelected = row;
1709 NSA[0] = LineSelected+1;
1710 NSA[1] = NSA[2] = NSA[3] =-1;
1711 }
1712 else
1713 {
1714 LineSelectedV = row;
1715 LineSelectedOld = row;
1716 }
1717 if(GeomDrawingArea != NULL) rafresh_drawing();
1718 if (event->type == GDK_2BUTTON_PRESS)
1719 {
1720
1721 if(strstr(menuName,"Geom")) DialogueEdit();
1722 else DialogueEditV();
1723 }
1724
1725 if (event->type == GDK_BUTTON_PRESS && ((GdkEventButton *) event)->button == 3)
1726 {
1727 gchar* pathEdit = NULL;
1728 gchar* pathDelete = NULL;
1729 gchar* pathOne = NULL;
1730 gchar* pathAll = NULL;
1731 GdkEventButton *bevent = (GdkEventButton *) event;
1732
1733 if(menuName) pathEdit = g_strdup_printf("%s/Edit",menuName);
1734 if(menuName) pathDelete = g_strdup_printf("%s/Delete",menuName);
1735 if(menuName) pathOne = g_strdup_printf("%s/One",menuName);
1736 if(menuName) pathAll = g_strdup_printf("%s/All",menuName);
1737 if(pathEdit)
1738 {
1739 if(row<0) set_sensitive_option(manager, pathEdit, FALSE);
1740 else set_sensitive_option(manager, pathEdit, TRUE);
1741 g_free(pathEdit);
1742 }
1743 if(pathOne)
1744 {
1745 if(row<0) set_sensitive_option(manager, pathOne, FALSE);
1746 else set_sensitive_option(manager, pathOne, TRUE);
1747 g_free(pathOne);
1748 }
1749 if(pathDelete)
1750 {
1751 if(strstr(menuName,"Geom"))
1752 {
1753 if(NcentersZmat <1) set_sensitive_option(manager, pathDelete, FALSE);
1754 else set_sensitive_option(manager, pathDelete, TRUE);
1755 }
1756 else
1757 if(strstr(menuName,"Variable"))
1758 {
1759 if(NVariables <1) set_sensitive_option(manager, pathDelete, FALSE);
1760 else set_sensitive_option(manager, pathDelete, TRUE);
1761 }
1762 g_free(pathDelete);
1763 }
1764 if(pathAll)
1765 {
1766 if(strstr(menuName,"Geom"))
1767 {
1768 if(NcentersZmat <1) set_sensitive_option(manager, pathAll, FALSE);
1769 else set_sensitive_option(manager, pathAll, TRUE);
1770 }
1771 else
1772 if(strstr(menuName,"Variable"))
1773 {
1774 if(NVariables <1) set_sensitive_option(manager, pathAll, FALSE);
1775 else set_sensitive_option(manager, pathAll, TRUE);
1776 }
1777 g_free(pathAll);
1778 }
1779 show_menu_popup(manager, menuName, bevent->button, bevent->time);
1780 }
1781 GTK_WIDGET_GET_CLASS(widget)->button_press_event(widget, event);
1782 }
1783 /********************************************************************************/
freeList(gchar ** strs,gint nlist)1784 static gchar** freeList(gchar** strs, gint nlist)
1785 {
1786 gint i;
1787
1788 for(i=0;i<nlist;i++)
1789 if(strs[i])
1790 g_free(strs[i]);
1791
1792 g_free(strs);
1793
1794 return NULL;
1795 }
1796 /********************************************************************************/
append_list_variables()1797 static void append_list_variables()
1798 {
1799 gchar *texts[2];
1800 guint i;
1801 gint k;
1802 GtkTreeIter iter;
1803 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(listv));
1804 GtkListStore *store = GTK_LIST_STORE (model);
1805
1806 model = GTK_TREE_MODEL (store);
1807
1808 for(i=0;i<NVariables;i++)
1809 {
1810 texts[0] = g_strdup(Variables[i].Name);
1811 texts[1] = g_strdup(Variables[i].Value);
1812
1813 gtk_list_store_append (store, &iter);
1814 for(k=0;k<2;k++)
1815 {
1816 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,TRUE, -1);
1817 g_free(texts[k]);
1818 }
1819 }
1820 }
1821 /********************************************************************************/
append_list_geom()1822 static void append_list_geom()
1823 {
1824 gint k;
1825 GtkTreeIter iter;
1826 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(list));
1827 GtkListStore *store = GTK_LIST_STORE (model);
1828 gchar *texts[NUMBER_LIST_ZMATRIX];
1829 guint Nc;
1830 guint i;
1831
1832 for(Nc=0;Nc<NcentersZmat;Nc++)
1833 {
1834 for (i=0;i<NUMBER_LIST_ZMATRIX;i++) texts[i] = g_strdup(" ");
1835 switch ( Nc) {
1836 case 0: texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
1837 texts[E_SYMBOL] = g_strdup(Geom[Nc].Symb);
1838 texts[E_MMTYPE] = g_strdup(Geom[Nc].mmType);
1839 texts[E_PDBTYPE] = g_strdup(Geom[Nc].pdbType);
1840 texts[E_RESIDUE] = g_strdup(Geom[Nc].Residue);
1841 texts[E_CHARGE] = g_strdup(Geom[Nc].Charge);
1842 texts[E_LAYER] = g_strdup(Geom[Nc].Layer);
1843 break;
1844 case 1: texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
1845 texts[E_SYMBOL] = g_strdup(Geom[Nc].Symb);
1846 texts[E_MMTYPE] = g_strdup(Geom[Nc].mmType);
1847 texts[E_PDBTYPE] = g_strdup(Geom[Nc].pdbType);
1848 texts[E_RESIDUE] = g_strdup(Geom[Nc].Residue);
1849 texts[E_R] = g_strdup(Geom[Nc].R);
1850 texts[E_NUMBER_R] = g_strdup(Geom[Nc].NR);
1851 texts[E_CHARGE] = g_strdup(Geom[Nc].Charge);
1852 texts[E_LAYER] = g_strdup(Geom[Nc].Layer);
1853 break;
1854 case 2: texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
1855 texts[E_SYMBOL] = g_strdup(Geom[Nc].Symb);
1856 texts[E_MMTYPE] = g_strdup(Geom[Nc].mmType);
1857 texts[E_PDBTYPE] = g_strdup(Geom[Nc].pdbType);
1858 texts[E_RESIDUE] = g_strdup(Geom[Nc].Residue);
1859 texts[E_R] = g_strdup(Geom[Nc].R);
1860 texts[E_NUMBER_R] = g_strdup(Geom[Nc].NR);
1861 texts[E_ANGLE] = g_strdup(Geom[Nc].Angle);
1862 texts[E_NUMBER_ANGLE] = g_strdup(Geom[Nc].NAngle);
1863 texts[E_CHARGE] = g_strdup(Geom[Nc].Charge);
1864 texts[E_LAYER] = g_strdup(Geom[Nc].Layer);
1865 break;
1866 default : texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
1867 texts[E_SYMBOL] = g_strdup(Geom[Nc].Symb);
1868 texts[E_MMTYPE] = g_strdup(Geom[Nc].mmType);
1869 texts[E_PDBTYPE] = g_strdup(Geom[Nc].pdbType);
1870 texts[E_RESIDUE] = g_strdup(Geom[Nc].Residue);
1871 texts[E_R] = g_strdup(Geom[Nc].R);
1872 texts[E_NUMBER_R] = g_strdup(Geom[Nc].NR);
1873 texts[E_ANGLE] = g_strdup(Geom[Nc].Angle);
1874 texts[E_NUMBER_ANGLE] = g_strdup(Geom[Nc].NAngle);
1875 texts[E_DIHEDRAL] = g_strdup(Geom[Nc].Dihedral);
1876 texts[E_NUMBER_DIHEDRAL] = g_strdup(Geom[Nc].NDihedral);
1877 texts[E_CHARGE] = g_strdup(Geom[Nc].Charge);
1878 texts[E_LAYER] = g_strdup(Geom[Nc].Layer);
1879 break;
1880 }
1881 gtk_list_store_append (store, &iter);
1882 for(k=0;k<NUMBER_LIST_ZMATRIX;k++)
1883 {
1884 gboolean ed = TRUE;
1885 if(k==0) ed=FALSE;
1886 if(Nc<1 && k>4 && k<11) ed=FALSE;
1887 if(Nc<2 && k>6 && k<11) ed=FALSE;
1888 if(Nc<3 && k>8 && k<11) ed=FALSE;
1889 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
1890 g_free(texts[k]);
1891 }
1892 }
1893 }
1894 /********************************************************************************/
FreeGeom(GeomAtomDef * Geomtemp,VariablesDef * Variablestemp,gint Ncent,gint Nvar)1895 void FreeGeom(GeomAtomDef* Geomtemp,VariablesDef* Variablestemp,gint Ncent,gint Nvar)
1896 {
1897 guint i;
1898 init_dipole();
1899 if( Geomtemp)
1900 for(i=0;(gint)i<Ncent;i++)
1901 {
1902 if(Geomtemp[i].Symb)
1903 g_free(Geomtemp[i].Symb);
1904 if(Geomtemp[i].mmType)
1905 g_free(Geomtemp[i].mmType);
1906 if(Geomtemp[i].pdbType)
1907 g_free(Geomtemp[i].pdbType);
1908 if(i>0)
1909 {
1910 if(Geomtemp[i].R)
1911 g_free(Geomtemp[i].R);
1912 if(Geomtemp[i].NR)
1913 g_free(Geomtemp[i].NR);
1914 }
1915 if(i>1)
1916 {
1917 if(Geomtemp[i].Angle)
1918 g_free(Geomtemp[i].Angle);
1919 if(Geomtemp[i].NAngle)
1920 g_free(Geomtemp[i].NAngle);
1921 }
1922 if(i>2)
1923 {
1924 if(Geomtemp[i].Dihedral)
1925 g_free(Geomtemp[i].Dihedral);
1926 if(Geomtemp[i].NDihedral)
1927 g_free(Geomtemp[i].NDihedral);
1928 }
1929 if(Geomtemp[i].Charge)
1930 g_free(Geomtemp[i].Charge);
1931 if(Geomtemp[i].Layer)
1932 g_free(Geomtemp[i].Layer);
1933 }
1934 if( Geomtemp)
1935 g_free(Geomtemp);
1936 if( !Variablestemp)
1937 return;
1938 for(i=0;(gint)i<Nvar;i++)
1939 {
1940 if(Variablestemp[i].Name)
1941 g_free(Variablestemp[i].Name);
1942 if(Variablestemp[i].Value)
1943 g_free(Variablestemp[i].Value);
1944 }
1945 g_free(Variablestemp);
1946 }
1947 /********************************************************************************/
freeGeom()1948 void freeGeom()
1949 {
1950 guint i;
1951 init_dipole();
1952 if(Geom == NULL)
1953 return;
1954 for(i=0;i<NcentersZmat;i++)
1955 {
1956 g_free(Geom[i].Symb);
1957 g_free(Geom[i].mmType);
1958 g_free(Geom[i].pdbType);
1959 if(i>0)
1960 {
1961 g_free(Geom[i].R);
1962 g_free(Geom[i].NR);
1963 }
1964 if(i>1)
1965 {
1966 g_free(Geom[i].Angle);
1967 g_free(Geom[i].NAngle);
1968 }
1969 if(i>2)
1970 {
1971 g_free(Geom[i].Dihedral);
1972 g_free(Geom[i].NDihedral);
1973 }
1974 g_free(Geom[i].Charge);
1975 g_free(Geom[i].Layer);
1976 }
1977 g_free(Geom);
1978 Geom = NULL;
1979 NcentersZmat = 0;
1980 }
1981 /********************************************************************************/
freeVariables()1982 void freeVariables()
1983 {
1984 guint i;
1985 if(Variables==NULL)
1986 return;
1987 for(i=0;i<NVariables;i++)
1988 {
1989 g_free(Variables[i].Name);
1990 g_free(Variables[i].Value);
1991 }
1992 g_free(Variables);
1993 Variables = NULL;
1994 NVariables = 0;
1995 }
1996 /********************************************************************************/
destroy_dialogue(GtkWidget * win,gpointer d)1997 static void destroy_dialogue(GtkWidget *win,gpointer d)
1998 {
1999 if(DestroyDialog)
2000 {
2001 delete_child(win);
2002 }
2003 }
2004 /********************************************************************************/
save_gzmatrix_file(G_CONST_RETURN gchar * NameFileZmatrix)2005 void save_gzmatrix_file(G_CONST_RETURN gchar* NameFileZmatrix)
2006 {
2007 guint i;
2008 guint j;
2009 gboolean OK;
2010 FILE *fd;
2011 gchar *projectname = NULL;
2012 gchar *datafile = NULL;
2013 gchar *localdir = NULL;
2014 gchar *remotehost = NULL;
2015 gchar *remoteuser = NULL;
2016 gchar *remotepass = NULL;
2017 gchar *remotedir = NULL;
2018 gchar *temp = NULL;
2019
2020 temp = get_suffix_name_file(NameFileZmatrix);
2021 NameFileZmatrix = g_strdup_printf("%s.gzmt",temp);
2022 g_free(temp);
2023 fd = FOpen(NameFileZmatrix, "w");
2024 if(fd == NULL)
2025 {
2026 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),NameFileZmatrix);
2027 Message(t,_("Error"),TRUE);
2028 g_free(t);
2029 return;
2030 }
2031 fprintf(fd,"%s\n",Geom[0].Symb);
2032 if(NcentersZmat>1)
2033 {
2034 if(Units==1 || !test(Geom[1].R))
2035 fprintf(fd,"%s\t%s\t%s\n",Geom[1].Symb,
2036 Geom[1].NR,Geom[1].R);
2037 else
2038 fprintf(fd,"%s\t%s\t%s\n",Geom[1].Symb,
2039 Geom[1].NR,bohr_to_ang(Geom[1].R));
2040 }
2041 if(NcentersZmat>2)
2042 {
2043 if(Units==1 || !test(Geom[2].R))
2044 fprintf(fd,"%s\t%s\t%s\t%s\t%s\n",Geom[2].Symb,
2045 Geom[2].NR,Geom[2].R,
2046 Geom[2].NAngle,Geom[2].Angle);
2047 else
2048 fprintf(fd,"%s\t%s\t%s\t%s\t%s\n",Geom[2].Symb,
2049 Geom[2].NR,bohr_to_ang(Geom[2].R),
2050 Geom[2].NAngle,Geom[2].Angle);
2051 }
2052 for(i=3;i<NcentersZmat;i++)
2053 {
2054 if(Units==1 || !test(Geom[i].R))
2055 fprintf(fd,"%s\t%s\t%s\t%s\t%s\t%s\t%s\n",Geom[i].Symb,
2056 Geom[i].NR,Geom[i].R,
2057 Geom[i].NAngle,Geom[i].Angle,
2058 Geom[i].NDihedral,Geom[i].Dihedral);
2059 else
2060 fprintf(fd,"%s\t%s\t%s\t%s\t%s\t%s\t%s\n",Geom[i].Symb,
2061 Geom[i].NR,bohr_to_ang(Geom[i].R),
2062 Geom[i].NAngle,Geom[i].Angle,
2063 Geom[i].NDihedral,Geom[i].Dihedral);
2064 }
2065 /* Variables */
2066 fprintf(fd,"\n");
2067 for(i=0;i<NVariables;i++)
2068 {
2069 if(Units==1)
2070 fprintf(fd,"%s\t%s\n",
2071 Variables[i].Name,Variables[i].Value);
2072 else
2073 {
2074 /* search if variable i is used for R */
2075 OK=FALSE;
2076 for(j=1;j<NcentersZmat;j++)
2077 if(!strcmp(Geom[j].R,Variables[i].Name))
2078 {
2079 OK=TRUE;
2080 break;
2081 }
2082 if(OK)
2083 fprintf(fd,"%s\t%s\n",
2084 Variables[i].Name,bohr_to_ang(Variables[i].Value));
2085 else
2086 fprintf(fd,"%s\t%s\n",
2087 Variables[i].Name,Variables[i].Value);
2088 }
2089 }
2090 fprintf(fd,"\n");
2091
2092 fclose(fd);
2093 datafile = get_name_file(NameFileZmatrix);
2094 temp = get_suffix_name_file(NameFileZmatrix);
2095 projectname = get_name_file(temp);
2096 localdir = get_name_dir(temp);
2097 if(lastdirectory)
2098 g_free(lastdirectory);
2099 lastdirectory = g_strdup(localdir);
2100 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_GZMAT],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_GZMAT, NULL, defaultNetWorkProtocol);
2101 g_free(temp);
2102 g_free(datafile);
2103 g_free(projectname);
2104 g_free(localdir);
2105 }
2106 /************************************************************************************/
save_geometry_gzmatrix_file(GabeditFileChooser * SelecFile,gint response_id)2107 void save_geometry_gzmatrix_file(GabeditFileChooser *SelecFile, gint response_id)
2108 {
2109 gchar *FileName;
2110
2111 if(response_id != GTK_RESPONSE_OK) return;
2112 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2113 if ((!FileName) || (strcmp(FileName,"") == 0))
2114 {
2115 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2116 return ;
2117 }
2118 save_gzmatrix_file(FileName);
2119 }
2120 /********************************************************************************/
save_gzmatrix_file_entry(GtkWidget * entry)2121 void save_gzmatrix_file_entry(GtkWidget* entry)
2122 {
2123 G_CONST_RETURN gchar *NameFileZmatrix;
2124
2125 NameFileZmatrix = gtk_entry_get_text(GTK_ENTRY(entry));
2126 if ((!NameFileZmatrix) || (strcmp(NameFileZmatrix,"") == 0))
2127 return ;
2128 save_gzmatrix_file(NameFileZmatrix);
2129 }
2130 /********************************************************************************/
get_info(gint i,gchar * info[])2131 static void get_info(gint i,gchar* info[])
2132 {
2133 gint n = -1;
2134 gdouble R;
2135 gdouble A;
2136 gdouble D;
2137 if(i<=2)
2138 n = i;
2139 else
2140 n = 3;
2141
2142 switch(n)
2143 {
2144 case 0 :
2145 info[0] = g_strdup(Geom[i].Symb);
2146 info[1] = g_strdup_printf("%20.10f",0.0);
2147 info[2] = g_strdup("0");
2148 info[3] = g_strdup_printf("%20.10f",0.0);
2149 info[4] = g_strdup("0");
2150 info[5] = g_strdup_printf("%20.10f",0.0);
2151 info[6] = g_strdup("0");
2152 info[7] = g_strdup("0");
2153 info[8] = g_strdup("0");
2154 info[9] = g_strdup("0");
2155 break;
2156 case 1 :
2157 if(!test(Geom[i].R))
2158 R = get_value_variableZmat(Geom[i].R);
2159 else
2160 R = atof(Geom[i].R);
2161 if(Units == 0)
2162 R *= BOHR_TO_ANG;
2163
2164 info[0] = g_strdup(Geom[i].Symb);
2165 info[1] = g_strdup_printf("%20.10f",R);
2166 info[2] = g_strdup("0");
2167 info[3] = g_strdup_printf("%20.10f",0.0);
2168 info[4] = g_strdup("0");
2169 info[5] = g_strdup_printf("%20.10f",0.0);
2170 info[6] = g_strdup("0");
2171 info[7] = g_strdup(Geom[i].NR);
2172 info[8] = g_strdup("0");
2173 info[9] = g_strdup("0");
2174 break;
2175 case 2 :
2176 if(!test(Geom[i].R))
2177 R = get_value_variableZmat(Geom[i].R);
2178 else
2179 R = atof(Geom[i].R);
2180 if(Units == 0)
2181 R *= BOHR_TO_ANG;
2182 if(!test(Geom[i].Angle))
2183 A = get_value_variableZmat(Geom[i].Angle);
2184 else
2185 A = atof(Geom[i].Angle);
2186
2187 info[0] = g_strdup(Geom[i].Symb);
2188 info[1] = g_strdup_printf("%20.10f",R);
2189 info[2] = g_strdup("0");
2190 info[3] = g_strdup_printf("%20.10f",A);
2191 info[4] = g_strdup("0");
2192 info[5] = g_strdup_printf("%20.10f",0.0);
2193 info[6] = g_strdup("0");
2194 info[7] = g_strdup(Geom[i].NR);
2195 info[8] = g_strdup(Geom[i].NAngle);
2196 info[9] = g_strdup("0");
2197 break;
2198 case 3 :
2199 if(!test(Geom[i].R))
2200 R = get_value_variableZmat(Geom[i].R);
2201 else
2202 R = atof(Geom[i].R);
2203 if(Units == 0)
2204 R *= BOHR_TO_ANG;
2205 if(!test(Geom[i].Angle))
2206 A = get_value_variableZmat(Geom[i].Angle);
2207 else
2208 A = atof(Geom[i].Angle);
2209 if(!test(Geom[i].Dihedral))
2210 D = get_value_variableZmat(Geom[i].Dihedral);
2211 else
2212 D = atof(Geom[i].Dihedral);
2213 info[0] = g_strdup(Geom[i].Symb);
2214 info[1] = g_strdup_printf("%20.10f",R);
2215 info[2] = g_strdup("0");
2216 info[3] = g_strdup_printf("%20.10f",A);
2217 info[4] = g_strdup("0");
2218 info[5] = g_strdup_printf("%20.10f",D);
2219 info[6] = g_strdup("0");
2220 info[7] = g_strdup(Geom[i].NR);
2221 info[8] = g_strdup(Geom[i].NAngle);
2222 info[9] = g_strdup(Geom[i].NDihedral);
2223 break;
2224 }
2225 }
2226 /********************************************************************************/
save_mzmatrix_file(G_CONST_RETURN gchar * NameFileZmatrix)2227 void save_mzmatrix_file(G_CONST_RETURN gchar* NameFileZmatrix)
2228 {
2229 guint i;
2230 guint j;
2231 FILE *fd;
2232 gchar *projectname = NULL;
2233 gchar *datafile = NULL;
2234 gchar *localdir = NULL;
2235 gchar *remotehost = NULL;
2236 gchar *remoteuser = NULL;
2237 gchar *remotepass = NULL;
2238 gchar *remotedir = NULL;
2239 gchar *temp = NULL;
2240 gchar *info[10];
2241
2242 temp = get_suffix_name_file(NameFileZmatrix);
2243 NameFileZmatrix = g_strdup_printf("%s.zmt",temp);
2244 g_free(temp);
2245 fd = FOpen(NameFileZmatrix, "w");
2246 if(fd == NULL)
2247 {
2248 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),NameFileZmatrix);
2249 Message(t,_("Error"),TRUE);
2250 g_free(t);
2251 return;
2252 }
2253 for(j=0;j<10;j++)
2254 info[j] = g_strdup(" ");
2255
2256 fprintf(fd,"\n\n MOPAC file created by Gabedit\n");
2257 for(i=0;i<NcentersZmat;i++)
2258 {
2259
2260 for(j=0;j<10;j++)
2261 g_free(info[j]);
2262 get_info(i,info);
2263 fprintf(fd,"%3s %20s %5s %20s %5s %20s %5s %5s %5s %5s\n",
2264 info[0],info[1],info[2],info[3],info[4],info[5],info[6],info[7],info[8],info[9]);
2265 }
2266 fprintf(fd,"0");
2267
2268 fclose(fd);
2269 datafile = get_name_file(NameFileZmatrix);
2270 temp = get_suffix_name_file(NameFileZmatrix);
2271 projectname = get_name_file(temp);
2272 localdir = get_name_dir(temp);
2273 if(lastdirectory)
2274 g_free(lastdirectory);
2275 lastdirectory = g_strdup(localdir);
2276 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_MZMAT],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_MZMAT, NULL, defaultNetWorkProtocol);
2277 g_free(temp);
2278 g_free(datafile);
2279 g_free(projectname);
2280 g_free(localdir);
2281 }
2282 /************************************************************************************/
save_geometry_mzmatrix_file(GabeditFileChooser * SelecFile,gint response_id)2283 void save_geometry_mzmatrix_file(GabeditFileChooser *SelecFile, gint response_id)
2284 {
2285 gchar *FileName;
2286
2287 if(response_id != GTK_RESPONSE_OK) return;
2288 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2289 if ((!FileName) || (strcmp(FileName,"") == 0))
2290 {
2291 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2292 return ;
2293 }
2294 save_mzmatrix_file(FileName);
2295 }
2296 /********************************************************************************/
save_mzmatrix_file_entry(GtkWidget * entry)2297 void save_mzmatrix_file_entry(GtkWidget* entry)
2298 {
2299 G_CONST_RETURN gchar *NameFileZmatrix;
2300
2301 NameFileZmatrix = gtk_entry_get_text(GTK_ENTRY(entry));
2302 if ((!NameFileZmatrix) || (strcmp(NameFileZmatrix,"") == 0))
2303 return ;
2304 save_mzmatrix_file(NameFileZmatrix);
2305
2306 }
2307 /********************************************************************************/
save_gmzmatrix_file(GtkWidget * win,gpointer data)2308 void save_gmzmatrix_file(GtkWidget* win,gpointer data)
2309 {
2310 GtkWidget * ButtonGZmat = g_object_get_data(G_OBJECT(win),"ButtonGZmat");
2311 GtkWidget * entry = g_object_get_data(G_OBJECT(win),"Entry");
2312 GtkWidget * buttonDirSelector = g_object_get_data(G_OBJECT(win),"ButtonDirSelector");
2313 G_CONST_RETURN gchar *entrytext;
2314 gchar *dirName;
2315 gchar *fileName;
2316
2317 entrytext = gtk_entry_get_text(GTK_ENTRY(entry));
2318 dirName = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER(buttonDirSelector));
2319 fileName = get_dir_file_name(dirName,entrytext);
2320 if (GTK_TOGGLE_BUTTON (ButtonGZmat)->active)
2321 {
2322 save_gzmatrix_file(fileName);
2323 }
2324 else
2325 {
2326 save_mzmatrix_file(fileName);
2327 }
2328 }
2329 /********************************************************************************/
reset_extended_file(gpointer data,G_CONST_RETURN gchar * ext)2330 static void reset_extended_file(gpointer data,G_CONST_RETURN gchar* ext)
2331 {
2332 GtkWidget* entry = GTK_WIDGET(data);
2333 G_CONST_RETURN gchar* entrytext = gtk_entry_get_text(GTK_ENTRY(entry));
2334 gchar* temp = get_filename_without_ext(entrytext);
2335 gchar* t = g_strdup_printf("%s.%s",temp,ext);
2336 gtk_entry_set_text(GTK_ENTRY(entry),t);
2337 g_free(t);
2338 g_free(temp);
2339 }
2340 /********************************************************************************/
reset_extended_gzmat_file(GtkWidget * b,gpointer data)2341 void reset_extended_gzmat_file(GtkWidget* b,gpointer data)
2342 {
2343 reset_extended_file(data,"gzmt");
2344 }
2345 /********************************************************************************/
reset_extended_mzmat_file(GtkWidget * b,gpointer data)2346 void reset_extended_mzmat_file(GtkWidget* b,gpointer data)
2347 {
2348 reset_extended_file(data,"zmt");
2349 }
2350 /********************************************************************************/
create_window_save_zmat()2351 void create_window_save_zmat()
2352 {
2353 GtkWidget *fp;
2354 GtkWidget *frame;
2355 GtkWidget *vboxall;
2356 GtkWidget *vboxframe;
2357 GtkWidget *hbox;
2358 GtkWidget *button;
2359 GtkWidget *ButtonGZmat;
2360 GtkWidget *ButtonMZmat;
2361 GtkWidget *entry;
2362 GtkWidget *Win = WindowGeom;
2363 gchar *labelt = g_strdup(" File : ");
2364 gchar *fileName;
2365 gchar *titre=g_strdup("Save in Z-matrix file");
2366 GtkWidget* buttonDirSelector;
2367
2368 if(NcentersZmat<1)
2369 {
2370 MessageGeom(_(" Sorry No Center !"),_("Error"),TRUE);
2371 return;
2372 }
2373 if(!Win)
2374 Win = Fenetre;
2375 fileName = g_strdup_printf("%s.gzmt",fileopen.projectname);
2376 /* Fenetre principale */
2377 fp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2378 gtk_window_set_title(GTK_WINDOW(fp),titre);
2379 gtk_window_set_position(GTK_WINDOW(fp),GTK_WIN_POS_CENTER);
2380 gtk_window_set_transient_for(GTK_WINDOW(fp),GTK_WINDOW(Fenetre));
2381
2382 add_child(Win,fp,gtk_widget_destroy," Save Z-matrix ");
2383
2384 g_signal_connect(G_OBJECT(fp),"delete_event",(GCallback)delete_child,NULL);
2385 g_signal_connect(G_OBJECT(fp),"delete_event",(GCallback)gtk_widget_destroy,NULL);
2386
2387 gtk_container_set_border_width (GTK_CONTAINER (fp), 5);
2388 vboxall = create_vbox(fp);
2389
2390
2391 frame = gtk_frame_new ("Type of file");
2392 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
2393 gtk_container_add (GTK_CONTAINER (vboxall), frame);
2394 gtk_widget_show (frame);
2395
2396 vboxframe = create_vbox(frame);
2397
2398 hbox = gtk_hbox_new(TRUE, 10);
2399 gtk_container_add (GTK_CONTAINER (vboxframe), hbox);
2400 gtk_widget_show (hbox);
2401 ButtonGZmat = gtk_radio_button_new_with_label( NULL,"Gaussian Z-matrix " );
2402 gtk_box_pack_start (GTK_BOX (hbox), ButtonGZmat, FALSE, FALSE, 5);
2403 gtk_widget_show (ButtonGZmat);
2404 ButtonMZmat = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ButtonGZmat)), "Mopac Z-matrix");
2405 gtk_box_pack_start (GTK_BOX (hbox), ButtonMZmat, FALSE, FALSE, 5);
2406 gtk_widget_show (ButtonMZmat);
2407 create_hseparator(vboxframe);
2408
2409
2410
2411 create_table_browser(Win,vboxframe);
2412 entry = (GtkWidget*)(g_object_get_data(G_OBJECT(Win),"EntryFileName"));
2413 gtk_entry_set_text(GTK_ENTRY(entry),fileName);
2414 buttonDirSelector = (GtkWidget*)(g_object_get_data(G_OBJECT(Win),"ButtonDirSelector"));
2415 if(fileopen.localdir && strcmp(fileopen.localdir,"NoName")!=0) gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(buttonDirSelector), fileopen.localdir);
2416
2417 create_hseparator(vboxframe);
2418 g_signal_connect(G_OBJECT(ButtonGZmat),"clicked",(GCallback)reset_extended_gzmat_file,(gpointer)(entry));
2419 g_signal_connect(G_OBJECT(ButtonMZmat),"clicked",(GCallback)reset_extended_mzmat_file,(gpointer)(entry));
2420
2421 g_object_set_data(G_OBJECT (fp), "ButtonGZmat",ButtonGZmat);
2422 g_object_set_data(G_OBJECT (fp), "ButtonMZmat",ButtonMZmat);
2423 g_object_set_data(G_OBJECT (fp), "Entry",entry);
2424 g_object_set_data(G_OBJECT (fp), "ButtonDirSelector",buttonDirSelector);
2425 /* buttons */
2426 create_hseparator(vboxall);
2427 hbox = gtk_hbox_new(FALSE, 0);
2428 gtk_box_pack_start (GTK_BOX (vboxall), hbox, FALSE, FALSE, 5);
2429 gtk_widget_realize(fp);
2430
2431
2432
2433
2434 button = create_button(fp,_("OK"));
2435 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, FALSE, 3);
2436 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2437 gtk_widget_grab_default(button);
2438 gtk_widget_show (button);
2439 g_signal_connect_swapped(G_OBJECT(button), "clicked",G_CALLBACK(save_gmzmatrix_file),GTK_OBJECT(fp));
2440 g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)delete_child,GTK_OBJECT(fp));
2441
2442 button = create_button(fp,_("Cancel"));
2443 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, FALSE, 3);
2444 g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)delete_child,GTK_OBJECT(fp));
2445 gtk_widget_show (button);
2446 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2447
2448 g_free(labelt);
2449 g_free(fileName);
2450
2451 gtk_widget_show_all(fp);
2452 }
2453 /********************************************************************************/
testav(gchar * t)2454 static gint testav(gchar *t)
2455 {
2456 guint i;
2457 if(!test(t) ){
2458 for(i=0;i<NVariables;i++)
2459 if (!strcmp(t,Variables[i].Name))
2460 return i;
2461
2462 return -2;
2463 }
2464 else
2465 return -1;
2466 }
2467 /********************************************************************************/
ChangeVariablesUseds()2468 static void ChangeVariablesUseds()
2469 {
2470 guint i;
2471 guint j;
2472 gboolean k;
2473
2474 for (i=0;i<NVariables;i++)
2475 {
2476 k=FALSE;
2477 for (j=0;j<NcentersZmat;j++)
2478 {
2479 if(Geom[j].Nentry>NUMBER_ENTRY_0)
2480 {
2481 if (!strcmp(Variables[i].Name, Geom[j].R) )
2482 k=TRUE;
2483 if(k)break;
2484 }
2485 if(Geom[j].Nentry>NUMBER_ENTRY_R)
2486 {
2487 if (!strcmp(Variables[i].Name, Geom[j].Angle) )
2488 k=TRUE;
2489 if(k)break;
2490 }
2491 if(Geom[j].Nentry>NUMBER_ENTRY_ANGLE)
2492 {
2493 if (!strcmp(Variables[i].Name, Geom[j].Dihedral) )
2494 k=TRUE;
2495 if(k)break;
2496 }
2497 }
2498 Variables[i].Used=k;
2499 }
2500 }
2501 /********************************************************************************/
AllocationVariable()2502 void AllocationVariable()
2503 {
2504 if(Variables != NULL)
2505 Variables = g_realloc(Variables,NVariables*sizeof(VariablesDef));
2506 else
2507 Variables = g_malloc(NVariables*sizeof(VariablesDef));
2508 }
2509 /********************************************************************************/
AddVariableZmat(gchar * NameV,gchar * ValueV,gboolean rafresh)2510 void AddVariableZmat(gchar *NameV,gchar *ValueV, gboolean rafresh)
2511 {
2512 gchar *texts[2];
2513 NVariables++;
2514 AllocationVariable();
2515 Variables[NVariables-1].Name = g_strdup(NameV);
2516 Variables[NVariables-1].Value = g_strdup(ValueV);
2517 texts[0] = g_strdup(NameV);
2518 texts[1] = g_strdup(ValueV);
2519 if(rafresh) appendToList(listv, texts, 2);
2520 }
2521 /********************************************************************************/
reset_variable_value(gchar * NameV,gchar * ValueV,gboolean rafresh)2522 static gboolean reset_variable_value(gchar *NameV,gchar *ValueV, gboolean rafresh)
2523 {
2524 gint i=testav(NameV);
2525 if(i>=0)
2526 {
2527 if(Variables[i].Value) g_free(Variables[i].Value);
2528 Variables[i].Value = g_strdup(ValueV);
2529 if(rafresh)
2530 {
2531 gchar* texts[2] = { Variables[i].Name, Variables[i].Value};
2532 removeFromList(listv, i);
2533 insertToList(listv, i, texts, 2);
2534 }
2535 return TRUE;
2536 }
2537 return FALSE;
2538 }
2539 /********************************************************************************/
trans_coord_Zmat(gchar T,guint i,gboolean rafresh)2540 static void trans_coord_Zmat(gchar T,guint i, gboolean rafresh)
2541 {
2542 gdouble V;
2543 gchar *NameV;
2544 gchar *ValueV;
2545
2546 V = atof(Geom[i].R);
2547 if( T == 'A' )
2548 V = atof(Geom[i].Angle);
2549 if( T == 'D' )
2550 V = atof(Geom[i].Dihedral);
2551 NameV = g_strdup_printf("%c%s%d",T,Geom[i].Symb,i+1);
2552 ValueV = g_strdup_printf("%f",V);
2553 if(!reset_variable_value(NameV,ValueV, rafresh))
2554 AddVariableZmat(NameV,ValueV, rafresh);
2555 if( T == 'R' )
2556 Geom[i].R=g_strdup(NameV);
2557 if( T == 'A' )
2558 Geom[i].Angle=g_strdup(NameV);
2559 if( T == 'D' )
2560 Geom[i].Dihedral=g_strdup(NameV);
2561 }
2562 /********************************************************************************/
set_variable_one_atom_in_GeomZMatrix(gint i)2563 void set_variable_one_atom_in_GeomZMatrix(gint i)
2564 {
2565
2566 if( i>0 && test(Geom[i].R)) trans_coord_Zmat('R',i,FALSE);
2567 if( i>1 && test(Geom[i].Angle) ) trans_coord_Zmat('A',i,FALSE);
2568 if(i>2 && test(Geom[i].Dihedral) ) trans_coord_Zmat('D',i,FALSE);
2569
2570 ChangeVariablesUseds();
2571 }
2572 /********************************************************************************/
trans_OneGeom_to_variables(guint i,gboolean rv,gboolean ra,gboolean rd)2573 void trans_OneGeom_to_variables(guint i, gboolean rv, gboolean ra, gboolean rd)
2574 {
2575 guint j;
2576 gchar *texts[NUMBER_LIST_ZMATRIX];
2577
2578 for(j=0;j<NUMBER_LIST_ZMATRIX;j++)
2579 texts[j] =g_strdup(" ");
2580
2581 if( i>0 && test(Geom[i].R) && rv)
2582 trans_coord_Zmat('R',i,TRUE);
2583 if( i>1 && test(Geom[i].Angle) && ra)
2584 trans_coord_Zmat('A',i,TRUE);
2585 if(i>2 && test(Geom[i].Dihedral) && rd )
2586 trans_coord_Zmat('D',i,TRUE);
2587
2588 texts[E_NUMBER] =g_strdup_printf("%d",i+1);
2589 texts[E_SYMBOL] = g_strdup(Geom[i].Symb);
2590 texts[E_MMTYPE] = g_strdup(Geom[i].mmType);
2591 texts[E_PDBTYPE] = g_strdup(Geom[i].pdbType);
2592 texts[E_RESIDUE] = g_strdup(Geom[i].Residue);
2593 if(i>0)
2594 {
2595 texts[E_R] = g_strdup(Geom[i].R);
2596 texts[E_NUMBER_R] = g_strdup(Geom[i].NR);
2597 }
2598 if(i>1)
2599 {
2600 texts[E_ANGLE] = g_strdup(Geom[i].Angle);
2601 texts[E_NUMBER_ANGLE] = g_strdup(Geom[i].NAngle);
2602 }
2603 if(i>2)
2604 {
2605 texts[E_DIHEDRAL] = g_strdup(Geom[i].Dihedral);
2606 texts[E_NUMBER_DIHEDRAL] = g_strdup(Geom[i].NDihedral);
2607 }
2608 texts[E_CHARGE] = g_strdup(Geom[i].Charge);
2609 texts[E_LAYER] = g_strdup(Geom[i].Layer);
2610 removeFromList(list, i);
2611 insertToList(list, i, texts, NUMBER_LIST_ZMATRIX);
2612
2613 ChangeVariablesUseds();
2614 }
2615 /********************************************************************************/
trans_allGeom_to_variables()2616 void trans_allGeom_to_variables()
2617 {
2618 guint i;
2619
2620 if(NcentersZmat <1 ) return;
2621
2622 for(i=0;i<NcentersZmat;i++)
2623 trans_OneGeom_to_variables(i,TRUE,TRUE,TRUE);
2624 if(GeomDrawingArea != NULL) rafresh_drawing();
2625
2626 }
2627 /********************************************************************************/
trans_allRGeom_to_variables()2628 static void trans_allRGeom_to_variables()
2629 {
2630 guint i;
2631 if(NcentersZmat <1 ) return;
2632 for(i=0;i<NcentersZmat;i++)
2633 trans_OneGeom_to_variables(i,TRUE,FALSE,FALSE);
2634 if(GeomDrawingArea != NULL) rafresh_drawing();
2635 }
2636 /********************************************************************************/
trans_allAngleGeom_to_variables()2637 static void trans_allAngleGeom_to_variables()
2638 {
2639 guint i;
2640 if(NcentersZmat <1 ) return;
2641 for(i=0;i<NcentersZmat;i++)
2642 trans_OneGeom_to_variables(i,FALSE,TRUE,FALSE);
2643 if(GeomDrawingArea != NULL) rafresh_drawing();
2644 }
2645 /********************************************************************************/
trans_allDihedralGeom_to_variables()2646 static void trans_allDihedralGeom_to_variables()
2647 {
2648 guint i;
2649 if(NcentersZmat <1 ) return;
2650 for(i=0;i<NcentersZmat;i++)
2651 trans_OneGeom_to_variables(i,FALSE,FALSE,TRUE);
2652 if(GeomDrawingArea != NULL) rafresh_drawing();
2653 }
2654 /********************************************************************************/
DialogueTransInVar()2655 static void DialogueTransInVar()
2656 {
2657 GtkWidget *Dialogue;
2658 GtkWidget *Label;
2659 GtkWidget *Bouton;
2660 GtkWidget *frame, *vboxframe;
2661
2662
2663 if (NcentersZmat <1)
2664 {
2665 MessageGeom(_(" Sorry No Center !"),_("Warning"),TRUE);
2666 return ;
2667 }
2668
2669 Dialogue = gtk_dialog_new();
2670 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Tansform all constants in Variables"));
2671 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
2672 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
2673 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
2674
2675 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Question "));
2676 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
2677
2678 gtk_widget_realize(Dialogue);
2679
2680 Label = create_label_with_pixmap(Dialogue,_("\nAre you sure to transform\n all constants in variables? \n"),_(" Question "));
2681 frame = gtk_frame_new (NULL);
2682 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2683
2684 g_object_ref (frame);
2685 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
2686 frame,(GDestroyNotify) g_object_unref);
2687 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
2688 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
2689
2690 gtk_widget_show (frame);
2691
2692 vboxframe = create_vbox(frame);
2693
2694 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
2695
2696 Bouton = create_button(Dialogue,"No");
2697 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2698 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2699 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2700 gtk_widget_grab_default(Bouton);
2701
2702 Bouton = create_button(Dialogue,"Yes");
2703 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2704 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)trans_allGeom_to_variables, NULL);
2705 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2706 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2707
2708
2709 gtk_widget_show_all(Dialogue);
2710 }
2711 /********************************************************************************/
TransConstVar(gboolean vr,gboolean va,gboolean vd)2712 static void TransConstVar(gboolean vr, gboolean va, gboolean vd)
2713 {
2714 gint Nc;
2715 Nc=LineSelected;
2716 if(Nc<0)
2717 {
2718 MessageGeom(_("Sorry No line selected"),_("Warning"),TRUE);
2719 return;
2720 }
2721 trans_OneGeom_to_variables((guint)Nc, vr,va,vd);
2722 if(GeomDrawingArea != NULL) rafresh_drawing();
2723 }
2724 /********************************************************************************/
show_geom_in_list(guint i)2725 static void show_geom_in_list(guint i)
2726 {
2727 gchar *texts[NUMBER_LIST_ZMATRIX];
2728 guint k;
2729 for(k=0;k<NUMBER_LIST_ZMATRIX;k++)
2730 texts[k] = g_strdup(" ");
2731
2732 texts[E_NUMBER] = g_strdup_printf("%d",i+1);
2733 texts[E_SYMBOL] = g_strdup(Geom[i].Symb);
2734 texts[E_MMTYPE] = g_strdup(Geom[i].mmType);
2735 texts[E_PDBTYPE] = g_strdup(Geom[i].pdbType);
2736 texts[E_RESIDUE] = g_strdup(Geom[i].Residue);
2737 if(i>0)
2738 {
2739 texts[E_R] = g_strdup(Geom[i].R);
2740 texts[E_NUMBER_R] = g_strdup(Geom[i].NR);
2741 }
2742 if(i>1)
2743 {
2744 texts[E_ANGLE] = g_strdup(Geom[i].Angle);
2745 texts[E_NUMBER_ANGLE] = g_strdup(Geom[i].NAngle);
2746 }
2747 if(i>2)
2748 {
2749 texts[E_DIHEDRAL] = g_strdup(Geom[i].Dihedral);
2750 texts[E_NUMBER_DIHEDRAL] = g_strdup(Geom[i].NDihedral);
2751 }
2752 texts[E_CHARGE] = g_strdup(Geom[i].Charge);
2753 texts[E_LAYER] = g_strdup(Geom[i].Layer);
2754 removeFromList(list, i);
2755 insertToList(list, i, texts, NUMBER_LIST_ZMATRIX);
2756 }
2757 /********************************************************************************/
ModifyCoord(gchar T,guint numC,guint numV)2758 guint ModifyCoord(gchar T,guint numC,guint numV )
2759 {
2760 if(T == 'R')
2761 {
2762 if(!strcmp(Geom[numC].R,Variables[numV].Name))
2763 Geom[numC].R =g_strdup(Variables[numV].Value);
2764 return 1;
2765 }
2766 if(T == 'A')
2767 {
2768 if(!strcmp(Geom[numC].Angle,Variables[numV].Name))
2769 Geom[numC].Angle =g_strdup(Variables[numV].Value);
2770 return 1;
2771 }
2772 if(T == 'D')
2773 {
2774 if(!strcmp(Geom[numC].Dihedral,Variables[numV].Name))
2775 Geom[numC].Dihedral =g_strdup(Variables[numV].Value);
2776 return 1;
2777 }
2778 return 0;
2779 }
2780 /********************************************************************************/
OneVariableToConst(guint num)2781 void OneVariableToConst(guint num)
2782 {
2783 guint i;
2784 guint k;
2785 if(!Variables[num].Used) return;
2786
2787 for(i=0;i<NcentersZmat;i++)
2788 {
2789 k = 0;
2790 if(i>0)
2791 k += ModifyCoord('R',i,num);
2792 if(i>1)
2793 k += ModifyCoord('A',i,num);
2794 if(i>2)
2795 k += ModifyCoord('D',i,num);
2796
2797 if(k>0) show_geom_in_list(i);
2798 }
2799 for(i=num;i<NVariables-1;i++)
2800 {
2801 Variables[i].Name = g_strdup(Variables[i+1].Name);
2802 Variables[i].Value = g_strdup(Variables[i+1].Value);
2803 Variables[i].Used = Variables[i+1].Used;
2804 }
2805 NVariables--;
2806 if(NVariables>0)
2807 AllocationVariable();
2808 else
2809 freeVariables();
2810
2811 removeFromList(listv, num);
2812 }
2813 /********************************************************************************/
TransVarConst()2814 static void TransVarConst()
2815 {
2816 gint Nc;
2817 Nc=LineSelectedV;
2818 if(Nc<0)
2819 {
2820 MessageGeom(_("Sorry No Variable selected"),_("Warning"),TRUE);
2821 return;
2822 }
2823 OneVariableToConst((guint)Nc);
2824 if(GeomDrawingArea != NULL) rafresh_drawing();
2825 }
2826 /********************************************************************************/
trans_allVariables_to_Constants()2827 static void trans_allVariables_to_Constants()
2828 {
2829 guint numV;
2830 guint numC;
2831 guint k;
2832 guint i;
2833 guint NRem=0;
2834 gboolean *Rem;
2835 VariablesDef *VZmat;
2836 Rem = g_malloc(NVariables*sizeof(gboolean));
2837 VZmat = g_malloc(NVariables*sizeof(VariablesDef));
2838
2839 for(numV=0;numV<NVariables;numV++)
2840 {
2841 Rem[numV] = FALSE;
2842 if(Variables[numV].Used)
2843 {
2844 for(numC=0;numC<NcentersZmat;numC++)
2845 {
2846 k = 0;
2847 if(numC>0)
2848 k += ModifyCoord('R',numC,numV);
2849 if(numC>1)
2850 k += ModifyCoord('A',numC,numV);
2851 if(numC>2)
2852 k += ModifyCoord('D',numC,numV);
2853 }
2854 NRem++;
2855 Rem[numV] = TRUE;
2856 Variables[numV].Used = FALSE;
2857 }
2858 }
2859 for(i=0;i<NVariables;i++)
2860 {
2861 VZmat[i].Name = g_strdup(Variables[i].Name);
2862 VZmat[i].Value = g_strdup(Variables[i].Value);
2863 VZmat[i].Used = Variables[i].Used;
2864 }
2865 k=NVariables;
2866 freeVariables();
2867 NVariables = k - NRem;
2868 Variables = g_malloc(NVariables*sizeof(VariablesDef));
2869 numV =-1;
2870 for(i=0;i<k;i++)
2871 {
2872 if(!Rem[i])
2873 {
2874 numV++;
2875 Variables[numV].Name = g_strdup(VZmat[i].Name);
2876 Variables[numV].Value = g_strdup(VZmat[i].Value);
2877 Variables[numV].Used = VZmat[i].Used;
2878 }
2879 }
2880
2881 clearList(listv);
2882 append_list_variables();
2883
2884 clearList(list);
2885 append_list_geom();
2886
2887 for(i=0;i<NVariables;i++)
2888 {
2889 g_free(VZmat[i].Name);
2890 g_free(VZmat[i].Value);
2891 }
2892 g_free(VZmat);
2893 g_free(Rem);
2894 if(GeomDrawingArea != NULL) rafresh_drawing();
2895 }
2896 /********************************************************************************/
DialogueTransInConst()2897 static void DialogueTransInConst()
2898 {
2899 GtkWidget *Dialogue;
2900 GtkWidget *Label;
2901 GtkWidget *Bouton;
2902 GtkWidget *frame, *vboxframe;
2903
2904
2905 if (NcentersZmat <1)
2906 {
2907 MessageGeom(_(" Sorry No Center !"),_("Warning"),TRUE);
2908 return ;
2909 }
2910
2911 Dialogue = gtk_dialog_new();
2912 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Tansform all variables to constants"));
2913 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
2914 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
2915 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
2916
2917 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Question "));
2918 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
2919
2920 gtk_widget_realize(Dialogue);
2921
2922 Label = create_label_with_pixmap(Dialogue,_("\n Are you sure to transform\n all variables to constants? \n"),_(" Question "));
2923 frame = gtk_frame_new (NULL);
2924 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2925
2926 g_object_ref (frame);
2927 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
2928 frame,(GDestroyNotify) g_object_unref);
2929 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
2930 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
2931
2932 gtk_widget_show (frame);
2933
2934 vboxframe = create_vbox(frame);
2935
2936 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
2937
2938 Bouton = create_button(Dialogue,"No");
2939 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2940 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2941 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2942 gtk_widget_grab_default(Bouton);
2943
2944 Bouton = create_button(Dialogue,"Yes");
2945 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2946 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)trans_allVariables_to_Constants,NULL);
2947 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2948 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2949
2950
2951 gtk_widget_show_all(Dialogue);
2952 }
2953 /********************************************************************************/
set_entry_Zmat()2954 static void set_entry_Zmat()
2955 {
2956 SAtomsProp Atom[3];
2957 gdouble r;
2958 gdouble Coord[3];
2959 gdouble angle;
2960 gdouble dihed;
2961 gchar *strdump;
2962 G_CONST_RETURN gchar *Atomdump;
2963
2964 angle = (gdouble)rand()/RAND_MAX*60;
2965 dihed = (gdouble)rand()/RAND_MAX*60;
2966 angle = 109.0;
2967 dihed = 180.0;
2968
2969 if(NcentersZmat==0)
2970 return;
2971 if(InEdit && LineSelected<1)
2972 return;
2973
2974 Atomdump =gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL]));
2975 Atom[0] = prop_atom_get(Atomdump);
2976 Atom[1] = prop_atom_get(Geom[NcentersZmat-1].Symb);
2977 r = Atom[0].covalentRadii+Atom[1].covalentRadii;
2978 r *=0.8;
2979 if(Units==1)
2980 r*=BOHR_TO_ANG;
2981 Coord[0] = r ;
2982 Coord[1] = angle;
2983 Coord[2] = dihed;
2984 strdump = g_strdup_printf("%f", Coord[0]);
2985 gtk_entry_set_text(GTK_ENTRY(Entry[E_R]),strdump);
2986 if(NcentersZmat<2 || (InEdit && LineSelected<2))
2987 {
2988 g_free(strdump);
2989 return;
2990 }
2991 strdump = g_strdup_printf("%f", Coord[1]);
2992 gtk_entry_set_text(GTK_ENTRY(Entry[E_ANGLE]),strdump);
2993 if(NcentersZmat<3 || (InEdit && LineSelected<3))
2994 {
2995 g_free(strdump);
2996 return;
2997 }
2998 strdump = g_strdup_printf("%f", Coord[2]);
2999 gtk_entry_set_text(GTK_ENTRY(Entry[E_DIHEDRAL]),strdump);
3000 g_free(strdump);
3001
3002 }
3003 /********************************************************************************/
SetAtom(GtkWidget * w,gpointer data)3004 static void SetAtom(GtkWidget *w,gpointer data)
3005 {
3006 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),(char *)data);
3007 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),(char *)data);
3008 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),(char *)data);
3009 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),(char *)data);
3010 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
3011 gtk_widget_destroy(FenetreTable);
3012 set_entry_Zmat();
3013 }
3014 /********************************************************************************/
SelectAtom(GtkWidget * w,gpointer entry0)3015 static void SelectAtom(GtkWidget *w,gpointer entry0)
3016 {
3017 GtkWidget* Table;
3018 GtkWidget* button;
3019 GtkWidget* frame;
3020 guint i;
3021 guint j;
3022 GtkStyle *button_style;
3023 GtkStyle *style;
3024
3025 gchar*** Symb = get_periodic_table();
3026
3027 FenetreTable = gtk_window_new(GTK_WINDOW_TOPLEVEL);
3028 gtk_window_set_modal(GTK_WINDOW(FenetreTable),TRUE);
3029 gtk_window_set_title(GTK_WINDOW(FenetreTable),"Select your atom");
3030 gtk_window_set_default_size (GTK_WINDOW(FenetreTable),(gint)(ScreenWidth*0.5),(gint)(ScreenHeight*0.4));
3031
3032 frame = gtk_frame_new (NULL);
3033 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3034 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3035 gtk_container_add(GTK_CONTAINER(FenetreTable),frame);
3036 gtk_widget_show (frame);
3037
3038 Table = gtk_table_new(PERIODIC_TABLE_N_ROWS-1,PERIODIC_TABLE_N_COLUMNS,TRUE);
3039 gtk_container_add(GTK_CONTAINER(frame),Table);
3040 button_style = gtk_widget_get_style(FenetreTable);
3041
3042 for ( i = 0;i<PERIODIC_TABLE_N_ROWS-1;i++)
3043 for ( j = 0;j<PERIODIC_TABLE_N_COLUMNS;j++)
3044 {
3045 if(strcmp(Symb[j][i],"00"))
3046 {
3047 button = gtk_button_new_with_label(Symb[j][i]);
3048 style=set_button_style(button_style,button,Symb[j][i]);
3049 g_signal_connect(G_OBJECT(button), "clicked",
3050 (GCallback)SetAtom,(gpointer )Symb[j][i]);
3051 gtk_table_attach(GTK_TABLE(Table),button,j,j+1,i,i+1,
3052 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND) ,
3053 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
3054 1,1);
3055 }
3056
3057 }
3058
3059 gtk_widget_show_all(FenetreTable);
3060
3061 }
3062 /********************************************************************************/
DelAtom(GtkWidget * w,gpointer data)3063 static void DelAtom(GtkWidget *w,gpointer data)
3064 {
3065
3066 NcentersZmat--;
3067 if((gint)NcentersZmat>-1)
3068 {
3069 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
3070 removeFromList(list, NcentersZmat);
3071 if(GeomDrawingArea != NULL)
3072 rafresh_drawing();
3073 if(iprogram == PROG_IS_GAUSS)
3074 set_spin_of_electrons();
3075 }
3076 else
3077 freeGeom();
3078
3079 ChangeVariablesUseds();
3080 }
3081 /********************************************************************************/
addAtom(GtkWidget * w,gpointer Entree)3082 static void addAtom(GtkWidget *w,gpointer Entree)
3083 {
3084 gchar *texts[NUMBER_LIST_ZMATRIX];
3085 gchar *message;
3086 gint i;
3087 gboolean false;
3088
3089 false = FALSE;
3090 DestroyDialog=TRUE;
3091
3092 for (i=0;i<NUMBER_LIST_ZMATRIX;i++)
3093 texts[i]=g_strdup(" ");
3094
3095 texts[E_SYMBOL] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL])));
3096 texts[E_MMTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_MMTYPE])));
3097 texts[E_PDBTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_PDBTYPE])));
3098 texts[E_RESIDUE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_RESIDUE])));
3099 if (texts[E_SYMBOL] && strcmp(texts[E_SYMBOL], ""))
3100 { /* on cree l'atome */
3101 NcentersZmat++;
3102 if(Geom==NULL)
3103 Geom=g_malloc(sizeof(GeomAtomDef));
3104 else
3105 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
3106
3107 texts[E_NUMBER] =g_strdup_printf("%d",NcentersZmat);
3108 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_0;
3109 Geom[NcentersZmat-1].Symb=g_strdup(texts[E_SYMBOL]);
3110 Geom[NcentersZmat-1].mmType=g_strdup(texts[E_MMTYPE]);
3111 Geom[NcentersZmat-1].pdbType=g_strdup(texts[E_PDBTYPE]);
3112 Geom[NcentersZmat-1].Residue=g_strdup(texts[E_RESIDUE]);
3113
3114 if(NcentersZmat==1)
3115 Geom[NcentersZmat-1].ResidueNumber = 0;
3116 else
3117 {
3118 gint k;
3119 Geom[NcentersZmat-1].ResidueNumber = 0;
3120 for(k=0;k<(gint)NcentersZmat-1;k++)
3121 {
3122 if(Geom[NcentersZmat-1].ResidueNumber<Geom[k].ResidueNumber)
3123 Geom[NcentersZmat-1].ResidueNumber = Geom[k].ResidueNumber;
3124 }
3125 Geom[NcentersZmat-1].ResidueNumber += 1;
3126 }
3127
3128 if(NcentersZmat>1)
3129 {
3130 for (i=E_R;i<=E_NUMBER_R;i++)
3131 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3132
3133 if (!texts[E_R] || !strcmp(texts[E_R], ""))
3134 {
3135 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3136 DestroyDialog=FALSE;
3137 false = TRUE;
3138 }
3139 i=testav(texts[E_R]);
3140 if(i>-1)Variables[i].Used=TRUE;
3141 if(i<-1)
3142 {
3143 message=g_strdup_printf(
3144 _( "Sorry\n %s \nis not a number \nand is not a variable ")
3145 ,texts[E_R]
3146 );
3147 MessageGeom(message,_("Warning"),TRUE);
3148 g_free(message);
3149 DestroyDialog=FALSE;
3150 false = TRUE;
3151 }
3152
3153 Geom[NcentersZmat-1].Nentry = NUMBER_ENTRY_R;
3154 if(test(texts[E_R]) && !testpointeE(texts[E_R]) )
3155 texts[E_R]=g_strdup_printf("%s.0",texts[E_R]);
3156
3157 Geom[NcentersZmat-1].R=g_strdup(texts[E_R]);
3158 Geom[NcentersZmat-1].NR=g_strdup(texts[E_NUMBER_R]);
3159 }
3160 if ( (NcentersZmat>2) && (!false) )
3161 {
3162 for (i=E_ANGLE;i<=E_NUMBER_ANGLE;i++)
3163 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3164
3165 if (!texts[E_ANGLE] || !strcmp(texts[E_ANGLE], ""))
3166 {
3167 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3168 DestroyDialog=FALSE;
3169 false = TRUE;
3170 }
3171 i=testav(texts[E_ANGLE]);
3172 if(i>-1)Variables[i].Used=TRUE;
3173 if(i<-1)
3174 {
3175 message=g_strdup_printf(
3176 _("Sorry\n %s \nis not a number \nand is not a variable ")
3177 ,texts[E_ANGLE]
3178 );
3179 MessageGeom(message,_("Warning"),TRUE);
3180 g_free(message);
3181 DestroyDialog=FALSE;
3182 false = TRUE;
3183 }
3184
3185 Geom[NcentersZmat-1].Nentry = NUMBER_ENTRY_ANGLE;
3186 if(test(texts[E_ANGLE]) && !testpointeE(texts[E_ANGLE]) )
3187 texts[E_ANGLE]=g_strdup_printf("%s.0",texts[E_ANGLE]);
3188
3189 Geom[NcentersZmat-1].Angle=g_strdup(texts[E_ANGLE]);
3190 Geom[NcentersZmat-1].NAngle=g_strdup(texts[E_NUMBER_ANGLE]);
3191 }
3192 if( (NcentersZmat>3) && (!false) )
3193 {
3194 for (i=E_DIHEDRAL;i<=E_NUMBER_DIHEDRAL;i++)
3195 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3196
3197 if (!texts[E_DIHEDRAL] || !strcmp(texts[E_DIHEDRAL], ""))
3198 {
3199 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3200 DestroyDialog=FALSE;
3201 false = TRUE;
3202 }
3203
3204 i=testav(texts[E_DIHEDRAL]);
3205 if(i>-1)Variables[i].Used=TRUE;
3206 if(i<-1)
3207 {
3208 message=g_strdup_printf(
3209 _("Sorry\n %s \nis not a number \nand is not a variable ")
3210 ,texts[E_DIHEDRAL]
3211 );
3212 MessageGeom(message,_("Warning"),TRUE);
3213 g_free(message);
3214 DestroyDialog=FALSE;
3215 false = TRUE;
3216 }
3217
3218 Geom[NcentersZmat-1].Nentry = NUMBER_ENTRY_DIHEDRAL;
3219 if(test(texts[E_DIHEDRAL]) && !testpointeE(texts[E_DIHEDRAL]) )
3220 texts[E_DIHEDRAL]=g_strdup_printf("%s.0",texts[E_DIHEDRAL]);
3221 Geom[NcentersZmat-1].Dihedral=g_strdup(texts[E_DIHEDRAL]);
3222 Geom[NcentersZmat-1].NDihedral=g_strdup(texts[E_NUMBER_DIHEDRAL]);
3223 }
3224
3225 texts[E_CHARGE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_CHARGE])));
3226 Geom[NcentersZmat-1].Charge=g_strdup(texts[E_CHARGE]);
3227
3228 if(iprogram != PROG_IS_MOLPRO)
3229 texts[E_LAYER] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_LAYER])));
3230 else
3231 texts[E_LAYER] = g_strdup(" ");
3232
3233 Geom[NcentersZmat-1].Layer=g_strdup(texts[E_LAYER]);
3234 if(!false)
3235 {
3236 appendToList(list, texts, NUMBER_LIST_ZMATRIX);
3237 if(GeomDrawingArea != NULL)
3238 rafresh_drawing();
3239 if(iprogram == PROG_IS_GAUSS)
3240 set_spin_of_electrons();
3241 }
3242 else
3243 {
3244 NcentersZmat--;
3245 if(NcentersZmat>0)
3246 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
3247 else
3248 Geom=NULL;
3249 }
3250
3251 }
3252
3253 }
3254 /********************************************************************************/
EditAtom(GtkWidget * w,gpointer Entree)3255 static void EditAtom(GtkWidget *w,gpointer Entree)
3256 {
3257 gchar *texts[NUMBER_LIST_ZMATRIX];
3258 gchar *message;
3259 gint i;
3260 gint Nc;
3261 gint j;
3262 gint k;
3263 gboolean False;
3264 GeomAtomDef Gtmp;
3265
3266 False = FALSE;
3267 DestroyDialog=TRUE;
3268 j=-1;
3269 Nc=-1;
3270 for (i=0;i<NUMBER_LIST_ZMATRIX;i++)
3271 texts[i]=g_strdup(" ");
3272
3273 texts[E_SYMBOL] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL])));
3274 texts[E_MMTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_MMTYPE])));
3275 texts[E_PDBTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_PDBTYPE])));
3276 texts[E_RESIDUE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_RESIDUE])));
3277
3278 Nc=LineSelected;
3279 if(Nc<0) Nc=LineSelectedOld;
3280 Gtmp=Geom[Nc];
3281 if (texts[E_SYMBOL] && strcmp(texts[E_SYMBOL], ""))
3282 {
3283 Nc=LineSelected;
3284 if(Nc<0)
3285 Nc=LineSelectedOld;
3286
3287 texts[E_NUMBER] =g_strdup_printf("%d",Nc+1);
3288 if(Nc>=0)
3289 {
3290 gboolean oldResidue = FALSE;
3291
3292 Gtmp=Geom[Nc];
3293
3294 if(!strcmp(Gtmp.Residue,texts[E_RESIDUE]))
3295 oldResidue = TRUE;
3296
3297 Gtmp.Symb=g_strdup(texts[E_SYMBOL]);
3298 Gtmp.mmType=g_strdup(texts[E_MMTYPE]);
3299 Gtmp.pdbType=g_strdup(texts[E_PDBTYPE]);
3300 Gtmp.Residue=g_strdup(texts[E_RESIDUE]);
3301 if(!oldResidue)
3302 {
3303 gint k;
3304 Gtmp.ResidueNumber = -1;
3305 for(k=0;k<(gint)NcentersZmat;k++)
3306 {
3307 if(Nc != k && !strcmp(Gtmp.Residue,Geom[k].Residue))
3308 {
3309 Gtmp.ResidueNumber = Geom[k].ResidueNumber;
3310 break;
3311 }
3312 }
3313 if(Gtmp.ResidueNumber == -1)
3314 {
3315 for(k=0;k<(gint)NcentersZmat;k++)
3316 {
3317 if(Gtmp.ResidueNumber<Geom[k].ResidueNumber)
3318 Gtmp.ResidueNumber = Geom[k].ResidueNumber;
3319 }
3320 Gtmp.ResidueNumber += 1;
3321 }
3322 }
3323 }
3324 if(Nc>0)
3325 {
3326 for (i=E_R;i<=E_NUMBER_R;i++)
3327 {
3328 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3329 k=testav(texts[i]);
3330 if(k<-1)
3331 {
3332 j=i;
3333 False=TRUE;
3334 break;
3335 }
3336 }
3337 if (!texts[E_R] || !strcmp(texts[E_R], ""))
3338 {
3339 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3340 DestroyDialog=FALSE;
3341 return;
3342 }
3343
3344 if(False)
3345 {
3346 message=g_strdup_printf(
3347 _("Sorry\n %s \nis not a number \nand is not a variable "),texts[j]
3348 );
3349 MessageGeom(message,_("Warning"),TRUE);
3350 g_free(message);
3351 DestroyDialog=FALSE;
3352 return;
3353 }
3354 if(test(texts[E_R]) && !testpointeE(texts[E_R]) )
3355 texts[E_R]=g_strdup_printf("%s.0",texts[E_R]);
3356 Gtmp.R=g_strdup(texts[E_R]);
3357 Gtmp.NR=g_strdup(texts[E_NUMBER_R]);
3358 }
3359 if(Nc>1)
3360 {
3361 for (i=E_ANGLE;i<=E_NUMBER_ANGLE;i++)
3362 {
3363 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3364 k=testav(texts[i]);
3365 if(k<-1)
3366 {
3367 j=i;
3368 False=TRUE;
3369 break;
3370 }
3371 }
3372 if (!texts[E_ANGLE] || !strcmp(texts[E_ANGLE], ""))
3373 {
3374 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3375 DestroyDialog=FALSE;
3376 return;
3377 }
3378 if(False)
3379 {
3380 message=g_strdup_printf(
3381 _("Sorry\n %s \nis not a number \nand is not a variable ")
3382 ,texts[j]
3383 );
3384 MessageGeom(message,_("Warning"),TRUE);
3385 g_free(message);
3386 DestroyDialog=FALSE;
3387 return;
3388 }
3389 if(test(texts[E_ANGLE]) && !testpointeE(texts[E_ANGLE]) )
3390 texts[E_ANGLE]=g_strdup_printf("%s.0",texts[E_ANGLE]);
3391 Gtmp.Angle=g_strdup(texts[E_ANGLE]);
3392 Gtmp.NAngle=g_strdup(texts[E_NUMBER_ANGLE]);
3393 }
3394 if(Nc>2)
3395 {
3396 for (i=E_DIHEDRAL;i<=E_NUMBER_DIHEDRAL;i++)
3397 {
3398 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3399 k=testav(texts[i]);
3400 if(k<-1)
3401 {
3402 j=i;
3403 False=TRUE;
3404 break;
3405 }
3406 }
3407 if (!texts[E_DIHEDRAL] || !strcmp(texts[E_DIHEDRAL], ""))
3408 {
3409 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
3410 DestroyDialog=FALSE;
3411 return;
3412 }
3413 if(False)
3414 {
3415 message=g_strdup_printf(
3416 _("Sorry\n %s \nis not a number \nand is not a variable ")
3417 ,texts[j]
3418 );
3419 MessageGeom(message,_("Warning"),TRUE);
3420 g_free(message);
3421 DestroyDialog=FALSE;
3422 return;
3423 }
3424 if(test(texts[E_DIHEDRAL]) && !testpointeE(texts[E_DIHEDRAL]) )
3425 texts[E_DIHEDRAL]=g_strdup_printf("%s.0",texts[E_DIHEDRAL]);
3426 Gtmp.Dihedral=g_strdup(texts[E_DIHEDRAL]);
3427 Gtmp.NDihedral=g_strdup(texts[E_NUMBER_DIHEDRAL]);
3428 }
3429
3430 texts[E_CHARGE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_CHARGE])));
3431 Gtmp.Charge=g_strdup(texts[E_CHARGE]);
3432
3433 if(iprogram != PROG_IS_MOLPRO)
3434 texts[E_LAYER] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_LAYER])));
3435 else
3436 texts[E_LAYER] = g_strdup(" ");
3437
3438 Gtmp.Layer=g_strdup(texts[E_LAYER]);
3439
3440 Geom[Nc]=Gtmp;
3441
3442 removeFromList(list, Nc);
3443 insertToList(list, Nc, texts, NUMBER_LIST_ZMATRIX);
3444 if(GeomDrawingArea != NULL)
3445 rafresh_drawing();
3446 if(iprogram == PROG_IS_GAUSS)
3447 set_spin_of_electrons();
3448
3449 }
3450 else
3451 MessageGeom(_("Sorry No line selected"),_("Warning"),TRUE);
3452
3453 ChangeVariablesUseds();
3454
3455 }
3456 /********************************************************************************/
get_list_variables()3457 static gchar **get_list_variables()
3458 {
3459 guint i;
3460 gchar **tlist;
3461
3462 tlist=g_malloc((NVariables+1)*sizeof(gchar*));
3463
3464 for (i=0;i<NVariables;i++)
3465 tlist[i+1] = g_strdup(Variables[i].Name);
3466 tlist[0] = g_strdup("");
3467
3468 return tlist;
3469 }
3470 /********************************************************************************/
freelistvariables(gchar ** tlist)3471 static void freelistvariables(gchar **tlist)
3472 {
3473 guint i;
3474
3475 for (i=0;i<NVariables+1;i++)
3476 g_free(tlist[i]);
3477
3478 g_free(tlist);
3479 }
3480 /********************************************************************************/
DialogueAdd()3481 static void DialogueAdd()
3482 {
3483 GtkWidget *Dialogue;
3484 GtkWidget *Bouton;
3485 GtkWidget *hbox;
3486 GtkWidget *frame,*vboxframe;
3487 guint nlist;
3488 gchar *tlabel[]={
3489 " ",
3490 N_("Atom Symbol : "),
3491 N_("MM Type : "),
3492 N_("PDB Type : "),
3493 N_("Residue : "),
3494 N_("R : "),
3495 N_("Center : "),
3496 N_("Angle : "),
3497 N_("Center : "),
3498 N_("Dihedral : "),
3499 N_("Center : "),
3500 N_("Charge : "),
3501 N_("Layer : ")};
3502 gchar **tlist;
3503 gchar **tlistvar;
3504 guint i;
3505 InEdit = FALSE;
3506 tlist=g_malloc(NcentersZmat*sizeof(gchar*));
3507 for (i=0;i<NcentersZmat;i++)
3508 tlist[i]=g_strdup_printf("%d",i+1);
3509
3510 Dialogue = gtk_dialog_new();
3511 gtk_window_set_title(GTK_WINDOW(Dialogue),"New Center");
3512 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3513 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3514
3515 add_child(WindowGeom,Dialogue,gtk_widget_destroy," New Center ");
3516 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3517
3518 frame = gtk_frame_new (NULL);
3519 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3520 g_object_ref (frame);
3521 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3522 frame,(GDestroyNotify) g_object_unref);
3523 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3524 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3525 gtk_widget_show (frame);
3526 vboxframe = create_vbox(frame);
3527
3528
3529 hbox=create_hbox_false(vboxframe);
3530 Entry[E_SYMBOL] = create_label_entry(hbox,tlabel[E_SYMBOL], (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3531 if(NcentersZmat==0)
3532 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),"H");
3533 else
3534 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),Geom[NcentersZmat-1].Symb);
3535 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
3536
3537 Bouton = gtk_button_new_with_label(" Set ");
3538 gtk_box_pack_start (GTK_BOX(hbox), Bouton, TRUE, TRUE, 5);
3539 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)SelectAtom,
3540 Entry[E_SYMBOL]);
3541 hbox=create_hbox_false(vboxframe);
3542 {
3543 gint n=0;
3544 gchar** t = getListMMTypes(&n);
3545 if(n!=0)
3546 {
3547 Entry[E_MMTYPE] = create_label_combo(hbox,tlabel[E_MMTYPE],t,n,
3548 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3549 }
3550 else
3551 {
3552 Entry[E_MMTYPE] = create_label_entry(hbox,tlabel[E_MMTYPE],
3553 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3554 }
3555
3556 if(t) freeList(t,n);
3557 if(NcentersZmat==0)
3558 {
3559 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),"H");
3560 }
3561 else
3562 {
3563 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),Geom[NcentersZmat-1].mmType);
3564 }
3565 }
3566 hbox=create_hbox_false(vboxframe);
3567 {
3568 gint n=0;
3569 gchar** t = getListPDBTypes("UNK",&n);
3570 if(n!=0)
3571 {
3572 Entry[E_PDBTYPE] = create_label_combo(hbox,tlabel[E_PDBTYPE],t,n,
3573 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3574 }
3575 else
3576 {
3577 Entry[E_PDBTYPE] = create_label_entry(hbox,tlabel[E_PDBTYPE],
3578 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3579 }
3580 if(NcentersZmat==0)
3581 {
3582 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),"H");
3583 }
3584 else
3585 {
3586 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),Geom[NcentersZmat-1].pdbType);
3587 }
3588
3589 if(t) freeList(t,n);
3590 }
3591 hbox=create_hbox_false(vboxframe);
3592 Entry[E_RESIDUE] = create_label_entry(hbox,tlabel[E_RESIDUE],
3593 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3594
3595 if(NcentersZmat==0)
3596 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),"");
3597 else
3598 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),Geom[NcentersZmat-1].Residue);
3599
3600
3601
3602
3603 tlistvar = get_list_variables();
3604 if(NcentersZmat>0)
3605 {
3606 hbox=create_hbox_false(vboxframe);
3607 Entry[E_R] = create_label_combo(hbox,tlabel[E_R],tlistvar,NVariables+1,TRUE,
3608 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3609 Entry[E_NUMBER_R] = create_label_combo(hbox,tlabel[E_NUMBER_R],tlist,NcentersZmat,FALSE,
3610 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3611 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_R]),tlist[NcentersZmat-1]);
3612 }
3613 if(NcentersZmat>1)
3614 {
3615 hbox=create_hbox_false(vboxframe);
3616 Entry[E_ANGLE] = create_label_combo(hbox,tlabel[E_ANGLE],tlistvar,NVariables+1,TRUE,
3617 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3618 Entry[E_NUMBER_ANGLE] = create_label_combo(hbox,tlabel[E_NUMBER_ANGLE],tlist,NcentersZmat,FALSE,
3619 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3620 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_R]),tlist[NcentersZmat-1]);
3621 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_ANGLE]),tlist[NcentersZmat-2]);
3622 }
3623 if(NcentersZmat>2)
3624 {
3625 hbox=create_hbox_false(vboxframe);
3626 Entry[E_DIHEDRAL] = create_label_combo(hbox,tlabel[E_DIHEDRAL],tlistvar,NVariables+1,TRUE,
3627 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3628 Entry[E_NUMBER_DIHEDRAL] = create_label_combo(hbox,tlabel[E_NUMBER_DIHEDRAL],tlist,NcentersZmat,FALSE,
3629 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3630 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_R]),tlist[NcentersZmat-1]);
3631 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_ANGLE]),tlist[NcentersZmat-2]);
3632 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_DIHEDRAL]),tlist[NcentersZmat-3]);
3633 }
3634 g_free(tlist);
3635 freelistvariables(tlistvar);
3636
3637 hbox=create_hbox_false(vboxframe);
3638 Entry[E_CHARGE] = create_label_entry(hbox,tlabel[E_CHARGE],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3639 gtk_entry_set_text(GTK_ENTRY(Entry[E_CHARGE]),"0.0");
3640
3641 tlist=g_malloc(4*sizeof(gchar*));
3642 nlist=4;
3643 /* if(NcentersZmat<3) nlist=1;*/
3644 tlist[0]=g_strdup(" ");
3645 tlist[1]=g_strdup("High");
3646 tlist[2]=g_strdup("Medium");
3647 tlist[3]=g_strdup("Low");
3648
3649 hbox=create_hbox_false(vboxframe);
3650 if(iprogram != PROG_IS_MOLPRO)
3651 Entry[E_LAYER] = create_label_combo(hbox,tlabel[E_LAYER],tlist,nlist,FALSE,
3652 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3653
3654 gtk_widget_realize(Dialogue);
3655
3656 Bouton = create_button(Dialogue,_("Cancel"));
3657 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3658 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3659 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3660
3661 Bouton = create_button(Dialogue,_("OK"));
3662 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3663 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)addAtom, Entry[E_SYMBOL]);
3664 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)destroy_dialogue, GTK_OBJECT(Dialogue));
3665 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3666 gtk_widget_grab_default(Bouton);
3667
3668
3669 gtk_widget_show_all(Dialogue);
3670 g_free(tlist);
3671 set_entry_Zmat();
3672 }
3673 /********************************************************************************/
DialogueEdit()3674 static void DialogueEdit()
3675 {
3676 GtkWidget *Dialogue;
3677 GtkWidget *Bouton;
3678 GtkWidget *hbox;
3679 GtkWidget *frame;
3680 GtkWidget *vboxframe;
3681
3682 gint nlist;
3683 gchar *tlabel[]={
3684 " ",
3685 N_("Atom Symbol : "),
3686 N_("MM Type : "),
3687 N_("PDB Type : "),
3688 N_("Residue : "),
3689 N_("R : "),
3690 N_("Center : "),
3691 N_("Angle : "),
3692 N_("Center : "),
3693 N_("Dihedral : "),
3694 N_("Center : "),
3695 N_("Charge : "),
3696 N_("Layer : ")
3697 };
3698 gchar **tlist=NULL;
3699 gchar **tlistvar;
3700 gint i;
3701 gint Nc;
3702
3703 InEdit = TRUE;
3704
3705 Nc=LineSelected;
3706 if(Nc<0 )
3707 {
3708 if(NcentersZmat<1 )
3709 MessageGeom(_("Create center before \n"),_("Warning"),TRUE);
3710 else
3711 MessageGeom(_("Please Select your center \n"),_("Warning"),TRUE);
3712 return;
3713 }
3714
3715 if(Nc>0)
3716 {
3717 tlist=g_malloc(Nc*sizeof(gchar*));
3718 for (i=0;i<Nc;i++)
3719 tlist[i]=g_strdup_printf("%d",i+1);
3720 }
3721
3722 Dialogue = gtk_dialog_new();
3723 gtk_window_set_title(GTK_WINDOW(Dialogue),_(" Edit center"));
3724 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3725 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3726
3727 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Edit Center "));
3728 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3729
3730 frame = gtk_frame_new (NULL);
3731 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3732 g_object_ref (frame);
3733 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3734 frame,(GDestroyNotify) g_object_unref);
3735 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3736 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3737 gtk_widget_show (frame);
3738 vboxframe = create_vbox(frame);
3739
3740
3741 hbox=create_hbox_false(vboxframe);
3742 Entry[E_SYMBOL] = create_label_entry(hbox,tlabel[E_SYMBOL],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3743 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),Geom[Nc].Symb);
3744 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
3745
3746 Bouton = gtk_button_new_with_label(" Set ");
3747 gtk_box_pack_start (GTK_BOX(hbox), Bouton, TRUE, TRUE, 5);
3748 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)SelectAtom,
3749 Entry[E_SYMBOL]);
3750
3751 hbox=create_hbox_false(vboxframe);
3752 {
3753 gint n=0;
3754 gchar** t = getListMMTypes(&n);
3755 if(n!=0)
3756 {
3757 Entry[E_MMTYPE] = create_label_combo(hbox,tlabel[E_MMTYPE],t,n,
3758 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3759 }
3760 else
3761 {
3762 Entry[E_MMTYPE] = create_label_entry(hbox,tlabel[E_MMTYPE],
3763 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3764 }
3765
3766 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),Geom[Nc].mmType);
3767 if(t) freeList(t,n);
3768 }
3769 hbox=create_hbox_false(vboxframe);
3770 {
3771 gint n=0;
3772 gchar** t = getListPDBTypes(Geom[Nc].Residue, &n);
3773 if(n!=0)
3774 {
3775 Entry[E_PDBTYPE] = create_label_combo(hbox,tlabel[E_PDBTYPE],t,n,
3776 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3777 }
3778 else
3779 {
3780 Entry[E_PDBTYPE] = create_label_entry(hbox,tlabel[E_PDBTYPE],
3781 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3782 }
3783
3784 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),Geom[Nc].pdbType);
3785 if(t) freeList(t,n);
3786 }
3787 hbox=create_hbox_false(vboxframe);
3788 Entry[E_RESIDUE] = create_label_entry(hbox,tlabel[E_RESIDUE],
3789 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3790
3791 if(NcentersZmat==0)
3792 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),"");
3793 else
3794 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),Geom[Nc].Residue);
3795
3796 tlistvar = get_list_variables();
3797 if(Nc>0)
3798 {
3799 hbox=create_hbox_false(vboxframe);
3800 tlistvar[0] = g_strdup(Geom[Nc].R);
3801 Entry[E_R] = create_label_combo(hbox,tlabel[E_R],tlistvar,NVariables+1,TRUE,
3802 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3803 Entry[E_NUMBER_R] = create_label_combo(hbox,tlabel[E_NUMBER_R],tlist,Nc,FALSE,
3804 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3805 gtk_entry_set_text(GTK_ENTRY(Entry[E_R]),Geom[Nc].R);
3806 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_R]),Geom[Nc].NR);
3807 }
3808 if(Nc>1)
3809 {
3810 hbox=create_hbox_false(vboxframe);
3811 tlistvar[0] = g_strdup(Geom[Nc].Angle);
3812 Entry[E_ANGLE] = create_label_combo(hbox,tlabel[E_ANGLE],tlistvar,NVariables+1,TRUE,
3813 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3814 Entry[E_NUMBER_ANGLE] = create_label_combo(hbox,tlabel[E_NUMBER_ANGLE],tlist,Nc,FALSE,
3815 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3816 gtk_entry_set_text(GTK_ENTRY(Entry[E_ANGLE]),Geom[Nc].Angle);
3817 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_ANGLE]),Geom[Nc].NAngle);
3818 }
3819 if(Nc>2)
3820 {
3821 hbox=create_hbox_false(vboxframe);
3822 tlistvar[0] = g_strdup(Geom[Nc].Dihedral);
3823 Entry[E_DIHEDRAL] = create_label_combo(hbox,tlabel[E_DIHEDRAL],tlistvar,NVariables+1,TRUE,
3824 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3825 Entry[E_NUMBER_DIHEDRAL] = create_label_combo(hbox,tlabel[E_NUMBER_DIHEDRAL],tlist,Nc,FALSE,
3826 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*0.08));
3827 gtk_entry_set_text(GTK_ENTRY(Entry[E_DIHEDRAL]),Geom[Nc].Dihedral);
3828 gtk_entry_set_text(GTK_ENTRY(Entry[E_NUMBER_DIHEDRAL]),Geom[Nc].NDihedral);
3829 }
3830 if(tlist)
3831 g_free(tlist);
3832 freelistvariables(tlistvar);
3833
3834 hbox=create_hbox_false(vboxframe);
3835 Entry[E_CHARGE] = create_label_entry(hbox,tlabel[E_CHARGE],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3836 gtk_entry_set_text(GTK_ENTRY(Entry[E_CHARGE]),Geom[Nc].Charge);
3837
3838 tlist=g_malloc(4*sizeof(gchar*));
3839 nlist=4;
3840 /* if(LineSelected<3) nlist=1;*/
3841 tlist[0]=g_strdup(" ");
3842 tlist[1]=g_strdup("High");
3843 tlist[2]=g_strdup("Medium");
3844 tlist[3]=g_strdup("Low");
3845
3846 hbox=create_hbox_false(vboxframe);
3847 if(iprogram != PROG_IS_MOLPRO)
3848 {
3849 Entry[E_LAYER] = create_label_combo(hbox,tlabel[E_LAYER],tlist,nlist,FALSE,
3850 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3851 gtk_entry_set_text(GTK_ENTRY(Entry[E_LAYER]),Geom[Nc].Layer);
3852 }
3853 gtk_widget_realize(Dialogue);
3854
3855 Bouton = create_button(Dialogue,_("Cancel"));
3856 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3857 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3858 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3859
3860 Bouton = create_button(Dialogue,_("OK"));
3861 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3862 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)EditAtom, Entry[E_SYMBOL]);
3863 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)destroy_dialogue, GTK_OBJECT(Dialogue));
3864 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3865 gtk_widget_grab_default(Bouton);
3866
3867
3868 gtk_widget_show_all(Dialogue);
3869 g_free(tlist);
3870 }
3871 /********************************************************************************/
DialogueDelete()3872 static void DialogueDelete()
3873 {
3874 GtkWidget *Dialogue;
3875 GtkWidget *Label;
3876 GtkWidget *Bouton;
3877 GtkWidget *frame;
3878 GtkWidget *vboxframe;
3879
3880
3881 if (NcentersZmat <1)
3882 {
3883 MessageGeom(_(" No Center to delet !"),_(" Warning "),TRUE);
3884 return ;
3885 }
3886
3887 Dialogue = gtk_dialog_new();
3888 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Delete Center"));
3889 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3890 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3891 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
3892
3893 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Question "));
3894 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3895
3896 frame = gtk_frame_new (NULL);
3897 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3898
3899 g_object_ref (frame);
3900 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3901 frame,(GDestroyNotify) g_object_unref);
3902 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3903 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3904
3905 gtk_widget_show (frame);
3906
3907 vboxframe = create_vbox(frame);
3908
3909 gtk_widget_realize(Dialogue);
3910 /* The Label */
3911 Label = create_label_with_pixmap(Dialogue,_("\nAre you sure to delete \nthe last center? \n"),_(" Question "));
3912 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
3913
3914 Bouton = create_button(Dialogue,"No");
3915 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3916 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3917 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3918 gtk_widget_grab_default(Bouton);
3919
3920 Bouton = create_button(Dialogue,"Yes");
3921 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3922 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)DelAtom, NULL);
3923 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3924 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3925
3926
3927 gtk_widget_show_all(Dialogue);
3928 }
3929 /********************************************************************************/
put_geom_in_list()3930 void put_geom_in_list()
3931 {
3932
3933 if(Geom != NULL )
3934 append_list_geom();
3935 if(GeomDrawingArea != NULL)
3936 rafresh_drawing();
3937 if(iprogram == PROG_IS_GAUSS)
3938 set_spin_of_electrons();
3939 }
3940 /********************************************************************************/
ThisIsNotAnAtom(gchar * t)3941 gboolean ThisIsNotAnAtom(gchar *t)
3942 {
3943 gint i,j;
3944 gchar *temp;
3945 gchar *t1;
3946 gchar*** Symb = get_periodic_table();
3947
3948 temp = g_strdup(t);
3949 uppercase(temp);
3950 for ( i = 0;i<PERIODIC_TABLE_N_ROWS;i++)
3951 for ( j = 0;j<PERIODIC_TABLE_N_COLUMNS;j++)
3952 {
3953 t1=g_strdup(Symb[j][i]);
3954 uppercase(t1);
3955 if (!strcmp(temp, t1) )
3956 {
3957 g_free(t1);
3958 g_free(temp);
3959 return FALSE;
3960 }
3961 g_free(t1);
3962 }
3963 g_free(temp);
3964 return TRUE;
3965
3966 }
3967 /*************************************************************************************/
Geom_Change_Unit(gboolean toang)3968 void Geom_Change_Unit(gboolean toang)
3969 {
3970 guint i;
3971 guint j;
3972 for(i=1;i<NcentersZmat;i++)
3973 {
3974 if(test(Geom[i].R))
3975 {
3976 if(toang)
3977 Geom[i].R=bohr_to_ang(Geom[i].R);
3978 else
3979 Geom[i].R=ang_to_bohr(Geom[i].R);
3980 }
3981 }
3982 for(i=0;i<NVariables;i++)
3983 {
3984 /* search if variable i is used for R */
3985 for(j=1;j<NcentersZmat;j++)
3986 if(!strcmp(Geom[j].R,Variables[i].Name))
3987 {
3988 if(toang)
3989 Variables[i].Value=bohr_to_ang(Variables[i].Value);
3990 else
3991 Variables[i].Value=ang_to_bohr(Variables[i].Value);
3992 break;
3993 }
3994 }
3995 }
3996 /********************************************************************************/
deleteNumericChars(gchar * st)3997 static void deleteNumericChars(gchar *st)
3998 {
3999 gint i;
4000 gint l = strlen(st);
4001 if(l>0) st[0] = toupper(st[0]);
4002 for(i=1;i<l;i++)
4003 if(isdigit(st[i]))
4004 {
4005 st[i]='\0';
4006 return;
4007 }
4008 else st[i] = tolower(st[i]);
4009 }
4010 /********************************************************************************/
get_charge_and_multiplicity_from_molcas_input_file(FILE * fd)4011 static void get_charge_and_multiplicity_from_molcas_input_file(FILE* fd)
4012 {
4013 guint taille=BSIZE;
4014 gchar t[BSIZE];
4015
4016 TotalCharges[0] = 0;
4017 SpinMultiplicities[0] =1;
4018
4019 fseek(fd, 0L, SEEK_SET);
4020 while(!feof(fd) )
4021 {
4022 if(!fgets(t, taille, fd)) return;
4023 uppercase(t);
4024 if ( strstr(t,"CHARGE") && strstr(t,"="))
4025 {
4026 gchar* p = strstr(t,"=")+1;
4027 TotalCharges[0] = atoi(p);
4028 }
4029 if ( strstr(t,"ZSPIN") && strstr(t,"="))
4030 {
4031 gchar* p = strstr(t,"=")+1;
4032 SpinMultiplicities[0] = atoi(p)+1;
4033 }
4034 }
4035 }
4036 /*************************************************************************************/
read_Zmat_from_molcas_input_file(gchar * fileName)4037 gint read_Zmat_from_molcas_input_file(gchar *fileName)
4038 {
4039 gboolean OK;
4040 gchar *AtomCoord[7];
4041 FILE *file;
4042 gint i;
4043 gint j;
4044 GeomAtomDef* Geomtemp=NULL;
4045 gint Ncent = 0;
4046 gchar t[BSIZE];
4047
4048 file = FOpen(fileName, "rb");
4049 if(file == NULL)
4050 {
4051 gchar buffer[BSIZE];
4052 sprintf(buffer,_("Sorry, I cannot open %s file"),fileName);
4053 MessageGeom(buffer,_("Error"),TRUE);
4054 return -1;
4055 }
4056 /* search ZMAT */
4057 OK=FALSE;
4058 i = 0;
4059 while(!feof(file))
4060 {
4061 if(!fgets(t,BSIZE,file))break;
4062 uppercase(t);
4063 if(strstr(t,"ZMAT")) i++;
4064 if(strstr(t,"END") && strstr(t,"BASIS"))
4065 {
4066 if(i>0) OK = TRUE;
4067 break;
4068 }
4069
4070 }
4071 if(!OK)
4072 {
4073 gchar buffer[BSIZE];
4074 sprintf(buffer,_("Sorry, I cannot read the Z-Matrix from the %s file"),fileName);
4075 MessageGeom(buffer,_("Error"),TRUE);
4076 return -1;
4077 }
4078
4079 for(i=0;i<7;i++) AtomCoord[i]=g_malloc(BSIZE*sizeof(gchar));
4080
4081 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4082 /* First atom */
4083 {
4084 { char* e = fgets(t,BSIZE,file);}
4085 i = sscanf(t,"%s",AtomCoord[0]);
4086 if( i == 1 )
4087 {
4088 deleteNumericChars(AtomCoord[0]);
4089 Ncent ++;
4090 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4091 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
4092 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4093 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4094 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4095 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4096 Geomtemp[Ncent-1].ResidueNumber=0;
4097 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4098 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4099 }
4100 else
4101 {
4102 OK = FALSE;
4103 Ncent--;
4104 g_free(Geomtemp);
4105 Geomtemp = NULL;
4106 }
4107 }
4108 j=-1;
4109 while( !feof(file) && OK)
4110 {
4111 j++;
4112 { char* e = fgets(t,BSIZE,file);}
4113 uppercase(t);
4114 if(strstr(t,"END") && strstr(t,"MATRIX")) break;
4115 if(strstr(t,"VARIABLE")) break;
4116 Ncent++;
4117 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4118 Geomtemp[Ncent-1].Symb=NULL;
4119 Geomtemp[Ncent-1].mmType=NULL;
4120 Geomtemp[Ncent-1].pdbType=NULL;
4121 Geomtemp[Ncent-1].NR=NULL;
4122 Geomtemp[Ncent-1].R=NULL;
4123 Geomtemp[Ncent-1].NAngle=NULL;
4124 Geomtemp[Ncent-1].Angle=NULL;
4125 Geomtemp[Ncent-1].NDihedral=NULL;
4126 Geomtemp[Ncent-1].Dihedral=NULL;
4127 Geomtemp[Ncent-1].Charge=NULL;
4128 Geomtemp[Ncent-1].Layer=NULL;
4129 switch(Ncent)
4130 {
4131 case 2 :
4132 i = sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]) ;
4133 deleteNumericChars(AtomCoord[0]);
4134 if(i == 3 && test(AtomCoord[2]))
4135 {
4136 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
4137 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4138 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4139 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4140 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4141 Geomtemp[Ncent-1].ResidueNumber=0;
4142 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4143 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4144 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4145 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4146 }
4147 else
4148 {
4149 Ncent--;
4150 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4151 OK = FALSE;
4152 }
4153 break;
4154 case 3 :
4155 i = sscanf(
4156 t,"%s %s %s %s %s",
4157 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4158 AtomCoord[3],AtomCoord[4]
4159 ) ;
4160 deleteNumericChars(AtomCoord[0]);
4161 if(i == 5 && test(AtomCoord[2]) && test(AtomCoord[4]))
4162 {
4163 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
4164 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4165 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4166 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4167 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4168 Geomtemp[Ncent-1].ResidueNumber=0;
4169 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4170 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4171 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4172 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4173 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4174 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4175 }
4176 else
4177 {
4178 Ncent--;
4179 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4180 OK = FALSE;
4181 }
4182 break;
4183 default :
4184 i = sscanf(
4185 t,"%s %s %s %s %s %s %s ",
4186 AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3],
4187 AtomCoord[4],AtomCoord[5],AtomCoord[6]
4188 );
4189 deleteNumericChars(AtomCoord[0]);
4190 if(i == 7 && test(AtomCoord[2]) && test(AtomCoord[4]) && test(AtomCoord[6]))
4191 {
4192 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
4193 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4194 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4195 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4196 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4197 Geomtemp[Ncent-1].ResidueNumber=0;
4198 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4199 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4200 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4201 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4202 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
4203 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
4204 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4205 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4206 }
4207 else
4208 {
4209 Ncent--;
4210 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4211 OK = FALSE;
4212 }
4213
4214 }
4215 }
4216
4217 for(i=0;i<7;i++) g_free(AtomCoord[i]);
4218 if( !OK || Ncent <1 )
4219 {
4220 MessageGeom(_("Sorry\n I can not read geometry from you Molcas input file"),_("Error"),TRUE);
4221 return -1;
4222 }
4223 get_charge_and_multiplicity_from_molcas_input_file(file);
4224 fclose(file);
4225 if(Geom) freeGeom();
4226 if(Variables) freeVariables();
4227 Geom = Geomtemp;
4228 NcentersZmat = Ncent;
4229 NVariables = 0;
4230 Variables = NULL;
4231 MethodeGeom = GEOM_IS_ZMAT;
4232 if(Units== 0 ) Geom_Change_Unit(FALSE);
4233 if(GeomIsOpen) create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
4234
4235 if(GeomDrawingArea != NULL) rafresh_drawing();
4236 set_last_directory(fileName);
4237 return 0;
4238 }
4239 /*************************************************************************************/
read_Zmat_from_molpro_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)4240 void read_Zmat_from_molpro_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
4241 {
4242 gchar *t;
4243 gchar *t1;
4244 gchar *t2;
4245 gchar *t3;
4246 gboolean OK;
4247 gchar *AtomCoord[7];
4248 FILE *fd;
4249 guint taille=BSIZE;
4250 guint i;
4251 gint j;
4252 gint k;
4253 gint Kvar=0;
4254 gboolean Uvar=FALSE;
4255 GeomAtomDef* Geomtemp=NULL;
4256 gint Ncent = 0;
4257 gint Nvar = 0;
4258 VariablesDef* Variablestemp=NULL;
4259
4260 for(i=0;i<7;i++)
4261 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
4262
4263
4264 t=g_malloc(taille);
4265 /* Read Geomery */
4266 fd = FOpen(NomFichier, "rb");
4267 OK=TRUE;
4268 if(fd!=NULL)
4269 {
4270 for(i=0;(gint)i<InfoFile.numline;i++)
4271 { char* e = fgets(t,taille,fd);}
4272 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4273 { char* e = fgets(t,taille,fd);} /* Ligne de commentaires*/
4274
4275 Kvar = 0;
4276 { char* e = fgets(t,taille,fd);}
4277 if(t[0] == '}')
4278 {
4279 OK = FALSE;
4280 }
4281 else
4282 {
4283 i = sscanf(t,"%s",AtomCoord[0]);
4284 if( i == 1 )
4285 {
4286 Ncent ++;
4287 DeleteLastChar(AtomCoord[0]);
4288 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4289 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
4290 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4291 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4292 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4293 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4294 Geomtemp[Ncent-1].ResidueNumber=0;
4295 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4296 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4297 }
4298 else
4299 {
4300 OK = FALSE;
4301 Ncent--;
4302 g_free(Geomtemp);
4303 Geomtemp = NULL;
4304 }
4305 }
4306 j=-1;
4307 while( !feof(fd) && OK)
4308 {
4309 j++;
4310 { char* e = fgets(t,taille,fd);}
4311 if(t[0] == '}')
4312 break;
4313 Ncent++;
4314 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4315 Geomtemp[Ncent-1].Symb=NULL;
4316 Geomtemp[Ncent-1].mmType=NULL;
4317 Geomtemp[Ncent-1].pdbType=NULL;
4318 Geomtemp[Ncent-1].NR=NULL;
4319 Geomtemp[Ncent-1].R=NULL;
4320 Geomtemp[Ncent-1].NAngle=NULL;
4321 Geomtemp[Ncent-1].Angle=NULL;
4322 Geomtemp[Ncent-1].NDihedral=NULL;
4323 Geomtemp[Ncent-1].Dihedral=NULL;
4324 Geomtemp[Ncent-1].Charge=NULL;
4325 Geomtemp[Ncent-1].Layer=NULL;
4326 switch(Ncent)
4327 {
4328 case 2 :
4329 i = sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]) ;
4330 if(i == 3)
4331 {
4332 for(k=0;k<(gint)i;k++)
4333 DeleteLastChar(AtomCoord[k]);
4334 if( !test(AtomCoord[2]) )
4335 {
4336 Uvar = TRUE;
4337 Kvar++;
4338 }
4339 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
4340 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4341 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4342 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4343 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4344 Geomtemp[Ncent-1].ResidueNumber=0;
4345 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4346 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4347 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4348 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4349 }
4350 else
4351 {
4352 Ncent--;
4353 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4354 OK = FALSE;
4355 }
4356 break;
4357 case 3 :
4358 i = sscanf(
4359 t,"%s %s %s %s %s",
4360 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4361 AtomCoord[3],AtomCoord[4]
4362 ) ;
4363 if(i == 5)
4364 {
4365 for(k=0;k<(gint)i;k++)
4366 DeleteLastChar(AtomCoord[k]);
4367 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) )
4368 Uvar = TRUE;
4369 if(!test(AtomCoord[2]))
4370 Kvar++;
4371 if(!test(AtomCoord[4]))
4372 Kvar++;
4373 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
4374 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4375 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4376 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4377 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4378 Geomtemp[Ncent-1].ResidueNumber=0;
4379 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4380 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4381 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4382 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4383 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4384 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4385 }
4386 else
4387 {
4388 Ncent--;
4389 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4390 OK = FALSE;
4391 }
4392 break;
4393 default :
4394 i = sscanf(
4395 t,"%s %s %s %s %s %s %s ",
4396 AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3],
4397 AtomCoord[4],AtomCoord[5],AtomCoord[6]
4398 );
4399 if(i == 7)
4400 {
4401 for(k=0;k<(gint)i;k++)
4402 DeleteLastChar(AtomCoord[k]);
4403 if(
4404 !test(AtomCoord[2]) ||
4405 !test(AtomCoord[4]) ||
4406 !test(AtomCoord[6])
4407 )
4408 Uvar = TRUE;
4409 if(!test(AtomCoord[2]))
4410 Kvar++;
4411 if(!test(AtomCoord[4]))
4412 Kvar++;
4413 if(!test(AtomCoord[6]))
4414 Kvar++;
4415 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
4416 Geomtemp[Ncent-1].Symb=g_strdup(AtomCoord[0]);
4417 Geomtemp[Ncent-1].mmType=g_strdup(AtomCoord[0]);
4418 Geomtemp[Ncent-1].pdbType=g_strdup(AtomCoord[0]);
4419 Geomtemp[Ncent-1].Residue=g_strdup(" ");
4420 Geomtemp[Ncent-1].ResidueNumber=0;
4421 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4422 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4423 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4424 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4425 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
4426 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
4427 Geomtemp[Ncent-1].Charge=g_strdup("0.0");
4428 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4429 }
4430 else
4431 {
4432 Ncent--;
4433 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4434 OK = FALSE;
4435 }
4436
4437 }
4438 }
4439 fclose(fd);
4440 }
4441 else
4442 OK = FALSE;
4443
4444 /* Read Variables */
4445 if(OK && Uvar )
4446 {
4447 Nvar = 0;
4448 fd = FOpen(NomFichier, "rb");
4449 if(fd!=NULL)
4450 {
4451 t2= g_strdup("Variables");
4452 uppercase(t2);
4453 while( !feof(fd) )
4454 {
4455 { char* e = fgets(t,taille,fd);}
4456 t1 = g_strdup(t);
4457 uppercase(t1);
4458 t3 = strstr(t1,t2);
4459 if(t3 != NULL)
4460 break;
4461 g_free(t1);
4462 }
4463 g_free(t2);
4464 while( !feof(fd) )
4465 {
4466 { char* e = fgets(t,taille,fd);}
4467 i = sscanf(t,"%s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2]);
4468 if( i != EOF && i == 3)
4469 {
4470 Nvar++;
4471 if(Nvar == 1)
4472 Variablestemp=g_malloc(sizeof(VariablesDef));
4473 else
4474 Variablestemp=g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
4475 DeleteLastChar(AtomCoord[2]);
4476 Variablestemp[Nvar-1].Name = g_strdup(AtomCoord[0]);
4477 Variablestemp[Nvar-1].Value = g_strdup(AtomCoord[2]);
4478 Variablestemp[Nvar-1].Used = TRUE;
4479 }
4480 else
4481 break;
4482 }
4483
4484 fclose(fd);
4485 }
4486 }
4487 g_free(t);
4488 for(i=0;i<7;i++)
4489 g_free(AtomCoord[i]);
4490 if( !OK || Ncent <1 || Nvar < Kvar)
4491 {
4492 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
4493 MessageGeom(_("Sorry\n I can not read geometry in Molpro input file"),_("Error"),TRUE);
4494 return;
4495 }
4496 if(Geom)
4497 freeGeom();
4498 if(Variables)
4499 freeVariables();
4500 Geom = Geomtemp;
4501 NcentersZmat = Ncent;
4502 NVariables = Nvar;
4503 Variables = Variablestemp;
4504 MethodeGeom = GEOM_IS_ZMAT;
4505 if( InfoFile.units== 1 && Units== 0 )
4506 Geom_Change_Unit(FALSE);
4507 else
4508 if( InfoFile.units== 0 && Units== 1 )
4509 Geom_Change_Unit(TRUE);
4510 if(GeomIsOpen)
4511 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
4512
4513 if(GeomDrawingArea != NULL)
4514 rafresh_drawing();
4515 set_last_directory(NomFichier);
4516 }
4517 /*************************************************************************************/
read_Zmat_from_demon_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)4518 void read_Zmat_from_demon_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
4519 {
4520 gchar *t;
4521 gboolean OK;
4522 gchar *AtomCoord[7];
4523 FILE *fd;
4524 guint taille=BSIZE;
4525 guint i;
4526 gint j;
4527 gboolean Uvar=FALSE;
4528 GeomAtomDef* Geomtemp=NULL;
4529 gint Ncent = 0;
4530 gint Nvar = 0;
4531 VariablesDef* Variablestemp=NULL;
4532 gchar symb[BSIZE];
4533 gchar type[BSIZE];
4534 gchar charge[BSIZE];
4535
4536 if ( strcmp(NomFichier,"") == 0 )
4537 return;
4538
4539 for(i=0;i<7;i++)
4540 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
4541
4542
4543 t=g_malloc(taille);
4544 fd = FOpen(NomFichier, "rb");
4545 OK=TRUE;
4546 if(fd!=NULL)
4547 {
4548 for(i=0;(gint)i<InfoFile.numline-1;i++) { char* e = fgets(t,taille,fd);}
4549
4550 i = 0;
4551 while(!feof(fd) && OK )
4552 {
4553 if(!fgets(t,taille,fd)) break;
4554 deleteFirstSpaces(t);
4555 if(t[0] == '#') continue;
4556 i = sscanf(t,"%s",AtomCoord[0]);
4557 break;
4558 }
4559 if(i != 1) OK = FALSE;
4560 else
4561 {
4562 Ncent++;
4563 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4564 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
4565
4566 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4567 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4568 Geomtemp[Ncent-1].mmType = g_strdup(type);
4569 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4570 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4571
4572 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4573 Geomtemp[Ncent-1].ResidueNumber=0;
4574 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4575 }
4576 j=-1;
4577 while(!feof(fd) && OK )
4578 {
4579 j++;
4580 if(!fgets(t,taille,fd)) break;
4581 deleteFirstSpaces(t);
4582 if(t[0] == '#') continue;
4583 if(t[0] == '\n') break;
4584 i = sscanf(t,"%s ",AtomCoord[0]);
4585 if(i != 1)
4586 {
4587 OK = FALSE;
4588 break;
4589 }
4590 uppercase(AtomCoord[0]);
4591 if(strstr(AtomCoord[0],"VARIA") )
4592 {
4593 Uvar = TRUE;
4594 break;
4595 }
4596 Ncent++;
4597 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4598 switch( Ncent ){
4599 case 2 :
4600 i = sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]);
4601 if( i != 3 )
4602 {
4603 Ncent--;
4604 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4605 OK = FALSE;
4606 }
4607 if( !test(AtomCoord[2]) )
4608 Uvar = TRUE;
4609 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
4610
4611 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4612 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4613 Geomtemp[Ncent-1].mmType = g_strdup(type);
4614 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4615 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4616
4617 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4618 Geomtemp[Ncent-1].ResidueNumber=0;
4619 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4620 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4621 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4622 break;
4623 case 3 :
4624 i = sscanf(
4625 t,"%s %s %s %s %s ",
4626 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4627 AtomCoord[3],AtomCoord[4]
4628 );
4629 if(i != 5)
4630 {
4631 Ncent--;
4632 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4633 OK = FALSE;
4634 }
4635 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) )
4636 Uvar = TRUE;
4637 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
4638
4639 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4640 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4641 Geomtemp[Ncent-1].mmType = g_strdup(type);
4642 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4643 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4644
4645 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4646 Geomtemp[Ncent-1].ResidueNumber=0;
4647 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4648 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4649 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4650 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4651 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4652 break;
4653 default :
4654 i = sscanf(
4655 t,"%s %s %s %s %s %s %s",
4656 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4657 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
4658 );
4659 if( i!= 7)
4660 {
4661 Ncent--;
4662 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4663 OK = FALSE;
4664 }
4665 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) || !test(AtomCoord[6]))
4666 Uvar = TRUE;
4667 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
4668
4669 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4670 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4671 Geomtemp[Ncent-1].mmType = g_strdup(type);
4672 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4673 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4674
4675 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4676 Geomtemp[Ncent-1].ResidueNumber=0;
4677 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4678 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4679 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4680 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4681 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
4682 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
4683 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4684 }/*end switch*/
4685 }/*end while*/
4686 /* Variables */
4687 Nvar=0;
4688 while(!feof(fd) && Uvar && OK )
4689 {
4690 if(!fgets(t,taille,fd)) break;
4691 deleteFirstSpaces(t);
4692 if(t[0] == '#') continue;
4693 if(t[0] == '\n') break;
4694 {
4695 Nvar++;
4696 if(Nvar==1) Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
4697 else Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
4698 Variablestemp[Nvar-1].Name=NULL;
4699 Variablestemp[Nvar-1].Value=NULL;
4700 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
4701 if( i == 2)
4702 {
4703 Variablestemp[Nvar-1].Name=g_strdup(AtomCoord[0]);
4704 Variablestemp[Nvar-1].Value=g_strdup(AtomCoord[1]);
4705 Variablestemp[Nvar-1].Used=TRUE;
4706 OK = TRUE;
4707 }
4708 else
4709 {
4710 OK = FALSE;
4711 }
4712 }
4713 }
4714 /* end while variables */
4715 fclose(fd);
4716 }
4717 else
4718 OK = FALSE;
4719
4720 g_free(t);
4721 for(i=0;i<7;i++)
4722 g_free(AtomCoord[i]);
4723 if( !OK || Ncent <1 )
4724 {
4725 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
4726 MessageGeom(_("Sorry\n I can not read geometry in DeMon input file"),_("Error"),TRUE);
4727 return;
4728 }
4729 if(Geom)
4730 freeGeom();
4731 if(Variables)
4732 freeVariables();
4733 Geom = Geomtemp;
4734 NcentersZmat = Ncent;
4735 NVariables = Nvar;
4736 Variables = Variablestemp;
4737 MethodeGeom = GEOM_IS_ZMAT;
4738 if( InfoFile.units== 1 && Units== 0 )
4739 Geom_Change_Unit(FALSE);
4740 else
4741 if( InfoFile.units== 0 && Units== 1 )
4742 Geom_Change_Unit(TRUE);
4743 if(GeomIsOpen)
4744 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
4745
4746 if(GeomDrawingArea != NULL)
4747 rafresh_drawing();
4748 set_last_directory(NomFichier);
4749 }
4750 /*************************************************************************************/
read_Zmat_from_gauss_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)4751 void read_Zmat_from_gauss_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
4752 {
4753 gchar *t;
4754 gboolean OK;
4755 gchar *AtomCoord[7];
4756 FILE *fd;
4757 guint taille=BSIZE;
4758 guint i;
4759 gint j;
4760 gboolean Uvar=FALSE;
4761 GeomAtomDef* Geomtemp=NULL;
4762 gint Ncent = 0;
4763 gint Nvar = 0;
4764 VariablesDef* Variablestemp=NULL;
4765 gchar symb[BSIZE];
4766 gchar type[BSIZE];
4767 gchar charge[BSIZE];
4768
4769 if ( strcmp(NomFichier,"") == 0 )
4770 return;
4771
4772 for(i=0;i<7;i++)
4773 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
4774
4775
4776 t=g_malloc(taille);
4777 fd = FOpen(NomFichier, "rb");
4778 OK=TRUE;
4779 if(fd!=NULL)
4780 {
4781 for(i=0;(gint)i<InfoFile.numline-1;i++)
4782 { char* e = fgets(t,taille,fd);}
4783
4784 { char* e = fgets(t,taille,fd);}
4785 i = sscanf(t,"%s",AtomCoord[0]);
4786 if(i != 1)
4787 OK = FALSE;
4788 else
4789 {
4790 Ncent++;
4791 Geomtemp=g_malloc(sizeof(GeomAtomDef));
4792 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
4793
4794 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4795 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4796 Geomtemp[Ncent-1].mmType = g_strdup(type);
4797 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4798 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4799
4800 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4801 Geomtemp[Ncent-1].ResidueNumber=0;
4802 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4803 }
4804 j=-1;
4805 while(!feof(fd) && OK )
4806 {
4807 j++;
4808 { char* e = fgets(t,taille,fd);}
4809 if(t[0] == '\n')
4810 break;
4811 for(i=0;i<strlen(t);i++)
4812 if(t[i] != ' ')
4813 break;
4814 if(i == strlen(t)-1)
4815 break;
4816 i = sscanf(t,"%s ",AtomCoord[0]);
4817 if(i != 1)
4818 {
4819 OK = FALSE;
4820 break;
4821 }
4822 if( !strcmp(AtomCoord[0],"Variables") )
4823 {
4824 Uvar = TRUE;
4825 break;
4826 }
4827 Ncent++;
4828 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4829 switch( Ncent ){
4830 case 2 :
4831 i = sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]);
4832 if( i != 3 )
4833 {
4834 Ncent--;
4835 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4836 OK = FALSE;
4837 }
4838 if( !test(AtomCoord[2]) )
4839 Uvar = TRUE;
4840 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
4841
4842 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4843 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4844 Geomtemp[Ncent-1].mmType = g_strdup(type);
4845 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4846 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4847
4848 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4849 Geomtemp[Ncent-1].ResidueNumber=0;
4850 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4851 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4852 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4853 break;
4854 case 3 :
4855 i = sscanf(
4856 t,"%s %s %s %s %s ",
4857 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4858 AtomCoord[3],AtomCoord[4]
4859 );
4860 if(i != 5)
4861 {
4862 Ncent--;
4863 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4864 OK = FALSE;
4865 }
4866 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) )
4867 Uvar = TRUE;
4868 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
4869
4870 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4871 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4872 Geomtemp[Ncent-1].mmType = g_strdup(type);
4873 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4874 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4875
4876 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4877 Geomtemp[Ncent-1].ResidueNumber=0;
4878 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4879 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4880 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4881 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4882 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4883 break;
4884 default :
4885 i = sscanf(
4886 t,"%s %s %s %s %s %s %s",
4887 AtomCoord[0],AtomCoord[1],AtomCoord[2],
4888 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
4889 );
4890 if( i!= 7)
4891 {
4892 Ncent--;
4893 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
4894 OK = FALSE;
4895 }
4896 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) || !test(AtomCoord[6]))
4897 Uvar = TRUE;
4898 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
4899
4900 get_symb_type_charge(AtomCoord[0],symb,type,charge);
4901 Geomtemp[Ncent-1].Symb = g_strdup(symb);
4902 Geomtemp[Ncent-1].mmType = g_strdup(type);
4903 Geomtemp[Ncent-1].pdbType = g_strdup(type);
4904 Geomtemp[Ncent-1].Charge=g_strdup(charge);
4905
4906 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
4907 Geomtemp[Ncent-1].ResidueNumber=0;
4908 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
4909 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
4910 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
4911 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
4912 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
4913 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
4914 Geomtemp[Ncent-1].Layer=g_strdup(" ");
4915 }/*end switch*/
4916 }/*end while*/
4917 /* Variables */
4918 Nvar=0;
4919 while(!feof(fd) && Uvar && OK )
4920 {
4921 { char* e = fgets(t,taille,fd);}
4922 OK=TRUE;
4923 for(i=0;i<strlen(t)-1;i++)
4924 if ( (int)t[i] != (int)' ' )
4925 OK=FALSE;
4926 if(OK)
4927 break;
4928 else
4929 {
4930 Nvar++;
4931 if(Nvar==1)
4932 Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
4933 else
4934 Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
4935 Variablestemp[Nvar-1].Name=NULL;
4936 Variablestemp[Nvar-1].Value=NULL;
4937 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
4938 if( i == 2)
4939 {
4940 Variablestemp[Nvar-1].Name=g_strdup(AtomCoord[0]);
4941 Variablestemp[Nvar-1].Value=g_strdup(AtomCoord[1]);
4942 Variablestemp[Nvar-1].Used=TRUE;
4943 OK = TRUE;
4944 }
4945 else
4946 {
4947 OK = FALSE;
4948 }
4949 }
4950 }
4951 /* end while variables */
4952 fclose(fd);
4953 }
4954 else
4955 OK = FALSE;
4956
4957 g_free(t);
4958 for(i=0;i<7;i++)
4959 g_free(AtomCoord[i]);
4960 if( !OK || Ncent <1 )
4961 {
4962 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
4963 MessageGeom(_("Sorry\n I can not read geometry in Gaussian input file"),_("Error"),TRUE);
4964 return;
4965 }
4966 if(Geom)
4967 freeGeom();
4968 if(Variables)
4969 freeVariables();
4970 Geom = Geomtemp;
4971 NcentersZmat = Ncent;
4972 NVariables = Nvar;
4973 Variables = Variablestemp;
4974 MethodeGeom = GEOM_IS_ZMAT;
4975 if( InfoFile.units== 1 && Units== 0 )
4976 Geom_Change_Unit(FALSE);
4977 else
4978 if( InfoFile.units== 0 && Units== 1 )
4979 Geom_Change_Unit(TRUE);
4980 if(GeomIsOpen)
4981 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
4982
4983 if(GeomDrawingArea != NULL)
4984 rafresh_drawing();
4985 set_last_directory(NomFichier);
4986 }
4987 /*************************************************************************************/
read_Zmat_from_nwchem_input_file(gchar * NomFichier)4988 void read_Zmat_from_nwchem_input_file(gchar *NomFichier)
4989 {
4990 gchar *t;
4991 gboolean OK;
4992 gchar *AtomCoord[7];
4993 FILE *file;
4994 guint taille=BSIZE;
4995 guint i;
4996 gint j;
4997 gint k;
4998 gboolean Uvar=FALSE;
4999 GeomAtomDef* Geomtemp=NULL;
5000 gint Ncent = 0;
5001 gint Nvar = 0;
5002 VariablesDef* Variablestemp=NULL;
5003 gchar symb[BSIZE];
5004 gchar type[BSIZE];
5005 gchar charge[BSIZE];
5006 gint globalCharge, mult;
5007
5008 if ( strcmp(NomFichier,"") == 0 ) return;
5009
5010 file = FOpen(NomFichier, "rb");
5011 OK=TRUE;
5012 if(file==NULL)
5013 {
5014 MessageGeom(_("Sorry\n I can not read geometry in NWChem input file"),_("Error"),TRUE);
5015 return;
5016 }
5017 t=g_malloc(taille*sizeof(gchar));
5018 for(i=0;i<5;i++)
5019 AtomCoord[i]=g_malloc(taille*sizeof(char));
5020
5021 while(!feof(file))
5022 {
5023 if(!fgets(t,taille,file))
5024 {
5025 OK = FALSE;
5026 break;
5027 }
5028 uppercase(t);
5029 if(strstr(t,"* INT") && 4==sscanf(t,"%s %s %d %d",AtomCoord[0],AtomCoord[1],&globalCharge, &mult) )
5030 {
5031 OK = TRUE;
5032 break;
5033 }
5034 }
5035
5036 for(i=0;i<7;i++)
5037 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
5038
5039
5040 Ncent = 0;
5041 while(!feof(file) && OK )
5042 {
5043 { char* e = fgets(t,taille,file);}
5044 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
5045 if(i<=(gint)strlen(t) && t[i] == '*') break;
5046 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='{' || t[k]=='}') t[k] = ' ';
5047
5048 i = sscanf(t,"%s ",AtomCoord[0]);
5049 if(i != 1)
5050 {
5051 OK = FALSE;
5052 break;
5053 }
5054 Ncent++;
5055 if(Ncent==1) Geomtemp=g_malloc(Ncent*sizeof(GeomAtomDef));
5056 else Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5057 switch( Ncent ){
5058 case 1 :
5059 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
5060
5061 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5062 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5063 Geomtemp[Ncent-1].mmType = g_strdup(type);
5064 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5065 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5066
5067 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5068 Geomtemp[Ncent-1].ResidueNumber=0;
5069 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5070 break;
5071 case 2 :
5072 i = sscanf(
5073 t,"%s %s %s %s %s",
5074 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5075 AtomCoord[3],AtomCoord[4]
5076 );
5077 if( i != 5 )
5078 {
5079 Ncent--;
5080 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5081 OK = FALSE;
5082 }
5083 if( !test(AtomCoord[4]) ) Uvar = TRUE;
5084 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
5085
5086 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5087 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5088 Geomtemp[Ncent-1].mmType = g_strdup(type);
5089 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5090 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5091
5092 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5093 Geomtemp[Ncent-1].ResidueNumber=0;
5094 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5095 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5096 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5097 break;
5098 case 3 :
5099 i = sscanf(
5100 t,"%s %s %s %s %s %s",
5101 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5102 AtomCoord[3],AtomCoord[4],AtomCoord[5]
5103 );
5104 if(i != 6)
5105 {
5106 Ncent--;
5107 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5108 OK = FALSE;
5109 }
5110 if(!test(AtomCoord[4]) || !test(AtomCoord[5]) )
5111 Uvar = TRUE;
5112 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
5113
5114 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5115 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5116 Geomtemp[Ncent-1].mmType = g_strdup(type);
5117 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5118 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5119
5120 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5121 Geomtemp[Ncent-1].ResidueNumber=0;
5122 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5123 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5124 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[2]);
5125 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[5]);
5126 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5127 break;
5128 default :
5129 i = sscanf(
5130 t,"%s %s %s %s %s %s %s",
5131 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5132 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
5133 );
5134 if( i!= 7)
5135 {
5136 Ncent--;
5137 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5138 OK = FALSE;
5139 }
5140 if(!test(AtomCoord[4]) || !test(AtomCoord[5]) || !test(AtomCoord[6]))
5141 Uvar = TRUE;
5142 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
5143
5144 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5145 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5146 Geomtemp[Ncent-1].mmType = g_strdup(type);
5147 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5148 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5149
5150 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5151 Geomtemp[Ncent-1].ResidueNumber=0;
5152 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5153 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5154 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[2]);
5155 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[5]);
5156 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[3]);
5157 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
5158 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5159 }/*end switch*/
5160 }/*end while*/
5161 /* Variables */
5162 Nvar=0;
5163 fseek(file, 0L, SEEK_SET);
5164 if(Uvar)
5165 {
5166 OK =FALSE;
5167 while(!feof(file) && Uvar)
5168 {
5169 if(!fgets(t,taille,file)) break;
5170 uppercase(t);
5171 if(strstr(t,"PARAS"))
5172 {
5173 OK = TRUE;
5174 break;
5175 }
5176 }
5177 }
5178 while(!feof(file) && Uvar && OK )
5179 {
5180 uppercase(t);
5181 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
5182 for(j=0;j<Ncent;j++)
5183 {
5184 gchar* co[3] = {Geomtemp[j].R,Geomtemp[j].Angle,Geomtemp[j].Dihedral};
5185 for(k=0;k<3;k++)
5186 if(!test(co[k]))
5187 {
5188 gchar* b = strstr(t,co[k]);
5189 if(b)
5190 {
5191 b = b+strlen(co[k])+1;
5192 Nvar++;
5193 if(Nvar==1) Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
5194 else Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
5195 Variablestemp[Nvar-1].Name=g_strdup(co[k]);
5196 Variablestemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
5197 Variablestemp[Nvar-1].Used=TRUE;
5198 }
5199 }
5200 }
5201 if(strstr(t,"END")) break;
5202 { char* e = fgets(t,taille,file);}
5203 }
5204 /* end while variables */
5205 fclose(file);
5206 if(OK)
5207 {
5208 TotalCharges[0] = globalCharge;
5209 SpinMultiplicities[0] = mult;
5210 }
5211
5212 g_free(t);
5213 for(i=0;i<7;i++) g_free(AtomCoord[i]);
5214 if( !OK || Ncent <1 )
5215 {
5216 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
5217 MessageGeom(_("Sorry\n I can not read geometry in Q-Chem input file"),_("Error"),TRUE);
5218 return;
5219 }
5220 if(Geom) freeGeom();
5221 if(Variables) freeVariables();
5222 Geom = Geomtemp;
5223 NcentersZmat = Ncent;
5224 NVariables = Nvar;
5225 Variables = Variablestemp;
5226 MethodeGeom = GEOM_IS_ZMAT;
5227 if( Units== 0 ) Geom_Change_Unit(FALSE);
5228 if(GeomIsOpen)
5229 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
5230
5231 if(GeomDrawingArea != NULL) rafresh_drawing();
5232 set_last_directory(NomFichier);
5233 }
5234 /*************************************************************************************/
read_Zmat_from_psicode_input_file(gchar * NomFichier)5235 void read_Zmat_from_psicode_input_file(gchar *NomFichier)
5236 {
5237 gchar *t;
5238 gboolean OK;
5239 gchar *AtomCoord[7];
5240 FILE *file;
5241 guint taille=BSIZE;
5242 guint i;
5243 gint j;
5244 gint k;
5245 gboolean Uvar=FALSE;
5246 GeomAtomDef* Geomtemp=NULL;
5247 gint Ncent = 0;
5248 gint Nvar = 0;
5249 VariablesDef* Variablestemp=NULL;
5250 gchar symb[BSIZE];
5251 gchar type[BSIZE];
5252 gchar charge[BSIZE];
5253 gint globalCharge, mult;
5254
5255 if ( strcmp(NomFichier,"") == 0 ) return;
5256
5257 file = FOpen(NomFichier, "rb");
5258 OK=TRUE;
5259 if(file==NULL)
5260 {
5261 MessageGeom(_("Sorry\n I can not read geometry in Psicode input file"),_("Error"),TRUE);
5262 return;
5263 }
5264 t=g_malloc(taille*sizeof(gchar));
5265 for(i=0;i<5;i++)
5266 AtomCoord[i]=g_malloc(taille*sizeof(char));
5267
5268 while(!feof(file))
5269 {
5270 if(!fgets(t,taille,file))
5271 {
5272 OK = FALSE;
5273 break;
5274 }
5275 uppercase(t);
5276 if(strstr(t,"MOLECULE"))
5277 {
5278 OK = TRUE;
5279 break;
5280 }
5281 }
5282 if(fgets(t,taille,file) && 2==sscanf(t,"%d %d",&globalCharge,&mult)) OK = TRUE;
5283 else OK = FALSE;
5284
5285 for(i=0;i<7;i++)
5286 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
5287
5288
5289 Ncent = 0;
5290 /* printf("begin read zmatrix\n");*/
5291 while(!feof(file) && OK )
5292 {
5293 { char* e = fgets(t,taille,file);}
5294 /* printf("t=%s\n",t);*/
5295 if(strstr(t,"SYMMETRY")) continue;
5296 if(strstr(t,"}")) break;
5297 if(this_is_a_backspace(t)) break;
5298 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ' && t[i]!= '\t') break;
5299 if(i<=(gint)strlen(t) && t[i] == '#') continue;
5300
5301 i = sscanf(t,"%s ",AtomCoord[0]);
5302 if(i != 1)
5303 {
5304 OK = FALSE;
5305 break;
5306 }
5307 Ncent++;
5308 if(Ncent==1) Geomtemp=g_malloc(Ncent*sizeof(GeomAtomDef));
5309 else Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5310 switch( Ncent ){
5311 case 1 :
5312 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
5313
5314 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5315 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5316 Geomtemp[Ncent-1].mmType = g_strdup(type);
5317 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5318 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5319
5320 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5321 Geomtemp[Ncent-1].ResidueNumber=0;
5322 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5323 break;
5324 case 2 :
5325 /* printf("t=%s\n",t);*/
5326 i = sscanf(
5327 t,"%s %s %s",
5328 AtomCoord[0],AtomCoord[1],AtomCoord[2]
5329 );
5330 /* printf("i=%d\n",i);*/
5331 if( i != 3 )
5332 {
5333 Ncent--;
5334 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5335 OK = FALSE;
5336 }
5337 if( !test(AtomCoord[2]) ) Uvar = TRUE;
5338 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
5339
5340 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5341 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5342 Geomtemp[Ncent-1].mmType = g_strdup(type);
5343 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5344 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5345
5346 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5347 Geomtemp[Ncent-1].ResidueNumber=0;
5348 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5349 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5350 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5351 break;
5352 case 3 :
5353 /* printf("t=%s\n",t);*/
5354 i = sscanf(
5355 t,"%s %s %s %s %s",
5356 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5357 AtomCoord[3],AtomCoord[4]
5358 );
5359 /* printf("i=%d\n",i);*/
5360 if(i != 5)
5361 {
5362 Ncent--;
5363 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5364 OK = FALSE;
5365 }
5366 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) )
5367 Uvar = TRUE;
5368 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
5369
5370 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5371 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5372 Geomtemp[Ncent-1].mmType = g_strdup(type);
5373 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5374 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5375
5376 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5377 Geomtemp[Ncent-1].ResidueNumber=0;
5378 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5379 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5380 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
5381 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
5382 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5383 break;
5384 default :
5385 i = sscanf(
5386 t,"%s %s %s %s %s %s %s",
5387 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5388 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
5389 );
5390 if( i!= 7)
5391 {
5392 Ncent--;
5393 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5394 OK = FALSE;
5395 }
5396 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) || !test(AtomCoord[6]))
5397 Uvar = TRUE;
5398 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
5399
5400 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5401 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5402 Geomtemp[Ncent-1].mmType = g_strdup(type);
5403 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5404 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5405
5406 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5407 Geomtemp[Ncent-1].ResidueNumber=0;
5408 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5409 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5410 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
5411 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
5412 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
5413 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
5414 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5415 }/*end switch*/
5416 }/*end while*/
5417 /* Variables */
5418 Nvar=0;
5419 while(!feof(file) && Uvar && OK )
5420 {
5421 { char* e = fgets(t,taille,file);}
5422 uppercase(t);
5423 /* printf("t=%s\n",t);*/
5424 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
5425 /* printf("Ncent = %d\n",Ncent);*/
5426 /* printf("t = %s\n",t);*/
5427 for(j=1;j<Ncent;j++)
5428 {
5429 gchar* co[3] = {Geomtemp[j].R,NULL,NULL};
5430 if(j>=2) co[1] = Geomtemp[j].Angle;
5431 if(j>=3) co[2] = Geomtemp[j].Dihedral;
5432 /* printf("j = %d \n",j);*/
5433 for(k=0;k<3;k++)
5434 if(co[k] && !test(co[k]))
5435 {
5436 gchar* b = strstr(t,co[k]);
5437 /* printf("co = %s t = %s\n",co[k],t);*/
5438 if(b)
5439 {
5440 b = b+strlen(co[k])+1;
5441 Nvar++;
5442 if(Nvar==1) Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
5443 else Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
5444 Variablestemp[Nvar-1].Name=g_strdup(co[k]);
5445 Variablestemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
5446 Variablestemp[Nvar-1].Used=TRUE;
5447 }
5448 }
5449 }
5450 if(strstr(t,"}")) break;
5451 }
5452 /* end while variables */
5453 fclose(file);
5454 if(OK)
5455 {
5456 TotalCharges[0] = globalCharge;
5457 SpinMultiplicities[0] = mult;
5458 }
5459
5460 g_free(t);
5461 for(i=0;i<7;i++) g_free(AtomCoord[i]);
5462 if( !OK || Ncent <1 )
5463 {
5464 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
5465 MessageGeom(_("Sorry\n I can not read geometry in Psicode input file"),_("Error"),TRUE);
5466 return;
5467 }
5468 if(Geom) freeGeom();
5469 if(Variables) freeVariables();
5470 Geom = Geomtemp;
5471 NcentersZmat = Ncent;
5472 NVariables = Nvar;
5473 Variables = Variablestemp;
5474 MethodeGeom = GEOM_IS_ZMAT;
5475 if( Units== 0 ) Geom_Change_Unit(FALSE);
5476 if(GeomIsOpen)
5477 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
5478
5479 if(GeomDrawingArea != NULL) rafresh_drawing();
5480 set_last_directory(NomFichier);
5481 }
5482 /*************************************************************************************/
read_Zmat_from_orca_input_file(gchar * NomFichier)5483 void read_Zmat_from_orca_input_file(gchar *NomFichier)
5484 {
5485 gchar *t;
5486 gboolean OK;
5487 gchar *AtomCoord[7];
5488 FILE *file;
5489 guint taille=BSIZE;
5490 guint i;
5491 gint j;
5492 gint k;
5493 gboolean Uvar=FALSE;
5494 GeomAtomDef* Geomtemp=NULL;
5495 gint Ncent = 0;
5496 gint Nvar = 0;
5497 VariablesDef* Variablestemp=NULL;
5498 gchar symb[BSIZE];
5499 gchar type[BSIZE];
5500 gchar charge[BSIZE];
5501 gint globalCharge, mult;
5502 gint l;
5503
5504 if ( strcmp(NomFichier,"") == 0 ) return;
5505
5506 file = FOpen(NomFichier, "rb");
5507 OK=TRUE;
5508 if(file==NULL)
5509 {
5510 MessageGeom(_("Sorry\n I can not read geometry in Orca input file"),_("Error"),TRUE);
5511 return;
5512 }
5513 t=g_malloc(taille*sizeof(gchar));
5514 for(i=0;i<5;i++)
5515 AtomCoord[i]=g_malloc(taille*sizeof(char));
5516
5517 while(!feof(file))
5518 {
5519 if(!fgets(t,taille,file))
5520 {
5521 OK = FALSE;
5522 break;
5523 }
5524 uppercase(t);
5525 if(strstr(t,"* INT") && 4==sscanf(t,"%s %s %d %d",AtomCoord[0],AtomCoord[1],&globalCharge, &mult) )
5526 {
5527 OK = TRUE;
5528 break;
5529 }
5530 }
5531
5532 for(i=0;i<7;i++)
5533 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
5534
5535
5536 Ncent = 0;
5537 while(!feof(file) && OK )
5538 {
5539 { char* e = fgets(t,taille,file);}
5540 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
5541 if(i<=(gint)strlen(t) && t[i] == '*') break;
5542 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='{' || t[k]=='}') t[k] = ' ';
5543
5544 i = sscanf(t,"%s ",AtomCoord[0]);
5545 if(i != 1)
5546 {
5547 OK = FALSE;
5548 break;
5549 }
5550 Ncent++;
5551 if(Ncent==1) Geomtemp=g_malloc(Ncent*sizeof(GeomAtomDef));
5552 else Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5553 switch( Ncent ){
5554 case 1 :
5555 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
5556
5557 l=strlen(AtomCoord[0]);
5558 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
5559 if(!strcmp(AtomCoord[0],"Da")) sprintf(AtomCoord[0],"X");
5560 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5561 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5562 Geomtemp[Ncent-1].mmType = g_strdup(type);
5563 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5564 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5565
5566 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5567 Geomtemp[Ncent-1].ResidueNumber=0;
5568 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5569 break;
5570 case 2 :
5571 i = sscanf(
5572 t,"%s %s %s %s %s",
5573 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5574 AtomCoord[3],AtomCoord[4]
5575 );
5576 if( i != 5 )
5577 {
5578 Ncent--;
5579 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5580 OK = FALSE;
5581 }
5582 if( !test(AtomCoord[4]) ) Uvar = TRUE;
5583 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
5584
5585 l=strlen(AtomCoord[0]);
5586 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
5587 if(!strcmp(AtomCoord[0],"Da")) sprintf(AtomCoord[0],"X");
5588 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5589 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5590 Geomtemp[Ncent-1].mmType = g_strdup(type);
5591 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5592 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5593
5594 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5595 Geomtemp[Ncent-1].ResidueNumber=0;
5596 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5597 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5598 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5599 break;
5600 case 3 :
5601 i = sscanf(
5602 t,"%s %s %s %s %s %s",
5603 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5604 AtomCoord[3],AtomCoord[4],AtomCoord[5]
5605 );
5606 if(i != 6)
5607 {
5608 Ncent--;
5609 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5610 OK = FALSE;
5611 }
5612 if(!test(AtomCoord[4]) || !test(AtomCoord[5]) )
5613 Uvar = TRUE;
5614 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
5615
5616 l=strlen(AtomCoord[0]);
5617 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
5618 if(!strcmp(AtomCoord[0],"Da")) sprintf(AtomCoord[0],"X");
5619 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5620 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5621 Geomtemp[Ncent-1].mmType = g_strdup(type);
5622 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5623 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5624
5625 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5626 Geomtemp[Ncent-1].ResidueNumber=0;
5627 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5628 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5629 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[2]);
5630 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[5]);
5631 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5632 break;
5633 default :
5634 i = sscanf(
5635 t,"%s %s %s %s %s %s %s",
5636 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5637 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
5638 );
5639 if( i!= 7)
5640 {
5641 Ncent--;
5642 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5643 OK = FALSE;
5644 }
5645 if(!test(AtomCoord[4]) || !test(AtomCoord[5]) || !test(AtomCoord[6]))
5646 Uvar = TRUE;
5647 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
5648
5649 l=strlen(AtomCoord[0]);
5650 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
5651 if(!strcmp(AtomCoord[0],"Da")) sprintf(AtomCoord[0],"X");
5652 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5653 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5654 Geomtemp[Ncent-1].mmType = g_strdup(type);
5655 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5656 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5657
5658 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5659 Geomtemp[Ncent-1].ResidueNumber=0;
5660 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5661 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[4]);
5662 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[2]);
5663 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[5]);
5664 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[3]);
5665 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
5666 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5667 }/*end switch*/
5668 }/*end while*/
5669 /* Variables */
5670 Nvar=0;
5671 fseek(file, 0L, SEEK_SET);
5672 if(Uvar)
5673 {
5674 OK =FALSE;
5675 while(!feof(file) && Uvar)
5676 {
5677 if(!fgets(t,taille,file)) break;
5678 uppercase(t);
5679 if(strstr(t,"PARAS"))
5680 {
5681 OK = TRUE;
5682 break;
5683 }
5684 }
5685 }
5686 while(!feof(file) && Uvar && OK )
5687 {
5688 uppercase(t);
5689 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
5690 for(j=0;j<Ncent;j++)
5691 {
5692 gchar* co[3] = {Geomtemp[j].R,Geomtemp[j].Angle,Geomtemp[j].Dihedral};
5693 for(k=0;k<3;k++)
5694 if(!test(co[k]))
5695 {
5696 gchar* b = strstr(t,co[k]);
5697 if(b)
5698 {
5699 b = b+strlen(co[k])+1;
5700 Nvar++;
5701 if(Nvar==1) Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
5702 else Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
5703 Variablestemp[Nvar-1].Name=g_strdup(co[k]);
5704 Variablestemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
5705 Variablestemp[Nvar-1].Used=TRUE;
5706 }
5707 }
5708 }
5709 if(strstr(t,"END")) break;
5710 { char* e = fgets(t,taille,file);}
5711 }
5712 /* end while variables */
5713 fclose(file);
5714 if(OK)
5715 {
5716 TotalCharges[0] = globalCharge;
5717 SpinMultiplicities[0] = mult;
5718 }
5719
5720 g_free(t);
5721 for(i=0;i<7;i++) g_free(AtomCoord[i]);
5722 if( !OK || Ncent <1 )
5723 {
5724 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
5725 MessageGeom(_("Sorry\n I can not read geometry in Q-Chem input file"),_("Error"),TRUE);
5726 return;
5727 }
5728 if(Geom) freeGeom();
5729 if(Variables) freeVariables();
5730 Geom = Geomtemp;
5731 NcentersZmat = Ncent;
5732 NVariables = Nvar;
5733 Variables = Variablestemp;
5734 MethodeGeom = GEOM_IS_ZMAT;
5735 if( Units== 0 ) Geom_Change_Unit(FALSE);
5736 if(GeomIsOpen)
5737 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
5738
5739 if(GeomDrawingArea != NULL) rafresh_drawing();
5740 set_last_directory(NomFichier);
5741 }
5742 /*************************************************************************************/
read_Zmat_from_qchem_input_file(gchar * NomFichier)5743 void read_Zmat_from_qchem_input_file(gchar *NomFichier)
5744 {
5745 gchar *t;
5746 gboolean OK;
5747 gchar *AtomCoord[7];
5748 FILE *fd;
5749 guint taille=BSIZE;
5750 guint i;
5751 gint j;
5752 gboolean Uvar=FALSE;
5753 GeomAtomDef* Geomtemp=NULL;
5754 gint Ncent = 0;
5755 gint Nvar = 0;
5756 VariablesDef* Variablestemp=NULL;
5757 gchar symb[BSIZE];
5758 gchar type[BSIZE];
5759 gchar charge[BSIZE];
5760
5761 if ( strcmp(NomFichier,"") == 0 ) return;
5762
5763 for(i=0;i<7;i++)
5764 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
5765
5766
5767 t=g_malloc(taille);
5768 fd = FOpen(NomFichier, "rb");
5769 OK=TRUE;
5770 if(fd!=NULL)
5771 {
5772 while(!feof(fd))
5773 {
5774 if(!fgets(t,taille,fd))
5775 {
5776 OK = FALSE;
5777 break;
5778 }
5779 uppercase(t);
5780 if(strstr(t,"$MOLECULE"))
5781 {
5782 { char* e = fgets(t,taille,fd);} /* charge and spin */
5783 OK = TRUE;
5784 break;
5785 }
5786 }
5787 if(OK) { char* e = fgets(t,taille,fd);}
5788 i = sscanf(t,"%s",AtomCoord[0]);
5789 if(i != 1)
5790 OK = FALSE;
5791 else
5792 {
5793 Ncent++;
5794 Geomtemp=g_malloc(sizeof(GeomAtomDef));
5795 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_0;
5796
5797 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5798 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5799 Geomtemp[Ncent-1].mmType = g_strdup(type);
5800 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5801 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5802
5803 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5804 Geomtemp[Ncent-1].ResidueNumber=0;
5805 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5806 }
5807 j=-1;
5808 while(!feof(fd) && OK )
5809 {
5810 j++;
5811 { char* e = fgets(t,taille,fd);}
5812 if(strstr(t,"$end")) break;
5813 if(t[0] == '\n') break;
5814 for(i=0;i<strlen(t);i++)
5815 if(t[i] != ' ') break;
5816 if(i == strlen(t)-1) break;
5817 for(i=0;i<strlen(t);i++) if(t[i] ==',') t[i] = ' ';
5818
5819 i = sscanf(t,"%s ",AtomCoord[0]);
5820 if(i != 1)
5821 {
5822 OK = FALSE;
5823 break;
5824 }
5825 if( !strcmp(AtomCoord[0],"Variables") )
5826 {
5827 Uvar = TRUE;
5828 break;
5829 }
5830 Ncent++;
5831 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5832 switch( Ncent ){
5833 case 2 :
5834 i = sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]);
5835 if( i != 3 )
5836 {
5837 Ncent--;
5838 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5839 OK = FALSE;
5840 }
5841 if( !test(AtomCoord[2]) )
5842 Uvar = TRUE;
5843 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_R;
5844
5845 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5846 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5847 Geomtemp[Ncent-1].mmType = g_strdup(type);
5848 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5849 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5850
5851 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5852 Geomtemp[Ncent-1].ResidueNumber=0;
5853 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5854 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5855 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5856 break;
5857 case 3 :
5858 i = sscanf(
5859 t,"%s %s %s %s %s ",
5860 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5861 AtomCoord[3],AtomCoord[4]
5862 );
5863 if(i != 5)
5864 {
5865 Ncent--;
5866 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5867 OK = FALSE;
5868 }
5869 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) )
5870 Uvar = TRUE;
5871 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_ANGLE;
5872
5873 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5874 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5875 Geomtemp[Ncent-1].mmType = g_strdup(type);
5876 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5877 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5878
5879 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5880 Geomtemp[Ncent-1].ResidueNumber=0;
5881 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5882 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5883 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
5884 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
5885 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5886 break;
5887 default :
5888 i = sscanf(
5889 t,"%s %s %s %s %s %s %s",
5890 AtomCoord[0],AtomCoord[1],AtomCoord[2],
5891 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
5892 );
5893 if( i!= 7)
5894 {
5895 Ncent--;
5896 Geomtemp=g_realloc(Geomtemp,Ncent*sizeof(GeomAtomDef));
5897 OK = FALSE;
5898 }
5899 if(!test(AtomCoord[2]) || !test(AtomCoord[4]) || !test(AtomCoord[6]))
5900 Uvar = TRUE;
5901 Geomtemp[Ncent-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
5902
5903 get_symb_type_charge(AtomCoord[0],symb,type,charge);
5904 Geomtemp[Ncent-1].Symb = g_strdup(symb);
5905 Geomtemp[Ncent-1].mmType = g_strdup(type);
5906 Geomtemp[Ncent-1].pdbType = g_strdup(type);
5907 Geomtemp[Ncent-1].Charge=g_strdup(charge);
5908
5909 Geomtemp[Ncent-1].Residue=g_strdup("DUM");
5910 Geomtemp[Ncent-1].ResidueNumber=0;
5911 Geomtemp[Ncent-1].NR=g_strdup(AtomCoord[1]);
5912 Geomtemp[Ncent-1].R=g_strdup(AtomCoord[2]);
5913 Geomtemp[Ncent-1].NAngle=g_strdup(AtomCoord[3]);
5914 Geomtemp[Ncent-1].Angle=g_strdup(AtomCoord[4]);
5915 Geomtemp[Ncent-1].NDihedral=g_strdup(AtomCoord[5]);
5916 Geomtemp[Ncent-1].Dihedral=g_strdup(AtomCoord[6]);
5917 Geomtemp[Ncent-1].Layer=g_strdup(" ");
5918 }/*end switch*/
5919 }/*end while*/
5920 /* Variables */
5921 Nvar=0;
5922 while(!feof(fd) && Uvar && OK )
5923 {
5924 { char* e = fgets(t,taille,fd);}
5925 OK=TRUE;
5926 if(strstr(t,"$end")) break;
5927 for(i=0;i<strlen(t)-1;i++)
5928 if ( (int)t[i] != (int)' ' )
5929 OK=FALSE;
5930 if(OK)
5931 break;
5932 else
5933 {
5934 Nvar++;
5935 if(Nvar==1)
5936 Variablestemp = g_malloc(Nvar*sizeof(VariablesDef));
5937 else
5938 Variablestemp = g_realloc(Variablestemp,Nvar*sizeof(VariablesDef));
5939 Variablestemp[Nvar-1].Name=NULL;
5940 Variablestemp[Nvar-1].Value=NULL;
5941 for(i=0;i<strlen(t);i++) if(t[i] =='=') t[i] = ' ';
5942 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
5943 if( i == 2)
5944 {
5945 Variablestemp[Nvar-1].Name=g_strdup(AtomCoord[0]);
5946 Variablestemp[Nvar-1].Value=g_strdup(AtomCoord[1]);
5947 Variablestemp[Nvar-1].Used=TRUE;
5948 OK = TRUE;
5949 }
5950 else
5951 {
5952 OK = FALSE;
5953 }
5954 }
5955 }
5956 /* end while variables */
5957 fclose(fd);
5958 }
5959 else
5960 OK = FALSE;
5961
5962 g_free(t);
5963 for(i=0;i<7;i++)
5964 g_free(AtomCoord[i]);
5965 if( !OK || Ncent <1 )
5966 {
5967 FreeGeom(Geomtemp,Variablestemp,Ncent,Nvar);
5968 MessageGeom(_("Sorry\n I can not read geometry in Q-Chem input file"),_("Error"),TRUE);
5969 return;
5970 }
5971 if(Geom)
5972 freeGeom();
5973 if(Variables)
5974 freeVariables();
5975 Geom = Geomtemp;
5976 NcentersZmat = Ncent;
5977 NVariables = Nvar;
5978 Variables = Variablestemp;
5979 MethodeGeom = GEOM_IS_ZMAT;
5980 if( Units== 0 ) Geom_Change_Unit(FALSE);
5981 if(GeomIsOpen)
5982 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
5983
5984 if(GeomDrawingArea != NULL)
5985 rafresh_drawing();
5986 set_last_directory(NomFichier);
5987 }
5988 /********************************************************************************/
get_charge_and_multiplicity_from_mopac_input_file(FILE * fd)5989 static void get_charge_and_multiplicity_from_mopac_input_file(FILE* fd)
5990 {
5991 guint taille=BSIZE;
5992 gchar t[BSIZE];
5993 gint i;
5994
5995 TotalCharges[0] = 0;
5996 SpinMultiplicities[0] =1;
5997
5998 fseek(fd, 0L, SEEK_SET);
5999 while(!feof(fd) )
6000 {
6001 if(!fgets(t, taille, fd)) return;
6002 if(t[0] !='*') break;
6003 }
6004 for(i=0;i<2;i++)
6005 {
6006 uppercase(t);
6007 if ( strstr(t,"CHARGE") && strstr(t,"="))
6008 {
6009 gchar* tt = strstr(t,"CHARGE");
6010 gchar* p = strstr(tt,"=")+1;
6011 if(p) TotalCharges[0] = atoi(p);
6012 }
6013 if ( strstr(t,"SINGLET")) SpinMultiplicities[0] = 1;
6014 if ( strstr(t,"DOUBLET")) SpinMultiplicities[0] = 2;
6015 if ( strstr(t,"TRIPLET")) SpinMultiplicities[0] = 3;
6016 if ( strstr(t,"QUARTET")) SpinMultiplicities[0] = 4;
6017 if ( strstr(t,"QUINTET")) SpinMultiplicities[0] = 5;
6018 if ( strstr(t,"SEXTET")) SpinMultiplicities[0] = 6;
6019 if(!fgets(t,taille,fd)) break;
6020 }
6021 }
6022 /*************************************************************************************/
read_Zmat_from_mopac_input_file(gchar * FileName)6023 void read_Zmat_from_mopac_input_file(gchar *FileName)
6024 {
6025 gchar *t;
6026 gboolean OK;
6027 gchar *AtomCoord[10];
6028 FILE *fd;
6029 guint taille=BSIZE;
6030 guint i,l;
6031
6032 for(i=0;i<10;i++)
6033 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
6034 fd = FOpen(FileName, "rb");
6035 if(fd == NULL)
6036 {
6037 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
6038 MessageGeom(t,_("Error"),TRUE);
6039 g_free(t);
6040 return;
6041 }
6042 t=g_malloc(taille);
6043 OK = TRUE;
6044 while(!feof(fd) )
6045 {
6046 if(!fgets(t, taille, fd))break;
6047 if(t[0] !='*') break;
6048 }
6049 if(!fgets(t,taille,fd)) OK = FALSE;
6050 if(!fgets(t,taille,fd)) OK = FALSE;
6051 if(!fgets(t,taille,fd)) OK = FALSE;
6052 if(!OK)
6053 {
6054 g_free(t);
6055 t = g_strdup_printf(_("Sorry\n I can not read geometry from \"%s\" file"),FileName);
6056 MessageGeom(t,_("Error"),TRUE);
6057 g_free(t);
6058 return;
6059 }
6060 if( get_info_one_center(t,AtomCoord) == EOF)
6061 {
6062 MessageGeom(_("Sorry\n I can not read geometry from this file"),_("Error"),TRUE);
6063 g_free(t);
6064 for(i=0;i<10;i++)
6065 g_free(AtomCoord[i]);
6066 freeGeom();
6067 freeVariables();
6068 fclose(fd);
6069 return;
6070 }
6071 freeGeom();
6072 freeVariables();
6073 NcentersZmat=0;
6074 NcentersZmat++;
6075 Geom=g_malloc(sizeof(GeomAtomDef));
6076 set_center(AtomCoord);
6077
6078 while(!feof(fd) )
6079 {
6080 { char* e = fgets(t,taille,fd);}
6081 if(feof(fd)) break;
6082 if(this_is_a_backspace(t)) break;
6083 if( get_info_one_center(t,AtomCoord) == EOF) break;
6084 NcentersZmat++;
6085 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
6086 set_center(AtomCoord);
6087 i = NcentersZmat-1;
6088 if(NcentersZmat>0 && atoi(AtomCoord[2])==1)trans_coord_Zmat('R',i,FALSE);
6089 if(NcentersZmat>1 && atoi(AtomCoord[4])==1)trans_coord_Zmat('A',i,FALSE);
6090 if(NcentersZmat>2 && atoi(AtomCoord[6])==1)trans_coord_Zmat('D',i,FALSE);
6091 }
6092 fseek(fd, 0L, SEEK_SET);
6093 get_charge_and_multiplicity_from_mopac_input_file(fd);
6094
6095 fclose(fd);
6096 for(i=0;i<10;i++)
6097 g_free(AtomCoord[i]);
6098 for (i=0;i<NcentersZmat;i++)
6099 {
6100 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
6101 l=strlen(Geom[i].Symb);
6102 if (l==2) Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
6103 if(l<3) t=g_strdup(Geom[i].Symb);
6104 else
6105 {
6106 t[0]=Geom[i].Symb[0];
6107 t[1]=Geom[i].Symb[1];
6108 }
6109 if(ThisIsNotAnAtom(t))
6110 {
6111 MessageGeom(_("Sorry\n This is not a Zmatrix mopac file"),_("Error"),TRUE);
6112 g_free(t);
6113 freeGeom();
6114 freeVariables();
6115 return;
6116 }
6117 }
6118 g_free(t);
6119 if(Units==0)
6120 for (i=1;i<NcentersZmat;i++)
6121 Geom[i].R=ang_to_bohr(Geom[i].R);
6122
6123 MethodeGeom = GEOM_IS_ZMAT;
6124 if(GeomIsOpen)
6125 {
6126 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
6127 clearList(list);
6128 append_list_geom();
6129 append_list_variables();
6130 }
6131 if(GeomDrawingArea != NULL) rafresh_drawing();
6132 if(GeomIsOpen && iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
6133 }
6134 /********************************************************************************/
get_charge_and_multiplicity_from_mopac_output_file(FILE * fd)6135 static void get_charge_and_multiplicity_from_mopac_output_file(FILE* fd)
6136 {
6137 guint taille=BSIZE;
6138 gchar t[BSIZE];
6139
6140 TotalCharges[0] = 0;
6141 SpinMultiplicities[0] =1;
6142
6143 while(!feof(fd) )
6144 {
6145 if(!fgets(t,taille,fd)) break;
6146 if ( strstr(t,"CHARGE ON SYSTEM") && strstr(t,"="))
6147 {
6148 gchar* p = strstr(t,"=")+1;
6149 TotalCharges[0] = atoi(p);
6150 }
6151 if ( strstr(t,"SPIN STATE DEFINED AS A"))
6152 {
6153 if ( strstr(t,"SINGLET")) SpinMultiplicities[0] = 1;
6154 if ( strstr(t,"DOUBLET")) SpinMultiplicities[0] = 2;
6155 if ( strstr(t,"TRIPLET")) SpinMultiplicities[0] = 3;
6156 if ( strstr(t,"QUARTET")) SpinMultiplicities[0] = 4;
6157 if ( strstr(t,"QUINTET")) SpinMultiplicities[0] = 5;
6158 if ( strstr(t,"SEXTET")) SpinMultiplicities[0] = 6;
6159 }
6160 }
6161 }
6162 /********************************************************************************/
read_Zmat_from_mopac_irc_output_file(gchar * FileName,gint numGeom)6163 void read_Zmat_from_mopac_irc_output_file(gchar *FileName, gint numGeom)
6164 {
6165 gchar *t;
6166 gboolean OK;
6167 gchar *AtomCoord[10];
6168 FILE *fd;
6169 guint taille=BSIZE;
6170 guint i,l;
6171
6172 for(i=0;i<10;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
6173 fd = FOpen(FileName, "rb");
6174 if(fd == NULL)
6175 {
6176 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
6177 MessageGeom(t,_("Error"),TRUE);
6178 g_free(t);
6179 return;
6180 }
6181 t=g_malloc(taille);
6182 OK = TRUE;
6183 i = 0;
6184 while(!feof(fd) )
6185 {
6186 if(!fgets(t, taille, fd))break;
6187 if(
6188 strstr(t,"POTENTIAL") &&
6189 strstr(t,"LOST") &&
6190 strstr(t,"TOTAL")
6191 )
6192 {
6193 i++;
6194 if(i==numGeom)break;
6195 }
6196 }
6197 if(i==0) OK = FALSE;
6198 while(!feof(fd) && OK )
6199 {
6200 if(!fgets(t, taille, fd))OK = FALSE;
6201 if(strstr(t,"FINAL")&& strstr(t,"GEOMETRY")&& strstr(t,"OBTAINED"))
6202 {
6203 if(!fgets(t, taille, fd))OK = FALSE;
6204 if(!fgets(t, taille, fd))OK = FALSE;
6205 if(!fgets(t, taille, fd))OK = FALSE;
6206 if(!fgets(t, taille, fd))OK = FALSE;
6207 break;
6208 }
6209 }
6210 if(!OK ||1!=sscanf(t,"%s", AtomCoord[0]))
6211 {
6212 g_free(t);
6213 t = g_strdup_printf(_("Sorry\n I can not read geometry from \"%s\" file"),FileName);
6214 MessageGeom(t,_("Error"),TRUE);
6215 g_free(t);
6216 for(i=0;i<10;i++)
6217 g_free(AtomCoord[i]);
6218 freeGeom();
6219 freeVariables();
6220 fclose(fd);
6221 return;
6222 return;
6223 }
6224 freeGeom();
6225 freeVariables();
6226 NcentersZmat=0;
6227 NcentersZmat++;
6228 Geom=g_malloc(sizeof(GeomAtomDef));
6229 set_center(AtomCoord);
6230
6231 while(!feof(fd) )
6232 {
6233 if(!fgets(t,taille,fd))break;
6234 if(feof(fd)) break;
6235 if(this_is_a_backspace(t)) break;
6236 if(1!=sscanf(t,"%s", AtomCoord[0])) break;
6237 if(NcentersZmat==1)
6238 {
6239 if(3!=sscanf(t,"%s %s %s", AtomCoord[0],AtomCoord[1],AtomCoord[2])) break;
6240 sprintf(AtomCoord[7],"%d", 1);
6241 }
6242 else
6243 if( get_info_one_center(t,AtomCoord) == EOF) break;
6244 NcentersZmat++;
6245 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
6246 set_center(AtomCoord);
6247 i = NcentersZmat-1;
6248 if(NcentersZmat>1 && atoi(AtomCoord[2])==1)trans_coord_Zmat('R',i,FALSE);
6249 if(NcentersZmat>2 && atoi(AtomCoord[4])==1)trans_coord_Zmat('A',i,FALSE);
6250 if(NcentersZmat>3 && atoi(AtomCoord[6])==1)trans_coord_Zmat('D',i,FALSE);
6251 }
6252 fseek(fd, 0L, SEEK_SET);
6253 get_charge_and_multiplicity_from_mopac_output_file(fd);
6254
6255 fclose(fd);
6256 for(i=0;i<10;i++)
6257 g_free(AtomCoord[i]);
6258 for (i=0;i<NcentersZmat;i++)
6259 {
6260 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
6261 l=strlen(Geom[i].Symb);
6262 if (l==2) Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
6263 if(l<3) t=g_strdup(Geom[i].Symb);
6264 else
6265 {
6266 t[0]=Geom[i].Symb[0];
6267 t[1]=Geom[i].Symb[1];
6268 }
6269 if(ThisIsNotAnAtom(t))
6270 {
6271 MessageGeom(_("Sorry\n This is not a Zmatrix mopac file"),_("Error"),TRUE);
6272 g_free(t);
6273 freeGeom();
6274 freeVariables();
6275 return;
6276 }
6277 }
6278 g_free(t);
6279 if(Units==0)
6280 for (i=1;i<NcentersZmat;i++)
6281 Geom[i].R=ang_to_bohr(Geom[i].R);
6282
6283 MethodeGeom = GEOM_IS_ZMAT;
6284 if(GeomIsOpen)
6285 {
6286 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
6287 clearList(list);
6288 append_list_geom();
6289 append_list_variables();
6290 }
6291 if(GeomDrawingArea != NULL) rafresh_drawing();
6292 if(GeomIsOpen && iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
6293 }
6294 /********************************************************************************/
read_Zmat_from_mopac_scan_output_file(gchar * FileName,gint numGeom)6295 void read_Zmat_from_mopac_scan_output_file(gchar *FileName, gint numGeom)
6296 {
6297 gchar *t;
6298 gboolean OK;
6299 gchar *AtomCoord[10];
6300 FILE *fd;
6301 guint taille=BSIZE;
6302 guint i,l;
6303
6304 for(i=0;i<10;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
6305 fd = FOpen(FileName, "rb");
6306 if(fd == NULL)
6307 {
6308 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
6309 MessageGeom(t,_("Error"),TRUE);
6310 g_free(t);
6311 return;
6312 }
6313 t=g_malloc(taille);
6314 OK = TRUE;
6315 i = 0;
6316 while(!feof(fd) )
6317 {
6318 if(!fgets(t, taille, fd))break;
6319 if(
6320 strstr(t,"VARIABLE") &&
6321 strstr(t,"FUNCTION")
6322 )
6323 {
6324 i++;
6325 if(i==numGeom)break;
6326 }
6327 }
6328 if(i==0) OK = FALSE;
6329 if(OK && !fgets(t, taille, fd))OK = FALSE; /* Values */
6330 while(!feof(fd) && OK )
6331 {
6332 if(!fgets(t, taille, fd))OK = FALSE;
6333 if(t[0] != '*') break; /* Keywords */
6334 }
6335 if(!fgets(t,taille,fd)) OK = FALSE;
6336 if(!fgets(t,taille,fd)) OK = FALSE;
6337 if(!OK)
6338 {
6339 g_free(t);
6340 t = g_strdup_printf(_("Sorry\n I can not read geometry from \"%s\" file"),FileName);
6341 MessageGeom(t,_("Error"),TRUE);
6342 g_free(t);
6343 return;
6344 }
6345 if(!fgets(t,taille,fd)) OK = FALSE;
6346 if( !OK || 1!=sscanf(t,"%s", AtomCoord[0]))
6347 {
6348 MessageGeom(_("Sorry\n I can not read geometry from this file"),_("Error"),TRUE);
6349 g_free(t);
6350 for(i=0;i<10;i++)
6351 g_free(AtomCoord[i]);
6352 freeGeom();
6353 freeVariables();
6354 fclose(fd);
6355 return;
6356 }
6357 freeGeom();
6358 freeVariables();
6359 NcentersZmat=0;
6360 NcentersZmat++;
6361 Geom=g_malloc(sizeof(GeomAtomDef));
6362 set_center(AtomCoord);
6363
6364 while(!feof(fd) )
6365 {
6366 if(!fgets(t,taille,fd))break;
6367 if(feof(fd)) break;
6368 if(this_is_a_backspace(t)) break;
6369 if(NcentersZmat==1)
6370 {
6371 if(3!=sscanf(t,"%s %s %s", AtomCoord[0],AtomCoord[1],AtomCoord[2])) break;
6372 sprintf(AtomCoord[7],"%d", 1);
6373 }
6374 else
6375 if( get_info_one_center(t,AtomCoord) == EOF) break;
6376 NcentersZmat++;
6377 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
6378 set_center(AtomCoord);
6379 i = NcentersZmat-1;
6380 if(NcentersZmat>1 && atoi(AtomCoord[2])==1)trans_coord_Zmat('R',i,FALSE);
6381 if(NcentersZmat>2 && atoi(AtomCoord[4])==1)trans_coord_Zmat('A',i,FALSE);
6382 if(NcentersZmat>3 && atoi(AtomCoord[6])==1)trans_coord_Zmat('D',i,FALSE);
6383 }
6384 fseek(fd, 0L, SEEK_SET);
6385 get_charge_and_multiplicity_from_mopac_output_file(fd);
6386
6387 fclose(fd);
6388 for(i=0;i<10;i++)
6389 g_free(AtomCoord[i]);
6390 for (i=0;i<NcentersZmat;i++)
6391 {
6392 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
6393 l=strlen(Geom[i].Symb);
6394 if (l==2) Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
6395 if(l<3) t=g_strdup(Geom[i].Symb);
6396 else
6397 {
6398 t[0]=Geom[i].Symb[0];
6399 t[1]=Geom[i].Symb[1];
6400 }
6401 if(ThisIsNotAnAtom(t))
6402 {
6403 MessageGeom(_("Sorry\n This is not a Zmatrix mopac file"),_("Error"),TRUE);
6404 g_free(t);
6405 freeGeom();
6406 freeVariables();
6407 return;
6408 }
6409 }
6410 g_free(t);
6411 if(Units==0)
6412 for (i=1;i<NcentersZmat;i++)
6413 Geom[i].R=ang_to_bohr(Geom[i].R);
6414
6415 MethodeGeom = GEOM_IS_ZMAT;
6416 if(GeomIsOpen)
6417 {
6418 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
6419 clearList(list);
6420 append_list_geom();
6421 append_list_variables();
6422 }
6423 if(GeomDrawingArea != NULL) rafresh_drawing();
6424 if(GeomIsOpen && iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
6425 }
6426 /*************************************************************************************/
read_ZMatrix_file_no_add_list(gchar * NomFichier)6427 void read_ZMatrix_file_no_add_list(gchar* NomFichier)
6428 {
6429 gchar *t;
6430 gboolean OK;
6431 gchar *AtomCoord[7];
6432 FILE *fd;
6433 guint taille=BSIZE;
6434 guint i,l;
6435
6436 for(i=0;i<7;i++)
6437 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
6438
6439 t=g_malloc(taille);
6440 fd = FOpen(NomFichier, "rb");
6441 if(fd!=NULL)
6442 {
6443 { char* e = fgets(t,taille,fd);}
6444 sscanf(t,"%s",AtomCoord[0]);
6445 if ( strcmp(NomFichier,"") == 0 )
6446 return;
6447 else
6448 {
6449 freeGeom();
6450 freeVariables();
6451 NcentersZmat=0;
6452 NcentersZmat++;
6453 Geom=g_malloc(sizeof(GeomAtomDef));
6454 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_0;
6455 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6456 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6457 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6458 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6459 Geom[NcentersZmat-1].ResidueNumber=0;
6460 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6461 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6462 }
6463 while(!feof(fd) )
6464 {
6465 { char* e = fgets(t,taille,fd);}
6466 sscanf(t,"%s",AtomCoord[0]);
6467 OK=TRUE;
6468 for(i=0;i<strlen(t)-1;i++)
6469 if ( (int)t[i] != (int)' ' )
6470 OK=FALSE;
6471 if(OK)
6472 break;
6473 else
6474 {
6475 NcentersZmat++;
6476 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
6477 switch( NcentersZmat ){
6478 case 2 :
6479 if(sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]) ==EOF )
6480 {
6481 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6482 g_free(t);
6483 for(i=0;i<7;i++)
6484 g_free(AtomCoord[i]);
6485 freeGeom();
6486 freeVariables();
6487 fclose(fd);
6488 return;
6489 };
6490 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_R;
6491 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6492 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6493 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6494 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6495 Geom[NcentersZmat-1].ResidueNumber=0;
6496 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6497 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6498 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6499 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6500 break;
6501 case 3 :
6502 if( sscanf(
6503 t,"%s %s %s %s %s ",
6504 AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3],AtomCoord[4]
6505 ) ==EOF
6506 )
6507 {
6508 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6509 g_free(t);
6510 for(i=0;i<7;i++)
6511 g_free(AtomCoord[i]);
6512 freeGeom();
6513 freeVariables();
6514 fclose(fd);
6515 return;
6516 };
6517 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_ANGLE;
6518 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6519 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6520 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6521 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6522 Geom[NcentersZmat-1].ResidueNumber=0;
6523 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6524 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6525 Geom[NcentersZmat-1].NAngle=g_strdup(AtomCoord[3]);
6526 Geom[NcentersZmat-1].Angle=g_strdup(AtomCoord[4]);
6527 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6528 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6529 break;
6530 default :
6531 if( sscanf(
6532 t,"%s %s %s %s %s %s %s",
6533 AtomCoord[0],AtomCoord[1],AtomCoord[2],
6534 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
6535 )==EOF
6536 )
6537 {
6538 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6539 g_free(t);
6540 for(i=0;i<7;i++)
6541 g_free(AtomCoord[i]);
6542 freeGeom();
6543 freeVariables();
6544 fclose(fd);
6545 return;
6546 };
6547 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
6548 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6549 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6550 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6551 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6552 Geom[NcentersZmat-1].ResidueNumber=0;
6553 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6554 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6555 Geom[NcentersZmat-1].NAngle=g_strdup(AtomCoord[3]);
6556 Geom[NcentersZmat-1].Angle=g_strdup(AtomCoord[4]);
6557 Geom[NcentersZmat-1].NDihedral=g_strdup(AtomCoord[5]);
6558 Geom[NcentersZmat-1].Dihedral=g_strdup(AtomCoord[6]);
6559 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6560 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6561 }
6562 }
6563 }
6564 /* Variable */
6565 NVariables=0;
6566 while(!feof(fd) )
6567 {
6568 { char* e = fgets(t,taille,fd);}
6569 OK=TRUE;
6570 for(i=0;i<strlen(t)-1;i++)
6571 if ( (int)t[i] != (int)' ' )
6572 OK=FALSE;
6573 if(OK)
6574 break;
6575 else
6576 {
6577 NVariables++;
6578 if(NVariables==1)
6579 Variables = g_malloc(NVariables*sizeof(VariablesDef));
6580 else
6581 Variables = g_realloc(Variables,NVariables*sizeof(VariablesDef));
6582 sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
6583 Variables[NVariables-1].Name=g_strdup(AtomCoord[0]);
6584 Variables[NVariables-1].Value=g_strdup(AtomCoord[1]);
6585 Variables[NVariables-1].Used=TRUE;
6586 }
6587 }
6588 /* end while variables */
6589 fclose(fd);
6590 }
6591 for(i=0;i<7;i++)
6592 g_free(AtomCoord[i]);
6593 for (i=0;i<NcentersZmat;i++)
6594 {
6595 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
6596 l=strlen(Geom[i].Symb);
6597 if (l==2)
6598 Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
6599 if(l<3)
6600 t=g_strdup(Geom[i].Symb);
6601 else
6602 {
6603 t[0]=Geom[i].Symb[0];
6604 t[1]=Geom[i].Symb[1];
6605 }
6606 if(ThisIsNotAnAtom(t))
6607 {
6608 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6609 g_free(t);
6610 freeGeom();
6611 freeVariables();
6612 return;
6613 }
6614 }
6615 g_free(t);
6616 if(Units==0)
6617 for (i=1;i<NcentersZmat;i++)
6618 {
6619 if(test(Geom[i].R))
6620 Geom[i].R=ang_to_bohr(Geom[i].R);
6621 else
6622 {
6623 l= get_num_variableZmat(Geom[i].R);
6624 Variables[l].Value=ang_to_bohr(Variables[l].Value);
6625 }
6626
6627 }
6628 if(GeomIsOpen)
6629 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
6630 else
6631 {
6632 switch(iprogram)
6633 {
6634 case PROG_IS_MOLPRO :
6635 insert_molpro(2);
6636 break;
6637 case PROG_IS_GAUSS :
6638 insert_gaussian(2);
6639 break;
6640 default :
6641 edit_geometry();
6642 }
6643 }
6644 if(GeomDrawingArea != NULL)
6645 rafresh_drawing();
6646 }
6647 /********************************************************************************/
read_ZMatrix_file(GabeditFileChooser * SelecteurFichier,gint response_id)6648 void read_ZMatrix_file(GabeditFileChooser *SelecteurFichier, gint response_id)
6649 {
6650 gchar *t;
6651 char *NomFichier=NULL;
6652 gboolean OK;
6653 gchar *AtomCoord[7];
6654 FILE *fd;
6655 guint taille=BSIZE;
6656 guint i,l;
6657 gchar *projectname = NULL;
6658 gchar *datafile = NULL;
6659 gchar *localdir = NULL;
6660 gchar *remotehost = NULL;
6661 gchar *remoteuser = NULL;
6662 gchar *remotepass = NULL;
6663 gchar *remotedir = NULL;
6664 gchar *temp = NULL;
6665
6666 if(response_id != GTK_RESPONSE_OK) return;
6667 for(i=0;i<7;i++)
6668 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
6669 NomFichier = gabedit_file_chooser_get_current_file(SelecteurFichier);
6670 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
6671 {
6672 MessageGeom(_("Sorry\n No file selected"),_("Warning"),TRUE);
6673 return ;
6674 }
6675
6676 t=g_malloc(taille);
6677 fd = FOpen(NomFichier, "rb");
6678 NcentersZmat=0;
6679 if(fd!=NULL)
6680 {
6681 { char* e = fgets(t,taille,fd);}
6682 sscanf(t,"%s",AtomCoord[0]);
6683 if ( strcmp(NomFichier,"") == 0 )
6684 return;
6685 else
6686 {
6687 NcentersZmat++;
6688 Geom=g_malloc(sizeof(GeomAtomDef));
6689 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_0;
6690 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6691 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6692 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6693 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6694 Geom[NcentersZmat-1].ResidueNumber=0;
6695 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6696 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6697 }
6698 while(!feof(fd) )
6699 {
6700 { char* e = fgets(t,taille,fd);}
6701 sscanf(t,"%s",AtomCoord[0]);
6702 if(this_is_a_backspace(t)) break;
6703 else
6704 {
6705 NcentersZmat++;
6706 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
6707 switch( NcentersZmat ){
6708 case 2 :
6709 if(sscanf(t,"%s %s %s ",AtomCoord[0],AtomCoord[1],AtomCoord[2]) ==EOF )
6710 {
6711 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6712 g_free(t);
6713 for(i=0;i<7;i++)
6714 g_free(AtomCoord[i]);
6715 freeGeom();
6716 freeVariables();
6717 fclose(fd);
6718 return;
6719 };
6720 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_R;
6721 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6722 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6723 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6724 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6725 Geom[NcentersZmat-1].ResidueNumber=0;
6726 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6727 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6728 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6729 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6730 break;
6731 case 3 :
6732 if( sscanf(
6733 t,"%s %s %s %s %s ",
6734 AtomCoord[0],AtomCoord[1],AtomCoord[2],
6735 AtomCoord[3],AtomCoord[4]
6736 ) ==EOF
6737 )
6738 {
6739 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6740 g_free(t);
6741 for(i=0;i<7;i++)
6742 g_free(AtomCoord[i]);
6743 freeGeom();
6744 freeVariables();
6745 fclose(fd);
6746 return;
6747 };
6748 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_ANGLE;
6749 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6750 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6751 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6752 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6753 Geom[NcentersZmat-1].ResidueNumber=0;
6754 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6755 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6756 Geom[NcentersZmat-1].NAngle=g_strdup(AtomCoord[3]);
6757 Geom[NcentersZmat-1].Angle=g_strdup(AtomCoord[4]);
6758 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6759 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6760 break;
6761 default :
6762 if( sscanf(
6763 t,"%s %s %s %s %s %s %s",
6764 AtomCoord[0],AtomCoord[1],AtomCoord[2],
6765 AtomCoord[3],AtomCoord[4],AtomCoord[5],AtomCoord[6]
6766 )==EOF
6767 )
6768 {
6769 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6770 g_free(t);
6771 for(i=0;i<7;i++)
6772 g_free(AtomCoord[i]);
6773 freeGeom();
6774 freeVariables();
6775 fclose(fd);
6776 return;
6777 };
6778 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
6779 Geom[NcentersZmat-1].Symb=g_strdup(AtomCoord[0]);
6780 Geom[NcentersZmat-1].mmType=g_strdup(AtomCoord[0]);
6781 Geom[NcentersZmat-1].pdbType=g_strdup(AtomCoord[0]);
6782 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6783 Geom[NcentersZmat-1].ResidueNumber=0;
6784 Geom[NcentersZmat-1].NR=g_strdup(AtomCoord[1]);
6785 Geom[NcentersZmat-1].R=g_strdup(AtomCoord[2]);
6786 Geom[NcentersZmat-1].NAngle=g_strdup(AtomCoord[3]);
6787 Geom[NcentersZmat-1].Angle=g_strdup(AtomCoord[4]);
6788 Geom[NcentersZmat-1].NDihedral=g_strdup(AtomCoord[5]);
6789 Geom[NcentersZmat-1].Dihedral=g_strdup(AtomCoord[6]);
6790 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6791 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6792 }
6793 }
6794 }
6795 /* Variable */
6796 NVariables=0;
6797 while(!feof(fd) )
6798 {
6799 { char* e = fgets(t,taille,fd);}
6800 if(this_is_a_backspace(t)) break;
6801 else
6802 {
6803 NVariables++;
6804 if(NVariables==1)
6805 Variables = g_malloc(NVariables*sizeof(VariablesDef));
6806 else
6807 Variables = g_realloc(Variables,NVariables*sizeof(VariablesDef));
6808 sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
6809 Variables[NVariables-1].Name=g_strdup(AtomCoord[0]);
6810 Variables[NVariables-1].Value=g_strdup(AtomCoord[1]);
6811 Variables[NVariables-1].Used=TRUE;
6812 }
6813 }
6814 /* end while variables */
6815 fclose(fd);
6816 }
6817 for(i=0;i<7;i++)
6818 g_free(AtomCoord[i]);
6819 for (i=0;i<NcentersZmat;i++)
6820 {
6821 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
6822 l=strlen(Geom[i].Symb);
6823 if (l==2)
6824 Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
6825 if(l<3)
6826 t=g_strdup(Geom[i].Symb);
6827 else
6828 {
6829 t[0]=Geom[i].Symb[0];
6830 t[1]=Geom[i].Symb[1];
6831 }
6832 if(ThisIsNotAnAtom(t))
6833 {
6834 MessageGeom(_("Sorry\n This is not a Zmatrix file"),_("Error"),TRUE);
6835 g_free(t);
6836 freeGeom();
6837 freeVariables();
6838 return;
6839 }
6840 }
6841 g_free(t);
6842 if(Units==0)
6843 for (i=1;i<NcentersZmat;i++)
6844 {
6845 if(test(Geom[i].R))
6846 Geom[i].R=ang_to_bohr(Geom[i].R);
6847 else
6848 {
6849 l= get_num_variableZmat(Geom[i].R);
6850 Variables[l].Value=ang_to_bohr(Variables[l].Value);
6851 }
6852
6853 }
6854
6855 if(GeomIsOpen)
6856 {
6857 append_list_geom();
6858 append_list_variables();
6859 }
6860 if(GeomDrawingArea != NULL)
6861 rafresh_drawing();
6862 if(iprogram == PROG_IS_GAUSS)
6863 set_spin_of_electrons();
6864
6865 datafile = get_name_file(NomFichier);
6866 temp = get_suffix_name_file(NomFichier);
6867 projectname = get_name_file(temp);
6868 localdir = get_name_dir(temp);
6869 if(lastdirectory)
6870 g_free(lastdirectory);
6871 lastdirectory = g_strdup(localdir);
6872
6873 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_GZMAT],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_GZMAT, NULL, defaultNetWorkProtocol);
6874 g_free(temp);
6875 g_free(datafile);
6876 g_free(projectname);
6877 g_free(localdir);
6878 }
6879 /********************************************************************************/
selc_ZMatrix_file()6880 void selc_ZMatrix_file()
6881 {
6882 GtkWidget *SelecteurFichier;
6883 gchar* patterns[] = {"*.gzmt","*",NULL};
6884
6885
6886 /* Cr�ation du s�lecteur de fichier */
6887 SelecteurFichier = gabedit_file_chooser_new("Read Z-Matrix file", GTK_FILE_CHOOSER_ACTION_OPEN);
6888 gabedit_file_chooser_hide_hidden(GABEDIT_FILE_CHOOSER(SelecteurFichier));
6889 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecteurFichier),patterns);
6890
6891 if(WindowGeom)
6892 gtk_window_set_transient_for(GTK_WINDOW(SelecteurFichier),GTK_WINDOW(WindowGeom));
6893 else
6894 gtk_window_set_transient_for(GTK_WINDOW(SelecteurFichier),GTK_WINDOW(Fenetre));
6895 gtk_window_set_modal (GTK_WINDOW (SelecteurFichier), TRUE);
6896 if(lastdirectory)
6897 {
6898 gchar* t = g_strdup_printf("%s%sdump.gzmt",lastdirectory,G_DIR_SEPARATOR_S);
6899 gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(SelecteurFichier),t);
6900 g_free(t);
6901 }
6902
6903 g_signal_connect (SelecteurFichier, "response", G_CALLBACK (read_ZMatrix_file), GTK_OBJECT(SelecteurFichier));
6904 g_signal_connect (SelecteurFichier, "response", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecteurFichier));
6905
6906 /*
6907 g_signal_connect (SelecteurFichier, "close", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecteurFichier));
6908 */
6909 gtk_widget_show(SelecteurFichier);
6910 }
6911 /********************************************************************************/
get_number_connection(gchar * info[])6912 static gint get_number_connection(gchar* info[])
6913 {
6914 gint n = 0;
6915 /*
6916 gint i;
6917 for(i=2;i<7;i+=2)
6918 if(atoi(info[i])>0)
6919 n++;
6920 */
6921 if(NcentersZmat<=3)
6922 n = NcentersZmat -1;
6923 else
6924 n = 3;
6925 return n;
6926 }
6927 /********************************************************************************/
set_center(gchar * info[])6928 static void set_center(gchar* info[])
6929 {
6930 gint n = get_number_connection(info);
6931
6932 switch(n)
6933 {
6934 case 0 :
6935 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_0;
6936 Geom[NcentersZmat-1].Symb=g_strdup(info[0]);
6937 Geom[NcentersZmat-1].mmType=g_strdup(info[0]);
6938 Geom[NcentersZmat-1].pdbType=g_strdup(info[0]);
6939 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6940 Geom[NcentersZmat-1].ResidueNumber=0;
6941 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6942 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6943 break;
6944 case 1 :
6945 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_R;
6946 Geom[NcentersZmat-1].Symb=g_strdup(info[0]);
6947 Geom[NcentersZmat-1].mmType=g_strdup(info[0]);
6948 Geom[NcentersZmat-1].pdbType=g_strdup(info[0]);
6949 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6950 Geom[NcentersZmat-1].ResidueNumber=0;
6951 Geom[NcentersZmat-1].NR=g_strdup(info[7]);
6952 Geom[NcentersZmat-1].R=g_strdup(info[1]);
6953 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6954 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6955 break;
6956 case 2 :
6957 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_ANGLE;
6958 Geom[NcentersZmat-1].Symb=g_strdup(info[0]);
6959 Geom[NcentersZmat-1].mmType=g_strdup(info[0]);
6960 Geom[NcentersZmat-1].pdbType=g_strdup(info[0]);
6961 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6962 Geom[NcentersZmat-1].ResidueNumber=0;
6963 Geom[NcentersZmat-1].NR=g_strdup(info[7]);
6964 Geom[NcentersZmat-1].R=g_strdup(info[1]);
6965 Geom[NcentersZmat-1].NAngle=g_strdup(info[8]);
6966 Geom[NcentersZmat-1].Angle=g_strdup(info[3]);
6967 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6968 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6969 break;
6970 case 3 :
6971 Geom[NcentersZmat-1].Nentry=NUMBER_ENTRY_DIHEDRAL;
6972 Geom[NcentersZmat-1].Symb=g_strdup(info[0]);
6973 Geom[NcentersZmat-1].mmType=g_strdup(info[0]);
6974 Geom[NcentersZmat-1].pdbType=g_strdup(info[0]);
6975 Geom[NcentersZmat-1].Residue=g_strdup(" ");
6976 Geom[NcentersZmat-1].ResidueNumber=0;
6977 Geom[NcentersZmat-1].NR=g_strdup(info[7]);
6978 Geom[NcentersZmat-1].R=g_strdup(info[1]);
6979 Geom[NcentersZmat-1].NAngle=g_strdup(info[8]);
6980 Geom[NcentersZmat-1].Angle=g_strdup(info[3]);
6981 Geom[NcentersZmat-1].NDihedral=g_strdup(info[9]);
6982 Geom[NcentersZmat-1].Dihedral=g_strdup(info[5]);
6983 Geom[NcentersZmat-1].Charge=g_strdup("0.0");
6984 Geom[NcentersZmat-1].Layer=g_strdup(" ");
6985 break;
6986 }
6987 }
6988 /********************************************************************************/
get_info_one_center(gchar * t,gchar * info[])6989 static gint get_info_one_center(gchar* t, gchar* info[])
6990 {
6991 gint i = sscanf(t,"%s %s %s %s %s %s %s %s %s %s",
6992 info[0],info[1],info[2],info[3],info[4],
6993 info[5],info[6],info[7],info[8],info[9]);
6994
6995 if(i<10)
6996 return EOF;
6997 else
6998 return i;
6999 }
7000 /********************************************************************************/
read_ZMatrix_mopac_file_no_add_list(gchar * FileName)7001 void read_ZMatrix_mopac_file_no_add_list(gchar*FileName)
7002 {
7003 gchar *t;
7004 gboolean OK;
7005 gchar *AtomCoord[10];
7006 FILE *fd;
7007 guint taille=BSIZE;
7008 guint i,l;
7009
7010 for(i=0;i<10;i++)
7011 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
7012 fd = FOpen(FileName, "rb");
7013 if(fd == NULL)
7014 {
7015 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
7016 MessageGeom(t,_("Error"),TRUE);
7017 g_free(t);
7018 return;
7019 }
7020 t=g_malloc(taille);
7021 OK = TRUE;
7022 for(i=0;i<4;i++)
7023 {
7024 { char* e = fgets(t,taille,fd);}
7025 if(feof(fd))
7026 {
7027 OK = FALSE;
7028 break;
7029 }
7030 }
7031 if(!OK)
7032 {
7033 g_free(t);
7034 t = g_strdup_printf(_("Sorry\n I can not read \"%s\" file"),FileName);
7035 MessageGeom(t,_("Error"),TRUE);
7036 g_free(t);
7037 return;
7038 }
7039 if( get_info_one_center(t,AtomCoord) == EOF)
7040 {
7041 MessageGeom(_("Sorry\n This is not a Zmatrix mopac file"),_("Error"),TRUE);
7042 g_free(t);
7043 for(i=0;i<10;i++)
7044 g_free(AtomCoord[i]);
7045 freeGeom();
7046 freeVariables();
7047 fclose(fd);
7048 return;
7049 }
7050 NcentersZmat=0;
7051 NcentersZmat++;
7052 Geom=g_malloc(sizeof(GeomAtomDef));
7053 set_center(AtomCoord);
7054
7055 while(!feof(fd) )
7056 {
7057 { char* e = fgets(t,taille,fd);}
7058 if(feof(fd))
7059 break;
7060 if(this_is_a_backspace(t))
7061 break;
7062 if( get_info_one_center(t,AtomCoord) == EOF)
7063 break;
7064 NcentersZmat++;
7065 Geom=g_realloc(Geom,NcentersZmat*sizeof(GeomAtomDef));
7066 set_center(AtomCoord);
7067 }
7068
7069 /* Variable */
7070 NVariables=0;
7071 fclose(fd);
7072 for(i=0;i<10;i++)
7073 g_free(AtomCoord[i]);
7074 for (i=0;i<NcentersZmat;i++)
7075 {
7076 Geom[i].Symb[0]=toupper(Geom[i].Symb[0]);
7077 l=strlen(Geom[i].Symb);
7078 if (l==2)
7079 Geom[i].Symb[1]=tolower(Geom[i].Symb[1]);
7080 if(l<3)
7081 t=g_strdup(Geom[i].Symb);
7082 else
7083 {
7084 t[0]=Geom[i].Symb[0];
7085 t[1]=Geom[i].Symb[1];
7086 }
7087 if(ThisIsNotAnAtom(t))
7088 {
7089 MessageGeom(_("Sorry\n This is not a Zmatrix mopac file"),_("Error"),TRUE);
7090 g_free(t);
7091 freeGeom();
7092 freeVariables();
7093 return;
7094 }
7095 }
7096 g_free(t);
7097 if(Units==0)
7098 for (i=1;i<NcentersZmat;i++)
7099 {
7100 /* if(test(Geom[i].R))*/
7101 Geom[i].R=ang_to_bohr(Geom[i].R);
7102 /*
7103 else
7104 {
7105 l= get_num_variableZmat(Geom[i].R);
7106 Variables[l].Value=ang_to_bohr(Variables[l].Value);
7107 }
7108 */
7109 }
7110
7111 if(GeomIsOpen)
7112 {
7113 create_geom_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
7114 clearList(list);
7115 append_list_geom();
7116 append_list_variables();
7117 }
7118 else
7119 if(GeomDrawingArea == NULL)
7120 {
7121 switch(iprogram)
7122 {
7123 case PROG_IS_MOLPRO :
7124 insert_molpro(2);
7125 break;
7126 case PROG_IS_GAUSS :
7127 insert_gaussian(2);
7128 break;
7129 default :
7130 edit_geometry();
7131 }
7132 }
7133 if(GeomDrawingArea != NULL)
7134 rafresh_drawing();
7135 if(GeomIsOpen && iprogram == PROG_IS_GAUSS)
7136 set_spin_of_electrons();
7137
7138 }
7139 /********************************************************************************/
read_ZMatrix_mopac_file(GabeditFileChooser * SelecteurFichier,gint response_id)7140 void read_ZMatrix_mopac_file(GabeditFileChooser *SelecteurFichier, gint response_id)
7141 {
7142 gchar *FileName=NULL;
7143 gchar *projectname = NULL;
7144 gchar *datafile = NULL;
7145 gchar *localdir = NULL;
7146 gchar *remotehost = NULL;
7147 gchar *remoteuser = NULL;
7148 gchar *remotepass = NULL;
7149 gchar *remotedir = NULL;
7150 gchar *temp = NULL;
7151
7152 if(response_id != GTK_RESPONSE_OK) return;
7153 FileName = gabedit_file_chooser_get_current_file(SelecteurFichier);
7154 if ((!FileName) || (strcmp(FileName,"") == 0))
7155 {
7156 MessageGeom(_("Sorry\n No file selected"),_("Warning"),TRUE);
7157 return ;
7158 }
7159 read_ZMatrix_mopac_file_no_add_list(FileName);
7160
7161 datafile = get_name_file(FileName);
7162 temp = get_suffix_name_file(FileName);
7163 projectname = get_name_file(temp);
7164 localdir = get_name_dir(temp);
7165 if(lastdirectory)
7166 g_free(lastdirectory);
7167 lastdirectory = g_strdup(localdir);
7168 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_MZMAT],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_MZMAT, NULL, defaultNetWorkProtocol);
7169 g_free(temp);
7170 g_free(datafile);
7171 g_free(projectname);
7172 g_free(localdir);
7173 }
7174 /********************************************************************************/
selc_ZMatrix_mopac_file()7175 void selc_ZMatrix_mopac_file()
7176 {
7177 GtkWidget *SelecteurFichier;
7178 gchar* patterns[] = {"*.zmt","*",NULL};
7179
7180
7181 SelecteurFichier = gabedit_file_chooser_new("Read Mopac Z-Matrix file", GTK_FILE_CHOOSER_ACTION_OPEN);
7182 gabedit_file_chooser_hide_hidden(GABEDIT_FILE_CHOOSER(SelecteurFichier));
7183 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecteurFichier),patterns);
7184
7185 if(WindowGeom)
7186 gtk_window_set_transient_for(GTK_WINDOW(SelecteurFichier),GTK_WINDOW(WindowGeom));
7187 else
7188 gtk_window_set_transient_for(GTK_WINDOW(SelecteurFichier),GTK_WINDOW(Fenetre));
7189 gtk_window_set_modal (GTK_WINDOW (SelecteurFichier), TRUE);
7190 if(lastdirectory)
7191 {
7192 gchar* t = g_strdup_printf("%s%sdump.zmt",lastdirectory,G_DIR_SEPARATOR_S);
7193 gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(SelecteurFichier),t);
7194 g_free(t);
7195 }
7196
7197 g_signal_connect (SelecteurFichier, "response", G_CALLBACK (read_ZMatrix_mopac_file), GTK_OBJECT(SelecteurFichier));
7198 g_signal_connect (SelecteurFichier, "response", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecteurFichier));
7199 /*
7200 g_signal_connect (SelecteurFichier, "close", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecteurFichier));
7201 */
7202 gtk_widget_show(SelecteurFichier);
7203 }
7204 /********************************************************************************/
create_geom_list(GtkWidget * vbox,GabEditTypeFileGeom readfile)7205 void create_geom_list(GtkWidget *vbox, GabEditTypeFileGeom readfile)
7206 {
7207 GtkListStore *store;
7208 GtkTreeModel *model;
7209 GtkCellRenderer *renderer;
7210 GtkTreeViewColumn *column;
7211 GtkWidget *scr;
7212 guint i;
7213 guint Factor=7;
7214 guint widall=0;
7215 gchar *titres[NUMBER_LIST_ZMATRIX]={
7216 "N ","Symbol","MM Type","PDB Type",
7217 "Residue",
7218 "R "," NR ",
7219 "Angle "," NA ",
7220 "Dihedral "," ND ",
7221 "Charge",
7222 "Layer"
7223 };
7224 guint width[NUMBER_LIST_ZMATRIX]={ 4,6,8,8,
7225 8,
7226 10,4,
7227 10,4,
7228 10,4,
7229 10,
7230 8
7231 };
7232 GtkUIManager *manager = NULL;
7233
7234 if(iprogram == PROG_IS_MOLPRO) NCr = NUMBER_LIST_ZMATRIX-1;
7235 else NCr = NUMBER_LIST_ZMATRIX;
7236 NSA[0] = NSA[1] = NSA[2] = NSA[3] =-1;
7237 MethodeGeom = GEOM_IS_ZMAT;
7238
7239 if(readfile != GABEDIT_TYPEFILEGEOM_UNKNOWN) freeGeom();
7240
7241 LineSelected=-1;
7242 for(i=0;(gint)i<NCr;i++) widall+=width[i];
7243 widall=widall*Factor+90;
7244
7245 scr=gtk_scrolled_window_new(NULL,NULL);
7246 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*0.4));
7247 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
7248 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 2);
7249
7250 store = gtk_list_store_new (2*NUMBER_LIST_ZMATRIX,
7251 G_TYPE_STRING, G_TYPE_BOOLEAN,
7252 G_TYPE_STRING, G_TYPE_BOOLEAN,
7253 G_TYPE_STRING, G_TYPE_BOOLEAN,
7254 G_TYPE_STRING, G_TYPE_BOOLEAN,
7255 G_TYPE_STRING, G_TYPE_BOOLEAN,
7256 G_TYPE_STRING, G_TYPE_BOOLEAN,
7257 G_TYPE_STRING, G_TYPE_BOOLEAN,
7258 G_TYPE_STRING, G_TYPE_BOOLEAN,
7259 G_TYPE_STRING, G_TYPE_BOOLEAN,
7260 G_TYPE_STRING, G_TYPE_BOOLEAN,
7261 G_TYPE_STRING, G_TYPE_BOOLEAN,
7262 G_TYPE_STRING, G_TYPE_BOOLEAN,
7263 G_TYPE_STRING, G_TYPE_BOOLEAN
7264 );
7265 model = GTK_TREE_MODEL (store);
7266
7267 list = gtk_tree_view_new_with_model (model);
7268 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), TRUE);
7269 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), TRUE);
7270 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (list), FALSE);
7271 for (i=0;(gint)i<NCr;i++)
7272 {
7273 column = gtk_tree_view_column_new ();
7274 gtk_tree_view_column_set_title (column, titres[i]);
7275 gtk_tree_view_column_set_min_width(column, width[i]*Factor);
7276 gtk_tree_view_column_set_reorderable(column, TRUE);
7277 renderer = gtk_cell_renderer_text_new ();
7278 gtk_tree_view_column_pack_start (column, renderer, TRUE);
7279 gtk_tree_view_column_set_attributes (column, renderer, "text", i+i, "editable",i+i+1,NULL);
7280 gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
7281 g_object_set_data(G_OBJECT(renderer),"NumColumn", GINT_TO_POINTER(i));
7282 g_signal_connect (renderer, "edited", G_CALLBACK (editedGeom), model);
7283 g_signal_connect (renderer, "editing-started", G_CALLBACK (selectedCell), model);
7284 }
7285 gtk_container_add(GTK_CONTAINER(scr),list);
7286 /* Drag and Drop */
7287 /*
7288 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (list), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
7289 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (list), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
7290 */
7291
7292 set_base_style(list,55000,55000,55000);
7293 gtk_widget_show (list);
7294
7295 if(readfile == GABEDIT_TYPEFILEGEOM_GAUSSIAN_ZMATRIX) selc_ZMatrix_file();
7296 else if(readfile == GABEDIT_TYPEFILEGEOM_MOPAC_ZMATRIX) selc_ZMatrix_mopac_file();
7297
7298 if(WindowGeom) manager = newMenuZMatGeom(WindowGeom);
7299 else manager = newMenuZMatGeom(Fenetre);
7300
7301 if(Geom != NULL) put_geom_in_list();
7302
7303 g_signal_connect(G_OBJECT (list), "button_press_event", G_CALLBACK(event_dispatcher), manager);
7304 }
7305 /********************************************************************************/
DelVariable(GtkWidget * w,gpointer data)7306 static void DelVariable(GtkWidget *w,gpointer data)
7307 {
7308 gint i,imin;
7309 gchar *message;
7310
7311 if(LineSelectedV<0)
7312 LineSelectedV=NVariables-1;
7313 if(Variables[LineSelectedV].Used) {
7314 message=g_strdup_printf(_("Sorry\n %s \n is used in Geometry"),Variables[LineSelectedV].Name);
7315 MessageGeom(message,_("Warning"),TRUE);
7316 return;
7317 }
7318 if(NVariables>0)
7319 {
7320 imin=LineSelectedV;
7321 removeFromList(listv, LineSelectedV);
7322 for(i=imin;i<(gint)NVariables-1;i++)
7323 {
7324 Variables[i].Name=g_strdup(Variables[i+1].Name);
7325 Variables[i].Value=g_strdup(Variables[i+1].Value);
7326 Variables[i].Used=Variables[i+1].Used;
7327 }
7328 NVariables--;
7329 if(NVariables>0)
7330 Variables=g_realloc(Variables,NVariables*sizeof(VariablesDef));
7331 else
7332 freeVariables();
7333 }
7334 LineSelectedV=-1;
7335 }
7336 /********************************************************************************/
TestVariablesCreated(gchar * NewName,gint j)7337 static gboolean TestVariablesCreated(gchar *NewName,gint j)
7338 {
7339 guint i;
7340 gboolean k;
7341
7342 k=FALSE;
7343 for (i=0;i<NVariables;i++)
7344 {
7345 if (j==(gint)i)continue;
7346 if (!strcmp(Variables[i].Name, NewName) )
7347 {
7348 k=TRUE;
7349 break;
7350 }
7351 }
7352 return k;
7353 }
7354 /********************************************************************************/
EditVariable(GtkWidget * w,gpointer Entree)7355 static void EditVariable(GtkWidget *w,gpointer Entree)
7356 {
7357 gchar *texts[2];
7358 gchar *message;
7359 gint Nc;
7360
7361 DestroyDialog=TRUE;
7362 texts[0] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[0])));
7363 texts[1] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[1])));
7364 if(!variable_name_valid(texts[0]))
7365 {
7366 show_forbidden_characters();
7367 DestroyDialog = FALSE;
7368 return;
7369 }
7370 if ( strcmp(texts[0], "") && strcmp(texts[1], "") )
7371 {
7372 Nc=LineSelectedV;
7373 if(Nc<0)
7374 Nc=LineSelectedOld;
7375 }
7376 else
7377 {
7378 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
7379 DestroyDialog=FALSE;
7380 return;
7381 }
7382 if(TestVariablesCreated(texts[0],Nc) )
7383 {
7384 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Warning"),TRUE);
7385 DestroyDialog=FALSE;
7386 return;
7387 }
7388
7389 if(!test(texts[1]))
7390 {
7391 message=g_strdup_printf(_("Sorry %s is not a number \n"),texts[1]);
7392 MessageGeom(message,_("Warning"),TRUE);
7393 DestroyDialog=FALSE;
7394 }
7395 else
7396 {
7397 if(test(texts[1]) && !testpointeE(texts[1]) )
7398 texts[1]=g_strdup_printf("%s.0",texts[1]);
7399 Variables[Nc].Name=g_strdup(texts[0]);
7400 Variables[Nc].Value=g_strdup(texts[1]);
7401
7402 removeFromList(listv, Nc);
7403 insertToList(listv, Nc, texts, 2);
7404 }
7405 }
7406 /********************************************************************************/
DialogueDeleteV()7407 static void DialogueDeleteV()
7408 {
7409 GtkWidget *Dialogue;
7410 GtkWidget *Label;
7411 GtkWidget *Bouton;
7412 GtkWidget *frame;
7413 GtkWidget *vboxframe;
7414
7415 gchar *message;
7416
7417 if (NVariables <1)
7418 {
7419 MessageGeom(_(" No Variable to delete !"),_("Warning"),TRUE);
7420 return ;
7421 }
7422
7423 if(LineSelectedV<0)
7424 LineSelectedV=NVariables-1;
7425 if(Variables[LineSelectedV].Used) {
7426 message=g_strdup_printf(_("Sorry\n %s \n is used in Geometry"),Variables[LineSelectedV].Name);
7427 MessageGeom(message,_("Warning"),TRUE);
7428 return;
7429 }
7430
7431 Dialogue = gtk_dialog_new();
7432 gtk_window_set_title(GTK_WINDOW(Dialogue),"Delete Variable");
7433 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
7434 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
7435 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
7436
7437 add_child(WindowGeom,Dialogue,gtk_widget_destroy," Delete Variable ");
7438 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
7439
7440 frame = gtk_frame_new (NULL);
7441 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
7442
7443 g_object_ref (frame);
7444 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
7445 frame,(GDestroyNotify) g_object_unref);
7446 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
7447 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
7448
7449 gtk_widget_show (frame);
7450
7451 vboxframe = create_vbox(frame);
7452
7453 gtk_widget_realize(Dialogue);
7454
7455 message = g_strdup_printf("\n Are you sure to delete the variable\n %s\n?",Variables[LineSelectedV].Name);
7456 Label = create_label_with_pixmap(Dialogue,message," Question ");
7457 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
7458
7459 Bouton = create_button(Dialogue,"No");
7460 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7461 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
7462 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7463 gtk_widget_grab_default(Bouton);
7464
7465 Bouton = create_button(Dialogue,"Yes");
7466 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7467 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)DelVariable, NULL);
7468 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
7469 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7470
7471
7472 gtk_widget_show_all(Dialogue);
7473 }
7474 /********************************************************************************/
DialogueEditV()7475 static void DialogueEditV()
7476 {
7477 GtkWidget *Dialogue;
7478 GtkWidget *Bouton;
7479 GtkWidget *hbox;
7480 GtkWidget *frame;
7481 GtkWidget *vboxframe;
7482
7483 gint Nc;
7484 gchar *tlabel[]={" Name : ", " Value : "};
7485
7486 Nc=LineSelectedV;
7487 if(Nc<0 ) {
7488 if(NVariables<1)
7489 MessageGeom(_("Create variable before \n"),_("Warning"),TRUE);
7490 else
7491 MessageGeom(_("Please Select your variable \n"),_("Warning"),TRUE);
7492 return;
7493 }
7494 Dialogue = gtk_dialog_new();
7495 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Edit Variable"));
7496 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
7497 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
7498
7499 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Edit variable "));
7500 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
7501
7502 frame = gtk_frame_new (NULL);
7503 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
7504 g_object_ref (frame);
7505 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
7506 frame,(GDestroyNotify) g_object_unref);
7507 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
7508 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
7509 gtk_widget_show (frame);
7510 vboxframe = create_vbox(frame);
7511
7512 hbox=create_hbox_false(vboxframe);
7513 EntryV[0] = create_label_entry(hbox,tlabel[0],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
7514 gtk_entry_set_text(GTK_ENTRY(EntryV[0]),Variables[Nc].Name);
7515 if(Variables[Nc].Used)
7516 gtk_editable_set_editable((GtkEditable*) EntryV[0],FALSE);
7517
7518 hbox=create_hbox_false(vboxframe);
7519 EntryV[1] = create_label_entry(hbox,tlabel[1],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
7520 gtk_entry_set_text(GTK_ENTRY(EntryV[1]),Variables[Nc].Value);
7521
7522 gtk_widget_realize(Dialogue);
7523
7524 Bouton = create_button(Dialogue,_("Cancel"));
7525 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7526 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
7527 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7528
7529 Bouton = create_button(Dialogue,_("OK"));
7530 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7531 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)EditVariable, NULL);
7532 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)destroy_dialogue, GTK_OBJECT(Dialogue));
7533 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7534 gtk_widget_grab_default(Bouton);
7535
7536
7537 gtk_widget_show_all(Dialogue);
7538 }
7539 /********************************************************************************/
AddVariable(GtkWidget * w,gpointer Entree)7540 static void AddVariable(GtkWidget *w,gpointer Entree)
7541 {
7542 gchar *texts[2];
7543 gchar *message;
7544
7545 DestroyDialog=TRUE;
7546 texts[0] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[0])));
7547 texts[1] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[1])));
7548 if(!variable_name_valid(texts[0]))
7549 {
7550 show_forbidden_characters();
7551 DestroyDialog = FALSE;
7552 return;
7553 }
7554 if(TestVariablesCreated(texts[0],-1))
7555 {
7556 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Warning"),TRUE);
7557 DestroyDialog=FALSE;
7558 return;
7559 }
7560 if ( strcmp(texts[0], "") && strcmp(texts[1], "") )
7561 NVariables++;
7562 else
7563 {
7564 MessageGeom(_("Sorry a Entry text is void !\n"),_("Warning"),TRUE);
7565 DestroyDialog=FALSE;
7566 return;
7567 }
7568 if(Variables==NULL)
7569 Variables=g_malloc(sizeof(VariablesDef));
7570 else
7571 Variables=g_realloc(Variables,NVariables*sizeof(VariablesDef));
7572
7573 if(test(texts[1]) && !testpointeE(texts[1]) )
7574 texts[1]=g_strdup_printf("%s.0",texts[1]);
7575 Variables[NVariables-1].Name=g_strdup(texts[0]);
7576 Variables[NVariables-1].Value=g_strdup(texts[1]);
7577 Variables[NVariables-1].Used=FALSE;
7578 if(!test(texts[1]))
7579 {
7580 message=g_strdup_printf(_("Sorry %s is not a number \n"),texts[1]);
7581 MessageGeom(message,_("Warning"),TRUE);
7582 DestroyDialog=FALSE;
7583 NVariables--;
7584 if(NVariables>0)
7585 Variables=g_realloc(Variables,NVariables*sizeof(VariablesDef));
7586 else
7587 Variables=NULL;
7588 }
7589 else
7590 appendToList(listv, texts, 2);
7591 }
7592 /********************************************************************************/
DialogueAddV()7593 static void DialogueAddV()
7594 {
7595 GtkWidget *Dialogue;
7596 GtkWidget *Bouton;
7597 GtkWidget *hbox;
7598 GtkWidget *frame;
7599 GtkWidget *vboxframe;
7600
7601 gchar *tlabel[]={" Name : ", " Value : "};
7602
7603 Dialogue = gtk_dialog_new();
7604 gtk_window_set_title(GTK_WINDOW(Dialogue),"New Variable");
7605 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
7606 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
7607
7608 add_child(WindowGeom,Dialogue,gtk_widget_destroy," New Variable ");
7609 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
7610
7611 frame = gtk_frame_new (NULL);
7612 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
7613
7614 g_object_ref (frame);
7615 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
7616 frame,(GDestroyNotify) g_object_unref);
7617 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
7618 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
7619
7620 gtk_widget_show (frame);
7621
7622 vboxframe = create_vbox(frame);
7623
7624 hbox=create_hbox_false(vboxframe);
7625 EntryV[0] = create_label_entry(hbox,tlabel[0],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
7626 hbox=create_hbox_false(vboxframe);
7627 EntryV[1] = create_label_entry(hbox,tlabel[1],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
7628
7629 gtk_widget_realize(Dialogue);
7630
7631 Bouton = create_button(Dialogue,_("Cancel"));
7632 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7633 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
7634 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7635
7636 Bouton = create_button(Dialogue,_("OK"));
7637 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
7638 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)AddVariable, NULL);
7639 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)destroy_dialogue, GTK_OBJECT(Dialogue));
7640 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
7641 gtk_widget_grab_default(Bouton);
7642
7643
7644 gtk_widget_show_all(Dialogue);
7645 }
7646 /********************************************************************************/
create_variables_list(GtkWidget * vbox,GabEditTypeFileGeom itype)7647 void create_variables_list(GtkWidget *vbox,GabEditTypeFileGeom itype)
7648 {
7649
7650 GtkListStore *store;
7651 GtkTreeModel *model;
7652 GtkCellRenderer *renderer;
7653 GtkTreeViewColumn *column;
7654
7655 GtkWidget *scr;
7656 guint i;
7657 guint Factor=7;
7658 guint widall=0;
7659 gchar *titres[2]={ " Name "," value "};
7660 guint width[2]={8,8 };
7661 GtkUIManager *manager = NULL;
7662
7663 if(itype != GABEDIT_TYPEFILEGEOM_UNKNOWN) freeVariables();
7664
7665 LineSelectedV=-1;
7666 for(i=0;i<2;i++) widall+=width[i];
7667 widall=widall*Factor+50;
7668
7669
7670 scr=gtk_scrolled_window_new(NULL,NULL);
7671 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*0.4));
7672 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
7673 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 2);
7674
7675 store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_BOOLEAN);
7676 model = GTK_TREE_MODEL (store);
7677
7678 listv = gtk_tree_view_new_with_model (model);
7679 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (listv), TRUE);
7680 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (listv), TRUE);
7681 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (listv), TRUE);
7682 for (i=0;(gint)i<2;i++)
7683 {
7684 column = gtk_tree_view_column_new ();
7685 gtk_tree_view_column_set_title (column, titres[i]);
7686 gtk_tree_view_column_set_min_width(column, width[i]*Factor);
7687 gtk_tree_view_column_set_reorderable(column, TRUE);
7688 renderer = gtk_cell_renderer_text_new ();
7689 gtk_tree_view_column_pack_start (column, renderer, TRUE);
7690 gtk_tree_view_column_set_attributes (column, renderer, "text", i+i, "editable",i+i+1,NULL);
7691 g_object_set_data(G_OBJECT(renderer),"NumColumn", GINT_TO_POINTER(i));
7692 g_signal_connect (renderer, "edited", G_CALLBACK (editedVariable), model);
7693 gtk_tree_view_append_column (GTK_TREE_VIEW (listv), column);
7694 }
7695 gtk_container_add(GTK_CONTAINER(scr),listv);
7696
7697 set_base_style(listv,58000,58000,58000);
7698 gtk_widget_show (listv);
7699
7700
7701 if(WindowGeom) manager = newMenuZMatVariables(WindowGeom);
7702 else manager = newMenuZMatVariables(Fenetre);
7703
7704 if(Geom != NULL && Variables != NULL) append_list_variables();
7705
7706 g_signal_connect(G_OBJECT (listv), "button_press_event", G_CALLBACK(event_dispatcher), manager);
7707 }
7708 /********************************************************************************/
multi_by_factor(gdouble factor)7709 static void multi_by_factor(gdouble factor)
7710 {
7711 gint i;
7712 guint j;
7713
7714 for (i=1;(guint)i<NcentersZmat;i++)
7715 {
7716 if(test(Geom[i].R))
7717 Geom[i].R = g_strdup_printf("%f",factor*atof(Geom[i].R));
7718 else
7719 {
7720 j = get_num_variableZmat(Geom[i].R);
7721 Variables[j].Value = g_strdup_printf("%f",factor*atof(Variables[j].Value));
7722
7723 }
7724 }
7725
7726 clearList(list);
7727 append_list_geom();
7728
7729 clearList(listv);
7730 append_list_variables();
7731
7732 if(GeomDrawingArea != NULL)
7733 rafresh_drawing();
7734 if(iprogram == PROG_IS_GAUSS)
7735 set_spin_of_electrons();
7736 }
7737 /********************************************************************************/
MultiByA0()7738 static void MultiByA0()
7739 {
7740 multi_by_factor(BOHR_TO_ANG);
7741 }
7742 /********************************************************************************/
DivideByA0()7743 static void DivideByA0()
7744 {
7745 multi_by_factor(ANG_TO_BOHR);
7746 }
7747 /********************************************************************************/
7748