1 /* GGeomXYZ.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 <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <math.h>
27 #include <gtk/gtk.h>
28 #include <glib/gprintf.h>
29
30 #include "../Common/Global.h"
31 #include "../Utils/Constants.h"
32 #include "../Common/Help.h"
33 #include "../Utils/UtilsInterface.h"
34 #include "../Utils/Utils.h"
35 #include "../Geometry/GeomGlobal.h"
36 #include "../Utils/AtomsProp.h"
37 #include "../Utils/UtilsVASP.h"
38 #include "../Crystallography/UtilsCIF.h"
39 #include "../Geometry/Fragments.h"
40 #include "../Geometry/DrawGeom.h"
41 #include "../Geometry/GeomZmatrix.h"
42 #include "../Files/ListeFiles.h"
43 #include "../Common/Windows.h"
44 #include "../Geometry/InterfaceGeom.h"
45 #include "../Gaussian/Gaussian.h"
46 #include "../Molpro/Molpro.h"
47 #include "../Geometry/GeomConversion.h"
48 #include "../Common/StockIcons.h"
49 #include "../Geometry/GeomXYZ.h"
50 #include "../Geometry/ResultsAnalise.h"
51 #include "../Geometry/OpenBabel.h"
52 #include "../Geometry/SelectionDlg.h"
53 #include "../MolecularMechanics/PDBTemplate.h"
54 #include "../MolecularMechanics/CalculTypesAmber.h"
55
56 #ifdef G_OS_WIN32
57 #include <fcntl.h>
58 #include <io.h>
59 #else
60 #include <unistd.h>
61 #endif
62
63 #define MAXNAME 6
64 #define MAXATOMTYPE 4
65 #define MAXRESIDUENAME 4
66 #define MAXSYMBOL 2
67
68 typedef enum
69 {
70 E_NUMBER=0,
71 E_SYMBOL,
72 E_MMTYPE,
73 E_PDBTYPE,
74 E_RESIDUE,
75 E_X,
76 E_Y,
77 E_Z,
78 E_CHARGE,
79 E_LAYER
80 } GabeditEntryType;
81 static GtkWidget *FenetreTable;
82
83 static gint LineSelectedV;
84 static GtkWidget *listv=NULL;
85 static GtkWidget *EntryV[2];
86 static gint LineSelected;
87 static GtkWidget *list = NULL;
88 static GtkWidget *Entry[NUMBER_LIST_XYZ];
89 static gboolean DestroyDialog;
90 static gint NCr;
91 static gint LineSelectedOld = -1;
92 static gdouble labelWidth = 0.15;
93 static gdouble entryWidth = 0.20;
94 static gint rowInserted = -1;
95
96 /*
97 static GtkTargetEntry row_targets[] = { { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0} };
98 */
99
100 static void TransXYZConstXVar();
101 static void TransXYZConstYVar();
102 static void TransXYZConstZVar();
103 static void get_position(guint i,gdouble Pos[]);
104 gchar** getListMMTypes(gint* nlist);
105 gchar** getListPDBTypes(gchar* residueName, gint* nlist);
106 /********************************************************************************/
107 static gboolean connected(guint i,guint j);
108 static void DialogueAdd();
109 static void DialogueEdit();
110 static void DialogueDelete();
111 void create_window_save_xyzmol2tinkerpdbhin();
112 static void DialogueTransInVar();
113 static void TransXYZConstVar();
114 static void MultiByA0();
115 static void DivideByA0();
116 static void OriginToCenter();
117 static void sort_GeomXYZ();
118 static void clearList(GtkWidget* myList);
119 static void removeFromList(GtkWidget* myList, gint ligne);
120 static void insertToList(GtkWidget* myList, gint ligne, gchar* texts[], gint nColumns);
121 static void appendToList(GtkWidget* myList, gchar* texts[], gint nColumns);
122 static void append_list();
123 static gboolean TestVariablesXYZCreated(gchar *NewName,gint j);
124 static gint testav(gchar *t);
125 static gint read_gabedit_geoms_file(gchar* fileName, gint geometryNumber);
126 void read_geom_from_vasp_xml_file(gchar *fileName, gint numgeom);
127 void read_geom_from_cif_file(gchar *fileName, gboolean applySymOp);
128 static void trans_coordXYZ_geom(gchar T, GeomXYZAtomDef* myGeomXYZ, gint i, VariablesXYZDef* myVariablesXYZ, gint iv);
129 static void GeomXYZ_Change_Unit(gboolean toang);
130 /********************************************************************************/
get_layer(gchar * layer)131 static gint get_layer(gchar* layer)
132 {
133 if(strstr(layer,"Low")) return LOW_LAYER;
134 else if(strstr(layer,"Medium")) return MEDIUM_LAYER;
135 else return HIGH_LAYER;
136 }
137 /*************************************************************************************/
get_number_of_electrons(guint type)138 static guint get_number_of_electrons(guint type)
139 {
140 /*
141 type = 1 : Medium and High
142 type = 2 : High
143 type = other : All
144 */
145 guint i;
146 guint Ne=0;
147 SAtomsProp Atom;
148 for(i=0;i<NcentersXYZ;i++)
149 {
150 Atom = prop_atom_get(GeomXYZ[i].Symb);
151 switch (type)
152 {
153 case 1 : if(get_layer(GeomXYZ[i].Layer)==HIGH_LAYER ||
154 get_layer(GeomXYZ[i].Layer)==MEDIUM_LAYER) Ne += Atom.atomicNumber;
155 break;
156 case 2 : if(get_layer(GeomXYZ[i].Layer)==HIGH_LAYER) Ne += Atom.atomicNumber;
157 break;
158 default : Ne += Atom.atomicNumber;
159 }
160 g_free(Atom.name);
161 g_free(Atom.symbol);
162 }
163 return Ne;
164 }
165 /************************************************************************************************************/
get_number_of_model_connections()166 static gint get_number_of_model_connections()
167 {
168 gint i;
169 gint j;
170 gint nc = 0;
171 gint NC = NcentersXYZ;
172 if(NcentersXYZ<1) return 0;
173 for(i=0;i<NC;i++)
174 {
175 if(get_layer(GeomXYZ[i].Layer)==MEDIUM_LAYER || get_layer(GeomXYZ[i].Layer)==LOW_LAYER) continue;
176 for(j=0;j<NC;j++)
177 {
178 gint nj = j;
179 if(i==j) continue;
180 if(get_layer(GeomXYZ[j].Layer)==MEDIUM_LAYER || get_layer(GeomXYZ[j].Layer)==LOW_LAYER) continue;
181 if(GeomXYZ[i].typeConnections[nj]>0) nc++;
182 }
183 }
184 return nc;
185 }
186 /************************************************************************************************************/
get_number_of_inter_connections()187 static gint get_number_of_inter_connections()
188 {
189 gint i;
190 gint j;
191 gint nc = 0;
192 gint NC = NcentersXYZ;
193 for(i=0;i<NC;i++)
194 {
195 if(get_layer(GeomXYZ[i].Layer)==HIGH_LAYER || get_layer(GeomXYZ[i].Layer)==LOW_LAYER) continue;
196 for(j=0;j<NC;j++)
197 {
198 gint nj = j;
199 if(i==j) continue;
200 if(get_layer(GeomXYZ[j].Layer)==HIGH_LAYER || get_layer(GeomXYZ[j].Layer)==LOW_LAYER) continue;
201 if(GeomXYZ[i].typeConnections[nj]>0) nc++;
202 }
203 }
204 return nc;
205 }
206 /************************************************************************************************************/
reset_spin_of_electrons()207 static void reset_spin_of_electrons()
208 {
209 gint i;
210 guint NumberElectrons[3];
211 guint SpinElectrons[3];
212 gint n = 1;
213 gint nL = 0;
214 gint nM = 0;
215 gint nH = 0;
216
217 if(NcentersXYZ<1) return;
218
219 NumberElectrons[2]= get_number_of_electrons(2);
220 NumberElectrons[1]= get_number_of_electrons(1);
221 NumberElectrons[0]= get_number_of_electrons(0);
222
223
224 for(i=0;i<3;i++)
225 SpinElectrons[i]=0;
226 for(i=0;i<NcentersXYZ;i++)
227 {
228 if(get_layer(GeomXYZ[i].Layer)==LOW_LAYER) nL =1;
229 if(get_layer(GeomXYZ[i].Layer)==MEDIUM_LAYER) nM =1;
230 if(get_layer(GeomXYZ[i].Layer)==HIGH_LAYER) nH =1;
231 }
232 n = nH + nM + nL;
233 if(n==3)
234 {
235 NumberElectrons[2] += get_number_of_model_connections();
236 NumberElectrons[1] += get_number_of_inter_connections();
237 }
238 if(n==2)
239 {
240 NumberElectrons[1] += get_number_of_model_connections();
241 }
242
243 for(i=0;(guint)i<n;i++)
244 if((NumberElectrons[i]-TotalCharges[i])%2==0)
245 SpinElectrons[i]=1;
246 else
247 SpinElectrons[i]=2;
248
249 for(i=0;(guint)i<n;i++)
250 {
251 if(SpinMultiplicities[i]%2 != SpinElectrons[i]%2)
252 SpinMultiplicities[i] = SpinElectrons[i];
253 }
254 }
255 /*****************************************************************************/
reset_charges_multiplicities_XYZ()256 static void reset_charges_multiplicities_XYZ()
257 {
258 gint i;
259 if(Natoms<1) return;
260 for(i=0;i<3;i++)
261 TotalCharges[i] = 0;
262 reset_spin_of_electrons();
263
264 }
265 /************************************************************************************************************/
compute_dipole_using_charges_of_xyz_geom()266 void compute_dipole_using_charges_of_xyz_geom()
267 {
268 gdouble charge;
269 gdouble x;
270 gdouble y;
271 gdouble z;
272 gint i;
273
274 Dipole.def = TRUE;
275 Dipole.value[0] = 0;
276 Dipole.value[1] = 0;
277 Dipole.value[2] = 0;
278 for(i=0;i<NcentersXYZ;i++)
279 {
280 charge = atof(GeomXYZ[i].Charge);
281 if(!test(GeomXYZ[i].X)) x = get_value_variableXYZ(GeomXYZ[i].X);
282 else x = atof(GeomXYZ[i].X);
283 if(!test(GeomXYZ[i].Y)) y = get_value_variableXYZ(GeomXYZ[i].Y);
284 else y = atof(GeomXYZ[i].Y);
285 if(!test(GeomXYZ[i].Z)) z = get_value_variableXYZ(GeomXYZ[i].Z);
286 else z = atof(GeomXYZ[i].Z);
287 Dipole.value[0] += charge*x;
288 Dipole.value[1] += charge*y;
289 Dipole.value[2] += charge*z;
290 }
291 if(Units == 1 )
292 for(i=0;i<3;i++) Dipole.value[i] *= ANG_TO_BOHR;
293 for(i=0;i<3;i++)
294 Dipole.value[i] *= AUTODEB;
295 }
296 /********************************************************************************/
calculMMTypes(gboolean withCharge)297 static void calculMMTypes(gboolean withCharge)
298 {
299 gint i;
300 MethodeGeom = GEOM_IS_XYZ;
301 define_geometry();
302 reset_all_connections();
303 calculTypesAmber(geometry,NcentersXYZ);
304 for(i=0;i<(gint)NcentersXYZ;i++)
305 {
306 gint in = geometry[i].N-1;
307 GeomXYZ[in].mmType = g_strdup(geometry[i].mmType);
308 if(withCharge) GeomXYZ[in].Charge = g_strdup_printf("%f",geometry[i].Charge);
309 }
310 }
311 /********************************************************************************/
set_sensitive_option(GtkUIManager * manager,gchar * path,gboolean sensitive)312 static void set_sensitive_option(GtkUIManager *manager, gchar* path, gboolean sensitive)
313 {
314 GtkWidget *wid = gtk_ui_manager_get_widget (manager, path);
315 if(GTK_IS_WIDGET(wid)) gtk_widget_set_sensitive(wid, sensitive);
316 }
317 /**********************************************************************************/
show_menu_popup(GtkUIManager * manager,gchar * menuName,guint button,guint32 time)318 static gboolean show_menu_popup(GtkUIManager *manager, gchar* menuName, guint button, guint32 time)
319 {
320 GtkWidget *menu = gtk_ui_manager_get_widget (manager, menuName);
321 if (GTK_IS_MENU (menu))
322 {
323 gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, time);
324 return TRUE;
325 }
326 return FALSE;
327 }
328 /*********************************************************************************************************************/
activate_action_xyz_geom(GtkAction * action)329 static void activate_action_xyz_geom (GtkAction *action)
330 {
331 const gchar *name = gtk_action_get_name (action);
332
333 if(!strcmp(name, "Edit")) DialogueEdit();
334 else if(!strcmp(name, "New")) DialogueAdd();
335 else if(!strcmp(name, "Delete")) DialogueDelete();
336 else if(!strcmp(name, "Draw")) draw_geometry(NULL, NULL);
337 else if(!strcmp(name, "Save")) create_window_save_xyzmol2tinkerpdbhin();
338 else if(!strcmp(name, "All")) DialogueTransInVar();
339 else if(!strcmp(name, "AllX")) TransXYZConstXVar();
340 else if(!strcmp(name, "AllY")) TransXYZConstYVar();
341 else if(!strcmp(name, "AllZ")) TransXYZConstZVar();
342 else if(!strcmp(name, "One")) TransXYZConstVar();
343 else if(!strcmp(name, "MultiplyBya0")) MultiByA0();
344 else if(!strcmp(name, "DivideBya0")) DivideByA0();
345 else if(!strcmp(name, "Center")) OriginToCenter();
346 else if(!strcmp(name, "Sort")) sort_GeomXYZ();
347 else if(!strcmp(name, "ToZmat")) conversion_xyz_to_zmat();
348 else if(!strcmp(name, "ToZmatConn")) conversion_xyz_to_zmat_using_connections();
349 }
350 /*--------------------------------------------------------------------*/
351 static GtkActionEntry gtkActionEntriesXYZGeom[] =
352 {
353 {"Edit", NULL, N_("_Edit"), NULL, "Edit", G_CALLBACK (activate_action_xyz_geom) },
354 {"New", GABEDIT_STOCK_NEW, N_("_New"), NULL, "New", G_CALLBACK (activate_action_xyz_geom) },
355 {"Delete", GABEDIT_STOCK_CUT, N_("_Delete"), NULL, "Delete", G_CALLBACK (activate_action_xyz_geom) },
356 {"Draw", GABEDIT_STOCK_DRAW, N_("D_raw"), NULL, "Draw", G_CALLBACK (activate_action_xyz_geom) },
357 {"Save", GABEDIT_STOCK_SAVE, N_("_Save"), NULL, "Save", G_CALLBACK (activate_action_xyz_geom) },
358 {"All", NULL, N_("_All=>"), NULL, "All=>", G_CALLBACK (activate_action_xyz_geom) },
359 {"AllX", NULL,N_("All _X=>"), NULL, "All X=>", G_CALLBACK (activate_action_xyz_geom) },
360 {"AllY", NULL,N_("All _Y=>"), NULL, "All Y=>", G_CALLBACK (activate_action_xyz_geom) },
361 {"AllZ", NULL,N_("All _Z=>"), NULL, "All Z=>", G_CALLBACK (activate_action_xyz_geom) },
362 {"One", NULL,N_("_One=>"), NULL, "One=>", G_CALLBACK (activate_action_xyz_geom) },
363 {"MultiplyBya0", GABEDIT_STOCK_A0P, N_("M_ultiply by a0"), NULL, "Multiply by a0", G_CALLBACK (activate_action_xyz_geom) },
364 {"DivideBya0", GABEDIT_STOCK_A0D, N_("D_ivide by a0"), NULL, "D_ivide by a0", G_CALLBACK (activate_action_xyz_geom) },
365 {"Center", NULL, N_("_Center"), NULL, "Center", G_CALLBACK (activate_action_xyz_geom) },
366 {"Sort", NULL, N_("_Sort"), NULL, "Sort", G_CALLBACK (activate_action_xyz_geom) },
367 {"ToZmat", NULL, N_("to _Zmat"), NULL, "to _Zmat", G_CALLBACK (activate_action_xyz_geom) },
368 {"ToZmatConn", NULL, N_("to _Zmat using connections"), NULL, "to _Zmat using conn.", G_CALLBACK (activate_action_xyz_geom) },
369 };
370 static guint numberOfGtkActionEntriesXYZGeom = G_N_ELEMENTS (gtkActionEntriesXYZGeom);
371 /********************************************************************************/
372 /* XML description of the menus for the test app. The parser understands
373 * a subset of the Bonobo UI XML format, and uses GMarkup for parsing */
374 static const gchar *uiMenuXYZGeomInfo =
375 " <popup name=\"MenuXYZGeom\">\n"
376 " <separator name=\"sepMenuPopNew\" />\n"
377 " <menuitem name=\"Edit\" action=\"Edit\" />\n"
378 " <menuitem name=\"New\" action=\"New\" />\n"
379 " <menuitem name=\"Delete\" action=\"Delete\" />\n"
380 " <separator name=\"sepMenuPopDraw\" />\n"
381 " <menuitem name=\"Draw\" action=\"Draw\" />\n"
382 " <separator name=\"sepMenuPopSave\" />\n"
383 " <menuitem name=\"Save\" action=\"Save\" />\n"
384 " <separator name=\"sepMenuPopSave\" />\n"
385 " <menuitem name=\"Save\" action=\"Save\" />\n"
386 " <separator name=\"sepMenuPopAll\" />\n"
387 " <menuitem name=\"All\" action=\"All\" />\n"
388 " <menuitem name=\"AllX\" action=\"AllX\" />\n"
389 " <menuitem name=\"AllY\" action=\"AllY\" />\n"
390 " <menuitem name=\"AllZ\" action=\"AllZ\" />\n"
391 " <menuitem name=\"One\" action=\"One\" />\n"
392 " <separator name=\"sepMenuPopMul\" />\n"
393 " <menuitem name=\"MultiplyBya0\" action=\"MultiplyBya0\" />\n"
394 " <menuitem name=\"DivideBya0\" action=\"DivideBya0\" />\n"
395 " <separator name=\"sepMenuPopCent\" />\n"
396 " <menuitem name=\"Center\" action=\"Center\" />\n"
397 " <menuitem name=\"Sort\" action=\"Sort\" />\n"
398 " <separator name=\"sepMenuPopZmat\" />\n"
399 " <menuitem name=\"ToZmat\" action=\"ToZmat\" />\n"
400 " <menuitem name=\"ToZmatConn\" action=\"ToZmatConn\" />\n"
401 " </popup>\n"
402 ;
403 /*******************************************************************************************************************************/
newMenuXYZGeom(GtkWidget * win)404 static GtkUIManager *newMenuXYZGeom(GtkWidget* win)
405 {
406 GtkActionGroup *actionGroup = NULL;
407 GtkUIManager *manager = NULL;
408 GError *error = NULL;
409 static gchar* menuName = "/MenuXYZGeom";
410
411 manager = gtk_ui_manager_new ();
412 g_signal_connect_swapped (win, "destroy", G_CALLBACK (g_object_unref), manager);
413
414 actionGroup = gtk_action_group_new ("GabeditListOfProject");
415 gtk_action_group_set_translation_domain(actionGroup,GETTEXT_PACKAGE);
416 gtk_action_group_add_actions (actionGroup, gtkActionEntriesXYZGeom, numberOfGtkActionEntriesXYZGeom, NULL);
417
418 gtk_ui_manager_insert_action_group (manager, actionGroup, 0);
419
420 gtk_window_add_accel_group (GTK_WINDOW (win), gtk_ui_manager_get_accel_group (manager));
421 if (!gtk_ui_manager_add_ui_from_string (manager, uiMenuXYZGeomInfo, -1, &error))
422 {
423 g_message ("building menus failed: %s", error->message);
424 g_error_free (error);
425 }
426 g_object_set_data(G_OBJECT(manager),"MenuName", menuName);
427 return manager;
428 }
429 /********************************************************************************/
430 static void DialogueAddV();
431 static void DialogueEditV();
432 static void DialogueDeleteV();
433 static void DialogueTransInConst();
434 static void TransXYZVarConst();
435 /*********************************************************************************************************************/
activate_action_xyz_variables(GtkAction * action)436 static void activate_action_xyz_variables (GtkAction *action)
437 {
438 const gchar *name = gtk_action_get_name (action);
439 if(!strcmp(name, "Edit")) DialogueEditV();
440 else if(!strcmp(name, "New")) DialogueAddV();
441 else if(!strcmp(name, "Delete")) DialogueDeleteV();
442 else if(!strcmp(name, "All")) DialogueTransInConst();
443 else if(!strcmp(name, "One")) TransXYZVarConst();
444 }
445 /*--------------------------------------------------------------------*/
446 static GtkActionEntry gtkActionEntriesXYZVariables[] =
447 {
448 {"Edit", NULL, "_Edit", NULL, "Edit", G_CALLBACK (activate_action_xyz_variables) },
449 {"New", GABEDIT_STOCK_NEW, "_New", NULL, "New", G_CALLBACK (activate_action_xyz_variables) },
450 {"Delete", GABEDIT_STOCK_CUT, "_Delete", NULL, "Delete", G_CALLBACK (activate_action_xyz_variables) },
451 {"All", NULL, "<=_All", NULL, "<=All", G_CALLBACK (activate_action_xyz_variables) },
452 {"One", NULL, "<=_On", NULL, "<=One", G_CALLBACK (activate_action_xyz_variables) },
453 };
454 static guint numberOfGtkActionEntriesXYZVariables = G_N_ELEMENTS (gtkActionEntriesXYZVariables);
455 /********************************************************************************/
456 /* XML description of the menus for the test app. The parser understands
457 * a subset of the Bonobo UI XML format, and uses GMarkup for parsing */
458 static const gchar *uiMenuXYZVariablesInfo =
459 " <popup name=\"MenuXYZVariables\">\n"
460 " <separator name=\"sepMenuPopNew\" />\n"
461 " <menuitem name=\"Edit\" action=\"Edit\" />\n"
462 " <menuitem name=\"New\" action=\"New\" />\n"
463 " <menuitem name=\"Delete\" action=\"Delete\" />\n"
464 " <separator name=\"sepMenuPopAll\" />\n"
465 " <menuitem name=\"All\" action=\"All\" />\n"
466 " <menuitem name=\"One\" action=\"One\" />\n"
467 " </popup>\n"
468 ;
469 /*******************************************************************************************************************************/
newMenuXYZVariables(GtkWidget * win)470 static GtkUIManager *newMenuXYZVariables(GtkWidget* win)
471 {
472 GtkActionGroup *actionGroup = NULL;
473 GtkUIManager *manager = NULL;
474 GError *error = NULL;
475 static gchar* menuName = "/MenuXYZVariables";
476
477 manager = gtk_ui_manager_new ();
478 g_signal_connect_swapped (win, "destroy", G_CALLBACK (g_object_unref), manager);
479
480 actionGroup = gtk_action_group_new ("GabeditListOfProject");
481 gtk_action_group_set_translation_domain(actionGroup,GETTEXT_PACKAGE);
482 gtk_action_group_add_actions (actionGroup, gtkActionEntriesXYZVariables, numberOfGtkActionEntriesXYZVariables, NULL);
483
484 gtk_ui_manager_insert_action_group (manager, actionGroup, 0);
485
486 gtk_window_add_accel_group (GTK_WINDOW (win), gtk_ui_manager_get_accel_group (manager));
487 if (!gtk_ui_manager_add_ui_from_string (manager, uiMenuXYZVariablesInfo, -1, &error))
488 {
489 g_message ("building menus failed: %s", error->message);
490 g_error_free (error);
491 }
492 g_object_set_data(G_OBJECT(manager),"MenuName", menuName);
493 return manager;
494 }
495 /********************************************************************************/
row_inserted(GtkTreeModel * model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)496 static void row_inserted(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
497 {
498 rowInserted = atoi(gtk_tree_path_to_string(path));
499 }
500 /********************************************************************************/
row_deleted(GtkTreeModel * model,GtkTreePath * path,gpointer data)501 static void row_deleted(GtkTreeModel *model, GtkTreePath *path, gpointer data)
502 {
503 gint rowDeleted = atoi(gtk_tree_path_to_string(path));
504 gchar* tmp;
505 GList *glist = NULL;
506 GList *g = NULL;
507 GeomXYZAtomDef* tmpGeomXYZ;
508 gint i;
509 gint k;
510 gint nd;
511 gint j;
512
513 if(rowInserted>(gint)NcentersXYZ || rowDeleted>(gint)NcentersXYZ || rowInserted<0 || rowDeleted<0 || rowInserted == rowDeleted) return;
514
515 for(i=0;i<NcentersXYZ; i++) glist = g_list_append(glist, GINT_TO_POINTER(i));
516
517 nd = rowDeleted+NcentersXYZ;
518 if(rowInserted<rowDeleted) nd--;
519 glist = g_list_insert(glist, GINT_TO_POINTER(nd), rowInserted);
520 if(rowInserted<rowDeleted) glist = g_list_remove(glist, GINT_TO_POINTER(rowDeleted-1));
521 if(rowInserted>rowDeleted) glist = g_list_remove(glist, GINT_TO_POINTER(rowDeleted));
522
523
524
525 tmpGeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
526 i = 0;
527 g = glist;
528 while(g)
529 {
530 k = GPOINTER_TO_INT(g->data);
531 if(k>=NcentersXYZ)
532 {
533 k -= NcentersXYZ;
534 }
535 tmpGeomXYZ[i].Symb = g_strdup(GeomXYZ[k].Symb);
536 tmpGeomXYZ[i].mmType = g_strdup(GeomXYZ[k].mmType);
537 tmpGeomXYZ[i].pdbType = g_strdup(GeomXYZ[k].pdbType);
538 tmpGeomXYZ[i].Residue = g_strdup(GeomXYZ[k].Residue);
539 tmpGeomXYZ[i].X = g_strdup(GeomXYZ[k].X);
540 tmpGeomXYZ[i].Y = g_strdup(GeomXYZ[k].Y);
541 tmpGeomXYZ[i].Z = g_strdup(GeomXYZ[k].Z);
542 tmpGeomXYZ[i].Charge = g_strdup(GeomXYZ[k].Charge);
543 tmpGeomXYZ[i].Layer = g_strdup(GeomXYZ[k].Layer);
544 tmpGeomXYZ[i].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
545 for(j=0; j<NcentersXYZ; j++) tmpGeomXYZ[i].typeConnections[j] = GeomXYZ[k].typeConnections[j];
546 g = g->next;
547 i++;
548 }
549
550 g_list_free(glist);
551 for(i=0;i<NcentersXYZ;i++)
552 {
553 g_free(GeomXYZ[i].Symb);
554 g_free(GeomXYZ[i].mmType);
555 g_free(GeomXYZ[i].pdbType);
556 g_free(GeomXYZ[i].Residue);
557 g_free(GeomXYZ[i].X);
558 g_free(GeomXYZ[i].Y);
559 g_free(GeomXYZ[i].Z);
560 g_free(GeomXYZ[i].Charge);
561 g_free(GeomXYZ[i].Layer);
562 if(GeomXYZ[i].typeConnections) g_free(GeomXYZ[i].typeConnections);
563 }
564 g_free(GeomXYZ);
565 GeomXYZ = tmpGeomXYZ;
566
567 clearList(list);
568 append_list();
569
570 LineSelected = rowInserted;
571 if(rowInserted>rowDeleted) LineSelected--;
572 tmp = g_strdup_printf("%d", LineSelected);
573 path = gtk_tree_path_new_from_string (tmp);
574 g_free(tmp);
575 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), path);
576 gtk_tree_path_free(path);
577 NSA[0] = LineSelected+1;
578 NSA[1] = NSA[2] = NSA[3] =-1;
579 if(GeomDrawingArea != NULL) rafresh_drawing();
580 }
581 /********************************************************************************/
event_dispatcher(GtkWidget * widget,GdkEventButton * event,gpointer user_data)582 static void event_dispatcher(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
583 {
584
585 GtkTreePath *path;
586 gint row = -1;
587 GtkUIManager *manager = NULL;
588 gchar* menuName = NULL;
589
590 if (!event) return;
591 if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))
592 && !gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
593 event->x, event->y, NULL, NULL, NULL, NULL)) {
594 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)));
595 }
596 if(gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, NULL, NULL, NULL))
597 {
598 if(path)
599 {
600 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), path);
601 row = atoi(gtk_tree_path_to_string(path));
602 gtk_tree_path_free(path);
603 }
604 }
605 manager = GTK_UI_MANAGER(user_data);
606 menuName = g_object_get_data(G_OBJECT(manager),"MenuName");
607 if(strstr(menuName,"Geom"))
608 {
609 LineSelected = row;
610 NSA[0] = LineSelected+1;
611 NSA[1] = NSA[2] = NSA[3] =-1;
612 }
613 else
614 {
615 LineSelectedV = row;
616 LineSelectedOld = row;
617 }
618 if(GeomDrawingArea != NULL) rafresh_drawing();
619 if (event->type == GDK_2BUTTON_PRESS)
620 {
621
622 if(strstr(menuName,"Geom")) DialogueEdit();
623 else DialogueEditV();
624 }
625
626 if (event->type == GDK_BUTTON_PRESS && ((GdkEventButton *) event)->button == 3)
627 {
628 gchar* pathEdit = NULL;
629 gchar* pathDelete = NULL;
630 gchar* pathOne = NULL;
631 gchar* pathAll = NULL;
632 GdkEventButton *bevent = (GdkEventButton *) event;
633
634 if(menuName) pathEdit = g_strdup_printf("%s/Edit",menuName);
635 if(menuName) pathDelete = g_strdup_printf("%s/Delete",menuName);
636 if(menuName) pathOne = g_strdup_printf("%s/One",menuName);
637 if(menuName) pathAll = g_strdup_printf("%s/All",menuName);
638 if(pathEdit)
639 {
640 if(row<0) set_sensitive_option(manager, pathEdit, FALSE);
641 else set_sensitive_option(manager, pathEdit, TRUE);
642 g_free(pathEdit);
643 }
644 if(pathOne)
645 {
646 if(row<0) set_sensitive_option(manager, pathOne, FALSE);
647 else set_sensitive_option(manager, pathOne, TRUE);
648 g_free(pathOne);
649 }
650 if(pathDelete)
651 {
652 if(strstr(menuName,"Geom"))
653 {
654 if(NcentersXYZ <1) set_sensitive_option(manager, pathDelete, FALSE);
655 else set_sensitive_option(manager, pathDelete, TRUE);
656 }
657 else
658 if(strstr(menuName,"Variable"))
659 {
660 if(NVariablesXYZ <1) set_sensitive_option(manager, pathDelete, FALSE);
661 else set_sensitive_option(manager, pathDelete, TRUE);
662 }
663 g_free(pathDelete);
664 }
665 if(pathAll)
666 {
667 if(strstr(menuName,"Geom"))
668 {
669 if(NcentersXYZ <1) set_sensitive_option(manager, pathAll, FALSE);
670 else set_sensitive_option(manager, pathAll, TRUE);
671 }
672 else
673 if(strstr(menuName,"Variable"))
674 {
675 if(NVariablesXYZ <1) set_sensitive_option(manager, pathAll, FALSE);
676 else set_sensitive_option(manager, pathAll, TRUE);
677 }
678 g_free(pathAll);
679 }
680 show_menu_popup(manager, menuName, bevent->button, bevent->time);
681 }
682 GTK_WIDGET_GET_CLASS(widget)->button_press_event(widget, event);
683 }
684 /********************************************************************************/
freeList(gchar ** strs,gint nlist)685 static gchar** freeList(gchar** strs, gint nlist)
686 {
687 gint i;
688
689 for(i=0;i<nlist;i++)
690 if(strs[i])
691 g_free(strs[i]);
692
693 g_free(strs);
694
695 return NULL;
696 }
697 /*****************************************************************************/
set_coord(guint i,gdouble V[])698 void set_coord(guint i,gdouble V[])
699 {
700 if(!test(GeomXYZ[i].X))
701 V[0] = get_value_variableXYZ(GeomXYZ[i].X);
702 else
703 V[0] = atof(GeomXYZ[i].X);
704 if(!test(GeomXYZ[i].Y))
705 V[1] = get_value_variableXYZ(GeomXYZ[i].Y);
706 else
707 V[1] = atof(GeomXYZ[i].Y);
708 if(!test(GeomXYZ[i].Z))
709 V[2] = get_value_variableXYZ(GeomXYZ[i].Z);
710 else
711 V[2] = atof(GeomXYZ[i].Z);
712 if(Units==1)
713 {
714 V[0] /= BOHR_TO_ANG;
715 V[1] /= BOHR_TO_ANG;
716 V[2] /= BOHR_TO_ANG;
717 }
718 }
719 /************************************************************************/
set_multiple_bonds()720 static void set_multiple_bonds()
721 {
722 gint* nBonds = NULL;
723 gint i;
724 gint j;
725 if(NcentersXYZ<1) return;
726 nBonds = g_malloc(NcentersXYZ*sizeof(gint));
727
728 for(i=0;i<(gint)NcentersXYZ;i++) nBonds[i] = 0;
729 for(i=0;i<(gint)NcentersXYZ;i++)
730 for(j=i+1;j<(gint)NcentersXYZ;j++)
731 if(GeomXYZ[i].typeConnections && GeomXYZ[i].typeConnections[j]!=0)
732 {
733 nBonds[i] += 1;
734 nBonds[j] += 1;
735 }
736 for(i=0;i<(gint)NcentersXYZ;i++)
737 {
738 SAtomsProp Prop_i = prop_atom_get(GeomXYZ[i].Symb);
739 if(!GeomXYZ[i].typeConnections) continue;
740 for(j=i+1;j<(gint)NcentersXYZ;j++)
741 {
742 SAtomsProp Prop_j;
743 if(GeomXYZ[i].typeConnections[j]==0) continue;
744 Prop_j = prop_atom_get(GeomXYZ[j].Symb);
745 if(
746 nBonds[i] < Prop_i.maximumBondValence &&
747 nBonds[j] < Prop_j.maximumBondValence
748 )
749 {
750 GeomXYZ[i].typeConnections[j] = 2;
751 if(GeomXYZ[j].typeConnections) GeomXYZ[j].typeConnections[i] = 2;
752 nBonds[i] += 1;
753 nBonds[j] += 1;
754 }
755 g_free(Prop_j.name);
756 g_free(Prop_j.symbol);
757 }
758 g_free(Prop_i.name);
759 g_free(Prop_i.symbol);
760 }
761 for(i=0;i<(gint)NcentersXYZ;i++)
762 {
763 SAtomsProp Prop_i = prop_atom_get(GeomXYZ[i].Symb);
764 if(!GeomXYZ[i].typeConnections) continue;
765 for(j=i+1;j<(gint)NcentersXYZ;j++)
766 {
767 SAtomsProp Prop_j;
768 if(GeomXYZ[i].typeConnections[j]==0) continue;
769 Prop_j = prop_atom_get(GeomXYZ[j].Symb);
770 if(
771 nBonds[i] < Prop_i.maximumBondValence &&
772 nBonds[j] < Prop_j.maximumBondValence
773 )
774 {
775 GeomXYZ[i].typeConnections[j] = 3;
776 if(GeomXYZ[j].typeConnections) GeomXYZ[j].typeConnections[i] = 3;
777 nBonds[i] += 1;
778 nBonds[j] += 1;
779 }
780 g_free(Prop_j.name);
781 g_free(Prop_j.symbol);
782 }
783 g_free(Prop_i.name);
784 g_free(Prop_i.symbol);
785 }
786 g_free(nBonds);
787 }
788 /*****************************************************************************/
reset_connections_XYZ()789 void reset_connections_XYZ()
790 {
791 gint i,j;
792 for(i=0;i<NcentersXYZ;i++)
793 {
794 if(GeomXYZ[i].typeConnections) g_free(GeomXYZ[i].typeConnections);
795 GeomXYZ[i].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
796 for(j=0;j<NcentersXYZ;j++) GeomXYZ[i].typeConnections[j] = 0;
797 for(j=0;j<NcentersXYZ;j++)
798 if(i!=j && connected(i,j)) GeomXYZ[i].typeConnections[j]=1;
799 }
800 set_multiple_bonds();
801 }
802 /*****************************************************************************/
connecteds(guint i,guint j)803 gboolean connecteds(guint i,guint j)
804 {
805 gdouble distance;
806 gdouble dif[3];
807 guint k;
808 gdouble V1[3];
809 gdouble V2[3];
810 gdouble vd1;
811 gdouble vd2;
812 SAtomsProp Prop;
813
814 if(GeomXYZ[i].typeConnections)
815 {
816 if(GeomXYZ[i].typeConnections[j]>0) return TRUE;
817 else return FALSE;
818 }
819 if(GeomXYZ[j].typeConnections)
820 {
821 if(GeomXYZ[j].typeConnections[i]>0) return TRUE;
822 else return FALSE;
823 }
824 set_coord(i,V1);
825 set_coord(j,V2);
826
827 dif[0] = V1[0]-V2[0];
828 dif[1] = V1[1]-V2[1];
829 dif[2] = V1[2]-V2[2];
830
831 distance = 0;
832 for (k=0;k<3;k++)
833 distance +=dif[k]*dif[k];
834 distance = sqrt(distance);
835
836 Prop = prop_atom_get(GeomXYZ[i].Symb);
837 vd1 = Prop.covalentRadii;
838 g_free(Prop.symbol);
839
840 Prop = prop_atom_get(GeomXYZ[j].Symb);
841 vd2 = Prop.covalentRadii;
842 g_free(Prop.name);
843 g_free(Prop.symbol);
844
845 if(distance<(vd1+vd2))
846 return TRUE;
847 else
848 return FALSE;
849 }
850 /********************************************************************************/
clearList(GtkWidget * myList)851 static void clearList(GtkWidget* myList)
852 {
853 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
854 GtkListStore *store = GTK_LIST_STORE (model);
855 if(myList == list) g_signal_handlers_disconnect_by_func (model, row_deleted, NULL);
856 gtk_list_store_clear(store);
857 if(myList == list) g_signal_connect_after(G_OBJECT (model), "row_deleted", G_CALLBACK(row_deleted), NULL);
858 }
859 /********************************************************************************/
removeFromList(GtkWidget * myList,gint ligne)860 static void removeFromList(GtkWidget* myList, gint ligne)
861 {
862 GtkTreeModel *model;
863 GtkListStore *store;
864 GtkTreeIter iter;
865 gchar* tmp;
866
867 if(ligne<0) return;
868
869 tmp = g_strdup_printf("%d",ligne);
870
871 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
872 store = GTK_LIST_STORE (model);
873
874 if(myList == list) g_signal_handlers_disconnect_by_func (model, row_deleted, NULL);
875 if(gtk_tree_model_get_iter_from_string (model, &iter, tmp))
876 {
877 gtk_list_store_remove(store, &iter);
878 }
879 g_free(tmp);
880 if(myList == list) g_signal_connect_after(G_OBJECT (model), "row_deleted", G_CALLBACK(row_deleted), NULL);
881
882
883
884 }
885 /********************************************************************************/
changeNameVariableInGeometry(gchar * oldName,gchar * newName)886 static void changeNameVariableInGeometry(gchar* oldName, gchar* newName)
887 {
888 gint i;
889 gint k=-1;
890 for(i=0;i<NcentersXYZ;i++)
891 {
892 if(!strcmp(GeomXYZ[i].X,oldName))
893 {
894 if(GeomXYZ[i].X) g_free(GeomXYZ[i].X);
895 GeomXYZ[i].X = g_strdup(newName);
896 k = 0;
897 }
898 if(!strcmp(GeomXYZ[i].Y,oldName))
899 {
900 if(GeomXYZ[i].Y) g_free(GeomXYZ[i].Y);
901 GeomXYZ[i].Y = g_strdup(newName);
902 k = 0;
903 }
904 if(!strcmp(GeomXYZ[i].Z,oldName))
905 {
906 if(GeomXYZ[i].Z) g_free(GeomXYZ[i].Z);
907 GeomXYZ[i].Z = g_strdup(newName);
908 k=0;
909 }
910 }
911 if(k==0)
912 {
913 clearList(list);
914 append_list();
915 }
916 }
917 /********************************************************************************/
editedVariable(GtkCellRendererText * cell,gchar * path_string,gchar * new_text,gpointer data)918 static void editedVariable (GtkCellRendererText *cell, gchar *path_string,
919 gchar *new_text, gpointer data)
920 {
921 GtkTreeModel *model = GTK_TREE_MODEL (data);
922 GtkTreeIter iter;
923 GtkTreePath *path = NULL;
924 gint numCol = 0;
925 gint Nc = -1;
926 numCol = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),"NumColumn"));
927 gchar* oldName = NULL;
928 if(numCol==0)
929 {
930 Nc = -1;
931 if(!variable_name_valid(new_text))
932 {
933 show_forbidden_characters();
934 return;
935 }
936 if ( !strcmp(new_text, "")) return;
937 Nc = atoi(path_string);
938 if(TestVariablesXYZCreated(new_text,Nc) )
939 {
940 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Error"),TRUE);
941 return;
942 }
943 }
944 if(numCol==1)
945 {
946 if(!test(new_text))
947 {
948 gchar* message=g_strdup_printf(_("Sorry %s is not a number \n"),new_text);
949 MessageGeom(message,_("Error"),TRUE);
950 g_free(message);
951 return;
952 }
953 if ( !strcmp(new_text, "")) return;
954 Nc = atoi(path_string);
955 if(test(new_text) && !testpointeE(new_text) )
956 new_text=g_strdup_printf("%s.0",new_text);
957 }
958 if(Nc<0)return;
959 if(numCol==0)
960 {
961 oldName = VariablesXYZ[Nc].Name;
962 VariablesXYZ[Nc].Name=g_strdup(new_text);
963 }
964 if(numCol==1)
965 {
966 if(VariablesXYZ[Nc].Value) g_free(VariablesXYZ[Nc].Value);
967 VariablesXYZ[Nc].Value=g_strdup(new_text);
968 }
969
970 path = gtk_tree_path_new_from_string (path_string);
971 gtk_tree_model_get_iter (model, &iter, path);
972 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
973
974 gtk_tree_path_free (path);
975 if(numCol==0 && oldName)
976 {
977 changeNameVariableInGeometry(oldName, new_text);
978 g_free(oldName);
979 }
980 if(numCol==1 && GeomDrawingArea != NULL) rafresh_drawing();
981 }
982 /********************************************************************************/
editedGeom(GtkCellRendererText * cell,gchar * path_string,gchar * new_text,gpointer data)983 static void editedGeom (GtkCellRendererText *cell, gchar *path_string,
984 gchar *new_text, gpointer data)
985 {
986 GtkTreeModel *model = GTK_TREE_MODEL (data);
987 GtkTreeIter iter;
988 GtkTreePath *path = NULL;
989 gint numCol = 0;
990 gint Nc = -1;
991 if(!new_text) return;
992 numCol = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),"NumColumn"));
993 if(numCol==0)
994 {
995 gint i;
996 gint j;
997 gint oldNum = atoi(path_string);
998 gint newNum = atoi(new_text)-1;
999 GeomXYZAtomDef g;
1000 if(newNum<0 || newNum>=NcentersXYZ)return;
1001 if(newNum==oldNum)return;
1002 /* swap oldNum and newNum */
1003 g = GeomXYZ[oldNum];
1004 GeomXYZ[oldNum] = GeomXYZ[newNum];
1005 GeomXYZ[newNum] = g;
1006 for (i = 0; i <(gint)NcentersXYZ; i++)
1007 {
1008 if(!GeomXYZ[i].typeConnections) continue;
1009 j = GeomXYZ[i].typeConnections[oldNum];
1010 GeomXYZ[i].typeConnections[oldNum] = GeomXYZ[i].typeConnections[newNum];
1011 GeomXYZ[i].typeConnections[newNum] = j;
1012 }
1013
1014 clearList(list);
1015 append_list();
1016 if(GeomDrawingArea != NULL) rafresh_drawing();
1017 return;
1018 }
1019 /* symbol */
1020 if(numCol==1)
1021 {
1022 gint nc = strlen(new_text);
1023 if(nc<1)return;
1024 new_text[0]=toupper(new_text[0]);
1025 if(nc>1)new_text[1]=tolower(new_text[1]);
1026 if(!test_atom_define(new_text))
1027 {
1028 gchar* message=g_strdup_printf(_("Sorry %s is not a symbol for an atom \n"),new_text);
1029 MessageGeom(message,_("Error"),TRUE);
1030 g_free(message);
1031 return;
1032 }
1033 Nc = atoi(path_string);
1034 if(GeomXYZ[Nc].Symb) g_free(GeomXYZ[Nc].Symb);
1035 GeomXYZ[Nc].Symb = g_strdup(new_text);
1036 path = gtk_tree_path_new_from_string (path_string);
1037 gtk_tree_model_get_iter (model, &iter, path);
1038 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1039 gtk_tree_path_free (path);
1040 if(GeomDrawingArea != NULL) rafresh_drawing();
1041 return;
1042 }
1043 /* MM Type */
1044 if(numCol==2)
1045 {
1046 gint nc = strlen(new_text);
1047 if(nc<1)return;
1048 Nc = atoi(path_string);
1049 if(GeomXYZ[Nc].mmType) g_free(GeomXYZ[Nc].mmType);
1050 GeomXYZ[Nc].mmType = g_strdup(new_text);
1051 path = gtk_tree_path_new_from_string (path_string);
1052 gtk_tree_model_get_iter (model, &iter, path);
1053 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1054 gtk_tree_path_free (path);
1055 if(GeomDrawingArea != NULL) rafresh_drawing();
1056 return;
1057 }
1058 /* PDB Type */
1059 if(numCol==3)
1060 {
1061 gint nc = strlen(new_text);
1062 if(nc<1)return;
1063 Nc = atoi(path_string);
1064 if(GeomXYZ[Nc].pdbType) g_free(GeomXYZ[Nc].pdbType);
1065 GeomXYZ[Nc].pdbType = g_strdup(new_text);
1066 path = gtk_tree_path_new_from_string (path_string);
1067 gtk_tree_model_get_iter (model, &iter, path);
1068 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1069 gtk_tree_path_free (path);
1070 if(GeomDrawingArea != NULL) rafresh_drawing();
1071 return;
1072 }
1073 /* Residue Name */
1074 if(numCol==4)
1075 {
1076 gint nc = strlen(new_text);
1077 if(nc<1)return;
1078 Nc = atoi(path_string);
1079 if(strcmp(GeomXYZ[Nc].Residue,new_text))
1080 {
1081 if(GeomXYZ[Nc].Residue) g_free(GeomXYZ[Nc].Residue);
1082 GeomXYZ[Nc].Residue = g_strdup(new_text);
1083 gint k;
1084 GeomXYZ[Nc].ResidueNumber = -1;
1085 for(k=0;k<(gint)NcentersXYZ;k++)
1086 {
1087 if(Nc != k && !strcmp(GeomXYZ[Nc].Residue,GeomXYZ[k].Residue))
1088 {
1089 GeomXYZ[Nc].ResidueNumber = GeomXYZ[k].ResidueNumber;
1090 break;
1091 }
1092 }
1093 if(GeomXYZ[Nc].ResidueNumber == -1)
1094 {
1095 for(k=0;k<(gint)NcentersXYZ;k++)
1096 {
1097 if(GeomXYZ[Nc].ResidueNumber<GeomXYZ[k].ResidueNumber)
1098 GeomXYZ[Nc].ResidueNumber = GeomXYZ[k].ResidueNumber;
1099 }
1100 GeomXYZ[Nc].ResidueNumber += 1;
1101 }
1102 }
1103 path = gtk_tree_path_new_from_string (path_string);
1104 gtk_tree_model_get_iter (model, &iter, path);
1105 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1106 gtk_tree_path_free (path);
1107 if(GeomDrawingArea != NULL) rafresh_drawing();
1108 return;
1109 }
1110 /* X, Y or Z */
1111 if(numCol==5 || numCol==6 || numCol==7)
1112 {
1113 gint nc = strlen(new_text);
1114 if(nc<1)return;
1115 Nc = atoi(path_string);
1116 if(testav(new_text)<-1)
1117 {
1118 gchar* message=g_strdup_printf(_("Sorry\n %s \nis not a number \nand is not a variable "),new_text);
1119 MessageGeom(message,_("Error"),TRUE);
1120 g_free(message);
1121 return;
1122 }
1123 if(test(new_text) && !testpointeE(new_text) )
1124 new_text=g_strdup_printf("%s.0",new_text);
1125 if(numCol==5)
1126 {
1127 if(GeomXYZ[Nc].X) g_free(GeomXYZ[Nc].X);
1128 GeomXYZ[Nc].X = g_strdup(new_text);
1129 }
1130 if(numCol==6)
1131 {
1132 if(GeomXYZ[Nc].Y) g_free(GeomXYZ[Nc].Y);
1133 GeomXYZ[Nc].Y = g_strdup(new_text);
1134 }
1135 if(numCol==7)
1136 {
1137 if(GeomXYZ[Nc].Z) g_free(GeomXYZ[Nc].Z);
1138 GeomXYZ[Nc].Z = g_strdup(new_text);
1139 }
1140 path = gtk_tree_path_new_from_string (path_string);
1141 gtk_tree_model_get_iter (model, &iter, path);
1142 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1143 gtk_tree_path_free (path);
1144 if(GeomDrawingArea != NULL) rafresh_drawing();
1145 return;
1146 }
1147 /* Charge */
1148 if(numCol==8)
1149 {
1150 gint nc = strlen(new_text);
1151 gchar* txt = NULL;
1152 if(nc<1)return;
1153 Nc = atoi(path_string);
1154 if(!test(new_text))
1155 {
1156 gchar* message=g_strdup_printf(_("Sorry %s is not a number \n"),new_text);
1157 MessageGeom(message,_("Error"),TRUE);
1158 g_free(message);
1159 return;
1160 }
1161 if(test(new_text) && !testpointeE(new_text) )
1162 txt=g_strdup_printf("%s.0",new_text);
1163 else
1164 txt=g_strdup_printf("%s",new_text);
1165 if(GeomXYZ[Nc].Charge) g_free(GeomXYZ[Nc].Charge);
1166 GeomXYZ[Nc].Charge = g_strdup(new_text);
1167 path = gtk_tree_path_new_from_string (path_string);
1168 gtk_tree_model_get_iter (model, &iter, path);
1169 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, txt, -1);
1170 gtk_tree_path_free (path);
1171 if(GeomDrawingArea != NULL) rafresh_drawing();
1172 if(txt) g_free(txt);
1173 return;
1174 }
1175 /* Layer */
1176 if(numCol==9)
1177 {
1178 gint nc = strlen(new_text);
1179 gint i;
1180 if(nc<1)return;
1181 new_text[0] = toupper(new_text[0]);
1182 for(i=1;i<nc;i++) new_text[i] = tolower(new_text[i]);
1183 Nc = atoi(path_string);
1184 if(!(!strcmp(new_text,"High")
1185 || !strcmp(new_text,"Medium")
1186 ||!strcmp(new_text,"Low")
1187 || !strcmp(new_text," ")))
1188 {
1189 gchar* message=g_strdup_printf(_("Sorry The layer should be High, Medium, Low or one space \n"));
1190 MessageGeom(message,_("Error"),TRUE);
1191 g_free(message);
1192 return;
1193 }
1194 if(GeomXYZ[Nc].Layer) g_free(GeomXYZ[Nc].Layer);
1195 GeomXYZ[Nc].Layer = g_strdup(new_text);
1196 path = gtk_tree_path_new_from_string (path_string);
1197 gtk_tree_model_get_iter (model, &iter, path);
1198 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2*numCol, new_text, -1);
1199 gtk_tree_path_free (path);
1200 if(GeomDrawingArea != NULL) rafresh_drawing();
1201 return;
1202 }
1203 }
1204 /********************************************************************************/
insertToList(GtkWidget * myList,gint ligne,gchar * texts[],gint nColumns)1205 static void insertToList(GtkWidget* myList, gint ligne, gchar* texts[], gint nColumns)
1206 {
1207 GtkTreeModel *model;
1208 GtkListStore *store;
1209 GtkTreeIter iter;
1210 gint k;
1211
1212 if(ligne<0) ligne = 0;
1213
1214 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
1215 store = GTK_LIST_STORE (model);
1216
1217 if(myList == list) g_signal_handlers_disconnect_by_func (model, row_inserted, NULL);
1218 gtk_list_store_insert(store, &iter, ligne);
1219 for(k=0;k<nColumns;k++)
1220 {
1221 gboolean ed = TRUE;
1222 /*if(k==0 && myList == list) ed=FALSE;*/
1223 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
1224 g_free(texts[k]);
1225 }
1226 if(myList == list) g_signal_connect_after(G_OBJECT (model), "row_inserted", G_CALLBACK(row_inserted), NULL);
1227 }
1228 /********************************************************************************/
appendToList(GtkWidget * myList,gchar * texts[],gint nColumns)1229 static void appendToList(GtkWidget* myList, gchar* texts[], gint nColumns)
1230 {
1231 GtkTreeModel *model;
1232 GtkListStore *store;
1233 GtkTreeIter iter;
1234 gint k;
1235
1236 model = gtk_tree_view_get_model(GTK_TREE_VIEW(myList));
1237 store = GTK_LIST_STORE (model);
1238
1239 if(myList == list) g_signal_handlers_disconnect_by_func (model, row_inserted, NULL);
1240 gtk_list_store_append(store, &iter);
1241 for(k=0;k<nColumns;k++)
1242 {
1243 gboolean ed = TRUE;
1244 /* if(k==0 && myList == list) ed=FALSE;*/
1245 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
1246 g_free(texts[k]);
1247 }
1248 if(myList == list) g_signal_connect_after(G_OBJECT (model), "row_inserted", G_CALLBACK(row_inserted), NULL);
1249 }
1250 /********************************************************************************/
append_list()1251 static void append_list()
1252 {
1253 gchar *texts[NUMBER_LIST_XYZ];
1254 guint Nc;
1255 gint k;
1256 GtkTreeIter iter;
1257 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(list));
1258 GtkListStore *store = GTK_LIST_STORE (model);
1259
1260 model = GTK_TREE_MODEL (store);
1261 g_signal_handlers_disconnect_by_func (model, row_inserted, NULL);
1262
1263 for(Nc=0;Nc<NcentersXYZ;Nc++)
1264 {
1265 texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
1266 texts[E_SYMBOL] = g_strdup(GeomXYZ[Nc].Symb);
1267 texts[E_RESIDUE] = g_strdup(GeomXYZ[Nc].Residue);
1268 texts[E_MMTYPE] = g_strdup(GeomXYZ[Nc].mmType);
1269 texts[E_PDBTYPE] = g_strdup(GeomXYZ[Nc].pdbType);
1270 texts[E_X] = g_strdup(GeomXYZ[Nc].X);
1271 texts[E_Y] = g_strdup(GeomXYZ[Nc].Y);
1272 texts[E_Z] = g_strdup(GeomXYZ[Nc].Z);
1273 texts[E_CHARGE] = g_strdup(GeomXYZ[Nc].Charge);
1274 texts[E_LAYER] = g_strdup(GeomXYZ[Nc].Layer);
1275
1276 gtk_list_store_append (store, &iter);
1277 for(k=0;k<NUMBER_LIST_XYZ;k++)
1278 {
1279 gboolean ed = TRUE;
1280 /* if(k==0) ed=FALSE;*/
1281 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,ed, -1);
1282 g_free(texts[k]);
1283 }
1284 }
1285 g_signal_connect_after(G_OBJECT (model), "row_inserted", G_CALLBACK(row_inserted), NULL);
1286 }
1287 /*****************************************************************************/
get_distance_xyz(gint i,gint j)1288 static gdouble get_distance_xyz(gint i,gint j)
1289 {
1290 guint k;
1291 gchar *serr;
1292 gdouble res;
1293 Point A;
1294 Point B;
1295 gdouble Pos[3];
1296
1297 if(i>=(gint)NcentersXYZ || j >=(gint)NcentersXYZ || i<0 || j<0)
1298 {
1299 return -1000;
1300 }
1301 get_position(i,Pos);
1302 for(k=0;k<3;k++)
1303 A.C[k] = Pos[k];
1304 get_position(j,Pos);
1305 for(k=0;k<3;k++)
1306 B.C[k] = Pos[k];
1307 serr = get_distance_points(A,B,FALSE);
1308 res = atof(serr);
1309 g_free(serr);
1310 return res;
1311 }
1312 /*****************************************************************************/
sort_GeomXYZ()1313 static void sort_GeomXYZ()
1314 {
1315 gint i;
1316 gint j;
1317 gint k;
1318 GeomXYZAtomDef t;
1319 gint* oldNum = NULL;
1320 gint* N = NULL;
1321
1322
1323 if (NcentersXYZ <= 0) return ;
1324 oldNum = g_malloc(NcentersXYZ*sizeof(gint));
1325 for (i = 0; i <(gint)NcentersXYZ; i++) oldNum[i] = i;
1326
1327 N = g_malloc(NcentersXYZ*sizeof(gint));
1328 for (i = 0; i <(gint)NcentersXYZ; i++) N[i] = 0;
1329
1330 for (i = 1; i <(gint)NcentersXYZ-1; i++)
1331 {
1332 k = i;
1333 for (j = i+1; j <(gint)NcentersXYZ; j++)
1334 if( get_distance_xyz(j,i-1)<get_distance_xyz(k,i-1))
1335 k = j;
1336 if(k!=i)
1337 {
1338 t= GeomXYZ[i];
1339 GeomXYZ[i] = GeomXYZ[k];
1340 GeomXYZ[k] = t;
1341 j = oldNum[i];
1342 oldNum[i] = oldNum[k];
1343 oldNum[k] = j;
1344 }
1345 }
1346 for (i = 0; i <(gint)NcentersXYZ; i++)
1347 {
1348 if(!GeomXYZ[i].typeConnections) continue;
1349 for (j = 0; j <(gint)NcentersXYZ; j++) N[j] = GeomXYZ[i].typeConnections[j];
1350 for (j = 0; j <(gint)NcentersXYZ; j++) GeomXYZ[i].typeConnections[j]=N[oldNum[j]];
1351 }
1352 if(N) g_free(N);
1353 if(oldNum) g_free(oldNum);
1354
1355 if(GeomIsOpen)
1356 {
1357 clearList(list);
1358 append_list();
1359 }
1360 if(GeomDrawingArea != NULL)
1361 draw_geometry(NULL,NULL);
1362 }
1363 /*****************************************************************************/
sortGeomXYZByResidueNumber()1364 static void sortGeomXYZByResidueNumber()
1365 {
1366 gint i;
1367 gint j;
1368 gint k;
1369 GeomXYZAtomDef t;
1370 gint* oldNum = NULL;
1371 gint* N = NULL;
1372
1373 if (NcentersXYZ <= 0) return ;
1374 oldNum = g_malloc(NcentersXYZ*sizeof(gint));
1375 for (i = 0; i <(gint)NcentersXYZ; i++) oldNum[i] = i;
1376
1377 N = g_malloc(NcentersXYZ*sizeof(gint));
1378 for (i = 0; i <(gint)NcentersXYZ; i++) N[i] = 0;
1379
1380 for (i = 0; i <(gint)NcentersXYZ-1; i++)
1381 {
1382 k = i;
1383 for (j = i+1; j <(gint)NcentersXYZ; j++)
1384 if( GeomXYZ[j].ResidueNumber<GeomXYZ[k].ResidueNumber)
1385 k = j;
1386 if(k!=i)
1387 {
1388 t= GeomXYZ[i];
1389 GeomXYZ[i] = GeomXYZ[k];
1390 GeomXYZ[k] = t;
1391 j = oldNum[i];
1392 oldNum[i] = oldNum[k];
1393 oldNum[k] = j;
1394 }
1395 }
1396 for (i = 0; i <(gint)NcentersXYZ; i++)
1397 {
1398 if(!GeomXYZ[i].typeConnections) continue;
1399 for (j = 0; j <(gint)NcentersXYZ; j++) N[j] = GeomXYZ[i].typeConnections[j];
1400 for (j = 0; j <(gint)NcentersXYZ; j++) GeomXYZ[i].typeConnections[j]=N[oldNum[j]];
1401 }
1402 if(N) g_free(N);
1403 if(oldNum) g_free(oldNum);
1404 if(GeomIsOpen)
1405 {
1406 clearList(list);
1407 append_list();
1408 }
1409 if(GeomDrawingArea != NULL)
1410 draw_geometry(NULL,NULL);
1411 }
1412 /********************************************************************************/
append_VariablesXYZ_in_list()1413 void append_VariablesXYZ_in_list()
1414 {
1415 gchar *texts[2];
1416 guint i;
1417 gint k;
1418 GtkTreeIter iter;
1419 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(listv));
1420 GtkListStore *store = GTK_LIST_STORE (model);
1421
1422 model = GTK_TREE_MODEL (store);
1423
1424 for(i=0;i<NVariablesXYZ;i++)
1425 {
1426 texts[0] = g_strdup(VariablesXYZ[i].Name);
1427 texts[1] = g_strdup(VariablesXYZ[i].Value);
1428
1429 gtk_list_store_append (store, &iter);
1430 for(k=0;k<2;k++)
1431 {
1432 gtk_list_store_set (store, &iter, k+k, texts[k],k+k+1,TRUE, -1);
1433 g_free(texts[k]);
1434 }
1435 }
1436 }
1437 /********************************************************************************/
FreeGeomXYZ(GeomXYZAtomDef * GeomXYZtemp,VariablesXYZDef * VariablesXYZtemp,gint Ncent,gint Nvar)1438 void FreeGeomXYZ(GeomXYZAtomDef* GeomXYZtemp, VariablesXYZDef* VariablesXYZtemp, gint Ncent, gint Nvar)
1439 {
1440 gint i;
1441 if(GeomXYZtemp)
1442 {
1443 for(i=0;i<Ncent;i++)
1444 {
1445 if(GeomXYZtemp[i].Symb)
1446 g_free(GeomXYZtemp[i].Symb);
1447 if(GeomXYZtemp[i].mmType)
1448 g_free(GeomXYZtemp[i].mmType);
1449 if(GeomXYZtemp[i].pdbType)
1450 g_free(GeomXYZtemp[i].pdbType);
1451 if(GeomXYZtemp[i].X)
1452 g_free(GeomXYZtemp[i].X);
1453 if(GeomXYZtemp[i].Y)
1454 g_free(GeomXYZtemp[i].Y);
1455 if(GeomXYZtemp[i].Z)
1456 g_free(GeomXYZtemp[i].Z);
1457 if(GeomXYZtemp[i].Charge)
1458 g_free(GeomXYZtemp[i].Charge);
1459 if(GeomXYZtemp[i].Layer)
1460 g_free(GeomXYZtemp[i].Layer);
1461 if(GeomXYZtemp[i].typeConnections)
1462 g_free(GeomXYZtemp[i].typeConnections);
1463 }
1464 g_free(GeomXYZtemp);
1465 }
1466 if(VariablesXYZtemp)
1467 {
1468 for(i=0;i<Nvar;i++)
1469 {
1470 g_free(VariablesXYZtemp[i].Name);
1471 g_free(VariablesXYZtemp[i].Value);
1472 }
1473 g_free(VariablesXYZtemp);
1474 }
1475 init_dipole();
1476 }
1477 /********************************************************************************/
freeGeomXYZ()1478 void freeGeomXYZ()
1479 {
1480 guint i;
1481 for(i=0;i<NcentersXYZ;i++)
1482 {
1483 g_free(GeomXYZ[i].Symb);
1484 g_free(GeomXYZ[i].mmType);
1485 g_free(GeomXYZ[i].pdbType);
1486 g_free(GeomXYZ[i].Residue);
1487 g_free(GeomXYZ[i].X);
1488 g_free(GeomXYZ[i].Y);
1489 g_free(GeomXYZ[i].Z);
1490 g_free(GeomXYZ[i].Charge);
1491 g_free(GeomXYZ[i].Layer);
1492 if(GeomXYZ[i].typeConnections) g_free(GeomXYZ[i].typeConnections);
1493 }
1494 g_free(GeomXYZ);
1495 GeomXYZ = NULL;
1496 NcentersXYZ = 0;
1497 init_dipole();
1498 }
1499 /********************************************************************************/
freeVariablesXYZ()1500 void freeVariablesXYZ()
1501 {
1502 guint i;
1503 for(i=0;i<NVariablesXYZ;i++)
1504 {
1505 g_free(VariablesXYZ[i].Name);
1506 g_free(VariablesXYZ[i].Value);
1507 }
1508 g_free(VariablesXYZ);
1509 VariablesXYZ = NULL;
1510 NVariablesXYZ = 0;
1511 }
1512 /********************************************************************************/
destroy_dialogue(GtkWidget * win,gpointer d)1513 static void destroy_dialogue(GtkWidget *win,gpointer d)
1514 {
1515 if(DestroyDialog)
1516 {
1517 delete_child(win);
1518 }
1519 }
1520 /********************************************************************************/
compute_volume_molecule()1521 void compute_volume_molecule()
1522 {
1523 gint i,j;
1524 gdouble X;
1525 gdouble Y;
1526 gdouble Z;
1527 gdouble vol = 0;
1528 gdouble r =0;
1529 gdouble rmax =0;
1530 gdouble C[3]={0,0,0};
1531 gint nAtoms = 0;
1532 gdouble volNonH = 18.0;
1533 gint nAtomsNonH = 0;
1534
1535
1536 if(NcentersXYZ>1)
1537 /*
1538 for(i=0;i<NcentersXYZ;i++)
1539 {
1540 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) continue;
1541 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1542 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1543 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1544 C[0] = X;
1545 C[1] = Y;
1546 C[2] = Z;
1547 nAtoms++;
1548 if(strcmp(GeomXYZ[i].Symb, "H")) nAtomsNonH++;
1549 for(j=i+1;j<NcentersXYZ;j++)
1550 {
1551 if(!strcmp(GeomXYZ[j].Symb, "TV") || !strcmp(GeomXYZ[j].Symb, "Tv")) continue;
1552 if(!test(GeomXYZ[j].X)) X = get_value_variableXYZ(GeomXYZ[j].X); else X = atof(GeomXYZ[j].X);
1553 if(!test(GeomXYZ[j].Y)) Y = get_value_variableXYZ(GeomXYZ[j].Y); else Y = atof(GeomXYZ[j].Y);
1554 if(!test(GeomXYZ[j].Z)) Z = get_value_variableXYZ(GeomXYZ[j].Z); else Z = atof(GeomXYZ[j].Z);
1555 r = (C[0]-X)*(C[0]-X)+(C[1]-Y)*(C[1]-Y)+(C[2]-Z)*(C[2]-Z);
1556 if(r>rmax) rmax = r;
1557 }
1558 }
1559 rmax = sqrt(rmax)/2;
1560 */
1561 for(i=0;i<NcentersXYZ;i++)
1562 {
1563 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) continue;
1564 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1565 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1566 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1567 C[0] += X;
1568 C[1] += Y;
1569 C[2] += Z;
1570 nAtoms++;
1571 if(strcmp(GeomXYZ[i].Symb, "H")) nAtomsNonH++;
1572 }
1573 if(nAtoms>1)
1574 {
1575 for(i=0;i<3;i++) C[i] /= nAtoms;
1576 for(i=0;i<NcentersXYZ;i++)
1577 {
1578 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) continue;
1579 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1580 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1581 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1582 r = (C[0]-X)*(C[0]-X)+(C[1]-Y)*(C[1]-Y)+(C[2]-Z)*(C[2]-Z);
1583 if(r>rmax) rmax = r;
1584 }
1585 rmax = sqrt(rmax);
1586 }
1587
1588 if(nAtoms<2)
1589 {
1590 gchar* t = g_strdup_printf(_("Sorry,\nI cannot compute volume with only %d atoms"),nAtoms);
1591 Message(t,_("Error"),TRUE);
1592 g_free(t);
1593 return;
1594 }
1595 if(Units==0) rmax *= BOHR_TO_ANG;
1596
1597 {
1598 gchar* t = g_strdup_printf(_(
1599 "rmax = %lf Angstrom\nVolume = 4/3 pi rmax^3 = %0.6lf Angstrom^3\n\n"
1600 "Volume by Crystallographers (18 ang^3 by # of a non H atom) = %0.6lf Angstrom^3\n\n"
1601 " 18 ang^3 * # of atoms = %0.6lf Angstrom^3\n"
1602 ),
1603 rmax,4*M_PI*rmax*rmax*rmax/3.0,
1604 volNonH*nAtomsNonH,
1605 volNonH*nAtoms
1606 );
1607 Message(t,_("Info"),TRUE);
1608 g_free(t);
1609 return;
1610 }
1611 }
1612 /********************************************************************************/
compute_volume_cell()1613 void compute_volume_cell()
1614 {
1615 gint i;
1616 gdouble X;
1617 gdouble Y;
1618 gdouble Z;
1619 gdouble TV[3][3];
1620 gdouble cross[3];
1621 gdouble vol = 0;
1622 gint nTV = 0;
1623
1624 if(NcentersXYZ<1) return;
1625 for(i=0;i<NcentersXYZ;i++)
1626 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv"))
1627 {
1628 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1629 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1630 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1631 if(Units==0) { X *= BOHR_TO_ANG; Y *= BOHR_TO_ANG; Z *= BOHR_TO_ANG; }
1632 TV[nTV][0] = X;
1633 TV[nTV][1] = Y;
1634 TV[nTV][2] = Z;
1635 nTV++;
1636 }
1637 if(nTV<3)
1638 {
1639 gchar* t = g_strdup_printf(_("Sorry,\nI cannot compute volume with only %d Tv vectors"),nTV);
1640 Message(t,_("Error"),TRUE);
1641 g_free(t);
1642 return;
1643 }
1644
1645 for(i=0;i<3;i++) cross[i] = TV[0][(i+1)%3]*TV[1][(i+2)%3]-TV[0][(i+2)%3]*TV[1][(i+1)%3];
1646 for(i=0;i<3;i++) vol += cross[i]*TV[2][i];
1647 {
1648 gchar* t = g_strdup_printf(_("Volume = %0.8lf Angstrom^3"),fabs(vol));
1649 Message(t,_("Info"),TRUE);
1650 g_free(t);
1651 return;
1652 }
1653
1654 }
1655 /********************************************************************************/
get_crystal_from_GeomXYZ()1656 Crystal* get_crystal_from_GeomXYZ()
1657 {
1658 Crystal* crystal = g_malloc(sizeof(Crystal));
1659 gint i;
1660 gint nAtoms = NcentersXYZ;
1661
1662 initCrystal(crystal);
1663
1664 if(nAtoms<1) return crystal;
1665
1666 /* fprintf(stderr,"Units=%d\n",Units);*/
1667 for(i=0;i<nAtoms;i++)
1668 {
1669 gdouble X,Y,Z;
1670 CrystalloAtom* a = g_malloc(sizeof(CrystalloAtom));
1671
1672 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1673 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1674 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1675 if(Units==0) { X *= (BOHR_TO_ANG); Y *= (BOHR_TO_ANG); Z *= (BOHR_TO_ANG); }
1676 a->C[0] = X;
1677 a->C[1] = Y;
1678 a->C[2] = Z;
1679
1680
1681 a->charge = atof(GeomXYZ[i].Charge);
1682 a->residueNumber = GeomXYZ[i].ResidueNumber;
1683
1684 sprintf(a->symbol,"%s",GeomXYZ[i].Symb);
1685 sprintf(a->mmType,"%s",GeomXYZ[i].mmType);
1686 sprintf(a->pdbType,"%s",GeomXYZ[i].pdbType);
1687 sprintf(a->residueName,"%s",GeomXYZ[i].Residue);
1688
1689 crystal->atoms=g_list_append(crystal->atoms, (gpointer) a);
1690 }
1691 return crystal;
1692 }
1693 /********************************************************************************/
save_cif_file_no_add_list(const gchar * FileName,gboolean allAtoms)1694 void save_cif_file_no_add_list(const gchar* FileName, gboolean allAtoms)
1695 {
1696 FILE *file;
1697 Crystal* crystal = NULL;
1698 gint nAtoms = NcentersXYZ;
1699 gchar* tmp = NULL;
1700 gdouble symprec = 1e-4;
1701 gint i;
1702 gint nTv=0;
1703
1704 if(nAtoms<1) return;
1705 for(i=0;i<nAtoms;i++) if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) nTv++;
1706 if(nTv<3)
1707 {
1708 gchar* t = g_strdup_printf(_("Sorry,\nI cannot create the cif file, only %d Tv vectors are available"),nTv);
1709 Message(t,_("Error"),TRUE);
1710 g_free(t);
1711 return;
1712 }
1713 crystal = get_crystal_from_GeomXYZ();
1714 if(!crystal) return;
1715
1716 file = FOpen(FileName, "w");
1717 if(file == NULL)
1718 {
1719 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
1720 Message(t,_("Error"),TRUE);
1721 g_free(t);
1722 return;
1723 }
1724 tmp = crystalloGetCIF(crystal, symprec, !allAtoms);
1725 if(tmp)
1726 {
1727 fprintf(file,"%s",tmp);
1728 g_free(tmp);
1729 }
1730 fclose(file);
1731 freeCrystal(crystal);
1732 g_free(crystal);
1733 }
1734 /********************************************************************************/
save_poscar_direct_file_no_add_list(const gchar * FileName)1735 void save_poscar_direct_file_no_add_list(const gchar* FileName)
1736 {
1737 gint i;
1738 gint j;
1739 FILE *fd;
1740 gdouble X;
1741 gdouble Y;
1742 gdouble Z;
1743 gchar *temp = NULL;
1744 gint nTV = 0;
1745 gint nTypes = 0;
1746 gint* types = NULL;
1747 gboolean ok;
1748 gchar** listTypes = NULL;
1749 gint* nListTypes = NULL;
1750 Crystal* crystal = NULL;
1751 gint nAtoms = NcentersXYZ;
1752
1753 if(nAtoms<1) return;
1754 for(i=0;i<nAtoms;i++) if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) nTV++;
1755 if(nTV<3)
1756 {
1757 gchar* t = g_strdup_printf(_("Sorry,\nI cannot create the poscar file, only %d Tv vectors are available"),nTV);
1758 Message(t,_("Error"),TRUE);
1759 g_free(t);
1760 return;
1761 }
1762 crystal = get_crystal_from_GeomXYZ();
1763 if(!crystal) return;
1764 crystalloCartnToFract(crystal->atoms);
1765
1766 //printf("nTv = %d\n",nTV);
1767 types = g_malloc(nAtoms*sizeof(gint));
1768 for(i=0;i<nAtoms;i++) types[i] = -1;
1769
1770 nTypes = 0;
1771 for(i=0;i<nAtoms;i++)
1772 {
1773 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) continue;
1774 ok = TRUE;
1775 for(j=0;j<i;j++)
1776 {
1777 if(!strcmp(GeomXYZ[i].Symb,GeomXYZ[j].Symb))
1778 {
1779 types[i]= types[j];
1780 ok = FALSE;
1781 break;
1782 }
1783 }
1784 if(ok)
1785 {
1786 types[i]= nTypes;
1787 nTypes++;
1788 }
1789 }
1790 if(nTypes<1) return;
1791 //printf("nTypes = %d\n",nTypes);
1792 listTypes = g_malloc(nTypes*sizeof(gchar*));
1793 nListTypes = g_malloc(nTypes*sizeof(gint));
1794 for(i=0;i<nTypes;i++) listTypes[i] = NULL;
1795 for(i=0;i<nTypes;i++) nListTypes[i] = 0;
1796 for(i=0;i<nAtoms;i++)
1797 {
1798 if(types[i]==-1) continue;
1799 nListTypes[types[i]]++;
1800 if(!listTypes[types[i]]) listTypes[types[i]] = g_strdup(GeomXYZ[i].Symb);
1801 }
1802
1803 temp = get_suffix_name_file(FileName);
1804 FileName = g_strdup_printf("%s",temp);
1805 g_free(temp);
1806 fd = FOpen(FileName, "w");
1807 if(fd == NULL)
1808 {
1809 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
1810 Message(t,_("Error"),TRUE);
1811 g_free(t);
1812 return;
1813 }
1814 for(i=0;i<nTypes;i++) fprintf(fd,"%s%d ",listTypes[i],nListTypes[i]);
1815 fprintf(fd," : POSCAR (Direct) generated by Gabedit\n");
1816 fprintf(fd,"%6s %0.10lf\n"," ",1.0);
1817 for(i=0;i<NcentersXYZ;i++)
1818 {
1819 if(types[i]!=-1) continue;
1820 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1821 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1822 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1823 if(Units==0) { X *= BOHR_TO_ANG; Y *= BOHR_TO_ANG; Z *= BOHR_TO_ANG; }
1824 fprintf(fd," %20.10f %20.10f %20.10f\n",X,Y,Z);
1825 }
1826 fprintf(fd,"%6s"," ");
1827 for(i=0;i<nTypes;i++) fprintf(fd,"%6s ",listTypes[i]);
1828 fprintf(fd,"\n");
1829 fprintf(fd,"%6s"," ");
1830 for(i=0;i<nTypes;i++) fprintf(fd,"%6d ",nListTypes[i]);
1831 fprintf(fd,"\n");
1832 fprintf(fd,"Direct\n");
1833 for(j=0;j<nTypes;j++)
1834 {
1835 GList *l = NULL;
1836 i=-1;
1837 for(l = g_list_first(crystal->atoms); l != NULL; l = l->next)
1838 {
1839 i++;
1840 CrystalloAtom* crystalloAtom = (CrystalloAtom*)l->data;
1841 if(strstr(crystalloAtom->symbol,"Tv") || strstr(crystalloAtom->symbol,"TV")) continue;
1842 if(types[i]==-1) continue;
1843 if(strcmp(crystalloAtom->symbol,listTypes[j]))continue;
1844 fprintf(fd,"%6s %20.10f %20.10f %20.10f %s\n"," ",crystalloAtom->C[0], crystalloAtom->C[1],crystalloAtom->C[2], crystalloAtom->symbol);
1845 }
1846 }
1847
1848 fclose(fd);
1849 for(i=0;i<nTypes;i++) if(listTypes[i]) g_free(listTypes[i]);
1850 if(listTypes) g_free(listTypes);
1851 if(nListTypes) g_free(nListTypes);
1852 if(types) g_free(types);
1853 freeCrystal(crystal);
1854 g_free(crystal);
1855 }
1856 /********************************************************************************/
save_poscar_file_no_add_list(const gchar * FileName)1857 void save_poscar_file_no_add_list(const gchar* FileName)
1858 {
1859 gint i;
1860 gint j;
1861 FILE *fd;
1862 gdouble X;
1863 gdouble Y;
1864 gdouble Z;
1865 gchar *temp = NULL;
1866 gint nTV = 0;
1867 gint nTypes = 0;
1868 gint* types = NULL;
1869 gboolean ok;
1870 gchar** listTypes = NULL;
1871 gint* nListTypes = NULL;
1872
1873 if(NcentersXYZ<1) return;
1874 for(i=0;i<NcentersXYZ;i++) if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) nTV++;
1875 if(nTV<3)
1876 {
1877 gchar* t = g_strdup_printf(_("Sorry,\nI cannot create the poscar file, only %d Tv vectors are available"),nTV);
1878 Message(t,_("Error"),TRUE);
1879 g_free(t);
1880 return;
1881 }
1882 //printf("nTv = %d\n",nTV);
1883 types = g_malloc(NcentersXYZ*sizeof(gint));
1884 for(i=0;i<NcentersXYZ;i++) types[i] = -1;
1885
1886 nTypes = 0;
1887 for(i=0;i<NcentersXYZ;i++)
1888 {
1889 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv")) continue;
1890 ok = TRUE;
1891 for(j=0;j<i;j++)
1892 {
1893 if(!strcmp(GeomXYZ[i].Symb,GeomXYZ[j].Symb))
1894 {
1895 types[i]= types[j];
1896 ok = FALSE;
1897 break;
1898 }
1899 }
1900 if(ok)
1901 {
1902 types[i]= nTypes;
1903 nTypes++;
1904 }
1905 }
1906 if(nTypes<1) return;
1907 //printf("nTypes = %d\n",nTypes);
1908 listTypes = g_malloc(nTypes*sizeof(gchar*));
1909 nListTypes = g_malloc(nTypes*sizeof(gint));
1910 for(i=0;i<nTypes;i++) listTypes[i] = NULL;
1911 for(i=0;i<nTypes;i++) nListTypes[i] = 0;
1912 for(i=0;i<NcentersXYZ;i++)
1913 {
1914 if(types[i]==-1) continue;
1915 nListTypes[types[i]]++;
1916 if(!listTypes[types[i]]) listTypes[types[i]] = g_strdup(GeomXYZ[i].Symb);
1917 }
1918
1919 temp = get_suffix_name_file(FileName);
1920 FileName = g_strdup_printf("%s",temp);
1921 g_free(temp);
1922 fd = FOpen(FileName, "w");
1923 if(fd == NULL)
1924 {
1925 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
1926 Message(t,_("Error"),TRUE);
1927 g_free(t);
1928 return;
1929 }
1930 for(i=0;i<nTypes;i++) fprintf(fd,"%s%d ",listTypes[i],nListTypes[i]);
1931 fprintf(fd," : POSCAR generated by Gabedit\n");
1932 fprintf(fd,"%6s %0.10lf\n"," ",1.0);
1933 for(i=0;i<NcentersXYZ;i++)
1934 {
1935 if(types[i]!=-1) continue;
1936 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1937 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1938 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1939 if(Units==0) { X *= BOHR_TO_ANG; Y *= BOHR_TO_ANG; Z *= BOHR_TO_ANG; }
1940 fprintf(fd," %20.10f %20.10f %20.10f\n",X,Y,Z);
1941 }
1942 fprintf(fd,"%6s"," ");
1943 for(i=0;i<nTypes;i++) fprintf(fd,"%6s ",listTypes[i]);
1944 fprintf(fd,"\n");
1945 fprintf(fd,"%6s"," ");
1946 for(i=0;i<nTypes;i++) fprintf(fd,"%6d ",nListTypes[i]);
1947 fprintf(fd,"\n");
1948 fprintf(fd,"Cartesian\n");
1949 for(j=0;j<nTypes;j++)
1950 {
1951 for(i=0;i<NcentersXYZ;i++)
1952 {
1953 if(types[i]==-1) continue;
1954 if(strcmp(GeomXYZ[i].Symb,listTypes[j]))continue;
1955 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1956 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1957 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1958 if(Units==0) { X *= BOHR_TO_ANG; Y *= BOHR_TO_ANG; Z *= BOHR_TO_ANG; }
1959 fprintf(fd,"%6s %20.10f %20.10f %20.10f\n"," ",X,Y,Z);
1960 }
1961 }
1962
1963 /*
1964 for(i=0;i<NcentersXYZ;i++)
1965 {
1966 if(types[i]==-1) continue;
1967 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X); else X = atof(GeomXYZ[i].X);
1968 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y); else Y = atof(GeomXYZ[i].Y);
1969 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z); else Z = atof(GeomXYZ[i].Z);
1970 if(Units==0) { X *= BOHR_TO_ANG; Y *= BOHR_TO_ANG; Z *= BOHR_TO_ANG; }
1971 fprintf(fd,"%6s %20.10f %20.10f %20.10f\n"," ",X,Y,Z);
1972 }
1973 */
1974 fclose(fd);
1975 for(i=0;i<nTypes;i++) if(listTypes[i]) g_free(listTypes[i]);
1976 if(listTypes) g_free(listTypes);
1977 if(nListTypes) g_free(nListTypes);
1978 if(types) g_free(types);
1979 }
1980 /********************************************************************************/
save_xyz_file_no_add_list(const gchar * FileName)1981 void save_xyz_file_no_add_list(const gchar* FileName)
1982 {
1983 guint i;
1984 FILE *fd;
1985 gdouble X;
1986 gdouble Y;
1987 gdouble Z;
1988 gchar *temp = NULL;
1989
1990 temp = get_suffix_name_file(FileName);
1991 FileName = g_strdup_printf("%s.xyz",temp);
1992 g_free(temp);
1993 fd = FOpen(FileName, "w");
1994 if(fd == NULL)
1995 {
1996 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
1997 Message(t,_("Error"),TRUE);
1998 g_free(t);
1999 return;
2000 }
2001 fprintf(fd,"%d\n",NcentersXYZ);
2002 fprintf(fd,"XYZ file generated by gabedit : coordinates in Angstrom\n");
2003 for(i=0;i<NcentersXYZ;i++)
2004 {
2005 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X);
2006 else X = atof(GeomXYZ[i].X);
2007
2008 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y);
2009 else Y = atof(GeomXYZ[i].Y);
2010
2011 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z);
2012 else Z = atof(GeomXYZ[i].Z);
2013
2014 if(Units==0)
2015 {
2016 X *= BOHR_TO_ANG;
2017 Y *= BOHR_TO_ANG;
2018 Z *= BOHR_TO_ANG;
2019 }
2020 fprintf(fd,"%s %20.10f %20.10f %20.10f\n",GeomXYZ[i].Symb,X,Y,Z);
2021 }
2022 fclose(fd);
2023 }
2024 /********************************************************************************/
save_xyz_file(const gchar * FileName)2025 void save_xyz_file(const gchar* FileName)
2026 {
2027 guint i;
2028 FILE *fd;
2029 gdouble X;
2030 gdouble Y;
2031 gdouble Z;
2032 gchar *projectname = NULL;
2033 gchar *datafile = NULL;
2034 gchar *localdir = NULL;
2035 gchar *remotehost = NULL;
2036 gchar *remoteuser = NULL;
2037 gchar *remotepass = NULL;
2038 gchar *remotedir = NULL;
2039 gchar *temp = NULL;
2040
2041 temp = get_suffix_name_file(FileName);
2042 FileName = g_strdup_printf("%s.xyz",temp);
2043 g_free(temp);
2044 fd = FOpen(FileName, "w");
2045 if(fd == NULL)
2046 {
2047 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
2048 Message(t,_("Error"),TRUE);
2049 g_free(t);
2050 return;
2051 }
2052 fprintf(fd,"%d\n",NcentersXYZ);
2053 fprintf(fd,"XYZ file generated by gabedit : coordinates in Angstrom\n");
2054 for(i=0;i<NcentersXYZ;i++)
2055 {
2056 if(!test(GeomXYZ[i].X))
2057 X = get_value_variableXYZ(GeomXYZ[i].X);
2058 else
2059 X = atof(GeomXYZ[i].X);
2060 if(!test(GeomXYZ[i].Y))
2061 Y = get_value_variableXYZ(GeomXYZ[i].Y);
2062 else
2063 Y = atof(GeomXYZ[i].Y);
2064 if(!test(GeomXYZ[i].Z))
2065 Z = get_value_variableXYZ(GeomXYZ[i].Z);
2066 else
2067 Z = atof(GeomXYZ[i].Z);
2068 if(Units==0)
2069 {
2070 X *= BOHR_TO_ANG;
2071 Y *= BOHR_TO_ANG;
2072 Z *= BOHR_TO_ANG;
2073 }
2074
2075 g_fprintf(fd,"%s %20.10f %20.10f %20.10f\n",GeomXYZ[i].Symb,X,Y,Z);
2076 }
2077 fprintf(fd," \n");
2078
2079 fclose(fd);
2080 datafile = get_name_file(FileName);
2081 temp = get_suffix_name_file(FileName);
2082 projectname = get_name_file(temp);
2083 localdir = get_name_dir(temp);
2084 if(lastdirectory)
2085 g_free(lastdirectory);
2086 lastdirectory = g_strdup(localdir);
2087 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_XYZ],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_XYZ, NULL, defaultNetWorkProtocol);
2088 g_free(temp);
2089 g_free(datafile);
2090 g_free(projectname);
2091 g_free(localdir);
2092 }
2093 /************************************************************************************/
save_geometry_cif_allatoms_file(GabeditFileChooser * SelecFile,gint response_id)2094 void save_geometry_cif_allatoms_file(GabeditFileChooser *SelecFile, gint response_id)
2095 {
2096 gchar *FileName;
2097
2098 if(response_id != GTK_RESPONSE_OK) return;
2099 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2100 if ((!FileName) || (strcmp(FileName,"") == 0))
2101 {
2102 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2103 return ;
2104 }
2105 save_cif_file_no_add_list(FileName,TRUE);
2106 }
2107 /************************************************************************************/
save_geometry_cif_file(GabeditFileChooser * SelecFile,gint response_id)2108 void save_geometry_cif_file(GabeditFileChooser *SelecFile, gint response_id)
2109 {
2110 gchar *FileName;
2111
2112 if(response_id != GTK_RESPONSE_OK) return;
2113 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2114 if ((!FileName) || (strcmp(FileName,"") == 0))
2115 {
2116 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2117 return ;
2118 }
2119 save_cif_file_no_add_list(FileName,FALSE);
2120 }
2121 /************************************************************************************/
save_geometry_poscar_file(GabeditFileChooser * SelecFile,gint response_id)2122 void save_geometry_poscar_file(GabeditFileChooser *SelecFile, gint response_id)
2123 {
2124 gchar *FileName;
2125
2126 if(response_id != GTK_RESPONSE_OK) return;
2127 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2128 if ((!FileName) || (strcmp(FileName,"") == 0))
2129 {
2130 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2131 return ;
2132 }
2133 save_poscar_file_no_add_list(FileName);
2134 }
2135 /************************************************************************************/
save_geometry_poscar_direct_file(GabeditFileChooser * SelecFile,gint response_id)2136 void save_geometry_poscar_direct_file(GabeditFileChooser *SelecFile, gint response_id)
2137 {
2138 gchar *FileName;
2139
2140 if(response_id != GTK_RESPONSE_OK) return;
2141 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2142 if ((!FileName) || (strcmp(FileName,"") == 0))
2143 {
2144 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2145 return ;
2146 }
2147 save_poscar_direct_file_no_add_list(FileName);
2148 }
2149 /************************************************************************************/
save_geometry_xyz_file(GabeditFileChooser * SelecFile,gint response_id)2150 void save_geometry_xyz_file(GabeditFileChooser *SelecFile, gint response_id)
2151 {
2152 gchar *FileName;
2153
2154 if(response_id != GTK_RESPONSE_OK) return;
2155 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2156 if ((!FileName) || (strcmp(FileName,"") == 0))
2157 {
2158 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2159 return ;
2160 }
2161 save_xyz_file(FileName);
2162 }
2163
2164 /********************************************************************************/
save_xyz_file_entry(GtkWidget * entry)2165 void save_xyz_file_entry(GtkWidget* entry)
2166 {
2167 G_CONST_RETURN gchar *FileName;
2168
2169 FileName = gtk_entry_get_text(GTK_ENTRY(entry));
2170 if ((!FileName) || (strcmp(FileName,"") == 0))
2171 return ;
2172 save_xyz_file(FileName);
2173 }
2174 /********************************************************************************/
save_mol_file(const gchar * FileName)2175 void save_mol_file(const gchar* FileName)
2176 {
2177 guint i;
2178 gint j;
2179 gint n;
2180 FILE *fd;
2181 gdouble X;
2182 gdouble Y;
2183 gdouble Z;
2184 gchar *projectname = NULL;
2185 gchar *datafile = NULL;
2186 gchar *localdir = NULL;
2187 /*
2188 gchar *remotehost = NULL;
2189 gchar *remoteuser = NULL;
2190 gchar *remotepass = NULL;
2191 gchar *remotedir = NULL;
2192 */
2193 gchar *temp = NULL;
2194
2195 temp = get_suffix_name_file(FileName);
2196 FileName = g_strdup_printf("%s.mol",temp);
2197 g_free(temp);
2198 fd = FOpen(FileName, "w");
2199 if(fd == NULL)
2200 {
2201 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
2202 Message(t,_("Error"),TRUE);
2203 g_free(t);
2204 return;
2205 }
2206 n = 0;
2207 for(i=0;i<NcentersXYZ;i++)
2208 if(GeomXYZ[i].typeConnections)
2209 for(j=i+1;j<NcentersXYZ;j++)
2210 if(GeomXYZ[i].typeConnections[j]) n++;
2211 fprintf(fd," Molecule\n");
2212 fprintf(fd," GENERATED BY GABEDIT %d.%d.%d\n",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION);
2213 temp = get_time_str();
2214 if(temp) fprintf(fd," Time = %s",temp);
2215 else fprintf(fd,"\n");
2216
2217 fprintf(fd,"%3d%3d 0 0 0 0999 V2000\n",NcentersXYZ,n);
2218 for(i=0;i<NcentersXYZ;i++)
2219 {
2220 if(!test(GeomXYZ[i].X))
2221 X = get_value_variableXYZ(GeomXYZ[i].X);
2222 else
2223 X = atof(GeomXYZ[i].X);
2224 if(!test(GeomXYZ[i].Y))
2225 Y = get_value_variableXYZ(GeomXYZ[i].Y);
2226 else
2227 Y = atof(GeomXYZ[i].Y);
2228 if(!test(GeomXYZ[i].Z))
2229 Z = get_value_variableXYZ(GeomXYZ[i].Z);
2230 else
2231 Z = atof(GeomXYZ[i].Z);
2232 if(Units==0)
2233 {
2234 X *= BOHR_TO_ANG;
2235 Y *= BOHR_TO_ANG;
2236 Z *= BOHR_TO_ANG;
2237 }
2238 fprintf(fd,"%10.4f%10.4f%10.4f %-3s%2d%3d%3d%3d%3d%3d%3d%3d%3d%3d%3d%3d\n",
2239 X,Y,Z,GeomXYZ[i].Symb,0,0,0,0,0,0,0,0,0,0,0,0);
2240 }
2241 n = 0;
2242 for(i=0;i<NcentersXYZ;i++)
2243 {
2244 if(GeomXYZ[i].typeConnections)
2245 for(j=i+1;j<NcentersXYZ;j++)
2246 {
2247 if(GeomXYZ[i].typeConnections[j])
2248 {
2249 /*fprintf(fd," %5d %5d %5d 0 0 0\n", i+1, j+1, GeomXYZ[i].typeConnections[j]);*/
2250 fprintf(fd,"%3d%3d%3d 0 0 0 0\n", i+1, j+1, GeomXYZ[i].typeConnections[j]);
2251 n++;
2252 }
2253
2254 }
2255 }
2256 fprintf(fd,"M END\n");
2257 fclose(fd);
2258 datafile = get_name_file(FileName);
2259 temp = get_suffix_name_file(FileName);
2260 projectname = get_name_file(temp);
2261 localdir = get_name_dir(temp);
2262 if(lastdirectory)
2263 g_free(lastdirectory);
2264 lastdirectory = g_strdup(localdir);
2265 /* CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_XYZ],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_XYZ,NULL, defaultNetWorkProtocol);*/
2266 g_free(temp);
2267 g_free(datafile);
2268 g_free(projectname);
2269 g_free(localdir);
2270 }
2271 /************************************************************************************/
save_geometry_mol_file(GabeditFileChooser * SelecFile,gint response_id)2272 void save_geometry_mol_file(GabeditFileChooser *SelecFile, gint response_id)
2273 {
2274 gchar *FileName;
2275
2276 if(response_id != GTK_RESPONSE_OK) return;
2277 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2278 if ((!FileName) || (strcmp(FileName,"") == 0))
2279 {
2280 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2281 return ;
2282 }
2283 save_mol_file(FileName);
2284 }
2285 /********************************************************************************/
save_mol2_file(const gchar * FileName)2286 void save_mol2_file(const gchar* FileName)
2287 {
2288 guint i;
2289 gint j;
2290 gint n;
2291 FILE *fd;
2292 gdouble X;
2293 gdouble Y;
2294 gdouble Z;
2295 gchar *projectname = NULL;
2296 gchar *datafile = NULL;
2297 gchar *localdir = NULL;
2298 gchar *remotehost = NULL;
2299 gchar *remoteuser = NULL;
2300 gchar *remotepass = NULL;
2301 gchar *remotedir = NULL;
2302 gchar *temp = NULL;
2303
2304 temp = get_suffix_name_file(FileName);
2305 FileName = g_strdup_printf("%s.mol2",temp);
2306 g_free(temp);
2307 fd = FOpen(FileName, "w");
2308 if(fd == NULL)
2309 {
2310 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
2311 Message(t,_("Error"),TRUE);
2312 g_free(t);
2313 return;
2314 }
2315 n = 0;
2316 for(i=0;i<NcentersXYZ;i++)
2317 if(GeomXYZ[i].typeConnections)
2318 for(j=i+1;j<NcentersXYZ;j++)
2319 if(GeomXYZ[i].typeConnections[j]) n++;
2320 fprintf(fd,"@<TRIPOS>MOLECULE\n");
2321 fprintf(fd,"MOL2 : Made in Gabedit. mol2 file\n");
2322 fprintf(fd," %10d %10d %10d\n",NcentersXYZ,n,1);
2323 fprintf(fd," SMALL\n");
2324 fprintf(fd," NO_CHARGES\n");
2325 fprintf(fd," ****\n");
2326 fprintf(fd," ****\n");
2327 fprintf(fd,"@<TRIPOS>ATOM\n");
2328 for(i=0;i<NcentersXYZ;i++)
2329 {
2330 if(!test(GeomXYZ[i].X))
2331 X = get_value_variableXYZ(GeomXYZ[i].X);
2332 else
2333 X = atof(GeomXYZ[i].X);
2334 if(!test(GeomXYZ[i].Y))
2335 Y = get_value_variableXYZ(GeomXYZ[i].Y);
2336 else
2337 Y = atof(GeomXYZ[i].Y);
2338 if(!test(GeomXYZ[i].Z))
2339 Z = get_value_variableXYZ(GeomXYZ[i].Z);
2340 else
2341 Z = atof(GeomXYZ[i].Z);
2342 if(Units==0)
2343 {
2344 X *= BOHR_TO_ANG;
2345 Y *= BOHR_TO_ANG;
2346 Z *= BOHR_TO_ANG;
2347 }
2348
2349 fprintf(fd,"%7d%1s%-6s%12.4f%10.4f%10.4f%1s%-5s%4d%1s %-8s%10.4f\n",
2350 i+1,"",GeomXYZ[i].Symb,X,Y,Z,"",GeomXYZ[i].mmType,GeomXYZ[i].ResidueNumber+1,"",GeomXYZ[i].Residue,atof(GeomXYZ[i].Charge));
2351 }
2352 fprintf(fd,"@<TRIPOS>BOND\n");
2353 n = 0;
2354 for(i=0;i<NcentersXYZ;i++)
2355 {
2356 if(GeomXYZ[i].typeConnections)
2357 for(j=i+1;j<NcentersXYZ;j++)
2358 {
2359 if(GeomXYZ[i].typeConnections[j])
2360 {
2361 fprintf(fd,"%6d%6d%6d%3s%2d\n",n+1, i+1, j+1, "",GeomXYZ[i].typeConnections[j]);
2362 n++;
2363 }
2364
2365 }
2366 }
2367 fprintf(fd,"@<TRIPOS>SUBSTRUCTURE\n");
2368 fprintf(fd," 1 RES1 1\n");
2369
2370 fclose(fd);
2371 datafile = get_name_file(FileName);
2372 temp = get_suffix_name_file(FileName);
2373 projectname = get_name_file(temp);
2374 localdir = get_name_dir(temp);
2375 if(lastdirectory)
2376 g_free(lastdirectory);
2377 lastdirectory = g_strdup(localdir);
2378 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_MOL2],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_MOL2,NULL, defaultNetWorkProtocol);
2379 g_free(temp);
2380 g_free(datafile);
2381 g_free(projectname);
2382 g_free(localdir);
2383 }
2384 /************************************************************************************/
save_geometry_mol2_file(GabeditFileChooser * SelecFile,gint response_id)2385 void save_geometry_mol2_file(GabeditFileChooser *SelecFile, gint response_id)
2386 {
2387 gchar *FileName;
2388
2389 if(response_id != GTK_RESPONSE_OK) return;
2390 FileName = gabedit_file_chooser_get_current_file(SelecFile);
2391 if ((!FileName) || (strcmp(FileName,"") == 0))
2392 {
2393 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
2394 return ;
2395 }
2396 save_mol2_file(FileName);
2397 }
2398 /********************************************************************************/
save_mol2_file_entry(GtkWidget * entry)2399 void save_mol2_file_entry(GtkWidget* entry)
2400 {
2401 G_CONST_RETURN gchar *FileName;
2402
2403 FileName = gtk_entry_get_text(GTK_ENTRY(entry));
2404 if ((!FileName) || (strcmp(FileName,"") == 0))
2405 return;
2406
2407 save_mol2_file(FileName);
2408 }
2409 /********************************************************************************/
testav(gchar * t)2410 static gint testav(gchar *t)
2411 {
2412 guint i;
2413 if(!test(t) ){
2414 for(i=0;i<NVariablesXYZ;i++)
2415 if (!strcmp(t,VariablesXYZ[i].Name) || ( t[0] == '-' && !strcmp(t+1,VariablesXYZ[i].Name)))
2416 return i;
2417
2418 return -2;
2419 }
2420 else
2421 return -1;
2422 }
2423 /********************************************************************************/
ChangeVariablesXYZUseds()2424 static void ChangeVariablesXYZUseds()
2425 {
2426 guint i;
2427 guint j;
2428 gboolean k;
2429
2430 for (i=0;i<NVariablesXYZ;i++)
2431 {
2432 k=FALSE;
2433 for (j=0;j<NcentersXYZ;j++)
2434 {
2435 if (!strcmp(VariablesXYZ[i].Name, GeomXYZ[j].X) || (GeomXYZ[j].X[0] == '-' && !strcmp(VariablesXYZ[i].Name, GeomXYZ[j].X+1)))
2436 {
2437 k=TRUE;
2438 break;
2439 }
2440 if (!strcmp(VariablesXYZ[i].Name, GeomXYZ[j].Y) || (GeomXYZ[j].Y[0] == '-' && !strcmp(VariablesXYZ[i].Name, GeomXYZ[j].Y+1)))
2441 {
2442 k=TRUE;
2443 break;
2444 }
2445 if (!strcmp(VariablesXYZ[i].Name, GeomXYZ[j].Z) || (GeomXYZ[j].Z[0] == '-' && !strcmp(VariablesXYZ[i].Name, GeomXYZ[j].Z+1)))
2446 {
2447 k=TRUE;
2448 break;
2449 }
2450 }
2451 VariablesXYZ[i].Used=k;
2452 }
2453 }
2454 /********************************************************************************/
AllocationVariableXYZ()2455 void AllocationVariableXYZ()
2456 {
2457 if(VariablesXYZ != NULL)
2458 VariablesXYZ = g_realloc(VariablesXYZ,NVariablesXYZ*sizeof(VariablesXYZDef));
2459 else
2460 VariablesXYZ = g_malloc(NVariablesXYZ*sizeof(VariablesXYZDef));
2461 }
2462 /********************************************************************************/
show_geom_in_list(guint i)2463 void show_geom_in_list(guint i)
2464 {
2465 gchar *texts[NUMBER_LIST_XYZ];
2466 texts[E_NUMBER] = g_strdup_printf("%d",i+1);
2467 texts[E_SYMBOL] = g_strdup(GeomXYZ[i].Symb);
2468 texts[E_RESIDUE] = g_strdup(GeomXYZ[i].Residue);
2469 texts[E_MMTYPE] = g_strdup(GeomXYZ[i].mmType);
2470 texts[E_PDBTYPE] = g_strdup(GeomXYZ[i].pdbType);
2471 texts[E_X] = g_strdup(GeomXYZ[i].X);
2472 texts[E_Y] = g_strdup(GeomXYZ[i].Y);
2473 texts[E_Z] = g_strdup(GeomXYZ[i].Z);
2474 texts[E_CHARGE] = g_strdup(GeomXYZ[i].Charge);
2475 texts[E_LAYER] = g_strdup(GeomXYZ[i].Layer);
2476
2477 removeFromList(list, i);
2478 insertToList(list, i, texts, NUMBER_LIST_XYZ);
2479 }
2480 /********************************************************************************/
ModifyCoordXYZ(gchar T,guint numC,guint numV)2481 guint ModifyCoordXYZ(gchar T,guint numC,guint numV )
2482 {
2483 if(T == 'X')
2484 {
2485 if(!strcmp(GeomXYZ[numC].X,VariablesXYZ[numV].Name))
2486 GeomXYZ[numC].X =g_strdup(VariablesXYZ[numV].Value);
2487 return 1;
2488 }
2489 if(T == 'Y')
2490 {
2491 if(!strcmp(GeomXYZ[numC].Y,VariablesXYZ[numV].Name))
2492 GeomXYZ[numC].Y =g_strdup(VariablesXYZ[numV].Value);
2493 return 1;
2494 }
2495 if(T == 'Z')
2496 {
2497 if(!strcmp(GeomXYZ[numC].Z,VariablesXYZ[numV].Name))
2498 GeomXYZ[numC].Z =g_strdup(VariablesXYZ[numV].Value);
2499 return 1;
2500 }
2501 return 0;
2502 }
2503 /********************************************************************************/
OneVariableToConstXYZ(guint num)2504 void OneVariableToConstXYZ(guint num)
2505 {
2506 guint i;
2507 guint k;
2508 if(!VariablesXYZ[num].Used)
2509 return;
2510 for(i=0;i<NcentersXYZ;i++)
2511 {
2512 k = 0;
2513 k += ModifyCoordXYZ('X',i,num);
2514 k += ModifyCoordXYZ('Y',i,num);
2515 k += ModifyCoordXYZ('Z',i,num);
2516 if(k>0) show_geom_in_list(i);
2517 }
2518 for(i=num;i<NVariablesXYZ-1;i++)
2519 {
2520 VariablesXYZ[i].Name = g_strdup(VariablesXYZ[i+1].Name);
2521 VariablesXYZ[i].Value = g_strdup(VariablesXYZ[i+1].Value);
2522 VariablesXYZ[i].Used = VariablesXYZ[i+1].Used;
2523 }
2524 NVariablesXYZ--;
2525 if(NVariablesXYZ>0)
2526 AllocationVariableXYZ();
2527 else
2528 freeVariablesXYZ();
2529
2530 /*
2531 ChangeVariablesXYZUseds();
2532 */
2533
2534 removeFromList(listv, num);
2535 }
2536 /********************************************************************************/
trans_allVariables_to_Constants()2537 void trans_allVariables_to_Constants()
2538 {
2539 guint numV;
2540 guint numC;
2541 guint k;
2542 guint i;
2543 guint NRem=0;
2544 gboolean *Rem;
2545 VariablesXYZDef *VXYZ;
2546 Rem = g_malloc(NVariablesXYZ*sizeof(gboolean));
2547 VXYZ = g_malloc(NVariablesXYZ*sizeof(VariablesXYZDef));
2548
2549 for(numV=0;numV<NVariablesXYZ;numV++)
2550 {
2551 Rem[numV] = FALSE;
2552 if(VariablesXYZ[numV].Used)
2553 {
2554 for(numC=0;numC<NcentersXYZ;numC++)
2555 {
2556 k = 0;
2557 k += ModifyCoordXYZ('X',numC,numV);
2558 k += ModifyCoordXYZ('Y',numC,numV);
2559 k += ModifyCoordXYZ('Z',numC,numV);
2560 }
2561 NRem++;
2562 Rem[numV] = TRUE;
2563 VariablesXYZ[numV].Used = FALSE;
2564 }
2565 }
2566 for(i=0;i<NVariablesXYZ;i++)
2567 {
2568 VXYZ[i].Name = g_strdup(VariablesXYZ[i].Name);
2569 VXYZ[i].Value = g_strdup(VariablesXYZ[i].Value);
2570 VXYZ[i].Used = VariablesXYZ[i].Used;
2571 }
2572 k=NVariablesXYZ;
2573 freeVariablesXYZ();
2574 NVariablesXYZ = k - NRem;
2575 VariablesXYZ = g_malloc(NVariablesXYZ*sizeof(VariablesXYZDef));
2576 numV =-1;
2577 for(i=0;i<k;i++)
2578 {
2579 if(!Rem[i])
2580 {
2581 numV++;
2582 VariablesXYZ[numV].Name = g_strdup(VXYZ[i].Name);
2583 VariablesXYZ[numV].Value = g_strdup(VXYZ[i].Value);
2584 VariablesXYZ[numV].Used = VXYZ[i].Used;
2585 }
2586 }
2587
2588 clearList(listv);
2589 append_VariablesXYZ_in_list();
2590
2591 clearList(list);
2592 append_list();
2593
2594 for(i=0;i<NVariablesXYZ;i++)
2595 {
2596 g_free(VXYZ[i].Name);
2597 g_free(VXYZ[i].Value);
2598 }
2599 g_free(VXYZ);
2600 g_free(Rem);
2601 if(GeomDrawingArea != NULL) rafresh_drawing();
2602 }
2603 /********************************************************************************/
AddVariableXYZ(gchar * NameV,gchar * ValueV,gboolean rafresh)2604 void AddVariableXYZ(gchar *NameV,gchar *ValueV, gboolean rafresh)
2605 {
2606 gchar *texts[2];
2607 NVariablesXYZ++;
2608 AllocationVariableXYZ();
2609 VariablesXYZ[NVariablesXYZ-1].Name = g_strdup(NameV);
2610 VariablesXYZ[NVariablesXYZ-1].Value = g_strdup(ValueV);
2611 texts[0] = g_strdup(NameV);
2612 texts[1] = g_strdup(ValueV);
2613 if(rafresh) appendToList(listv, texts, 2);
2614 }
2615 /********************************************************************************/
reset_variableXYZ_value(gchar * NameV,gchar * ValueV,gboolean rafresh)2616 static gboolean reset_variableXYZ_value(gchar *NameV,gchar *ValueV, gboolean rafresh)
2617 {
2618 gint i=testav(NameV);
2619 if(i>=0)
2620 {
2621 if(VariablesXYZ[i].Value) g_free(VariablesXYZ[i].Value);
2622 VariablesXYZ[i].Value = g_strdup(ValueV);
2623 if(rafresh)
2624 {
2625 gchar* texts[2] = { VariablesXYZ[i].Name, VariablesXYZ[i].Value};
2626 removeFromList(listv, i);
2627 insertToList(listv, i, texts, 2);
2628 }
2629 return TRUE;
2630 }
2631 return FALSE;
2632 }
2633 /********************************************************************************/
trans_coordXYZ(gchar T,guint i,gboolean rafresh)2634 void trans_coordXYZ(gchar T,guint i, gboolean rafresh)
2635 {
2636 gdouble V;
2637 gchar *NameV;
2638 gchar *ValueV;
2639 gint j;
2640 gint k;
2641 gboolean OK;
2642
2643 V = atof(GeomXYZ[i].X);
2644 if( T == 'Y' )
2645 V = atof(GeomXYZ[i].Y);
2646 if( T == 'Z' )
2647 V = atof(GeomXYZ[i].Z);
2648 NameV = g_strdup_printf("%c%s%d",T,GeomXYZ[i].Symb,i+1);
2649 k = i+2;
2650 OK = FALSE;
2651 while(!OK)
2652 {
2653 OK = TRUE;
2654 for(j=0;j<(gint)NVariablesXYZ;j++)
2655 {
2656 if(strcmp(NameV,VariablesXYZ[j].Name )==0)
2657 {
2658 NameV = g_strdup_printf("%c%s%d",T,GeomXYZ[i].Symb,k);
2659 k++;
2660 OK = FALSE;
2661 break;
2662 }
2663 }
2664 }
2665 ValueV = g_strdup_printf("%f",V);
2666 if(!reset_variableXYZ_value(NameV,ValueV, rafresh))
2667 AddVariableXYZ(NameV,ValueV,rafresh);
2668 if( T == 'X' )
2669 GeomXYZ[i].X=g_strdup(NameV);
2670 if( T == 'Y' )
2671 GeomXYZ[i].Y=g_strdup(NameV);
2672 if( T == 'Z' )
2673 GeomXYZ[i].Z=g_strdup(NameV);
2674 }
2675 /********************************************************************************/
set_variable_one_atom_in_GeomXYZ(gint i)2676 void set_variable_one_atom_in_GeomXYZ(gint i)
2677 {
2678 if(test(GeomXYZ[i].X)) trans_coordXYZ('X',(guint)i,FALSE);
2679 if(test(GeomXYZ[i].Y)) trans_coordXYZ('Y',(guint)i,FALSE);
2680 if(test(GeomXYZ[i].Z)) trans_coordXYZ('Z',(guint)i,FALSE);
2681
2682 ChangeVariablesXYZUseds();
2683 }
2684 /********************************************************************************/
trans_OneGeomXYZ_to_variables(guint i)2685 void trans_OneGeomXYZ_to_variables(guint i)
2686 {
2687 if(test(GeomXYZ[i].X))
2688 trans_coordXYZ('X',i,TRUE);
2689 if(test(GeomXYZ[i].Y))
2690 trans_coordXYZ('Y',i,TRUE);
2691 if(test(GeomXYZ[i].Z))
2692 trans_coordXYZ('Z',i,TRUE);
2693
2694 show_geom_in_list(i);
2695 ChangeVariablesXYZUseds();
2696 }
2697 /********************************************************************************/
trans_allGeomXYZ_to_variables()2698 void trans_allGeomXYZ_to_variables()
2699 {
2700 guint i;
2701
2702 if(NcentersXYZ <1 ) return;
2703 for(i=0;i<NcentersXYZ;i++)
2704 trans_OneGeomXYZ_to_variables(i);
2705 if(GeomDrawingArea != NULL) rafresh_drawing();
2706 }
2707 /********************************************************************************/
DialogueTransInVar()2708 static void DialogueTransInVar()
2709 {
2710 GtkWidget *Dialogue;
2711 GtkWidget *Label;
2712 GtkWidget *Bouton;
2713 GtkWidget *frame, *vboxframe;
2714
2715
2716 if (NcentersXYZ <1)
2717 {
2718 MessageGeom(_(" Sorry No Center !"),_("Error"),TRUE);
2719 return ;
2720 }
2721
2722 Dialogue = gtk_dialog_new();
2723 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Tansform all constants in Variables"));
2724 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
2725 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
2726 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
2727
2728 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Question "));
2729 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
2730
2731 gtk_widget_realize(Dialogue);
2732 Label = create_label_with_pixmap(Dialogue,_("\nAre you sure to transform\n all constants in variables? \n"),_(" Question "));
2733
2734 frame = gtk_frame_new (NULL);
2735 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2736
2737 g_object_ref (frame);
2738 g_object_set_data_full(G_OBJECT (Dialogue), "frame",frame,(GDestroyNotify) g_object_unref);
2739 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
2740 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
2741
2742 gtk_widget_show (frame);
2743
2744 vboxframe = create_vbox(frame);
2745
2746 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
2747
2748 Bouton = create_button(Dialogue,_("No"));
2749 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2750 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2751 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2752 gtk_widget_grab_default(Bouton);
2753
2754 Bouton = create_button(Dialogue,_("Yes"));
2755 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2756 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)trans_allGeomXYZ_to_variables, NULL);
2757 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2758 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2759
2760
2761 gtk_widget_show_all(Dialogue);
2762 }
2763 /********************************************************************************/
DialogueTransInConst()2764 static void DialogueTransInConst()
2765 {
2766 GtkWidget *Dialogue;
2767 GtkWidget *Label;
2768 GtkWidget *Bouton;
2769 GtkWidget *frame, *vboxframe;
2770
2771
2772 if (NcentersXYZ <1)
2773 {
2774 MessageGeom(_(" Sorry No Center !"),_("Error"),TRUE);
2775 return ;
2776 }
2777
2778 Dialogue = gtk_dialog_new();
2779 gtk_window_set_title(GTK_WINDOW(Dialogue),"Tansform all variables in constants ");
2780 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
2781 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
2782 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
2783
2784 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Question "));
2785 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
2786
2787 gtk_widget_realize(Dialogue);
2788 Label = create_label_with_pixmap(Dialogue,_("\nAre you sure to transform\nall variables in constants? \n"),_(" Question "));
2789 frame = gtk_frame_new (NULL);
2790 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2791
2792 g_object_ref (frame);
2793 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
2794 frame,(GDestroyNotify) g_object_unref);
2795 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
2796 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
2797
2798 gtk_widget_show (frame);
2799
2800 vboxframe = create_vbox(frame);
2801
2802 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
2803
2804 Bouton = create_button(Dialogue,_("No"));
2805 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2806 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2807 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2808 gtk_widget_grab_default(Bouton);
2809
2810 Bouton = create_button(Dialogue,_("Yes"));
2811 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
2812 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)trans_allVariables_to_Constants, NULL);
2813 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
2814 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
2815
2816
2817 gtk_widget_show_all(Dialogue);
2818 }
2819 /********************************************************************************/
TransXYZConstVar()2820 static void TransXYZConstVar()
2821 {
2822 gint Nc;
2823 Nc=LineSelected;
2824 if(Nc<0)
2825 {
2826 MessageGeom(_("Sorry No line selected"),_("Error"),TRUE);
2827 return;
2828 }
2829 trans_OneGeomXYZ_to_variables((guint)Nc);
2830 LineSelected = -1;
2831 if(GeomDrawingArea != NULL) rafresh_drawing();
2832 }
2833 /********************************************************************************/
TransXYZConstXVar()2834 static void TransXYZConstXVar()
2835 {
2836 gint i;
2837 if (NcentersXYZ <1) return ;
2838 for(i=0;i<NcentersXYZ;i++)
2839 {
2840 if(test(GeomXYZ[i].X)) trans_coordXYZ('X',i,TRUE);
2841 show_geom_in_list(i);
2842 }
2843 ChangeVariablesXYZUseds();
2844 if(GeomDrawingArea != NULL) rafresh_drawing();
2845 }
2846 /********************************************************************************/
TransXYZConstYVar()2847 static void TransXYZConstYVar()
2848 {
2849 gint i;
2850 if (NcentersXYZ <1) return ;
2851 for(i=0;i<NcentersXYZ;i++)
2852 {
2853 if(test(GeomXYZ[i].Y)) trans_coordXYZ('Y',i,TRUE);
2854 show_geom_in_list(i);
2855 }
2856 ChangeVariablesXYZUseds();
2857 if(GeomDrawingArea != NULL) rafresh_drawing();
2858 }
2859 /********************************************************************************/
TransXYZConstZVar()2860 static void TransXYZConstZVar()
2861 {
2862 gint i;
2863 if (NcentersXYZ <1) return ;
2864 for(i=0;i<NcentersXYZ;i++)
2865 {
2866 if(test(GeomXYZ[i].Z)) trans_coordXYZ('Z',i,TRUE);
2867 show_geom_in_list(i);
2868 }
2869 ChangeVariablesXYZUseds();
2870 if(GeomDrawingArea != NULL) rafresh_drawing();
2871 }
2872 /********************************************************************************/
TransXYZVarConst()2873 static void TransXYZVarConst()
2874 {
2875 gint Nc;
2876 Nc=LineSelectedV;
2877 if(Nc<0)
2878 {
2879 MessageGeom(_("Sorry\n No variable selected"),_("Error"),TRUE);
2880 return;
2881 }
2882 OneVariableToConstXYZ((guint)Nc);
2883 LineSelectedV = -1;
2884 if(GeomDrawingArea != NULL) rafresh_drawing();
2885 }
2886 /********************************************************************************/
set_entry_XYZ()2887 static void set_entry_XYZ()
2888 {
2889 SAtomsProp Atom[3];
2890 gdouble r;
2891 gdouble Coord[3];
2892 gdouble angle1=60.0*DEG_TO_RAD;
2893 gdouble angle2=60.0*DEG_TO_RAD;
2894 gchar *strdump;
2895 G_CONST_RETURN gchar *Atomdump;
2896
2897 angle1= (gdouble)rand()/RAND_MAX*60*DEG_TO_RAD;
2898 angle2= (gdouble)rand()/RAND_MAX*60*DEG_TO_RAD;
2899
2900 if(NcentersXYZ==0)
2901 {
2902 gtk_entry_set_text(GTK_ENTRY(Entry[E_X]),"0.0");
2903 gtk_entry_set_text(GTK_ENTRY(Entry[E_Y]),"0.0");
2904 gtk_entry_set_text(GTK_ENTRY(Entry[E_Z]),"0.0");
2905 }
2906 else
2907 {
2908 Atomdump =gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL]));
2909 Atom[0] = prop_atom_get(Atomdump);
2910 Atom[1] = prop_atom_get(GeomXYZ[NcentersXYZ-1].Symb);
2911 r = Atom[0].covalentRadii+Atom[1].covalentRadii;
2912 r *=0.8;
2913 if(Units==1)
2914 r*=BOHR_TO_ANG;
2915 if(test(GeomXYZ[NcentersXYZ-1].X))
2916 Coord[0] = atof(GeomXYZ[NcentersXYZ-1].X)
2917 + r * sin(angle1)*cos(angle2);
2918 else
2919 Coord[0] = get_value_variableXYZ(GeomXYZ[NcentersXYZ-1].X)
2920 + r * sin(angle1)*cos(angle2);
2921
2922 if(test(GeomXYZ[NcentersXYZ-1].Y))
2923 Coord[1] = atof(GeomXYZ[NcentersXYZ-1].Y) + r * sin(angle1)*sin(angle2);
2924 else
2925 Coord[1] = get_value_variableXYZ(GeomXYZ[NcentersXYZ-1].Y)
2926 + r * sin(angle1)*sin(angle2);
2927
2928 if(test(GeomXYZ[NcentersXYZ-1].Z))
2929 Coord[2] = atof(GeomXYZ[NcentersXYZ-1].Z)
2930 + r * cos(angle1);
2931 else
2932 Coord[2] = get_value_variableXYZ(GeomXYZ[NcentersXYZ-1].Z)
2933 + r * cos(angle1);
2934
2935 strdump = g_strdup_printf("%f", Coord[0]);
2936 gtk_entry_set_text(GTK_ENTRY(Entry[E_X]),strdump);
2937 strdump = g_strdup_printf("%f", Coord[1]);
2938 gtk_entry_set_text(GTK_ENTRY(Entry[E_Y]),strdump);
2939 strdump = g_strdup_printf("%f", Coord[2]);
2940 gtk_entry_set_text(GTK_ENTRY(Entry[E_Z]),strdump);
2941 g_free(strdump);
2942 }
2943
2944 }
2945 /********************************************************************************/
SetAtom(GtkWidget * w,gpointer data)2946 static void SetAtom(GtkWidget *w,gpointer data)
2947 {
2948 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),(char *)data);
2949 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),(char *)data);
2950 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),(char *)data);
2951 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
2952 gtk_widget_destroy(FenetreTable);
2953 set_entry_XYZ();
2954 }
2955 /********************************************************************************/
SelectAtom(GtkWidget * w,gpointer entry0)2956 static void SelectAtom(GtkWidget *w,gpointer entry0)
2957 {
2958 GtkWidget* Table;
2959 GtkWidget* button;
2960 GtkWidget* frame;
2961 guint i;
2962 guint j;
2963 GtkStyle *button_style;
2964 /* GtkStyle *style;*/
2965
2966 gchar*** Symb = get_periodic_table();
2967
2968 FenetreTable = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2969 gtk_window_set_modal(GTK_WINDOW(FenetreTable),TRUE);
2970 gtk_window_set_title(GTK_WINDOW(FenetreTable),_("Select your atom"));
2971 gtk_window_set_default_size (GTK_WINDOW(FenetreTable),(gint)(ScreenWidth*0.5),(gint)(ScreenHeight*0.4));
2972
2973 frame = gtk_frame_new (NULL);
2974 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
2975 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
2976
2977 gtk_container_add(GTK_CONTAINER(FenetreTable),frame);
2978 gtk_widget_show (frame);
2979
2980 Table = gtk_table_new(PERIODIC_TABLE_N_ROWS-1,PERIODIC_TABLE_N_COLUMNS,TRUE);
2981 gtk_container_add(GTK_CONTAINER(frame),Table);
2982 button_style = gtk_widget_get_style(FenetreTable);
2983
2984 for ( i = 0;i<PERIODIC_TABLE_N_ROWS-1;i++)
2985 for ( j = 0;j<PERIODIC_TABLE_N_COLUMNS;j++)
2986 {
2987 if(strcmp(Symb[j][i],"00"))
2988 {
2989 button = gtk_button_new_with_label(Symb[j][i]);
2990 set_button_style(button_style,button,Symb[j][i]);
2991 g_signal_connect(G_OBJECT(button), "clicked",
2992 (GCallback)SetAtom,(gpointer )Symb[j][i]);
2993 gtk_table_attach(GTK_TABLE(Table),button,j,j+1,i,i+1,
2994 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND) ,
2995 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
2996 1,1);
2997 }
2998
2999 }
3000
3001 gtk_widget_show_all(FenetreTable);
3002
3003 }
3004 /********************************************************************************/
DelAtom(GtkWidget * w,gpointer data)3005 static void DelAtom(GtkWidget *w,gpointer data)
3006 {
3007
3008 NcentersXYZ--;
3009 if((gint)NcentersXYZ>-1)
3010 {
3011 GeomXYZ=g_realloc(GeomXYZ,NcentersXYZ*sizeof(GeomXYZAtomDef));
3012 removeFromList(list, NcentersXYZ);
3013 }
3014 else
3015 freeGeomXYZ();
3016
3017 ChangeVariablesXYZUseds();
3018 if(GeomDrawingArea != NULL)
3019 rafresh_drawing();
3020 if(iprogram == PROG_IS_GAUSS)
3021 set_spin_of_electrons();
3022 }
3023 /********************************************************************************/
addAtom(GtkWidget * w,gpointer Entree)3024 static void addAtom(GtkWidget *w,gpointer Entree)
3025 {
3026 gchar *texts[NUMBER_LIST_XYZ];
3027 gchar *message;
3028 gint i;
3029 gint k;
3030
3031 DestroyDialog = TRUE;
3032 texts[E_NUMBER] = g_strdup_printf("%d",NcentersXYZ+1);
3033 texts[E_SYMBOL] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL])));
3034 texts[E_MMTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_MMTYPE])));
3035 texts[E_PDBTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_PDBTYPE])));
3036 texts[E_RESIDUE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_RESIDUE])));
3037 for (i=E_X;i<=E_Z;i++)
3038 {
3039 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3040 if (!texts[i] || !strcmp(texts[i], ""))
3041 {
3042 MessageGeom(_("Sorry a Entry text is void !\n"),_("Error"),TRUE);
3043 DestroyDialog = FALSE;
3044 return;
3045 }
3046 k=testav(texts[i]);
3047 if(k<-1)
3048 {
3049 message=g_strdup_printf(_("Sorry\n %s \nis not a number \nand is not a variable "),texts[i]);
3050 MessageGeom(message,_("Error"),TRUE);
3051 DestroyDialog = FALSE;
3052 return;
3053 }
3054 }
3055
3056 texts[E_CHARGE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_CHARGE])));
3057
3058 if(iprogram == PROG_IS_MOLPRO)
3059 texts[E_LAYER] = g_strdup(" ");
3060 else
3061 texts[E_LAYER] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_LAYER])));
3062
3063 NcentersXYZ++;
3064 if(GeomXYZ==NULL)
3065 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
3066 else
3067 GeomXYZ=g_realloc(GeomXYZ,NcentersXYZ*sizeof(GeomXYZAtomDef));
3068 for(i=0; i<NcentersXYZ; i++) GeomXYZ[i].typeConnections = NULL;
3069 for(i=E_X;i<=E_Z;i++)
3070 if(test(texts[i]) && !testpointeE(texts[i]) )
3071 texts[i]=g_strdup_printf("%s.0",texts[i]);
3072
3073 GeomXYZ[NcentersXYZ-1].Nentry=NUMBER_LIST_XYZ;
3074 GeomXYZ[NcentersXYZ-1].Symb = g_strdup(texts[E_SYMBOL]);
3075 GeomXYZ[NcentersXYZ-1].mmType = g_strdup(texts[E_MMTYPE]);
3076 GeomXYZ[NcentersXYZ-1].pdbType = g_strdup(texts[E_PDBTYPE]);
3077 GeomXYZ[NcentersXYZ-1].Residue = g_strdup(texts[E_RESIDUE]);
3078 GeomXYZ[NcentersXYZ-1].X = g_strdup(texts[E_X]);
3079 GeomXYZ[NcentersXYZ-1].Y = g_strdup(texts[E_Y]);
3080 GeomXYZ[NcentersXYZ-1].Z = g_strdup(texts[E_Z]);
3081 GeomXYZ[NcentersXYZ-1].Charge = g_strdup(texts[E_CHARGE]);
3082 GeomXYZ[NcentersXYZ-1].Layer = g_strdup(texts[E_LAYER]);
3083 GeomXYZ[NcentersXYZ-1].typeConnections = NULL;
3084 if(NcentersXYZ==1)
3085 GeomXYZ[NcentersXYZ-1].ResidueNumber = 0;
3086 else
3087 {
3088 gint k;
3089 GeomXYZ[NcentersXYZ-1].ResidueNumber = 0;
3090 for(k=0;k<(gint)NcentersXYZ-1;k++)
3091 {
3092 if(GeomXYZ[NcentersXYZ-1].ResidueNumber<GeomXYZ[k].ResidueNumber)
3093 GeomXYZ[NcentersXYZ-1].ResidueNumber = GeomXYZ[k].ResidueNumber;
3094 }
3095 GeomXYZ[NcentersXYZ-1].ResidueNumber += 1;
3096 }
3097 ChangeVariablesXYZUseds();
3098
3099 appendToList(list, texts, NUMBER_LIST_XYZ);
3100
3101 if(GeomDrawingArea != NULL)
3102 rafresh_drawing();
3103 if(iprogram == PROG_IS_GAUSS)
3104 set_spin_of_electrons();
3105
3106 }
3107 /********************************************************************************/
EditAtom(GtkWidget * w,gpointer Entree)3108 static void EditAtom(GtkWidget *w,gpointer Entree)
3109 {
3110 gchar *texts[NUMBER_LIST_XYZ];
3111 gchar *message;
3112 gint i;
3113 gint Nc;
3114 gint k;
3115 gboolean oldResidue = FALSE;
3116
3117 DestroyDialog = TRUE;
3118 Nc = LineSelected;
3119 if(Nc<0)
3120 Nc = LineSelectedOld;
3121 texts[E_NUMBER] = g_strdup_printf("%d",Nc+1);
3122 texts[E_SYMBOL] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_SYMBOL])));
3123 texts[E_RESIDUE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_RESIDUE])));
3124 texts[E_MMTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_MMTYPE])));
3125 texts[E_PDBTYPE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_PDBTYPE])));
3126
3127 for (i=E_X;i<=E_Z;i++)
3128 {
3129 texts[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[i])));
3130 if (!texts[i] || !strcmp(texts[i], ""))
3131 {
3132 message=g_strdup_printf(_("Sorry\n a entry is void "));
3133 MessageGeom(message,_("Error"),TRUE);
3134 DestroyDialog = FALSE;
3135 return;
3136 }
3137 k=testav(texts[i]);
3138 if(k<-1)
3139 {
3140 message=g_strdup_printf(_("Sorry\n %s \nis not a number \nand is not a variable "),texts[i]);
3141 MessageGeom(message,_("Error"),TRUE);
3142 DestroyDialog = FALSE;
3143 return;
3144 }
3145 }
3146 texts[E_CHARGE] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_CHARGE])));
3147
3148 if(iprogram != PROG_IS_MOLPRO)
3149 texts[E_LAYER] = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry[E_LAYER])));
3150 else
3151 texts[E_LAYER] = g_strdup(" ");
3152
3153 Nc = LineSelected;
3154 if(Nc<0)
3155 Nc = LineSelectedOld;
3156 if(Nc>-1)
3157 {
3158
3159 for(i=E_X;i<=E_Z;i++)
3160 if(test(texts[i]) && !testpointeE(texts[i]) )
3161 texts[i]=g_strdup_printf("%s.0",texts[i]);
3162
3163 if(!strcmp(GeomXYZ[Nc].Residue,texts[E_RESIDUE]))
3164 oldResidue = TRUE;
3165 GeomXYZ[Nc].Nentry=NUMBER_LIST_XYZ;
3166 GeomXYZ[Nc].Symb = g_strdup(texts[E_SYMBOL]);
3167 GeomXYZ[Nc].mmType = g_strdup(texts[E_MMTYPE]);
3168 GeomXYZ[Nc].pdbType = g_strdup(texts[E_PDBTYPE]);
3169 GeomXYZ[Nc].Residue = g_strdup(texts[E_RESIDUE]);
3170 GeomXYZ[Nc].X = g_strdup(texts[E_X]);
3171 GeomXYZ[Nc].Y = g_strdup(texts[E_Y]);
3172 GeomXYZ[Nc].Z = g_strdup(texts[E_Z]);
3173 GeomXYZ[Nc].Charge = g_strdup(texts[E_CHARGE]);
3174 GeomXYZ[Nc].Layer = g_strdup(texts[E_LAYER]);
3175 if(!oldResidue)
3176 {
3177 gint k;
3178 GeomXYZ[Nc].ResidueNumber = -1;
3179 for(k=0;k<(gint)NcentersXYZ;k++)
3180 {
3181 if(Nc != k && !strcmp(GeomXYZ[Nc].Residue,GeomXYZ[k].Residue))
3182 {
3183 GeomXYZ[Nc].ResidueNumber = GeomXYZ[k].ResidueNumber;
3184 break;
3185 }
3186 }
3187 if(GeomXYZ[Nc].ResidueNumber == -1)
3188 {
3189 for(k=0;k<(gint)NcentersXYZ;k++)
3190 {
3191 if(GeomXYZ[Nc].ResidueNumber<GeomXYZ[k].ResidueNumber)
3192 GeomXYZ[Nc].ResidueNumber = GeomXYZ[k].ResidueNumber;
3193 }
3194 GeomXYZ[Nc].ResidueNumber += 1;
3195 }
3196 }
3197
3198 removeFromList(list, Nc);
3199 insertToList(list, Nc, texts, NUMBER_LIST_XYZ);
3200
3201 ChangeVariablesXYZUseds();
3202 if(GeomDrawingArea != NULL)
3203 rafresh_drawing();
3204 if(iprogram == PROG_IS_GAUSS)
3205 set_spin_of_electrons();
3206 }
3207 else
3208 MessageGeom(_("Sorry No line selected"),_("Error"),TRUE);
3209
3210 if(iprogram == PROG_IS_GAUSS)
3211 set_spin_of_electrons();
3212
3213
3214 }
3215 /********************************************************************************/
get_list_variablesXYZ()3216 static gchar **get_list_variablesXYZ()
3217 {
3218 guint i;
3219 gchar **tlist;
3220 gint nl = NVariablesXYZ*2+1;
3221
3222 tlist=g_malloc(nl*sizeof(char*));
3223
3224 tlist[0] = g_strdup("");
3225 for (i=0;i<NVariablesXYZ;i++)
3226 tlist[i+1] = g_strdup(VariablesXYZ[i].Name);
3227 for (i=NVariablesXYZ;i<2*NVariablesXYZ;i++)
3228 tlist[i+1] = g_strdup_printf("-%s",VariablesXYZ[i-NVariablesXYZ].Name);
3229
3230 return tlist;
3231 }
3232 /********************************************************************************/
freelistvariablesXYZ(gchar ** tlist)3233 static void freelistvariablesXYZ(gchar **tlist)
3234 {
3235 guint i;
3236 guint nl = NVariablesXYZ*2+1;
3237
3238 for (i=0;i<nl;i++)
3239 g_free(tlist[i]);
3240
3241 g_free(tlist);
3242 }
3243
3244
3245 /********************************************************************************/
DialogueAdd(GtkWidget * w,gpointer data)3246 static void DialogueAdd(GtkWidget *w,gpointer data)
3247 {
3248 GtkWidget *Dialogue;
3249 GtkWidget *Bouton;
3250 GtkWidget *hbox;
3251 GtkWidget *frame, *vboxframe;
3252 gint nlist;
3253 gchar *tlabel[]={ " ",
3254 N_("Atom Symbol : "),
3255 N_("MM Type : "),
3256 N_("PDB Type : "),
3257 N_("Residue Type : "),
3258 " X : ",
3259 " Y : ",
3260 " Z : ",
3261 N_(" Charge : "),N_(" Layer : ")
3262 };
3263 gint i;
3264 gchar **tlist;
3265 gchar **tlistvar;
3266
3267 Dialogue = gtk_dialog_new();
3268 gtk_window_set_title(GTK_WINDOW(Dialogue),_("New Center"));
3269 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3270 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3271
3272 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" New Center "));
3273 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3274
3275 frame = gtk_frame_new (NULL);
3276 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3277
3278 g_object_ref (frame);
3279 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3280 frame,(GDestroyNotify) g_object_unref);
3281 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3282 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3283
3284 gtk_widget_show (frame);
3285
3286 vboxframe = create_vbox(frame);
3287
3288
3289 hbox=create_hbox_false(vboxframe);
3290 Entry[E_SYMBOL] = create_label_entry(hbox,tlabel[E_SYMBOL],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3291 if(NcentersXYZ==0)
3292 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),"H");
3293 else
3294 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),GeomXYZ[NcentersXYZ-1].Symb);
3295 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
3296
3297 Bouton = gtk_button_new_with_label(_(" Set "));
3298 gtk_box_pack_start (GTK_BOX(hbox), Bouton, TRUE, TRUE, 5);
3299 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)SelectAtom,
3300 Entry[E_SYMBOL]);
3301
3302 hbox=create_hbox_false(vboxframe);
3303 {
3304 gint n=0;
3305 gchar** t = getListMMTypes(&n);
3306 if(n!=0)
3307 {
3308 Entry[E_MMTYPE] = create_label_combo(hbox,tlabel[E_MMTYPE],t,n,
3309 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3310 }
3311 else
3312 {
3313 Entry[E_MMTYPE] = create_label_entry(hbox,tlabel[E_MMTYPE],
3314 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3315 }
3316
3317 if(t)
3318 freeList(t,n);
3319
3320 if(NcentersXYZ==0)
3321 {
3322 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),"H");
3323 }
3324 else
3325 {
3326 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),GeomXYZ[NcentersXYZ-1].mmType);
3327 }
3328 }
3329 hbox=create_hbox_false(vboxframe);
3330 {
3331 gint n=0;
3332 gchar** t = getListPDBTypes("UNK", &n);
3333 if(n!=0)
3334 {
3335 Entry[E_PDBTYPE] = create_label_combo(hbox,tlabel[E_PDBTYPE],t,n,
3336 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3337 }
3338 else
3339 {
3340 Entry[E_PDBTYPE] = create_label_entry(hbox,tlabel[E_PDBTYPE],
3341 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3342 }
3343
3344 if(t) freeList(t,n);
3345
3346 if(NcentersXYZ==0)
3347 {
3348 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),"H");
3349 }
3350 else
3351 {
3352 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),GeomXYZ[NcentersXYZ-1].pdbType);
3353 }
3354 }
3355 hbox=create_hbox_false(vboxframe);
3356 Entry[E_RESIDUE] = create_label_entry(hbox,tlabel[E_RESIDUE],
3357 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3358
3359 if(NcentersXYZ==0)
3360 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE])," ");
3361 else
3362 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),GeomXYZ[NcentersXYZ-1].Residue);
3363
3364 tlistvar =get_list_variablesXYZ();
3365
3366 for (i=E_X;i<=E_Z;i++)
3367 {
3368 hbox=create_hbox_false(vboxframe);
3369 Entry[i] = create_label_combo(hbox,tlabel[i],tlistvar,
3370 2*NVariablesXYZ+1,TRUE,
3371 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3372
3373 }
3374 freelistvariablesXYZ(tlistvar);
3375 set_entry_XYZ();
3376
3377 hbox=create_hbox_false(vboxframe);
3378 Entry[E_CHARGE] = create_label_entry(hbox,tlabel[E_CHARGE],
3379 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3380 gtk_entry_set_text(GTK_ENTRY(Entry[E_CHARGE]),"0.0");
3381
3382 tlist=g_malloc(4*sizeof(char*));
3383
3384 tlist[0]=g_strdup(" ");
3385 tlist[1]=g_strdup("High");
3386 tlist[2]=g_strdup("Medium");
3387 tlist[3]=g_strdup("Low");
3388 nlist=4;
3389 if(NcentersXYZ<3)
3390 nlist=1;
3391
3392 hbox=create_hbox_false(vboxframe);
3393 if(iprogram != PROG_IS_MOLPRO)
3394 Entry[E_LAYER] = create_label_combo(hbox,tlabel[E_LAYER],tlist,nlist,FALSE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3395
3396 gtk_widget_realize(Dialogue);
3397
3398 Bouton = create_button(Dialogue,_("Cancel"));
3399 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3400 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3401 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3402
3403 Bouton = create_button(Dialogue,_("OK"));
3404 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3405 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)addAtom,Entry[E_SYMBOL]);
3406 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)destroy_dialogue,GTK_OBJECT(Dialogue));
3407 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3408 gtk_widget_grab_default(Bouton);
3409
3410
3411 gtk_widget_show_all(Dialogue);
3412 g_free(tlist);
3413 }
3414
3415 /********************************************************************************/
DialogueEdit()3416 static void DialogueEdit()
3417 {
3418 GtkWidget *Dialogue;
3419 GtkWidget *Bouton;
3420 GtkWidget *hbox;
3421 GtkWidget *frame, *vboxframe;
3422 gint nlist;
3423
3424 gchar *tlabel[]={ " ",
3425 N_("Atom Symbol : "),
3426 N_("MM Type : "),
3427 N_("PDB Type : "),
3428 N_("Residue Type : "),
3429 " X : ",
3430 " Y : ",
3431 " Z : ",
3432 N_(" Charge : "),N_(" Layer : ")
3433 };
3434 gint i;
3435 gchar **tlist;
3436 gchar **tlistvar;
3437 gint Nc;
3438 Nc=LineSelected;
3439 if(Nc<0 ) {
3440 if(NcentersXYZ<1 )
3441 MessageGeom(_("Create center before \n"),_("Error"),TRUE);
3442 else
3443 MessageGeom(_("Please Select your center \n"),_("Warning"),TRUE);
3444 return;
3445 }
3446
3447 Dialogue = gtk_dialog_new();
3448 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Edit Center"));
3449 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3450 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3451
3452 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Edit Center "));
3453 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3454
3455 frame = gtk_frame_new (NULL);
3456 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3457
3458 g_object_ref (frame);
3459 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3460 frame,(GDestroyNotify) g_object_unref);
3461 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3462 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3463
3464 gtk_widget_show (frame);
3465
3466 vboxframe = create_vbox(frame);
3467
3468
3469 hbox=create_hbox_false(vboxframe);
3470 Entry[E_SYMBOL] = create_label_entry(hbox,tlabel[E_SYMBOL],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3471 gtk_entry_set_text(GTK_ENTRY(Entry[E_SYMBOL]),GeomXYZ[Nc].Symb);
3472 gtk_editable_set_editable((GtkEditable*) Entry[E_SYMBOL],FALSE);
3473
3474 Bouton = gtk_button_new_with_label(_(" Set "));
3475 gtk_box_pack_start (GTK_BOX(hbox), Bouton, TRUE, TRUE, 5);
3476 g_signal_connect(G_OBJECT(Bouton), "clicked", (GCallback)SelectAtom,
3477 Entry[E_SYMBOL]);
3478
3479 hbox=create_hbox_false(vboxframe);
3480 {
3481 gint n=0;
3482 gchar** t = getListMMTypes(&n);
3483 if(n!=0)
3484 {
3485 Entry[E_MMTYPE] = create_label_combo(hbox,tlabel[E_MMTYPE],t,n,
3486 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3487 }
3488 else
3489 {
3490 Entry[E_MMTYPE] = create_label_entry(hbox,tlabel[E_MMTYPE],
3491 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3492 }
3493
3494 if(t) freeList(t,n);
3495 gtk_entry_set_text(GTK_ENTRY(Entry[E_MMTYPE]),GeomXYZ[Nc].mmType);
3496 }
3497 hbox=create_hbox_false(vboxframe);
3498 {
3499 gint n=0;
3500 gchar** t = getListPDBTypes(GeomXYZ[Nc].Residue, &n);
3501 if(n!=0)
3502 {
3503 Entry[E_PDBTYPE] = create_label_combo(hbox,tlabel[E_PDBTYPE],t,n,
3504 TRUE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3505 }
3506 else
3507 {
3508 Entry[E_PDBTYPE] = create_label_entry(hbox,tlabel[E_PDBTYPE],
3509 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3510 }
3511
3512 if(t) freeList(t,n);
3513 gtk_entry_set_text(GTK_ENTRY(Entry[E_PDBTYPE]),GeomXYZ[Nc].pdbType);
3514 }
3515 hbox=create_hbox_false(vboxframe);
3516 Entry[E_RESIDUE] = create_label_entry(hbox,tlabel[E_RESIDUE],
3517 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3518
3519 if(NcentersXYZ==0)
3520 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE])," ");
3521 else
3522 gtk_entry_set_text(GTK_ENTRY(Entry[E_RESIDUE]),GeomXYZ[Nc].Residue);
3523
3524
3525 tlistvar =get_list_variablesXYZ();
3526
3527 for (i=E_X;i<=E_Z;i++)
3528 {
3529 hbox=create_hbox_false(vboxframe);
3530 if(i==E_X)tlistvar[0] = g_strdup(GeomXYZ[Nc].X);
3531 if(i==E_Y)tlistvar[0] = g_strdup(GeomXYZ[Nc].Y);
3532 if(i==E_Z)tlistvar[0] = g_strdup(GeomXYZ[Nc].Z);
3533 Entry[i] = create_label_combo(hbox,tlabel[i],tlistvar,
3534 2*NVariablesXYZ+1,TRUE,
3535 (gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3536 }
3537 freelistvariablesXYZ(tlistvar);
3538 gtk_entry_set_text(GTK_ENTRY(Entry[E_X]),GeomXYZ[Nc].X);
3539 gtk_entry_set_text(GTK_ENTRY(Entry[E_Y]),GeomXYZ[Nc].Y);
3540 gtk_entry_set_text(GTK_ENTRY(Entry[E_Z]),GeomXYZ[Nc].Z);
3541
3542 hbox=create_hbox_false(vboxframe);
3543 Entry[E_CHARGE] = create_label_entry(hbox,tlabel[E_CHARGE],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3544 gtk_entry_set_text(GTK_ENTRY(Entry[E_CHARGE]),GeomXYZ[Nc].Charge);
3545
3546 tlist=g_malloc(4*sizeof(char*));
3547 tlist[0]=g_strdup(" ");
3548 tlist[1]=g_strdup("High");
3549 tlist[2]=g_strdup("Medium");
3550 tlist[3]=g_strdup("Low");
3551 nlist=4;
3552 if(LineSelected<3)
3553 nlist=1;
3554
3555 hbox=create_hbox_false(vboxframe);
3556 if(iprogram != PROG_IS_MOLPRO)
3557 {
3558 Entry[E_LAYER] = create_label_combo(hbox,tlabel[E_LAYER],tlist,nlist,FALSE,(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
3559 gtk_entry_set_text(GTK_ENTRY(Entry[E_LAYER]),GeomXYZ[Nc].Layer);
3560 }
3561 gtk_widget_realize(Dialogue);
3562
3563 Bouton = create_button(Dialogue,_("Cancel"));
3564 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3565 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
3566 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3567
3568 Bouton = create_button(Dialogue,_("OK"));
3569 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3570 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)EditAtom,Entry[E_SYMBOL]);
3571 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)destroy_dialogue,GTK_OBJECT(Dialogue));
3572 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3573 gtk_widget_grab_default(Bouton);
3574
3575
3576 gtk_widget_show_all(Dialogue);
3577 g_free(tlist);
3578 }
3579 /********************************************************************************/
DialogueDelete()3580 static void DialogueDelete()
3581 {
3582 GtkWidget *Dialogue;
3583 GtkWidget *Label;
3584 GtkWidget *Bouton;
3585 GtkWidget *frame, *vboxframe;
3586
3587
3588 if (NcentersXYZ <1)
3589 {
3590 MessageGeom(_(" No Center to delete !"),_("Info"),TRUE);
3591 return ;
3592 }
3593
3594 Dialogue = gtk_dialog_new();
3595 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Delete Center"));
3596 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
3597 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
3598 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
3599
3600 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Delete Center "));
3601 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
3602
3603 gtk_widget_realize(Dialogue);
3604 Label = create_label_with_pixmap(Dialogue,_("\nAre you sure to delete \nthe last center?\n"),_("Question"));
3605 frame = gtk_frame_new (NULL);
3606 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
3607
3608 g_object_ref (frame);
3609 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
3610 frame,(GDestroyNotify) g_object_unref);
3611 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
3612 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
3613
3614 gtk_widget_show (frame);
3615
3616 vboxframe = create_vbox(frame);
3617
3618 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
3619
3620 Bouton = create_button(Dialogue,_("No"));
3621 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3622 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)delete_child,GTK_OBJECT(Dialogue));
3623 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3624 gtk_widget_grab_default(Bouton);
3625
3626 Bouton = create_button(Dialogue,_("Yes"));
3627 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
3628 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)DelAtom, NULL);
3629 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)delete_child,GTK_OBJECT(Dialogue));
3630 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
3631
3632
3633 gtk_widget_show_all(Dialogue);
3634 }
3635 /********************************************************************************/
get_symb_atom(gchar * symb)3636 static gchar* get_symb_atom(gchar* symb)
3637 {
3638 gchar* S;
3639 gchar Forbidden[]={'0','1','2','3','4','5','6','7','8','9'};
3640
3641 if(strlen(symb)==1)
3642 S = g_strdup(symb);
3643 else
3644 {
3645 gint Ok = 1;
3646 gint i;
3647 for(i=0;i<10;i++)
3648 if(symb[1]== Forbidden[i])
3649 {
3650 Ok =0;
3651 break;
3652 }
3653 if(Ok==1)
3654 {
3655 S = g_strdup_printf("%c%c",toupper(symb[0]),symb[1]);
3656 }
3657 else
3658 S = g_strdup_printf("%c",toupper(symb[0]));
3659 }
3660 if(!test_atom_define(S))
3661 {
3662 S = g_strdup_printf("%c",toupper(symb[0]));
3663 if(!test_atom_define(S)) S = g_strdup("H");
3664 }
3665
3666
3667 return S;
3668 }
3669 /********************************************************************************/
get_connections_one_atom_hin(gchar * t,gint nAtoms,gint * connections)3670 static gint get_connections_one_atom_hin(gchar* t, gint nAtoms, gint* connections)
3671 {
3672 gint k;
3673 gint nc;
3674 gint nj;
3675 gchar** split = NULL;
3676 gint nA = 0;
3677 gint type = 1;
3678 gint ibeg = 11;
3679 for(k=0;k<nAtoms;k++) connections[k] = 0;
3680 split = gab_split(t);
3681 nA = 0;
3682 while(split && split[nA]!=NULL) nA++;
3683 if(nA<ibeg)
3684 {
3685 g_strfreev(split);
3686 return 0;
3687 }
3688 nc = atoi(split[ibeg-1]);
3689 for(k=0;k<2*nc;k+=2)
3690 {
3691 if(!split[ibeg+k]) break;
3692 if(!split[ibeg+k+1]) break;
3693 nj = atoi(split[ibeg+k]);
3694 type = 1;
3695 if(strstr(split[ibeg+k+1],"d"))type = 2;
3696 if(strstr(split[ibeg+k+1],"D"))type = 2;
3697 if(strstr(split[ibeg+k+1],"t"))type = 3;
3698 if(strstr(split[ibeg+k+1],"T"))type = 3;
3699 connections[nj-1] = type;
3700 }
3701
3702 g_strfreev(split);
3703
3704 return 1;
3705 }
3706 /*************************************************************************************/
read_hin_numbers_of_atoms(FILE * file,int * natoms,int * nresidues)3707 static void read_hin_numbers_of_atoms(FILE* file, int* natoms, int* nresidues)
3708 {
3709 guint taille = BSIZE;
3710 gchar t[BSIZE];
3711 gchar dump[BSIZE];
3712
3713 *natoms = 0;
3714 *nresidues = 0;
3715
3716
3717 fseek(file, 0L, SEEK_SET);
3718 while(!feof(file))
3719 {
3720 if(!fgets(t,taille,file)) break;
3721 sscanf(t,"%s",dump);
3722 uppercase(dump);
3723 if(!strcmp(dump,"ATOM")) (*natoms)++;
3724 if(!strcmp(dump,"RES")) (*nresidues)++;
3725 }
3726 }
3727 /*************************************************************************************/
read_atom_hin_file(FILE * file,gchar * listFields[],gint nAtoms,gint * connections,gint * nc)3728 static gboolean read_atom_hin_file(FILE* file,gchar* listFields[], gint nAtoms, gint* connections, gint* nc)
3729 {
3730 guint taille = BSIZE;
3731 gchar t[BSIZE];
3732 gchar dump[BSIZE];
3733 gint i;
3734
3735 if(!fgets(t,taille,file)) return FALSE;
3736 sscanf(t,"%s",dump);
3737 uppercase(dump);
3738 if(strcmp(dump,"ATOM")!=0)
3739 {
3740 if(strcmp(dump,"RES")==0)
3741 {
3742 sscanf(t,"%s %s %s",dump,dump,listFields[1]);
3743 sprintf(listFields[0],"Unknown");
3744 }
3745 else
3746 return FALSE;
3747 }
3748 else
3749 {
3750 /* 0 -> Atom Type PDB Style*/
3751 /* 1 -> Atom Symbol*/
3752 /* 2 -> Atom Type Amber*/
3753 /* 3 -> Atom Charge*/
3754 /* 4 -> x*/
3755 /* 5 -> y*/
3756 /* 6 -> z*/
3757 sscanf(t,"%s %s %s %s %s %s %s %s %s %s",dump,dump,listFields[0],listFields[1],listFields[2],dump,listFields[3],listFields[4],listFields[5],listFields[6]);
3758 *nc = get_connections_one_atom_hin(t, nAtoms, connections);
3759 }
3760 for(i=0;i<6;i++)
3761 {
3762 delete_last_spaces(listFields[i]);
3763 delete_first_spaces(listFields[i]);
3764 }
3765 return TRUE;
3766
3767 }
3768 /*************************************************************************************/
read_hin_file_no_add_list(gchar * NomFichier)3769 void read_hin_file_no_add_list(gchar *NomFichier)
3770 {
3771 FILE *fd;
3772 int natoms;
3773 int nresidues;
3774 gchar *listFields[8];
3775 gint i;
3776 gint j;
3777 gchar resName[BSIZE] = "U";
3778 gint taille = BSIZE;
3779 gint ncAll =0;
3780
3781 for(i=0;i<8;i++) listFields[i]=g_malloc(taille*sizeof(gchar));
3782
3783 fd = FOpen(NomFichier, "rb");
3784 if(fd == NULL)
3785 {
3786 gchar* t;
3787 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),NomFichier);
3788 MessageGeom(t,_("Error"),TRUE);
3789 g_free(t);
3790 return;
3791 }
3792 read_hin_numbers_of_atoms(fd,&natoms, &nresidues);
3793
3794 if(natoms <1)
3795 {
3796 gchar* t;
3797 t = g_strdup_printf(_("Sorry\n I can read \"%s\" file"),NomFichier);
3798 MessageGeom(t,_("Error"),TRUE);
3799 g_free(t);
3800 return;
3801 }
3802
3803 if(GeomXYZ) freeGeomXYZ();
3804 if(VariablesXYZ) freeVariablesXYZ();
3805 init_dipole();
3806 GeomXYZ=g_malloc(natoms*sizeof(GeomXYZAtomDef));
3807 for(i=0; i<natoms; i++) GeomXYZ[i].typeConnections = g_malloc(natoms*sizeof(gint));
3808 NcentersXYZ = natoms;
3809 NVariablesXYZ = 0;
3810
3811 fseek(fd, 0L, SEEK_SET);
3812 j = 0;
3813 i = -1; /* number residu */
3814 while(!feof(fd))
3815 {
3816 gint nc = 0;
3817 if(!read_atom_hin_file(fd,listFields, natoms,GeomXYZ[j].typeConnections,&nc))continue;
3818 if(strcmp(listFields[0],"Unknown")==0)
3819 {
3820 sprintf(resName,"%s",listFields[1]);
3821 i++;
3822 continue;
3823 }
3824 ncAll += nc;
3825 /* 0 -> Atom Type PDB Style*/
3826 /* 1 -> Atom Symbol*/
3827 /* 2 -> Atom Type Amber*/
3828 /* 3 -> Atom Charge*/
3829 /* 4 -> x*/
3830 /* 5 -> y*/
3831 /* 6 -> z*/
3832 /* printf("%s %s %s %s %s %s %s \n",listFields[0],listFields[1],listFields[2],listFields[3],listFields[4],listFields[5],listFields[6]);*/
3833 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
3834 GeomXYZ[j].Symb= g_strdup(listFields[1]);
3835
3836 if(strcmp(listFields[0],"-")==0) GeomXYZ[j].pdbType= g_strdup(listFields[1]);
3837 else GeomXYZ[j].pdbType= g_strdup(listFields[1]);
3838
3839 if(strcmp(listFields[2],"**")==0) GeomXYZ[j].mmType= g_strdup(listFields[1]);
3840 else GeomXYZ[j].mmType= g_strdup(listFields[2]);
3841
3842 GeomXYZ[j].Residue= g_strdup(resName);
3843 GeomXYZ[j].ResidueNumber= i;
3844
3845 if(Units==1)
3846 {
3847 GeomXYZ[j].X=g_strdup(listFields[4]);
3848 GeomXYZ[j].Y=g_strdup(listFields[5]);
3849 GeomXYZ[j].Z=g_strdup(listFields[6]);
3850 }
3851 else
3852 {
3853 GeomXYZ[j].X=g_strdup(ang_to_bohr(listFields[4]));
3854 GeomXYZ[j].Y=g_strdup(ang_to_bohr(listFields[5]));
3855 GeomXYZ[j].Z=g_strdup(ang_to_bohr(listFields[6]));
3856 }
3857 GeomXYZ[j].Charge=g_strdup(listFields[3]);
3858
3859 GeomXYZ[j].Layer=g_strdup(" ");
3860 j++;
3861 if(j>=natoms)break;
3862 }
3863 if(natoms!=j)
3864 {
3865 if(GeomXYZ) freeGeomXYZ();
3866 if(VariablesXYZ) freeVariablesXYZ();
3867 NcentersXYZ = 0;
3868 NVariablesXYZ = 0;
3869 }
3870
3871 fclose(fd);
3872 for(i=0;i<8;i++)
3873 g_free(listFields[i]);
3874 if(ncAll==0)
3875 {
3876 for(i=0; i<natoms; i++) if(GeomXYZ[i].typeConnections) g_free(GeomXYZ[i].typeConnections);
3877 for(i=0; i<natoms; i++) GeomXYZ[i].typeConnections = NULL;
3878 }
3879
3880 if(GeomIsOpen)
3881 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
3882 else
3883 if(GeomDrawingArea == NULL)
3884 {
3885 /*
3886 switch(iprogram)
3887 {
3888 case PROG_IS_MOLPRO : insert_molpro(2); break;
3889 case PROG_IS_GAUSS : insert_gaussian(2);
3890 break;
3891 default : edit_geometry();
3892 }
3893 */
3894 create_window_drawing();
3895 }
3896
3897 if(GeomDrawingArea != NULL)
3898 rafresh_drawing();
3899 }
3900 /********************************************************************************/
read_hin_file(GabeditFileChooser * SelecFile,gint response_id)3901 void read_hin_file(GabeditFileChooser *SelecFile, gint response_id)
3902 {
3903 gchar *NomFichier;
3904 gchar *projectname = NULL;
3905 gchar *datafile = NULL;
3906 gchar *localdir = NULL;
3907 gchar *remotehost = NULL;
3908 gchar *remoteuser = NULL;
3909 gchar *remotepass = NULL;
3910 gchar *remotedir = NULL;
3911 gchar *temp = NULL;
3912
3913 if(response_id != GTK_RESPONSE_OK) return;
3914
3915 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
3916
3917 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
3918 {
3919 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
3920 return ;
3921 }
3922
3923 read_hin_file_no_add_list(NomFichier);
3924
3925 datafile = get_name_file(NomFichier);
3926 temp = get_suffix_name_file(NomFichier);
3927 projectname = get_name_file(temp);
3928 localdir = get_name_dir(temp);
3929 if(lastdirectory) g_free(lastdirectory);
3930 lastdirectory = g_strdup(localdir);
3931 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_HIN],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_HIN, NULL, defaultNetWorkProtocol);
3932 g_free(temp);
3933 g_free(datafile);
3934 g_free(projectname);
3935 g_free(localdir);
3936 }
3937 /*********************************************************************/
get_number_geoms_gabedit(gchar * fileName)3938 static gint get_number_geoms_gabedit(gchar* fileName)
3939 {
3940 gchar t[BSIZE];
3941 FILE *file;
3942 gint nGeometries = 0;
3943 gint nLabels = 0;
3944 gchar* pdest = NULL;
3945
3946 file = FOpen(fileName, "rb");
3947 if(!file) return -1;
3948 while(!feof(file))
3949 {
3950 if(!fgets(t,BSIZE,file))break;
3951 pdest = strstr( t, "[GEOMS]");
3952 if (pdest)
3953 {
3954 if(!fgets(t,BSIZE,file))break;
3955 sscanf(t,"%d %d",&nGeometries, &nLabels);
3956 fclose(file);
3957 return nGeometries;
3958 }
3959 }
3960 fclose(file);
3961 return 0;
3962 }
3963 /*************************************************************************************/
read_gabedit_file_all_geoms(gchar * fileName)3964 static gint read_gabedit_file_all_geoms(gchar *fileName)
3965 {
3966 gint res = 0;
3967 gint nG = get_number_geoms_gabedit(fileName);
3968 if(nG<0)
3969 {
3970 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),fileName);
3971 MessageGeom(t,_("Error"),TRUE);
3972 g_free(t);
3973 return 1;
3974 }
3975 if(nG<1)
3976 {
3977 gchar* t = g_strdup_printf(_("Sorry,\n No geometry in %s file"),fileName);
3978 MessageGeom(t,_("Error"),TRUE);
3979 g_free(t);
3980 return 1;
3981 }
3982 if(nG==1)
3983 {
3984 res = read_gabedit_geoms_file(fileName, 1);
3985 }
3986 else
3987 {
3988 find_energy_gabedit(fileName);
3989 }
3990 if(res==0)
3991 {
3992 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
3993 else if(GeomDrawingArea == NULL) create_window_drawing();
3994 if(GeomDrawingArea != NULL) rafresh_drawing();
3995 }
3996 return res;
3997 }
3998 /*************************************************************************************/
read_gabedit_file_no_add_list(gchar * fileName)3999 void read_gabedit_file_no_add_list(gchar *fileName)
4000 {
4001 if(read_gabedit_file_all_geoms(fileName) != 0)
4002 {
4003
4004 }
4005 }
4006 /*************************************************************************************/
add_gabedit_file_to_list(G_CONST_RETURN gchar * fileName)4007 static void add_gabedit_file_to_list(G_CONST_RETURN gchar *fileName)
4008 {
4009 gchar *projectname = NULL;
4010 gchar *datafile = NULL;
4011 gchar *localdir = NULL;
4012 gchar *remotehost = NULL;
4013 gchar *remoteuser = NULL;
4014 gchar *remotepass = NULL;
4015 gchar *remotedir = NULL;
4016 gchar *temp = NULL;
4017
4018 datafile = get_name_file(fileName);
4019 temp = get_suffix_name_file(fileName);
4020 projectname = get_name_file(temp);
4021 localdir = get_name_dir(temp);
4022 if(lastdirectory) g_free(lastdirectory);
4023 lastdirectory = g_strdup(localdir);
4024 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_GABEDIT],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_GABEDIT, NULL, defaultNetWorkProtocol);
4025 g_free(temp);
4026 g_free(datafile);
4027 g_free(projectname);
4028 g_free(localdir);
4029 }
4030 /*************************************************************************************/
read_gabedit_file_add_list(gchar * fileName)4031 void read_gabedit_file_add_list(gchar *fileName)
4032 {
4033 if(read_gabedit_file_all_geoms(fileName) != 0) return ;
4034 add_gabedit_file_to_list(fileName);
4035 }
4036 /********************************************************************************/
read_gabedit_file(GabeditFileChooser * SelecFile,gint response_id)4037 void read_gabedit_file(GabeditFileChooser *SelecFile, gint response_id)
4038 {
4039 gchar* fileName = NULL;
4040 if(response_id != GTK_RESPONSE_OK) return;
4041
4042 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4043
4044 if ((!fileName) || (strcmp(fileName,"") == 0))
4045 {
4046 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
4047 return ;
4048 }
4049 read_gabedit_file_add_list(fileName);
4050 }
4051 /********************************************************************************/
read_poscar_file(GabeditFileChooser * SelecFile,gint response_id)4052 void read_poscar_file(GabeditFileChooser *SelecFile, gint response_id)
4053 {
4054 gchar* fileName = NULL;
4055 if(response_id != GTK_RESPONSE_OK) return;
4056
4057 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4058
4059 if ((!fileName) || (strcmp(fileName,"") == 0))
4060 {
4061 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
4062 return ;
4063 }
4064 read_geom_from_poscar_file(fileName);
4065 }
4066 /********************************************************************************/
read_cif_file(GabeditFileChooser * SelecFile,gint response_id)4067 void read_cif_file(GabeditFileChooser *SelecFile, gint response_id)
4068 {
4069 gboolean applySymOp = TRUE;
4070 gchar* fileName = NULL;
4071 if(response_id != GTK_RESPONSE_OK) return;
4072
4073 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4074
4075 if ((!fileName) || (strcmp(fileName,"") == 0))
4076 {
4077 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
4078 return ;
4079 }
4080 read_geom_from_cif_file(fileName, applySymOp);
4081 }
4082 /********************************************************************************/
read_cif_file_nosym(GabeditFileChooser * SelecFile,gint response_id)4083 void read_cif_file_nosym(GabeditFileChooser *SelecFile, gint response_id)
4084 {
4085 gboolean applySymOp = FALSE;
4086 gchar* fileName = NULL;
4087 if(response_id != GTK_RESPONSE_OK) return;
4088
4089 fileName = gabedit_file_chooser_get_current_file(SelecFile);
4090
4091 if ((!fileName) || (strcmp(fileName,"") == 0))
4092 {
4093 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
4094 return ;
4095 }
4096 read_geom_from_cif_file(fileName, applySymOp);
4097 }
4098 /********************************************************************************/
save_in_xyz_and_conversion(GtkWidget * wid,gpointer data)4099 static void save_in_xyz_and_conversion(GtkWidget *wid,gpointer data)
4100 {
4101 gchar *fout = g_strdup_printf("%s%stmp%sfout",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4102 gchar *ferr = g_strdup_printf("%s%stmp%sferr",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4103 gchar *inputFileName = g_strdup_printf("%s%stmp%sgeom.xyz",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4104 G_CONST_RETURN gchar* outputFileName;
4105 gchar outputFileType[100];
4106 gchar inputFileType[] ="xyz" ;
4107 GtkWidget* entryFileName = NULL;
4108 GtkWidget* entryFileType = NULL;
4109 G_CONST_RETURN gchar* t0;
4110 gchar* t;
4111 gchar* strout;
4112 gchar* strerr;
4113
4114 GtkWidget *Win = (GtkWidget *)data;
4115 if(!this_is_an_object((GtkObject*)Win)) return;
4116
4117 entryFileName = g_object_get_data (G_OBJECT (Win), "EntryFileName");
4118 entryFileType = g_object_get_data (G_OBJECT (Win), "EntryCombo");
4119
4120 if(!this_is_an_object((GtkObject*)entryFileName)) return;
4121 if(!this_is_an_object((GtkObject*)entryFileType)) return;
4122
4123 save_xyz_file_no_add_list(inputFileName);
4124
4125 outputFileName = gtk_entry_get_text(GTK_ENTRY(entryFileName));
4126
4127 t0 = gtk_entry_get_text(GTK_ENTRY(entryFileType));
4128 sscanf(t0,"%s",outputFileType);
4129 if(strstr(t0,"Automatic")) t = g_strdup_printf("%s %s -O %s", babelCommand, inputFileName, outputFileName);
4130 else t = g_strdup_printf("%s -i%s %s -o%s -O %s", babelCommand, inputFileType, inputFileName, outputFileType, outputFileName);
4131
4132 run_local_command(fout,ferr,t,FALSE);
4133 strout = cat_file(fout,FALSE);
4134 strerr = cat_file(ferr,FALSE);
4135 if(strout)
4136 {
4137 Message(strout, "Info", TRUE);
4138 g_free(strout);
4139 }
4140 if(strerr)
4141 {
4142 Message(strerr, "Error", TRUE);
4143 g_free(strerr);
4144 }
4145 unlink(fout);
4146 unlink(ferr);
4147 unlink(inputFileName);
4148 g_free(fout);
4149 g_free(ferr);
4150 g_free(t);
4151 g_free(inputFileName);
4152 }
4153 /********************************************************************************/
create_babel_save_dialogue()4154 void create_babel_save_dialogue()
4155 {
4156 GtkWidget* okButton = create_babel_read_save_dialogue(FALSE);
4157 GtkWidget* win = g_object_get_data (G_OBJECT (okButton), "Window");
4158
4159 g_signal_connect(G_OBJECT(okButton), "clicked", G_CALLBACK(save_in_xyz_and_conversion),win);
4160 g_signal_connect_swapped(G_OBJECT(okButton), "clicked",G_CALLBACK(delete_child),GTK_OBJECT(win));
4161 }
4162 /******************************************************************************/
save_atom_hin_file(FILE * file,gchar * name,gint atomNumber,gchar * atomPDBType,gchar * atomMMType,gchar * residueName,gint residueNumber,gdouble x,gdouble y,gdouble z,gdouble occupancy,gdouble temperature,gchar * symbol,gdouble charge,gint N,gint * connection,gint * connectionType)4163 static void save_atom_hin_file(FILE* file,
4164 gchar*name, gint atomNumber,
4165 gchar* atomPDBType, gchar* atomMMType, gchar* residueName,
4166 gint residueNumber,
4167 gdouble x, gdouble y, gdouble z,
4168 gdouble occupancy,
4169 gdouble temperature,
4170 gchar* symbol,
4171 gdouble charge,
4172 gint N,
4173 gint* connection,
4174 gint* connectionType
4175 )
4176 {
4177 gint i;
4178 fprintf(file,"%s %d ",name,atomNumber);
4179 fprintf(file,"%s ",atomPDBType);
4180 fprintf(file,"%s ",symbol);
4181 fprintf(file,"%s - ",atomMMType);
4182 fprintf(file,"%f ",charge);
4183 fprintf(file,"%f ",x);
4184 fprintf(file,"%f ",y);
4185 fprintf(file,"%f ",z);
4186 if(N>0)
4187 {
4188 fprintf(file,"%d ",N);
4189 for(i=0;i<N;i++)
4190 {
4191 if(connectionType[i]==3) fprintf(file,"%d t ",connection[i]);
4192 else if(connectionType[i]==2) fprintf(file,"%d d ",connection[i]);
4193 else fprintf(file,"%d s ",connection[i]);
4194 }
4195 }
4196 fprintf(file,"\n");
4197 }
4198 /*****************************************************************************/
save_hin_file(G_CONST_RETURN gchar * FileName)4199 gboolean save_hin_file(G_CONST_RETURN gchar* FileName)
4200 {
4201 gint i;
4202 gint j;
4203 gint k;
4204 FILE* fd;
4205 gdouble X;
4206 gdouble Y;
4207 gdouble Z;
4208 gchar *projectname = NULL;
4209 gchar *datafile = NULL;
4210 gchar *localdir = NULL;
4211 gchar *remotehost = NULL;
4212 gchar *remoteuser = NULL;
4213 gchar *remotepass = NULL;
4214 gchar *remotedir = NULL;
4215 gchar *temp = NULL;
4216 gint* connection = NULL;
4217 gint* connectionType = NULL;
4218 gint N;
4219
4220 if(NcentersXYZ<1) return TRUE;
4221
4222 temp = get_suffix_name_file(FileName);
4223 FileName = g_strdup_printf("%s.hin",temp);
4224 g_free(temp);
4225 fd = FOpen(FileName, "w");
4226
4227
4228 if(fd == NULL)
4229 {
4230 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
4231 Message(t,_("Error"),TRUE);
4232 g_free(t);
4233 return FALSE;
4234 }
4235
4236 sortGeomXYZByResidueNumber();
4237
4238
4239 fprintf(fd,"forcefield Amber99\n");
4240 fprintf(fd,"sys 0 0 1\n");
4241 fprintf(fd,"view 40 0.1272 55 15 0.247224 0.3713666 0.8949677 -0.8641704 0.5022867 0.0302929 -0.4382806 -0.7808937 0.4451014 6.191 0.64575 -54.754\n");
4242 fprintf(fd,"seed -1108\n");
4243 fprintf(fd,"mol 1\n");
4244 if(NcentersXYZ>0 && strcmp(GeomXYZ[0].Residue,"U")!=0)
4245 fprintf(fd,"res 1 %s 1 - - \n",GeomXYZ[0].Residue);
4246
4247 connection = g_malloc(NcentersXYZ*sizeof(gint));
4248 connectionType = g_malloc(NcentersXYZ*sizeof(gint));
4249
4250 j = 1;
4251 for(i=0;i<(gint)NcentersXYZ;i++)
4252 {
4253 N = 0;
4254 if(GeomXYZ[i].typeConnections)
4255 for(k=0;k<(gint)NcentersXYZ;k++)
4256 {
4257 if(i==k) continue;
4258 if(GeomXYZ[i].typeConnections[k]>0)
4259 {
4260 connection[N] = k+1;
4261 connectionType[N] = GeomXYZ[i].typeConnections[k];
4262 N++;
4263 }
4264 }
4265
4266 if(i>0&& strcmp(GeomXYZ[i].Residue,GeomXYZ[i-1].Residue)!=0)
4267 {
4268 fprintf(fd,"endres %d\n",j);
4269 /* if(i!=(gint)(NcentersXYZ-1)) */
4270 fprintf(fd,"res %d %s %d - - \n",j+1,GeomXYZ[i].Residue,j+1);
4271 j++;
4272 }
4273 if(!test(GeomXYZ[i].X)) X = get_value_variableXYZ(GeomXYZ[i].X);
4274 else X = atof(GeomXYZ[i].X);
4275 if(!test(GeomXYZ[i].Y)) Y = get_value_variableXYZ(GeomXYZ[i].Y);
4276 else Y = atof(GeomXYZ[i].Y);
4277 if(!test(GeomXYZ[i].Z)) Z = get_value_variableXYZ(GeomXYZ[i].Z);
4278 else Z = atof(GeomXYZ[i].Z);
4279 if(Units==0)
4280 {
4281 X *= BOHR_TO_ANG;
4282 Y *= BOHR_TO_ANG;
4283 Z *= BOHR_TO_ANG;
4284 }
4285 save_atom_hin_file(fd,"ATOM",i+1,GeomXYZ[i].pdbType, GeomXYZ[i].mmType,GeomXYZ[i].Residue,
4286 GeomXYZ[i].ResidueNumber, X,Y,Z,
4287 1.0, 300.0, GeomXYZ[i].Symb, atof(GeomXYZ[i].Charge),N,connection, connectionType);
4288 }
4289 if(NcentersXYZ>0 && strcmp(GeomXYZ[NcentersXYZ-1].Residue,"U")!=0)
4290 fprintf(fd,"endres %d\n",j);
4291 fprintf(fd,"endmol 1\n");
4292 fclose(fd);
4293 g_free(connection);
4294 g_free(connectionType);
4295
4296 datafile = get_name_file(FileName);
4297 temp = get_suffix_name_file(FileName);
4298 projectname = get_name_file(temp);
4299 localdir = get_name_dir(temp);
4300 if(lastdirectory)
4301 g_free(lastdirectory);
4302 lastdirectory = g_strdup(localdir);
4303 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_HIN],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_HIN, NULL, defaultNetWorkProtocol);
4304 g_free(temp);
4305 g_free(datafile);
4306 g_free(projectname);
4307 g_free(localdir);
4308 return TRUE;
4309 }
4310 /************************************************************************************/
save_geometry_hin_file(GabeditFileChooser * SelecFile,gint response_id)4311 void save_geometry_hin_file(GabeditFileChooser *SelecFile, gint response_id)
4312 {
4313 gchar *FileName;
4314
4315 if(response_id != GTK_RESPONSE_OK) return;
4316 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4317 if ((!FileName) || (strcmp(FileName,"") == 0))
4318 {
4319 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
4320 return ;
4321 }
4322 save_hin_file(FileName);
4323 }
4324 /********************************************************************************/
save_hin_file_entry(GtkWidget * entry)4325 void save_hin_file_entry(GtkWidget* entry)
4326 {
4327 G_CONST_RETURN gchar *FileName;
4328
4329 FileName = gtk_entry_get_text(GTK_ENTRY(entry));
4330 if ((!FileName) || (strcmp(FileName,"") == 0))
4331 return ;
4332 save_hin_file(FileName);
4333 }
4334 /*****************************************************************************/
save_cchemi_file(G_CONST_RETURN gchar * fileNameGeom)4335 static gboolean save_cchemi_file(G_CONST_RETURN gchar* fileNameGeom)
4336 {
4337 FILE* file = NULL;
4338 gint j;
4339 gint k;
4340 gdouble X,Y,Z;
4341 gint nc = 0;
4342 gint* connection = NULL;
4343 gint* connectionType = NULL;
4344 gint ct;
4345 gboolean allFixed = TRUE;
4346
4347 if(NcentersXYZ<1) return FALSE;
4348 if(!GeomXYZ) return FALSE;
4349
4350 file = fopen(fileNameGeom, "w");
4351
4352 if(!file) return FALSE;
4353 fprintf(file,"#RunType = Energy, Optimization, MD, MDConfo, REMDConfo, RDCONFO, OptFreq\n");
4354 fprintf(file,"RunType=MDConfo\n");
4355 fprintf(file,"#Model = MM , Mopac , Orca or FireFly\n");
4356 fprintf(file,"Model=MM\n");
4357 fprintf(file,"#QMKeys=PM6\n");
4358 fprintf(file,"QMKeys=AM1\n");
4359 fprintf(file,"mopacCommand=mopac\n");
4360 fprintf(file,"orcaCommand=orca\n");
4361 fprintf(file,"fireflyCommand=firefly\n");
4362 fprintf(file,"\n");
4363 fprintf(file,"#Confo\n");
4364 fprintf(file,"gaussianCommand=g09\n");
4365 fprintf(file,"fireflyCommand=firefly\n");
4366 fprintf(file,"numberOfGeometries=500\n");
4367 fprintf(file,"tolEnergy=0.1\n");
4368 fprintf(file,"tolDistance=0.1\n");
4369 fprintf(file,"ConfoOptMM=TRUE\n");
4370 fprintf(file,"ConfoOptMopac=TRUE\n");
4371 fprintf(file,"ConfoOptMopacMethod=PM6 GNORM=0.001\n");
4372 fprintf(file,"ConfoOptFireFly=FALSE\n");
4373 fprintf(file,"# remove # if post processing required\n");
4374 fprintf(file,"#mopacKeywordsPost=PM6\n");
4375 fprintf(file,"gaussianKeywordsPost=B3LYP/6-31G*\n");
4376 fprintf(file,"#fireflyKeywordsPost=AM1\n");
4377 fprintf(file,"\n");
4378 fprintf(file,"#MM\n");
4379 fprintf(file,"# AMBER, UFF(not implemented), PAIRWISE\n");
4380 fprintf(file,"ForceFieldType=0\n");
4381 fprintf(file,"ForceFieldUseBond=TRUE\n");
4382 fprintf(file,"ForceFieldUseBend=TRUE\n");
4383 fprintf(file,"ForceFieldUseStrBend=FALSE\n");
4384 fprintf(file,"ForceFieldUseDihedral=TRUE\n");
4385 fprintf(file,"ForceFieldUseOutOfPlane=FALSE\n");
4386 fprintf(file,"ForceFieldUseImproper=FALSE\n");
4387 fprintf(file,"ForceFieldUseHydrogenBonded=FALSE\n");
4388 fprintf(file,"ForceFieldUsecoulomb=TRUE\n");
4389 fprintf(file,"#ForceFieldChargesType=ACKH2\n");
4390 fprintf(file,"#ForceFieldChargesType=ACKH2-BEGIN\n");
4391 fprintf(file,"#ForceFieldChargesType=EEM\n");
4392 fprintf(file,"#ForceFieldChargesType=EEM-BEGIN\n");
4393 fprintf(file,"ForceFieldVanderWals=6-12\n");
4394 fprintf(file,"#ForceFieldVanderWals=7-14\n");
4395 fprintf(file,"# NOCONSTRAINTS = 0, BONDSCONSTRAINTS = 1, BONDSANGLESCONSTRAINTS = 2\n");
4396 fprintf(file,"ForceFieldConstraints=1\n");
4397 fprintf(file,"\n");
4398 fprintf(file,"#MD\n");
4399 fprintf(file,"updateFrequency=5\n");
4400 fprintf(file,"#Time in ps\n");
4401 fprintf(file,"heatTime = 0.1\n");
4402 fprintf(file,"equiTime = 0.1\n");
4403 fprintf(file,"runTime = 2.0\n");
4404 fprintf(file,"coolTime = 0\n");
4405 fprintf(file,"timeExchange = 0.01\n");
4406 fprintf(file,"heatTemp = 0\n");
4407 fprintf(file,"runTemp = 400\n");
4408 fprintf(file,"runTempMax = 700\n");
4409 fprintf(file,"nTemperatures = 10\n");
4410 fprintf(file,"#in fs\n");
4411 fprintf(file,"stepSize = 0.5\n");
4412 fprintf(file,"# VERLET = 0, BEEMAN = 1, STOCHASTIC = 2\n");
4413 fprintf(file,"integrator = 0\n");
4414 fprintf(file,"# NONE = 0, ANDERSEN = 1, BERENDSEN = 2, BUSSI = 3, NOSEHOOVER = 4\n");
4415 fprintf(file,"thermostat = 0\n");
4416 fprintf(file,"friction=40\n");
4417 fprintf(file,"collide = 20\n");
4418 fprintf(file,"\n");
4419 fprintf(file,"#QuasiNewton\n");
4420 fprintf(file,"useQuasiNewton = TRUE\n");
4421 fprintf(file,"quasiNewtonMaxIterations = 20000\n");
4422 fprintf(file,"quasiNewtonUpdateFrequency = 100\n");
4423 fprintf(file,"quasiNewtonEpsilon = 0.0001\n");
4424 fprintf(file,"quasiNewtonTolerence = 1e-16\n");
4425 fprintf(file,"quasiNewtonMaxLines = 25\n");
4426 fprintf(file,"\n");
4427 fprintf(file,"#ConjugateGradient\n");
4428 fprintf(file,"useConjugateGradient = FALSE\n");
4429 fprintf(file,"conjugateGradientGradientNorm = 1e-3\n");
4430 fprintf(file,"conjugateGradientMaxIterations = 100\n");
4431 fprintf(file,"conjugateGradientUpdateFrequency = 1\n");
4432 fprintf(file,"conjugateGradientMaxLines = 25\n");
4433 fprintf(file,"conjugateGradientInitialStep = 0.001\n");
4434 fprintf(file,"# 1 : Hestenes Stiefel, 2 : Fletcher Reeves, 3 : Polak Ribiere, 4 : Wolf Powell\n");
4435 fprintf(file,"conjugateGradientMethod = 1\n");
4436 fprintf(file,"\n");
4437 fprintf(file,"#Geometry, nAtoms, charge, spin multiplicity. For each atom : symbol, MMType, pdbType, residueName, numResidue, charge, layer, x(Ang),y,z, nconn, num1, type1, num2, type2,...\n");
4438 fprintf(file,"Geometry\n");
4439 fprintf(file,"%d %d %d\n",Natoms,TotalCharges[0],SpinMultiplicities[0]);
4440
4441 connection = g_malloc(NcentersXYZ*sizeof(gint));
4442 connectionType = g_malloc(NcentersXYZ*sizeof(gint));
4443
4444 for(j=0;j<NcentersXYZ;j++)
4445 if( !test(GeomXYZ[j].X) || !test(GeomXYZ[j].Y) || !test(GeomXYZ[j].Z) ) {allFixed = FALSE;break;}
4446
4447 for(j=0;j<NcentersXYZ;j++)
4448 {
4449 int variable = 0;
4450 if( !test(GeomXYZ[j].X) || !test(GeomXYZ[j].Y) || !test(GeomXYZ[j].Z) ) variable = 1;
4451 if(!test(GeomXYZ[j].X)) X = get_value_variableXYZ(GeomXYZ[j].X);
4452 else X = atof(GeomXYZ[j].X);
4453 if(!test(GeomXYZ[j].Y)) Y = get_value_variableXYZ(GeomXYZ[j].Y);
4454 else Y = atof(GeomXYZ[j].Y);
4455 if(!test(GeomXYZ[j].Z)) Z = get_value_variableXYZ(GeomXYZ[j].Z);
4456 else Z = atof(GeomXYZ[j].Z);
4457 if(allFixed) variable = 1;
4458 if(Units==0)
4459 {
4460 X *= BOHR_TO_ANG;
4461 Y *= BOHR_TO_ANG;
4462 Z *= BOHR_TO_ANG;
4463 }
4464 nc = 0;
4465 if(GeomXYZ[j].typeConnections)
4466 for(k=0;k<(gint)NcentersXYZ;k++)
4467 {
4468 if(j==k) continue;
4469 ct = GeomXYZ[j].typeConnections[k];
4470 if( ct!=0)
4471 {
4472 connection[nc] = k+1;
4473 connectionType[nc] = ct;
4474 nc++;
4475 }
4476 }
4477
4478 fprintf(file," %s %s %s %s %d %f %d %d %f %f %f ",
4479 GeomXYZ[j].Symb,
4480 GeomXYZ[j].mmType,
4481 GeomXYZ[j].pdbType,
4482 GeomXYZ[j].Residue,
4483 GeomXYZ[j].ResidueNumber,
4484 atof(GeomXYZ[j].Charge),
4485 get_layer(GeomXYZ[j].Layer),
4486 variable,
4487 X,
4488 Y,
4489 Z
4490 );
4491 fprintf(file," %d ", nc);
4492 for(k=0;k<nc;k++)
4493 fprintf(file," %d %d", connection[k], connectionType[k]);
4494 fprintf(file,"\n");
4495
4496 }
4497
4498 fclose(file);
4499 return TRUE;
4500 }
4501 /*****************************************************************************/
save_gabedit_file(G_CONST_RETURN gchar * fileNameGeom)4502 static gboolean save_gabedit_file(G_CONST_RETURN gchar* fileNameGeom)
4503 {
4504 FILE* file = NULL;
4505 gint j;
4506 gint k;
4507 gdouble X,Y,Z;
4508 gint nc = 0;
4509 gint* connection = NULL;
4510 gint* connectionType = NULL;
4511 gint ct;
4512 gint form = 1;
4513
4514 if(NcentersXYZ<1) return FALSE;
4515 if(!GeomXYZ) return FALSE;
4516
4517 file = fopen(fileNameGeom, "w");
4518
4519 if(!file) return FALSE;
4520
4521 fprintf(file,"[Gabedit Format]\n");
4522 fprintf(file,"[GEOMS] %d\n",form);
4523 fprintf(file,"1 1\n");
4524 fprintf(file,"ENERGY UNK 1\n");
4525 fprintf(file,"0.0\n");
4526 fprintf(file,"%d %d %d\n",Natoms,TotalCharges[0],SpinMultiplicities[0]);
4527
4528 connection = g_malloc(NcentersXYZ*sizeof(gint));
4529 connectionType = g_malloc(NcentersXYZ*sizeof(gint));
4530
4531 for(j=0;j<NcentersXYZ;j++)
4532 {
4533 int variable = 0;
4534 if(!test(GeomXYZ[j].X)) X = get_value_variableXYZ(GeomXYZ[j].X);
4535 else X = atof(GeomXYZ[j].X);
4536 if(!test(GeomXYZ[j].Y)) Y = get_value_variableXYZ(GeomXYZ[j].Y);
4537 else Y = atof(GeomXYZ[j].Y);
4538 if(!test(GeomXYZ[j].Z)) Z = get_value_variableXYZ(GeomXYZ[j].Z);
4539 else Z = atof(GeomXYZ[j].Z);
4540 if( !test(GeomXYZ[j].X) || !test(GeomXYZ[j].Y) || !test(GeomXYZ[j].Z) ) variable = 1;
4541 if(Units==0)
4542 {
4543 X *= BOHR_TO_ANG;
4544 Y *= BOHR_TO_ANG;
4545 Z *= BOHR_TO_ANG;
4546 }
4547 nc = 0;
4548 if(GeomXYZ[j].typeConnections)
4549 for(k=0;k<(gint)NcentersXYZ;k++)
4550 {
4551 if(j==k) continue;
4552 ct = GeomXYZ[j].typeConnections[k];
4553 if( ct!=0)
4554 {
4555 connection[nc] = k+1;
4556 connectionType[nc] = ct;
4557 nc++;
4558 }
4559 }
4560
4561 fprintf(file," %s %s %s %s %d %f %d %d %f %f %f ",
4562 GeomXYZ[j].Symb,
4563 GeomXYZ[j].mmType,
4564 GeomXYZ[j].pdbType,
4565 GeomXYZ[j].Residue,
4566 GeomXYZ[j].ResidueNumber,
4567 atof(GeomXYZ[j].Charge),
4568 get_layer(GeomXYZ[j].Layer),
4569 variable,
4570 X,
4571 Y,
4572 Z
4573 );
4574 fprintf(file," %d ", nc);
4575 for(k=0;k<nc;k++)
4576 fprintf(file," %d %d", connection[k], connectionType[k]);
4577 fprintf(file,"\n");
4578
4579 }
4580
4581 fclose(file);
4582 add_gabedit_file_to_list(fileNameGeom);
4583 return TRUE;
4584 }
4585 /************************************************************************************/
save_geometry_gabedit_file(GabeditFileChooser * SelecFile,gint response_id)4586 void save_geometry_gabedit_file(GabeditFileChooser *SelecFile, gint response_id)
4587 {
4588 gchar *FileName;
4589
4590 if(response_id != GTK_RESPONSE_OK) return;
4591 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4592 if ((!FileName) || (strcmp(FileName,"") == 0))
4593 {
4594 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
4595 return ;
4596 }
4597 save_gabedit_file(FileName);
4598 }
4599 /************************************************************************************/
save_geometry_cchemi_file(GabeditFileChooser * SelecFile,gint response_id)4600 void save_geometry_cchemi_file(GabeditFileChooser *SelecFile, gint response_id)
4601 {
4602 gchar *FileName;
4603
4604 if(response_id != GTK_RESPONSE_OK) return;
4605 FileName = gabedit_file_chooser_get_current_file(SelecFile);
4606 if ((!FileName) || (strcmp(FileName,"") == 0))
4607 {
4608 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
4609 return ;
4610 }
4611 save_cchemi_file(FileName);
4612 }
4613 /*****************************************************************************************/
conversion_to_xyz_and_read(GtkWidget * wid,gpointer data)4614 static void conversion_to_xyz_and_read(GtkWidget *wid,gpointer data)
4615 {
4616 gchar *fout = g_strdup_printf("%s%stmp%sfout",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4617 gchar *ferr = g_strdup_printf("%s%stmp%sferr",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4618 gchar *outputFileName = g_strdup_printf("%s%stmp%sgeom.xyz",gabedit_directory(),G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
4619 G_CONST_RETURN gchar* inputFileName;
4620 gchar inputFileType[100];
4621 gchar outputFileType[] ="xyz" ;
4622 GtkWidget* entryFileName = NULL;
4623 GtkWidget* entryFileType = NULL;
4624 G_CONST_RETURN gchar* t0;
4625 gchar* t;
4626 gchar* strout;
4627 gchar* strerr;
4628
4629 GtkWidget *Win = (GtkWidget *)data;
4630 if(!this_is_an_object((GtkObject*)Win)) return;
4631
4632 entryFileName = g_object_get_data (G_OBJECT (Win), "EntryFileName");
4633 entryFileType = g_object_get_data (G_OBJECT (Win), "EntryCombo");
4634
4635 if(!this_is_an_object((GtkObject*)entryFileName)) return;
4636 if(!this_is_an_object((GtkObject*)entryFileType)) return;
4637
4638 inputFileName = gtk_entry_get_text(GTK_ENTRY(entryFileName));
4639
4640 t0 = gtk_entry_get_text(GTK_ENTRY(entryFileType));
4641 sscanf(t0,"%s",inputFileType);
4642 if(strstr(t0,"Automatic")) t = g_strdup_printf("%s %s -O %s", babelCommand, inputFileName, outputFileName);
4643 else t = g_strdup_printf("%s -i%s %s -o%s -O %s", babelCommand, inputFileType, inputFileName, outputFileType, outputFileName);
4644
4645 unlink(fout);
4646 unlink(ferr);
4647 /* printf("babelcommand = %s\n",t);*/
4648 run_local_command(fout,ferr,t,FALSE);
4649 strout = cat_file(fout,FALSE);
4650 strerr = cat_file(ferr,FALSE);
4651 if(strout)
4652 {
4653 Message(strout, "Info", TRUE);
4654 g_free(strout);
4655 }
4656 if(strerr)
4657 {
4658 Message(strerr, "Error", TRUE);
4659 g_free(strerr);
4660 }
4661 /*else*/
4662 {
4663 MethodeGeom = GEOM_IS_XYZ;
4664 read_XYZ_file_no_add_list(outputFileName);
4665 }
4666 unlink(fout);
4667 unlink(ferr);
4668 unlink(outputFileName);
4669 g_free(fout);
4670 g_free(ferr);
4671 g_free(t);
4672 g_free(outputFileName);
4673 }
4674 /********************************************************************************/
create_babel_read_dialogue()4675 void create_babel_read_dialogue()
4676 {
4677 GtkWidget* okButton = create_babel_read_save_dialogue(TRUE);
4678 GtkWidget* win = g_object_get_data (G_OBJECT (okButton), "Window");
4679
4680 g_signal_connect(G_OBJECT(okButton), "clicked", G_CALLBACK(conversion_to_xyz_and_read),win);
4681 g_signal_connect_swapped(G_OBJECT(okButton), "clicked",G_CALLBACK(delete_child),GTK_OBJECT(win));
4682 }
4683 /*************************************************************************************/
read_charges_from_gromacs_topology_file(gchar * NomFichier)4684 void read_charges_from_gromacs_topology_file(gchar *NomFichier)
4685 {
4686 gchar *fileNameTOP = NULL;
4687 FILE* file;
4688 gchar* str = NULL;
4689 gchar** split = NULL;
4690 gint i,j;
4691
4692 fileNameTOP = get_suffix_name_file(NomFichier);
4693 fileNameTOP = g_strdup_printf("%s.top",fileNameTOP);
4694 file = FOpen(fileNameTOP, "rb");
4695 if(fileNameTOP) g_free(fileNameTOP);
4696 if(file == NULL) return;
4697 str = g_malloc(BSIZE*sizeof(gchar));
4698 fseek(file, 0L, SEEK_SET);
4699
4700 while(!feof(file))
4701 {
4702 if(!fgets(str,BSIZE,file)) break;
4703 if(strstr(str,"[ atoms ]"))
4704 {
4705 break;
4706 }
4707 }
4708
4709 j = -1;
4710 while(!feof(file))
4711 {
4712 if(!fgets(str,BSIZE,file)) break;
4713 if(strlen(str)>0 && str[0] ==';') continue;
4714 if(strstr(str,"[")) break;
4715 split = NULL;
4716 split = gab_split(str);
4717 i = 0;
4718 if(split)
4719 for(i=0;i<8;i++)
4720 {
4721 if(split[i]==NULL) break;
4722 if(i==6 && split[i]) break;
4723 }
4724 if(i==6)
4725 {
4726 j++;
4727 GeomXYZ[j].Charge=g_strdup(split[6]);
4728 }
4729 if(split) g_strfreev(split);
4730 if(j>=NcentersXYZ) break;
4731 }
4732 fclose(file);
4733 }
4734 /*************************************************************************************/
read_atom_pdb_file(gchar * line,gchar * listFields[])4735 static gboolean read_atom_pdb_file(gchar* line,gchar* listFields[])
4736 {
4737 gint i;
4738 gint k = 0;
4739 if(strlen(line)<54)
4740 return FALSE;
4741
4742 /* 0 -> Atom Type */
4743 k = 0;
4744 for(i=0;i<MAXATOMTYPE;i++)
4745 listFields[k][i] = line[13+i-1];
4746 listFields[k][MAXATOMTYPE] = '\0';
4747 if(isdigit(listFields[k][0]))
4748 {
4749 gchar c0 = listFields[k][0];
4750 for(i=0;i<MAXATOMTYPE-1;i++)
4751 listFields[k][i] = listFields[k][i+1];
4752 listFields[k][MAXATOMTYPE-1] = c0;
4753 }
4754 /* 1-> Residue Name */
4755 k = 1;
4756 for(i=0;i<MAXRESIDUENAME;i++)
4757 listFields[k][i] = line[17+i-1];
4758 listFields[k][MAXRESIDUENAME] = '\0';
4759
4760 /* 2-> Residue Number */
4761 k = 2;
4762 for(i=0;i<4;i++)
4763 listFields[k][i] = line[23+i-1];
4764 listFields[k][4] = '\0';
4765 /* 3-> x */
4766 k = 3;
4767 for(i=0;i<8;i++)
4768 listFields[k][i] = line[31+i-1];
4769 listFields[k][8] = '\0';
4770
4771 /* 4-> y */
4772 k = 4;
4773 for(i=0;i<8;i++)
4774 listFields[k][i] = line[39+i-1];
4775 listFields[k][8] = '\0';
4776
4777 /* 5-> z */
4778 k = 5;
4779 for(i=0;i<8;i++)
4780 listFields[k][i] = line[47+i-1];
4781 listFields[k][8] = '\0';
4782
4783 /* 6-> Symbol */
4784 k = 6;
4785 if(strlen(line)>=78)
4786 {
4787 for(i=0;i<2;i++)
4788 {
4789 listFields[k][i] = line[76+i];
4790 }
4791 listFields[k][2] = '\0';
4792 if(listFields[k][1]==' ')
4793 listFields[k][1] = '\0';
4794 if(listFields[k][0]==' ')
4795 listFields[k][0] = '\0';
4796 }
4797 else
4798 listFields[k][0] = '\0';
4799 /* 7-> Charge */
4800 k = 7;
4801 if(strlen(line)>=80)
4802 {
4803 for(i=0;i<(gint)strlen(line)-79+1;i++)
4804 listFields[k][i] = line[79+i-1];
4805
4806 listFields[k][strlen(line)-79+1] = '\0';
4807
4808 if(listFields[k][strlen(line)-79]=='\n')
4809 listFields[k][strlen(line)-79]='\0';
4810
4811 }
4812 else
4813 listFields[k][0] = '\0';
4814
4815 for(i=0;i<8;i++)
4816 {
4817 delete_last_spaces(listFields[i]);
4818 delete_first_spaces(listFields[i]);
4819 }
4820 return TRUE;
4821
4822 }
4823 /********************************************************************************/
get_connections_one_connect_pdb(gchar * t)4824 gint get_connections_one_connect_pdb(gchar* t)
4825 {
4826 gint k;
4827 gint ni;
4828 gint nj;
4829 gchar** split = NULL;
4830 gint nA = 0;
4831 split = gab_split(t);
4832 nA = 0;
4833 while(split && split[nA]!=NULL) nA++;
4834 if(nA<3)
4835 {
4836 g_strfreev(split);
4837 return 0;
4838 }
4839 ni = atoi(split[1])-1;
4840 if(ni<0 || ni>NcentersXYZ-1)
4841 {
4842 g_strfreev(split);
4843 return 0;
4844 }
4845 GeomXYZ[ni].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
4846 for(k=0;k<NcentersXYZ;k++) GeomXYZ[ni].typeConnections[k] = 0;
4847 for(k=0;k<nA-2;k++)
4848 {
4849 if(!split[2+k]) break;
4850 nj = atoi(split[2+k])-1;
4851 if(nj<0 || nj>NcentersXYZ-1) continue;
4852 GeomXYZ[ni].typeConnections[nj] = 1;
4853 }
4854
4855 g_strfreev(split);
4856
4857 return 1;
4858 }
4859 /*************************************************************************************/
read_pdb_file_no_add_list(gchar * NomFichier)4860 void read_pdb_file_no_add_list(gchar *NomFichier)
4861 {
4862 gchar *t;
4863 gchar *listFields[8];
4864 FILE *fd;
4865 guint taille=BSIZE;
4866 guint i;
4867 gint j;
4868 gdouble charge;
4869
4870 for(i=0;i<8;i++)
4871 listFields[i]=g_malloc(taille*sizeof(gchar));
4872
4873
4874 fd = FOpen(NomFichier, "rb");
4875 if(fd == NULL)
4876 {
4877 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),NomFichier);
4878 MessageGeom(t,_("Error"),TRUE);
4879 return;
4880 }
4881 t=g_malloc(taille);
4882
4883
4884 if(GeomXYZ)
4885 freeGeomXYZ();
4886 if(VariablesXYZ)
4887 freeVariablesXYZ();
4888 init_dipole();
4889 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
4890 GeomXYZ[0].typeConnections = NULL;
4891
4892 j=0;
4893 while(!feof(fd))
4894 {
4895 if(!fgets(t,taille,fd)) break;
4896 sscanf(t,"%s",listFields[0]);
4897 if(strcmp(listFields[0],"HETATM")!=0 && strcmp(listFields[0],"ATOM")!=0)
4898 continue;
4899 if(!strcmp(t,"END"))
4900 break;
4901 if(!read_atom_pdb_file(t,listFields))
4902 continue;
4903 /* 0 -> Atom Type 1-> Residue Name 2-> Residue Number
4904 * 3-> x 4-> y 5-> z 6-> Symbol 7-> Charge */
4905 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
4906 GeomXYZ[j].typeConnections = NULL;
4907 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
4908 if(strlen(listFields[6])<=0)
4909 GeomXYZ[j].Symb= get_symb_atom(listFields[0]);
4910 else
4911 GeomXYZ[j].Symb= g_strdup(listFields[6]);
4912
4913 GeomXYZ[j].pdbType= g_strdup(listFields[0]);
4914 GeomXYZ[j].Residue= g_strdup(listFields[1]);
4915 GeomXYZ[j].ResidueNumber= atoi(listFields[2])-1;
4916 GeomXYZ[j].mmType= getMMTypeFromPDBTpl(GeomXYZ[j].Residue,GeomXYZ[j].pdbType,&charge);
4917
4918 if(Units==1)
4919 {
4920 GeomXYZ[j].X=g_strdup(listFields[3]);
4921 GeomXYZ[j].Y=g_strdup(listFields[4]);
4922 GeomXYZ[j].Z=g_strdup(listFields[5]);
4923 }
4924 else
4925 {
4926 GeomXYZ[j].X=g_strdup(ang_to_bohr(listFields[3]));
4927 GeomXYZ[j].Y=g_strdup(ang_to_bohr(listFields[4]));
4928 GeomXYZ[j].Z=g_strdup(ang_to_bohr(listFields[5]));
4929 }
4930 if(strlen(listFields[7])<=0)
4931 {
4932 GeomXYZ[j].Charge=g_strdup_printf("%f",charge);
4933 }
4934 else
4935 GeomXYZ[j].Charge=g_strdup(listFields[7]);
4936
4937 GeomXYZ[j].Layer=g_strdup(" ");
4938 j++;
4939 }
4940 fseek(fd, 0L, SEEK_SET);
4941 NcentersXYZ = j;
4942 NVariablesXYZ = 0;
4943 while(!feof(fd))
4944 {
4945 if(!fgets(t,taille,fd)) break;
4946 sscanf(t,"%s",listFields[0]);
4947 if(strcmp(listFields[0],"CONECT")!=0) continue;
4948 if(!strcmp(t,"END")) break;
4949 if(!read_atom_pdb_file(t,listFields)) continue;
4950 get_connections_one_connect_pdb(t);
4951 }
4952
4953 fclose(fd);
4954 /* multiple bond not define in a pdb file */
4955 set_multiple_bonds();
4956
4957 g_free(t);
4958 for(i=0;i<8;i++)
4959 g_free(listFields[i]);
4960 read_charges_from_gromacs_topology_file(NomFichier);
4961
4962 if(GeomIsOpen)
4963 {
4964 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
4965 }
4966 else
4967 if(GeomDrawingArea == NULL)
4968 {
4969 /*
4970 switch(iprogram)
4971 {
4972 case PROG_IS_MOLPRO :
4973 insert_molpro(2);
4974 break;
4975 case PROG_IS_GAUSS :
4976 insert_gaussian(2);
4977 break;
4978 default :
4979 edit_geometry();
4980 }
4981 */
4982 create_window_drawing();
4983 }
4984 if(GeomDrawingArea != NULL) rafresh_drawing();
4985 if(NcentersXYZ==0)
4986 {
4987 t = g_strdup_printf(_("Sorry\n I can read \"%s\" file"),NomFichier);
4988 MessageGeom(t,_("Error"),TRUE);
4989 return;
4990 }
4991 }
4992 /******************************************************************************/
save_atom_pdb_file(FILE * file,gchar * name,gint atomNumber,gchar * atomType,gchar * residueName,gint residueNumber,gdouble x,gdouble y,gdouble z,gdouble occupancy,gdouble temperature,gchar * symbol,gdouble charge)4993 static void save_atom_pdb_file(FILE* file,
4994 gchar*name, gint atomNumber,
4995 gchar* atomType, gchar* residueName,
4996 gint residueNumber,
4997 gdouble x, gdouble y, gdouble z,
4998 gdouble occupancy,
4999 gdouble temperature,
5000 gchar* symbol,
5001 gdouble charge
5002 )
5003 {
5004 gchar localName[MAXNAME+1];
5005 gchar localAtomType[MAXATOMTYPE+1];
5006 gchar localResidueName[MAXRESIDUENAME+1];
5007 gchar localSymbol[MAXSYMBOL+1];
5008
5009 localName[MAXNAME] = '\0';
5010 localAtomType[MAXATOMTYPE] = '\0';
5011 localResidueName[MAXRESIDUENAME] = '\0';
5012 localSymbol[MAXSYMBOL] = '\0';
5013
5014 if(strlen(name)>MAXNAME)
5015 strncpy(localName, name, MAXNAME);
5016 else
5017 strcpy(localName, name);
5018 uppercase(localName);
5019
5020 if(strlen(atomType)>MAXATOMTYPE)
5021 {
5022 strncpy(localAtomType, atomType, MAXATOMTYPE);
5023 }
5024 else
5025 {
5026 if(atomType && isdigit(atomType[0])) strcpy(localAtomType,atomType);
5027 else
5028 {
5029 sprintf(localAtomType," %s",atomType);
5030 if(strlen(localAtomType)>=MAXATOMTYPE)
5031 {
5032 if(isdigit(localAtomType[MAXATOMTYPE]))
5033 localAtomType[0] = localAtomType[MAXATOMTYPE];
5034 localAtomType[MAXATOMTYPE] = '\0';
5035 }
5036 }
5037 }
5038
5039 if(strlen(residueName)>=MAXRESIDUENAME)
5040 strncpy(localResidueName, residueName, MAXRESIDUENAME);
5041 else
5042 {
5043 sprintf(localResidueName," %s",residueName);
5044 if(strlen(localResidueName)>=MAXRESIDUENAME)
5045 {
5046 if(isdigit(localResidueName[MAXRESIDUENAME]))
5047 localResidueName[0] = localResidueName[MAXRESIDUENAME];
5048 localResidueName[MAXRESIDUENAME] = '\0';
5049 }
5050 }
5051 uppercase(localResidueName);
5052
5053 if(strlen(symbol)>MAXSYMBOL)
5054 strncpy(localSymbol, symbol, MAXSYMBOL);
5055 else
5056 strcpy(localSymbol,symbol);
5057 localSymbol[0] = toupper(localSymbol[0]);
5058 if(strlen(localSymbol)>1)
5059 localSymbol[1] = tolower(localSymbol[1]);
5060
5061 if(atomNumber>99999)
5062 atomNumber = 99999;
5063 if(residueNumber>9999)
5064 residueNumber = 9999;
5065
5066
5067 fprintf(file,"%-6s",localName); /* Atom or HETATM */
5068 fprintf(file,"%-6d",atomNumber);
5069 fprintf(file,"%-4s",localAtomType);
5070 fprintf(file,"%-4s",localResidueName);
5071 fprintf(file," ");
5072 fprintf(file,"%-4d",residueNumber);
5073 fprintf(file," ");
5074 fprintf(file,"%-8.3f",x);
5075 fprintf(file,"%-8.3f",y);
5076 fprintf(file,"%-8.3f",z);
5077 fprintf(file,"%-6.2f",occupancy);
5078 fprintf(file,"%-6.2f",temperature);
5079 fprintf(file," ");
5080 fprintf(file," ");
5081 fprintf(file,"%-2s",localSymbol);
5082 fprintf(file,"%-9.4f\n",charge);
5083 }
5084 /******************************************************************************/
save_pdb_file(G_CONST_RETURN gchar * FileName)5085 gboolean save_pdb_file(G_CONST_RETURN gchar* FileName)
5086 {
5087 guint i;
5088 guint j;
5089 FILE* fd;
5090 gdouble X;
5091 gdouble Y;
5092 gdouble Z;
5093 gchar *projectname = NULL;
5094 gchar *datafile = NULL;
5095 gchar *localdir = NULL;
5096 gchar *remotehost = NULL;
5097 gchar *remoteuser = NULL;
5098 gchar *remotepass = NULL;
5099 gchar *remotedir = NULL;
5100 gchar *temp = NULL;
5101 gint* connection = NULL;
5102 gint N;
5103
5104 temp = get_suffix_name_file(FileName);
5105 FileName = g_strdup_printf("%s.pdb",temp);
5106 g_free(temp);
5107 fd = FOpen(FileName, "w");
5108
5109 if(fd == NULL)
5110 {
5111 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
5112 Message(t,_("Error"),TRUE);
5113 g_free(t);
5114 return FALSE;
5115 }
5116 sortGeomXYZByResidueNumber();
5117
5118 fprintf(fd,"HEADER PROTEIN\n");
5119 fprintf(fd,"COMPND UNNAMED\n");
5120 temp = get_time_str();
5121 if(temp)
5122 fprintf(fd,"AUTHOR GENERATED BY GABEDIT %d.%d.%d at %s",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION,temp);
5123 else
5124 fprintf(fd,"AUTHOR GENERATED BY GABEDIT %d.%d.%d\n",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION);
5125
5126
5127 for(i=0;i<NcentersXYZ;i++)
5128 {
5129 if(!test(GeomXYZ[i].X))
5130 X = get_value_variableXYZ(GeomXYZ[i].X);
5131 else
5132 X = atof(GeomXYZ[i].X);
5133 if(!test(GeomXYZ[i].Y))
5134 Y = get_value_variableXYZ(GeomXYZ[i].Y);
5135 else
5136 Y = atof(GeomXYZ[i].Y);
5137 if(!test(GeomXYZ[i].Z))
5138 Z = get_value_variableXYZ(GeomXYZ[i].Z);
5139 else
5140 Z = atof(GeomXYZ[i].Z);
5141 if(Units==0)
5142 {
5143 X *= BOHR_TO_ANG;
5144 Y *= BOHR_TO_ANG;
5145 Z *= BOHR_TO_ANG;
5146 }
5147 save_atom_pdb_file(fd,"ATOM",i+1,GeomXYZ[i].pdbType,GeomXYZ[i].Residue,
5148 GeomXYZ[i].ResidueNumber+1, X,Y,Z,
5149 1.0, 300.0, GeomXYZ[i].Symb, atof(GeomXYZ[i].Charge));
5150 }
5151 connection = g_malloc(NcentersXYZ*sizeof(gint));
5152 for(i=0;i<NcentersXYZ;i++)
5153 {
5154 N = 0;
5155 for(j=0;j<NcentersXYZ;j++)
5156 {
5157 if(i==j) continue;
5158 if(GeomXYZ[i].typeConnections && GeomXYZ[i].typeConnections[j]>0)
5159 {
5160 connection[N] = j+1;
5161 N++;
5162 }
5163 }
5164 if(N>0)
5165 {
5166 gint len = 0;
5167 fprintf(fd,"CONECT %4d ",i+1);
5168 len += 6 + 1 +4;
5169 fprintf(fd,"%4d",connection[0]);
5170 len += 4;
5171 for(j=1;j<(guint)N;j++)
5172 {
5173 fprintf(fd,"%5d",connection[j]);
5174 len += 5;
5175 }
5176 if(len<72) for(j=1;j<72-len;j++) fprintf(fd," ");
5177
5178 fprintf(fd,"\n");
5179 }
5180 }
5181 fprintf(fd,"MASTER 0 0 0 0 0 0 0 0 ");
5182 fprintf(fd,"%4d 0 %4d 0\n",NcentersXYZ,NcentersXYZ);
5183 fprintf(fd,"END\n");
5184 fclose(fd);
5185 g_free(connection);
5186
5187 datafile = get_name_file(FileName);
5188 temp = get_suffix_name_file(FileName);
5189 projectname = get_name_file(temp);
5190 localdir = get_name_dir(temp);
5191 if(lastdirectory)
5192 g_free(lastdirectory);
5193 lastdirectory = g_strdup(localdir);
5194 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_PDB],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_PDB, NULL, defaultNetWorkProtocol);
5195 g_free(temp);
5196 g_free(datafile);
5197 g_free(projectname);
5198 g_free(localdir);
5199 return TRUE;
5200 }
5201 /************************************************************************************/
save_geometry_pdb_file(GabeditFileChooser * SelecFile,gint response_id)5202 void save_geometry_pdb_file(GabeditFileChooser *SelecFile, gint response_id)
5203 {
5204 gchar *FileName;
5205
5206 if(response_id != GTK_RESPONSE_OK) return;
5207 FileName = gabedit_file_chooser_get_current_file(SelecFile);
5208 if ((!FileName) || (strcmp(FileName,"") == 0))
5209 {
5210 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
5211 return ;
5212 }
5213 save_pdb_file(FileName);
5214 }
5215
5216 /********************************************************************************/
save_pdb_file_entry(GtkWidget * entry)5217 void save_pdb_file_entry(GtkWidget* entry)
5218 {
5219 G_CONST_RETURN gchar *FileName;
5220
5221 FileName = gtk_entry_get_text(GTK_ENTRY(entry));
5222 if ((!FileName) || (strcmp(FileName,"") == 0))
5223 return ;
5224 save_pdb_file(FileName);
5225 }
5226 /********************************************************************************/
get_charges_from_gamess_output_file(FILE * fd,gint N)5227 void get_charges_from_gamess_output_file(FILE* fd,gint N)
5228 {
5229 guint taille=BSIZE;
5230 gchar t[BSIZE];
5231 gchar dump[BSIZE];
5232 gchar d[BSIZE];
5233 gchar* pdest;
5234 gint i;
5235
5236
5237 /* printf("NAtoms = %d\n",N);*/
5238 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
5239
5240 while(!feof(fd) )
5241 {
5242 pdest = NULL;
5243 if(!fgets(t,taille,fd)) break;
5244 pdest = strstr( t, "TOTAL MULLIKEN AND LOWDIN ATOMIC POPULATIONS");
5245
5246 if(pdest)
5247 {
5248 if(!fgets(t,taille,fd)) break;
5249 for(i=0;i<N;i++)
5250 {
5251 if(!fgets(t,taille,fd)) break;
5252 if(sscanf(t,"%s %s %s %s %s %s",dump, dump ,dump, dump, dump, d)==6)
5253 {
5254 g_free(GeomXYZ[i].Charge);
5255 GeomXYZ[i].Charge = g_strdup(d);
5256 }
5257 else break;
5258 }
5259 break;
5260 }
5261 }
5262 }
5263 /********************************************************************************/
get_npa_charges_from_turbomole_output_file(FILE * fd,gint N)5264 gboolean get_npa_charges_from_turbomole_output_file(FILE* fd,gint N)
5265 {
5266 guint taille=BSIZE;
5267 gchar t[BSIZE];
5268 gchar dump[BSIZE];
5269 gchar d[BSIZE];
5270 gchar* pdest;
5271 gint i;
5272
5273
5274 /* printf("NAtoms = %d\n",N);*/
5275
5276 while(!feof(fd) )
5277 {
5278 pdest = NULL;
5279 if(!fgets(t,taille,fd)) break;
5280 pdest = strstr( t, "Summary of Natural Population Analysis:");
5281
5282 if(pdest)
5283 {
5284 while(!feof(fd) )
5285 {
5286 if(!fgets(t,taille,fd)) break;
5287 if(strstr(t,"Atom") && strstr(t,"Charge") && strstr(t,"Core")) break;
5288 }
5289 if(!(strstr(t,"Atom") && strstr(t,"Charge") && strstr(t,"Core"))) return FALSE;
5290 if(!fgets(t,taille,fd)) break;
5291 for(i=0;i<N;i++)
5292 {
5293 if(!fgets(t,taille,fd)) break;
5294 if(sscanf(t,"%s %s %s",dump, dump, d)==3)
5295 {
5296 g_free(GeomXYZ[i].Charge);
5297 GeomXYZ[i].Charge = g_strdup(d);
5298 }
5299 else return FALSE;
5300 }
5301 return TRUE;
5302 }
5303 }
5304 return FALSE;
5305 }
5306 /********************************************************************************/
get_fit_charges_from_turbomole_output_file(FILE * fd,gint N)5307 gboolean get_fit_charges_from_turbomole_output_file(FILE* fd,gint N)
5308 {
5309 guint taille=BSIZE;
5310 gchar t[BSIZE];
5311 gchar dump[BSIZE];
5312 gchar d[BSIZE];
5313 gchar* pdest;
5314 gint i;
5315
5316
5317 /* printf("NAtoms = %d\n",N);*/
5318
5319 while(!feof(fd) )
5320 {
5321 pdest = NULL;
5322 if(!fgets(t,taille,fd)) break;
5323 pdest = strstr( t, "charges resulting from fit:");
5324
5325 if(pdest)
5326 {
5327 while(!feof(fd) )
5328 {
5329 if(!fgets(t,taille,fd)) break;
5330 if(strstr(t,"atom") && strstr(t,"radius/au") && strstr(t,"charge")) break;
5331 }
5332 if(!(strstr(t,"atom") && strstr(t,"radius/au") && strstr(t,"charge"))) return FALSE;
5333 if(!fgets(t,taille,fd)) break;
5334 for(i=0;i<N;i++)
5335 {
5336 if(!fgets(t,taille,fd)) break;
5337 if(sscanf(t,"%s %s %s %s",dump, dump, dump, d)==4)
5338 {
5339 g_free(GeomXYZ[i].Charge);
5340 GeomXYZ[i].Charge = g_strdup(d);
5341 }
5342 else return FALSE;
5343 }
5344 return TRUE;
5345 }
5346 }
5347 return FALSE;
5348 }
5349 /********************************************************************************/
get_charges_from_turbomole_output_file(FILE * fd,gint N)5350 void get_charges_from_turbomole_output_file(FILE* fd,gint N)
5351 {
5352 gint i;
5353 long long int pos = ftell(fd);
5354 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
5355 if(get_fit_charges_from_turbomole_output_file(fd,N)) return;
5356 fseek(fd, pos, SEEK_SET);
5357 if(get_npa_charges_from_turbomole_output_file(fd,N)) return;
5358
5359 }
5360 /********************************************************************************/
get_charges_from_gaussian_output_file(FILE * fd,gint N)5361 void get_charges_from_gaussian_output_file(FILE* fd,gint N)
5362 {
5363 guint taille=BSIZE;
5364 gchar t[BSIZE];
5365 gchar dump[BSIZE];
5366 gchar d[BSIZE];
5367 gchar* pdest;
5368 gint i;
5369 gint ngrad=0;
5370
5371
5372 /* fprintf(stderr,"I try to read charges from gaussian output file\n");*/
5373 for(i=0;i<N;i++)
5374 GeomXYZ[i].Charge = g_strdup("0.0");
5375
5376 while(!feof(fd) )
5377 {
5378 pdest = NULL;
5379 { char* e = fgets(t,taille,fd);}
5380 pdest = strstr( t, "Total atomic charges");
5381 if(!pdest) /* Gaussian 03 */
5382 pdest = strstr( t, "atomic charges");
5383 if(!pdest) /* Gaussian 09D */
5384 pdest = strstr( t, "Mulliken charges and spin densities:");
5385 if(!pdest) /* Gaussian 09D */
5386 pdest = strstr( t, "Mulliken charges:");
5387
5388 if(pdest)
5389 {
5390 if(!feof(fd))
5391 { char* e = fgets(t,taille,fd);}
5392 else
5393 break;
5394
5395 for(i=0;i<N;i++)
5396 {
5397 if(!feof(fd))
5398 { char* e = fgets(t,taille,fd);}
5399 else
5400 break;
5401 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
5402 {
5403 g_free(GeomXYZ[i].Charge);
5404 GeomXYZ[i].Charge = g_strdup(d);
5405 }
5406 }
5407 break;
5408 }
5409 else
5410 {
5411 pdest = strstr( t, "GradGradGrad" );
5412 if(pdest)
5413 {
5414 ngrad++;
5415 }
5416 if(ngrad>2)
5417 break;
5418 }
5419
5420 }
5421 }
5422 /********************************************************************************/
get_natural_charges_from_gaussian_output_file(FILE * fd,gint N)5423 void get_natural_charges_from_gaussian_output_file(FILE* fd,gint N)
5424 {
5425 guint taille=BSIZE;
5426 gchar t[BSIZE];
5427 gchar dump[BSIZE];
5428 gchar d[BSIZE];
5429 gchar* pdest;
5430 gint i;
5431 gint ngrad =0;
5432
5433
5434
5435 while(!feof(fd) )
5436 {
5437 pdest = NULL;
5438 { char* e = fgets(t,taille,fd);}
5439 pdest = strstr( t, "Summary of Natural Population Analysis:");
5440 if(!pdest) /* Gaussian 03 */
5441 pdest = strstr( t, "Summary of Natural Population Analysis:");
5442
5443 if(pdest)
5444 {
5445 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5446 else break;
5447 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5448 else break;
5449 if(!strstr(t,"Natural Population"))break;
5450 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5451 else break;
5452 if(!strstr(t,"Natural"))break;
5453 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5454 else break;
5455 if(!strstr(t,"Charge"))break;
5456 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5457 else break;
5458 if(!strstr(t,"-------------"))break;
5459
5460 for(i=0;i<N;i++)
5461 {
5462 if(GeomXYZ[i].Charge) g_free(GeomXYZ[i].Charge);
5463 GeomXYZ[i].Charge = g_strdup("0.0");
5464 }
5465
5466 for(i=0;i<N;i++)
5467 {
5468 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5469 else break;
5470 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
5471 {
5472 g_free(GeomXYZ[i].Charge);
5473 GeomXYZ[i].Charge = g_strdup(d);
5474 }
5475 }
5476 break;
5477 }
5478 else
5479 {
5480 pdest = strstr( t, "GradGradGrad" );
5481 if(pdest)
5482 {
5483 ngrad++;
5484 }
5485 if(ngrad>2)
5486 break;
5487 }
5488
5489 }
5490 }
5491 /********************************************************************************/
get_esp_charges_from_gaussian_output_file(FILE * fd,gint N)5492 void get_esp_charges_from_gaussian_output_file(FILE* fd,gint N)
5493 {
5494 guint taille=BSIZE;
5495 gchar t[BSIZE];
5496 gchar dump[BSIZE];
5497 gchar d[BSIZE];
5498 gchar* pdest;
5499 gint i;
5500 gint ngrad=0;
5501
5502
5503 while(!feof(fd) )
5504 {
5505 pdest = NULL;
5506 { char* e = fgets(t,taille,fd);}
5507 pdest = strstr( t, "Charges from ESP fit");
5508 if(!pdest) /* Gaussian 03 */
5509 pdest = strstr( t, "harges from ESP");
5510
5511 if(pdest)
5512 {
5513 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5514 else break;
5515 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5516 else break;
5517
5518 for(i=0;i<N;i++)
5519 {
5520 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
5521 else break;
5522 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
5523 {
5524 g_free(GeomXYZ[i].Charge);
5525 GeomXYZ[i].Charge = g_strdup(d);
5526 }
5527 }
5528 break;
5529 }
5530 else
5531 {
5532 pdest = strstr( t, "GradGradGrad" );
5533 if(pdest)
5534 {
5535 ngrad++;
5536 }
5537 if(ngrad>2)
5538 break;
5539 }
5540
5541 }
5542 }
5543 /********************************************************************************/
read_molden_gabedit_geom_conv_file(gchar * fileName,gint geometryNumber,GabEditTypeFile type)5544 static void read_molden_gabedit_geom_conv_file(gchar* fileName, gint geometryNumber, GabEditTypeFile type)
5545 {
5546 gchar t[BSIZE];
5547 gchar AtomCoord[5][BSIZE];
5548 FILE *fd;
5549 guint taille=BSIZE;
5550 gint i;
5551 gint l;
5552 gint numgeom;
5553 gchar *pdest;
5554 gint nn;
5555
5556 fd = FOpen(fileName, "rb");
5557 if(fd ==NULL)
5558 {
5559 sprintf(t,"Sorry\nI can not open %s file ",fileName);
5560 MessageGeom(t," Error ",TRUE);
5561 return;
5562 }
5563 numgeom =0;
5564 while(!feof(fd))
5565 {
5566 if(!fgets(t,taille,fd))break;
5567 pdest = strstr( t, "[GEOMETRIES]");
5568 if(pdest && strstr(t,"ZMAT"))
5569 {
5570 if(type == GABEDIT_TYPEFILE_MOLDEN)
5571 sprintf(t,_("Sorry\nMolden file with ZMAT coordinate is not supported by Gabedit"));
5572 if(type == GABEDIT_TYPEFILE_GABEDIT)
5573 sprintf(t,_("Sorry\nGabedit file with ZMAT coordinate is not supported by Gabedit"));
5574
5575 MessageGeom(t,_("Error"),TRUE);
5576 return;
5577 }
5578 if (pdest)
5579 {
5580 while(!feof(fd))
5581 {
5582 if(!fgets(t,taille,fd))break;
5583
5584 str_delete_n(t);
5585 delete_last_spaces(t);
5586 delete_first_spaces(t);
5587 if(!isInteger(t))break;
5588 numgeom++;
5589 if(numgeom == geometryNumber)
5590 {
5591 nn = atoi(t);
5592 if(nn<1)break;
5593 GeomXYZ=g_malloc(nn*sizeof(GeomXYZAtomDef));
5594 for(i=0; i<nn; i++) GeomXYZ[i].typeConnections = NULL;
5595 if(!fgets(t,taille,fd))break;
5596 for(i=0; i<nn; i++)
5597 {
5598 if(!fgets(t,taille,fd))break;
5599 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
5600 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
5601 l=strlen(AtomCoord[0]);
5602 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
5603
5604 GeomXYZ[i].Nentry=NUMBER_LIST_XYZ;
5605 GeomXYZ[i].Symb=g_strdup(AtomCoord[0]);
5606 GeomXYZ[i].mmType=g_strdup(GeomXYZ[i].Symb);
5607 GeomXYZ[i].pdbType=g_strdup(GeomXYZ[i].Symb);
5608 GeomXYZ[i].Residue=g_strdup(GeomXYZ[i].Symb);
5609 GeomXYZ[i].ResidueNumber=0;
5610 if(Units == 0 )
5611 {
5612 GeomXYZ[i].X=g_strdup(ang_to_bohr(AtomCoord[1]));
5613 GeomXYZ[i].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
5614 GeomXYZ[i].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
5615 }
5616 else
5617 {
5618 GeomXYZ[i].X=g_strdup(AtomCoord[1]);
5619 GeomXYZ[i].Y=g_strdup(AtomCoord[2]);
5620 GeomXYZ[i].Z=g_strdup(AtomCoord[3]);
5621 }
5622 GeomXYZ[i].Charge=g_strdup("0.0");
5623 GeomXYZ[i].Layer=g_strdup(" ");
5624 }
5625 NcentersXYZ = nn;
5626 break;
5627 }
5628 else
5629 {
5630 nn = atoi(t);
5631 if(!fgets(t,taille,fd)) break;
5632 for(i=0; i<nn; i++)
5633 if(!fgets(t,taille,fd))break;
5634 }
5635 }
5636 }
5637 }
5638
5639 fclose(fd);
5640 calculMMTypes(FALSE);
5641 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
5642 {
5643 clearList(list);
5644 append_list();
5645 }
5646 MethodeGeom = GEOM_IS_XYZ;
5647 if(GeomDrawingArea != NULL)
5648 rafresh_drawing();
5649 if(iprogram == PROG_IS_GAUSS && GeomIsOpen)
5650 set_spin_of_electrons();
5651 }
5652 /********************************************************************************/
get_connections_one_atom_gabedit(gchar * t,gint nAtoms,gint ibeg,gint * connections)5653 gint get_connections_one_atom_gabedit(gchar* t, gint nAtoms, gint ibeg, gint* connections)
5654 {
5655 gint k;
5656 gint nc;
5657 gint nj;
5658 gchar** split = NULL;
5659 gint nA = 0;
5660 /* gint ibeg = 12;*/
5661 for(k=0;k<nAtoms;k++) connections[k] = 0;
5662 split = gab_split(t);
5663 nA = 0;
5664 while(split && split[nA]!=NULL) nA++;
5665 if(nA<ibeg)
5666 {
5667 g_strfreev(split);
5668 return 0;
5669 }
5670 nc = atoi(split[ibeg-1]);
5671 for(k=0;k<2*nc;k+=2)
5672 {
5673 if(!split[ibeg+k]) break;
5674 if(!split[ibeg+k+1]) break;
5675 nj = atoi(split[ibeg+k]);
5676 connections[nj-1] = atoi(split[ibeg+k+1]);
5677 }
5678
5679 g_strfreev(split);
5680
5681 return 1;
5682 }
5683 /********************************************************************************/
read_gabedit_geoms_file(gchar * fileName,gint geometryNumber)5684 static gint read_gabedit_geoms_file(gchar* fileName, gint geometryNumber)
5685 {
5686 #define SZ 50
5687 gboolean OK;
5688 gchar t[BSIZE];
5689 gchar symbol[SZ];
5690 gchar mmType[SZ];
5691 gchar pdbType[SZ];
5692 gchar residueName[SZ];
5693 gchar dum[SZ];
5694 gdouble X,Y,Z;
5695 gdouble charge;
5696 gint layer;
5697 FILE *fd;
5698 guint taille=BSIZE;
5699 gint i;
5700 gint j;
5701 gint k;
5702 gchar *pdest = NULL;
5703 gint nGeometries = 0;
5704 gint nLabels = 0;
5705 gint nAtoms=0;
5706 gint l;
5707 gint nc = 0;
5708 gint Nvar = 0;
5709 gint form = 1;
5710
5711 fd = FOpen(fileName, "rb");
5712 if(fd == NULL)
5713 {
5714 sprintf(t,_("Sorry\nI can not open %s file "),fileName);
5715 MessageGeom(t,_("Error"),TRUE);
5716 return 1;
5717 }
5718 OK=FALSE;
5719 Nvar = 0;
5720 while(!feof(fd))
5721 {
5722 if(!fgets(t,taille,fd))break;
5723 pdest = strstr( t, "[GEOMS]");
5724 if (pdest)
5725 {
5726 if(sscanf(t,"%s %d",dum,&form)!=2) form = 0;
5727 if(!fgets(t,taille,fd))break;
5728 sscanf(t,"%d %d",&nGeometries, &nLabels);
5729 if(nGeometries<geometryNumber)break;
5730 for(i=0;i<nLabels;i++)
5731 if(!fgets(t,taille,fd))break;
5732 if(i!=nLabels) break;
5733 for(j=0;j<geometryNumber-1;j++)
5734 {
5735 for(i=0;i<nLabels;i++) if(!fgets(t,taille,fd))break;
5736 if(i!=nLabels) break;
5737 if(!fgets(t,taille,fd))break;
5738 sscanf(t,"%d",&nAtoms);
5739 if(nAtoms<1)break;
5740 for(i=0; i<nAtoms; i++)
5741 if(!fgets(t,taille,fd))break;
5742 if(i!=nAtoms) break;
5743 }
5744 if(j!=geometryNumber-1) break;
5745 for(i=0;i<nLabels;i++) if(!fgets(t,taille,fd))break;
5746 if(i!=nLabels) break;
5747 if(!fgets(t,taille,fd))break;
5748 sscanf(t,"%d %d %d",&nAtoms, &TotalCharges[0], &SpinMultiplicities[0]);
5749 if(nAtoms<1)break;
5750
5751 if(nAtoms>0)
5752 {
5753 GeomXYZ=g_malloc(nAtoms*sizeof(GeomXYZAtomDef));
5754 for(i=0; i<nAtoms; i++) GeomXYZ[i].typeConnections = g_malloc(nAtoms*sizeof(gint));
5755 }
5756 else GeomXYZ= NULL;
5757 for(i=0; i<nAtoms; i++)
5758 {
5759 GeomXYZ[i].Symb=NULL;
5760 GeomXYZ[i].mmType=NULL;
5761 GeomXYZ[i].pdbType=NULL;
5762 GeomXYZ[i].Residue=NULL;
5763 GeomXYZ[i].Charge=NULL;
5764 GeomXYZ[i].Layer=NULL;
5765 }
5766 nc = 0;
5767 for(i=0; i<nAtoms; i++)
5768 {
5769 int variable = 0;
5770 gint ibeg = 12;
5771 if(!fgets(t,taille,fd))break;
5772 if(form==0)
5773 {
5774 k = sscanf(t,"%s %s %s %s %d %lf %d %lf %lf %lf",
5775 symbol,mmType,pdbType,residueName,
5776 &GeomXYZ[i].ResidueNumber,
5777 &charge,&layer,&X,&Y,&Z);
5778 k++;
5779 variable = TRUE;
5780 ibeg = 11;
5781 }
5782 else
5783 k = sscanf(t,"%s %s %s %s %d %lf %d %d %lf %lf %lf",
5784 symbol,mmType,pdbType,residueName,
5785 &GeomXYZ[i].ResidueNumber,
5786 &charge,&layer,&variable,&X,&Y,&Z);
5787 if(k!=11)
5788 {
5789 for(j=0; j<i; j++)
5790 {
5791 if(GeomXYZ[i].Symb) g_free(GeomXYZ[i].Symb);
5792 if(GeomXYZ[i].mmType) g_free(GeomXYZ[i].mmType);
5793 if(GeomXYZ[i].pdbType) g_free(GeomXYZ[i].pdbType);
5794 if(GeomXYZ[i].Residue) g_free(GeomXYZ[i].Residue);
5795 if(GeomXYZ[i].Charge) g_free(GeomXYZ[i].Charge);
5796 if(GeomXYZ[i].Layer) g_free(GeomXYZ[i].Layer);
5797 }
5798 for(i=0; i<nAtoms; i++) if(GeomXYZ[i].typeConnections)g_free(GeomXYZ[i].typeConnections);
5799 if(GeomXYZ) g_free(GeomXYZ);
5800 if(VariablesXYZ) g_free(VariablesXYZ);
5801 NcentersXYZ = 0;
5802 NVariablesXYZ = 0;
5803 fclose(fd);
5804 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ) clearList(list);
5805 return -1;
5806 }
5807 symbol[0]=toupper(symbol[0]);
5808 l=strlen(symbol);
5809 if (l==2) symbol[1]=tolower(symbol[1]);
5810
5811 GeomXYZ[i].Nentry=NUMBER_LIST_XYZ;
5812 GeomXYZ[i].Symb=g_strdup(symbol);
5813 GeomXYZ[i].mmType=g_strdup(mmType);
5814 GeomXYZ[i].pdbType=g_strdup(pdbType);
5815 GeomXYZ[i].Residue=g_strdup(residueName);
5816 if(Units == 0 )
5817 {
5818 GeomXYZ[i].X=g_strdup_printf("%f",ANG_TO_BOHR*X);
5819 GeomXYZ[i].Y=g_strdup_printf("%f",ANG_TO_BOHR*Y);
5820 GeomXYZ[i].Z=g_strdup_printf("%f",ANG_TO_BOHR*Z);
5821 }
5822 else
5823 {
5824 GeomXYZ[i].X=g_strdup_printf("%f",X);
5825 GeomXYZ[i].Y=g_strdup_printf("%f",Y);
5826 GeomXYZ[i].Z=g_strdup_printf("%f",Z);
5827 }
5828 if(variable!=0)
5829 {
5830 Nvar +=3;
5831 if(Nvar==3) VariablesXYZ = g_malloc(Nvar*sizeof(VariablesXYZDef));
5832 else VariablesXYZ = g_realloc(VariablesXYZ, Nvar*sizeof(VariablesXYZDef));
5833 trans_coordXYZ_geom('X', GeomXYZ, i, VariablesXYZ, Nvar-3);
5834 trans_coordXYZ_geom('Y', GeomXYZ, i, VariablesXYZ, Nvar-2);
5835 trans_coordXYZ_geom('Z', GeomXYZ, i, VariablesXYZ, Nvar-1);
5836 }
5837 GeomXYZ[i].Charge=g_strdup_printf("%f",charge);
5838 if(layer==0) GeomXYZ[i].Layer=g_strdup("Low");
5839 if(layer==1) GeomXYZ[i].Layer=g_strdup("Medium");
5840 if(layer==2) GeomXYZ[i].Layer=g_strdup(" ");
5841 nc += get_connections_one_atom_gabedit(t, nAtoms, ibeg, GeomXYZ[i].typeConnections);
5842 }
5843 NVariablesXYZ =Nvar;
5844 NcentersXYZ = nAtoms;
5845 OK = TRUE;
5846 break;
5847 }
5848 }
5849
5850 fclose(fd);
5851 /* printf("nAtoms = %d\n",nAtoms);*/
5852 if(!OK)
5853 {
5854 if(GeomXYZ)
5855 for(i=0; i<nAtoms; i++) if(GeomXYZ[i].typeConnections)g_free(GeomXYZ[i].typeConnections);
5856 return 3;
5857 }
5858 if(nc<1 && GeomXYZ)
5859 for(i=0; i<nAtoms; i++)
5860 {
5861 if(GeomXYZ[i].typeConnections)g_free(GeomXYZ[i].typeConnections);
5862 GeomXYZ[i].typeConnections = NULL;
5863 }
5864 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
5865 {
5866 clearList(list);
5867 append_list();
5868 }
5869 MethodeGeom = GEOM_IS_XYZ;
5870 if(GeomDrawingArea != NULL)
5871 {
5872 rafresh_drawing();
5873 }
5874 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
5875 return 0;
5876 #undef SZ
5877 }
5878 /********************************************************************************/
read_geom_from_molden_geom_conv_file(gchar * fileName,gint geometryNumber)5879 void read_geom_from_molden_geom_conv_file(gchar *fileName, gint geometryNumber)
5880 {
5881 read_molden_gabedit_geom_conv_file(fileName, geometryNumber, GABEDIT_TYPEFILE_MOLDEN);
5882
5883 }
5884 /********************************************************************************/
read_geom_from_gabedit_geom_conv_file(gchar * fileName,gint geometryNumber)5885 void read_geom_from_gabedit_geom_conv_file(gchar *fileName, gint geometryNumber)
5886 {
5887 gint res = read_gabedit_geoms_file(fileName, geometryNumber);
5888 /* printf("geometryNumber=%d res = %d\n",geometryNumber, res);*/
5889 if(res == 1) return;
5890 if(res == 0) return;
5891 if(res == -1) return;
5892 read_molden_gabedit_geom_conv_file(fileName, geometryNumber, GABEDIT_TYPEFILE_GABEDIT);
5893 }
5894 /********************************************************************************/
get_charges_from_mpqc_output_file(FILE * fd,gint N)5895 void get_charges_from_mpqc_output_file(FILE* fd,gint N)
5896 {
5897 guint taille=BSIZE;
5898 gchar t[BSIZE];
5899 gchar dump[BSIZE];
5900 gchar d[BSIZE];
5901 gint i;
5902 gboolean OK = FALSE;
5903
5904
5905 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
5906
5907 fseek(fd, 0L, SEEK_SET);
5908 OK = FALSE;
5909 while(!feof(fd) )
5910 {
5911 if(!fgets(t,taille,fd))break;
5912 if(strstr(t, "Natural Population Analysis"))
5913 {
5914 OK = TRUE;
5915 break;
5916 }
5917 }
5918 if(!OK) return;
5919
5920 OK = FALSE;
5921 while(!feof(fd) )
5922 {
5923 if(!fgets(t,taille,fd))break;
5924 if(strstr(t, "atom") && strstr(t, "charge"))
5925 {
5926 OK = TRUE;
5927 break;
5928 }
5929 }
5930 if(!OK) return;
5931 for(i=0;i<N && !feof(fd) ;i++)
5932 {
5933 if(!fgets(t,taille,fd)) break;
5934 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
5935 {
5936 g_free(GeomXYZ[i].Charge);
5937 GeomXYZ[i].Charge = g_strdup(d);
5938 }
5939 }
5940 if(i==N) return;
5941 for(i=0;i<N;i++)
5942 {
5943 g_free(GeomXYZ[i].Charge);
5944 GeomXYZ[i].Charge = g_strdup("0.0");
5945 }
5946
5947 return;
5948 }
5949 /********************************************************************************/
read_geom_from_mpqc_output_file(gchar * fileName,gint numGeometry)5950 void read_geom_from_mpqc_output_file(gchar *fileName, gint numGeometry)
5951 {
5952 gchar *t;
5953 gboolean OK;
5954 gchar *AtomCoord[5];
5955 FILE *fd;
5956 guint taille=BSIZE;
5957 guint idummy;
5958 guint i;
5959 gint j=0;
5960 gint l;
5961 guint numGeom;
5962 gdouble tmp;
5963
5964
5965 t=g_malloc(taille);
5966 fd = FOpen(fileName, "rb");
5967 if(fd ==NULL)
5968 {
5969 g_free(t);
5970 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
5971 MessageGeom(t,_("Error"),TRUE);
5972 g_free(t);
5973 return;
5974 }
5975 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
5976
5977 numGeom = 0;
5978 do
5979 {
5980 gboolean unitOfOutAng = FALSE;
5981 OK=FALSE;
5982 while(!feof(fd))
5983 {
5984 if(!fgets(t,taille,fd)) break;
5985 if (strstr(t,"<Molecule>"))
5986 {
5987 gboolean OkUnit = FALSE;
5988 do{
5989 if(!fgets(t,taille,fd))break;
5990 if(strstr(t,"unit"))
5991 {
5992 OkUnit = TRUE;
5993 if(strstr(t,"angstrom"))unitOfOutAng=TRUE;
5994 break;
5995 };
5996
5997 }while(!feof(fd));
5998 if(!OkUnit) break;
5999 numGeom++;
6000 if((gint)numGeom == numGeometry )
6001 {
6002 OK = TRUE;
6003 break;
6004 }
6005 if(numGeometry<0 )
6006 {
6007 OK = TRUE;
6008 break;
6009 }
6010 }
6011 }
6012 if(!OK && (numGeom == 0) )
6013 {
6014 g_free(t);
6015 t = g_strdup_printf(_("Sorry\nI can read Geometry from %s file "),fileName);
6016 MessageGeom(t,_("Error"),TRUE);
6017 g_free(t);
6018 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6019 return;
6020 }
6021 if(!OK) break;
6022 OK = FALSE;
6023 while(!feof(fd) )
6024 {
6025 if(!fgets(t,taille,fd))break;
6026 if ( !(strstr(t,"atoms") && strstr(t,"geometry"))) continue;
6027 OK = TRUE;
6028 break;
6029 }
6030 if(!OK)
6031 {
6032 g_free(t);
6033 t = g_strdup_printf(_("Sorry\nI can read Geometry from %s file "),fileName);
6034 MessageGeom(t,_("Error"),TRUE);
6035 g_free(t);
6036 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6037 return;
6038 }
6039
6040 j=-1;
6041 while(!feof(fd) )
6042 {
6043 if(!fgets(t,taille,fd))break;
6044 if(strstr(t,"}"))break;
6045 j++;
6046
6047 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6048 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6049 GeomXYZ[j].typeConnections = NULL;
6050
6051 for(i=0;i<strlen(t);i++) if(t[i]=='[' || t[i] ==']') t[i]=' ';
6052 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
6053 for(i=1;i<=3;i++)
6054 {
6055 tmp = atof(AtomCoord[i]);
6056 sprintf(AtomCoord[i],"%f",tmp);
6057 }
6058
6059 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6060
6061 l=strlen(AtomCoord[0]);
6062
6063 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6064
6065 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6066 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
6067 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6068 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6069 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6070 GeomXYZ[j].ResidueNumber=0;
6071
6072 if(!unitOfOutAng)
6073 {
6074 if(Units == 1)
6075 {
6076 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6077 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6078 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6079 }
6080 else
6081 {
6082 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6083 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6084 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6085 }
6086 }
6087 else
6088 {
6089 if(Units != 1)
6090 {
6091 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6092 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6093 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6094 }
6095 else
6096 {
6097 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6098 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6099 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6100 }
6101 }
6102
6103 GeomXYZ[j].Charge=g_strdup("0.0");
6104 GeomXYZ[j].Layer=g_strdup(" ");
6105 }
6106
6107 NcentersXYZ = j+1;
6108 if(numGeometry<0) continue;
6109 if(OK) break;
6110 }while(!feof(fd));
6111
6112
6113 if(numGeometry<0) get_charges_from_mpqc_output_file(fd,NcentersXYZ);
6114
6115 fclose(fd);
6116 calculMMTypes(FALSE);
6117 g_free(t);
6118 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6119
6120 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6121 {
6122 clearList(list);
6123 append_list();
6124 }
6125 MethodeGeom = GEOM_IS_XYZ;
6126 if(GeomDrawingArea != NULL) rafresh_drawing();
6127 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6128 }
6129 /********************************************************************************/
read_first_mpqc_file(GabeditFileChooser * SelecFile,gint response_id)6130 void read_first_mpqc_file(GabeditFileChooser *SelecFile, gint response_id)
6131 {
6132 gchar *fileName;
6133
6134 if(response_id != GTK_RESPONSE_OK) return;
6135 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6136
6137 if ((!fileName) || (strcmp(fileName,"") == 0))
6138 {
6139 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6140 return ;
6141 }
6142 read_geom_from_mpqc_output_file(fileName,1);
6143 }
6144 /********************************************************************************/
read_last_mpqc_file(GabeditFileChooser * SelecFile,gint response_id)6145 void read_last_mpqc_file(GabeditFileChooser *SelecFile, gint response_id)
6146 {
6147 gchar *fileName;
6148
6149 if(response_id != GTK_RESPONSE_OK) return;
6150 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6151
6152 if ((!fileName) || (strcmp(fileName,"") == 0))
6153 {
6154 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6155 return ;
6156 }
6157 read_geom_from_mpqc_output_file(fileName,-1);
6158 }
6159 /********************************************************************************/
read_geom_from_wfx_file(gchar * fileName)6160 void read_geom_from_wfx_file(gchar *fileName)
6161 {
6162 gint k;
6163 gint j;
6164 gchar t[BSIZE];
6165 gchar* C[3] ={ NULL, NULL,NULL};
6166 gchar** symbols = NULL;
6167 gdouble* coordinates = NULL;
6168 gint nSymbols,nCoordinates;
6169 FILE* file = FOpen(fileName, "rb");
6170 if(file ==NULL)
6171 {
6172 sprintf(t,"Sorry\nI can not open %s file ",fileName);
6173 MessageGeom(t," Error ",TRUE);
6174 return;
6175 }
6176 symbols = get_one_block_from_wfx_file(file,"Nuclear Name",&nSymbols);
6177 //fprintf(stderr,"nSymb = %d\n",nSymbols);
6178 if(!symbols || nSymbols<1)
6179 {
6180 sprintf(t,"Sorry\nI cannot read symbol from %s file ",fileName);
6181 MessageGeom(t," Error ",TRUE);
6182 fclose(file);
6183 if(symbols) free_one_string_table(symbols, nSymbols);
6184 return;
6185 }
6186 rewind(file);
6187 coordinates = get_one_block_real_from_wfx_file(file,"Nuclear Cartesian Coordinates",&nCoordinates);
6188 //fprintf(stderr,"nC = %d\n",nCoordinates);
6189 if(!coordinates || nCoordinates<3)
6190 {
6191 sprintf(t,"Sorry\nI cannot read coordinates from %s file ",fileName);
6192 MessageGeom(t," Error ",TRUE);
6193 fclose(file);
6194 if(symbols) free_one_string_table(symbols, nSymbols);
6195 if(coordinates) g_free(coordinates);
6196 return;
6197 }
6198 if(nCoordinates!=3*nSymbols)
6199 {
6200 sprintf(t,"Sorry\nI cannot read geomtry from %s file",fileName);
6201 MessageGeom(t," Error ",TRUE);
6202 fclose(file);
6203 if(symbols) free_one_string_table(symbols, nSymbols);
6204 if(coordinates) g_free(coordinates);
6205 return;
6206 }
6207 if(GeomXYZ==NULL) GeomXYZ=g_malloc(nSymbols*sizeof(GeomXYZAtomDef));
6208 else GeomXYZ=g_realloc(GeomXYZ,nSymbols*sizeof(GeomXYZAtomDef));
6209 for(k=0;k<3;k++) C[k] = g_malloc(BSIZE*sizeof(gchar));
6210 for(j=0;j<nSymbols;j++)
6211 {
6212 gint l;
6213 GeomXYZ[j].typeConnections = NULL;
6214 for(k=0;k<3;k++) sprintf(C[k],"%0.10e",coordinates[3*j+k]);
6215 //fprintf(stderr,"%s %s %s\n", C[0], C[1], C[2]);
6216
6217 for(k=0;k<(gint)strlen(symbols[j]);k++) if(isdigit(symbols[j][k])) symbols[j][k] = ' ';
6218 delete_all_spaces(symbols[j]);
6219
6220 symbols[j][0]=toupper(symbols[j][0]);
6221 l=strlen(symbols[j]);
6222 if (l==2) symbols[j][1]=tolower(symbols[j][1]);
6223 if(l==1)sprintf(t,"%c",symbols[j][0]);
6224 else sprintf(t,"%c%c",symbols[j][0],symbols[j][1]);
6225 //fprintf(stderr,"t=%s\n", t);
6226
6227 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6228 GeomXYZ[j].Symb=g_strdup(t);
6229 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
6230 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
6231 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
6232 GeomXYZ[j].ResidueNumber=0;
6233 if(Units == 0 )
6234 {
6235 GeomXYZ[j].X=g_strdup(C[0]);
6236 GeomXYZ[j].Y=g_strdup(C[1]);
6237 GeomXYZ[j].Z=g_strdup(C[2]);
6238 }
6239 else
6240 {
6241 GeomXYZ[j].X=g_strdup(bohr_to_ang(C[0]));
6242 GeomXYZ[j].Y=g_strdup(bohr_to_ang(C[1]));
6243 GeomXYZ[j].Z=g_strdup(bohr_to_ang(C[2]));
6244 }
6245 GeomXYZ[j].Charge=g_strdup("0.0");
6246 GeomXYZ[j].Layer=g_strdup(" ");
6247 //fprintf(stderr,"%s %s %s %s\n", GeomXYZ[j].Symb, GeomXYZ[j].X, GeomXYZ[j].Y, GeomXYZ[j].Z);
6248 }
6249 NcentersXYZ = nSymbols;
6250 for(k=0;k<3;k++) if(C[k]) g_free(C[k]);
6251 fclose(file);
6252 if(symbols) free_one_string_table(symbols, nSymbols);
6253 if(coordinates) g_free(coordinates);
6254 calculMMTypes(FALSE);
6255 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6256 {
6257 clearList(list);
6258 append_list();
6259 }
6260 MethodeGeom = GEOM_IS_XYZ;
6261 if(GeomDrawingArea != NULL) rafresh_drawing();
6262 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6263 }
6264 /********************************************************************************/
read_wfx_file(GabeditFileChooser * SelecFile,gint response_id)6265 void read_wfx_file(GabeditFileChooser *SelecFile , gint response_id)
6266 {
6267 gchar *NomFichier;
6268
6269 if(response_id != GTK_RESPONSE_OK) return;
6270 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
6271
6272 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
6273 {
6274 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6275 return ;
6276 }
6277 read_geom_from_wfx_file(NomFichier);
6278 set_last_directory(NomFichier);
6279 }
6280 /********************************************************************************/
read_first_vasp_xml_file(GabeditFileChooser * SelecFile,gint response_id)6281 void read_first_vasp_xml_file(GabeditFileChooser *SelecFile, gint response_id)
6282 {
6283 gchar *fileName;
6284
6285 if(response_id != GTK_RESPONSE_OK) return;
6286 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6287
6288 if ((!fileName) || (strcmp(fileName,"") == 0))
6289 {
6290 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6291 return ;
6292 }
6293 read_geom_from_vasp_xml_file(fileName,1);
6294 }
6295 /********************************************************************************/
read_last_vasp_xml_file(GabeditFileChooser * SelecFile,gint response_id)6296 void read_last_vasp_xml_file(GabeditFileChooser *SelecFile, gint response_id)
6297 {
6298 gchar *fileName;
6299
6300 if(response_id != GTK_RESPONSE_OK) return;
6301 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6302
6303 if ((!fileName) || (strcmp(fileName,"") == 0))
6304 {
6305 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6306 return ;
6307 }
6308 read_geom_from_vasp_xml_file(fileName,-1);
6309 }
6310 /********************************************************************************/
read_geom_conv_from_dalton_output_file(gchar * NomFichier,gint numgeometry)6311 void read_geom_conv_from_dalton_output_file(gchar *NomFichier, gint numgeometry)
6312 {
6313 gchar *t;
6314 gboolean OK;
6315 gchar *AtomCoord[5];
6316 FILE *fd;
6317 guint taille=BSIZE;
6318 guint i;
6319 gint j=0;
6320 gint l;
6321 guint numgeom;
6322 gchar dum[100];
6323 gint kk;
6324
6325 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
6326
6327 t=g_malloc(taille);
6328 fd = FOpen(NomFichier, "rb");
6329 if(fd ==NULL)
6330 {
6331 g_free(t);
6332 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6333 MessageGeom(t,_("Error"),TRUE);
6334 g_free(t);
6335 return;
6336 }
6337 numgeom = 0;
6338 do
6339 {
6340 OK=FALSE;
6341 while(!feof(fd)){
6342 { char* e = fgets(t,taille,fd);}
6343 if(strstr(t,"Next geometry") || strstr(t,"Final geometry"))
6344 {
6345 { char* e = fgets(t,taille,fd);}
6346 { char* e = fgets(t,taille,fd);}
6347 numgeom++;
6348 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
6349 if(numgeometry<0 ) { OK = TRUE; break; }
6350 }
6351 }
6352 if(!OK && (numgeom == 0) ){
6353 g_free(t);
6354 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6355 MessageGeom(t,_("Error"),TRUE);
6356 g_free(t);
6357 return;
6358 }
6359 if(!OK)break;
6360
6361 j=-1;
6362 while(!feof(fd) )
6363 {
6364 { char* e = fgets(t,taille,fd);}
6365 if ( !strcmp(t,"\n"))
6366 {
6367 get_dipole_from_dalton_output_file(fd);
6368 break;
6369 }
6370 j++;
6371
6372 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6373 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6374 GeomXYZ[j].typeConnections = NULL;
6375
6376 kk = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
6377 if(kk==5) sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
6378 {
6379 gint k;
6380 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
6381 delete_all_spaces(AtomCoord[0]);
6382 }
6383
6384 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6385 l=strlen(AtomCoord[0]);
6386 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6387 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6388 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
6389 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6390 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6391 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6392 GeomXYZ[j].ResidueNumber=0;
6393 if(Units == 1 )
6394 {
6395 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6396 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6397 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6398 }
6399 else
6400 {
6401 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6402 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6403 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6404 }
6405 GeomXYZ[j].Charge=g_strdup("0.0");
6406 GeomXYZ[j].Layer=g_strdup(" ");
6407 }
6408
6409 NcentersXYZ = j+1;
6410 if(OK && numgeometry>=0) break;
6411 }while(!feof(fd));
6412
6413 fclose(fd);
6414 calculMMTypes(FALSE);
6415 g_free(t);
6416 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6417 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6418 {
6419 clearList(list);
6420 append_list();
6421 }
6422 MethodeGeom = GEOM_IS_XYZ;
6423 if(GeomDrawingArea != NULL) rafresh_drawing();
6424 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6425 }
6426 /********************************************************************************/
read_geom_from_dalton_output_file(gchar * NomFichier,gint numgeometry)6427 void read_geom_from_dalton_output_file(gchar *NomFichier, gint numgeometry)
6428 {
6429 gchar *t;
6430 gboolean OK;
6431 gchar *AtomCoord[5];
6432 FILE *fd;
6433 guint taille=BSIZE;
6434 guint i;
6435 gint j=0;
6436 gint l;
6437 guint numgeom;
6438 gchar dum[100];
6439 gint kk;
6440
6441 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
6442
6443 t=g_malloc(taille);
6444 fd = FOpen(NomFichier, "rb");
6445 if(fd ==NULL)
6446 {
6447 g_free(t);
6448 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6449 MessageGeom(t,_("Error"),TRUE);
6450 g_free(t);
6451 return;
6452 }
6453 numgeom = 0;
6454 do
6455 {
6456 OK=FALSE;
6457 while(!feof(fd)){
6458 { char* e = fgets(t,taille,fd);}
6459 if ( strstr(t,"geometry (au)"))
6460 {
6461 { char* e = fgets(t,taille,fd);}
6462 { char* e = fgets(t,taille,fd);}
6463 numgeom++;
6464 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
6465 if(numgeometry<0 ) { OK = TRUE; break; }
6466 }
6467 }
6468 if(!OK && (numgeom == 0) ){
6469 g_free(t);
6470 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6471 MessageGeom(t,_("Error"),TRUE);
6472 g_free(t);
6473 return;
6474 }
6475 if(!OK)break;
6476
6477 j=-1;
6478 while(!feof(fd) )
6479 {
6480 { char* e = fgets(t,taille,fd);}
6481 if ( !strcmp(t,"\n"))
6482 {
6483 get_dipole_from_dalton_output_file(fd);
6484 break;
6485 }
6486 j++;
6487
6488 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6489 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6490 GeomXYZ[j].typeConnections = NULL;
6491
6492 kk = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[1], AtomCoord[2],AtomCoord[3], dum);
6493 if(kk==5) sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
6494 {
6495 gint k;
6496 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
6497 delete_all_spaces(AtomCoord[0]);
6498 }
6499
6500 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6501 l=strlen(AtomCoord[0]);
6502 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6503 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6504 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
6505 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6506 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6507 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6508 GeomXYZ[j].ResidueNumber=0;
6509 if(Units == 1 )
6510 {
6511 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6512 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6513 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6514 }
6515 else
6516 {
6517 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6518 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6519 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6520 }
6521 GeomXYZ[j].Charge=g_strdup("0.0");
6522 GeomXYZ[j].Layer=g_strdup(" ");
6523 }
6524
6525 NcentersXYZ = j+1;
6526 if(OK && numgeometry>=0) break;
6527 }while(!feof(fd));
6528
6529 fclose(fd);
6530 calculMMTypes(FALSE);
6531 g_free(t);
6532 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6533 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6534 {
6535 clearList(list);
6536 append_list();
6537 }
6538 MethodeGeom = GEOM_IS_XYZ;
6539 if(GeomDrawingArea != NULL) rafresh_drawing();
6540 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6541 }
6542 /********************************************************************************/
read_first_dalton_file(GabeditFileChooser * SelecFile,gint response_id)6543 void read_first_dalton_file(GabeditFileChooser *SelecFile, gint response_id)
6544 {
6545 gchar *fileName;
6546
6547 if(response_id != GTK_RESPONSE_OK) return;
6548 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6549
6550 if ((!fileName) || (strcmp(fileName,"") == 0))
6551 {
6552 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6553 return ;
6554 }
6555 read_geom_from_dalton_output_file(fileName,1);
6556 }
6557 /********************************************************************************/
read_last_dalton_file(GabeditFileChooser * SelecFile,gint response_id)6558 void read_last_dalton_file(GabeditFileChooser *SelecFile, gint response_id)
6559 {
6560 gchar *fileName;
6561
6562 if(response_id != GTK_RESPONSE_OK) return;
6563 fileName = gabedit_file_chooser_get_current_file(SelecFile);
6564
6565 if ((!fileName) || (strcmp(fileName,"") == 0))
6566 {
6567 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
6568 return ;
6569 }
6570 read_geom_from_dalton_output_file(fileName,-1);
6571 }
6572 /********************************************************************************/
read_geom_conv_from_gamess_output_file(gchar * NomFichier,gint numgeometry)6573 void read_geom_conv_from_gamess_output_file(gchar *NomFichier, gint numgeometry)
6574 {
6575 gchar *t;
6576 gboolean OK;
6577 gchar *AtomCoord[5];
6578 FILE *fd;
6579 guint taille=BSIZE;
6580 guint i;
6581 gint j=0;
6582 gint l;
6583 guint numgeom;
6584 gchar dum[100];
6585 gint uni=1;
6586
6587 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
6588
6589 t=g_malloc(taille);
6590 fd = FOpen(NomFichier, "rb");
6591 if(fd ==NULL)
6592 {
6593 g_free(t);
6594 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6595 MessageGeom(t,_("Error"),TRUE);
6596 g_free(t);
6597 return;
6598 }
6599 numgeom = 0;
6600 do
6601 {
6602 OK=FALSE;
6603 while(!feof(fd)){
6604 { char* e = fgets(t,taille,fd);}
6605 if ( strstr(t,"COORDINATES OF ALL ATOMS ARE (ANGS)"))
6606 {
6607 { char* e = fgets(t,taille,fd);}
6608 { char* e = fgets(t,taille,fd);}
6609 numgeom++;
6610 uni=1;
6611 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
6612 if(numgeometry<0 ) { OK = TRUE; break; }
6613 }
6614 }
6615 if(!OK && (numgeom == 0) ){
6616 g_free(t);
6617 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6618 MessageGeom(t,_("Error"),TRUE);
6619 g_free(t);
6620 return;
6621 }
6622 if(!OK)break;
6623
6624 j=-1;
6625 while(!feof(fd) )
6626 {
6627 { char* e = fgets(t,taille,fd);}
6628 if ( !strcmp(t,"\n") || !strcmp(t,"\r\n"))
6629 {
6630 get_dipole_from_gamess_output_file(fd);
6631 break;
6632 }
6633 j++;
6634
6635 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6636 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6637 GeomXYZ[j].typeConnections = NULL;
6638
6639 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
6640 {
6641 gint k;
6642 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
6643 delete_all_spaces(AtomCoord[0]);
6644 }
6645
6646 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6647 l=strlen(AtomCoord[0]);
6648 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6649 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6650 /* GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);*/
6651 GeomXYZ[j].Symb=get_symbol_using_z(atoi(dum));
6652 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6653 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6654 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6655 GeomXYZ[j].ResidueNumber=0;
6656 if(Units != uni )
6657 {
6658 if(Units==1)
6659 {
6660 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6661 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6662 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6663 }
6664 else
6665 {
6666 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
6667 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
6668 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
6669 }
6670 }
6671 else
6672 {
6673 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6674 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6675 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6676 }
6677 GeomXYZ[j].Charge=g_strdup("0.0");
6678 GeomXYZ[j].Layer=g_strdup(" ");
6679 }
6680
6681 NcentersXYZ = j+1;
6682 if(OK && numgeometry>=0) break;
6683 }while(!feof(fd));
6684
6685 fclose(fd);
6686 calculMMTypes(FALSE);
6687 g_free(t);
6688 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6689 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6690 {
6691 clearList(list);
6692 append_list();
6693 }
6694 MethodeGeom = GEOM_IS_XYZ;
6695 if(GeomDrawingArea != NULL) rafresh_drawing();
6696 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6697 }
6698 /********************************************************************************/
get_charges_from_aimall_file(FILE * fd,gint N)6699 void get_charges_from_aimall_file(FILE* fd,gint N)
6700 {
6701 guint taille=BSIZE;
6702 gchar t[BSIZE];
6703 gchar dump[BSIZE];
6704 gchar d[BSIZE];
6705 gchar* pdest;
6706 gint i;
6707
6708
6709 /* printf("NAtoms = %d\n",N);*/
6710 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
6711
6712 while(!feof(fd) )
6713 {
6714 pdest = NULL;
6715 if(!fgets(t,taille,fd)) break;
6716 pdest = strstr( t, "Atom A q(A)");
6717 if(pdest)
6718 {
6719 if(!fgets(t,taille,fd)) break;
6720 for(i=0;i<N;i++)
6721 {
6722 if(!fgets(t,taille,fd)) break;
6723 if(sscanf(t,"%s %s",dump, d)==2)
6724 {
6725 g_free(GeomXYZ[i].Charge);
6726 GeomXYZ[i].Charge = g_strdup(d);
6727 }
6728 else break;
6729 }
6730 break;
6731 }
6732 }
6733 }
6734 /********************************************************************************/
read_geom_from_aimall_file(gchar * NomFichier)6735 void read_geom_from_aimall_file(gchar *NomFichier)
6736 {
6737 gchar *t;
6738 gchar *AtomCoord[5];
6739 FILE *fd;
6740 guint taille=BSIZE;
6741 guint i;
6742 gint j=0;
6743 gint l;
6744 gchar dum[100];
6745 gint uni=0;
6746
6747 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
6748
6749 t=g_malloc(taille);
6750 fd = FOpen(NomFichier, "rb");
6751 if(fd ==NULL)
6752 {
6753 g_free(t);
6754 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6755 MessageGeom(t,_("Error"),TRUE);
6756 g_free(t);
6757 return;
6758 }
6759 while(!feof(fd))
6760 {
6761 { char* e = fgets(t,taille,fd);}
6762 if ( strstr(t,"Atom Charge X Y Z"))
6763 {
6764 { char* e = fgets(t,taille,fd);}
6765 break;
6766 }
6767 }
6768
6769 j=-1;
6770 while(!feof(fd) )
6771 {
6772 { char* e = fgets(t,taille,fd);}
6773 if(this_is_a_backspace(t))
6774 {
6775 get_charges_from_aimall_file(fd,j+1);
6776 break;
6777 }
6778 j++;
6779
6780 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6781 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6782
6783 GeomXYZ[j].typeConnections = NULL;
6784 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
6785 {
6786 gint k;
6787 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
6788 delete_all_spaces(AtomCoord[0]);
6789 }
6790 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6791 l=strlen(AtomCoord[0]);
6792 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6793 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6794 GeomXYZ[j].Symb=get_symbol_using_z(atoi(dum));
6795 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6796 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6797 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6798 GeomXYZ[j].ResidueNumber=0;
6799 if(Units != uni )
6800 {
6801 if(Units==1)
6802 {
6803 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6804 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6805 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6806 }
6807 else
6808 {
6809 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
6810 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
6811 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
6812 }
6813 }
6814 else
6815 {
6816 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6817 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6818 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6819 }
6820 GeomXYZ[j].Charge=g_strdup("0.0");
6821 GeomXYZ[j].Layer=g_strdup(" ");
6822 }
6823
6824 NcentersXYZ = j+1;
6825 fclose(fd);
6826 calculMMTypes(FALSE);
6827 g_free(t);
6828 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6829 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6830 {
6831 clearList(list);
6832 append_list();
6833 }
6834 MethodeGeom = GEOM_IS_XYZ;
6835 if(GeomDrawingArea != NULL) rafresh_drawing();
6836 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
6837 }
6838 /********************************************************************************/
get_charge_and_multilicity(FILE * fd)6839 static void get_charge_and_multilicity(FILE* fd)
6840 {
6841 guint taille=BSIZE;
6842 gchar t[BSIZE];
6843
6844 while(!feof(fd) )
6845 {
6846 if(!fgets(t,taille,fd)) break;
6847 if ( strstr(t,"CHARGE OF MOLECULE") && strstr(t,"="))
6848 {
6849 gchar* p = strstr(t,"=")+1;
6850 TotalCharges[0] = atoi(p);
6851 }
6852 if ( strstr(t,"SPIN MULTIPLICITY ") && strstr(t,"="))
6853 {
6854 gchar* p = strstr(t,"=")+1;
6855 SpinMultiplicities[0] = atoi(p);
6856 break;
6857 }
6858 }
6859 }
6860 /********************************************************************************/
read_geom_from_gamess_output_file(gchar * NomFichier,gint numgeometry)6861 void read_geom_from_gamess_output_file(gchar *NomFichier, gint numgeometry)
6862 {
6863 gchar *t;
6864 gboolean OK;
6865 gchar *AtomCoord[5];
6866 FILE *fd;
6867 guint taille=BSIZE;
6868 guint i;
6869 gint j=0;
6870 gint l;
6871 guint numgeom;
6872 gchar dum[100];
6873 gint uni=1;
6874 long geomposok = 0;
6875
6876
6877 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
6878
6879 t=g_malloc(taille);
6880 #ifdef G_OS_WIN32
6881 fd = FOpen(NomFichier, "rb");
6882 #else
6883 fd = FOpen(NomFichier, "rb");
6884 #endif
6885 if(fd ==NULL)
6886 {
6887 g_free(t);
6888 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6889 MessageGeom(t,_("Error"),TRUE);
6890 g_free(t);
6891 return;
6892 }
6893 numgeom = 0;
6894 do
6895 {
6896 OK=FALSE;
6897 while(!feof(fd)){
6898 { char* e = fgets(t,taille,fd);}
6899 if ( numgeometry==1 && strstr(t,"COORDINATES (BOHR)"))
6900 {
6901 { char* e = fgets(t,taille,fd);}
6902 numgeom++;
6903 uni=0;
6904 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
6905 }
6906 if ( strstr(t,"COORDINATES OF ALL ATOMS ARE (ANGS)"))
6907 {
6908 { char* e = fgets(t,taille,fd);}
6909 { char* e = fgets(t,taille,fd);}
6910 numgeom++;
6911 uni=1;
6912 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
6913 if(numgeometry<0 ) { OK = TRUE; break; }
6914 }
6915 }
6916 if(!OK && (numgeom == 0) ){
6917 g_free(t);
6918 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
6919 MessageGeom(t,_("Error"),TRUE);
6920 g_free(t);
6921 return;
6922 }
6923 if(!OK)break;
6924
6925 j=-1;
6926 while(!feof(fd) )
6927 {
6928 { char* e = fgets(t,taille,fd);}
6929 if ( !strcmp(t,"\n")) break;
6930 if ( !strcmp(t,"\r\n")) break;
6931 j++;
6932
6933 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
6934 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
6935 GeomXYZ[j].typeConnections = NULL;
6936
6937 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
6938 {
6939 gint k;
6940 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
6941 delete_all_spaces(AtomCoord[0]);
6942 }
6943
6944 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
6945 l=strlen(AtomCoord[0]);
6946 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
6947 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
6948 /* GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);*/
6949 GeomXYZ[j].Symb=get_symbol_using_z(atoi(dum));
6950 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
6951 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
6952 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
6953 GeomXYZ[j].ResidueNumber=0;
6954 if(Units != uni )
6955 {
6956 if(Units==1)
6957 {
6958 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
6959 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
6960 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
6961 }
6962 else
6963 {
6964 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
6965 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
6966 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
6967 }
6968 }
6969 else
6970 {
6971 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
6972 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
6973 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
6974 }
6975 GeomXYZ[j].Charge=g_strdup("0.0");
6976 GeomXYZ[j].Layer=g_strdup(" ");
6977 }
6978
6979 NcentersXYZ = j+1;
6980 if(OK && numgeometry>=0) break;
6981 if(numgeometry<0) geomposok = ftell(fd);
6982 }while(!feof(fd));
6983 if ( NcentersXYZ >0 )
6984 {
6985 if(numgeometry<0) fseek(fd, geomposok, SEEK_SET);
6986 geomposok = ftell(fd);
6987 get_charges_from_gamess_output_file(fd,NcentersXYZ);
6988 get_dipole_from_gamess_output_file(fd);
6989 fseek(fd, geomposok, SEEK_SET);
6990 get_charge_and_multilicity(fd);
6991 }
6992
6993 fclose(fd);
6994 calculMMTypes(FALSE);
6995 g_free(t);
6996 for(i=0;i<5;i++) g_free(AtomCoord[i]);
6997 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
6998 {
6999 clearList(list);
7000 append_list();
7001 }
7002 MethodeGeom = GEOM_IS_XYZ;
7003 if(GeomDrawingArea != NULL) rafresh_drawing();
7004 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
7005 }
7006 /********************************************************************************/
read_geom_from_gamess_irc_file(gchar * NomFichier,gint numgeometry)7007 void read_geom_from_gamess_irc_file(gchar *NomFichier, gint numgeometry)
7008 {
7009 gchar *t;
7010 gboolean OK;
7011 gchar *AtomCoord[5];
7012 FILE *fd;
7013 guint taille=BSIZE;
7014 guint i;
7015 gint j=0;
7016 gint l;
7017 guint numgeom;
7018 gchar dum[100];
7019 gint uni=1;
7020 /* long geomposok = 0;*/
7021
7022
7023
7024 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
7025
7026 t=g_malloc(taille);
7027 #ifdef G_OS_WIN32
7028 fd = FOpen(NomFichier, "rb");
7029 #else
7030 fd = FOpen(NomFichier, "rb");
7031 #endif
7032 if(fd ==NULL)
7033 {
7034 g_free(t);
7035 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
7036 MessageGeom(t,_("Error"),TRUE);
7037 g_free(t);
7038 return;
7039 }
7040 numgeom = 0;
7041 do
7042 {
7043 OK=FALSE;
7044 while(!feof(fd)){
7045 { char* e = fgets(t,taille,fd);}
7046 if (strstr(t,"CARTESIAN COORDINATES (BOHR)"))
7047 {
7048 numgeom++;
7049 uni=0;
7050 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
7051 }
7052 }
7053 if(!OK && (numgeom == 0) ){
7054 g_free(t);
7055 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
7056 MessageGeom(t,_("Error"),TRUE);
7057 g_free(t);
7058 return;
7059 }
7060 if(!OK)break;
7061
7062 j=-1;
7063 while(!feof(fd) )
7064 {
7065 gdouble rdum = 0;
7066 { char* e = fgets(t,taille,fd);}
7067 if ( !strcmp(t,"GRADIENT")) break;
7068 if(2!=sscanf(t,"%s %lf",AtomCoord[0],&rdum)) break;
7069 j++;
7070
7071 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
7072 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
7073 GeomXYZ[j].typeConnections = NULL;
7074
7075 sscanf(t,"%s %s %s %s %s",AtomCoord[0],dum, AtomCoord[1], AtomCoord[2],AtomCoord[3]);
7076 {
7077 gint k;
7078 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
7079 delete_all_spaces(AtomCoord[0]);
7080 }
7081
7082 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
7083 l=strlen(AtomCoord[0]);
7084 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
7085 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
7086 /* GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);*/
7087 GeomXYZ[j].Symb=get_symbol_using_z(atoi(dum));
7088 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
7089 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
7090 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
7091 GeomXYZ[j].ResidueNumber=0;
7092 if(Units != uni )
7093 {
7094 if(Units==1)
7095 {
7096 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
7097 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
7098 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
7099 }
7100 else
7101 {
7102 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
7103 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
7104 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
7105 }
7106 }
7107 else
7108 {
7109 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
7110 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
7111 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
7112 }
7113 GeomXYZ[j].Charge=g_strdup("0.0");
7114 GeomXYZ[j].Layer=g_strdup(" ");
7115 }
7116
7117 NcentersXYZ = j+1;
7118 if(OK && numgeometry>=0) break;
7119 // if(numgeometry<0) geomposok = ftell(fd);*/
7120 }while(!feof(fd));
7121 if ( NcentersXYZ >0 )
7122 {
7123 reset_charges_multiplicities_XYZ();
7124 }
7125
7126 fclose(fd);
7127 calculMMTypes(FALSE);
7128 g_free(t);
7129 for(i=0;i<5;i++) g_free(AtomCoord[i]);
7130 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
7131 {
7132 clearList(list);
7133 append_list();
7134 }
7135 MethodeGeom = GEOM_IS_XYZ;
7136 if(GeomDrawingArea != NULL) rafresh_drawing();
7137 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
7138 }
7139 /********************************************************************************/
read_first_gamess_file(GabeditFileChooser * SelecFile,gint response_id)7140 void read_first_gamess_file(GabeditFileChooser *SelecFile, gint response_id)
7141 {
7142 gchar *fileName;
7143
7144 if(response_id != GTK_RESPONSE_OK) return;
7145 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7146
7147 if ((!fileName) || (strcmp(fileName,"") == 0))
7148 {
7149 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7150 return ;
7151 }
7152 read_geom_from_gamess_output_file(fileName,1);
7153 }
7154 /********************************************************************************/
read_last_gamess_file(GabeditFileChooser * SelecFile,gint response_id)7155 void read_last_gamess_file(GabeditFileChooser *SelecFile, gint response_id)
7156 {
7157 gchar *fileName;
7158
7159 if(response_id != GTK_RESPONSE_OK) return;
7160 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7161
7162 if ((!fileName) || (strcmp(fileName,"") == 0))
7163 {
7164 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7165 return ;
7166 }
7167 read_geom_from_gamess_output_file(fileName,-1);
7168 }
7169 /********************************************************************************/
read_last_irc_gamess_file(GabeditFileChooser * SelecFile,gint response_id)7170 void read_last_irc_gamess_file(GabeditFileChooser *SelecFile, gint response_id)
7171 {
7172 gchar *fileName;
7173
7174 if(response_id != GTK_RESPONSE_OK) return;
7175 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7176
7177 if ((!fileName) || (strcmp(fileName,"") == 0))
7178 {
7179 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7180 return ;
7181 }
7182 read_geom_from_gamess_irc_file(fileName,-1);
7183 }
7184 /********************************************************************************/
read_aimall_file(GabeditFileChooser * SelecFile,gint response_id)7185 void read_aimall_file(GabeditFileChooser *SelecFile, gint response_id)
7186 {
7187 gchar *fileName;
7188
7189 if(response_id != GTK_RESPONSE_OK) return;
7190 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7191
7192 if ((!fileName) || (strcmp(fileName,"") == 0))
7193 {
7194 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7195 return ;
7196 }
7197 read_geom_from_aimall_file(fileName);
7198 }
7199 /********************************************************************************/
read_geom_from_turbomole_output_file(gchar * fileName,gint numgeometry)7200 void read_geom_from_turbomole_output_file(gchar *fileName, gint numgeometry)
7201 {
7202 gchar *t;
7203 gboolean OK;
7204 gchar *AtomCoord[5];
7205 FILE *fd;
7206 guint taille=BSIZE;
7207 guint i;
7208 gint j=0;
7209 gint l;
7210 guint numgeom;
7211 gint uni=1;
7212 long geomposok = 0;
7213
7214
7215 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
7216
7217 t=g_malloc(taille*sizeof(gchar));
7218 fd = FOpen(fileName, "rb");
7219 if(fd ==NULL)
7220 {
7221 g_free(t);
7222 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
7223 MessageGeom(t,_("Error"),TRUE);
7224 g_free(t);
7225 return;
7226 }
7227 numgeom = 0;
7228 do
7229 {
7230 OK=FALSE;
7231 while(!feof(fd)){
7232 { char* e = fgets(t,taille,fd);}
7233 if ( strstr(t,"Atomic coordinate, charge and isotop information"))
7234 {
7235 while(!feof(fd)){
7236 { char* e = fgets(t,taille,fd);}
7237 if(strstr(t,"atomic") && strstr(t, "coordinates") && strstr(t,"atom") && strstr(t,"shells") && strstr(t,"charge")) break;
7238 }
7239 if(!(strstr(t,"atomic") && strstr(t, "coordinates") && strstr(t,"atom") && strstr(t,"shells") && strstr(t,"charge"))) {OK = FALSE; break;}
7240 numgeom++;
7241 uni=0;
7242 if((gint)numgeom == numgeometry ) { OK = TRUE; break; }
7243 if(numgeometry<0 ) { OK = TRUE; break; }
7244 }
7245 }
7246 if(!OK && (numgeom == 0) ){
7247 g_free(t);
7248 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
7249 MessageGeom(t,_("Error"),TRUE);
7250 g_free(t);
7251 return;
7252 }
7253 if(!OK)break;
7254
7255 j=-1;
7256 while(!feof(fd) )
7257 {
7258 { char* e = fgets(t,taille,fd);}
7259 if ( !strcmp(t,"\n")) break;
7260 if ( !strcmp(t,"\r\n")) break;
7261 j++;
7262
7263 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
7264 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
7265 GeomXYZ[j].typeConnections = NULL;
7266
7267 sscanf(t,"%s %s %s %s",AtomCoord[1], AtomCoord[2],AtomCoord[3], AtomCoord[0]);
7268 {
7269 gint k;
7270 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
7271 delete_all_spaces(AtomCoord[0]);
7272 }
7273
7274 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
7275 l=strlen(AtomCoord[0]);
7276 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
7277 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
7278 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
7279 /* GeomXYZ[j].Symb=get_symbol_using_z(atoi(dum));*/
7280 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
7281 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
7282 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
7283 GeomXYZ[j].ResidueNumber=0;
7284 if(Units != uni )
7285 {
7286 if(Units==1)
7287 {
7288 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
7289 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
7290 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
7291 }
7292 else
7293 {
7294 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
7295 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
7296 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
7297 }
7298 }
7299 else
7300 {
7301 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
7302 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
7303 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
7304 }
7305 GeomXYZ[j].Charge=g_strdup("0.0");
7306 GeomXYZ[j].Layer=g_strdup(" ");
7307 }
7308
7309 NcentersXYZ = j+1;
7310 if(OK && numgeometry>=0) break;
7311 if(numgeometry<0) geomposok = ftell(fd);
7312 }while(!feof(fd));
7313 if ( NcentersXYZ >0 )
7314 {
7315 if(numgeometry<0) fseek(fd, geomposok, SEEK_SET);
7316 geomposok = ftell(fd);
7317 get_charges_from_turbomole_output_file(fd,NcentersXYZ);
7318 fseek(fd, geomposok, SEEK_SET);
7319 get_dipole_from_turbomole_output_file(fd);
7320 /*
7321 fseek(fd, geomposok, SEEK_SET);
7322 get_charge_and_multilicity(fd);
7323 */
7324 }
7325
7326 fclose(fd);
7327 calculMMTypes(FALSE);
7328 g_free(t);
7329 for(i=0;i<5;i++) g_free(AtomCoord[i]);
7330 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
7331 {
7332 clearList(list);
7333 append_list();
7334 }
7335 MethodeGeom = GEOM_IS_XYZ;
7336 if(GeomDrawingArea != NULL) rafresh_drawing();
7337 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
7338 }
7339 /********************************************************************************/
read_first_turbomole_file(GabeditFileChooser * SelecFile,gint response_id)7340 void read_first_turbomole_file(GabeditFileChooser *SelecFile, gint response_id)
7341 {
7342 gchar *fileName;
7343
7344 if(response_id != GTK_RESPONSE_OK) return;
7345 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7346
7347 if ((!fileName) || (strcmp(fileName,"") == 0))
7348 {
7349 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7350 return ;
7351 }
7352 read_geom_from_turbomole_output_file(fileName,1);
7353 }
7354 /********************************************************************************/
read_last_turbomole_file(GabeditFileChooser * SelecFile,gint response_id)7355 void read_last_turbomole_file(GabeditFileChooser *SelecFile, gint response_id)
7356 {
7357 gchar *fileName;
7358
7359 if(response_id != GTK_RESPONSE_OK) return;
7360 fileName = gabedit_file_chooser_get_current_file(SelecFile);
7361
7362 if ((!fileName) || (strcmp(fileName,"") == 0))
7363 {
7364 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
7365 return ;
7366 }
7367 read_geom_from_turbomole_output_file(fileName,-1);
7368 }
7369 /********************************************************************************/
read_geom_from_cif_file(gchar * fileName,gboolean applySymOp)7370 void read_geom_from_cif_file(gchar *fileName, gboolean applySymOp)
7371 {
7372 gint k;
7373 gchar* error = NULL;
7374 Crystal crystal;
7375 gint nAtoms = 0;
7376 GList* l;
7377
7378 error = read_geometry_from_cif_file(&crystal, fileName, applySymOp);
7379 if(!error) for(l = g_list_first(crystal.atoms); l != NULL; l = l->next) nAtoms++;
7380 if(error || nAtoms<1)
7381 {
7382 gchar* t = g_strdup_printf(_("Sorry\nI cannot read the geometry from %s file "),fileName);
7383 if(error)
7384 {
7385 gchar* tmp = t;
7386 t = g_strdup_printf(_("%s\n%s\n"),tmp, error);
7387 g_free(tmp);
7388 }
7389 MessageGeom(t,_("Error"),TRUE);
7390 g_free(t);
7391 freeCrystal(&crystal);
7392 return;
7393 }
7394 init_dipole();
7395 if(GeomXYZ) freeGeomXYZ();
7396 if(VariablesXYZ) freeVariablesXYZ();
7397
7398
7399 NcentersXYZ = nAtoms;
7400 GeomXYZ = g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
7401
7402 k=0;
7403 /* fprintf(stderr,"read cif Units=%d\n",Units);*/
7404 for(l = g_list_first(crystal.atoms); l != NULL; l = l->next)
7405 {
7406 CrystalloAtom* a = (CrystalloAtom*)l->data;
7407 gdouble X,Y,Z;
7408
7409 GeomXYZ[k].Nentry=NUMBER_LIST_XYZ;
7410 GeomXYZ[k].Symb=g_strdup(a->symbol);
7411 GeomXYZ[k].mmType=g_strdup(a->mmType);
7412 GeomXYZ[k].pdbType=g_strdup(a->pdbType);
7413 GeomXYZ[k].Residue=g_strdup(a->residueName);
7414 GeomXYZ[k].ResidueNumber=0;
7415 X=a->C[0];
7416 Y=a->C[1];
7417 Z=a->C[2];
7418 if(Units==0) { X /= (BOHR_TO_ANG); Y /= (BOHR_TO_ANG); Z /= (BOHR_TO_ANG); }
7419 GeomXYZ[k].X=g_strdup_printf("%0.10lf",X);
7420 GeomXYZ[k].Y=g_strdup_printf("%0.10lf",Y);
7421 GeomXYZ[k].Z=g_strdup_printf("%0.10lf",Z);
7422 GeomXYZ[k].Charge=g_strdup_printf("%0.5lf",a->charge);
7423 GeomXYZ[k].Layer=g_strdup(" ");
7424 GeomXYZ[k].typeConnections=NULL;
7425 k++;
7426 }
7427 reset_origine_molecule_drawgeom();
7428 //calculMMTypes(TRUE);
7429 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
7430 if(GeomDrawingArea != NULL) rafresh_drawing();
7431
7432 freeCrystal(&crystal);
7433 }
7434 /********************************************************************************/
read_geom_from_vasp_xml_file(gchar * fileName,gint numgeom)7435 void read_geom_from_vasp_xml_file(gchar *fileName, gint numgeom)
7436 {
7437 gchar** symbols = NULL;
7438 gdouble* positions[3]= { NULL, NULL, NULL};
7439 gint nAtoms = 0;
7440 gdouble* X;
7441 gdouble* Y;
7442 gdouble* Z;
7443 gint k;
7444
7445 nAtoms = read_geometry_vasp_xml_file(fileName, numgeom, &symbols, positions);
7446 if(nAtoms<1)
7447 {
7448 gchar* t = g_strdup_printf(_("Sorry\nI can not the geometry number %d from %s file "),numgeom, fileName);
7449 MessageGeom(t,_("Error"),TRUE);
7450 g_free(t);
7451 return;
7452 }
7453 init_dipole();
7454 if(GeomXYZ) freeGeomXYZ();
7455 if(VariablesXYZ) freeVariablesXYZ();
7456 NcentersXYZ = nAtoms;
7457 GeomXYZ = g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
7458 X = positions[0];
7459 Y = positions[1];
7460 Z = positions[2];
7461 for(k=0;k<nAtoms;k++)
7462 {
7463 GeomXYZ[k].Nentry=NUMBER_LIST_XYZ;
7464 GeomXYZ[k].Symb=g_strdup(symbols[k]);
7465 GeomXYZ[k].mmType=g_strdup(symbols[k]);
7466 GeomXYZ[k].pdbType=g_strdup(symbols[k]);
7467 GeomXYZ[k].Residue=g_strdup(symbols[k]);
7468 GeomXYZ[k].ResidueNumber=0;
7469 GeomXYZ[k].X=g_strdup_printf("%0.10f",X[k]);
7470 GeomXYZ[k].Y=g_strdup_printf("%0.10f",Y[k]);
7471 GeomXYZ[k].Z=g_strdup_printf("%0.10f",Z[k]);
7472 GeomXYZ[k].Charge=g_strdup("0.0");
7473 GeomXYZ[k].Layer=g_strdup(" ");
7474 GeomXYZ[k].typeConnections=NULL;
7475 }
7476 calculMMTypes(TRUE);
7477 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
7478 if(GeomDrawingArea != NULL) rafresh_drawing();
7479
7480 if(X) g_free(X);
7481 if(Y) g_free(Y);
7482 if(Z) g_free(Z);
7483 for(k=0;k<nAtoms;k++) if(symbols[k]) g_free(symbols[k]);
7484 if(symbols) g_free(symbols);
7485 }
7486 /********************************************************************************/
read_geom_from_poscar_file(gchar * fileName)7487 void read_geom_from_poscar_file(gchar *fileName)
7488 {
7489 gchar *t;
7490 gboolean OK;
7491 FILE *file;
7492 gint i;
7493 gint j;
7494 gint k;
7495 gint n = 0;
7496 gdouble factor = 1.0;
7497 gdouble TV[3][3];
7498 gchar** strsplit1 = NULL;
7499 gchar** strsplit2 = NULL;
7500 gint nmax = 0;
7501 gint nmax2 = 0;
7502 gchar** types = NULL;
7503 gchar** symbols = NULL;
7504 gint* ntypes = NULL;
7505 gdouble* X = NULL;
7506 gdouble* Y = NULL;
7507 gdouble* Z = NULL;
7508 gboolean direct = FALSE;
7509 gint nAtoms = 0;
7510
7511
7512 file = FOpen(fileName, "rb");
7513 if(!file)
7514 {
7515 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
7516 MessageGeom(t,_("Error"),TRUE);
7517 g_free(t);
7518 return;
7519 }
7520 OK = TRUE;
7521 t=g_malloc(BSIZE*sizeof(gchar));
7522 if(!fgets(t,BSIZE,file)) OK = FALSE; //comment
7523 if(OK && !fgets(t,BSIZE,file)) OK = FALSE; //global factor
7524 if(OK && 1!=sscanf(t,"%lf",&factor)) OK = FALSE;
7525 if(OK) for(i=0;i<3;i++)
7526 {
7527 if(OK && !fgets(t,BSIZE,file)){ OK = FALSE; break;}
7528 if(OK && 3!=sscanf(t,"%lf %lf %lf",&TV[i][0], &TV[i][1], &TV[i][2])) {OK = FALSE; break;}
7529 }
7530 if(OK && fgets(t,BSIZE,file))
7531 {
7532 deleteLastSpaces(t);
7533 strsplit1 = gab_split(t);
7534 while(strsplit1 && strsplit1[nmax]) nmax++;
7535 if(nmax>0 && fgets(t,BSIZE,file))
7536 {
7537 deleteLastSpaces(t);
7538 strsplit2 = gab_split(t);
7539 }
7540 while(strsplit2 && strsplit2[nmax2]) nmax2++;
7541 if(nmax<1 || nmax != nmax2)
7542 {
7543 if(t)g_free(t);
7544 t = g_strdup_printf(_("Sorry\nI can not the symbol of atoms from %s file,\nadd these after the cell definition before the number of each type"),fileName);
7545 MessageGeom(t,_("Error"),TRUE);
7546 g_free(t);
7547 if(strsplit1) g_strfreev(strsplit1);
7548 if(strsplit2) g_strfreev(strsplit2);
7549 return;
7550 }
7551
7552 }
7553 types = g_malloc(nmax*sizeof(gchar*));
7554 i = 0; while(strsplit1 && strsplit1[i]) { types[i] = g_strdup(strsplit1[i]); i++;}
7555 ntypes = g_malloc(nmax*sizeof(gint));
7556 i = 0; while(strsplit2 && strsplit2[i]) { ntypes[i] = atoi(strsplit2[i]); i++;}
7557 nAtoms = 0;
7558 //printf("nmax = %d\n",nmax);
7559 //for(i=0;i<nmax;i++) printf("ntype = %d\n",ntypes[i]);
7560
7561 for(i=0;i<nmax;i++) nAtoms += ntypes[i];
7562 if(nAtoms<1) OK = FALSE;
7563 nAtoms += 3; // TV
7564 //printf("nAtoms = %d\n",nAtoms);
7565
7566 if(OK)
7567 {
7568 OK = FALSE;
7569 while(!feof(file))
7570 {
7571 if(!fgets(t,BSIZE,file)){ break;}
7572 delete_last_spaces(t);
7573 delete_first_spaces(t);
7574 t[0]=toupper(t[0]);
7575 if(t[0]=='D') { direct = TRUE; OK = TRUE; break;}
7576 if(t[0] == 'C') { OK = TRUE; break; }
7577 }
7578 }
7579 //printf("direct = %d\n",direct);
7580 if(OK)
7581 {
7582 X = g_malloc(nAtoms*sizeof(gdouble));
7583 Y = g_malloc(nAtoms*sizeof(gdouble));
7584 Z = g_malloc(nAtoms*sizeof(gdouble));
7585 symbols = g_malloc(nAtoms*sizeof(gchar*));
7586 for(i=0;i<nAtoms;i++) symbols[i] = NULL;
7587 k = 0;
7588 for(i=0;i<nmax;i++)
7589 for(j=0;j<ntypes[i];j++)
7590 {
7591 symbols[k] = g_strdup(types[i]);
7592 symbols[k][0]=toupper(symbols[k][0]);
7593 if (strlen(symbols[k])==2) symbols[k][1]=tolower(symbols[k][1]);
7594 if (strlen(symbols[k])==3) symbols[k][2]=tolower(symbols[k][2]);
7595 if(!fgets(t,BSIZE,file)){ OK = FALSE; break;}
7596 if(3!=sscanf(t,"%lf %lf %lf",&X[k], &Y[k], &Z[k])) {OK = FALSE; break;}
7597 k++;
7598 }
7599 }
7600 if(OK && Units!=1) factor *= ANG_TO_BOHR;
7601 if(OK) for(k=0;k<3;k++) for(j=0;j<3;j++) TV[k][j] *= factor;
7602 if(OK&& !direct)
7603 {
7604 for(k=0;k<nAtoms-3;k++) X[k] *= factor;
7605 for(k=0;k<nAtoms-3;k++) Y[k] *= factor;
7606 for(k=0;k<nAtoms-3;k++) Z[k] *= factor;
7607 }
7608 if(OK&& direct)
7609 {
7610 gdouble* nX = g_malloc(nAtoms*sizeof(gdouble));
7611 gdouble* nY = g_malloc(nAtoms*sizeof(gdouble));
7612 gdouble* nZ = g_malloc(nAtoms*sizeof(gdouble));
7613 for(k=0;k<nAtoms-3;k++) nX[k] = 0.0;
7614 for(k=0;k<nAtoms-3;k++) nY[k] = 0.0;
7615 for(k=0;k<nAtoms-3;k++) nZ[k] = 0.0;
7616
7617 for(k=0;k<nAtoms-3;k++)
7618 {
7619 while(X[k]<0) X[k]+=1;
7620 while(Y[k]<0) Y[k]+=1;
7621 while(Z[k]<0) Z[k]+=1;
7622 while(X[k]>=1) X[k]-=1;
7623 while(Y[k]>=1) Y[k]-=1;
7624 while(Z[k]>=1) Z[k]-=1;
7625 if(fabs(X[k]-1.0)<1e-10) X[k]=0;
7626 if(fabs(Y[k]-1.0)<1e-10) Y[k]=0;
7627 if(fabs(Z[k]-1.0)<1e-10) Z[k]=0;
7628 }
7629
7630 for(k=0;k<nAtoms-3;k++)
7631 {
7632 nX[k] = X[k]*TV[0][0]+Y[k]*TV[1][0]+Z[k]*TV[2][0];
7633 nY[k] = X[k]*TV[0][1]+Y[k]*TV[1][1]+Z[k]*TV[2][1];
7634 nZ[k] = X[k]*TV[0][2]+Y[k]*TV[1][2]+Z[k]*TV[2][2];
7635 }
7636 g_free(X);
7637 g_free(Y);
7638 g_free(Z);
7639 X = nX;
7640 Y = nY;
7641 Z = nZ;
7642 }
7643
7644 if(OK)
7645 {
7646 init_dipole();
7647 if(GeomXYZ) freeGeomXYZ();
7648 if(VariablesXYZ) freeVariablesXYZ();
7649 NcentersXYZ = nAtoms;
7650 GeomXYZ = g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
7651 for(k=0;k<nAtoms-3;k++)
7652 {
7653 GeomXYZ[k].Nentry=NUMBER_LIST_XYZ;
7654 GeomXYZ[k].Symb=g_strdup(symbols[k]);
7655 GeomXYZ[k].mmType=g_strdup(symbols[k]);
7656 GeomXYZ[k].pdbType=g_strdup(symbols[k]);
7657 GeomXYZ[k].Residue=g_strdup(symbols[k]);
7658 GeomXYZ[k].ResidueNumber=0;
7659 GeomXYZ[k].X=g_strdup_printf("%0.10f",X[k]);
7660 GeomXYZ[k].Y=g_strdup_printf("%0.10f",Y[k]);
7661 GeomXYZ[k].Z=g_strdup_printf("%0.10f",Z[k]);
7662 GeomXYZ[k].Charge=g_strdup("0.0");
7663 GeomXYZ[k].Layer=g_strdup(" ");
7664 GeomXYZ[k].typeConnections=NULL;
7665 }
7666 for(k=nAtoms-3;k<nAtoms;k++)
7667 {
7668 GeomXYZ[k].Nentry=NUMBER_LIST_XYZ;
7669 GeomXYZ[k].Symb=g_strdup("Tv");
7670 GeomXYZ[k].mmType=g_strdup("Tv");
7671 GeomXYZ[k].pdbType=g_strdup("Tv");
7672 GeomXYZ[k].Residue=g_strdup("Tv");
7673 GeomXYZ[k].ResidueNumber=0;
7674 GeomXYZ[k].X=g_strdup_printf("%0.10f",TV[k-nAtoms+3][0]);
7675 GeomXYZ[k].Y=g_strdup_printf("%0.10f",TV[k-nAtoms+3][1]);
7676 GeomXYZ[k].Z=g_strdup_printf("%0.10f",TV[k-nAtoms+3][2]);
7677 GeomXYZ[k].Charge=g_strdup("0.0");
7678 GeomXYZ[k].Layer=g_strdup(" ");
7679 GeomXYZ[k].typeConnections=NULL;
7680 }
7681 }
7682 fclose(file);
7683 g_free(t);
7684 calculMMTypes(TRUE);
7685 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
7686 if(GeomDrawingArea != NULL) rafresh_drawing();
7687
7688 if(strsplit1) g_strfreev(strsplit1);
7689 if(strsplit2) g_strfreev(strsplit2);
7690 }
7691 /********************************************************************************/
read_geom_from_xyz_file(gchar * fileName,gint numGeom)7692 void read_geom_from_xyz_file(gchar *fileName, gint numGeom)
7693 {
7694 gchar *t;
7695 gboolean OK;
7696 gchar *AtomCoord[5];
7697 FILE *file;
7698 guint taille=BSIZE;
7699 gint i;
7700 gint j;
7701 gint l;
7702 gint n = 0;
7703
7704
7705 file = FOpen(fileName, "rb");
7706 if(!file)
7707 {
7708 t = g_strdup_printf(_("Sorry\nI can not open %s file "),fileName);
7709 MessageGeom(t,_("Error"),TRUE);
7710 g_free(t);
7711 return;
7712 }
7713 OK = FALSE;
7714 j = 0;
7715 t=g_malloc(taille);
7716 while(!feof(file))
7717 {
7718 j++;
7719 if(j==numGeom){OK = TRUE; break;}
7720 if(!fgets(t,BSIZE,file))break;
7721 n=atoi(t);
7722 if(n<1)break;
7723 if(!fgets(t,BSIZE,file))break;
7724 for(i=0;i<n;i++) if(!fgets(t,BSIZE,file))break;
7725 if(i!=n) break;
7726 }
7727 if(!OK)
7728 {
7729 g_free(t);
7730 t = g_strdup_printf(_("Sorry\n I can not read geometry number %d for %s file"),numGeom,fileName);
7731 MessageGeom(t,_("Error"),TRUE);
7732 g_free(t);
7733 return;
7734 }
7735 if(OK && fgets(t,BSIZE,file))
7736 {
7737 n=atoi(t);
7738 if(n<1) OK = FALSE;
7739 if(!fgets(t,BSIZE,file)) OK = FALSE;/* title */
7740 }
7741 else OK = FALSE;
7742 if(OK)
7743 {
7744 init_dipole();
7745 if(GeomXYZ) freeGeomXYZ();
7746 if(VariablesXYZ) freeVariablesXYZ();
7747 NcentersXYZ = n;
7748 GeomXYZ = g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
7749 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
7750 for(j=0;j<n;j++)
7751 {
7752 if(!fgets(t,BSIZE,file)) { OK = FALSE;break;}
7753 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
7754 delete_first_spaces(AtomCoord[0]);
7755 delete_last_spaces(AtomCoord[0]);
7756 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
7757 l=strlen(AtomCoord[0]);
7758 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
7759 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
7760 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
7761 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
7762 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
7763 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
7764 GeomXYZ[j].ResidueNumber=0;
7765 if(Units==1)
7766 {
7767 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
7768 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
7769 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
7770 }
7771 else
7772 {
7773 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
7774 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
7775 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
7776 }
7777 GeomXYZ[j].Charge=g_strdup("0.0");
7778 GeomXYZ[j].Layer=g_strdup(" ");
7779 GeomXYZ[j].typeConnections=NULL;
7780 }
7781 if(!OK)
7782 {
7783 NcentersXYZ = 0;
7784 if(GeomXYZ) freeGeomXYZ();
7785 }
7786 for(i=0;i<5;i++) g_free(AtomCoord[i]);
7787 }
7788 fclose(file);
7789 g_free(t);
7790 calculMMTypes(TRUE);
7791 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
7792 if(GeomDrawingArea != NULL) rafresh_drawing();
7793 }
7794 /********************************************************************************/
read_geom_from_gaussian_file(gchar * NomFichier,gint numgeometry)7795 void read_geom_from_gaussian_file(gchar *NomFichier, gint numgeometry)
7796 {
7797 gchar *t;
7798 gboolean OK;
7799 gchar *AtomCoord[5];
7800 FILE *fd;
7801 guint taille=BSIZE;
7802 guint idummy;
7803 guint i;
7804 gint j=0;
7805 gint l;
7806 gint numgeom;
7807 gchar *pdest;
7808 guint itype=0;
7809 gchar* strStandard = "Standard orientation:";
7810 gchar* strInput = "Input orientation:";
7811 gchar* strOther = "orientation:";
7812 gchar* strSearch = strOther;
7813
7814 /* fprintf(stderr,"DEBUG numGeom = %d\n",numgeometry);*/
7815
7816 for(i=0;i<5;i++)
7817 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
7818
7819 t=g_malloc(taille*sizeof(gchar));
7820 fd = FOpen(NomFichier, "rb");
7821 if(fd ==NULL)
7822 {
7823 g_free(t);
7824 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
7825 MessageGeom(t,_("Error"),TRUE);
7826 g_free(t);
7827 return;
7828 }
7829 while(!feof(fd))
7830 {
7831 if(!fgets(t,taille,fd))break;
7832 if(strstr( t, strStandard))
7833 {
7834 strSearch = strStandard;
7835 break;
7836 }
7837 if(strstr( t, strInput))
7838 strSearch = strInput;
7839 }
7840 rewind(fd);
7841 numgeom =0;
7842 do
7843 {
7844 OK=FALSE;
7845 while(!feof(fd)){
7846 { char* e = fgets(t,taille,fd);}
7847 if(strstr(t,"Charge =") && strstr(t,"Multiplicity ="))
7848 {
7849 gchar* p = strstr(t,"Charge =")+8;
7850 TotalCharges[0] = atoi(p);
7851 p = strstr(t,"Multiplicity =")+14;
7852 SpinMultiplicities[0] = atoi(p);
7853 }
7854 if ( strstr( t, strSearch))
7855 {
7856 { char* e = fgets(t,taille,fd);}
7857 { char* e = fgets(t,taille,fd);}
7858 { char* e = fgets(t,taille,fd);}
7859 if(strstr( t, "Type" ))
7860 itype=1;
7861 else
7862 itype=0;
7863 { char* e = fgets(t,taille,fd);}
7864 numgeom++;
7865 if(numgeom == numgeometry )
7866 {
7867 OK = TRUE;
7868 break;
7869 }
7870 }
7871 }
7872 if(!OK && (numgeom == 0) )
7873 {
7874 g_free(t);
7875 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
7876 MessageGeom(t,_("Error"),TRUE);
7877 g_free(t);
7878 return;
7879 }
7880 if(!OK)break;
7881
7882 j=-1;
7883 while(!feof(fd) )
7884 {
7885 { char* e = fgets(t,taille,fd);}
7886 if ( strstr( t, "----------------------------------" ))
7887 {
7888 long geomposok = ftell(fd);
7889 get_dipole_from_gaussian_output_file(fd);
7890 fseek(fd, geomposok, SEEK_SET);
7891 get_charges_from_gaussian_output_file(fd,j+1);
7892 get_natural_charges_from_gaussian_output_file(fd,j+1);
7893 fseek(fd, geomposok, SEEK_SET);
7894 get_esp_charges_from_gaussian_output_file(fd,j+1);
7895 break;
7896 }
7897 j++;
7898
7899 if(GeomXYZ==NULL)
7900 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
7901 else
7902 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
7903 GeomXYZ[j].typeConnections = NULL;
7904
7905 if(itype==0)
7906 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
7907 else
7908 sscanf(t,"%d %s %d %s %s %s",&idummy,AtomCoord[0],&idummy,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
7909 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
7910 l=strlen(AtomCoord[0]);
7911 if (l==2)
7912 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
7913
7914 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
7915 GeomXYZ[j].Symb=g_strdup(symb_atom_get((guint)atoi(AtomCoord[0])));
7916 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
7917 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
7918 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
7919 GeomXYZ[j].ResidueNumber=0;
7920 if(Units == 0 )
7921 {
7922 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
7923 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
7924 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
7925 }
7926 else
7927 {
7928 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
7929 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
7930 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
7931 }
7932 GeomXYZ[j].Charge=g_strdup("0.0");
7933 GeomXYZ[j].Layer=g_strdup(" ");
7934 }
7935
7936 NcentersXYZ = j+1;
7937 /* fprintf(stderr,"DEBUG Ncenters = %d\n",NcentersXYZ);*/
7938 if(OK)
7939 break;
7940 }while(!feof(fd));
7941
7942 fclose(fd);
7943 g_free(t);
7944 calculMMTypes(FALSE);
7945 for(i=0;i<5;i++)
7946 g_free(AtomCoord[i]);
7947 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
7948 {
7949 clearList(list);
7950 append_list();
7951 }
7952 MethodeGeom = GEOM_IS_XYZ;
7953 if(GeomDrawingArea != NULL)
7954 rafresh_drawing();
7955 if(iprogram == PROG_IS_GAUSS && GeomIsOpen)
7956 set_spin_of_electrons();
7957 }
7958 /********************************************************************************/
read_geom_from_molpro_file(gchar * NomFichier,gint numgeometry)7959 void read_geom_from_molpro_file(gchar *NomFichier, gint numgeometry)
7960 {
7961 gchar *t;
7962 gboolean OK;
7963 gchar *AtomCoord[5];
7964 FILE *fd;
7965 guint taille=BSIZE;
7966 guint idummy;
7967 guint i;
7968 gint j=0;
7969 gint l;
7970 guint numgeom;
7971
7972 for(i=0;i<5;i++)
7973 AtomCoord[i]=g_malloc(taille*sizeof(char));
7974
7975
7976 t=g_malloc(taille);
7977 fd = FOpen(NomFichier, "rb");
7978 if(fd ==NULL)
7979 {
7980 g_free(t);
7981 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
7982 MessageGeom(t,_("Error"),TRUE);
7983 g_free(t);
7984 return;
7985 }
7986 numgeom = 0;
7987 do
7988 {
7989 OK=FALSE;
7990 while(!feof(fd)){
7991 { char* e = fgets(t,taille,fd);}
7992 if ( !strcmp(t," ATOMIC COORDINATES\n"))
7993 {
7994 { char* e = fgets(t,taille,fd);}
7995 { char* e = fgets(t,taille,fd);}
7996 { char* e = fgets(t,taille,fd);}
7997 numgeom++;
7998 if((gint)numgeom == numgeometry )
7999 {
8000 OK = TRUE;
8001 break;
8002 }
8003 }
8004 }
8005 if(!OK && (numgeom == 0) ){
8006 g_free(t);
8007 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
8008 MessageGeom(t,_("Error"),TRUE);
8009 g_free(t);
8010 return;
8011 }
8012 if(!OK)break;
8013
8014 j=-1;
8015 while(!feof(fd) )
8016 {
8017 { char* e = fgets(t,taille,fd);}
8018 if ( !strcmp(t,"\n"))
8019 {
8020 get_dipole_from_molpro_output_file(fd);
8021 break;
8022 }
8023 j++;
8024
8025 if(GeomXYZ==NULL)
8026 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8027 else
8028 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8029 GeomXYZ[j].typeConnections = NULL;
8030 sscanf(t,"%d %s %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[1], AtomCoord[2],AtomCoord[3]);
8031
8032 {
8033 gint k;
8034 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
8035 delete_all_spaces(AtomCoord[0]);
8036 }
8037
8038 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
8039 l=strlen(AtomCoord[0]);
8040 if (l==2)
8041 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
8042 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8043 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
8044 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
8045 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
8046 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
8047 GeomXYZ[j].ResidueNumber=0;
8048 if(Units == 1 )
8049 {
8050 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
8051 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
8052 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
8053 }
8054 else
8055 {
8056 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
8057 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
8058 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
8059 }
8060 GeomXYZ[j].Charge=g_strdup("0.0");
8061 GeomXYZ[j].Layer=g_strdup(" ");
8062 }
8063
8064 NcentersXYZ = j+1;
8065 if(OK)
8066 break;
8067 }while(!feof(fd));
8068
8069 fclose(fd);
8070 g_free(t);
8071 calculMMTypes(FALSE);
8072 for(i=0;i<5;i++)
8073 g_free(AtomCoord[i]);
8074 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
8075 {
8076 clearList(list);
8077 append_list();
8078 }
8079 MethodeGeom = GEOM_IS_XYZ;
8080 if(GeomDrawingArea != NULL)
8081 rafresh_drawing();
8082 if(iprogram == PROG_IS_GAUSS && GeomIsOpen)
8083 set_spin_of_electrons();
8084 }
8085 /********************************************************************************/
read_last_gaussian_file(GabeditFileChooser * SelecFile,gint response_id)8086 void read_last_gaussian_file(GabeditFileChooser *SelecFile , gint response_id)
8087 {
8088 gchar *t;
8089 gchar *NomFichier;
8090 gboolean OK;
8091 gchar *AtomCoord[5];
8092 FILE *fd;
8093 guint taille=BSIZE;
8094 guint idummy;
8095 guint i;
8096 gint j=0;
8097 gint l;
8098 guint numgeom;
8099 gchar *pdest;
8100 guint itype=0;
8101 gchar* strInput = "Input orientation:";
8102 gchar* strStand = "Standard orientation:";
8103 gchar* strSearch = strInput;
8104
8105 if(response_id != GTK_RESPONSE_OK) return;
8106 for(i=0;i<5;i++)
8107 AtomCoord[i]=g_malloc(taille*sizeof(char));
8108 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
8109
8110 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
8111 {
8112 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
8113 return ;
8114 }
8115
8116 t=g_malloc(taille);
8117 fd = FOpen(NomFichier, "rb");
8118 if(fd ==NULL)
8119 {
8120 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
8121 return;
8122 }
8123 while(!feof(fd)){
8124 if(!fgets(t,taille,fd))break;
8125 if(strstr(t,strStand))
8126 {
8127 strSearch = strStand;
8128 break;
8129 }
8130 }
8131 fseek(fd, 0, SEEK_SET);
8132 numgeom =1;
8133 do
8134 {
8135 OK=FALSE;
8136 while(!feof(fd)){
8137 { char* e = fgets(t,taille,fd);}
8138 if(strstr(t,"Charge =") && strstr(t,"Multiplicity ="))
8139 {
8140 gchar* p = strstr(t,"Charge =")+8;
8141 TotalCharges[0] = atoi(p);
8142 p = strstr(t,"Multiplicity =")+14;
8143 SpinMultiplicities[0] = atoi(p);
8144 }
8145 if ( strstr( t, strSearch))
8146 {
8147 { char* e = fgets(t,taille,fd);}
8148 { char* e = fgets(t,taille,fd);}
8149 { char* e = fgets(t,taille,fd);}
8150 if(strstr( t, "Type" ))
8151 itype=1;
8152 else
8153 itype=0;
8154 { char* e = fgets(t,taille,fd);}
8155 numgeom++;
8156 OK = TRUE;
8157 break;
8158 }
8159 }
8160 if(!OK && (numgeom == 1) ){
8161 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
8162 return;
8163 }
8164 if(!OK)break;
8165
8166 j=-1;
8167 while(!feof(fd) )
8168 {
8169 { char* e = fgets(t,taille,fd);}
8170 if (strstr( t, "----------------------------------" ))
8171 {
8172 long geomposok = ftell(fd);
8173 get_dipole_from_gaussian_output_file(fd);
8174 fseek(fd, geomposok, SEEK_SET);
8175 get_charges_from_gaussian_output_file(fd,j+1);
8176 get_natural_charges_from_gaussian_output_file(fd,j+1);
8177 fseek(fd, geomposok, SEEK_SET);
8178 get_esp_charges_from_gaussian_output_file(fd,j+1);
8179 fseek(fd, geomposok, SEEK_SET);
8180 break;
8181 }
8182 j++;
8183
8184 if(GeomXYZ==NULL)
8185 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8186 else
8187 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8188 GeomXYZ[j].typeConnections = NULL;
8189
8190 if(itype==0)
8191 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
8192 else
8193 sscanf(t,"%d %s %d %s %s %s",&idummy,AtomCoord[0],&idummy,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
8194 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
8195 l=strlen(AtomCoord[0]);
8196 if (l==2)
8197 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
8198
8199 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8200 GeomXYZ[j].Symb=g_strdup(symb_atom_get((guint)atoi(AtomCoord[0])));
8201 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
8202 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
8203 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
8204 GeomXYZ[j].ResidueNumber=0;
8205 if(Units == 0 )
8206 {
8207 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
8208 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
8209 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
8210 }
8211 else
8212 {
8213 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
8214 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
8215 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
8216 }
8217 GeomXYZ[j].Charge=g_strdup("0.0");
8218 GeomXYZ[j].Layer=g_strdup(" ");
8219 }
8220
8221 NcentersXYZ = j+1;
8222 }while(!feof(fd));
8223
8224 fclose(fd);
8225 calculMMTypes(FALSE);
8226
8227 g_free(t);
8228 for(i=0;i<5;i++)
8229 g_free(AtomCoord[i]);
8230 if(GeomIsOpen)
8231 {
8232 append_list();
8233 }
8234 if(GeomDrawingArea != NULL)
8235 rafresh_drawing();
8236 if(iprogram == PROG_IS_GAUSS)
8237 set_spin_of_electrons();
8238 set_last_directory(NomFichier);
8239 }
8240 /********************************************************************************/
read_first_gaussian_file(GabeditFileChooser * SelecFile,gint response_id)8241 void read_first_gaussian_file(GabeditFileChooser *SelecFile, gint response_id)
8242 {
8243 gchar *t;
8244 gchar *NomFichier;
8245 gboolean OK;
8246 gchar *AtomCoord[5];
8247 FILE *fd;
8248 guint taille=BSIZE;
8249 guint idummy;
8250 guint i;
8251 gint j=0;
8252 gint l;
8253 gchar *pdest;
8254 guint itype=0;
8255 gchar* strInput = "Input orientation:";
8256 gchar* strStand = "Standard orientation:";
8257 gchar* strSearch = strInput;
8258
8259 if(response_id != GTK_RESPONSE_OK) return;
8260
8261 for(i=0;i<5;i++)
8262 AtomCoord[i]=g_malloc(taille*sizeof(char));
8263 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
8264
8265 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
8266 {
8267 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
8268 return ;
8269 }
8270
8271 t=g_malloc(taille);
8272 fd = FOpen(NomFichier, "rb");
8273 if(fd ==NULL)
8274 {
8275 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
8276 return;
8277 }
8278 while(!feof(fd)){
8279 if(!fgets(t,taille,fd))break;
8280 if(strstr(t,strStand))
8281 {
8282 strSearch = strStand;
8283 break;
8284 }
8285 }
8286 fseek(fd, 0, SEEK_SET);
8287 OK=FALSE;
8288 while(!feof(fd)){
8289 { char* e = fgets(t,taille,fd);}
8290 if(strstr(t,"Charge =") && strstr(t,"Multiplicity ="))
8291 {
8292 gchar* p = strstr(t,"Charge =")+8;
8293 TotalCharges[0] = atoi(p);
8294 p = strstr(t,"Multiplicity =")+14;
8295 SpinMultiplicities[0] = atoi(p);
8296 }
8297 if (strstr( t, strSearch ) )
8298 {
8299 { char* e = fgets(t,taille,fd);}
8300 { char* e = fgets(t,taille,fd);}
8301 { char* e = fgets(t,taille,fd);}
8302 if(strstr( t, "Type" ))
8303 itype=1;
8304 else
8305 itype=0;
8306
8307 { char* e = fgets(t,taille,fd);}
8308 OK = TRUE;
8309 break;
8310 }
8311 }
8312 if(!OK){
8313 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
8314 return;
8315 }
8316
8317 j=-1;
8318 while(!feof(fd) )
8319 {
8320 { char* e = fgets(t,taille,fd);}
8321 if (strstr( t, "----------------------------------" ))
8322 {
8323 long geomposok = ftell(fd);
8324 get_dipole_from_gaussian_output_file(fd);
8325 fseek(fd, geomposok, SEEK_SET);
8326 get_charges_from_gaussian_output_file(fd,j+1);
8327 get_natural_charges_from_gaussian_output_file(fd,j+1);
8328 fseek(fd, geomposok, SEEK_SET);
8329 get_esp_charges_from_gaussian_output_file(fd,j+1);
8330 break;
8331 }
8332 j++;
8333 if(GeomXYZ==NULL)GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8334 else
8335 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8336 GeomXYZ[j].typeConnections = NULL;
8337
8338 if(itype==0)
8339 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
8340 else
8341 sscanf(t,"%d %s %d %s %s %s",&idummy,AtomCoord[0],&idummy,AtomCoord[1],AtomCoord[2],AtomCoord[3]);
8342 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
8343 l=strlen(AtomCoord[0]);
8344 if (l==2)
8345 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
8346 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8347 GeomXYZ[j].Symb=g_strdup(symb_atom_get((guint)atoi(AtomCoord[0])));
8348 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
8349 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
8350 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
8351 GeomXYZ[j].ResidueNumber=0;
8352 if(Units == 0 )
8353 {
8354 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
8355 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
8356 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
8357 }
8358 else
8359 {
8360 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
8361 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
8362 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
8363 }
8364 GeomXYZ[j].Charge=g_strdup("0.0");
8365 GeomXYZ[j].Layer=g_strdup(" ");
8366 }
8367
8368 fclose(fd);
8369 calculMMTypes(FALSE);
8370 NcentersXYZ = j+1;
8371 g_free(t);
8372 for(i=0;i<5;i++)
8373 g_free(AtomCoord[i]);
8374 if(GeomIsOpen)
8375 {
8376 append_list();
8377 }
8378
8379 if(GeomDrawingArea != NULL)
8380 rafresh_drawing();
8381 if(iprogram == PROG_IS_GAUSS)
8382 set_spin_of_electrons();
8383 set_last_directory(NomFichier);
8384 }
8385 /********************************************************************************/
read_fchk_gaussian_file(GabeditFileChooser * SelecFile,gint response_id)8386 void read_fchk_gaussian_file(GabeditFileChooser *SelecFile , gint response_id)
8387 {
8388 gchar *fileName;
8389 FILE *file;
8390 gint i,j;
8391 gint *z = NULL;
8392 gdouble* coords = NULL;
8393 gdouble* charges = NULL;
8394 gdouble* dipole = NULL;
8395 gint n;
8396
8397 if(response_id != GTK_RESPONSE_OK) return;
8398
8399 fileName = gabedit_file_chooser_get_current_file(SelecFile);
8400 if ((!fileName) || (strcmp(fileName,"") == 0))
8401 {
8402 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
8403 return ;
8404 }
8405 file = FOpen(fileName, "rb");
8406 if(file ==NULL)
8407 {
8408 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
8409 return;
8410 }
8411
8412 i = get_one_int_from_fchk_gaussian_file(file,"Multiplicity ");
8413 if(i<1)
8414 {
8415 MessageGeom(_("Sorry\nI can not the multiplicity from this file"),_("Error"),TRUE);
8416 return;
8417 }
8418 rewind(file);
8419 j = get_one_int_from_fchk_gaussian_file(file,"Number of atoms ");
8420 if(j<1)
8421 {
8422 MessageGeom(_("Sorry\nI can not the number of atoms from this file"),_("Error"),TRUE);
8423 return;
8424 }
8425
8426 SpinMultiplicities[0] = i;
8427 rewind(file);
8428 z = get_array_int_from_fchk_gaussian_file(file, "Atomic numbers ", &n);
8429 if(n!=j)
8430 {
8431 MessageGeom(_("Sorry\nI can not read the atomic numbers from this file"),_("Error"),TRUE);
8432 return;
8433 }
8434 rewind(file);
8435 coords = get_array_real_from_fchk_gaussian_file(file, "Current cartesian coordinates ", &n);
8436 if(n!=3*j)
8437 {
8438 MessageGeom(_("Sorry\nI can not read the current cartesian coordinates from this file"),_("Error"),TRUE);
8439 return;
8440 }
8441 rewind(file);
8442 TotalCharges[0] = get_one_int_from_fchk_gaussian_file(file,"Charge ");
8443 NcentersXYZ = j;
8444
8445 GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
8446 for(j=0;j<NcentersXYZ;j++)
8447 {
8448 GeomXYZ[j].typeConnections = NULL;
8449 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8450 GeomXYZ[j].Symb=g_strdup(symb_atom_get(z[j]));
8451 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
8452 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
8453 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
8454 GeomXYZ[j].ResidueNumber=0;
8455 if(Units == 0 )
8456 {
8457 GeomXYZ[j].X=g_strdup_printf("%0.20lf",coords[j*3]);
8458 GeomXYZ[j].Y=g_strdup_printf("%0.20lf",coords[j*3+1]);
8459 GeomXYZ[j].Z=g_strdup_printf("%0.20lf",coords[j*3+2]);
8460 }
8461 else
8462 {
8463 GeomXYZ[j].X=g_strdup_printf("%0.20lf",coords[j*3]*BOHR_TO_ANG);
8464 GeomXYZ[j].Y=g_strdup_printf("%0.20lf",coords[j*3+1]*BOHR_TO_ANG);
8465 GeomXYZ[j].Z=g_strdup_printf("%0.20lf",coords[j*3+2]*BOHR_TO_ANG);
8466 }
8467 GeomXYZ[j].Charge=g_strdup("0.0");
8468 GeomXYZ[j].Layer=g_strdup(" ");
8469 }
8470 if(z) g_free(z);
8471 if(coords) g_free(coords);
8472 z = NULL;
8473 coords = NULL;
8474 rewind(file);
8475 charges = get_array_real_from_fchk_gaussian_file(file, "NPA Charges ", &n);
8476 if(n==NcentersXYZ && charges)
8477 {
8478 for(j=0;j<NcentersXYZ;j++)
8479 GeomXYZ[j].Charge = g_strdup_printf("%14.8f",charges[j]);
8480
8481 }
8482 else
8483 {
8484 rewind(file);
8485 charges = get_array_real_from_fchk_gaussian_file(file, "ESP Charges ", &n);
8486 if(n==NcentersXYZ && charges)
8487 {
8488 for(j=0;j<NcentersXYZ;j++)
8489 GeomXYZ[j].Charge = g_strdup_printf("%14.8f",charges[j]);
8490 }
8491 else
8492 {
8493 rewind(file);
8494 charges = get_array_real_from_fchk_gaussian_file(file, "Mulliken Charges ", &n);
8495 if(n==NcentersXYZ && charges)
8496 {
8497 for(j=0;j<NcentersXYZ;j++)
8498 GeomXYZ[j].Charge = g_strdup_printf("%14.8f",charges[j]);
8499 }
8500 if(charges) g_free(charges);
8501 }
8502 }
8503 rewind(file);
8504 dipole = get_array_real_from_fchk_gaussian_file(file, "Dipole Moment ", &n);
8505 init_dipole();
8506 if(n==3)
8507 {
8508 for(i=0;i<3;i++) Dipole.value[i] = dipole[i] / AUTODEB;
8509 Dipole.def = TRUE;
8510
8511 }
8512 if(dipole) g_free(dipole);
8513 fclose(file);
8514 calculMMTypes(FALSE);
8515 if(GeomIsOpen) append_list();
8516 if(GeomDrawingArea != NULL) rafresh_drawing();
8517 if(iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
8518 set_last_directory(fileName);
8519 }
8520 /********************************************************************************/
read_last_molcas_file(GabeditFileChooser * SelecFile,gint response_id)8521 void read_last_molcas_file(GabeditFileChooser *SelecFile , gint response_id)
8522 {
8523 gchar t[BSIZE];
8524 gchar *NomFichier;
8525 gboolean OK;
8526 gchar symb[100];
8527 gchar x[100];
8528 gchar y[100];
8529 gchar z[100];
8530 FILE *file;
8531 guint idummy;
8532 gint i;
8533 gint j=0;
8534 gint l;
8535 gint numgeom = 0;
8536
8537 if(response_id != GTK_RESPONSE_OK) return;
8538 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
8539
8540 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
8541 {
8542 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
8543 return ;
8544 }
8545
8546 file = FOpen(NomFichier, "rb");
8547 if(file ==NULL)
8548 {
8549 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
8550 return;
8551 }
8552 numgeom = 0;
8553 do{
8554 OK=FALSE;
8555 while(!feof(file))
8556 {
8557 { char* e = fgets(t,BSIZE,file);}
8558 if (strstr(t," Cartesian coordinates:"))
8559 {
8560 { char* e = fgets(t,BSIZE,file);}
8561 { char* e = fgets(t,BSIZE,file);}
8562 { char* e = fgets(t,BSIZE,file);}
8563 numgeom++;
8564 OK = TRUE;
8565 break;
8566 }
8567 }
8568 if(!OK && numgeom==0)
8569 {
8570 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
8571 return;
8572 }
8573 if(!OK) break;
8574
8575 j=-1;
8576 while(!feof(file) )
8577 {
8578 { char* e = fgets(t,BSIZE,file);}
8579 if (strstr(t,"-----------------------------------------"))
8580 {
8581 /*
8582 get_dipole_from_molcas_output_file(file);
8583 */
8584 break;
8585 }
8586 j++;
8587 if(GeomXYZ==NULL)GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8588 else
8589 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8590 GeomXYZ[j].typeConnections = NULL;
8591
8592 sscanf(t,"%d %s %s %s %s",&idummy,symb,x,y,z);
8593
8594 for(i=0;i<(gint)strlen(symb);i++)
8595 if(isdigit(symb[i])) symb[i] = ' ';
8596 delete_all_spaces(symb);
8597
8598 symb[0]=toupper(symb[0]);
8599 l=strlen(symb);
8600 for(i=1;i<l;i++)
8601 symb[i]=tolower(symb[i]);
8602
8603 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8604 GeomXYZ[j].Symb=g_strdup(symb);
8605 GeomXYZ[j].mmType=g_strdup(symb);
8606 GeomXYZ[j].pdbType=g_strdup(symb);
8607 GeomXYZ[j].Residue=g_strdup(symb);
8608 GeomXYZ[j].ResidueNumber=0;
8609 if(Units == 1 )
8610 {
8611 GeomXYZ[j].X=g_strdup(bohr_to_ang(x));
8612 GeomXYZ[j].Y=g_strdup(bohr_to_ang(y));
8613 GeomXYZ[j].Z=g_strdup(bohr_to_ang(z));
8614 }
8615 else
8616 {
8617 GeomXYZ[j].X=g_strdup(x);
8618 GeomXYZ[j].Y=g_strdup(y);
8619 GeomXYZ[j].Z=g_strdup(z);
8620 }
8621 GeomXYZ[j].Charge=g_strdup("0.0");
8622 GeomXYZ[j].Layer=g_strdup(" ");
8623 }
8624 NcentersXYZ = j+1;
8625 }while(!feof(file));
8626 fclose(file);
8627 calculMMTypes(FALSE);
8628
8629 if(GeomIsOpen)
8630 {
8631 append_list();
8632 }
8633 if(GeomDrawingArea != NULL) rafresh_drawing();
8634 if(iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
8635 set_last_directory(NomFichier);
8636 }
8637 /********************************************************************************/
read_last_molpro_file(GabeditFileChooser * SelecFile,gint response_id)8638 void read_last_molpro_file(GabeditFileChooser *SelecFile , gint response_id)
8639 {
8640 gchar *t;
8641 gchar *NomFichier;
8642 gboolean OK;
8643 gchar *AtomCoord[5];
8644 FILE *fd;
8645 guint taille=BSIZE;
8646 guint idummy;
8647 guint i;
8648 gint j=0;
8649 gint l;
8650 guint numgeom;
8651
8652 if(response_id != GTK_RESPONSE_OK) return;
8653 for(i=0;i<5;i++)
8654 AtomCoord[i]=g_malloc(taille*sizeof(char));
8655 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
8656
8657 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
8658 {
8659 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
8660 return ;
8661 }
8662
8663 t=g_malloc(taille);
8664 fd = FOpen(NomFichier, "rb");
8665 if(fd ==NULL)
8666 {
8667 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
8668 return;
8669 }
8670 numgeom =1;
8671 do
8672 {
8673 OK=FALSE;
8674 while(!feof(fd)){
8675 { char* e = fgets(t,BSIZE,fd);}
8676 if ( !strcmp(t," ATOMIC COORDINATES\n"))
8677 {
8678 { char* e = fgets(t,BSIZE,fd);}
8679 { char* e = fgets(t,BSIZE,fd);}
8680 { char* e = fgets(t,BSIZE,fd);}
8681 numgeom++;
8682 OK = TRUE;
8683 break;
8684 }
8685 }
8686 if(!OK && (numgeom == 1) ){
8687 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
8688 return;
8689 }
8690 if(!OK)break;
8691
8692 j=-1;
8693 while(!feof(fd) )
8694 {
8695 { char* e = fgets(t,BSIZE,fd);}
8696 if ( !strcmp(t,"\n"))
8697 {
8698 get_dipole_from_molpro_output_file(fd);
8699 break;
8700 }
8701 j++;
8702
8703 if(GeomXYZ==NULL)
8704 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8705 else
8706 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8707 GeomXYZ[j].typeConnections = NULL;
8708 sscanf(t,"%d %s %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[1],
8709 AtomCoord[2],AtomCoord[3]);
8710
8711 {
8712 gint k;
8713 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
8714 delete_all_spaces(AtomCoord[0]);
8715 }
8716
8717 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
8718 l=strlen(AtomCoord[0]);
8719 if (l==2)
8720 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
8721 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8722 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
8723 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
8724 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
8725 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
8726 GeomXYZ[j].ResidueNumber=0;
8727 if(Units == 1 )
8728 {
8729 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
8730 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
8731 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
8732 }
8733 else
8734 {
8735 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
8736 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
8737 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
8738 }
8739 GeomXYZ[j].Charge=g_strdup("0.0");
8740 GeomXYZ[j].Layer=g_strdup(" ");
8741 }
8742
8743 NcentersXYZ = j+1;
8744 }while(!feof(fd));
8745
8746 fclose(fd);
8747 calculMMTypes(FALSE);
8748 g_free(t);
8749 for(i=0;i<5;i++)
8750 g_free(AtomCoord[i]);
8751 if(GeomIsOpen)
8752 {
8753 append_list();
8754 }
8755 if(GeomDrawingArea != NULL)
8756 rafresh_drawing();
8757 if(iprogram == PROG_IS_GAUSS)
8758 set_spin_of_electrons();
8759
8760 set_last_directory(NomFichier);
8761 }
8762 /********************************************************************************/
get_charges_from_qchem_output_file(FILE * fd,gint N)8763 void get_charges_from_qchem_output_file(FILE* fd,gint N)
8764 {
8765 guint taille=BSIZE;
8766 gchar t[BSIZE];
8767 gchar dump[BSIZE];
8768 gchar d[BSIZE];
8769 gchar* pdest;
8770 gint i;
8771 gint ngrad=0;
8772
8773
8774 for(i=0;i<N;i++)
8775 GeomXYZ[i].Charge = g_strdup("0.0");
8776
8777 while(!feof(fd) )
8778 {
8779 pdest = NULL;
8780 { char* e = fgets(t,taille,fd);}
8781 pdest = strstr( t, "Mulliken Net Atomic Charges");
8782
8783 if(pdest)
8784 {
8785 gboolean OK = FALSE;
8786 while(!feof(fd) )
8787 {
8788 if(!fgets(t,taille,fd)) break;
8789 if(strstr(t,"----------------"))
8790 {
8791 OK = TRUE;
8792 break;
8793 }
8794 }
8795 if(!OK) break;
8796
8797 for(i=0;i<N;i++)
8798 {
8799 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
8800 else break;
8801 if(sscanf(t,"%s %s %s",dump,dump,d)==3)
8802 {
8803 g_free(GeomXYZ[i].Charge);
8804 GeomXYZ[i].Charge = g_strdup(d);
8805 }
8806 }
8807 break;
8808 }
8809 else
8810 {
8811 pdest = strstr( t, "GradGradGrad" );
8812 if(pdest)
8813 {
8814 ngrad++;
8815 }
8816 if(ngrad>2)
8817 break;
8818 }
8819
8820 }
8821 }
8822 /********************************************************************************/
read_geom_from_qchem_file(gchar * NomFichier,gint numgeometry)8823 void read_geom_from_qchem_file(gchar *NomFichier, gint numgeometry)
8824 {
8825 gchar *t;
8826 gchar *AtomCoord[5];
8827 FILE *fd;
8828 guint taille=BSIZE;
8829 guint idummy;
8830 guint i;
8831 gint j=0;
8832 gint l;
8833 gint numgeom;
8834 gchar *pdest;
8835 long int geomposok = 0;
8836
8837 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
8838
8839 t=g_malloc(taille*sizeof(gchar));
8840 fd = FOpen(NomFichier, "rb");
8841 if(fd ==NULL)
8842 {
8843 g_free(t);
8844 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
8845 MessageGeom(t,_("Error"),TRUE);
8846 g_free(t);
8847 return;
8848 }
8849 numgeom =0;
8850 while(!feof(fd))
8851 {
8852 if(!fgets(t,taille,fd))break;
8853 pdest = NULL;
8854 if(( strstr( t,"Atom") || strstr( t,"ATOM")) && strstr( t,"X") && strstr( t,"Y") && strstr( t,"Z"))
8855 {
8856 if(strstr( t,"Atom")) if(!fgets(t,taille,fd))break; /* ---- ligne */
8857 pdest = t;
8858 }
8859 if ( pdest )
8860 {
8861 numgeom++;
8862 geomposok = ftell(fd);
8863 if(numgeom == numgeometry )
8864 {
8865 break;
8866 }
8867 }
8868 }
8869 if(numgeom == 0)
8870 {
8871 g_free(t);
8872 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
8873 MessageGeom(t,_("Error"),TRUE);
8874 g_free(t);
8875 return;
8876 }
8877 j=-1;
8878 fseek(fd, geomposok, SEEK_SET);
8879 while(!feof(fd) )
8880 {
8881 if(!fgets(t,taille,fd))break;
8882 if (atoi(t)<1)
8883 {
8884 geomposok = ftell(fd);
8885 get_charges_from_qchem_output_file(fd,j+1);
8886 fseek(fd, geomposok, SEEK_SET);
8887 get_dipole_from_qchem_output_file(fd);
8888 break;
8889 }
8890 j++;
8891 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
8892 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
8893 GeomXYZ[j].typeConnections = NULL;
8894
8895 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
8896 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
8897 l=strlen(AtomCoord[0]);
8898 if(isdigit(AtomCoord[0][1]))l=1;
8899 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
8900 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
8901 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
8902
8903 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
8904 GeomXYZ[j].Symb=g_strdup(t);
8905 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
8906 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
8907 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
8908 GeomXYZ[j].ResidueNumber=0;
8909 if(Units == 0 )
8910 {
8911 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
8912 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
8913 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
8914 }
8915 else
8916 {
8917 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
8918 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
8919 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
8920 }
8921 GeomXYZ[j].Charge=g_strdup("0.0");
8922 GeomXYZ[j].Layer=g_strdup(" ");
8923 }
8924 NcentersXYZ = j+1;
8925
8926 fclose(fd);
8927 calculMMTypes(FALSE);
8928 g_free(t);
8929 for(i=0;i<5;i++) g_free(AtomCoord[i]);
8930 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
8931 {
8932 clearList(list);
8933 append_list();
8934 }
8935 MethodeGeom = GEOM_IS_XYZ;
8936 if(GeomDrawingArea != NULL) rafresh_drawing();
8937 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
8938 }
8939 /********************************************************************************/
get_charges_from_nwchem_output_file(FILE * fd,gint N)8940 void get_charges_from_nwchem_output_file(FILE* fd,gint N)
8941 {
8942 guint taille=BSIZE;
8943 gchar t[BSIZE];
8944 gchar d3[BSIZE];
8945 gchar d4[BSIZE];
8946 gchar d[BSIZE];
8947 gchar* pdest;
8948 gint i;
8949
8950
8951 for(i=0;i<N;i++)
8952 GeomXYZ[i].Charge = g_strdup("0.0");
8953
8954 while(!feof(fd) )
8955 {
8956 pdest = NULL;
8957 { char* e = fgets(t,taille,fd);}
8958 pdest = strstr( t, "Atom Charge Shell Charges");
8959
8960 if(pdest)
8961 {
8962 gboolean OK = FALSE;
8963 while(!feof(fd) )
8964 {
8965 if(!fgets(t,taille,fd)) break;
8966 if(strstr(t,"----------------"))
8967 {
8968 OK = TRUE;
8969 break;
8970 }
8971 }
8972 if(!OK) break;
8973
8974 for(i=0;i<N;i++)
8975 {
8976 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
8977 else break;
8978 if(sscanf(t,"%s %s %s %s",d,d,d3,d4)==4)
8979 {
8980 g_free(GeomXYZ[i].Charge);
8981 GeomXYZ[i].Charge = g_strdup_printf("%f",atof(d3)-atof(d4));
8982 }
8983 }
8984 break;
8985 }
8986 }
8987 }
8988 /********************************************************************************/
read_geom_from_nwchem_file(gchar * NomFichier,gint numgeometry)8989 void read_geom_from_nwchem_file(gchar *NomFichier, gint numgeometry)
8990 {
8991 gchar *t;
8992 gchar *AtomCoord[5];
8993 FILE *fd;
8994 guint taille=BSIZE;
8995 guint idummy;
8996 guint i;
8997 gint j=0;
8998 gint l;
8999 gint numgeom;
9000 gchar *pdest;
9001 long int geomposok = 0;
9002 gboolean ang = FALSE;
9003
9004 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9005
9006 t=g_malloc(taille*sizeof(gchar));
9007 fd = FOpen(NomFichier, "rb");
9008 if(fd ==NULL)
9009 {
9010 g_free(t);
9011 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
9012 MessageGeom(t,_("Error"),TRUE);
9013 g_free(t);
9014 return;
9015 }
9016 numgeom =0;
9017 while(!feof(fd))
9018 {
9019 if(!fgets(t,taille,fd))break;
9020 if(strstr(t,"Output coordinates in angstroms ")) ang = TRUE;
9021 if(strstr(t,"Output coordinates in a.u.")) ang = FALSE;
9022 pdest = strstr( t, "Charge X Y Z");
9023 if(pdest)
9024 {
9025 if(!fgets(t,taille,fd))break;
9026 pdest = strstr( t, "--------------");
9027 }
9028 if ( pdest )
9029 {
9030 numgeom++;
9031 geomposok = ftell(fd);
9032 if(numgeom == numgeometry )
9033 {
9034 break;
9035 }
9036 }
9037 }
9038 if(numgeom == 0)
9039 {
9040 g_free(t);
9041 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
9042 MessageGeom(t,_("Error"),TRUE);
9043 g_free(t);
9044 return;
9045 }
9046 j=-1;
9047 fseek(fd, geomposok, SEEK_SET);
9048 while(!feof(fd) )
9049 {
9050 if(!fgets(t,taille,fd))break;
9051 if(this_is_a_backspace(t))
9052 {
9053 geomposok = ftell(fd);
9054 get_charges_from_nwchem_output_file(fd,j+1);
9055 fseek(fd, geomposok, SEEK_SET);
9056 get_dipole_from_nwchem_output_file(fd);
9057 break;
9058 }
9059 j++;
9060 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
9061 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
9062 GeomXYZ[j].typeConnections = NULL;
9063
9064 sscanf(t,"%d %s %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
9065 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
9066 l=strlen(AtomCoord[0]);
9067 if(isdigit(AtomCoord[0][1]))l=1;
9068 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
9069 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
9070 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
9071
9072 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
9073 GeomXYZ[j].Symb=g_strdup(t);
9074 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
9075 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
9076 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
9077 GeomXYZ[j].ResidueNumber=0;
9078
9079 if(!ang )
9080 {
9081 AtomCoord[1] = bohr_to_ang(AtomCoord[1]);
9082 AtomCoord[2] = bohr_to_ang(AtomCoord[2]);
9083 AtomCoord[3] = bohr_to_ang(AtomCoord[3]);
9084 }
9085
9086 if(Units == 0 )
9087 {
9088 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
9089 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
9090 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
9091 }
9092 else
9093 {
9094 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
9095 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
9096 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
9097 }
9098 GeomXYZ[j].Charge=g_strdup("0.0");
9099 GeomXYZ[j].Layer=g_strdup(" ");
9100 }
9101 NcentersXYZ = j+1;
9102
9103 fclose(fd);
9104 calculMMTypes(FALSE);
9105 g_free(t);
9106 for(i=0;i<5;i++) g_free(AtomCoord[i]);
9107 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
9108 {
9109 clearList(list);
9110 append_list();
9111 }
9112 MethodeGeom = GEOM_IS_XYZ;
9113 if(GeomDrawingArea != NULL) rafresh_drawing();
9114 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
9115 }
9116 /********************************************************************************/
get_charges_from_psicode_output_file(FILE * fd,gint N)9117 void get_charges_from_psicode_output_file(FILE* fd,gint N)
9118 {
9119 guint taille=BSIZE;
9120 gchar t[BSIZE];
9121 gchar d3[BSIZE];
9122 gchar d4[BSIZE];
9123 gchar d[BSIZE];
9124 gchar* pdest;
9125 gint i;
9126
9127
9128 for(i=0;i<N;i++)
9129 GeomXYZ[i].Charge = g_strdup("0.0");
9130
9131 while(!feof(fd) )
9132 {
9133 pdest = NULL;
9134 { char* e = fgets(t,taille,fd);}
9135 pdest = strstr( t, "Atom Charge Shell Charges");
9136
9137 if(pdest)
9138 {
9139 gboolean OK = FALSE;
9140 while(!feof(fd) )
9141 {
9142 if(!fgets(t,taille,fd)) break;
9143 if(strstr(t,"----------------"))
9144 {
9145 OK = TRUE;
9146 break;
9147 }
9148 }
9149 if(!OK) break;
9150
9151 for(i=0;i<N;i++)
9152 {
9153 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
9154 else break;
9155 if(sscanf(t,"%s %s %s %s",d,d,d3,d4)==4)
9156 {
9157 g_free(GeomXYZ[i].Charge);
9158 GeomXYZ[i].Charge = g_strdup_printf("%f",atof(d3)-atof(d4));
9159 }
9160 }
9161 break;
9162 }
9163 }
9164 }
9165 /********************************************************************************/
read_geom_from_psicode_file(gchar * NomFichier,gint numgeometry)9166 void read_geom_from_psicode_file(gchar *NomFichier, gint numgeometry)
9167 {
9168 gchar *t;
9169 gchar *AtomCoord[5];
9170 FILE *fd;
9171 guint taille=BSIZE;
9172 guint idummy;
9173 guint i;
9174 gint j=0;
9175 gint l;
9176 gint numgeom;
9177 gchar *pdest;
9178 long int geomposok = 0;
9179 gboolean ang = TRUE;
9180
9181 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9182
9183 t=g_malloc(taille*sizeof(gchar));
9184 fd = FOpen(NomFichier, "rb");
9185 if(fd ==NULL)
9186 {
9187 g_free(t);
9188 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
9189 MessageGeom(t,_("Error"),TRUE);
9190 g_free(t);
9191 return;
9192 }
9193 numgeom =0;
9194 while(!feof(fd))
9195 {
9196 if(!fgets(t,taille,fd))break;
9197 pdest = strstr( t, "Geometry (in Angstrom),");
9198 if(pdest)
9199 {
9200 if(!fgets(t,taille,fd))break;
9201 if(!fgets(t,taille,fd))break;
9202 pdest = strstr( t, "Center X Y Z");
9203 }
9204
9205 if(pdest)
9206 {
9207 if(!fgets(t,taille,fd))break;
9208 pdest = strstr( t, "--------------");
9209 }
9210 if ( pdest )
9211 {
9212 numgeom++;
9213 geomposok = ftell(fd);
9214 if(numgeom == numgeometry )
9215 {
9216 break;
9217 }
9218 }
9219 }
9220 if(numgeom == 0)
9221 {
9222 g_free(t);
9223 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
9224 MessageGeom(t,_("Error"),TRUE);
9225 g_free(t);
9226 return;
9227 }
9228 j=-1;
9229 fseek(fd, geomposok, SEEK_SET);
9230 while(!feof(fd) )
9231 {
9232 if(!fgets(t,taille,fd))break;
9233 if(this_is_a_backspace(t))
9234 {
9235 geomposok = ftell(fd);
9236 get_charges_from_psicode_output_file(fd,j+1);
9237 fseek(fd, geomposok, SEEK_SET);
9238 get_dipole_from_psicode_output_file(fd);
9239 break;
9240 }
9241 j++;
9242 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
9243 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
9244 GeomXYZ[j].typeConnections = NULL;
9245
9246 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
9247 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
9248 l=strlen(AtomCoord[0]);
9249 if(isdigit(AtomCoord[0][1]))l=1;
9250 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
9251 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
9252 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
9253
9254 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
9255 GeomXYZ[j].Symb=g_strdup(t);
9256 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
9257 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
9258 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
9259 GeomXYZ[j].ResidueNumber=0;
9260
9261 if(!ang )
9262 {
9263 AtomCoord[1] = bohr_to_ang(AtomCoord[1]);
9264 AtomCoord[2] = bohr_to_ang(AtomCoord[2]);
9265 AtomCoord[3] = bohr_to_ang(AtomCoord[3]);
9266 }
9267
9268 if(Units == 0 )
9269 {
9270 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
9271 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
9272 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
9273 }
9274 else
9275 {
9276 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
9277 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
9278 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
9279 }
9280 GeomXYZ[j].Charge=g_strdup("0.0");
9281 GeomXYZ[j].Layer=g_strdup(" ");
9282 }
9283 NcentersXYZ = j+1;
9284
9285 fclose(fd);
9286 calculMMTypes(FALSE);
9287 g_free(t);
9288 for(i=0;i<5;i++) g_free(AtomCoord[i]);
9289 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
9290 {
9291 clearList(list);
9292 append_list();
9293 }
9294 MethodeGeom = GEOM_IS_XYZ;
9295 if(GeomDrawingArea != NULL) rafresh_drawing();
9296 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
9297 }
9298 /********************************************************************************/
get_esp_charges_from_mopac_output_file(FILE * fd,gint N)9299 void get_esp_charges_from_mopac_output_file(FILE* fd,gint N)
9300 {
9301 guint taille=BSIZE;
9302 gchar t[BSIZE];
9303 gchar dump[BSIZE];
9304 gchar d[BSIZE];
9305 gchar* pdest;
9306 gint i;
9307
9308
9309 /* printf("NAtoms = %d\n",N);*/
9310 /* for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");*/
9311
9312 while(!feof(fd) )
9313 {
9314 pdest = NULL;
9315 if(!fgets(t,taille,fd)) break;
9316 pdest = strstr( t, "ELECTROSTATIC POTENTIAL CHARGES");
9317
9318 if(pdest)
9319 {
9320 if(!fgets(t,taille,fd)) break;
9321 if(!fgets(t,taille,fd)) break;
9322 for(i=0;i<N;i++)
9323 {
9324 if(!fgets(t,taille,fd)) break;
9325 if(sscanf(t,"%s %s %s",dump, dump , d)==3)
9326 {
9327 if(GeomXYZ[i].Charge) g_free(GeomXYZ[i].Charge);
9328 GeomXYZ[i].Charge = g_strdup(d);
9329 }
9330 else break;
9331 }
9332 break;
9333 }
9334 }
9335 }
9336 /********************************************************************************/
get_charge_and_multiplicity_from_mopac_output_file(FILE * fd)9337 void get_charge_and_multiplicity_from_mopac_output_file(FILE* fd)
9338 {
9339 guint taille=BSIZE;
9340 gchar t[BSIZE];
9341
9342 TotalCharges[0] = 0;
9343 SpinMultiplicities[0] =1;
9344
9345 while(!feof(fd) )
9346 {
9347 if(!fgets(t,taille,fd)) break;
9348 if ( strstr(t,"CHARGE ON SYSTEM") && strstr(t,"="))
9349 {
9350 gchar* p = strstr(t,"=")+1;
9351 TotalCharges[0] = atoi(p);
9352 }
9353 if ( strstr(t,"SPIN STATE DEFINED AS A"))
9354 {
9355 if ( strstr(t,"SINGLET")) SpinMultiplicities[0] = 1;
9356 if ( strstr(t,"DOUBLET")) SpinMultiplicities[0] = 2;
9357 if ( strstr(t,"TRIPLET")) SpinMultiplicities[0] = 3;
9358 if ( strstr(t,"QUARTET")) SpinMultiplicities[0] = 4;
9359 if ( strstr(t,"QUINTET")) SpinMultiplicities[0] = 5;
9360 if ( strstr(t,"SEXTET")) SpinMultiplicities[0] = 6;
9361 }
9362 }
9363 }
9364 /********************************************************************************/
get_charges_from_mopac_output_file(FILE * fd,gint N)9365 void get_charges_from_mopac_output_file(FILE* fd,gint N)
9366 {
9367 guint taille=BSIZE;
9368 gchar t[BSIZE];
9369 gchar dump[BSIZE];
9370 gchar d[BSIZE];
9371 gchar* pdest;
9372 gint i;
9373
9374
9375 /* printf("NAtoms = %d\n",N);*/
9376 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
9377
9378 while(!feof(fd) )
9379 {
9380 pdest = NULL;
9381 if(!fgets(t,taille,fd)) break;
9382 pdest = strstr( t, "NET ATOMIC CHARGES");
9383
9384 if(pdest)
9385 {
9386 if(!fgets(t,taille,fd)) break;
9387 if(!fgets(t,taille,fd)) break;
9388 for(i=0;i<N;i++)
9389 {
9390 if(!fgets(t,taille,fd)) break;
9391 if(sscanf(t,"%s %s %s",dump, dump , d)==3)
9392 {
9393 g_free(GeomXYZ[i].Charge);
9394 GeomXYZ[i].Charge = g_strdup(d);
9395 }
9396 else break;
9397 }
9398 break;
9399 }
9400 }
9401 }
9402 /********************************************************************************/
read_geom_from_mopac_output_file(gchar * NomFichier,gint numgeometry)9403 void read_geom_from_mopac_output_file(gchar *NomFichier, gint numgeometry)
9404 {
9405 gchar *t;
9406 gchar *AtomCoord[5];
9407 FILE *fd;
9408 guint taille=BSIZE;
9409 guint idummy;
9410 guint i;
9411 gint j=0;
9412 gint l;
9413 gint numgeom;
9414 gchar *pdest;
9415 long int geomposok = 0;
9416 gchar tmp1[100];
9417 gchar tmp2[100];
9418
9419 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9420
9421 t=g_malloc(taille*sizeof(gchar));
9422 fd = FOpen(NomFichier, "rb");
9423 if(fd ==NULL)
9424 {
9425 g_free(t);
9426 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
9427 MessageGeom(t,_("Error"),TRUE);
9428 g_free(t);
9429 return;
9430 }
9431 numgeom =0;
9432 while(!feof(fd))
9433 {
9434 if(!fgets(t,taille,fd))break;
9435 pdest = strstr( t, "ATOM CHEMICAL X Y Z");
9436 if(pdest)
9437 {
9438 if(!fgets(t,taille,fd)) {pdest=0;break;}
9439 if(!fgets(t,taille,fd)) {pdest=0;break;}
9440 }
9441 if ( pdest )
9442 {
9443 numgeom++;
9444 geomposok = ftell(fd);
9445 if(numgeom == numgeometry )
9446 {
9447 break;
9448 }
9449 }
9450 }
9451 if(numgeom == 0)
9452 {
9453 g_free(t);
9454 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
9455 MessageGeom(t,_("Error"),TRUE);
9456 g_free(t);
9457 return;
9458 }
9459 j=-1;
9460 fseek(fd, geomposok, SEEK_SET);
9461 while(!feof(fd) )
9462 {
9463 gint ii;
9464 if(!fgets(t,taille,fd))break;
9465 if(this_is_a_backspace(t) || sscanf(t,"%d",&ii)==0)
9466 {
9467 if(numgeometry<0)
9468 {
9469 fseek(fd, 0, SEEK_SET);
9470 get_charges_from_mopac_output_file(fd,j+1);
9471 fseek(fd, 0, SEEK_SET);
9472 get_esp_charges_from_mopac_output_file(fd,j+1);
9473 fseek(fd, 0, SEEK_SET);
9474 get_dipole_from_mopac_output_file(fd);
9475 fseek(fd, 0, SEEK_SET);
9476 get_charge_and_multiplicity_from_mopac_output_file(fd);
9477 }
9478 break;
9479 }
9480 j++;
9481 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
9482 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
9483 GeomXYZ[j].typeConnections = NULL;
9484 for(ii=0;ii<strlen(t);ii++) if(t[ii]=='*') t[ii]=' ';
9485 sscanf(t,"%d %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
9486
9487 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
9488 l=strlen(AtomCoord[0]);
9489 if(isdigit(AtomCoord[0][1]))l=1;
9490 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
9491 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
9492 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
9493
9494 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
9495 GeomXYZ[j].Symb=g_strdup(t);
9496 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
9497 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
9498 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
9499 GeomXYZ[j].ResidueNumber=0;
9500 if(Units == 0 )
9501 {
9502 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
9503 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
9504 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
9505 }
9506 else
9507 {
9508 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
9509 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
9510 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
9511 }
9512 GeomXYZ[j].Charge=g_strdup("0.0");
9513 GeomXYZ[j].Layer=g_strdup(" ");
9514 }
9515 NcentersXYZ = j+1;
9516 if(NcentersXYZ>0)
9517 {
9518 fseek(fd, 0, SEEK_SET);
9519 get_charge_and_multiplicity_from_mopac_output_file(fd);
9520 }
9521
9522 fclose(fd);
9523 calculMMTypes(FALSE);
9524 g_free(t);
9525 for(i=0;i<5;i++) g_free(AtomCoord[i]);
9526 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
9527 {
9528 clearList(list);
9529 append_list();
9530 }
9531 MethodeGeom = GEOM_IS_XYZ;
9532 if(GeomDrawingArea != NULL) rafresh_drawing();
9533 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
9534 }
9535 /********************************************************************************/
read_XYZ_from_mopac_irc_output_file(gchar * FileName,gint numGeom)9536 void read_XYZ_from_mopac_irc_output_file(gchar *FileName, gint numGeom)
9537 {
9538 gchar *t;
9539 gboolean OK;
9540 gchar *AtomCoord[10];
9541 FILE *fd;
9542 guint taille=BSIZE;
9543 guint i,l;
9544 GeomXYZAtomDef* GeomXYZtemp=NULL;
9545 gint Ncent = 0;
9546 gint Nvar = 0;
9547 VariablesXYZDef* VariablesXYZtemp=NULL;
9548 gchar symb[20];
9549 gchar type[20];
9550 gchar charge[20];
9551 gint k1;
9552 gint j;
9553
9554 for(i=0;i<10;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9555 fd = FOpen(FileName, "rb");
9556 if(fd == NULL)
9557 {
9558 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
9559 MessageGeom(t,_("Error"),TRUE);
9560 g_free(t);
9561 return;
9562 }
9563 t=g_malloc(taille);
9564 OK = TRUE;
9565 i = 0;
9566 while(!feof(fd) )
9567 {
9568 if(!fgets(t, taille, fd))break;
9569 if(
9570 strstr(t,"POTENTIAL") &&
9571 strstr(t,"LOST") &&
9572 strstr(t,"TOTAL")
9573 )
9574 {
9575 i++;
9576 if(i==numGeom)break;
9577 }
9578 }
9579 if(i==0) OK = FALSE;
9580 while(!feof(fd) && OK )
9581 {
9582 if(!fgets(t, taille, fd))OK = FALSE;
9583 if(
9584 strstr(t,"ATOM")&&
9585 strstr(t,"X")&&
9586 strstr(t,"Y")&&
9587 strstr(t,"Z")) break;
9588 }
9589 if(!OK)
9590 {
9591 g_free(t);
9592 t = g_strdup_printf(_("Sorry\n I can not read geometry from \"%s\" file"),FileName);
9593 MessageGeom(t,_("Error"),TRUE);
9594 g_free(t);
9595 return;
9596 }
9597 Ncent=0;
9598 GeomXYZtemp = NULL;
9599
9600 j=0;
9601 while(!feof(fd) )
9602 {
9603 if(!fgets(t,taille,fd))break;
9604 if(this_is_a_backspace(t)) break;
9605 i = sscanf(t,"%d %s %s %s %s",
9606 &k1,AtomCoord[0],
9607 AtomCoord[1],AtomCoord[2],AtomCoord[3]);
9608 if(i==0) break;
9609 if( i== 5)
9610 {
9611 Ncent = j+1;
9612 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
9613 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
9614 l=strlen(AtomCoord[0]);
9615 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
9616
9617 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
9618 get_symb_type_charge(AtomCoord[0],symb,type,charge);
9619 {
9620 gint k;
9621 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
9622 delete_all_spaces(symb);
9623 }
9624
9625 GeomXYZtemp[j].Symb=g_strdup(symb);
9626 GeomXYZtemp[j].mmType=g_strdup(type);
9627 GeomXYZtemp[j].pdbType=g_strdup(type);
9628 GeomXYZtemp[j].Charge=g_strdup(charge);
9629
9630 GeomXYZtemp[j].Residue=g_strdup("DUM");
9631 GeomXYZtemp[j].ResidueNumber=0;
9632 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
9633 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
9634 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
9635 GeomXYZtemp[j].Layer=g_strdup(" ");
9636 GeomXYZtemp[j].typeConnections = NULL;
9637 j++;
9638 }
9639 }
9640 fseek(fd, 0L, SEEK_SET);
9641 if(j==0) OK = FALSE;
9642 else get_charge_and_multiplicity_from_mopac_output_file(fd);
9643 fclose(fd);
9644
9645 g_free(t);
9646 for(i=0;i<5;i++) g_free(AtomCoord[i]);
9647 if( !OK || Ncent <1 )
9648 {
9649 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
9650 MessageGeom(_("Sorry\n I can not read geometry in Mopac input file"),_("Error"),TRUE);
9651 return;
9652 }
9653 if(GeomXYZ) freeGeomXYZ();
9654 if(VariablesXYZ) freeVariablesXYZ();
9655 GeomXYZ = GeomXYZtemp;
9656 NcentersXYZ = Ncent;
9657 NVariablesXYZ = Nvar;
9658 VariablesXYZ = VariablesXYZtemp;
9659 MethodeGeom = GEOM_IS_XYZ;
9660 calculMMTypes(FALSE);
9661 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
9662 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
9663
9664 if(GeomDrawingArea != NULL) rafresh_drawing();
9665 set_last_directory(FileName);
9666 }
9667 /********************************************************************************/
read_geom_from_mopac_irc_output_file(gchar * FileName,gint numGeom)9668 void read_geom_from_mopac_irc_output_file(gchar *FileName, gint numGeom)
9669 {
9670 if(zmat_mopac_irc_output_file(FileName))
9671 {
9672 read_Zmat_from_mopac_irc_output_file(FileName, numGeom);
9673 }
9674 else
9675 read_XYZ_from_mopac_irc_output_file(FileName, numGeom);
9676 }
9677 /********************************************************************************/
read_XYZ_from_mopac_scan_output_file(gchar * FileName,gint numGeom)9678 void read_XYZ_from_mopac_scan_output_file(gchar *FileName, gint numGeom)
9679 {
9680 gchar *t;
9681 gboolean OK;
9682 gchar *AtomCoord[10];
9683 FILE *fd;
9684 guint taille=BSIZE;
9685 guint i,l;
9686 GeomXYZAtomDef* GeomXYZtemp=NULL;
9687 gint Ncent = 0;
9688 gint Nvar = 0;
9689 VariablesXYZDef* VariablesXYZtemp=NULL;
9690 gchar symb[20];
9691 gchar type[20];
9692 gchar charge[20];
9693 gint k1,k2,k3;
9694 gint j;
9695
9696 for(i=0;i<10;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9697 fd = FOpen(FileName, "rb");
9698 if(fd == NULL)
9699 {
9700 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),FileName);
9701 MessageGeom(t,_("Error"),TRUE);
9702 g_free(t);
9703 return;
9704 }
9705 t=g_malloc(taille);
9706 OK = TRUE;
9707 i = 0;
9708 while(!feof(fd) )
9709 {
9710 if(!fgets(t, taille, fd))break;
9711 if(
9712 strstr(t,"VARIABLE") &&
9713 strstr(t,"FUNCTION")
9714 )
9715 {
9716 i++;
9717 if(i==numGeom)break;
9718 }
9719 }
9720 if(i==0) OK = FALSE;
9721 if(OK && !fgets(t, taille, fd))OK = FALSE; /* Values */
9722 while(!feof(fd) && OK )
9723 {
9724 if(!fgets(t, taille, fd))OK = FALSE;
9725 if(t[0] != '*') break; /* Keywords */
9726 }
9727 if(!fgets(t,taille,fd)) OK = FALSE;
9728 if(!fgets(t,taille,fd)) OK = FALSE;
9729 if(!OK)
9730 {
9731 g_free(t);
9732 t = g_strdup_printf(_("Sorry\n I can not read geometry from \"%s\" file"),FileName);
9733 MessageGeom(t,_("Error"),TRUE);
9734 g_free(t);
9735 return;
9736 }
9737 Ncent=0;
9738 GeomXYZtemp = NULL;
9739
9740 j=0;
9741 while(!feof(fd) )
9742 {
9743 if(!fgets(t,taille,fd))break;
9744 if(this_is_a_backspace(t)) break;
9745 i = sscanf(t,"%s %s %d %s %d %s %d", AtomCoord[0],AtomCoord[1],&k1,AtomCoord[2],&k2,AtomCoord[3],&k3);
9746 if(i==0) break;
9747 if( i== 7)
9748 {
9749 gint newVar = 0;
9750
9751 Ncent = j+1;
9752 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
9753 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
9754 l=strlen(AtomCoord[0]);
9755 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
9756
9757 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
9758 get_symb_type_charge(AtomCoord[0],symb,type,charge);
9759 {
9760 gint k;
9761 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
9762 delete_all_spaces(symb);
9763 }
9764
9765 GeomXYZtemp[j].Symb=g_strdup(symb);
9766 GeomXYZtemp[j].mmType=g_strdup(type);
9767 GeomXYZtemp[j].pdbType=g_strdup(type);
9768 GeomXYZtemp[j].Charge=g_strdup(charge);
9769
9770 GeomXYZtemp[j].Residue=g_strdup("DUM");
9771 GeomXYZtemp[j].ResidueNumber=0;
9772 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
9773 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
9774 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
9775 GeomXYZtemp[j].Layer=g_strdup(" ");
9776 GeomXYZtemp[j].typeConnections = NULL;
9777 if(k1==1) newVar++;
9778 if(k2==1) newVar++;
9779 if(k3==1) newVar++;
9780 if(newVar>0)
9781 {
9782 gint n = Nvar+newVar;
9783 if(n==1)
9784 VariablesXYZtemp = g_malloc(n*sizeof(VariablesXYZDef));
9785 else
9786 VariablesXYZtemp = g_realloc(VariablesXYZtemp,n*sizeof(VariablesXYZDef));
9787 }
9788 newVar = 0;
9789 if(k1==1)
9790 {
9791 newVar++;
9792 trans_coordXYZ_geom('X', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
9793 }
9794 if(k2==1)
9795 {
9796 newVar++;
9797 trans_coordXYZ_geom('Y', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
9798 }
9799 if(k3==1)
9800 {
9801 newVar++;
9802 trans_coordXYZ_geom('Z', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
9803 }
9804 Nvar += newVar;
9805 j++;
9806 }
9807 }
9808 fseek(fd, 0L, SEEK_SET);
9809 if(j==0) OK = FALSE;
9810 else get_charge_and_multiplicity_from_mopac_output_file(fd);
9811 fclose(fd);
9812
9813 g_free(t);
9814 for(i=0;i<5;i++) g_free(AtomCoord[i]);
9815 if( !OK || Ncent <1 )
9816 {
9817 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
9818 MessageGeom(_("Sorry\n I can not read geometry in Mopac input file"),_("Error"),TRUE);
9819 return;
9820 }
9821 if(GeomXYZ) freeGeomXYZ();
9822 if(VariablesXYZ) freeVariablesXYZ();
9823 GeomXYZ = GeomXYZtemp;
9824 NcentersXYZ = Ncent;
9825 NVariablesXYZ = Nvar;
9826 VariablesXYZ = VariablesXYZtemp;
9827 MethodeGeom = GEOM_IS_XYZ;
9828 calculMMTypes(FALSE);
9829 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
9830 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
9831
9832 if(GeomDrawingArea != NULL) rafresh_drawing();
9833 set_last_directory(FileName);
9834 }
9835 /********************************************************************************/
read_geom_from_mopac_scan_output_file(gchar * FileName,gint numGeom)9836 void read_geom_from_mopac_scan_output_file(gchar *FileName, gint numGeom)
9837 {
9838 if(zmat_mopac_scan_output_file(FileName))
9839 read_Zmat_from_mopac_scan_output_file(FileName, numGeom);
9840 else
9841 read_XYZ_from_mopac_scan_output_file(FileName, numGeom);
9842 }
9843 /********************************************************************************/
get_charge_and_multiplicity_from_mopac_aux_file(FILE * fd)9844 void get_charge_and_multiplicity_from_mopac_aux_file(FILE* fd)
9845 {
9846 guint taille=BSIZE;
9847 gchar t[BSIZE];
9848
9849 TotalCharges[0] = 0;
9850 SpinMultiplicities[0] =1;
9851
9852 while(!feof(fd) )
9853 {
9854 if(!fgets(t,taille,fd)) break;
9855 if ( strstr(t,"KEYWORDS="))
9856 {
9857 if(strstr(t,"CHARGE="))
9858 {
9859 gchar* p = strstr(t,"CHARGE=")+7;
9860 TotalCharges[0] = atoi(p);
9861 }
9862 if ( strstr(t,"SINGLET")) SpinMultiplicities[0] = 1;
9863 if ( strstr(t,"DOUBLET")) SpinMultiplicities[0] = 2;
9864 if ( strstr(t,"TRIPLET")) SpinMultiplicities[0] = 3;
9865 if ( strstr(t,"QUARTET")) SpinMultiplicities[0] = 4;
9866 if ( strstr(t,"QUINTET")) SpinMultiplicities[0] = 5;
9867 if ( strstr(t,"SEXTET")) SpinMultiplicities[0] = 6;
9868 }
9869 }
9870 }
9871 /********************************************************************************/
get_charges_from_mopac_aux_file(FILE * fd,gint N)9872 void get_charges_from_mopac_aux_file(FILE* fd,gint N)
9873 {
9874 gchar** elements = NULL;
9875 gint n;
9876 gint i;
9877
9878 for(i=0;i<N;i++)
9879 GeomXYZ[i].Charge = g_strdup("0.0");
9880 elements = get_one_block_from_aux_mopac_file(fd, "ATOM_CHARGES[", &n);
9881
9882 if(!elements) return;
9883 if(n<N)
9884 {
9885 free_one_string_table(elements, n);
9886 return;
9887 }
9888 for(i=0;i<N;i++)
9889 {
9890 g_free(GeomXYZ[i].Charge);
9891 GeomXYZ[i].Charge = g_strdup(elements[i]);
9892 }
9893 free_one_string_table(elements, n);
9894 }
9895 /********************************************************************************/
get_translation_vectors_from_mopac_aux_file(FILE * fd,gint N)9896 gint get_translation_vectors_from_mopac_aux_file(FILE* fd,gint N)
9897 {
9898 gchar** elements = NULL;
9899 gint n;
9900 gint i,j,k;
9901 gint nTv = 0;
9902 gdouble Tv[3][3];
9903
9904 elements = get_one_block_from_aux_mopac_file(fd, "TRANS_VECTS", &n);
9905 if(!elements) return 0;
9906 nTv = n/3;
9907 if(nTv<1) { free_one_string_table(elements, n); return 0; }
9908 k = 0;
9909 for(i=0;i<nTv;i++)
9910 {
9911 for(j=0;j<3;j++)
9912 Tv[i][j]=atof(elements[k++]);
9913 }
9914
9915 /*
9916 printf("nTv=%d\n",nTv);
9917 printf("Tv0=%f %f %f\n",Tv[0][0],Tv[0][1],Tv[0][2]);
9918 */
9919
9920 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
9921 else GeomXYZ=g_realloc(GeomXYZ,(N+nTv)*sizeof(GeomXYZAtomDef));
9922 j = N;
9923 for(i=0;i<nTv;i++)
9924 {
9925 GeomXYZ[j].typeConnections = NULL;
9926 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
9927 GeomXYZ[j].Symb=g_strdup("Tv");
9928 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
9929 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
9930 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
9931 GeomXYZ[j].ResidueNumber=0;
9932 if(Units == 0 )
9933 {
9934 GeomXYZ[j].X=g_strdup_printf("%0.14f",Tv[i][0]*BOHR_TO_ANG);
9935 GeomXYZ[j].Y=g_strdup_printf("%0.14f",Tv[i][1]*BOHR_TO_ANG);
9936 GeomXYZ[j].Z=g_strdup_printf("%0.14f",Tv[i][2]*BOHR_TO_ANG);
9937 }
9938 else
9939 {
9940 GeomXYZ[j].X=g_strdup_printf("%0.14f",Tv[i][0]);
9941 GeomXYZ[j].Y=g_strdup_printf("%0.14f",Tv[i][1]);
9942 GeomXYZ[j].Z=g_strdup_printf("%0.14f",Tv[i][2]);
9943 }
9944 GeomXYZ[j].Charge=g_strdup("0.0");
9945 GeomXYZ[j].Layer=g_strdup(" ");
9946 j++;
9947 }
9948 free_one_string_table(elements, n);
9949 return nTv;
9950 }
9951 /********************************************************************************/
read_geom_from_mopac_aux_file(gchar * NomFichier,gint numgeometry)9952 void read_geom_from_mopac_aux_file(gchar *NomFichier, gint numgeometry)
9953 {
9954 gchar *t;
9955 gboolean OK;
9956 gchar *AtomCoord[5];
9957 FILE *fd;
9958 guint taille=BSIZE;
9959 guint i;
9960 gint j=0;
9961 gint l;
9962 gint numgeom;
9963 gchar *pdest;
9964 long int geomposok = 0;
9965 gint nElements = 0;
9966 gchar** elements = NULL;
9967
9968 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
9969
9970 t=g_malloc(taille*sizeof(gchar));
9971 fd = FOpen(NomFichier, "rb");
9972 if(fd ==NULL)
9973 {
9974 g_free(t);
9975 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
9976 MessageGeom(t,_("Error"),TRUE);
9977 g_free(t);
9978 return;
9979 }
9980 numgeom =0;
9981 OK=FALSE;
9982 elements = get_one_block_from_aux_mopac_file(fd, "ATOM_EL[", &nElements);
9983 if(elements) OK = TRUE;
9984 if(!OK)
9985 {
9986 g_free(t);
9987 t = g_strdup_printf(_("Sorry\nI can not read the atom symbols in %s file "),NomFichier);
9988 MessageGeom(t,_("Error"),TRUE);
9989 g_free(t);
9990 return;
9991 }
9992 while(!feof(fd))
9993 {
9994 if(!fgets(t,taille,fd))break;
9995 if(numgeometry<0)
9996 pdest = strstr( t, "ATOM_X_OPT:ANGSTROMS");
9997 else
9998 pdest = strstr( t, "ATOM_X_UPDATED:ANGSTROMS");
9999 if ( pdest )
10000 {
10001 numgeom++;
10002 geomposok = ftell(fd);
10003 if(numgeom == numgeometry )
10004 {
10005 OK = TRUE;
10006 break;
10007 }
10008 if(numgeometry<0)
10009 {
10010 OK = TRUE;
10011 }
10012 }
10013 }
10014 if(numgeom == 0)
10015 {
10016 g_free(t);
10017 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
10018 MessageGeom(t,_("Error"),TRUE);
10019 g_free(t);
10020 free_one_string_table(elements, nElements);
10021 return;
10022 }
10023 j=-1;
10024 fseek(fd, geomposok, SEEK_SET);
10025 while(!feof(fd) )
10026 {
10027 if(!fgets(t,taille,fd))break;
10028 if(strstr( t, "[")
10029 || strstr(t,"HEAT_OF_FORM_UPDATED")
10030 || strstr(t,"TRANS_VECTS")
10031 || strstr( t, "####################################")
10032 ||this_is_a_backspace(t))
10033 {
10034 if(numgeometry<0)
10035 {
10036 fseek(fd, geomposok, SEEK_SET);
10037 get_charges_from_mopac_aux_file(fd,j+1);
10038 if(j+1>0)
10039 {
10040 NcentersXYZ = j+1;
10041 compute_dipole_using_charges_of_xyz_geom();
10042 }
10043 /* Only module of dipole is available in aux mopac file*/
10044 }
10045 break;
10046 }
10047 if(j+1>nElements)break;
10048 j++;
10049 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10050 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
10051 GeomXYZ[j].typeConnections = NULL;
10052
10053 sscanf(t,"%s %s %s",AtomCoord[1],AtomCoord[2],AtomCoord[3]);
10054 if(j<nElements) sprintf(AtomCoord[0],"%s",elements[j]);
10055 else sprintf(AtomCoord[0],"X");
10056 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
10057 l=strlen(AtomCoord[0]);
10058 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
10059 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
10060 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
10061
10062 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10063 GeomXYZ[j].Symb=g_strdup(t);
10064 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
10065 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
10066 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
10067 GeomXYZ[j].ResidueNumber=0;
10068 if(Units == 0 )
10069 {
10070 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
10071 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
10072 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
10073 }
10074 else
10075 {
10076 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
10077 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
10078 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
10079 }
10080 GeomXYZ[j].Charge=g_strdup("0.0");
10081 GeomXYZ[j].Layer=g_strdup(" ");
10082 }
10083 if(j+1>0)
10084 {
10085 fseek(fd, geomposok, SEEK_SET);
10086 j += get_translation_vectors_from_mopac_aux_file(fd,j+1);
10087 fseek(fd, 0, SEEK_SET);
10088 get_charge_and_multiplicity_from_mopac_aux_file(fd);
10089 }
10090 fclose(fd);
10091 NcentersXYZ = j+1;
10092 calculMMTypes(FALSE);
10093 g_free(t);
10094 for(i=0;i<5;i++) g_free(AtomCoord[i]);
10095 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
10096 {
10097 clearList(list);
10098 append_list();
10099 }
10100 MethodeGeom = GEOM_IS_XYZ;
10101 if(GeomDrawingArea != NULL) rafresh_drawing();
10102 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
10103 free_one_string_table(elements, nElements);
10104 }
10105 /********************************************************************************/
get_charges_from_orca_output_file(FILE * fd,gint N)10106 void get_charges_from_orca_output_file(FILE* fd,gint N)
10107 {
10108 guint taille=BSIZE;
10109 gchar t[BSIZE];
10110 gchar dump[BSIZE];
10111 gchar d[BSIZE];
10112 gchar* pdest;
10113 gint i;
10114
10115
10116 for(i=0;i<N;i++)
10117 GeomXYZ[i].Charge = g_strdup("0.0");
10118
10119 while(!feof(fd) )
10120 {
10121 pdest = NULL;
10122 { char* e = fgets(t,taille,fd);}
10123 if(strstr(t,"GEOMETRY OPTIMIZATION CYCLE")) break;
10124 pdest = strstr( t, "MULLIKEN ATOMIC CHARGES");
10125 if(pdest)
10126 {
10127 gboolean OK = FALSE;
10128 while(!feof(fd) )
10129 {
10130 if(!fgets(t,taille,fd)) break;
10131 if(strstr(t,"----------------"))
10132 {
10133 OK = TRUE;
10134 break;
10135 }
10136 }
10137 if(!OK) break;
10138
10139 for(i=0;i<N;i++)
10140 {
10141 if(!feof(fd)) { char* e = fgets(t,taille,fd);}
10142 else break;
10143 if(sscanf(t,"%s %s %s %s",dump,dump,dump,d)==4)
10144 {
10145 g_free(GeomXYZ[i].Charge);
10146 GeomXYZ[i].Charge = g_strdup(d);
10147 }
10148 }
10149 break;
10150 }
10151 }
10152 }
10153 /********************************************************************************/
read_geom_from_orca_file(gchar * NomFichier,gint numgeometry)10154 void read_geom_from_orca_file(gchar *NomFichier, gint numgeometry)
10155 {
10156 gchar *t;
10157 gchar *AtomCoord[5];
10158 FILE *fd;
10159 guint taille=BSIZE;
10160 guint i;
10161 gint j=0;
10162 gint l;
10163 gint numgeom;
10164 gchar *pdest;
10165 long int geomposok = 0;
10166
10167 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
10168
10169 t=g_malloc(taille*sizeof(gchar));
10170 fd = FOpen(NomFichier, "rb");
10171 if(fd ==NULL)
10172 {
10173 g_free(t);
10174 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
10175 MessageGeom(t,_("Error"),TRUE);
10176 g_free(t);
10177 return;
10178 }
10179 numgeom =0;
10180 while(!feof(fd))
10181 {
10182 if(!fgets(t,taille,fd))break;
10183 pdest = strstr( t, "CARTESIAN COORDINATES (ANGSTROEM)");
10184 if(pdest)
10185 {
10186 if(!fgets(t,taille,fd))break;
10187 pdest = strstr( t, "---------------------------------");
10188 }
10189 if ( pdest )
10190 {
10191 numgeom++;
10192 geomposok = ftell(fd);
10193 if(numgeom == numgeometry )
10194 {
10195 break;
10196 }
10197 }
10198 }
10199 if(numgeom == 0)
10200 {
10201 g_free(t);
10202 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
10203 MessageGeom(t,_("Error"),TRUE);
10204 g_free(t);
10205 return;
10206 }
10207 j=-1;
10208 fseek(fd, geomposok, SEEK_SET);
10209 while(!feof(fd) )
10210 {
10211 if(!fgets(t,taille,fd))break;
10212 pdest = strstr( t, "----------------------------------" );
10213 if (pdest || this_is_a_backspace(t))
10214 {
10215 geomposok = ftell(fd);
10216 get_charges_from_orca_output_file(fd,j+1);
10217 fseek(fd, geomposok, SEEK_SET);
10218 get_dipole_from_orca_output_file(fd);
10219 break;
10220 }
10221 j++;
10222 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10223 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
10224 GeomXYZ[j].typeConnections = NULL;
10225
10226 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
10227 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
10228 l=strlen(AtomCoord[0]);
10229 if(isdigit(AtomCoord[0][1]))l=1;
10230 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
10231 if(l==1)sprintf(t,"%c",AtomCoord[0][0]);
10232 else sprintf(t,"%c%c",AtomCoord[0][0],AtomCoord[0][1]);
10233 /* if(!strcmp(t,"-")) sprintf(t,"%c",'X');*/
10234 if(!strcmp(t,"-")) { j--;continue;}
10235
10236 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10237 GeomXYZ[j].Symb=g_strdup(t);
10238 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
10239 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
10240 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
10241 GeomXYZ[j].ResidueNumber=0;
10242 if(Units == 0 )
10243 {
10244 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
10245 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
10246 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
10247 }
10248 else
10249 {
10250 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
10251 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
10252 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
10253 }
10254 GeomXYZ[j].Charge=g_strdup("0.0");
10255 GeomXYZ[j].Layer=g_strdup(" ");
10256 }
10257 NcentersXYZ = j+1;
10258
10259 fclose(fd);
10260 calculMMTypes(FALSE);
10261 g_free(t);
10262 for(i=0;i<5;i++) g_free(AtomCoord[i]);
10263 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
10264 {
10265 clearList(list);
10266 append_list();
10267 }
10268 MethodeGeom = GEOM_IS_XYZ;
10269 if(GeomDrawingArea != NULL) rafresh_drawing();
10270 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
10271 }
10272 /********************************************************************************/
read_first_orca_file(GabeditFileChooser * SelecFile,gint response_id)10273 void read_first_orca_file(GabeditFileChooser *SelecFile , gint response_id)
10274 {
10275 gchar *NomFichier;
10276
10277 if(response_id != GTK_RESPONSE_OK) return;
10278 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10279
10280 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10281 {
10282 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10283 return ;
10284 }
10285 read_geom_from_orca_file(NomFichier, 1);
10286 set_last_directory(NomFichier);
10287 }
10288 /********************************************************************************/
read_last_orca_file(GabeditFileChooser * SelecFile,gint response_id)10289 void read_last_orca_file(GabeditFileChooser *SelecFile , gint response_id)
10290 {
10291 gchar *NomFichier;
10292
10293 if(response_id != GTK_RESPONSE_OK) return;
10294 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10295
10296 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10297 {
10298 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10299 return ;
10300 }
10301 read_geom_from_orca_file(NomFichier, -1);
10302 set_last_directory(NomFichier);
10303 }
10304 /********************************************************************************/
read_first_nwchem_file(GabeditFileChooser * SelecFile,gint response_id)10305 void read_first_nwchem_file(GabeditFileChooser *SelecFile , gint response_id)
10306 {
10307 gchar *NomFichier;
10308
10309 if(response_id != GTK_RESPONSE_OK) return;
10310 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10311
10312 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10313 {
10314 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10315 return ;
10316 }
10317 read_geom_from_nwchem_file(NomFichier, 1);
10318 set_last_directory(NomFichier);
10319 }
10320 /********************************************************************************/
read_last_nwchem_file(GabeditFileChooser * SelecFile,gint response_id)10321 void read_last_nwchem_file(GabeditFileChooser *SelecFile , gint response_id)
10322 {
10323 gchar *NomFichier;
10324
10325 if(response_id != GTK_RESPONSE_OK) return;
10326 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10327
10328 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10329 {
10330 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10331 return ;
10332 }
10333 read_geom_from_nwchem_file(NomFichier, -1);
10334 set_last_directory(NomFichier);
10335 }
10336 /********************************************************************************/
read_first_psicode_file(GabeditFileChooser * SelecFile,gint response_id)10337 void read_first_psicode_file(GabeditFileChooser *SelecFile , gint response_id)
10338 {
10339 gchar *NomFichier;
10340
10341 if(response_id != GTK_RESPONSE_OK) return;
10342 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10343
10344 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10345 {
10346 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10347 return ;
10348 }
10349 read_geom_from_psicode_file(NomFichier, 1);
10350 set_last_directory(NomFichier);
10351 }
10352 /********************************************************************************/
read_last_psicode_file(GabeditFileChooser * SelecFile,gint response_id)10353 void read_last_psicode_file(GabeditFileChooser *SelecFile , gint response_id)
10354 {
10355 gchar *NomFichier;
10356
10357 if(response_id != GTK_RESPONSE_OK) return;
10358 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10359
10360 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10361 {
10362 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10363 return ;
10364 }
10365 read_geom_from_psicode_file(NomFichier, -1);
10366 set_last_directory(NomFichier);
10367 }
10368 /********************************************************************************/
read_first_qchem_file(GabeditFileChooser * SelecFile,gint response_id)10369 void read_first_qchem_file(GabeditFileChooser *SelecFile , gint response_id)
10370 {
10371 gchar *NomFichier;
10372
10373 if(response_id != GTK_RESPONSE_OK) return;
10374 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10375
10376 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10377 {
10378 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10379 return ;
10380 }
10381 read_geom_from_qchem_file(NomFichier, 1);
10382 set_last_directory(NomFichier);
10383 }
10384 /********************************************************************************/
read_last_qchem_file(GabeditFileChooser * SelecFile,gint response_id)10385 void read_last_qchem_file(GabeditFileChooser *SelecFile , gint response_id)
10386 {
10387 gchar *NomFichier;
10388
10389 if(response_id != GTK_RESPONSE_OK) return;
10390 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10391
10392 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10393 {
10394 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10395 return ;
10396 }
10397 read_geom_from_qchem_file(NomFichier, -1);
10398 set_last_directory(NomFichier);
10399 }
10400 /********************************************************************************/
read_first_mopac_output_file(GabeditFileChooser * SelecFile,gint response_id)10401 void read_first_mopac_output_file(GabeditFileChooser *SelecFile , gint response_id)
10402 {
10403 gchar *NomFichier;
10404
10405 if(response_id != GTK_RESPONSE_OK) return;
10406 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10407
10408 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10409 {
10410 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10411 return ;
10412 }
10413 read_geom_from_mopac_output_file(NomFichier, 1);
10414 set_last_directory(NomFichier);
10415 }
10416 /********************************************************************************/
read_last_mopac_output_file(GabeditFileChooser * SelecFile,gint response_id)10417 void read_last_mopac_output_file(GabeditFileChooser *SelecFile , gint response_id)
10418 {
10419 gchar *NomFichier;
10420
10421 if(response_id != GTK_RESPONSE_OK) return;
10422 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10423
10424 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10425 {
10426 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10427 return ;
10428 }
10429 read_geom_from_mopac_output_file(NomFichier, -1);
10430 set_last_directory(NomFichier);
10431 }
10432 /********************************************************************************/
read_last_mopac_aux_file(GabeditFileChooser * SelecFile,gint response_id)10433 void read_last_mopac_aux_file(GabeditFileChooser *SelecFile , gint response_id)
10434 {
10435 gchar *NomFichier;
10436
10437 if(response_id != GTK_RESPONSE_OK) return;
10438 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10439
10440 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10441 {
10442 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10443 return ;
10444 }
10445 read_geom_from_mopac_aux_file(NomFichier, -1);
10446 set_last_directory(NomFichier);
10447 }
10448 /********************************************************************************/
get_translation_vectors_from_vasp_file(FILE * fd,gint N)10449 gint get_translation_vectors_from_vasp_file(FILE* fd,gint N)
10450 {
10451 gchar** elements = NULL;
10452 gint n;
10453 gint i,j,k;
10454 gint nTv = 0;
10455 gdouble Tv[3][3];
10456 gchar t[BSIZE];
10457 gint size=BSIZE;
10458 gchar* pdest = NULL;
10459
10460 for(i=0;i<3;i++)
10461 {
10462 if(!fgets(t,size,fd))break;
10463 k = sscanf(t,"%lf %lf %lf",&Tv[i][0],&Tv[i][1],&Tv[i][2]);
10464 if(k!=3) break;
10465 nTv++;
10466 }
10467 if(nTv<1) { return 0; }
10468 /*
10469 printf("nTv=%d\n",nTv);
10470 printf("Tv0=%f %f %f\n",Tv[0][0],Tv[0][1],Tv[0][2]);
10471 */
10472
10473 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10474 else GeomXYZ=g_realloc(GeomXYZ,(N+nTv)*sizeof(GeomXYZAtomDef));
10475 j = N;
10476 for(i=0;i<nTv;i++)
10477 {
10478 GeomXYZ[j].typeConnections = NULL;
10479 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10480 GeomXYZ[j].Symb=g_strdup("Tv");
10481 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
10482 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
10483 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
10484 GeomXYZ[j].ResidueNumber=0;
10485 if(Units == 0 )
10486 {
10487 GeomXYZ[j].X=g_strdup_printf("%0.14f",Tv[i][0]*BOHR_TO_ANG);
10488 GeomXYZ[j].Y=g_strdup_printf("%0.14f",Tv[i][1]*BOHR_TO_ANG);
10489 GeomXYZ[j].Z=g_strdup_printf("%0.14f",Tv[i][2]*BOHR_TO_ANG);
10490 }
10491 else
10492 {
10493 GeomXYZ[j].X=g_strdup_printf("%0.14f",Tv[i][0]);
10494 GeomXYZ[j].Y=g_strdup_printf("%0.14f",Tv[i][1]);
10495 GeomXYZ[j].Z=g_strdup_printf("%0.14f",Tv[i][2]);
10496 }
10497 GeomXYZ[j].Charge=g_strdup("0.0");
10498 GeomXYZ[j].Layer=g_strdup(" ");
10499 j++;
10500 }
10501 return nTv;
10502 }
10503 /********************************************************************************/
get_charges_from_vasp_output_file(FILE * fd,gint N)10504 void get_charges_from_vasp_output_file(FILE* fd,gint N)
10505 {
10506 guint taille=BSIZE;
10507 gchar t[BSIZE];
10508 gchar dump[BSIZE];
10509 gchar d[BSIZE];
10510 gchar* pdest;
10511 gint i;
10512
10513 for(i=0;i<N;i++) GeomXYZ[i].Charge = g_strdup("0.0");
10514 /* TO DO */
10515 return;
10516
10517 }
10518 /********************************************************************************/
read_geom_from_vasp_file(gchar * NomFichier,gint numgeometry)10519 void read_geom_from_vasp_file(gchar *NomFichier, gint numgeometry)
10520 {
10521 gchar *t;
10522 gboolean OK;
10523 gchar *AtomCoord[5];
10524 FILE *fd;
10525 guint taille=BSIZE;
10526 guint i;
10527 guint k;
10528 gint j=0;
10529 gint l;
10530 gint numgeom;
10531 gchar *pdest;
10532 long int geomposok = 0;
10533 long int latticeposok = -1;
10534 gint ntypes = 0;
10535 gchar** symbols = NULL;
10536 gint* nntypes = NULL;
10537 gchar told[20];
10538 gchar t1[20];
10539 gchar t2[20];
10540 gchar t3[BSIZE];
10541 gchar** listTypes = NULL;
10542
10543 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
10544
10545 t=g_malloc(taille*sizeof(gchar));
10546 fd = FOpen(NomFichier, "rb");
10547 if(fd ==NULL)
10548 {
10549 g_free(t);
10550 t = g_strdup_printf(_("Sorry\nI can not open %s file "),NomFichier);
10551 MessageGeom(t,_("Error"),TRUE);
10552 g_free(t);
10553 return;
10554 }
10555 /* number atom types */
10556 OK=FALSE;
10557
10558 ntypes = 0;
10559 while(!feof(fd))
10560 {
10561 if(!fgets(t,taille,fd))break;
10562 pdest = strstr( t, "INCAR:");
10563 if(pdest)
10564 {
10565
10566 geomposok = ftell(fd);
10567 while(!feof(fd))
10568 {
10569 if(!fgets(t,taille,fd))break;
10570 if(strstr( t, "POTCAR:"))
10571 {
10572 gboolean ok = TRUE;
10573 for(j=0;j<ntypes;j++) if(!strcmp(t,listTypes[j])) { ok = FALSE; break;}
10574 if(!ok) break;
10575 ntypes++;
10576 listTypes = g_realloc(listTypes,ntypes*sizeof(gchar*));
10577 listTypes[ntypes-1] = g_strdup(t);
10578 }
10579 else break;
10580 }
10581 break;
10582 }
10583 }
10584 if(listTypes) for(j=0;j<ntypes;j++) if(listTypes[j]) g_free(listTypes[j]);
10585 if(listTypes) g_free(listTypes);
10586 listTypes = NULL;
10587
10588 if(ntypes<1)
10589 {
10590 g_free(t);
10591 t = g_strdup_printf(_("Sorry\nI can not read the type of atoms from %s file "),NomFichier);
10592 MessageGeom(t,_("Error"),TRUE);
10593 g_free(t);
10594 return;
10595 }
10596 fseek(fd, geomposok, SEEK_SET);
10597 symbols=g_malloc(ntypes*sizeof(gchar*));
10598 nntypes=g_malloc(ntypes*sizeof(gint));
10599 /* printf("ntypes = %d\n",ntypes);*/
10600 for(i=0;i<ntypes;i++) { symbols[i]=NULL; nntypes[i]=0;}
10601 for(i=0;i<ntypes;i++)
10602 {
10603 if(!fgets(t,taille,fd))break;
10604 if(3==sscanf(t,"%s %s %s",t1,t2,t3))
10605 {
10606 if(strlen(t3)>2) t3[2]='\0';
10607 symbols[i]=g_strdup(t3);
10608 /* printf("symb =%s\n",symbols[i]);*/
10609 }
10610 }
10611 /*printf("Ok end symbols\n");*/
10612 OK = TRUE;
10613 for(i=0;i<ntypes;i++) { if(symbols[i]==NULL) {OK = FALSE; break; }}
10614 if(!OK)
10615 {
10616 g_free(t);
10617 t = g_strdup_printf(_("Sorry\nI can not read the type of atoms from %s file, check your file ! "),NomFichier);
10618 MessageGeom(t,_("Error"),TRUE);
10619 g_free(t);
10620 g_free(symbols);
10621 g_free(nntypes);
10622 return;
10623 }
10624
10625 while(!feof(fd))
10626 {
10627 if(!fgets(t,taille,fd))break;
10628 if(strstr( t, "ions per type ="))
10629 {
10630 gchar** split = NULL;
10631 gchar* tt = strstr(t,"ions per type =")+strlen("ions per type =");
10632 gint nA=0;
10633 split = gab_split(tt);
10634 while(split && split[nA]!=NULL) nA++;
10635 if(nA==ntypes) for(i=0;i<ntypes;i++) nntypes[i] = atoi(split[i]);
10636 g_strfreev(split);
10637 break;
10638 }
10639 }
10640 OK = TRUE;
10641 for(i=0;i<ntypes;i++) { if(nntypes[i]==0) {OK = FALSE; break; }}
10642 if(!OK)
10643 {
10644 g_free(t);
10645 t = g_strdup_printf(_("Sorry\nI can not read the number of atoms by type from %s file, check your file ! "),NomFichier);
10646 MessageGeom(t,_("Error"),TRUE);
10647 g_free(t);
10648 g_free(symbols);
10649 g_free(nntypes);
10650 return;
10651 }
10652 /* printf("Ok end nntypes\n");*/
10653
10654 numgeom =0;
10655 OK=FALSE;
10656 while(!feof(fd))
10657 {
10658 if(!fgets(t,taille,fd))break;
10659 if(strstr(t, "direct lattice vectors")) latticeposok = ftell(fd);
10660 pdest = strstr( t, "POSITION");
10661 if(strstr( t, "POSITION") && strstr( t, "TOTAL-FORCE"))
10662 {
10663 if(!fgets(t,taille,fd))break;
10664 pdest = strstr( t, "---------------------------------");
10665 }
10666 if (pdest)
10667 {
10668 numgeom++;
10669 geomposok = ftell(fd);
10670 if(numgeom == numgeometry )
10671 {
10672 OK = TRUE;
10673 break;
10674 }
10675 if(numgeometry<0)
10676 {
10677 OK = TRUE;
10678 }
10679 }
10680 }
10681 if(numgeom == 0)
10682 {
10683 g_free(t);
10684 t = g_strdup_printf(_("Sorry\nI can not read geometry in %s file "),NomFichier);
10685 MessageGeom(t,_("Error"),TRUE);
10686 g_free(t);
10687 return;
10688 }
10689 j=-1;
10690 fseek(fd, geomposok, SEEK_SET);
10691 for(i=0;i<ntypes;i++)
10692 for(k=0;k<nntypes[i];k++)
10693 {
10694 j++;
10695 if(!fgets(t,taille,fd))break;
10696 if(GeomXYZ==NULL) GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10697 else GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
10698 GeomXYZ[j].typeConnections = NULL;
10699
10700 sscanf(t,"%s %s %s",AtomCoord[1],AtomCoord[2],AtomCoord[3]);
10701
10702 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10703 GeomXYZ[j].Symb=g_strdup(symbols[i]);
10704 GeomXYZ[j].mmType=g_strdup(GeomXYZ[j].Symb);
10705 GeomXYZ[j].pdbType=g_strdup(GeomXYZ[j].Symb);
10706 GeomXYZ[j].Residue=g_strdup(GeomXYZ[j].Symb);
10707 GeomXYZ[j].ResidueNumber=0;
10708 if(Units == 0 )
10709 {
10710 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
10711 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
10712 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
10713 }
10714 else
10715 {
10716 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
10717 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
10718 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
10719 }
10720 GeomXYZ[j].Charge=g_strdup("0.0");
10721 GeomXYZ[j].Layer=g_strdup(" ");
10722 }
10723 /* printf("Ok end geom j = %d\n",j);*/
10724 geomposok = ftell(fd);
10725 get_charges_from_vasp_output_file(fd,j+1);
10726 fseek(fd, geomposok, SEEK_SET);
10727 get_dipole_from_vasp_output_file(fd);
10728 if(latticeposok>-1)
10729 {
10730 fseek(fd, latticeposok, SEEK_SET);
10731 /* printf("%ld %ld\n",geomposok,latticeposok);*/
10732 j += get_translation_vectors_from_vasp_file(fd,j+1);
10733 }
10734 NcentersXYZ = j+1;
10735
10736 fclose(fd);
10737 calculMMTypes(FALSE);
10738 g_free(t);
10739 for(i=0;i<5;i++) g_free(AtomCoord[i]);
10740 if(GeomIsOpen && MethodeGeom == GEOM_IS_XYZ)
10741 {
10742 clearList(list);
10743 append_list();
10744 }
10745 MethodeGeom = GEOM_IS_XYZ;
10746 if(GeomDrawingArea != NULL) rafresh_drawing();
10747 if(iprogram == PROG_IS_GAUSS && GeomIsOpen) set_spin_of_electrons();
10748 g_free(symbols);
10749 g_free(nntypes);
10750 }
10751 /********************************************************************************/
read_first_vasp_file(GabeditFileChooser * SelecFile,gint response_id)10752 void read_first_vasp_file(GabeditFileChooser *SelecFile , gint response_id)
10753 {
10754 gchar *NomFichier;
10755
10756 if(response_id != GTK_RESPONSE_OK) return;
10757 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10758
10759 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10760 {
10761 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10762 return ;
10763 }
10764 read_geom_from_vasp_file(NomFichier, 1);
10765 set_last_directory(NomFichier);
10766 }
10767 /********************************************************************************/
read_last_vasp_file(GabeditFileChooser * SelecFile,gint response_id)10768 void read_last_vasp_file(GabeditFileChooser *SelecFile , gint response_id)
10769 {
10770 gchar *NomFichier;
10771
10772 if(response_id != GTK_RESPONSE_OK) return;
10773 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10774
10775 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10776 {
10777 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10778 return ;
10779 }
10780 read_geom_from_vasp_file(NomFichier, -1);
10781 set_last_directory(NomFichier);
10782 }
10783 /********************************************************************************/
read_first_molcas_file(GabeditFileChooser * SelecFile,gint response_id)10784 void read_first_molcas_file(GabeditFileChooser *SelecFile, gint response_id)
10785 {
10786 gchar t[BSIZE];
10787 gchar *NomFichier;
10788 gboolean OK;
10789 gchar symb[100];
10790 gchar x[100];
10791 gchar y[100];
10792 gchar z[100];
10793 FILE *file;
10794 guint idummy;
10795 gint i;
10796 gint j=0;
10797 gint l;
10798
10799 if(response_id != GTK_RESPONSE_OK) return;
10800 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10801
10802 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10803 {
10804 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10805 return ;
10806 }
10807
10808 file = FOpen(NomFichier, "rb");
10809 if(file ==NULL)
10810 {
10811 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
10812 return;
10813 }
10814 OK=FALSE;
10815 while(!feof(file))
10816 {
10817 { char* e = fgets(t,BSIZE,file);}
10818 if (strstr(t," Cartesian coordinates:"))
10819 {
10820 { char* e = fgets(t,BSIZE,file);}
10821 { char* e = fgets(t,BSIZE,file);}
10822 { char* e = fgets(t,BSIZE,file);}
10823 OK = TRUE;
10824 break;
10825 }
10826 }
10827 if(!OK)
10828 {
10829 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
10830 return;
10831 }
10832
10833 j=-1;
10834 while(!feof(file) )
10835 {
10836 { char* e = fgets(t,BSIZE,file);}
10837 if (strstr(t,"-----------------------------------------"))
10838 {
10839 /*
10840 get_dipole_from_molcas_output_file(file);
10841 */
10842 break;
10843 }
10844 j++;
10845 if(GeomXYZ==NULL)GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10846 else
10847 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
10848 GeomXYZ[j].typeConnections = NULL;
10849
10850 sscanf(t,"%d %s %s %s %s",&idummy,symb,x,y,z);
10851
10852 for(i=0;i<(gint)strlen(symb);i++)
10853 if(isdigit(symb[i])) symb[i] = ' ';
10854 delete_all_spaces(symb);
10855
10856 symb[0]=toupper(symb[0]);
10857 l=strlen(symb);
10858 for(i=1;i<l;i++)
10859 symb[i]=tolower(symb[i]);
10860
10861 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10862 GeomXYZ[j].Symb=g_strdup(symb);
10863 GeomXYZ[j].mmType=g_strdup(symb);
10864 GeomXYZ[j].pdbType=g_strdup(symb);
10865 GeomXYZ[j].Residue=g_strdup(symb);
10866 GeomXYZ[j].ResidueNumber=0;
10867 if(Units == 1 )
10868 {
10869 GeomXYZ[j].X=g_strdup(bohr_to_ang(x));
10870 GeomXYZ[j].Y=g_strdup(bohr_to_ang(y));
10871 GeomXYZ[j].Z=g_strdup(bohr_to_ang(z));
10872 }
10873 else
10874 {
10875 GeomXYZ[j].X=g_strdup(x);
10876 GeomXYZ[j].Y=g_strdup(y);
10877 GeomXYZ[j].Z=g_strdup(z);
10878 }
10879 GeomXYZ[j].Charge=g_strdup("0.0");
10880 GeomXYZ[j].Layer=g_strdup(" ");
10881 }
10882 fclose(file);
10883 calculMMTypes(FALSE);
10884 NcentersXYZ = j+1;
10885
10886 if(GeomIsOpen)
10887 {
10888 append_list();
10889 }
10890 if(GeomDrawingArea != NULL) rafresh_drawing();
10891 if(iprogram == PROG_IS_GAUSS) set_spin_of_electrons();
10892 set_last_directory(NomFichier);
10893 }
10894 /********************************************************************************/
read_first_molpro_file(GabeditFileChooser * SelecFile,gint response_id)10895 void read_first_molpro_file(GabeditFileChooser *SelecFile, gint response_id)
10896 {
10897 gchar *t;
10898 gchar *NomFichier;
10899 gboolean OK;
10900 gchar *AtomCoord[5];
10901 FILE *fd;
10902 guint taille=BSIZE;
10903 guint idummy;
10904 guint i;
10905 gint j=0;
10906 gint l;
10907
10908 if(response_id != GTK_RESPONSE_OK) return;
10909
10910 for(i=0;i<5;i++)
10911 AtomCoord[i]=g_malloc(taille*sizeof(char));
10912 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
10913
10914 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
10915 {
10916 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
10917 return ;
10918 }
10919
10920 t=g_malloc(taille);
10921 fd = FOpen(NomFichier, "rb");
10922 if(fd ==NULL)
10923 {
10924 MessageGeom(_("Sorry\nI can not open this file"),_("Error"),TRUE);
10925 return;
10926 }
10927 OK=FALSE;
10928 while(!feof(fd)){
10929 { char* e = fgets(t,taille,fd);}
10930 if ( !strcmp(t," ATOMIC COORDINATES\n"))
10931 {
10932 { char* e = fgets(t,taille,fd);}
10933 { char* e = fgets(t,taille,fd);}
10934 { char* e = fgets(t,taille,fd);}
10935 OK = TRUE;
10936 break;
10937 }
10938 }
10939 if(!OK){
10940 MessageGeom(_("Sorry\nI can not read this file"),_("Error"),TRUE);
10941 return;
10942 }
10943
10944 j=-1;
10945 while(!feof(fd) )
10946 {
10947 { char* e = fgets(t,taille,fd);}
10948 if ( !strcmp(t,"\n"))
10949 {
10950 get_dipole_from_molpro_output_file(fd);
10951 break;
10952 }
10953 j++;
10954 if(GeomXYZ==NULL)GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
10955 else
10956 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
10957 GeomXYZ[j].typeConnections = NULL;
10958
10959 sscanf(t,"%d %s %s %s %s %s",&idummy,AtomCoord[0],AtomCoord[1],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
10960
10961 {
10962 gint k;
10963 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
10964 delete_all_spaces(AtomCoord[0]);
10965 }
10966
10967 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
10968 l=strlen(AtomCoord[0]);
10969 if (l==2)
10970 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
10971 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
10972 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
10973 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
10974 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
10975 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
10976 GeomXYZ[j].ResidueNumber=0;
10977 if(Units == 1 )
10978 {
10979 GeomXYZ[j].X=g_strdup(bohr_to_ang(AtomCoord[1]));
10980 GeomXYZ[j].Y=g_strdup(bohr_to_ang(AtomCoord[2]));
10981 GeomXYZ[j].Z=g_strdup(bohr_to_ang(AtomCoord[3]));
10982 }
10983 else
10984 {
10985 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
10986 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
10987 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
10988 }
10989 GeomXYZ[j].Charge=g_strdup("0.0");
10990 GeomXYZ[j].Layer=g_strdup(" ");
10991 }
10992
10993 fclose(fd);
10994 calculMMTypes(FALSE);
10995 NcentersXYZ = j+1;
10996 g_free(t);
10997 for(i=0;i<5;i++)
10998 g_free(AtomCoord[i]);
10999 if(GeomIsOpen)
11000 append_list();
11001 if(GeomDrawingArea != NULL)
11002 rafresh_drawing();
11003 if(iprogram == PROG_IS_GAUSS)
11004 set_spin_of_electrons();
11005 set_last_directory(NomFichier);
11006 }
11007 /********************************************************************************/
GeomXYZ_Change_Unit(gboolean toang)11008 static void GeomXYZ_Change_Unit(gboolean toang)
11009 {
11010 guint i;
11011 for(i=0;i<NcentersXYZ;i++)
11012 {
11013 if(test(GeomXYZ[i].X))
11014 {
11015 if(toang)
11016 GeomXYZ[i].X=bohr_to_ang(GeomXYZ[i].X);
11017 else
11018 GeomXYZ[i].X=ang_to_bohr(GeomXYZ[i].X);
11019 }
11020 if(test(GeomXYZ[i].Y))
11021 {
11022 if(toang)
11023 GeomXYZ[i].Y=bohr_to_ang(GeomXYZ[i].Y);
11024 else
11025 GeomXYZ[i].Y=ang_to_bohr(GeomXYZ[i].Y);
11026 }
11027 if(test(GeomXYZ[i].Z))
11028 {
11029 if(toang)
11030 GeomXYZ[i].Z=bohr_to_ang(GeomXYZ[i].Z);
11031 else
11032 GeomXYZ[i].Z=ang_to_bohr(GeomXYZ[i].Z);
11033 }
11034 }
11035 /* Variables */
11036 for(i=0;i<NVariablesXYZ;i++)
11037 {
11038 if(toang)
11039 VariablesXYZ[i].Value =bohr_to_ang( VariablesXYZ[i].Value);
11040 else
11041 VariablesXYZ[i].Value =ang_to_bohr( VariablesXYZ[i].Value);
11042 }
11043 }
11044 /*************************************************************************************/
read_XYZ_from_gamess_input_file(gchar * fileName)11045 void read_XYZ_from_gamess_input_file(gchar *fileName)
11046 {
11047 gchar *t;
11048 gboolean OK;
11049 gchar *AtomCoord[5];
11050 FILE *fd;
11051 guint taille=BSIZE;
11052 gint i;
11053 gint j;
11054 gint l;
11055 GeomXYZAtomDef* GeomXYZtemp=NULL;
11056 gint Ncent = 0;
11057 VariablesXYZDef* VariablesXYZtemp=NULL;
11058 gchar symb[BSIZE];
11059 gchar type[BSIZE];
11060 gchar charge[BSIZE];
11061 gboolean unitAng = TRUE;
11062
11063 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
11064
11065 t=g_malloc(taille);
11066 fd = FOpen(fileName, "rb");
11067 OK=TRUE;
11068 if(fd!=NULL)
11069 {
11070 while(!feof(fd) && OK )
11071 {
11072 if(!fgets(t,taille,fd))
11073 {
11074 OK = FALSE;
11075 break;
11076 };
11077 if(strstr(t,"molecule") && strstr(t,":"))
11078 {
11079 if(strstr(t,"<") && strstr(t,">"))
11080 {
11081 while(!feof(fd) && OK )
11082 {
11083 if(!fgets(t,taille,fd))
11084 {
11085 OK = FALSE;
11086 break;
11087 };
11088 if(strstr(t,"unit"))
11089 if(strstr(t,"bohr")) unitAng=FALSE;
11090 if (strstr(t,"atoms") && strstr(t,"geometry")) break;
11091 }
11092 }
11093 break;
11094 }
11095 }
11096 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11097 j=-1;
11098 while(!feof(fd) && OK )
11099 {
11100 j++;
11101 { char* e = fgets(t,taille,fd);}
11102 if(this_is_a_backspace(t)) break;
11103 if(strstr(t,"}")) break;
11104 i = sscanf(t,"%s ",AtomCoord[0]);
11105 if(i != 1)
11106 {
11107 OK = FALSE;
11108 break;
11109 }
11110 for(i=0;i<(gint)strlen(t);i++) if(t[i]=='[' || t[i] ==']') t[i]=' ';
11111 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11112
11113 if( i==4)
11114 {
11115 Ncent = j+1;
11116 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
11117 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11118 l=strlen(AtomCoord[0]);
11119 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11120 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11121 get_symb_type_charge(AtomCoord[0],symb,type,charge);
11122
11123 GeomXYZtemp[j].Symb=g_strdup(symb);
11124 GeomXYZtemp[j].mmType=g_strdup(type);
11125 GeomXYZtemp[j].pdbType=g_strdup(type);
11126 GeomXYZtemp[j].Charge=g_strdup(charge);
11127
11128 GeomXYZtemp[j].Residue=g_strdup("DUM");
11129 GeomXYZtemp[j].ResidueNumber=0;
11130 GeomXYZtemp[j].X=g_strdup_printf("%f",atof(AtomCoord[1]));
11131 GeomXYZtemp[j].Y=g_strdup_printf("%f",atof(AtomCoord[2]));
11132 GeomXYZtemp[j].Z=g_strdup_printf("%f",atof(AtomCoord[3]));
11133
11134 GeomXYZtemp[j].Layer=g_strdup(" ");
11135 GeomXYZtemp[j].typeConnections = NULL;
11136 }
11137 else OK = FALSE;
11138 }
11139 fclose(fd);
11140 }
11141 else OK = FALSE;
11142
11143 g_free(t);
11144 for(i=0;i<5;i++) g_free(AtomCoord[i]);
11145 if( !OK || Ncent <1 )
11146 {
11147 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, 0);
11148 MessageGeom(_("Sorry\n I can not read geometry from your Gamess input file"),_("Error"),TRUE);
11149 return;
11150 }
11151 if(GeomXYZ) freeGeomXYZ();
11152 if(VariablesXYZ) freeVariablesXYZ();
11153
11154 GeomXYZ = GeomXYZtemp;
11155 NcentersXYZ = Ncent;
11156 NVariablesXYZ = 0;
11157 VariablesXYZ = VariablesXYZtemp;
11158 MethodeGeom = GEOM_IS_XYZ;
11159 calculMMTypes(FALSE);
11160
11161 if( unitAng && Units== 0 ) GeomXYZ_Change_Unit(FALSE);
11162 else if( !unitAng && Units== 1 ) GeomXYZ_Change_Unit(TRUE);
11163
11164 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
11165
11166 if(GeomDrawingArea != NULL) rafresh_drawing();
11167 set_last_directory(fileName);
11168 }
11169 /*************************************************************************************/
read_XYZ_from_mpqc_input_file(gchar * fileName)11170 void read_XYZ_from_mpqc_input_file(gchar *fileName)
11171 {
11172 gchar *t;
11173 gboolean OK;
11174 gchar *AtomCoord[5];
11175 FILE *fd;
11176 guint taille=BSIZE;
11177 gint i;
11178 gint j;
11179 gint l;
11180 GeomXYZAtomDef* GeomXYZtemp=NULL;
11181 gint Ncent = 0;
11182 VariablesXYZDef* VariablesXYZtemp=NULL;
11183 gchar symb[BSIZE];
11184 gchar type[BSIZE];
11185 gchar charge[BSIZE];
11186 gboolean unitAng = TRUE;
11187
11188 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(char));
11189
11190 t=g_malloc(taille);
11191 fd = FOpen(fileName, "rb");
11192 OK=TRUE;
11193 if(fd!=NULL)
11194 {
11195 while(!feof(fd) && OK )
11196 {
11197 if(!fgets(t,taille,fd))
11198 {
11199 OK = FALSE;
11200 break;
11201 };
11202 if(strstr(t,"molecule") && strstr(t,":"))
11203 {
11204 if(strstr(t,"<") && strstr(t,">"))
11205 {
11206 while(!feof(fd) && OK )
11207 {
11208 if(!fgets(t,taille,fd))
11209 {
11210 OK = FALSE;
11211 break;
11212 };
11213 if(strstr(t,"unit"))
11214 if(strstr(t,"bohr")) unitAng=FALSE;
11215 if (strstr(t,"atoms") && strstr(t,"geometry")) break;
11216 }
11217 }
11218 break;
11219 }
11220 }
11221 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11222 j=-1;
11223 while(!feof(fd) && OK )
11224 {
11225 j++;
11226 { char* e = fgets(t,taille,fd);}
11227 if(this_is_a_backspace(t)) break;
11228 if(strstr(t,"}")) break;
11229 i = sscanf(t,"%s ",AtomCoord[0]);
11230 if(i != 1)
11231 {
11232 OK = FALSE;
11233 break;
11234 }
11235 for(i=0;i<(gint)strlen(t);i++) if(t[i]=='[' || t[i] ==']') t[i]=' ';
11236 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11237
11238 if( i==4)
11239 {
11240 Ncent = j+1;
11241 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
11242 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11243 l=strlen(AtomCoord[0]);
11244 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11245 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11246 get_symb_type_charge(AtomCoord[0],symb,type,charge);
11247
11248 GeomXYZtemp[j].Symb=g_strdup(symb);
11249 GeomXYZtemp[j].mmType=g_strdup(type);
11250 GeomXYZtemp[j].pdbType=g_strdup(type);
11251 GeomXYZtemp[j].Charge=g_strdup(charge);
11252
11253 GeomXYZtemp[j].Residue=g_strdup("DUM");
11254 GeomXYZtemp[j].ResidueNumber=0;
11255 GeomXYZtemp[j].X=g_strdup_printf("%f",atof(AtomCoord[1]));
11256 GeomXYZtemp[j].Y=g_strdup_printf("%f",atof(AtomCoord[2]));
11257 GeomXYZtemp[j].Z=g_strdup_printf("%f",atof(AtomCoord[3]));
11258
11259 GeomXYZtemp[j].Layer=g_strdup(" ");
11260 GeomXYZtemp[j].typeConnections = NULL;
11261 }
11262 else OK = FALSE;
11263 }
11264 fclose(fd);
11265 }
11266 else OK = FALSE;
11267
11268 g_free(t);
11269 for(i=0;i<5;i++) g_free(AtomCoord[i]);
11270 if( !OK || Ncent <1 )
11271 {
11272 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, 0);
11273 MessageGeom(_("Sorry\n I can not read geometry from your MPQC input file"),_("Error"),TRUE);
11274 return;
11275 }
11276 if(GeomXYZ) freeGeomXYZ();
11277 if(VariablesXYZ) freeVariablesXYZ();
11278
11279 GeomXYZ = GeomXYZtemp;
11280 NcentersXYZ = Ncent;
11281 NVariablesXYZ = 0;
11282 VariablesXYZ = VariablesXYZtemp;
11283 MethodeGeom = GEOM_IS_XYZ;
11284 calculMMTypes(FALSE);
11285
11286 if( unitAng && Units== 0 ) GeomXYZ_Change_Unit(FALSE);
11287 else if( !unitAng && Units== 1 ) GeomXYZ_Change_Unit(TRUE);
11288
11289 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
11290
11291 if(GeomDrawingArea != NULL) rafresh_drawing();
11292 set_last_directory(fileName);
11293 }
11294 /*************************************************************************************/
read_XYZ_from_molpro_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)11295 void read_XYZ_from_molpro_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
11296 {
11297 gchar *t;
11298 gchar *t1;
11299 gchar *t2;
11300 gchar *t3;
11301 gboolean OK;
11302 gchar *AtomCoord[5];
11303 FILE *fd;
11304 guint taille=BSIZE;
11305 guint i;
11306 gint j;
11307 gint l;
11308 gint Kvar=0;
11309 gboolean Uvar=FALSE;
11310 GeomXYZAtomDef* GeomXYZtemp=NULL;
11311 gint Ncent = 0;
11312 gint Nvar = 0;
11313 VariablesXYZDef* VariablesXYZtemp=NULL;
11314
11315 for(i=0;i<5;i++)
11316 AtomCoord[i]=g_malloc(taille*sizeof(char));
11317
11318
11319 t=g_malloc(taille);
11320 /* Read Geomery */
11321 fd = FOpen(NomFichier, "rb");
11322 OK=TRUE;
11323 if(fd!=NULL)
11324 {
11325 for(i=0;(gint)i<InfoFile.numline;i++) { char* e = fgets(t,taille,fd);}
11326 GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11327 { char* e = fgets(t,taille,fd);}
11328 Ncent=atoi(t);
11329 if(Ncent<1)
11330 {
11331 MessageGeom(_("Sorry\n i can not read XYZ geometry in molpro input file"),_("Error"),TRUE);
11332 return;
11333 }
11334 init_dipole();
11335 { char* e = fgets(t,taille,fd);}
11336 GeomXYZtemp=g_malloc(Ncent*sizeof(GeomXYZAtomDef));
11337 for(j = 0;j<Ncent ;j++)
11338 {
11339 GeomXYZtemp[j].Symb=NULL;
11340 GeomXYZtemp[j].mmType=NULL;
11341 GeomXYZtemp[j].pdbType=NULL;
11342 GeomXYZtemp[j].X=NULL;
11343 GeomXYZtemp[j].Y=NULL;
11344 GeomXYZtemp[j].Z=NULL;
11345 GeomXYZtemp[j].Charge=NULL;
11346 GeomXYZtemp[j].Layer=NULL;
11347 GeomXYZtemp[j].typeConnections = NULL;
11348 }
11349 Kvar = 0;
11350 for(j = 0;j<Ncent && OK ;j++)
11351 {
11352 { char* e = fgets(t,taille,fd);}
11353 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]) ;
11354 if( i != EOF && i == 4 )
11355 {
11356 DeleteLastChar(AtomCoord[0]);
11357 DeleteLastChar(AtomCoord[1]);
11358 DeleteLastChar(AtomCoord[2]);
11359
11360 {
11361 gint k;
11362 for(k=0;k<(gint)strlen(AtomCoord[0]);k++) if(isdigit(AtomCoord[0][k])) AtomCoord[0][k] = ' ';
11363 delete_all_spaces(AtomCoord[0]);
11364 }
11365 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11366 l=strlen(AtomCoord[0]);
11367 if (l==2)
11368 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11369 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11370 GeomXYZtemp[j].Symb=g_strdup(AtomCoord[0]);
11371 GeomXYZtemp[j].mmType=g_strdup(AtomCoord[0]);
11372 GeomXYZtemp[j].pdbType=g_strdup(AtomCoord[0]);
11373 GeomXYZtemp[j].Residue=g_strdup(AtomCoord[0]);
11374 GeomXYZtemp[j].ResidueNumber=0;
11375 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3]))
11376 Uvar = TRUE;
11377 if(!test(AtomCoord[1]))
11378 Kvar++;
11379 if(!test(AtomCoord[2]))
11380 Kvar++;
11381 if(!test(AtomCoord[3]))
11382 Kvar++;
11383 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
11384 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
11385 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
11386
11387 GeomXYZtemp[j].Charge=g_strdup("0.0");
11388 GeomXYZtemp[j].Layer=g_strdup(" ");
11389 }
11390 else
11391 {
11392 OK = FALSE;
11393 break;
11394 }
11395 }
11396 fclose(fd);
11397 }
11398 else
11399 OK = FALSE;
11400
11401 /* Read Variables */
11402 if(OK && Uvar )
11403 {
11404 Nvar = 0;
11405 fd = FOpen(NomFichier, "rb");
11406 if(fd!=NULL)
11407 {
11408 t2= g_strdup("Variables");
11409 uppercase(t2);
11410 while( !feof(fd) )
11411 {
11412 { char* e = fgets(t,taille,fd);}
11413 t1 = g_strdup(t);
11414 uppercase(t1);
11415 t3 = strstr(t1,t2);
11416 if(t3 != NULL)
11417 break;
11418 g_free(t1);
11419 }
11420 g_free(t2);
11421 while( !feof(fd) )
11422 {
11423 { char* e = fgets(t,taille,fd);}
11424 i = sscanf(t,"%s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2]);
11425 if( i != EOF && i == 3)
11426 {
11427 Nvar++;
11428 if(Nvar == 1)
11429 VariablesXYZtemp=g_malloc(sizeof(VariablesXYZDef));
11430 else
11431 VariablesXYZtemp=g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11432 DeleteLastChar(AtomCoord[2]);
11433 VariablesXYZtemp[Nvar-1].Name = g_strdup(AtomCoord[0]);
11434 VariablesXYZtemp[Nvar-1].Value = g_strdup(AtomCoord[2]);
11435 VariablesXYZtemp[Nvar-1].Used = TRUE;
11436 }
11437 else
11438 break;
11439 }
11440
11441 fclose(fd);
11442 }
11443 }
11444 g_free(t);
11445 for(i=0;i<5;i++)
11446 g_free(AtomCoord[i]);
11447 if( !OK || Ncent <1 || Nvar < Kvar)
11448 {
11449 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
11450 MessageGeom(_("Sorry\n I can not read geometry in Molpro input file"),_("Error"),TRUE);
11451 return;
11452 }
11453 if(GeomXYZ)
11454 freeGeomXYZ();
11455 if(VariablesXYZ)
11456 freeVariablesXYZ();
11457 GeomXYZ = GeomXYZtemp;
11458 NcentersXYZ = Ncent;
11459 NVariablesXYZ = Nvar;
11460 VariablesXYZ = VariablesXYZtemp;
11461 MethodeGeom = GEOM_IS_XYZ;
11462 calculMMTypes(FALSE);
11463 if( InfoFile.units== 1 && Units== 0 )
11464 GeomXYZ_Change_Unit(FALSE);
11465 else
11466 if( InfoFile.units== 0 && Units== 1 )
11467 GeomXYZ_Change_Unit(TRUE);
11468 if(GeomIsOpen)
11469 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
11470
11471 if(GeomDrawingArea != NULL)
11472 rafresh_drawing();
11473 set_last_directory(NomFichier);
11474 }
11475 /*************************************************************************************/
read_XYZ_from_demon_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)11476 void read_XYZ_from_demon_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
11477 {
11478 gchar *t;
11479 gboolean OK;
11480 gchar *AtomCoord[5];
11481 FILE *fd;
11482 guint taille=BSIZE;
11483 gint i;
11484 gint j;
11485 gint l;
11486 gboolean Uvar=FALSE;
11487 GeomXYZAtomDef* GeomXYZtemp=NULL;
11488 gint Ncent = 0;
11489 gint Nvar = 0;
11490 VariablesXYZDef* VariablesXYZtemp=NULL;
11491 gchar symb[BSIZE];
11492 gchar type[BSIZE];
11493 gchar charge[BSIZE];
11494
11495 for(i=0;i<5;i++)
11496 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
11497
11498 t=g_malloc(taille*sizeof(gchar));
11499 fd = FOpen(NomFichier, "rb");
11500 OK=TRUE;
11501 if(fd!=NULL)
11502 {
11503 for(i=0;i<InfoFile.numline-1;i++) { char* e = fgets(t,taille,fd);}
11504 GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11505 j=-1;
11506 while(!feof(fd) && OK )
11507 {
11508 j++;
11509 if(!fgets(t,taille,fd))break;
11510 deleteFirstSpaces(t);
11511 if(t[0] == '#') continue;
11512 if(t[0] == '\n') break;
11513 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
11514 if(i == (gint)strlen(t)-1) break;
11515 i = sscanf(t,"%s ",AtomCoord[0]);
11516 //fprintf(stderr,"%s\n",t);
11517 if(i != 1)
11518 {
11519 OK = FALSE;
11520 break;
11521 }
11522 uppercase(AtomCoord[0]);
11523 if(strstr(AtomCoord[0],"VARIA") )
11524 {
11525 Uvar = TRUE;
11526 break;
11527 }
11528 i = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11529 if( i!= 5 )
11530 {
11531 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11532 }
11533 if( i== 5 || i== 4)
11534 {
11535
11536 Ncent = j+1;
11537 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
11538 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11539 if(isdigit(AtomCoord[0][0]) || atoi(AtomCoord[0])<0)
11540 {
11541 gchar* sy = get_symbol_using_z(atoi(AtomCoord[0]));
11542 sprintf(AtomCoord[0],"%s",sy);
11543 g_free(sy);
11544 }
11545 l=strlen(AtomCoord[0]);
11546 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11547
11548 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11549
11550 get_symb_type_charge(AtomCoord[0],symb,type,charge);
11551 {
11552 gint k;
11553 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
11554 delete_all_spaces(symb);
11555 }
11556
11557 GeomXYZtemp[j].Symb=g_strdup(symb);
11558 GeomXYZtemp[j].mmType=g_strdup(type);
11559 GeomXYZtemp[j].pdbType=g_strdup(type);
11560 GeomXYZtemp[j].Charge=g_strdup(charge);
11561
11562 GeomXYZtemp[j].Residue=g_strdup("DUM");
11563 GeomXYZtemp[j].ResidueNumber=0;
11564 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3]))
11565 Uvar = TRUE;
11566 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
11567 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
11568 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
11569
11570 if(strstr(t,"Low")) GeomXYZtemp[j].Layer=g_strdup("Low");
11571 else if(strstr(t,"Med")) GeomXYZtemp[j].Layer=g_strdup("Medium");
11572 else GeomXYZtemp[j].Layer=g_strdup(" ");
11573 GeomXYZtemp[j].typeConnections = NULL;
11574 }
11575 else
11576 {
11577 OK = FALSE;
11578 }
11579 }
11580 /* Variables */
11581 Nvar=0;
11582 while(!feof(fd) && Uvar && OK )
11583 {
11584 if(!fgets(t,taille,fd))break;
11585 deleteFirstSpaces(t);
11586 if(t[0] == '#') continue;
11587 if(t[0] == '\n') continue;
11588 Nvar++;
11589 if(Nvar==1) VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
11590 else VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11591 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
11592 //fprintf(stderr,"ilue=%d\n",i);
11593 if( i == 2)
11594 {
11595 for(j=0;j<Ncent;j++)
11596 {
11597 sprintf(t,"%s%d",GeomXYZtemp[j].Symb,j+1);
11598 //fprintf(stderr,"%s<>%s\n", t,AtomCoord[0]);
11599 if(!strcmp(t,AtomCoord[0]))
11600 {
11601 //fprintf(stderr,"Okkkkkkkkkkkkkkkkkkkkkkkkkk\n");
11602 VariablesXYZtemp[Nvar-1].Name=g_strdup_printf("%s%s",AtomCoord[1],AtomCoord[0]);
11603 if(strstr(AtomCoord[1],"X") || strstr(AtomCoord[1],"x"))
11604 {
11605 VariablesXYZtemp[Nvar-1].Value= g_strdup_printf("%s",GeomXYZtemp[j].X);
11606 GeomXYZtemp[j].X=g_strdup(VariablesXYZtemp[Nvar-1].Name);
11607 }
11608 if(strstr(AtomCoord[1],"Y") || strstr(AtomCoord[1],"y"))
11609 {
11610 VariablesXYZtemp[Nvar-1].Value= g_strdup_printf("%s",GeomXYZtemp[j].Y);
11611 GeomXYZtemp[j].Y=g_strdup(VariablesXYZtemp[Nvar-1].Name);
11612 }
11613 if(strstr(AtomCoord[1],"Z") || strstr(AtomCoord[1],"z"))
11614 {
11615 VariablesXYZtemp[Nvar-1].Value= g_strdup_printf("%s",GeomXYZtemp[j].Z);
11616 GeomXYZtemp[j].Z=g_strdup(VariablesXYZtemp[Nvar-1].Name);
11617 }
11618 VariablesXYZtemp[Nvar-1].Used=TRUE;
11619 OK = TRUE;
11620 break;
11621 }
11622 }
11623 }
11624 else
11625 {
11626 Nvar--;
11627 VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11628 OK = FALSE;
11629 break;
11630 }
11631 }
11632 /* end while variables */
11633 fclose(fd);
11634 }
11635 else
11636 OK = FALSE;
11637
11638 g_free(t);
11639 for(i=0;i<5;i++)
11640 g_free(AtomCoord[i]);
11641 if( !OK || Ncent <1 )
11642 {
11643 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
11644 MessageGeom(_("Sorry\n I can not read geometry in DeMon input file"),_("Error"),TRUE);
11645 return;
11646 }
11647 if(GeomXYZ)
11648 freeGeomXYZ();
11649 if(VariablesXYZ)
11650 freeVariablesXYZ();
11651 GeomXYZ = GeomXYZtemp;
11652 NcentersXYZ = Ncent;
11653 NVariablesXYZ = Nvar;
11654 VariablesXYZ = VariablesXYZtemp;
11655 MethodeGeom = GEOM_IS_XYZ;
11656 if( InfoFile.units== 1 && Units== 0 )
11657 GeomXYZ_Change_Unit(FALSE);
11658 else
11659 if( InfoFile.units== 0 && Units== 1 )
11660 GeomXYZ_Change_Unit(TRUE);
11661 if(GeomIsOpen)
11662 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
11663
11664 if(GeomDrawingArea != NULL)
11665 rafresh_drawing();
11666 set_last_directory(NomFichier);
11667 }
11668 /*************************************************************************************/
read_XYZ_from_gauss_input_file(gchar * NomFichier,FilePosTypeGeom InfoFile)11669 void read_XYZ_from_gauss_input_file(gchar *NomFichier, FilePosTypeGeom InfoFile )
11670 {
11671 gchar *t;
11672 gboolean OK;
11673 gchar *AtomCoord[5];
11674 FILE *fd;
11675 guint taille=BSIZE;
11676 gint i;
11677 gint j;
11678 gint l;
11679 gboolean Uvar=FALSE;
11680 GeomXYZAtomDef* GeomXYZtemp=NULL;
11681 gint Ncent = 0;
11682 gint Nvar = 0;
11683 VariablesXYZDef* VariablesXYZtemp=NULL;
11684 gchar symb[BSIZE];
11685 gchar type[BSIZE];
11686 gchar charge[BSIZE];
11687
11688 for(i=0;i<5;i++)
11689 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
11690
11691 t=g_malloc(taille*sizeof(gchar));
11692 fd = FOpen(NomFichier, "rb");
11693 OK=TRUE;
11694 if(fd!=NULL)
11695 {
11696 for(i=0;i<InfoFile.numline-1;i++) { char* e = fgets(t,taille,fd);}
11697 GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11698 j=-1;
11699 while(!feof(fd) && OK )
11700 {
11701 j++;
11702 if(!fgets(t,taille,fd))break;
11703 if(t[0] == '\n') break;
11704 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
11705 if(i == (gint)strlen(t)-1) break;
11706 i = sscanf(t,"%s ",AtomCoord[0]);
11707 if(i != 1)
11708 {
11709 OK = FALSE;
11710 break;
11711 }
11712 if( !strcmp(AtomCoord[0],"Variables") )
11713 {
11714 Uvar = TRUE;
11715 break;
11716 }
11717 i = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11718 if( i!= 5 )
11719 {
11720 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11721 }
11722 if( i== 5 || i== 4)
11723 {
11724
11725 Ncent = j+1;
11726 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
11727 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11728 if(isdigit(AtomCoord[0][0]) || atoi(AtomCoord[0])<0)
11729 {
11730 gchar* sy = get_symbol_using_z(atoi(AtomCoord[0]));
11731 sprintf(AtomCoord[0],"%s",sy);
11732 g_free(sy);
11733 }
11734 l=strlen(AtomCoord[0]);
11735 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11736
11737 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11738
11739 get_symb_type_charge(AtomCoord[0],symb,type,charge);
11740 {
11741 gint k;
11742 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
11743 delete_all_spaces(symb);
11744 }
11745
11746 GeomXYZtemp[j].Symb=g_strdup(symb);
11747 GeomXYZtemp[j].mmType=g_strdup(type);
11748 GeomXYZtemp[j].pdbType=g_strdup(type);
11749 GeomXYZtemp[j].Charge=g_strdup(charge);
11750
11751 GeomXYZtemp[j].Residue=g_strdup("DUM");
11752 GeomXYZtemp[j].ResidueNumber=0;
11753 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3]))
11754 Uvar = TRUE;
11755 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
11756 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
11757 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
11758
11759 if(strstr(t,"Low")) GeomXYZtemp[j].Layer=g_strdup("Low");
11760 else if(strstr(t,"Med")) GeomXYZtemp[j].Layer=g_strdup("Medium");
11761 else GeomXYZtemp[j].Layer=g_strdup(" ");
11762 GeomXYZtemp[j].typeConnections = NULL;
11763 }
11764 else
11765 {
11766 OK = FALSE;
11767 }
11768 }
11769 /* Variables */
11770 Nvar=0;
11771 while(!feof(fd) && Uvar && OK )
11772 {
11773 { char* e = fgets(t,taille,fd);}
11774 OK=TRUE;
11775 for(i=0;i<(gint)strlen(t)-1;i++)
11776 if ( (int)t[i] != (int)' ' )
11777 OK=FALSE;
11778 if(OK)
11779 {
11780 OK = TRUE;
11781 break;
11782 }
11783 else
11784 {
11785 Nvar++;
11786 if(Nvar==1)
11787 VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
11788 else
11789 VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11790 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
11791 if( i == 2)
11792 {
11793 VariablesXYZtemp[Nvar-1].Name=g_strdup(AtomCoord[0]);
11794 VariablesXYZtemp[Nvar-1].Value=g_strdup(AtomCoord[1]);
11795 VariablesXYZtemp[Nvar-1].Used=TRUE;
11796 OK = TRUE;
11797 }
11798 else
11799 {
11800 Nvar--;
11801 VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11802 OK = FALSE;
11803 break;
11804 }
11805 }
11806 }
11807 /* end while variables */
11808 fclose(fd);
11809 }
11810 else
11811 OK = FALSE;
11812
11813 g_free(t);
11814 for(i=0;i<5;i++)
11815 g_free(AtomCoord[i]);
11816 if( !OK || Ncent <1 )
11817 {
11818 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
11819 MessageGeom(_("Sorry\n I can not read geometry in Gaussian input file"),_("Error"),TRUE);
11820 return;
11821 }
11822 if(GeomXYZ)
11823 freeGeomXYZ();
11824 if(VariablesXYZ)
11825 freeVariablesXYZ();
11826 GeomXYZ = GeomXYZtemp;
11827 NcentersXYZ = Ncent;
11828 NVariablesXYZ = Nvar;
11829 VariablesXYZ = VariablesXYZtemp;
11830 MethodeGeom = GEOM_IS_XYZ;
11831 if( InfoFile.units== 1 && Units== 0 )
11832 GeomXYZ_Change_Unit(FALSE);
11833 else
11834 if( InfoFile.units== 0 && Units== 1 )
11835 GeomXYZ_Change_Unit(TRUE);
11836 if(GeomIsOpen)
11837 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
11838
11839 if(GeomDrawingArea != NULL)
11840 rafresh_drawing();
11841 set_last_directory(NomFichier);
11842 }
11843 /*************************************************************************************/
read_XYZ_from_nwchem_input_file(gchar * NomFichier)11844 void read_XYZ_from_nwchem_input_file(gchar *NomFichier)
11845 {
11846 gchar *t;
11847 gboolean OK;
11848 gboolean icharge;
11849 gchar *AtomCoord[5];
11850 FILE *file;
11851 guint taille=BSIZE;
11852 gint i;
11853 gint j;
11854 gint l;
11855 gint k;
11856 gboolean Uvar=FALSE;
11857 GeomXYZAtomDef* GeomXYZtemp=NULL;
11858 gint Ncent = 0;
11859 gint Nvar = 0;
11860 VariablesXYZDef* VariablesXYZtemp=NULL;
11861 gchar symb[BSIZE];
11862 gchar type[BSIZE];
11863 gchar charge[BSIZE];
11864 gint globalCharge, mult;
11865
11866
11867
11868 file = FOpen(NomFichier, "rb");
11869 OK=TRUE;
11870 if(file==NULL)
11871 {
11872 MessageGeom(_("Sorry\n I can not read geometry in NWChem input file"),_("Error"),TRUE);
11873 return;
11874 }
11875 t=g_malloc(taille*sizeof(gchar));
11876 for(i=0;i<5;i++)
11877 AtomCoord[i]=g_malloc(taille*sizeof(char));
11878
11879 while(!feof(file))
11880 {
11881 if(!fgets(t,taille,file))
11882 {
11883 OK = FALSE;
11884 break;
11885 }
11886 uppercase(t);
11887 if(strstr(t,"GEOMETRY"))
11888 {
11889 OK = TRUE;
11890 break;
11891 }
11892 }
11893 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
11894 j=-1;
11895 while(!feof(file) && OK )
11896 {
11897 j++;
11898 if(!fgets(t,taille,file))break;
11899 uppercase(t);
11900 if(strstr(t,"ZMATRIX"))
11901 {
11902 g_free(GeomXYZtemp);
11903 MessageGeom(_("Sorry\n I can not zmatrix geometry from a NWChem input file"),_("Error"),TRUE);
11904 return;
11905 }
11906
11907 if(strstr(t,"END")) break;
11908 if(strstr(t,"SYMMETRY")) { j--; continue;}
11909 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
11910 if(i<=(gint)strlen(t) && t[i] == '*') break;
11911 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='{' || t[k]=='}') t[k] = ' ';
11912 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
11913 if(i== 4)
11914 {
11915
11916 Ncent = j+1;
11917 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
11918 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
11919 l=strlen(AtomCoord[0]);
11920 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
11921
11922 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
11923 get_symb_type_charge(AtomCoord[0],symb,type,charge);
11924 {
11925 gint k;
11926 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
11927 delete_all_spaces(symb);
11928 }
11929
11930 GeomXYZtemp[j].Symb=g_strdup(symb);
11931 GeomXYZtemp[j].mmType=g_strdup(type);
11932 GeomXYZtemp[j].pdbType=g_strdup(type);
11933 GeomXYZtemp[j].Charge=g_strdup(charge);
11934
11935 GeomXYZtemp[j].Residue=g_strdup("DUM");
11936 GeomXYZtemp[j].ResidueNumber=0;
11937 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3])) Uvar = TRUE;
11938 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
11939 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
11940 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
11941
11942 GeomXYZtemp[j].Layer=g_strdup(" ");
11943 GeomXYZtemp[j].typeConnections = NULL;
11944 }
11945 else
11946 OK = FALSE;
11947 }
11948 /* Variables */
11949 Nvar=0;
11950 fseek(file, 0L, SEEK_SET);
11951 if(Uvar)
11952 {
11953 OK =FALSE;
11954 while(!feof(file) && Uvar)
11955 {
11956 if(!fgets(t,taille,file)) break;
11957 uppercase(t);
11958 if(strstr(t,"VARIABLE"))
11959 {
11960 OK = TRUE;
11961 break;
11962 }
11963 }
11964 }
11965 while(!feof(file) && Uvar && OK )
11966 {
11967 uppercase(t);
11968 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
11969 for(j=0;j<Ncent;j++)
11970 {
11971 gchar* co[3] = {GeomXYZtemp[j].X,GeomXYZtemp[j].Y,GeomXYZtemp[j].Z};
11972 for(k=0;k<3;k++)
11973 if(!test(co[k]))
11974 {
11975 gchar* b = strstr(t,co[k]);
11976 if(b)
11977 {
11978 b = b+strlen(co[k])+1;
11979 Nvar++;
11980 if(Nvar==1) VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
11981 else VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
11982 VariablesXYZtemp[Nvar-1].Name=g_strdup(co[k]);
11983 VariablesXYZtemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
11984 VariablesXYZtemp[Nvar-1].Used=TRUE;
11985 }
11986 }
11987 }
11988 if(strstr(t,"END")) break;
11989 { char* e = fgets(t,taille,file);}
11990 }
11991 /* end while variables */
11992 fseek(file, 0L, SEEK_SET);
11993 icharge = FALSE;
11994 globalCharge = 0;
11995 mult = 0;
11996 while(OK && !feof(file))
11997 {
11998 if(!fgets(t,taille,file)) break;
11999 uppercase(t);
12000 if(strstr(t,"CHARGE") && 2==sscanf(t,"%s %d",AtomCoord[0],&globalCharge) )
12001 {
12002 icharge = TRUE;
12003 continue;
12004 }
12005 if(strstr(t,"SINGLET")) mult=1;
12006 if(strstr(t,"DOUBLET")) mult=2;
12007 if(strstr(t,"TRIPLET")) mult=3;
12008 if(strstr(t,"QUARTET")) mult=4;
12009 if(strstr(t,"QUINTET")) mult=5;
12010 if(strstr(t,"SEXTET")) mult=6;
12011 if(strstr(t,"SEPTET")) mult=7;
12012 if(strstr(t,"OCTET")) mult=8;
12013 if(strlen(t)>5 && strstr(t,"MULT") && sscanf(strstr(t,"MULT")+4,"%d",&k) && k>0 ) mult=k;
12014 if(strlen(t)>6 && strstr(t,"NOPEN") && sscanf(strstr(t,"NOOPEN")+5,"%d",&k) && k>0 ) mult=2*k;
12015 if(mult>0 && icharge) break;
12016 }
12017 fclose(file);
12018 g_free(t);
12019 if(OK)
12020 {
12021 TotalCharges[0] = globalCharge;
12022 if(mult>0) SpinMultiplicities[0] = mult;
12023 else reset_spin_of_electrons();
12024 }
12025
12026 for(i=0;i<5;i++) g_free(AtomCoord[i]);
12027 if( !OK || Ncent <1 )
12028 {
12029 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
12030 MessageGeom(_("Sorry\n I can not read geometry in NWChem input file"),_("Error"),TRUE);
12031 return;
12032 }
12033 if(GeomXYZ) freeGeomXYZ();
12034 if(VariablesXYZ) freeVariablesXYZ();
12035 GeomXYZ = GeomXYZtemp;
12036 NcentersXYZ = Ncent;
12037 NVariablesXYZ = Nvar;
12038 VariablesXYZ = VariablesXYZtemp;
12039 MethodeGeom = GEOM_IS_XYZ;
12040 calculMMTypes(FALSE);
12041 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
12042 if(GeomIsOpen)
12043 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
12044
12045 if(GeomDrawingArea != NULL)
12046 rafresh_drawing();
12047 set_last_directory(NomFichier);
12048 }
12049 /*************************************************************************************/
read_XYZ_from_psicode_input_file(gchar * NomFichier)12050 void read_XYZ_from_psicode_input_file(gchar *NomFichier)
12051 {
12052 gchar *t;
12053 gboolean OK;
12054 gboolean icharge;
12055 gchar *AtomCoord[5];
12056 FILE *file;
12057 guint taille=BSIZE;
12058 gint i;
12059 gint j;
12060 gint l;
12061 gint k;
12062 gboolean Uvar=FALSE;
12063 GeomXYZAtomDef* GeomXYZtemp=NULL;
12064 gint Ncent = 0;
12065 gint Nvar = 0;
12066 VariablesXYZDef* VariablesXYZtemp=NULL;
12067 gchar symb[BSIZE];
12068 gchar type[BSIZE];
12069 gchar charge[BSIZE];
12070 gint globalCharge, mult;
12071
12072
12073
12074 /* printf("Coucou\n");*/
12075 file = FOpen(NomFichier, "rb");
12076 OK=TRUE;
12077 if(file==NULL)
12078 {
12079 gchar* buffer = g_strdup_printf(_("Sorry\n I can not read geometry in Psicode input file %s"), NomFichier);
12080 MessageGeom(buffer,_("Error"),TRUE);
12081 g_free(buffer);
12082 return;
12083 }
12084 t=g_malloc(taille*sizeof(gchar));
12085 for(i=0;i<5;i++)
12086 AtomCoord[i]=g_malloc(taille*sizeof(char));
12087
12088 while(!feof(file))
12089 {
12090 if(!fgets(t,taille,file))
12091 {
12092 OK = FALSE;
12093 break;
12094 }
12095 uppercase(t);
12096 /*printf("t=%s\n", t);*/
12097 if(strstr(t,"MOLECULE"))
12098 {
12099 OK = TRUE;
12100 break;
12101 }
12102 }
12103 if(fgets(t,taille,file) && 2==sscanf(t,"%d %d",&globalCharge,&mult)) OK = TRUE;
12104 else OK = FALSE;
12105
12106 /*printf("charge = %d mult = %d\n", globalCharge, mult);*/
12107 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
12108 j=-1;
12109 while(!feof(file) && OK )
12110 {
12111 j++;
12112 if(!fgets(t,taille,file))break;
12113 uppercase(t);
12114 if(strstr(t,"SYMMETRY")) continue;
12115 if(strstr(t,"ZMATRIX"))
12116 {
12117 g_free(GeomXYZtemp);
12118 MessageGeom(_("Sorry\n I can not zmatrix geometry from a Psicode input file"),_("Error"),TRUE);
12119 return;
12120 }
12121
12122 if(strstr(t,"}")) break;
12123 if(this_is_a_backspace(t)) break;
12124 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ' && t[i]!= '\t') break;
12125 if(i<=(gint)strlen(t) && t[i] == '#') continue;
12126 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
12127 /* printf("t=%s\n", t);*/
12128 if(i== 4)
12129 {
12130
12131 Ncent = j+1;
12132 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
12133 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
12134 l=strlen(AtomCoord[0]);
12135 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
12136
12137 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
12138 get_symb_type_charge(AtomCoord[0],symb,type,charge);
12139 {
12140 gint k;
12141 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
12142 delete_all_spaces(symb);
12143 }
12144
12145 GeomXYZtemp[j].Symb=g_strdup(symb);
12146 GeomXYZtemp[j].mmType=g_strdup(type);
12147 GeomXYZtemp[j].pdbType=g_strdup(type);
12148 GeomXYZtemp[j].Charge=g_strdup(charge);
12149
12150 GeomXYZtemp[j].Residue=g_strdup("DUM");
12151 GeomXYZtemp[j].ResidueNumber=0;
12152 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3])) Uvar = TRUE;
12153 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
12154 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
12155 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
12156
12157 GeomXYZtemp[j].Layer=g_strdup(" ");
12158 GeomXYZtemp[j].typeConnections = NULL;
12159 }
12160 else
12161 OK = FALSE;
12162 }
12163 /* Variables */
12164 Nvar=0;
12165 while(!feof(file) && Uvar && OK )
12166 {
12167 uppercase(t);
12168 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
12169 for(j=0;j<Ncent;j++)
12170 {
12171 gchar* co[3] = {GeomXYZtemp[j].X,GeomXYZtemp[j].Y,GeomXYZtemp[j].Z};
12172 for(k=0;k<3;k++)
12173 if(!test(co[k]))
12174 {
12175 gchar* b = strstr(t,co[k]);
12176 if(b)
12177 {
12178 b = b+strlen(co[k])+1;
12179 Nvar++;
12180 if(Nvar==1) VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
12181 else VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
12182 VariablesXYZtemp[Nvar-1].Name=g_strdup(co[k]);
12183 VariablesXYZtemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
12184 VariablesXYZtemp[Nvar-1].Used=TRUE;
12185 }
12186 }
12187 }
12188 if(strstr(t,"}")) break;
12189 { char* e = fgets(t,taille,file);}
12190 }
12191 /* end while variables */
12192 fclose(file);
12193 g_free(t);
12194 for(i=0;i<5;i++) g_free(AtomCoord[i]);
12195 if( !OK || Ncent <1 )
12196 {
12197 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
12198 MessageGeom(_("Sorry\n I can not read geometry in Psicode input file"),_("Error"),TRUE);
12199 return;
12200 }
12201 TotalCharges[0] = globalCharge;
12202 SpinMultiplicities[0]=mult;
12203 if(GeomXYZ) freeGeomXYZ();
12204 if(VariablesXYZ) freeVariablesXYZ();
12205 GeomXYZ = GeomXYZtemp;
12206 NcentersXYZ = Ncent;
12207 NVariablesXYZ = Nvar;
12208 VariablesXYZ = VariablesXYZtemp;
12209 MethodeGeom = GEOM_IS_XYZ;
12210 calculMMTypes(FALSE);
12211 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
12212 if(GeomIsOpen)
12213 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
12214
12215 if(GeomDrawingArea != NULL)
12216 rafresh_drawing();
12217 set_last_directory(NomFichier);
12218 }
12219 /*************************************************************************************/
read_XYZ_from_orca_input_file(gchar * NomFichier)12220 void read_XYZ_from_orca_input_file(gchar *NomFichier)
12221 {
12222 gchar *t;
12223 gboolean OK;
12224 gchar *AtomCoord[5];
12225 FILE *file;
12226 guint taille=BSIZE;
12227 gint i;
12228 gint j;
12229 gint l;
12230 gint k;
12231 gboolean Uvar=FALSE;
12232 GeomXYZAtomDef* GeomXYZtemp=NULL;
12233 gint Ncent = 0;
12234 gint Nvar = 0;
12235 VariablesXYZDef* VariablesXYZtemp=NULL;
12236 gchar symb[BSIZE];
12237 gchar type[BSIZE];
12238 gchar charge[BSIZE];
12239 gint globalCharge, mult;
12240
12241
12242
12243 file = FOpen(NomFichier, "rb");
12244 OK=TRUE;
12245 if(file==NULL)
12246 {
12247 MessageGeom(_("Sorry\n I can not read geometry in Orca input file"),_("Error"),TRUE);
12248 return;
12249 }
12250 t=g_malloc(taille*sizeof(gchar));
12251 for(i=0;i<5;i++)
12252 AtomCoord[i]=g_malloc(taille*sizeof(char));
12253
12254 while(!feof(file))
12255 {
12256 if(!fgets(t,taille,file))
12257 {
12258 OK = FALSE;
12259 break;
12260 }
12261 uppercase(t);
12262 if(strstr(t,"* XYZ") && 4==sscanf(t,"%s %s %d %d",AtomCoord[0],AtomCoord[1],&globalCharge, &mult) )
12263 {
12264 OK = TRUE;
12265 break;
12266 }
12267 }
12268 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
12269 j=-1;
12270 while(!feof(file) && OK )
12271 {
12272 j++;
12273 { char* e = fgets(t,taille,file);}
12274 for(i=0;i<(gint)strlen(t);i++) if(t[i] != ' ') break;
12275 if(i<=(gint)strlen(t) && t[i] == '*') break;
12276 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='{' || t[k]=='}') t[k] = ' ';
12277 i = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
12278 if( i!= 5 )
12279 {
12280 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
12281 }
12282 if( i== 5 || i== 4)
12283 {
12284
12285 Ncent = j+1;
12286 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
12287 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
12288 l=strlen(AtomCoord[0]);
12289 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
12290 if(!strcmp(AtomCoord[0],"Da")) sprintf(AtomCoord[0],"X");
12291
12292 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
12293 get_symb_type_charge(AtomCoord[0],symb,type,charge);
12294 {
12295 gint k;
12296 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
12297 delete_all_spaces(symb);
12298 }
12299
12300 GeomXYZtemp[j].Symb=g_strdup(symb);
12301 GeomXYZtemp[j].mmType=g_strdup(type);
12302 GeomXYZtemp[j].pdbType=g_strdup(type);
12303 GeomXYZtemp[j].Charge=g_strdup(charge);
12304
12305 GeomXYZtemp[j].Residue=g_strdup("DUM");
12306 GeomXYZtemp[j].ResidueNumber=0;
12307 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3]))
12308 Uvar = TRUE;
12309 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
12310 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
12311 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
12312
12313 GeomXYZtemp[j].Layer=g_strdup(" ");
12314 GeomXYZtemp[j].typeConnections = NULL;
12315 }
12316 else
12317 OK = FALSE;
12318 }
12319 /* Variables */
12320 Nvar=0;
12321 fseek(file, 0L, SEEK_SET);
12322 if(Uvar)
12323 {
12324 OK =FALSE;
12325 while(!feof(file) && Uvar)
12326 {
12327 if(!fgets(t,taille,file)) break;
12328 uppercase(t);
12329 if(strstr(t,"PARAS"))
12330 {
12331 OK = TRUE;
12332 break;
12333 }
12334 }
12335 }
12336 while(!feof(file) && Uvar && OK )
12337 {
12338 uppercase(t);
12339 for(k=0;k<(gint)strlen(t);k++) if(t[k]=='=') t[k] = ' ';
12340 for(j=0;j<Ncent;j++)
12341 {
12342 gchar* co[3] = {GeomXYZtemp[j].X,GeomXYZtemp[j].Y,GeomXYZtemp[j].Z};
12343 for(k=0;k<3;k++)
12344 if(!test(co[k]))
12345 {
12346 gchar* b = strstr(t,co[k]);
12347 if(b)
12348 {
12349 b = b+strlen(co[k])+1;
12350 Nvar++;
12351 if(Nvar==1) VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
12352 else VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
12353 VariablesXYZtemp[Nvar-1].Name=g_strdup(co[k]);
12354 VariablesXYZtemp[Nvar-1].Value=g_strdup_printf("%f",atof(b));
12355 VariablesXYZtemp[Nvar-1].Used=TRUE;
12356 }
12357 }
12358 }
12359 if(strstr(t,"END")) break;
12360 { char* e = fgets(t,taille,file);}
12361 }
12362 /* end while variables */
12363 fclose(file);
12364 if(OK)
12365 {
12366 TotalCharges[0] = globalCharge;
12367 SpinMultiplicities[0] = mult;
12368 }
12369
12370 g_free(t);
12371 for(i=0;i<5;i++) g_free(AtomCoord[i]);
12372 if( !OK || Ncent <1 )
12373 {
12374 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
12375 MessageGeom(_("Sorry\n I can not read geometry in Orca input file"),_("Error"),TRUE);
12376 return;
12377 }
12378 if(GeomXYZ) freeGeomXYZ();
12379 if(VariablesXYZ) freeVariablesXYZ();
12380 GeomXYZ = GeomXYZtemp;
12381 NcentersXYZ = Ncent;
12382 NVariablesXYZ = Nvar;
12383 VariablesXYZ = VariablesXYZtemp;
12384 MethodeGeom = GEOM_IS_XYZ;
12385 calculMMTypes(FALSE);
12386 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
12387 if(GeomIsOpen)
12388 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
12389
12390 if(GeomDrawingArea != NULL)
12391 rafresh_drawing();
12392 set_last_directory(NomFichier);
12393 }
12394 /*************************************************************************************/
read_XYZ_from_qchem_input_file(gchar * NomFichier)12395 void read_XYZ_from_qchem_input_file(gchar *NomFichier)
12396 {
12397 gchar *t;
12398 gboolean OK;
12399 gchar *AtomCoord[5];
12400 FILE *fd;
12401 guint taille=BSIZE;
12402 gint i;
12403 gint j;
12404 gint l;
12405 gboolean Uvar=FALSE;
12406 GeomXYZAtomDef* GeomXYZtemp=NULL;
12407 gint Ncent = 0;
12408 gint Nvar = 0;
12409 VariablesXYZDef* VariablesXYZtemp=NULL;
12410 gchar symb[BSIZE];
12411 gchar type[BSIZE];
12412 gchar charge[BSIZE];
12413
12414 for(i=0;i<5;i++)
12415 AtomCoord[i]=g_malloc(taille*sizeof(char));
12416
12417
12418 t=g_malloc(taille);
12419 fd = FOpen(NomFichier, "rb");
12420
12421 OK=TRUE;
12422 if(fd!=NULL)
12423 {
12424 while(!feof(fd))
12425 {
12426 if(!fgets(t,taille,fd))
12427 {
12428 OK = FALSE;
12429 break;
12430 }
12431 uppercase(t);
12432 if(strstr(t,"$MOLECULE"))
12433 {
12434 { char* e = fgets(t,taille,fd);} /* charge and spin */
12435 OK = TRUE;
12436 break;
12437 }
12438 }
12439 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
12440 j=-1;
12441 while(!feof(fd) && OK )
12442 {
12443 j++;
12444 { char* e = fgets(t,taille,fd);}
12445 if(strstr(t,"$")) break;
12446 if(t[0] == '\n') break;
12447 for(i=0;i<(gint)strlen(t);i++)
12448 if(t[i] != ' ') break;
12449
12450 if(i == (gint)strlen(t)-1) break;
12451
12452 i = sscanf(t,"%s ",AtomCoord[0]);
12453 if(i != 1)
12454 {
12455 OK = FALSE;
12456 break;
12457 }
12458 if( !strcmp(AtomCoord[0],"Variables") )
12459 {
12460 Uvar = TRUE;
12461 break;
12462 }
12463 i = sscanf(t,"%s %s %s %s %s",AtomCoord[0],AtomCoord[4],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
12464 if( i!= 5 )
12465 {
12466 i = sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
12467 }
12468 if( i== 5 || i== 4)
12469 {
12470
12471 Ncent = j+1;
12472 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
12473 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
12474 if(isdigit(AtomCoord[0][0]))
12475 {
12476 gchar* sy = get_symbol_using_z(atoi(AtomCoord[0]));
12477 sprintf(AtomCoord[0],"%s",sy);
12478 g_free(sy);
12479 }
12480 l=strlen(AtomCoord[0]);
12481 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
12482
12483 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
12484 get_symb_type_charge(AtomCoord[0],symb,type,charge);
12485 {
12486 gint k;
12487 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
12488 delete_all_spaces(symb);
12489 }
12490
12491 GeomXYZtemp[j].Symb=g_strdup(symb);
12492 GeomXYZtemp[j].mmType=g_strdup(type);
12493 GeomXYZtemp[j].pdbType=g_strdup(type);
12494 GeomXYZtemp[j].Charge=g_strdup(charge);
12495
12496 GeomXYZtemp[j].Residue=g_strdup("DUM");
12497 GeomXYZtemp[j].ResidueNumber=0;
12498 if(!test(AtomCoord[1]) || !test(AtomCoord[2]) || !test(AtomCoord[3]))
12499 Uvar = TRUE;
12500 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
12501 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
12502 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
12503
12504 GeomXYZtemp[j].Layer=g_strdup(" ");
12505 GeomXYZtemp[j].typeConnections = NULL;
12506 }
12507 else
12508 {
12509 OK = FALSE;
12510 }
12511 }
12512 /* Variables */
12513 Nvar=0;
12514 while(!feof(fd) && Uvar && OK )
12515 {
12516 { char* e = fgets(t,taille,fd);}
12517 OK=TRUE;
12518 for(i=0;i<(gint)strlen(t)-1;i++)
12519 if ( (int)t[i] != (int)' ' )
12520 OK=FALSE;
12521 if(OK || strstr(t,"$"))
12522 {
12523 OK = TRUE; /* sortie normale*/
12524 break;
12525 }
12526 else
12527 {
12528 Nvar++;
12529 if(Nvar==1)
12530 VariablesXYZtemp = g_malloc(Nvar*sizeof(VariablesXYZDef));
12531 else
12532 VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
12533 i = sscanf(t,"%s %s",AtomCoord[0],AtomCoord[1]);
12534 if( i == 2)
12535 {
12536 VariablesXYZtemp[Nvar-1].Name=g_strdup(AtomCoord[0]);
12537 VariablesXYZtemp[Nvar-1].Value=g_strdup(AtomCoord[1]);
12538 VariablesXYZtemp[Nvar-1].Used=TRUE;
12539 OK = TRUE;
12540 }
12541 else
12542 {
12543 Nvar--;
12544 VariablesXYZtemp = g_realloc(VariablesXYZtemp,Nvar*sizeof(VariablesXYZDef));
12545 OK = FALSE;
12546 break;
12547 }
12548 }
12549 }
12550 /* end while variables */
12551 fclose(fd);
12552 }
12553 else
12554 OK = FALSE;
12555
12556 g_free(t);
12557 for(i=0;i<5;i++)
12558 g_free(AtomCoord[i]);
12559 if( !OK || Ncent <1 )
12560 {
12561 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
12562 MessageGeom(_("Sorry\n I can not read geometry in QChem input file"),_("Error"),TRUE);
12563 return;
12564 }
12565 if(GeomXYZ)
12566 freeGeomXYZ();
12567 if(VariablesXYZ)
12568 freeVariablesXYZ();
12569 GeomXYZ = GeomXYZtemp;
12570 NcentersXYZ = Ncent;
12571 NVariablesXYZ = Nvar;
12572 VariablesXYZ = VariablesXYZtemp;
12573 MethodeGeom = GEOM_IS_XYZ;
12574 calculMMTypes(FALSE);
12575 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
12576 if(GeomIsOpen)
12577 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
12578
12579 if(GeomDrawingArea != NULL)
12580 rafresh_drawing();
12581 set_last_directory(NomFichier);
12582 }
12583 /********************************************************************************/
trans_coordXYZ_geom(gchar T,GeomXYZAtomDef * myGeomXYZ,gint i,VariablesXYZDef * myVariablesXYZ,gint iv)12584 static void trans_coordXYZ_geom(gchar T, GeomXYZAtomDef* myGeomXYZ, gint i, VariablesXYZDef* myVariablesXYZ, gint iv)
12585 {
12586 gdouble V;
12587 gchar *NameV;
12588 gchar *ValueV;
12589
12590 V = atof(myGeomXYZ[i].X);
12591 if( T == 'Y' ) V = atof(myGeomXYZ[i].Y);
12592 if( T == 'Z' ) V = atof(myGeomXYZ[i].Z);
12593 NameV = g_strdup_printf("%c%s%d",T,myGeomXYZ[i].Symb,i+1);
12594 ValueV = g_strdup_printf("%f",V);
12595 if( T == 'X' ) { g_free(myGeomXYZ[i].X); myGeomXYZ[i].X=g_strdup(NameV);}
12596 if( T == 'Y' ) { g_free(myGeomXYZ[i].Y); myGeomXYZ[i].Y=g_strdup(NameV);}
12597 if( T == 'Z' ) { g_free(myGeomXYZ[i].Z); myGeomXYZ[i].Z=g_strdup(NameV);}
12598 myVariablesXYZ[iv].Name = g_strdup(NameV);
12599 myVariablesXYZ[iv].Value = g_strdup(ValueV);
12600 }
12601 /********************************************************************************/
get_charge_and_multiplicity_from_mopac_input_file(FILE * fd)12602 static void get_charge_and_multiplicity_from_mopac_input_file(FILE* fd)
12603 {
12604 guint taille=BSIZE;
12605 gchar t[BSIZE];
12606 gint i;
12607
12608 TotalCharges[0] = 0;
12609 SpinMultiplicities[0] =1;
12610
12611 fseek(fd, 0L, SEEK_SET);
12612 while(!feof(fd) )
12613 {
12614 if(!fgets(t, taille, fd)) return;
12615 if(t[0] !='*') break;
12616 }
12617 for(i=0;i<2;i++)
12618 {
12619 uppercase(t);
12620 if ( strstr(t,"CHARGE") && strstr(t,"="))
12621 {
12622 gchar* p = strstr(t,"=")+1;
12623 TotalCharges[0] = atoi(p);
12624 }
12625 if ( strstr(t,"SINGLET")) SpinMultiplicities[0] = 1;
12626 if ( strstr(t,"DOUBLET")) SpinMultiplicities[0] = 2;
12627 if ( strstr(t,"TRIPLET")) SpinMultiplicities[0] = 3;
12628 if ( strstr(t,"QUARTET")) SpinMultiplicities[0] = 4;
12629 if ( strstr(t,"QUINTET")) SpinMultiplicities[0] = 5;
12630 if ( strstr(t,"SEXTET")) SpinMultiplicities[0] = 6;
12631 if(!fgets(t,taille,fd)) break;
12632 }
12633 }
12634 /*************************************************************************************/
read_XYZ_from_mopac_input_file(gchar * NomFichier)12635 void read_XYZ_from_mopac_input_file(gchar *NomFichier)
12636 {
12637 gchar *t;
12638 gboolean OK;
12639 gchar *AtomCoord[5];
12640 FILE *fd;
12641 guint taille=BSIZE;
12642 gint i;
12643 gint j;
12644 gint l;
12645 /*gboolean Uvar=FALSE;*/
12646 GeomXYZAtomDef* GeomXYZtemp=NULL;
12647 gint Ncent = 0;
12648 gint Nvar = 0;
12649 VariablesXYZDef* VariablesXYZtemp=NULL;
12650 gchar symb[BSIZE];
12651 gchar type[BSIZE];
12652 gchar charge[BSIZE];
12653 gint k1,k2,k3;
12654
12655 for(i=0;i<5;i++)
12656 AtomCoord[i]=g_malloc(taille*sizeof(gchar));
12657
12658
12659 t=g_malloc(taille);
12660 fd = FOpen(NomFichier, "rb");
12661
12662 OK=TRUE;
12663 j = -1;
12664 if(fd!=NULL)
12665 {
12666 while(!feof(fd) )
12667 {
12668 if(!fgets(t, taille, fd)) {OK = FALSE; break;}
12669 if(t[0] !='*') break;
12670 }
12671 if(!fgets(t, taille, fd)) OK = FALSE;
12672 if(!fgets(t, taille, fd)) OK = FALSE;
12673
12674 if(OK) GeomXYZtemp=g_malloc(sizeof(GeomXYZAtomDef));
12675 j=-1;
12676 while(!feof(fd) && OK )
12677 {
12678 j++;
12679 if(!fgets(t,taille,fd)) break;
12680 if(this_is_a_backspace(t)) break;
12681 if(t[0] == '0') break;
12682 for(i=0;i<(gint)strlen(t);i++)
12683 if(t[i] != ' ') break;
12684 if(i == (gint)strlen(t)-1) break;
12685 i = sscanf(t,"%s ",AtomCoord[0]);
12686 if(i != 1)
12687 {
12688 OK = FALSE;
12689 break;
12690 }
12691 i = sscanf(t,"%s %s %d %s %d %s %d",
12692 AtomCoord[0],
12693 AtomCoord[1],&k1,AtomCoord[2],&k2,AtomCoord[3],&k3);
12694 if( i== 7)
12695 {
12696 gint newVar = 0;
12697
12698 Ncent = j+1;
12699 GeomXYZtemp=g_realloc(GeomXYZtemp,Ncent*sizeof(GeomXYZAtomDef));
12700 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
12701 l=strlen(AtomCoord[0]);
12702 if (l>=2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
12703
12704 GeomXYZtemp[j].Nentry=NUMBER_LIST_XYZ;
12705 get_symb_type_charge(AtomCoord[0],symb,type,charge);
12706 {
12707 gint k;
12708 for(k=0;k<(gint)strlen(symb);k++) if(isdigit(symb[k])) symb[k] = ' ';
12709 delete_all_spaces(symb);
12710 }
12711
12712 GeomXYZtemp[j].Symb=g_strdup(symb);
12713 GeomXYZtemp[j].mmType=g_strdup(type);
12714 GeomXYZtemp[j].pdbType=g_strdup(type);
12715 GeomXYZtemp[j].Charge=g_strdup(charge);
12716
12717 GeomXYZtemp[j].Residue=g_strdup("DUM");
12718 GeomXYZtemp[j].ResidueNumber=0;
12719 GeomXYZtemp[j].X=g_strdup(AtomCoord[1]);
12720 GeomXYZtemp[j].Y=g_strdup(AtomCoord[2]);
12721 GeomXYZtemp[j].Z=g_strdup(AtomCoord[3]);
12722 GeomXYZtemp[j].Layer=g_strdup(" ");
12723 GeomXYZtemp[j].typeConnections = NULL;
12724 /* if(k1 ==1 || k2 == 1 || k3==1) Uvar = TRUE;*/
12725 if(k1==1) newVar++;
12726 if(k2==1) newVar++;
12727 if(k3==1) newVar++;
12728 if(newVar>0)
12729 {
12730 gint n = Nvar+newVar;
12731 if(n==1)
12732 VariablesXYZtemp = g_malloc(n*sizeof(VariablesXYZDef));
12733 else
12734 VariablesXYZtemp = g_realloc(VariablesXYZtemp,n*sizeof(VariablesXYZDef));
12735 }
12736 newVar = 0;
12737 if(k1==1)
12738 {
12739 newVar++;
12740 trans_coordXYZ_geom('X', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
12741 }
12742 if(k2==1)
12743 {
12744 newVar++;
12745 trans_coordXYZ_geom('Y', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
12746 }
12747 if(k3==1)
12748 {
12749 newVar++;
12750 trans_coordXYZ_geom('Z', GeomXYZtemp, j, VariablesXYZtemp, Nvar+newVar-1);
12751 }
12752 Nvar += newVar;
12753
12754 }
12755 else
12756 {
12757 OK = FALSE;
12758 }
12759 }
12760 }
12761 if(j<0) OK = FALSE;
12762 else get_charge_and_multiplicity_from_mopac_input_file(fd);
12763 fclose(fd);
12764
12765 g_free(t);
12766 for(i=0;i<5;i++) g_free(AtomCoord[i]);
12767 if( !OK || Ncent <1 )
12768 {
12769 FreeGeomXYZ(GeomXYZtemp,VariablesXYZtemp,Ncent, Nvar);
12770 MessageGeom(_("Sorry\n I can not read geometry in Mopac input file"),_("Error"),TRUE);
12771 return;
12772 }
12773 if(GeomXYZ) freeGeomXYZ();
12774 if(VariablesXYZ) freeVariablesXYZ();
12775 GeomXYZ = GeomXYZtemp;
12776 NcentersXYZ = Ncent;
12777 NVariablesXYZ = Nvar;
12778 VariablesXYZ = VariablesXYZtemp;
12779 MethodeGeom = GEOM_IS_XYZ;
12780 calculMMTypes(FALSE);
12781 if( Units== 0 ) GeomXYZ_Change_Unit(FALSE);
12782 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
12783
12784 if(GeomDrawingArea != NULL) rafresh_drawing();
12785 set_last_directory(NomFichier);
12786 }
12787 /*************************************************************************************/
get_pdbtype_charge_from_tinker_amber_key_file(gchar * NomFichier,gchar *** types,gchar *** residues,gdouble ** charges)12788 static gint get_pdbtype_charge_from_tinker_amber_key_file(
12789 gchar* NomFichier,
12790 gchar***types,
12791 gchar***residues,
12792 gdouble**charges)
12793 {
12794 FILE *file;
12795 gint n = 0;
12796 gchar* tstr = NULL;
12797 gchar sdum0[100];
12798 gchar sdum1[100];
12799 gchar sdum2[100];
12800 gchar sdum3[500];
12801 gchar res[100];
12802 gint idum;
12803 gint k;
12804 gchar** pdbTypes = NULL;
12805 gchar** residueNames = NULL;
12806 gdouble* chargesValue = NULL;
12807 gdouble ddum;
12808 gint i;
12809 gchar *fileNameKey = NULL;
12810 gchar *fileNameParameters = NULL;
12811
12812 *charges = chargesValue;
12813 *types = pdbTypes;
12814 *residues = residueNames;
12815
12816 fileNameKey = get_suffix_name_file(NomFichier);
12817 fileNameKey = g_strdup_printf("%s.key",fileNameKey);
12818 /* printf("Key file = %s\n", fileNameKey);*/
12819 file = FOpen(fileNameKey, "rb");
12820 if(fileNameKey) g_free(fileNameKey);
12821 if(file == NULL) return 0;
12822 tstr = g_malloc(BSIZE*sizeof(gchar));
12823 sprintf(sdum1,"NO");
12824 while(!feof(file))
12825 {
12826 if(!fgets(tstr,BSIZE,file)) break;
12827 k = sscanf(tstr,"%s %s",sdum1,sdum3);
12828 if(k!=2) continue;
12829 if(!strstr(sdum1,"parameters")) continue;
12830 if(strstr(sdum3,".prm")) fileNameParameters = g_strdup(sdum3);
12831 else fileNameParameters = g_strdup_printf("%s.prm",sdum3);
12832 }
12833 fclose(file);
12834 /* printf("param file = %s\n", fileNameParameters);*/
12835 if(!fileNameParameters) return 0;
12836
12837 file = FOpen(fileNameParameters, "rb");
12838 if(file == NULL) return 0;
12839
12840 fseek(file, 0L, SEEK_SET);
12841 /* get the number of pdb type */
12842 n = 0;
12843 while(!feof(file))
12844 {
12845 if(!fgets(tstr,BSIZE,file)) break;
12846 k = sscanf(tstr,"%s %d %s %s",sdum1,&idum,sdum2,sdum3);
12847 if(k!=4) continue;
12848 if(idum<1) continue;
12849 if(!strstr(sdum1,"biotyp")) continue;
12850 n++;
12851 if(idum>n) n = idum;
12852 }
12853 if(n==0)
12854 {
12855 fclose(file);
12856 return 0;
12857 }
12858 pdbTypes = g_malloc(n*sizeof(gchar*));
12859 residueNames = g_malloc(n*sizeof(gchar*));
12860 chargesValue = g_malloc(n*sizeof(gdouble));
12861 for(i=0;i<n;i++)
12862 {
12863 pdbTypes[i] = NULL;
12864 residueNames[i] = NULL;
12865 chargesValue[i] = 0.0;
12866 }
12867 fseek(file, 0L, SEEK_SET);
12868 /* set pdb type, residueNames */
12869 while(!feof(file))
12870 {
12871 if(!fgets(tstr,BSIZE,file)) break;
12872 if(strstr(tstr,"N-Terminal") || strstr(tstr,"C-Terminal"))
12873 {
12874 k = sscanf(tstr,"%s %d %s %s %s",sdum1,&idum,sdum2,sdum0,sdum3);
12875 k--;
12876 }
12877 else k = sscanf(tstr,"%s %d %s %s",sdum1,&idum,sdum2,sdum3);
12878 if(k!=4) continue;
12879 if(idum<1) continue;
12880 if(!strstr(sdum1,"biotyp")) continue;
12881 if(idum>n) continue;
12882 i = idum-1;
12883 pdbTypes[i] = g_strdup(sdum2);
12884 sprintf(res,"UNK");
12885 k = 0;
12886 for(i=0;i<strlen(sdum3);i++)
12887 {
12888 if(sdum3[i]=='"') continue;
12889 res[k++] = toupper(sdum3[i]);
12890 if(k>2)break;
12891 }
12892 if(strstr(sdum3,"C-Terminus"))sprintf(res,"NME");
12893 else if(strstr(sdum3,"N-Terminus"))sprintf(res,"ACE");
12894 else if(strstr(sdum3,"C-Terminal"))sprintf(res,"CTE");
12895 else if(strstr(sdum3,"Adenosine"))sprintf(res,"DA");
12896 else if(strstr(sdum3,"Guanosine"))sprintf(res,"DG");
12897 else if(strstr(sdum3,"Cytidine"))sprintf(res,"DC");
12898 else if(strstr(sdum3,"Uridine"))sprintf(res,"DU");
12899 else if(strstr(sdum3,"Deoxyadenosine"))sprintf(res,"DA");
12900 else if(strstr(sdum3,"Deoxyguanosine"))sprintf(res,"DG");
12901 else if(strstr(sdum3,"Deoxycytidine"))sprintf(res,"DC");
12902 else if(strstr(sdum3,"Deoxythymidine"))sprintf(res,"DT");
12903 else if(strstr(sdum3,"5'") && strstr(sdum3,"RNA"))sprintf(res,"RG");
12904 else if(strstr(sdum3,"3'") && strstr(sdum3,"RNA"))sprintf(res,"RG");
12905 else if(strstr(sdum3,"5'") && strstr(sdum3,"DNA"))sprintf(res,"DT");
12906 else if(strstr(sdum3,"3'") && strstr(sdum3,"DNA"))sprintf(res,"DT");
12907 i = idum-1;
12908 residueNames[i] = g_strdup(res);
12909 }
12910 for(i=0;i<n;i++)
12911 {
12912 if(!pdbTypes[i]) pdbTypes[i] = g_strdup("UNK");
12913 if(!residueNames[i]) residueNames[i] = g_strdup("UNK");
12914 }
12915 fseek(file, 0L, SEEK_SET);
12916 /* set charge */
12917 while(!feof(file))
12918 {
12919 if(!fgets(tstr,BSIZE,file)) break;
12920 k = sscanf(tstr,"%s %d %lf",sdum1,&idum,&ddum);
12921 if(k!=3) continue;
12922 if(idum<1) continue;
12923 if(!strstr(sdum1,"charge")) continue;
12924 if(idum>n) continue;
12925 i = idum-1;
12926 chargesValue[i] = ddum;
12927 }
12928 fclose(file);
12929 *charges = chargesValue;
12930 *types = pdbTypes;
12931 *residues = residueNames;
12932 /*
12933 for(i=0;i<n;i++)
12934 printf("%s %s %f\n",pdbTypes[i], residueNames[i] , chargesValue[i]);
12935 */
12936 return n;
12937 }
12938 /*************************************************************************************/
read_mol2_tinker_file_no_add_list(gchar * NomFichier,gchar * type)12939 void read_mol2_tinker_file_no_add_list(gchar *NomFichier,gchar*type)
12940 {
12941 gchar *t;
12942 gboolean OK;
12943 gchar *AtomCoord[5];
12944 gchar *Type;
12945 FILE *fd;
12946 guint taille=BSIZE;
12947 guint i;
12948 gint j;
12949 gint Nc = -1;
12950 gchar** pdbTypes = NULL;
12951 gchar** residueNames = NULL;
12952 gdouble* charges = NULL;
12953 gint npdb = 0;
12954 gint ipdb = 0;
12955
12956 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
12957
12958
12959 fd = FOpen(NomFichier, "rb");
12960 if(fd == NULL)
12961 {
12962 t = g_strdup_printf(_("Sorry\n I can not open \"%s\" file"),NomFichier);
12963 MessageGeom(t,_("Error"),TRUE);
12964 return;
12965 }
12966 t=g_malloc(taille);
12967
12968 if(!strcmp(type,"MOL2"))
12969 {
12970 Type = g_strdup("<TRIPOS>ATOM");
12971 OK=FALSE;
12972 }
12973 else
12974 {
12975 Type = NULL;
12976 OK=TRUE;
12977 }
12978
12979 while(Type && !feof(fd))
12980 {
12981 { char* e = fgets(t,taille,fd);}
12982 if(strstr(t,Type))
12983 {
12984 OK = TRUE;
12985 break;
12986 }
12987 }
12988 if(!OK)
12989 {
12990 g_free(t);
12991 t = g_strdup_printf(_("Sorry\n \"%s\" is not at MOL2 format"),NomFichier);
12992 MessageGeom(t,_("Error"),TRUE);
12993 if(Type)
12994 g_free(Type);
12995 return;
12996 }
12997 if(!Type)
12998 {
12999 { char* e = fgets(t,taille,fd);}
13000 Nc=atoi(t);
13001 init_dipole();
13002 if(Nc<1)
13003 {
13004 OK=FALSE;
13005 NcentersXYZ=0;
13006 t = g_strdup_printf(_("Sorry\n \"%s\" is not at Tinker format"),NomFichier);
13007 MessageGeom(t,_("Error"),TRUE);
13008 return;
13009 }
13010 npdb = get_pdbtype_charge_from_tinker_amber_key_file
13011 (NomFichier, &pdbTypes, &residueNames, &charges);
13012 }
13013 if(GeomXYZ) freeGeomXYZ();
13014 if(VariablesXYZ) freeVariablesXYZ();
13015 init_dipole();
13016 GeomXYZ=g_malloc(sizeof(GeomXYZAtomDef));
13017 j=0;
13018 GeomXYZ[j].typeConnections = NULL;
13019 while(!feof(fd) && OK )
13020 {
13021 if(Nc>0 && j>Nc)
13022 break;
13023 if(!fgets(t,taille,fd))
13024 break;
13025 if(atoi(t)<=0)
13026 break;
13027 GeomXYZ=g_realloc(GeomXYZ,(j+1)*sizeof(GeomXYZAtomDef));
13028 if(type)
13029 {
13030 gchar rname[100];
13031 gchar charge[100];
13032 gint k;
13033 ipdb = 0;
13034 GeomXYZ[j].ResidueNumber=0;
13035 k = sscanf(t,"%d %s %s %s %s %s %d %s %s",&i,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3],AtomCoord[4],&GeomXYZ[j].ResidueNumber,
13036 rname,charge);
13037 GeomXYZ[j].Residue=NULL;
13038 GeomXYZ[j].Charge=NULL;
13039 if(k>=8) GeomXYZ[j].Residue=g_strdup(rname);
13040 if(k>=9) GeomXYZ[j].Charge=g_strdup_printf("%f",atof(charge));
13041 }
13042 else
13043 {
13044 sscanf(t,"%d %s %s %s %s %d",&i,AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3],&ipdb);
13045 GeomXYZ[j].ResidueNumber=0;
13046 }
13047 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
13048 GeomXYZ[j].typeConnections = NULL;
13049
13050 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
13051 GeomXYZ[j].Symb= get_symb_atom(AtomCoord[0]);
13052 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
13053 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
13054 if(ipdb>0 && npdb>0 && ipdb<npdb)
13055 {
13056 GeomXYZ[j].Residue = g_strdup(residueNames[ipdb-1]);
13057 /* experimental */
13058 if(j==0) GeomXYZ[j].ResidueNumber = 0;
13059 else
13060 {
13061 if(strcmp(GeomXYZ[j].Residue,GeomXYZ[j-1].Residue))
13062 GeomXYZ[j].ResidueNumber = GeomXYZ[j-1].ResidueNumber+1;
13063 else
13064 GeomXYZ[j].ResidueNumber = GeomXYZ[j-1].ResidueNumber;
13065 }
13066 GeomXYZ[j].Charge=g_strdup_printf("%f",charges[ipdb-1]);
13067 }
13068 else
13069 {
13070 if(!GeomXYZ[j].Residue) GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
13071 if(!GeomXYZ[j].Charge) GeomXYZ[j].Charge=g_strdup("0.0");
13072 }
13073 if(Units==1)
13074 {
13075 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
13076 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
13077 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
13078 }
13079 else
13080 {
13081 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
13082 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
13083 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
13084 }
13085 GeomXYZ[j].Layer=g_strdup(" ");
13086 j++;
13087 }
13088 for(i=0;i<npdb;i++)
13089 {
13090 if(pdbTypes && pdbTypes[i]) g_free(pdbTypes[i]);
13091 if(residueNames && residueNames[i]) g_free(residueNames[i]);
13092 }
13093 NcentersXYZ = j;
13094 /* Read Bonds from MOL2 */
13095 if(type && !strcmp(type,"MOL2"))
13096 {
13097 if(!strstr(t,"<TRIPOS>BOND"))
13098 {
13099 fseek(fd, 0L, SEEK_SET);
13100 while(!feof(fd))
13101 {
13102 { char* e = fgets(t,taille,fd);}
13103 if(strstr(t,"<TRIPOS>BOND"))
13104 {
13105 OK = TRUE;
13106 break;
13107 }
13108 }
13109 } else OK = TRUE;
13110 if(OK)
13111 {
13112 for(i=0;i<NcentersXYZ;i++)
13113 GeomXYZ[i].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
13114 for(i=0;i<NcentersXYZ;i++)
13115 for(j=0;j<NcentersXYZ;j++)
13116 GeomXYZ[i].typeConnections[j] = 0;
13117 }
13118 while(OK && !feof(fd))
13119 {
13120 gint a,i,j,d;
13121 gint k;
13122 { char* e = fgets(t,taille,fd);}
13123 k = sscanf(t,"%d %d %d %d",&a,&i,&j,&d);
13124 if(k<=3 &&strstr(t,"ar"))
13125 {
13126 d = 1;
13127 k = 4;
13128 }
13129 if(k!=4) break;
13130 i--;
13131 j--;
13132 if(i>=NcentersXYZ || i<0) break;
13133 if(j>=NcentersXYZ || j<0) break;
13134 if(d<0) break;
13135 GeomXYZ[i].typeConnections[j] = d;
13136 GeomXYZ[j].typeConnections[i] = d;
13137 }
13138 }
13139
13140 if(residueNames) g_free(residueNames);
13141 if(pdbTypes) g_free(pdbTypes);
13142 if(charges) g_free(charges);
13143 fclose(fd);
13144
13145 g_free(t);
13146 for(i=0;i<5;i++)
13147 g_free(AtomCoord[i]);
13148 if(GeomIsOpen)
13149 {
13150 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
13151 }
13152 else
13153 if(GeomDrawingArea == NULL)
13154 {
13155 /*
13156 switch(iprogram)
13157 {
13158 case PROG_IS_MOLPRO :
13159 insert_molpro(2);
13160 break;
13161 case PROG_IS_GAUSS :
13162 insert_gaussian(2);
13163 break;
13164 default :
13165 edit_geometry();
13166 }
13167 */
13168 create_window_drawing();
13169 }
13170 if(GeomDrawingArea != NULL)
13171 rafresh_drawing();
13172 }
13173 /*****************************************************************************/
get_position(guint i,gdouble Pos[])13174 static void get_position(guint i,gdouble Pos[])
13175 {
13176 if(!test(GeomXYZ[i].X))
13177 Pos[0] = get_value_variableXYZ(GeomXYZ[i].X);
13178 else
13179 Pos[0] = atof(GeomXYZ[i].X);
13180 if(!test(GeomXYZ[i].Y))
13181 Pos[1] = get_value_variableXYZ(GeomXYZ[i].Y);
13182 else
13183 Pos[1] = atof(GeomXYZ[i].Y);
13184 if(!test(GeomXYZ[i].Z))
13185 Pos[2] = get_value_variableXYZ(GeomXYZ[i].Z);
13186 else
13187 Pos[2] = atof(GeomXYZ[i].Z);
13188 }
13189 /*****************************************************************************/
connected(guint i,guint j)13190 static gboolean connected(guint i,guint j)
13191 {
13192 gdouble distance;
13193 gdouble dif[3];
13194 gdouble Pos1[3];
13195 gdouble Pos2[3];
13196 guint k;
13197 SAtomsProp Prop;
13198 gdouble d;
13199
13200 get_position(i,Pos1);
13201 get_position(j,Pos2);
13202 for (k=0;k<3;k++)
13203 dif[k] = Pos1[k] - Pos2[k];
13204 distance = 0;
13205 for (k=0;k<3;k++)
13206 distance +=dif[k]*dif[k];
13207 distance = sqrt(distance);
13208
13209
13210 Prop = prop_atom_get(GeomXYZ[i].Symb);
13211 d = Prop.covalentRadii;
13212 Prop = prop_atom_get(GeomXYZ[j].Symb);
13213 d += Prop.covalentRadii;
13214 if(Units == 1)
13215 d *= BOHR_TO_ANG;
13216 if(distance<d)
13217 return TRUE;
13218 else
13219 return FALSE;
13220 }
13221 /********************************************************************************/
save_tinker_file(G_CONST_RETURN gchar * FileName)13222 void save_tinker_file(G_CONST_RETURN gchar* FileName)
13223 {
13224 guint i;
13225 guint j;
13226 FILE *fd;
13227 gdouble X;
13228 gdouble Y;
13229 gdouble Z;
13230 gchar *projectname = NULL;
13231 gchar *datafile = NULL;
13232 gchar *localdir = NULL;
13233 gchar *remotehost = NULL;
13234 gchar *remoteuser = NULL;
13235 gchar *remotepass = NULL;
13236 gchar *remotedir = NULL;
13237 gchar *temp = NULL;
13238
13239 temp = get_suffix_name_file(FileName);
13240 FileName = g_strdup_printf("%s.tnk",temp);
13241 g_free(temp);
13242 fd = FOpen(FileName, "w");
13243 if(fd == NULL)
13244 {
13245 gchar* t = g_strdup_printf(_("Sorry,\n I can not open %s file"),FileName);
13246 Message(t,_("Error"),TRUE);
13247 g_free(t);
13248 return;
13249 }
13250 fprintf(fd," %d Gabedit generated tinker .xyz (mm2 param.)\n",NcentersXYZ);
13251
13252 for(i=0;i<NcentersXYZ;i++)
13253 {
13254 if(!test(GeomXYZ[i].X))
13255 X = get_value_variableXYZ(GeomXYZ[i].X);
13256 else
13257 X = atof(GeomXYZ[i].X);
13258 if(!test(GeomXYZ[i].Y))
13259 Y = get_value_variableXYZ(GeomXYZ[i].Y);
13260 else
13261 Y = atof(GeomXYZ[i].Y);
13262 if(!test(GeomXYZ[i].Z))
13263 Z = get_value_variableXYZ(GeomXYZ[i].Z);
13264 else
13265 Z = atof(GeomXYZ[i].Z);
13266 if(Units==0)
13267 {
13268 X *= BOHR_TO_ANG;
13269 Y *= BOHR_TO_ANG;
13270 Z *= BOHR_TO_ANG;
13271 }
13272 fprintf(fd,"%5d %s %20.10f %20.10f %20.10f 1 ",
13273 i+1,GeomXYZ[i].Symb,X,Y,Z);
13274 for(j=0;j<NcentersXYZ;j++)
13275 if(i != j && connected(i,j))
13276 fprintf(fd," %5d ",j+1);
13277
13278 fprintf(fd,"\n");
13279
13280 }
13281
13282 fclose(fd);
13283 datafile = get_name_file(FileName);
13284 temp = get_suffix_name_file(FileName);
13285 projectname = get_name_file(temp);
13286 localdir = get_name_dir(temp);
13287 if(lastdirectory)
13288 g_free(lastdirectory);
13289 lastdirectory = g_strdup(localdir);
13290 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_TINKER],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_TINKER, NULL, defaultNetWorkProtocol);
13291 g_free(temp);
13292 g_free(datafile);
13293 g_free(projectname);
13294 g_free(localdir);
13295 }
13296 /************************************************************************************/
save_geometry_tinker_file(GabeditFileChooser * SelecFile,gint response_id)13297 void save_geometry_tinker_file(GabeditFileChooser *SelecFile, gint response_id)
13298 {
13299 gchar *FileName;
13300
13301 if(response_id != GTK_RESPONSE_OK) return;
13302 FileName = gabedit_file_chooser_get_current_file(SelecFile);
13303 if ((!FileName) || (strcmp(FileName,"") == 0))
13304 {
13305 Message(_("Sorry\n No selected file"),_("Error"),TRUE);
13306 return ;
13307 }
13308 save_tinker_file(FileName);
13309 }
13310 /********************************************************************************/
save_tinker_file_entry(GtkWidget * entry)13311 void save_tinker_file_entry(GtkWidget* entry)
13312 {
13313 G_CONST_RETURN gchar *FileName;
13314
13315 FileName = gtk_entry_get_text(GTK_ENTRY(entry));
13316 if ((!FileName) || (strcmp(FileName,"") == 0))
13317 return ;
13318 save_tinker_file(FileName);
13319
13320 }
13321 /********************************************************************************/
read_mol_file_no_add_list(G_CONST_RETURN gchar * NomFichier)13322 void read_mol_file_no_add_list(G_CONST_RETURN gchar *NomFichier)
13323 {
13324 gchar *t;
13325 gchar *AtomCoord[5];
13326 FILE *fd;
13327 guint taille=BSIZE;
13328 gint i;
13329 gint j;
13330 gint l;
13331 gint nAtoms=0;
13332 gint nBonds;
13333
13334 for(i=0;i<5;i++) AtomCoord[i]=g_malloc(taille*sizeof(gchar));
13335
13336 t=g_malloc(taille);
13337 fd = FOpen(NomFichier, "rb");
13338 if(fd!=NULL)
13339 {
13340 { char* e = fgets(t,taille,fd);}
13341 { char* e = fgets(t,taille,fd);}
13342 { char* e = fgets(t,taille,fd);}
13343 { char* e = fgets(t,taille,fd);}
13344
13345 sscanf(t,"%d %d", &nAtoms, &nBonds);
13346 if(nAtoms<1)
13347 {
13348 MessageGeom(_("Sorry\n this is not a mol file"),_("Error"),TRUE);
13349 return;
13350 }
13351 }
13352 init_dipole();
13353 if(GeomXYZ) freeGeomXYZ();
13354 if(VariablesXYZ) freeVariablesXYZ();
13355 NcentersXYZ = nAtoms;
13356 GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13357 for(j=0;j<NcentersXYZ;j++)
13358 {
13359 GeomXYZ[j].typeConnections = NULL;
13360 GeomXYZ[j].Symb=NULL;
13361 GeomXYZ[j].mmType=NULL;
13362 GeomXYZ[j].pdbType=NULL;
13363 GeomXYZ[j].Residue=NULL;
13364 GeomXYZ[j].Charge=NULL;
13365 GeomXYZ[j].Layer=NULL;
13366 }
13367 for(j=0;j<nAtoms;j++)
13368 {
13369 if(!fgets(t,taille,fd))break;
13370 sscanf(t,"%s %s %s %s",AtomCoord[1],AtomCoord[2],AtomCoord[3],AtomCoord[0]);
13371 delete_first_spaces(AtomCoord[0]);
13372 delete_last_spaces(AtomCoord[0]);
13373 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
13374 l=strlen(AtomCoord[0]);
13375 if (l==2) AtomCoord[0][1]=tolower(AtomCoord[0][1]);
13376 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
13377 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
13378 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
13379 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
13380 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
13381 GeomXYZ[j].ResidueNumber=0;
13382 if(Units==1)
13383 {
13384 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
13385 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
13386 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
13387 }
13388 else
13389 {
13390 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
13391 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
13392 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
13393 }
13394 GeomXYZ[j].Charge=g_strdup("0.0");
13395 GeomXYZ[j].Layer=g_strdup(" ");
13396 }
13397 if(j!=nAtoms)
13398 {
13399 MessageGeom(_("Sorry\n I cannot read this file"),_("Error"),TRUE);
13400 if(GeomXYZ) freeGeomXYZ();
13401 fclose(fd);
13402 return;
13403 }
13404 if(nBonds>0)
13405 {
13406 gint k;
13407 for(j=0;j<NcentersXYZ;j++)
13408 {
13409 GeomXYZ[j].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
13410 for(i=0;i<NcentersXYZ;i++) GeomXYZ[j].typeConnections[i] = 0;
13411 }
13412 for(k=0;k<nBonds;k++)
13413 {
13414 gint d;
13415 if(!fgets(t,taille,fd))break;
13416 if(3!=sscanf(t,"%d %d %d",&i,&j,&d)) break;
13417 if(i>NcentersXYZ) break;
13418 if(j>NcentersXYZ) break;
13419 i--;
13420 j--;
13421 if(i<0) break;
13422 if(j<0) break;
13423 if(d<0) break;
13424 GeomXYZ[i].typeConnections[j] = d;
13425 GeomXYZ[j].typeConnections[i] = d;
13426 }
13427 }
13428 fclose(fd);
13429 g_free(t);
13430 calculMMTypes(FALSE);
13431 for(i=0;i<5;i++) g_free(AtomCoord[i]);
13432 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
13433 else if(GeomDrawingArea == NULL) create_window_drawing();
13434 if(GeomDrawingArea != NULL) rafresh_drawing();
13435 }
13436 /********************************************************************************/
read_XYZ_file_no_add_list(G_CONST_RETURN gchar * NomFichier)13437 void read_XYZ_file_no_add_list(G_CONST_RETURN gchar *NomFichier)
13438 {
13439 gchar *t;
13440 gboolean OK;
13441 gchar *AtomCoord[5];
13442 FILE *fd;
13443 guint taille=BSIZE;
13444 guint i;
13445 gint j;
13446 gint l;
13447 gint Nc;
13448
13449 for(i=0;i<5;i++)
13450 AtomCoord[i]=g_malloc(taille*sizeof(char));
13451
13452 t=g_malloc(taille);
13453 fd = FOpen(NomFichier, "rb");
13454 OK=TRUE;
13455 if(fd!=NULL)
13456 {
13457 { char* e = fgets(t,taille,fd);}
13458 Nc=atoi(t);
13459 if(Nc<1)
13460 {
13461 OK=FALSE;
13462 MessageGeom(_("Sorry\n this is not a XYZ file"),_("Error"),TRUE);
13463 return;
13464 }
13465 if(OK)
13466 {
13467 init_dipole();
13468 if(GeomXYZ)
13469 freeGeomXYZ();
13470 if(VariablesXYZ)
13471 freeVariablesXYZ();
13472 NcentersXYZ = Nc;
13473 GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13474 for(j=0;j<NcentersXYZ;j++) GeomXYZ[j].typeConnections = NULL;
13475 }
13476 { char* e = fgets(t,taille,fd);}
13477 j=-1;
13478 while(!feof(fd) && OK && (j<(gint)NcentersXYZ))
13479 {
13480 j++;
13481 if(j>=(gint)NcentersXYZ)
13482 break;
13483
13484 if(!fgets(t,taille,fd))
13485 {
13486 if(j-1 != (gint)NcentersXYZ)
13487 {
13488 NcentersXYZ = j -1;
13489 }
13490 break;
13491 };
13492 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
13493 delete_first_spaces(AtomCoord[0]);
13494 delete_last_spaces(AtomCoord[0]);
13495 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
13496 l=strlen(AtomCoord[0]);
13497 if (l==2)
13498 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
13499 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
13500 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
13501 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
13502 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
13503 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
13504 GeomXYZ[j].ResidueNumber=0;
13505 if(Units==1)
13506 {
13507 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
13508 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
13509 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
13510 }
13511 else
13512 {
13513 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
13514 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
13515 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
13516 }
13517 GeomXYZ[j].Charge=g_strdup("0.0");
13518 GeomXYZ[j].Layer=g_strdup(" ");
13519 }
13520 fclose(fd);
13521 }
13522 g_free(t);
13523 calculMMTypes(FALSE);
13524 for(i=0;i<5;i++)
13525 g_free(AtomCoord[i]);
13526 if(GeomIsOpen)
13527 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
13528 else
13529 if(GeomDrawingArea == NULL)
13530 {
13531 /*
13532 switch(iprogram)
13533 {
13534 case PROG_IS_MOLPRO :
13535 insert_molpro(2);
13536 break;
13537 case PROG_IS_GAUSS :
13538 insert_gaussian(2);
13539 break;
13540 default :
13541 edit_geometry();
13542 }
13543 */
13544 create_window_drawing();
13545 }
13546 if(GeomDrawingArea != NULL) rafresh_drawing();
13547 }
13548 /*************************************************************************************/
create_GeomXYZ_from_draw_grometry()13549 void create_GeomXYZ_from_draw_grometry()
13550 {
13551 gint j;
13552 gint jj;
13553 gboolean toSort = FALSE;
13554 gint iHigh = -1;
13555 gint i;
13556 gint* numOrd = NULL;
13557 gdouble Orig[3];
13558 gdouble X,Y,Z;
13559 gint nMaxCentersToVar = 500;
13560
13561 if(GeomXYZ) freeGeomXYZ();
13562 if(VariablesXYZ) freeVariablesXYZ();
13563
13564 get_origine_molecule_drawgeom(Orig);
13565
13566 init_dipole();
13567 NcentersXYZ = Natoms;
13568 /*
13569 if(Natoms<1)
13570 return;
13571
13572 GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13573 */
13574 if(Natoms>0) GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13575 if(Natoms>0) numOrd=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13576 for(i=0;i<(gint)NcentersXYZ;i++)
13577 {
13578 numOrd[i] = i;
13579 for(j=0;j<(gint)NcentersXYZ;j++)
13580 if(geometry0[j].N-1==i)
13581 {
13582 numOrd[i] = j;
13583 break;
13584 }
13585 }
13586
13587 copy_connections(geometry0, geometry, Natoms);
13588
13589 for(j=0;j<(gint)NcentersXYZ;j++)
13590 {
13591 jj = numOrd[j];
13592 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
13593 GeomXYZ[j].Symb=g_strdup(geometry0[jj].Prop.symbol);
13594 GeomXYZ[j].mmType=g_strdup(geometry0[jj].mmType);
13595 GeomXYZ[j].pdbType=g_strdup(geometry0[jj].pdbType);
13596 GeomXYZ[j].Residue=g_strdup(geometry0[jj].Residue);
13597 GeomXYZ[j].ResidueNumber=geometry0[jj].ResidueNumber;
13598 GeomXYZ[j].typeConnections = g_malloc(NcentersXYZ*sizeof(gint));
13599 for(i=0;i<NcentersXYZ;i++) GeomXYZ[j].typeConnections[i] = get_connection_type(jj,numOrd[i]);
13600 X = geometry0[jj].X+Orig[0];
13601 Y = geometry0[jj].Y+Orig[1];
13602 Z = geometry0[jj].Z+Orig[2];
13603 if(Units==1)
13604 {
13605 GeomXYZ[j].X=g_strdup_printf("%0.6f",X*BOHR_TO_ANG);
13606 GeomXYZ[j].Y=g_strdup_printf("%0.6f",Y*BOHR_TO_ANG);
13607 GeomXYZ[j].Z=g_strdup_printf("%0.6f",Z*BOHR_TO_ANG);
13608 }
13609 else
13610 {
13611 GeomXYZ[j].X=g_strdup_printf("%0.6f",X);
13612 GeomXYZ[j].Y=g_strdup_printf("%0.6f",Y);
13613 GeomXYZ[j].Z=g_strdup_printf("%0.6f",Z);
13614 }
13615 GeomXYZ[j].Charge=g_strdup_printf("%0.6f",geometry0[jj].Charge);
13616 /* this part is very consomming if Ncentres > nMaxCentersToVar */
13617 if(NcentersXYZ<nMaxCentersToVar && geometry0[jj].Variable) set_variable_one_atom_in_GeomXYZ(j);
13618 if(geometry0[jj].Layer==LOW_LAYER)
13619 {
13620 GeomXYZ[j].Layer=g_strdup("Low");
13621 toSort = TRUE;
13622 }
13623 else if(geometry0[jj].Layer==MEDIUM_LAYER)
13624 {
13625 GeomXYZ[j].Layer=g_strdup("Medium");
13626 toSort = TRUE;
13627 }
13628 else
13629 {
13630 if(iHigh<0) iHigh = j;
13631 GeomXYZ[j].Layer=g_strdup(" ");
13632 }
13633 /* if(j%50==0) fprintf(stderr,"DEBUG j=%d\n",j);*/
13634 }
13635 if(numOrd) g_free(numOrd);
13636 numOrd = NULL;
13637 if(toSort && iHigh>=0)
13638 {
13639 GeomXYZAtomDef t;
13640 gint i;
13641 gint j;
13642 gint k;
13643 gint* oldNum = NULL;
13644 gint* N = NULL;
13645
13646 oldNum = g_malloc(NcentersXYZ*sizeof(gint));
13647 for (i = 0; i <(gint)NcentersXYZ; i++) oldNum[i] = i;
13648
13649 N = g_malloc(NcentersXYZ*sizeof(gint));
13650 for (i = 0; i <(gint)NcentersXYZ; i++) N[i] = 0;
13651
13652 /* sorting Hight, Medium, Low */
13653 if(iHigh != 0)
13654 {
13655 t= GeomXYZ[0];
13656 GeomXYZ[0] = GeomXYZ[iHigh];
13657 GeomXYZ[iHigh] = t;
13658
13659 j = oldNum[0];
13660 oldNum[0]=oldNum[iHigh];
13661 oldNum[iHigh]=j;
13662 }
13663 for (i = 0; i <(gint)NcentersXYZ-1; i++)
13664 {
13665 if(strcmp(GeomXYZ[i].Layer," ")==0) continue;
13666 k = i;
13667 for (j = i+1; j <(gint)NcentersXYZ; j++)
13668 if( strcmp(GeomXYZ[j].Layer," ")==0) {k = j; break;}
13669 if(k!=i)
13670 {
13671 t= GeomXYZ[i];
13672 GeomXYZ[i] = GeomXYZ[k];
13673 GeomXYZ[k] = t;
13674
13675 j = oldNum[i];
13676 oldNum[i]=oldNum[k];
13677 oldNum[k]=j;
13678 }
13679 }
13680 for (i = 0; i <(gint)NcentersXYZ-1; i++)
13681 {
13682 if(strcmp(GeomXYZ[i].Layer," ")==0) continue;
13683 if(strcmp(GeomXYZ[i].Layer,"Medium")==0) continue;
13684 k = i;
13685 for (j = i+1; j <(gint)NcentersXYZ; j++)
13686 if( strcmp(GeomXYZ[j].Layer,"Medium")==0) {k = j; break;}
13687 if(k!=i)
13688 {
13689 t= GeomXYZ[i];
13690 GeomXYZ[i] = GeomXYZ[k];
13691 GeomXYZ[k] = t;
13692 j = oldNum[i];
13693 oldNum[i]=oldNum[k];
13694 oldNum[k]=j;
13695 }
13696 }
13697 for (i = 0; i <(gint)NcentersXYZ; i++)
13698 {
13699 if(!GeomXYZ[i].typeConnections) continue;
13700 for (j = 0; j <(gint)NcentersXYZ; j++) N[j] = GeomXYZ[i].typeConnections[j];
13701 for (j = 0; j <(gint)NcentersXYZ; j++) GeomXYZ[i].typeConnections[j]=N[oldNum[j]];
13702 }
13703 if(N) g_free(N);
13704 if(oldNum) g_free(oldNum);
13705 }
13706 MethodeGeom = GEOM_IS_XYZ;
13707 if(GeomIsOpen)
13708 {
13709 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
13710 if(toSort) unSelectAllAtoms();
13711 }
13712 }
13713 /********************************************************************************/
read_mol2_file(GabeditFileChooser * SelecFile,gint response_id)13714 void read_mol2_file(GabeditFileChooser *SelecFile , gint response_id)
13715 {
13716 gchar *NomFichier;
13717 gchar *projectname = NULL;
13718 gchar *datafile = NULL;
13719 gchar *localdir = NULL;
13720 gchar *remotehost = NULL;
13721 gchar *remoteuser = NULL;
13722 gchar *remotepass = NULL;
13723 gchar *remotedir = NULL;
13724 gchar *temp = NULL;
13725
13726 if(response_id != GTK_RESPONSE_OK) return;
13727
13728 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
13729
13730 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
13731 {
13732 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
13733 return ;
13734 }
13735
13736 read_mol2_tinker_file_no_add_list(NomFichier,"MOL2");
13737
13738 datafile = get_name_file(NomFichier);
13739 temp = get_suffix_name_file(NomFichier);
13740 projectname = get_name_file(temp);
13741 localdir = get_name_dir(temp);
13742 if(lastdirectory)
13743 g_free(lastdirectory);
13744 lastdirectory = g_strdup(localdir);
13745 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_MOL2],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_MOL2, NULL, defaultNetWorkProtocol);
13746 g_free(temp);
13747 g_free(datafile);
13748 g_free(projectname);
13749 g_free(localdir);
13750 }
13751 /********************************************************************************/
read_tinker_file(GabeditFileChooser * SelecFile,gint response_id)13752 void read_tinker_file(GabeditFileChooser *SelecFile, gint response_id)
13753 {
13754 gchar *NomFichier;
13755 gchar *projectname = NULL;
13756 gchar *datafile = NULL;
13757 gchar *localdir = NULL;
13758 gchar *remotehost = NULL;
13759 gchar *remoteuser = NULL;
13760 gchar *remotepass = NULL;
13761 gchar *remotedir = NULL;
13762 gchar *temp = NULL;
13763
13764 if(response_id != GTK_RESPONSE_OK) return;
13765 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
13766
13767 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
13768 {
13769 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
13770 return ;
13771 }
13772
13773 read_mol2_tinker_file_no_add_list(NomFichier,"TINKER");
13774
13775 datafile = get_name_file(NomFichier);
13776 temp = get_suffix_name_file(NomFichier);
13777 projectname = get_name_file(temp);
13778 localdir = get_name_dir(temp);
13779 if(lastdirectory)
13780 g_free(lastdirectory);
13781 lastdirectory = g_strdup(localdir);
13782 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_TINKER],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_TINKER, NULL, defaultNetWorkProtocol);
13783 g_free(temp);
13784 g_free(datafile);
13785 g_free(projectname);
13786 g_free(localdir);
13787
13788
13789 }
13790 /********************************************************************************/
read_pdb_file(GabeditFileChooser * SelecFile,gint response_id)13791 void read_pdb_file(GabeditFileChooser *SelecFile, gint response_id)
13792 {
13793 gchar *NomFichier;
13794 gchar *projectname = NULL;
13795 gchar *datafile = NULL;
13796 gchar *localdir = NULL;
13797 gchar *remotehost = NULL;
13798 gchar *remoteuser = NULL;
13799 gchar *remotepass = NULL;
13800 gchar *remotedir = NULL;
13801 gchar *temp = NULL;
13802
13803 if(response_id != GTK_RESPONSE_OK) return;
13804
13805 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
13806
13807 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
13808 {
13809 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
13810 return ;
13811 }
13812
13813 read_pdb_file_no_add_list(NomFichier);
13814
13815 datafile = get_name_file(NomFichier);
13816 temp = get_suffix_name_file(NomFichier);
13817 projectname = get_name_file(temp);
13818 localdir = get_name_dir(temp);
13819 if(lastdirectory)
13820 g_free(lastdirectory);
13821 lastdirectory = g_strdup(localdir);
13822 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_PDB],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_PDB, NULL, defaultNetWorkProtocol);
13823 g_free(temp);
13824 g_free(datafile);
13825 g_free(projectname);
13826 g_free(localdir);
13827
13828
13829 }
13830 /********************************************************************************/
read_mol_file(GabeditFileChooser * SelecFile,gint response_id)13831 void read_mol_file(GabeditFileChooser *SelecFile, gint response_id)
13832 {
13833 gchar *NomFichier;
13834 gchar *projectname = NULL;
13835 gchar *datafile = NULL;
13836 gchar *localdir = NULL;
13837 /*
13838 gchar *remotehost = NULL;
13839 gchar *remoteuser = NULL;
13840 gchar *remotepass = NULL;
13841 gchar *remotedir = NULL;
13842 */
13843 gchar *temp = NULL;
13844
13845 if(response_id != GTK_RESPONSE_OK) return;
13846 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
13847
13848 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
13849 {
13850 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
13851 return ;
13852 }
13853
13854 read_mol_file_no_add_list(NomFichier);
13855
13856 datafile = get_name_file(NomFichier);
13857 temp = get_suffix_name_file(NomFichier);
13858 projectname = get_name_file(temp);
13859 localdir = get_name_dir(temp);
13860 if(lastdirectory) g_free(lastdirectory);
13861 lastdirectory = g_strdup(localdir);
13862 /* CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_XYZ],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_XYZ, NULL, defaultNetWorkProtocol);*/
13863 g_free(temp);
13864 g_free(datafile);
13865 g_free(projectname);
13866 g_free(localdir);
13867 }
13868 /********************************************************************************/
read_XYZ_file(GabeditFileChooser * SelecFile,gint response_id)13869 void read_XYZ_file(GabeditFileChooser *SelecFile, gint response_id)
13870 {
13871 gchar *t;
13872 gchar *NomFichier;
13873 gboolean OK;
13874 gchar *AtomCoord[5];
13875 FILE *fd;
13876 guint taille=BSIZE;
13877 guint i;
13878 gint j;
13879 gint l;
13880 gchar *projectname = NULL;
13881 gchar *datafile = NULL;
13882 gchar *localdir = NULL;
13883 gchar *remotehost = NULL;
13884 gchar *remoteuser = NULL;
13885 gchar *remotepass = NULL;
13886 gchar *remotedir = NULL;
13887 gchar *temp = NULL;
13888
13889 if(response_id != GTK_RESPONSE_OK) return;
13890 for(i=0;i<5;i++)
13891 AtomCoord[i]=g_malloc(taille*sizeof(char));
13892 NomFichier = gabedit_file_chooser_get_current_file(SelecFile);
13893
13894 if ((!NomFichier) || (strcmp(NomFichier,"") == 0))
13895 {
13896 MessageGeom(_("Sorry\n No file selected"),_("Error"),TRUE);
13897 return ;
13898 }
13899
13900 t=g_malloc(taille);
13901 fd = FOpen(NomFichier, "rb");
13902 OK=TRUE;
13903 if(fd!=NULL)
13904 {
13905 { char* e = fgets(t,taille,fd);}
13906 NcentersXYZ=atoi(t);
13907 if(NcentersXYZ<1)
13908 {
13909 OK=FALSE;
13910 NcentersXYZ=0;
13911 MessageGeom(_("Sorry\n this is not a XYZ file"),_("Error"),TRUE);
13912
13913 return;
13914 }
13915 if(OK)
13916 {
13917 init_dipole();
13918 GeomXYZ=g_malloc(NcentersXYZ*sizeof(GeomXYZAtomDef));
13919 for(j=0;j<NcentersXYZ;j++) GeomXYZ[j].typeConnections = NULL;
13920 }
13921 { char* e = fgets(t,taille,fd);}
13922 j=-1;
13923 while(!feof(fd) && OK && (j<(gint)NcentersXYZ))
13924 {
13925 j++;
13926 if(j>=(gint)NcentersXYZ)
13927 break;
13928 if(!fgets(t,taille,fd))
13929 {
13930 if(j-1 != (gint)NcentersXYZ)
13931 {
13932 NcentersXYZ = j -1;
13933 }
13934 break;
13935 };
13936
13937 delete_first_spaces(t);
13938 sscanf(t,"%s %s %s %s",AtomCoord[0],AtomCoord[1],AtomCoord[2],AtomCoord[3]);
13939 AtomCoord[0][0]=toupper(AtomCoord[0][0]);
13940 l=strlen(AtomCoord[0]);
13941 if (l==2)
13942 AtomCoord[0][1]=tolower(AtomCoord[0][1]);
13943 GeomXYZ[j].Nentry=NUMBER_LIST_XYZ;
13944 GeomXYZ[j].Symb=g_strdup(AtomCoord[0]);
13945 GeomXYZ[j].mmType=g_strdup(AtomCoord[0]);
13946 GeomXYZ[j].pdbType=g_strdup(AtomCoord[0]);
13947 GeomXYZ[j].Residue=g_strdup(AtomCoord[0]);
13948 GeomXYZ[j].ResidueNumber=0;
13949 if(Units==1)
13950 {
13951 GeomXYZ[j].X=g_strdup(AtomCoord[1]);
13952 GeomXYZ[j].Y=g_strdup(AtomCoord[2]);
13953 GeomXYZ[j].Z=g_strdup(AtomCoord[3]);
13954 }
13955 else
13956 {
13957 GeomXYZ[j].X=g_strdup(ang_to_bohr(AtomCoord[1]));
13958 GeomXYZ[j].Y=g_strdup(ang_to_bohr(AtomCoord[2]));
13959 GeomXYZ[j].Z=g_strdup(ang_to_bohr(AtomCoord[3]));
13960 }
13961 GeomXYZ[j].Charge=g_strdup("0.0");
13962 GeomXYZ[j].Layer=g_strdup(" ");
13963 }
13964 fclose(fd);
13965 }
13966 g_free(t);
13967 calculMMTypes(FALSE);
13968 for(i=0;i<5;i++)
13969 g_free(AtomCoord[i]);
13970 if(GeomIsOpen)
13971 append_list();
13972 if(GeomDrawingArea != NULL)
13973 rafresh_drawing();
13974 if(iprogram == PROG_IS_GAUSS)
13975 set_spin_of_electrons();
13976
13977 datafile = get_name_file(NomFichier);
13978 temp = get_suffix_name_file(NomFichier);
13979 projectname = get_name_file(temp);
13980 localdir = get_name_dir(temp);
13981 if(lastdirectory)
13982 g_free(lastdirectory);
13983 lastdirectory = g_strdup(localdir);
13984 CreeFeuille(treeViewProjects, noeud[GABEDIT_TYPENODE_XYZ],projectname,datafile,localdir,remotehost,remoteuser,remotepass,remotedir,GABEDIT_TYPENODE_XYZ, NULL, defaultNetWorkProtocol);
13985 g_free(temp);
13986 g_free(datafile);
13987 g_free(projectname);
13988 g_free(localdir);
13989
13990
13991 }
13992 /********************************************************************************/
put_geomXYZ_in_list()13993 void put_geomXYZ_in_list()
13994 {
13995
13996 if(GeomXYZ != NULL )
13997 append_list();
13998 if(GeomDrawingArea != NULL)
13999 rafresh_drawing();
14000 if(iprogram == PROG_IS_GAUSS)
14001 set_spin_of_electrons();
14002 }
14003 /********************************************************************************/
selc_cif_file_nosym()14004 void selc_cif_file_nosym()
14005 {
14006 GtkWidget *SelecFile=NULL;
14007 gchar* patternscif[] = {"*.cif","*.mmcif","*",NULL};
14008
14009 SelecFile = gabedit_file_chooser_new(_("Read geometry from a CIF file (don\'t apply symm)"), GTK_FILE_CHOOSER_ACTION_OPEN);
14010 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternscif);
14011
14012 if(lastdirectory)
14013 {
14014 gchar* t = g_strdup_printf("%s%sdump.xyz",lastdirectory,G_DIR_SEPARATOR_S);
14015 gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(SelecFile),t);
14016 g_free(t);
14017 }
14018
14019 gabedit_file_chooser_hide_hidden(GABEDIT_FILE_CHOOSER(SelecFile));
14020 if(WindowGeom) gtk_window_set_transient_for(GTK_WINDOW(SelecFile),GTK_WINDOW(WindowGeom));
14021 else gtk_window_set_transient_for(GTK_WINDOW(SelecFile),GTK_WINDOW(Fenetre));
14022 gtk_window_set_modal (GTK_WINDOW (SelecFile), TRUE);
14023
14024 g_signal_connect (SelecFile, "response", G_CALLBACK (read_cif_file_nosym), GTK_OBJECT(SelecFile));
14025
14026 g_signal_connect_swapped(SelecFile, "response", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecFile));
14027 g_signal_connect_swapped(SelecFile, "close", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecFile));
14028 gtk_widget_show(SelecFile);
14029 }
14030 /********************************************************************************/
selc_XYZ_file(GabEditTypeFileGeom itype)14031 void selc_XYZ_file(GabEditTypeFileGeom itype)
14032 {
14033 GtkWidget *SelecFile=NULL;
14034 gchar* patternsxyz[] = {"*.xyz","*",NULL};
14035 gchar* patternsmol2[] = {"*.mol2","*",NULL};
14036 gchar* patternspdb[] = {"*.pdb","*",NULL};
14037 gchar* patternshin[] = {"*.hin","*",NULL};
14038 gchar* patternsaimall[] = {"*.sum","*",NULL};
14039 gchar* patternstnk[] = {"*.tnk","*",NULL};
14040 gchar* patternslog[] = {"*.log","*",NULL};
14041 gchar* patternsout[] = {"*.out","*.log","*",NULL};
14042 gchar* patternsaux[] = {"*.aux","*",NULL};
14043 gchar* patternsgab[] = {"*.gab","*",NULL};
14044 gchar* patternsmol[] = {"*.mol","*",NULL};
14045 gchar* patternsirc[] = {"*.irc","*",NULL};
14046 gchar* patternsfchk[] = {"*.fchk","*",NULL};
14047 gchar* patternsposcar[] = {"POS*","*",NULL};
14048 gchar* patternsxml[] = {"*.xml","*",NULL};
14049 gchar* patternsall[] = {"*",NULL};
14050 gchar* patternscif[] = {"*.cif","*",NULL};
14051 gchar* patternswfx[] = {"*.wfx","*",NULL};
14052
14053
14054 switch(itype){
14055 case GABEDIT_TYPEFILEGEOM_NEW : return;
14056 break;
14057 case GABEDIT_TYPEFILEGEOM_XYZ :
14058 SelecFile = gabedit_file_chooser_new(_("Read XYZ file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14059 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsxyz);
14060 break;
14061 case GABEDIT_TYPEFILEGEOM_MOL :
14062 SelecFile = gabedit_file_chooser_new(_("Read Mol file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14063 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsmol);
14064 break;
14065 case GABEDIT_TYPEFILEGEOM_DALTONFIRST :
14066 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a dalton output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14067 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14068 break;
14069 case GABEDIT_TYPEFILEGEOM_DALTONLAST :
14070 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a dalton output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14071 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14072 break;
14073 case GABEDIT_TYPEFILEGEOM_FIREFLYFIRST :
14074 case GABEDIT_TYPEFILEGEOM_GAMESSFIRST :
14075 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a Gamess output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14076 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternslog);
14077 break;
14078 case GABEDIT_TYPEFILEGEOM_FIREFLYLAST :
14079 case GABEDIT_TYPEFILEGEOM_GAMESSLAST :
14080 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Gamess output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14081 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternslog);
14082 break;
14083 case GABEDIT_TYPEFILEGEOM_GAMESSIRC :
14084 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Gamess IRC file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14085 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsirc);
14086 break;
14087 case GABEDIT_TYPEFILEGEOM_TURBOMOLEFIRST :
14088 case GABEDIT_TYPEFILEGEOM_TURBOMOLELAST :
14089 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Turbomole output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14090 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14091 break;
14092 case GABEDIT_TYPEFILEGEOM_GAUSSOUTFIRST :
14093 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a gaussian output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14094 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternslog);
14095 break;
14096 case GABEDIT_TYPEFILEGEOM_GAUSSOUTLAST :
14097 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a gaussian output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14098 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternslog);
14099 break;
14100 case GABEDIT_TYPEFILEGEOM_GAUSSIAN_FCHK :
14101 SelecFile = gabedit_file_chooser_new(_("Read the geometry from a gaussian fchk file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14102 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsfchk);
14103 break;
14104 case GABEDIT_TYPEFILEGEOM_MOLCASOUTFIRST :
14105 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a molcas output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14106 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14107 break;
14108 case GABEDIT_TYPEFILEGEOM_MOLCASOUTLAST :
14109 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a molcas output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14110 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14111 break;
14112 case GABEDIT_TYPEFILEGEOM_MOLPROOUTFIRST :
14113 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a molpro output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14114 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14115 break;
14116 case GABEDIT_TYPEFILEGEOM_MOLPROOUTLAST :
14117 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a molpro output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14118 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14119 break;
14120 case GABEDIT_TYPEFILEGEOM_MOL2 :
14121 SelecFile = gabedit_file_chooser_new(_("Read MOL2 file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14122 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsmol2);
14123 break;
14124 case GABEDIT_TYPEFILEGEOM_MPQCOUTFIRST :
14125 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a MPQC output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14126 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14127 break;
14128 case GABEDIT_TYPEFILEGEOM_MPQCOUTLAST :
14129 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a MPQC output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14130 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14131 break;
14132 case GABEDIT_TYPEFILEGEOM_VASPXMLFIRST :
14133 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a VASP/xml file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14134 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsxml);
14135 break;
14136 case GABEDIT_TYPEFILEGEOM_VASPXMLLAST :
14137 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a VASP/xml file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14138 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsxml);
14139 break;
14140
14141 case GABEDIT_TYPEFILEGEOM_ORCAOUTFIRST :
14142 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a ORCA output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14143 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14144 break;
14145 case GABEDIT_TYPEFILEGEOM_ORCAOUTLAST :
14146 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a ORCA output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14147 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14148 break;
14149
14150 case GABEDIT_TYPEFILEGEOM_VASPOUTFIRST :
14151 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a VASP output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14152 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsall);
14153 break;
14154 case GABEDIT_TYPEFILEGEOM_VASPOUTLAST :
14155 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a VASP output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14156 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsall);
14157 break;
14158
14159 case GABEDIT_TYPEFILEGEOM_NWCHEMOUTFIRST :
14160 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a NWCHEM output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14161 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14162 break;
14163 case GABEDIT_TYPEFILEGEOM_NWCHEMOUTLAST :
14164 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a NWCHEM output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14165 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14166 break;
14167 case GABEDIT_TYPEFILEGEOM_PSICODEOUTFIRST :
14168 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a Psicode output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14169 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14170 break;
14171 case GABEDIT_TYPEFILEGEOM_PSICODEOUTLAST :
14172 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Psicode output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14173 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14174 break;
14175 case GABEDIT_TYPEFILEGEOM_QCHEMOUTFIRST :
14176 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a Q-Chem output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14177 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14178 break;
14179 case GABEDIT_TYPEFILEGEOM_QCHEMOUTLAST :
14180 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Q-Chem output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14181 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14182 break;
14183 case GABEDIT_TYPEFILEGEOM_MOPACOUTFIRST :
14184 SelecFile = gabedit_file_chooser_new(_("Read the first geometry from a Mopac output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14185 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14186 break;
14187 case GABEDIT_TYPEFILEGEOM_MOPACOUTLAST :
14188 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Mopac output file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14189 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14190 break;
14191 case GABEDIT_TYPEFILEGEOM_MOPACAUX :
14192 SelecFile = gabedit_file_chooser_new(_("Read the last geometry from a Mopac aux file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14193 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsaux);
14194 break;
14195 case GABEDIT_TYPEFILEGEOM_WFX :
14196 SelecFile = gabedit_file_chooser_new(_("Read the geometry from a WFX file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14197 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternswfx);
14198 break;
14199 case GABEDIT_TYPEFILEGEOM_TINKER :
14200 SelecFile = gabedit_file_chooser_new(_("Read Tinker file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14201 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternstnk);
14202 break;
14203 case GABEDIT_TYPEFILEGEOM_PDB :
14204 SelecFile = gabedit_file_chooser_new(_("Read pdb file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14205 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternspdb);
14206 break;
14207 case GABEDIT_TYPEFILEGEOM_HIN :
14208 SelecFile = gabedit_file_chooser_new(_("Read hyperchem file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14209 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternshin);
14210 break;
14211 case GABEDIT_TYPEFILEGEOM_AIMALL :
14212 SelecFile = gabedit_file_chooser_new(_("Read AIMAll file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14213 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsaimall);
14214 break;
14215 case GABEDIT_TYPEFILEGEOM_GABEDIT :
14216 SelecFile = gabedit_file_chooser_new(_("Read Gabedit file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14217 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsgab);
14218 break;
14219 case GABEDIT_TYPEFILEGEOM_MOPACOUTSCAN :
14220 SelecFile = gabedit_file_chooser_new(_("Read geometries from a Mopac scan output"), GTK_FILE_CHOOSER_ACTION_OPEN);
14221 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsout);
14222 break;
14223 case GABEDIT_TYPEFILEGEOM_VASPPOSCAR :
14224 SelecFile = gabedit_file_chooser_new(_("Read geometries from a POSCAR/VASP file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14225 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternsposcar);
14226 break;
14227 case GABEDIT_TYPEFILEGEOM_CIF :
14228 SelecFile = gabedit_file_chooser_new(_("Read geometries from a CIF file"), GTK_FILE_CHOOSER_ACTION_OPEN);
14229 gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(SelecFile),patternscif);
14230 break;
14231 case GABEDIT_TYPEFILEGEOM_MOLDEN : return;
14232 case GABEDIT_TYPEFILEGEOM_DALTONIN : return;
14233 case GABEDIT_TYPEFILEGEOM_FIREFLYIN : return;
14234 case GABEDIT_TYPEFILEGEOM_GAMESSIN : return;
14235 case GABEDIT_TYPEFILEGEOM_GAUSSIN : return;
14236 case GABEDIT_TYPEFILEGEOM_MOLCASIN : return;
14237 case GABEDIT_TYPEFILEGEOM_MOLPROIN : return;
14238 case GABEDIT_TYPEFILEGEOM_MPQCIN : return;
14239 case GABEDIT_TYPEFILEGEOM_ORCAIN : return;
14240 case GABEDIT_TYPEFILEGEOM_VASPIN : return;
14241 case GABEDIT_TYPEFILEGEOM_NWCHEMIN : return;
14242 case GABEDIT_TYPEFILEGEOM_QCHEMIN : return;
14243 case GABEDIT_TYPEFILEGEOM_MOPACIN : return;
14244 case GABEDIT_TYPEFILEGEOM_GAUSSIAN_ZMATRIX : return;
14245 case GABEDIT_TYPEFILEGEOM_MOPAC_ZMATRIX : return;
14246 case GABEDIT_TYPEFILEGEOM_UNKNOWN : return;
14247 case GABEDIT_TYPEFILEGEOM_PSICODEIN : return;
14248 }
14249 if(lastdirectory)
14250 {
14251 gchar* t = g_strdup_printf("%s%sdump.xyz",lastdirectory,G_DIR_SEPARATOR_S);
14252 gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(SelecFile),t);
14253 g_free(t);
14254 }
14255
14256 gabedit_file_chooser_hide_hidden(GABEDIT_FILE_CHOOSER(SelecFile));
14257 if(WindowGeom) gtk_window_set_transient_for(GTK_WINDOW(SelecFile),GTK_WINDOW(WindowGeom));
14258 else gtk_window_set_transient_for(GTK_WINDOW(SelecFile),GTK_WINDOW(Fenetre));
14259 gtk_window_set_modal (GTK_WINDOW (SelecFile), TRUE);
14260
14261
14262 switch(itype){
14263 case GABEDIT_TYPEFILEGEOM_XYZ :
14264 g_signal_connect (SelecFile, "response", G_CALLBACK (read_XYZ_file), GTK_OBJECT(SelecFile)); break;
14265 case GABEDIT_TYPEFILEGEOM_MOL :
14266 g_signal_connect (SelecFile, "response", G_CALLBACK (read_mol_file), GTK_OBJECT(SelecFile)); break;
14267 case GABEDIT_TYPEFILEGEOM_DALTONFIRST :
14268 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_dalton_file), GTK_OBJECT(SelecFile)); break;
14269 case GABEDIT_TYPEFILEGEOM_DALTONLAST :
14270 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_dalton_file), GTK_OBJECT(SelecFile)); break;
14271 case GABEDIT_TYPEFILEGEOM_FIREFLYFIRST :
14272 case GABEDIT_TYPEFILEGEOM_GAMESSFIRST :
14273 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_gamess_file), GTK_OBJECT(SelecFile)); break;
14274 case GABEDIT_TYPEFILEGEOM_GAMESSLAST :
14275 case GABEDIT_TYPEFILEGEOM_FIREFLYLAST :
14276 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_gamess_file), GTK_OBJECT(SelecFile)); break;
14277 case GABEDIT_TYPEFILEGEOM_GAMESSIRC :
14278 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_irc_gamess_file), GTK_OBJECT(SelecFile)); break;
14279 case GABEDIT_TYPEFILEGEOM_GAUSSOUTFIRST :
14280 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_gaussian_file), GTK_OBJECT(SelecFile)); break;
14281 case GABEDIT_TYPEFILEGEOM_GAUSSOUTLAST :
14282 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_gaussian_file), GTK_OBJECT(SelecFile)); break;
14283 case GABEDIT_TYPEFILEGEOM_TURBOMOLEFIRST :
14284 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_turbomole_file), GTK_OBJECT(SelecFile)); break;
14285 case GABEDIT_TYPEFILEGEOM_TURBOMOLELAST :
14286 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_turbomole_file), GTK_OBJECT(SelecFile)); break;
14287 case GABEDIT_TYPEFILEGEOM_GAUSSIAN_FCHK :
14288 g_signal_connect (SelecFile, "response", G_CALLBACK (read_fchk_gaussian_file), GTK_OBJECT(SelecFile)); break;
14289 case GABEDIT_TYPEFILEGEOM_MOLCASOUTFIRST :
14290 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_molcas_file), GTK_OBJECT(SelecFile)); break;
14291 case GABEDIT_TYPEFILEGEOM_MOLCASOUTLAST :
14292 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_molcas_file), GTK_OBJECT(SelecFile)); break;
14293 case GABEDIT_TYPEFILEGEOM_MOLPROOUTFIRST :
14294 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_molpro_file), GTK_OBJECT(SelecFile)); break;
14295 case GABEDIT_TYPEFILEGEOM_MOLPROOUTLAST :
14296 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_molpro_file), GTK_OBJECT(SelecFile)); break;
14297 case GABEDIT_TYPEFILEGEOM_MPQCOUTFIRST :
14298 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_mpqc_file), GTK_OBJECT(SelecFile)); break;
14299 case GABEDIT_TYPEFILEGEOM_MPQCOUTLAST :
14300 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_mpqc_file), GTK_OBJECT(SelecFile)); break;
14301
14302 case GABEDIT_TYPEFILEGEOM_VASPXMLFIRST :
14303 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_vasp_xml_file), GTK_OBJECT(SelecFile)); break;
14304 case GABEDIT_TYPEFILEGEOM_VASPXMLLAST :
14305 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_vasp_xml_file), GTK_OBJECT(SelecFile)); break;
14306
14307 case GABEDIT_TYPEFILEGEOM_ORCAOUTFIRST :
14308 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_orca_file), GTK_OBJECT(SelecFile)); break;
14309 case GABEDIT_TYPEFILEGEOM_ORCAOUTLAST :
14310 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_orca_file), GTK_OBJECT(SelecFile)); break;
14311
14312 case GABEDIT_TYPEFILEGEOM_VASPOUTFIRST :
14313 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_vasp_file), GTK_OBJECT(SelecFile)); break;
14314 case GABEDIT_TYPEFILEGEOM_VASPOUTLAST :
14315 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_vasp_file), GTK_OBJECT(SelecFile)); break;
14316
14317 case GABEDIT_TYPEFILEGEOM_QCHEMOUTFIRST :
14318 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_qchem_file), GTK_OBJECT(SelecFile)); break;
14319 case GABEDIT_TYPEFILEGEOM_QCHEMOUTLAST :
14320 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_qchem_file), GTK_OBJECT(SelecFile)); break;
14321
14322 case GABEDIT_TYPEFILEGEOM_NWCHEMOUTFIRST :
14323 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_nwchem_file), GTK_OBJECT(SelecFile)); break;
14324 case GABEDIT_TYPEFILEGEOM_NWCHEMOUTLAST :
14325 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_nwchem_file), GTK_OBJECT(SelecFile)); break;
14326
14327 case GABEDIT_TYPEFILEGEOM_PSICODEOUTFIRST :
14328 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_psicode_file), GTK_OBJECT(SelecFile)); break;
14329 case GABEDIT_TYPEFILEGEOM_PSICODEOUTLAST :
14330 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_psicode_file), GTK_OBJECT(SelecFile)); break;
14331
14332
14333 case GABEDIT_TYPEFILEGEOM_MOPACOUTFIRST :
14334 g_signal_connect (SelecFile, "response", G_CALLBACK (read_first_mopac_output_file), GTK_OBJECT(SelecFile)); break;
14335 case GABEDIT_TYPEFILEGEOM_MOPACOUTLAST :
14336 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_mopac_output_file), GTK_OBJECT(SelecFile)); break;
14337 case GABEDIT_TYPEFILEGEOM_MOPACAUX :
14338 g_signal_connect (SelecFile, "response", G_CALLBACK (read_last_mopac_aux_file), GTK_OBJECT(SelecFile)); break;
14339 case GABEDIT_TYPEFILEGEOM_WFX :
14340 g_signal_connect (SelecFile, "response", G_CALLBACK (read_wfx_file), GTK_OBJECT(SelecFile)); break;
14341
14342 case GABEDIT_TYPEFILEGEOM_MOL2 :
14343 g_signal_connect (SelecFile, "response", G_CALLBACK (read_mol2_file), GTK_OBJECT(SelecFile)); break;
14344 case GABEDIT_TYPEFILEGEOM_TINKER :
14345 g_signal_connect (SelecFile, "response", G_CALLBACK (read_tinker_file), GTK_OBJECT(SelecFile)); break;
14346 case GABEDIT_TYPEFILEGEOM_PDB :
14347 g_signal_connect (SelecFile, "response", G_CALLBACK (read_pdb_file), GTK_OBJECT(SelecFile)); break;
14348 case GABEDIT_TYPEFILEGEOM_HIN :
14349 g_signal_connect (SelecFile, "response", G_CALLBACK (read_hin_file), GTK_OBJECT(SelecFile)); break;
14350 case GABEDIT_TYPEFILEGEOM_AIMALL :
14351 g_signal_connect (SelecFile, "response", G_CALLBACK (read_aimall_file), GTK_OBJECT(SelecFile)); break;
14352 case GABEDIT_TYPEFILEGEOM_GABEDIT :
14353 g_signal_connect (SelecFile, "response", G_CALLBACK (read_gabedit_file), GTK_OBJECT(SelecFile)); break;
14354 case GABEDIT_TYPEFILEGEOM_MOPACOUTSCAN :
14355 g_signal_connect (SelecFile, "response", G_CALLBACK (read_geometries_conv_mopac_scan), GTK_OBJECT(SelecFile)); break;
14356 case GABEDIT_TYPEFILEGEOM_VASPPOSCAR :
14357 g_signal_connect (SelecFile, "response", G_CALLBACK (read_poscar_file), GTK_OBJECT(SelecFile)); break;
14358 case GABEDIT_TYPEFILEGEOM_CIF :
14359 g_signal_connect (SelecFile, "response", G_CALLBACK (read_cif_file), GTK_OBJECT(SelecFile)); break;
14360 case GABEDIT_TYPEFILEGEOM_NEW :
14361 case GABEDIT_TYPEFILEGEOM_MOLDEN :
14362 case GABEDIT_TYPEFILEGEOM_GAUSSIN :
14363 case GABEDIT_TYPEFILEGEOM_DALTONIN :
14364 case GABEDIT_TYPEFILEGEOM_FIREFLYIN :
14365 case GABEDIT_TYPEFILEGEOM_GAMESSIN :
14366 case GABEDIT_TYPEFILEGEOM_MOLCASIN :
14367 case GABEDIT_TYPEFILEGEOM_MOLPROIN :
14368 case GABEDIT_TYPEFILEGEOM_MPQCIN :
14369 case GABEDIT_TYPEFILEGEOM_ORCAIN :
14370 case GABEDIT_TYPEFILEGEOM_VASPIN :
14371 case GABEDIT_TYPEFILEGEOM_NWCHEMIN :
14372 case GABEDIT_TYPEFILEGEOM_QCHEMIN :
14373 case GABEDIT_TYPEFILEGEOM_MOPACIN :
14374 case GABEDIT_TYPEFILEGEOM_GAUSSIAN_ZMATRIX :
14375 case GABEDIT_TYPEFILEGEOM_MOPAC_ZMATRIX :
14376 case GABEDIT_TYPEFILEGEOM_PSICODEIN :
14377 case GABEDIT_TYPEFILEGEOM_UNKNOWN : return;
14378 }
14379 g_signal_connect_swapped(SelecFile, "response", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecFile));
14380 g_signal_connect_swapped(SelecFile, "close", G_CALLBACK (gtk_widget_destroy), GTK_OBJECT(SelecFile));
14381 gtk_widget_show(SelecFile);
14382 }
14383 /********************************************************************************/
save_xyzmol2tinkerpdbhin_file(GtkWidget * win,gpointer data)14384 void save_xyzmol2tinkerpdbhin_file(GtkWidget* win,gpointer data)
14385 {
14386 GtkWidget * ButtonXYZ = g_object_get_data(G_OBJECT(win),"ButtonXYZ");
14387 GtkWidget * ButtonMol2 = g_object_get_data(G_OBJECT(win),"ButtonMol2");
14388 GtkWidget * ButtonPDB = g_object_get_data(G_OBJECT(win),"ButtonPDB");
14389 GtkWidget * ButtonHIN = g_object_get_data(G_OBJECT(win),"ButtonHIN");
14390 GtkWidget * entry = g_object_get_data(G_OBJECT(win),"Entry");
14391 GtkWidget * buttonDirSelector = g_object_get_data(G_OBJECT(win),"ButtonDirSelector");
14392 G_CONST_RETURN gchar *entrytext;
14393 gchar *dirName;
14394 gchar *fileName;
14395
14396 entrytext = gtk_entry_get_text(GTK_ENTRY(entry));
14397 dirName = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER(buttonDirSelector));
14398 fileName = get_dir_file_name(dirName,entrytext);
14399 if ((!fileName) || (strcmp(fileName,"") == 0)) return ;
14400 if (GTK_TOGGLE_BUTTON (ButtonXYZ)->active)
14401 {
14402 save_xyz_file(fileName);
14403 }
14404 else
14405 if (GTK_TOGGLE_BUTTON (ButtonMol2)->active)
14406 {
14407 save_mol2_file(fileName);
14408 }
14409 else
14410 if (GTK_TOGGLE_BUTTON (ButtonPDB)->active)
14411 {
14412 save_pdb_file(fileName);
14413 }
14414 if (GTK_TOGGLE_BUTTON (ButtonHIN)->active)
14415 {
14416 save_hin_file(fileName);
14417 }
14418 else
14419 {
14420 save_tinker_file(fileName);
14421 }
14422 }
14423 /********************************************************************************/
reset_extended_file(gpointer data,G_CONST_RETURN gchar * ext)14424 static void reset_extended_file(gpointer data,G_CONST_RETURN gchar* ext)
14425 {
14426 GtkWidget* entry = GTK_WIDGET(data);
14427 G_CONST_RETURN gchar* entrytext = gtk_entry_get_text(GTK_ENTRY(entry));
14428 gchar* temp = get_filename_without_ext(entrytext);
14429 gchar* t = g_strdup_printf("%s.%s",temp,ext);
14430 gtk_entry_set_text(GTK_ENTRY(entry),t);
14431 g_free(t);
14432 g_free(temp);
14433 }
14434 /********************************************************************************/
reset_extended_xyz_file(GtkWidget * b,gpointer data)14435 static void reset_extended_xyz_file(GtkWidget* b,gpointer data)
14436 {
14437 reset_extended_file(data,"xyz");
14438 }
14439 /********************************************************************************/
reset_extended_mol2_file(GtkWidget * b,gpointer data)14440 static void reset_extended_mol2_file(GtkWidget* b,gpointer data)
14441 {
14442 reset_extended_file(data,"mol2");
14443 }
14444 /********************************************************************************/
reset_extended_tinker_file(GtkWidget * b,gpointer data)14445 static void reset_extended_tinker_file(GtkWidget* b,gpointer data)
14446 {
14447 reset_extended_file(data,"tnk");
14448 }
14449 /********************************************************************************/
reset_extended_pdb_file(GtkWidget * b,gpointer data)14450 static void reset_extended_pdb_file(GtkWidget* b,gpointer data)
14451 {
14452 reset_extended_file(data,"pdb");
14453 }
14454 /********************************************************************************/
reset_extended_hin_file(GtkWidget * b,gpointer data)14455 static void reset_extended_hin_file(GtkWidget* b,gpointer data)
14456 {
14457 reset_extended_file(data,"hin");
14458 }
14459 /********************************************************************************/
create_window_save_xyzmol2tinkerpdbhin()14460 void create_window_save_xyzmol2tinkerpdbhin()
14461 {
14462 GtkWidget *fp;
14463 GtkWidget *frame;
14464 GtkWidget *vboxall;
14465 GtkWidget *vboxframe;
14466 GtkWidget *hbox;
14467 GtkWidget *button;
14468 GtkWidget *buttonDirSelector;
14469 GtkWidget *ButtonXYZ;
14470 GtkWidget *ButtonMol2;
14471 GtkWidget *ButtonTinker;
14472 GtkWidget *ButtonPDB;
14473 GtkWidget *ButtonHIN;
14474 GtkWidget *entry;
14475 GtkWidget *Win = WindowGeom;
14476 gchar *labelt = g_strdup(" File : ");
14477 gchar *titre=g_strdup("Save in xyz/mol2/tinker/Hyperchem file");
14478 gchar* fileName = g_strdup_printf("%s.xyz",fileopen.projectname);
14479
14480 if(NcentersXYZ<1)
14481 {
14482 MessageGeom(_(" Sorry No Center !"),_("Error"),TRUE);
14483 return;
14484 }
14485 if(!Win)
14486 Win = Fenetre;
14487
14488 fp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
14489 gtk_window_set_title(GTK_WINDOW(fp),titre);
14490 gtk_window_set_position(GTK_WINDOW(fp),GTK_WIN_POS_CENTER);
14491 gtk_window_set_transient_for(GTK_WINDOW(fp),GTK_WINDOW(Fenetre));
14492
14493 add_child(Win,fp,gtk_widget_destroy,_(" Save XYZ "));
14494
14495 g_signal_connect(G_OBJECT(fp),"delete_event",(GCallback)delete_child,NULL);
14496 g_signal_connect(G_OBJECT(fp),"delete_event",(GCallback)gtk_widget_destroy,NULL);
14497
14498 gtk_container_set_border_width (GTK_CONTAINER (fp), 5);
14499 vboxall = create_vbox(fp);
14500
14501
14502 frame = gtk_frame_new ("Type of file");
14503 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
14504 gtk_container_add (GTK_CONTAINER (vboxall), frame);
14505 gtk_widget_show (frame);
14506
14507 vboxframe = create_vbox(frame);
14508
14509 hbox = gtk_hbox_new(FALSE, 10);
14510 gtk_box_pack_start (GTK_BOX (vboxframe), hbox, FALSE, FALSE, 5);
14511 gtk_widget_show (hbox);
14512 ButtonXYZ = gtk_radio_button_new_with_label( NULL,"XYZ " );
14513 gtk_box_pack_start (GTK_BOX (hbox), ButtonXYZ, FALSE, FALSE, 5);
14514 gtk_widget_show (ButtonXYZ);
14515 ButtonMol2 = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ButtonXYZ)), "Mol2");
14516 gtk_box_pack_start (GTK_BOX (hbox), ButtonMol2, FALSE, FALSE, 5);
14517 gtk_widget_show (ButtonMol2);
14518 ButtonTinker = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ButtonXYZ)), "Tinker");
14519 gtk_box_pack_start (GTK_BOX (hbox), ButtonTinker, FALSE, FALSE, 5);
14520 gtk_widget_show (ButtonTinker);
14521
14522 hbox = gtk_hbox_new(FALSE, 10);
14523 gtk_box_pack_start (GTK_BOX (vboxframe), hbox, FALSE, FALSE, 5);
14524
14525
14526 ButtonPDB = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ButtonXYZ)), "PDB");
14527 gtk_box_pack_start (GTK_BOX (hbox), ButtonPDB, FALSE, FALSE, 5);
14528 gtk_widget_show (ButtonPDB);
14529
14530 ButtonHIN = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ButtonXYZ)), "Hyperchem");
14531 gtk_box_pack_start (GTK_BOX (hbox), ButtonHIN, FALSE, FALSE, 5);
14532 gtk_widget_show (ButtonHIN);
14533 create_hseparator(vboxframe);
14534
14535
14536
14537 create_table_browser(Win,vboxframe);
14538 entry = (GtkWidget*)(g_object_get_data(G_OBJECT(Win),"EntryFileName"));
14539 gtk_entry_set_text(GTK_ENTRY(entry),fileName);
14540 buttonDirSelector = (GtkWidget*)(g_object_get_data(G_OBJECT(Win),"ButtonDirSelector"));
14541 if(fileopen.localdir && strcmp(fileopen.localdir,"NoName")!=0) gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(buttonDirSelector), fileopen.localdir);
14542
14543 create_hseparator(vboxframe);
14544 g_signal_connect(G_OBJECT(ButtonXYZ),"clicked",(GCallback)reset_extended_xyz_file,(gpointer)(entry));
14545 g_signal_connect(G_OBJECT(ButtonMol2),"clicked",(GCallback)reset_extended_mol2_file,(gpointer)(entry));
14546 g_signal_connect(G_OBJECT(ButtonTinker),"clicked",(GCallback)reset_extended_tinker_file,(gpointer)(entry));
14547 g_signal_connect(G_OBJECT(ButtonPDB),"clicked",(GCallback)reset_extended_pdb_file,(gpointer)(entry));
14548 g_signal_connect(G_OBJECT(ButtonHIN),"clicked",(GCallback)reset_extended_hin_file,(gpointer)(entry));
14549
14550 g_object_set_data(G_OBJECT (fp), "ButtonXYZ",ButtonXYZ);
14551 g_object_set_data(G_OBJECT (fp), "ButtonMol2",ButtonMol2);
14552 g_object_set_data(G_OBJECT (fp), "ButtonTinker",ButtonTinker);
14553 g_object_set_data(G_OBJECT (fp), "ButtonPDB",ButtonPDB);
14554 g_object_set_data(G_OBJECT (fp), "ButtonHIN",ButtonHIN);
14555 g_object_set_data(G_OBJECT (fp), "Entry",entry);
14556 g_object_set_data(G_OBJECT (fp), "ButtonDirSelector",buttonDirSelector);
14557
14558 create_hseparator(vboxall);
14559 hbox = gtk_hbox_new(FALSE, 0);
14560 gtk_box_pack_start (GTK_BOX (vboxall), hbox, FALSE, FALSE, 5);
14561 gtk_widget_realize(fp);
14562
14563
14564 button = create_button(fp,_("OK"));
14565 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, FALSE, 3);
14566 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
14567 gtk_widget_grab_default(button);
14568 gtk_widget_show (button);
14569 g_signal_connect_swapped(G_OBJECT(button), "clicked",G_CALLBACK(save_xyzmol2tinkerpdbhin_file),GTK_OBJECT(fp));
14570 g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)delete_child,GTK_OBJECT(fp));
14571
14572 button = create_button(fp,_("Cancel"));
14573 gtk_box_pack_end (GTK_BOX( hbox), button, FALSE, FALSE, 3);
14574 g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)delete_child,GTK_OBJECT(fp));
14575 gtk_widget_show (button);
14576 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
14577
14578
14579 g_free(labelt);
14580 g_free(fileName);
14581
14582 gtk_widget_show_all(fp);
14583 }
14584
14585
14586 /********************************************************************************/
create_geomXYZ_list(GtkWidget * vbox,GabEditTypeFileGeom readfile)14587 void create_geomXYZ_list(GtkWidget *vbox, GabEditTypeFileGeom readfile)
14588 {
14589 GtkListStore *store;
14590 GtkTreeModel *model;
14591 GtkCellRenderer *renderer;
14592 GtkTreeViewColumn *column;
14593
14594 GtkWidget *scr;
14595 guint i;
14596 guint Factor=7;
14597 guint widall=0;
14598 gchar *titres[NUMBER_LIST_XYZ]={
14599 "Nr",
14600 " Symbol ",
14601 " MM Type ",
14602 " PDB Type ",
14603 " Residue ",
14604 " X ",
14605 " Y ",
14606 " Z ",
14607 " Charge "," Layer "
14608 };
14609 gint width[NUMBER_LIST_XYZ]={4,6,8,8,8,10,10,10,10,10 };
14610 GtkUIManager *manager = NULL;
14611
14612
14613 if(iprogram == PROG_IS_MOLPRO) NCr = NUMBER_LIST_XYZ-1;
14614 else NCr = NUMBER_LIST_XYZ;
14615
14616 NSA[0] = -1;
14617 NSA[1] = NSA[2] = NSA[3] =-1;
14618 MethodeGeom = GEOM_IS_XYZ;
14619 if(GeomXYZ!=NULL && readfile != GABEDIT_TYPEFILEGEOM_UNKNOWN)
14620 {
14621 freeGeomXYZ();
14622 if(VariablesXYZ) freeVariablesXYZ();
14623 }
14624
14625 LineSelected=-1;
14626 if(readfile != GABEDIT_TYPEFILEGEOM_NEW) selc_XYZ_file(readfile);
14627 else NcentersXYZ=0;
14628 for(i=0;(gint)i<NCr;i++) widall+=width[i];
14629 widall=widall*Factor+60;
14630
14631 scr=gtk_scrolled_window_new(NULL,NULL);
14632 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*0.4));
14633 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
14634 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 2);
14635
14636 store = gtk_list_store_new (NUMBER_LIST_XYZ*2,
14637 G_TYPE_STRING, G_TYPE_BOOLEAN,
14638 G_TYPE_STRING, G_TYPE_BOOLEAN,
14639 G_TYPE_STRING, G_TYPE_BOOLEAN,
14640 G_TYPE_STRING, G_TYPE_BOOLEAN,
14641 G_TYPE_STRING, G_TYPE_BOOLEAN,
14642 G_TYPE_STRING, G_TYPE_BOOLEAN,
14643 G_TYPE_STRING, G_TYPE_BOOLEAN,
14644 G_TYPE_STRING, G_TYPE_BOOLEAN,
14645 G_TYPE_STRING, G_TYPE_BOOLEAN,
14646 G_TYPE_STRING, G_TYPE_BOOLEAN
14647 );
14648 model = GTK_TREE_MODEL (store);
14649
14650 list = gtk_tree_view_new_with_model (model);
14651 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), TRUE);
14652 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), TRUE);
14653 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (list), TRUE);
14654 for (i=0;(gint)i<NCr;i++)
14655 {
14656 column = gtk_tree_view_column_new ();
14657 gtk_tree_view_column_set_title (column, titres[i]);
14658 gtk_tree_view_column_set_min_width(column, width[i]*Factor);
14659 gtk_tree_view_column_set_reorderable(column, TRUE);
14660 renderer = gtk_cell_renderer_text_new ();
14661 gtk_tree_view_column_pack_start (column, renderer, TRUE);
14662 gtk_tree_view_column_set_attributes (column, renderer, "text", i+i, "editable",i+i+1,NULL);
14663 gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
14664 g_object_set_data(G_OBJECT(renderer),"NumColumn", GINT_TO_POINTER(i));
14665 g_signal_connect (renderer, "edited", G_CALLBACK (editedGeom), model);
14666 }
14667 gtk_container_add(GTK_CONTAINER(scr),list);
14668 /* Drag and Drop */
14669 /*
14670 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (list), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
14671 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (list), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE);
14672 */
14673
14674
14675
14676 set_base_style(list,55000,55000,55000);
14677 gtk_widget_show (list);
14678
14679 if(WindowGeom) manager = newMenuXYZGeom(WindowGeom);
14680 else manager = newMenuXYZGeom(Fenetre);
14681 g_signal_connect(G_OBJECT (model), "row_deleted", G_CALLBACK(row_deleted), NULL);
14682 g_signal_connect(G_OBJECT (model), "row_inserted", G_CALLBACK(row_inserted), NULL);
14683
14684 if(GeomXYZ != NULL) put_geomXYZ_in_list();
14685 g_signal_connect(G_OBJECT (list), "button_press_event", G_CALLBACK(event_dispatcher), manager);
14686
14687
14688 }
14689 /********************************************************************************/
DelVariable(GtkWidget * w,gpointer data)14690 static void DelVariable(GtkWidget *w,gpointer data)
14691 {
14692 guint i,imin;
14693 gchar *message;
14694
14695 if(LineSelectedV<0)
14696 LineSelectedV=NVariablesXYZ-1;
14697 if(VariablesXYZ[LineSelectedV].Used) {
14698 message=g_strdup_printf(_("Sorry\n %s \n is used in Geometry"),VariablesXYZ[LineSelectedV].Name);
14699 MessageGeom(message,_("Error"),TRUE);
14700 return;
14701 }
14702 if(NVariablesXYZ>0)
14703 {
14704 imin=LineSelectedV;
14705 removeFromList(listv, LineSelectedV);
14706 for(i=imin;i<NVariablesXYZ-1;i++)
14707 {
14708 VariablesXYZ[i].Name=g_strdup(VariablesXYZ[i+1].Name);
14709 VariablesXYZ[i].Value=g_strdup(VariablesXYZ[i+1].Value);
14710 VariablesXYZ[i].Used=VariablesXYZ[i+1].Used;
14711 }
14712 NVariablesXYZ--;
14713 if(NVariablesXYZ>0)
14714 VariablesXYZ=g_realloc(VariablesXYZ,NVariablesXYZ*sizeof(VariablesXYZDef));
14715 else
14716 freeVariablesXYZ();
14717 }
14718 LineSelectedV=-1;
14719 }
14720 /********************************************************************************/
TestVariablesXYZCreated(gchar * NewName,gint j)14721 static gboolean TestVariablesXYZCreated(gchar *NewName,gint j)
14722 {
14723 gint i;
14724 gboolean k;
14725
14726 k=FALSE;
14727 for (i=0;i<(gint)NVariablesXYZ;i++)
14728 {
14729 if (j==i)continue;
14730 if (!strcmp(VariablesXYZ[i].Name, NewName) )
14731 {
14732 k=TRUE;
14733 break;
14734 }
14735 }
14736 return k;
14737 }
14738 /********************************************************************************/
EditVariable(GtkWidget * w,gpointer Entree)14739 static void EditVariable(GtkWidget *w,gpointer Entree)
14740 {
14741 gchar *texts[2];
14742 gchar *message;
14743 gint Nc;
14744
14745 DestroyDialog = TRUE;
14746 texts[0] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[0])));
14747 texts[1] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[1])));
14748 if(!variable_name_valid(texts[0]))
14749 {
14750 show_forbidden_characters();
14751 DestroyDialog = FALSE;
14752 return;
14753 }
14754 if ( strcmp(texts[0], "") && strcmp(texts[1], "") )
14755 {
14756 Nc=LineSelectedV;
14757 if(Nc<0)
14758 Nc = LineSelectedOld;
14759 }
14760 else
14761 {
14762 MessageGeom(_("Sorry a Entry text is void !\n"),_("Error"),TRUE);
14763 DestroyDialog = FALSE;
14764 return;
14765 }
14766
14767 if(TestVariablesXYZCreated(texts[0],Nc) )
14768 {
14769 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Error"),TRUE);
14770 DestroyDialog = FALSE;
14771 return;
14772 }
14773
14774 if(!test(texts[1]))
14775 {
14776 message=g_strdup_printf(_("Sorry %s is not a number \n"),texts[1]);
14777 MessageGeom(message,_("Error"),TRUE);
14778 DestroyDialog = FALSE;
14779 }
14780 else
14781 {
14782 if(test(texts[1]) && !testpointeE(texts[1]) )
14783 texts[1]=g_strdup_printf("%s.0",texts[1]);
14784 VariablesXYZ[Nc].Name=g_strdup(texts[0]);
14785 VariablesXYZ[Nc].Value=g_strdup(texts[1]);
14786
14787 removeFromList(listv, Nc);
14788 insertToList(listv, Nc, texts, 2);
14789 }
14790 }
14791 /********************************************************************************/
DialogueDeleteV()14792 static void DialogueDeleteV()
14793 {
14794 GtkWidget *Dialogue;
14795 GtkWidget *Label;
14796 GtkWidget *Bouton;
14797 GtkWidget *frame;
14798 GtkWidget *vboxframe;
14799 gchar *message;
14800
14801 if (NVariablesXYZ <1)
14802 {
14803 MessageGeom(_(" No Variable to delet !"),_("Error"),TRUE);
14804 return ;
14805 }
14806
14807 if(LineSelectedV<0)
14808 LineSelectedV=NVariablesXYZ-1;
14809 if(VariablesXYZ[LineSelectedV].Used) {
14810 message=g_strdup_printf(_("Sorry\n %s \n is used in Geometry"),VariablesXYZ[LineSelectedV].Name);
14811 MessageGeom(message,_("Error"),TRUE);
14812 return;
14813 }
14814
14815 Dialogue = gtk_dialog_new();
14816 frame = gtk_frame_new (NULL);
14817 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
14818 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
14819 gtk_window_set_title(GTK_WINDOW(Dialogue),"Delete Variable");
14820 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
14821 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
14822
14823 add_child(WindowGeom,Dialogue,gtk_widget_destroy," Delete Variable ");
14824 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
14825
14826 g_object_ref (frame);
14827 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
14828 frame,(GDestroyNotify) g_object_unref);
14829 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
14830 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
14831
14832 gtk_widget_show (frame);
14833
14834 vboxframe = create_vbox(frame);
14835
14836 gtk_widget_realize(Dialogue);
14837 message = g_strdup_printf("\nAre you sure to delete the variable\n %s\n?",VariablesXYZ[LineSelectedV].Name);
14838 Label = create_label_with_pixmap(Dialogue,message," Question ");
14839 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
14840
14841 Bouton = create_button(Dialogue,"No");
14842 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
14843 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)delete_child,GTK_OBJECT(Dialogue));
14844 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
14845 gtk_widget_grab_default(Bouton);
14846
14847 Bouton = create_button(Dialogue,"Yes");
14848 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
14849 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)DelVariable, NULL);
14850 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)delete_child,GTK_OBJECT(Dialogue));
14851 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
14852
14853
14854 gtk_widget_show_all(Dialogue);
14855 }
14856 /********************************************************************************/
DialogueEditV()14857 static void DialogueEditV()
14858 {
14859 GtkWidget *Dialogue;
14860 GtkWidget *Bouton;
14861 GtkWidget *hbox;
14862 GtkWidget *frame, *vboxframe;
14863 gint Nc;
14864 gchar *tlabel[]={" Name : ", " Value : "};
14865
14866 Nc=LineSelectedV;
14867 if(Nc<0 ) {
14868 if(NVariablesXYZ<1)
14869 MessageGeom(_("Create variable before \n"),_("Warning"),TRUE);
14870 else
14871 MessageGeom(_("Please Select your variable \n"),_("Warning"),TRUE);
14872 return;
14873 }
14874 Dialogue = gtk_dialog_new();
14875 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Edit Variable"));
14876 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
14877 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(Fenetre));
14878 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
14879
14880 add_child(WindowGeom,Dialogue,gtk_widget_destroy,_(" Edit Variable "));
14881 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
14882
14883 frame = gtk_frame_new (NULL);
14884 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
14885
14886 g_object_ref (frame);
14887 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
14888 frame,(GDestroyNotify) g_object_unref);
14889 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
14890 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
14891
14892 gtk_widget_show (frame);
14893
14894 vboxframe = create_vbox(frame);
14895
14896
14897 hbox=create_hbox_false(vboxframe);
14898 EntryV[0] = create_label_entry(hbox,tlabel[0],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
14899 gtk_entry_set_text(GTK_ENTRY(EntryV[0]),VariablesXYZ[Nc].Name);
14900 if(VariablesXYZ[Nc].Used)
14901 gtk_editable_set_editable((GtkEditable*) EntryV[0],FALSE);
14902
14903 hbox=create_hbox_false(vboxframe);
14904 EntryV[1] = create_label_entry(hbox,tlabel[1],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
14905 gtk_entry_set_text(GTK_ENTRY(EntryV[1]),VariablesXYZ[Nc].Value);
14906
14907 gtk_widget_realize(Dialogue);
14908 Bouton = create_button(Dialogue,_("Cancel"));
14909 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
14910 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
14911 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
14912
14913 Bouton = create_button(Dialogue,_("OK"));
14914 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
14915 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)EditVariable,NULL);
14916 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)destroy_dialogue,GTK_OBJECT(Dialogue));
14917 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
14918 gtk_widget_grab_default(Bouton);
14919
14920
14921 gtk_widget_show_all(Dialogue);
14922 }
14923 /********************************************************************************/
AddVariable(GtkWidget * w,gpointer Entree)14924 static void AddVariable(GtkWidget *w,gpointer Entree)
14925 {
14926 gchar *texts[2];
14927 gchar *message;
14928
14929 texts[0] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[0])));
14930 texts[1] = g_strdup(gtk_entry_get_text(GTK_ENTRY(EntryV[1])));
14931 DestroyDialog = TRUE;
14932 if(TestVariablesXYZCreated(texts[0],-1))
14933 {
14934 MessageGeom(_("Sorry a other variable have any Name !\n"),_("Error"),TRUE);
14935 DestroyDialog = FALSE;
14936 return;
14937 }
14938 if(!variable_name_valid(texts[0]))
14939 {
14940 show_forbidden_characters();
14941 DestroyDialog = FALSE;
14942 return;
14943 }
14944 if ( strcmp(texts[0], "") && strcmp(texts[1], "") )
14945 NVariablesXYZ++;
14946 else
14947 {
14948 MessageGeom(_("Sorry a Entry text is void !\n"),_("Error"),TRUE);
14949 DestroyDialog = FALSE;
14950 return;
14951 }
14952 if(VariablesXYZ==NULL)
14953 VariablesXYZ=g_malloc(sizeof(VariablesXYZDef));
14954 else
14955 VariablesXYZ=g_realloc(VariablesXYZ,NVariablesXYZ*sizeof(VariablesXYZDef));
14956
14957 if(test(texts[1]) && !testpointeE(texts[1]) )
14958 texts[1]=g_strdup_printf("%s.0",texts[1]);
14959 VariablesXYZ[NVariablesXYZ-1].Name=g_strdup(texts[0]);
14960 VariablesXYZ[NVariablesXYZ-1].Value=g_strdup(texts[1]);
14961 VariablesXYZ[NVariablesXYZ-1].Used=FALSE;
14962 if(!test(texts[1]))
14963 {
14964 message=g_strdup_printf(_("Sorry %s is not a number \n"),texts[1]);
14965 DestroyDialog = FALSE;
14966 MessageGeom(message,_("Error"),TRUE);
14967 NVariablesXYZ--;
14968 if(NVariablesXYZ>0)
14969 VariablesXYZ=g_realloc(VariablesXYZ,NVariablesXYZ*sizeof(VariablesXYZDef));
14970 else
14971 VariablesXYZ=NULL;
14972 }
14973 else
14974 appendToList(listv, texts, 2);
14975 }
14976 /********************************************************************************/
DialogueAddV()14977 static void DialogueAddV()
14978 {
14979 GtkWidget *Dialogue;
14980 GtkWidget *Bouton;
14981 GtkWidget *hbox;
14982 GtkWidget *frame, *vboxframe;
14983 gchar *tlabel[]={" Name : ", " Value : "};
14984
14985 Dialogue = gtk_dialog_new();
14986 gtk_window_set_title(GTK_WINDOW(Dialogue),"New Variable");
14987 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
14988 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(WindowGeom));
14989
14990 add_child(WindowGeom,Dialogue,gtk_widget_destroy," New Variable ");
14991 g_signal_connect(G_OBJECT(Dialogue),"delete_event",(GCallback)delete_child,NULL);
14992
14993 frame = gtk_frame_new (NULL);
14994 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
14995
14996 g_object_ref (frame);
14997 g_object_set_data_full(G_OBJECT (Dialogue), "frame",
14998 frame,(GDestroyNotify) g_object_unref);
14999 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
15000 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
15001
15002 gtk_widget_show (frame);
15003
15004 vboxframe = create_vbox(frame);
15005
15006
15007 hbox=create_hbox_false(vboxframe);
15008 EntryV[0] = create_label_entry(hbox,tlabel[0],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
15009 hbox=create_hbox_false(vboxframe);
15010 EntryV[1] = create_label_entry(hbox,tlabel[1],(gint)(ScreenHeight*labelWidth),(gint)(ScreenHeight*entryWidth));
15011
15012 gtk_widget_realize(Dialogue);
15013
15014 Bouton = create_button(Dialogue,_("Cancel"));
15015 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
15016 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)delete_child,GTK_OBJECT(Dialogue));
15017 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
15018
15019 Bouton = create_button(Dialogue,_("OK"));
15020 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
15021 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)AddVariable,NULL);
15022 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)destroy_dialogue,GTK_OBJECT(Dialogue));
15023 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
15024 gtk_widget_grab_default(Bouton);
15025
15026
15027 gtk_widget_show_all(Dialogue);
15028 }
15029 /********************************************************************************/
create_variablesXYZ_list(GtkWidget * vbox,guint itype)15030 void create_variablesXYZ_list(GtkWidget *vbox,guint itype)
15031 {
15032 GtkWidget *scr;
15033 guint i;
15034 guint Factor=7;
15035 guint widall=0;
15036 gchar *titres[2]={ " Name "," Value "};
15037 gint width[2]={10,10 };
15038 GtkUIManager *manager;
15039
15040 GtkListStore *store;
15041 GtkTreeModel *model;
15042 GtkCellRenderer *renderer;
15043 GtkTreeViewColumn *column;
15044
15045 if(itype!=GABEDIT_TYPEFILEGEOM_UNKNOWN) freeVariablesXYZ();
15046
15047 LineSelectedV=-1;
15048 for(i=0;i<2;i++) widall+=width[i];
15049 widall=widall*Factor+50;
15050
15051 scr=gtk_scrolled_window_new(NULL,NULL);
15052 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*0.4));
15053 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
15054 gtk_box_pack_start(GTK_BOX (vbox), scr,TRUE, TRUE, 2);
15055
15056 store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_BOOLEAN);
15057 model = GTK_TREE_MODEL (store);
15058
15059 listv = gtk_tree_view_new_with_model (model);
15060 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (listv), TRUE);
15061 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (listv), TRUE);
15062 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (listv), TRUE);
15063 for (i=0;(gint)i<2;i++)
15064 {
15065 column = gtk_tree_view_column_new ();
15066 gtk_tree_view_column_set_title (column, titres[i]);
15067 gtk_tree_view_column_set_min_width(column, width[i]*Factor);
15068 gtk_tree_view_column_set_reorderable(column, TRUE);
15069 renderer = gtk_cell_renderer_text_new ();
15070 gtk_tree_view_column_pack_start (column, renderer, TRUE);
15071 gtk_tree_view_column_set_attributes (column, renderer, "text", i+i, "editable",i+i+1,NULL);
15072 gtk_tree_view_append_column (GTK_TREE_VIEW (listv), column);
15073 g_object_set_data(G_OBJECT(renderer),"NumColumn", GINT_TO_POINTER(i));
15074 g_signal_connect (renderer, "edited", G_CALLBACK (editedVariable), model);
15075 }
15076 gtk_container_add(GTK_CONTAINER(scr),listv);
15077
15078 set_base_style(listv,58000,58000,58000);
15079 gtk_widget_show (listv);
15080
15081 if(WindowGeom) manager = newMenuXYZVariables(WindowGeom);
15082 else manager = newMenuXYZVariables(Fenetre);
15083
15084
15085 if(GeomXYZ != NULL && VariablesXYZ != NULL) append_VariablesXYZ_in_list();
15086 g_signal_connect(G_OBJECT (listv), "button_press_event", G_CALLBACK(event_dispatcher), manager);
15087 }
15088 /********************************************************************************/
multi_by_factor(gdouble factor)15089 static void multi_by_factor(gdouble factor)
15090 {
15091 gint i;
15092
15093 for (i=0;(guint)i<NcentersXYZ;i++)
15094 {
15095 if(test(GeomXYZ[i].X))
15096 GeomXYZ[i].X = g_strdup_printf("%f",factor*atof(GeomXYZ[i].X));
15097 if(test(GeomXYZ[i].Y))
15098 GeomXYZ[i].Y = g_strdup_printf("%f",factor*atof(GeomXYZ[i].Y));
15099 if(test(GeomXYZ[i].Z))
15100 GeomXYZ[i].Z = g_strdup_printf("%f",factor*atof(GeomXYZ[i].Z));
15101 }
15102
15103 for (i=0;(guint)i<NVariablesXYZ;i++)
15104 VariablesXYZ[i].Value = g_strdup_printf("%f",factor*atof(VariablesXYZ[i].Value));
15105
15106 clearList(list);
15107 append_list();
15108
15109 clearList(listv);
15110 append_VariablesXYZ_in_list();
15111
15112 if(GeomDrawingArea != NULL)
15113 rafresh_drawing();
15114 if(iprogram == PROG_IS_GAUSS)
15115 set_spin_of_electrons();
15116 }
15117 /********************************************************************************/
MultiByA0()15118 static void MultiByA0()
15119 {
15120 multi_by_factor(BOHR_TO_ANG);
15121 }
15122 /********************************************************************************/
DivideByA0()15123 static void DivideByA0()
15124 {
15125 multi_by_factor(ANG_TO_BOHR);
15126 }
15127 /********************************************************************************/
OriginToCenter()15128 static void OriginToCenter()
15129 {
15130 guint i;
15131 guint j;
15132 gdouble X0=0.0;
15133 gdouble Y0=0.0;
15134 gdouble Z0=0.0;
15135
15136 for (i=0;i<NcentersXYZ;i++)
15137 {
15138 if(!test(GeomXYZ[i].X))
15139 X0 += get_value_variableXYZ(GeomXYZ[i].X);
15140 else
15141 X0 += atof(GeomXYZ[i].X);
15142 if(!test(GeomXYZ[i].Y))
15143 Y0 += get_value_variableXYZ(GeomXYZ[i].Y);
15144 else
15145 Y0 += atof(GeomXYZ[i].Y);
15146 if(!test(GeomXYZ[i].Z))
15147 Z0 += get_value_variableXYZ(GeomXYZ[i].Z);
15148 else
15149 Z0 += atof(GeomXYZ[i].Z);
15150 }
15151 X0 /=NcentersXYZ;
15152 Y0 /=NcentersXYZ;
15153 Z0 /=NcentersXYZ;
15154
15155 for (i=0;i<NcentersXYZ;i++)
15156 {
15157 if(!test(GeomXYZ[i].X))
15158 {
15159 j = get_num_variableXYZ(GeomXYZ[i].X);
15160 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)-X0);
15161 }
15162 else
15163 GeomXYZ[i].X = g_strdup_printf("%f",atof(GeomXYZ[i].X)-X0);
15164 if(!test(GeomXYZ[i].Y))
15165 {
15166 j = get_num_variableXYZ(GeomXYZ[i].Y);
15167 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)-Y0);
15168 }
15169 else
15170 GeomXYZ[i].Y = g_strdup_printf("%f",atof(GeomXYZ[i].Y)-Y0);
15171 if(!test(GeomXYZ[i].Z))
15172 {
15173 j = get_num_variableXYZ(GeomXYZ[i].Z);
15174 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)-Z0);
15175 }
15176 else
15177 GeomXYZ[i].Z = g_strdup_printf("%f",atof(GeomXYZ[i].Z)-Z0);
15178 }
15179
15180 clearList(list);
15181 append_list();
15182
15183 clearList(listv);
15184 append_VariablesXYZ_in_list();
15185
15186 if(GeomDrawingArea != NULL)
15187 rafresh_drawing();
15188 if(iprogram == PROG_IS_GAUSS)
15189 set_spin_of_electrons();
15190 }
15191 /********************************************************************************/
scale_cell(GtkWidget * fp,gpointer data)15192 static void scale_cell(GtkWidget* fp,gpointer data)
15193 {
15194 GtkWidget** entrys = (GtkWidget**)data;
15195 G_CONST_RETURN gchar* tentry[3];
15196 gint i,j;
15197 gdouble fact[3]={1.0,1.0,1.0};
15198 gint nTV = 0;
15199
15200 for(i=0;i<3;i++) tentry[i] = gtk_entry_get_text(GTK_ENTRY(entrys[i]));
15201 for(i=0;i<3;i++) fact[i] = atof(tentry[i]);
15202
15203 for(i=0;i<NcentersXYZ;i++)
15204 if(!strcmp(GeomXYZ[i].Symb, "TV") || !strcmp(GeomXYZ[i].Symb, "Tv"))
15205 {
15206
15207 gdouble f = fact[nTV];
15208 if(!test(GeomXYZ[i].X))
15209 {
15210 j = get_num_variableXYZ(GeomXYZ[i].X);
15211 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)*f);
15212 }
15213 else GeomXYZ[i].X = g_strdup_printf("%f",atof(GeomXYZ[i].X)*f);
15214 if(!test(GeomXYZ[i].Y))
15215 {
15216 j = get_num_variableXYZ(GeomXYZ[i].Y);
15217 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)*f);
15218 }
15219 else GeomXYZ[i].Y = g_strdup_printf("%f",atof(GeomXYZ[i].Y)*f);
15220 if(!test(GeomXYZ[i].Z))
15221 {
15222 j = get_num_variableXYZ(GeomXYZ[i].Z);
15223 VariablesXYZ[j].Value = g_strdup_printf("%f",atof(VariablesXYZ[j].Value)*f);
15224 }
15225 else GeomXYZ[i].Z = g_strdup_printf("%f",atof(GeomXYZ[i].Z)*f);
15226
15227 nTV++;
15228 if(nTV>=3) break;
15229 }
15230
15231 for(i=0;i<3;i++) gtk_entry_set_text(GTK_ENTRY(entrys[i]),"1.0");
15232 if(GeomDrawingArea != NULL) rafresh_drawing();
15233 }
15234 /*********************************************************************/
scale_cell_dialog()15235 GtkWidget* scale_cell_dialog ()
15236 {
15237 GtkWidget *fp;
15238 GtkWidget *frame;
15239 GtkWidget *vboxall;
15240 GtkWidget *vboxframe;
15241 GtkWidget *hbox;
15242 GtkWidget *button;
15243 GtkWidget *label;
15244 GtkStyle *style;
15245 static GtkWidget* entrys[3];
15246 static GdkColor color;
15247 gchar* tlabel[3]={"a : ","b : ","c : "};
15248 gint i;
15249
15250 /* principal Window */
15251 fp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
15252 gtk_window_set_modal(GTK_WINDOW(fp),TRUE);
15253 gtk_window_set_title(GTK_WINDOW(fp),_("Scal box"));
15254 gtk_container_set_border_width (GTK_CONTAINER (fp), 5);
15255
15256 gtk_window_set_position(GTK_WINDOW(fp),GTK_WIN_POS_CENTER);
15257 gtk_window_set_modal (GTK_WINDOW (fp), TRUE);
15258
15259 g_signal_connect(G_OBJECT(fp),"delete_event",(GCallback)gtk_widget_destroy,NULL);
15260
15261 vboxall = create_vbox(fp);
15262 frame = gtk_frame_new (_("Scaling factors"));
15263 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
15264 gtk_container_add (GTK_CONTAINER (vboxall), frame);
15265 gtk_widget_show (frame);
15266
15267 vboxframe = create_vbox(frame);
15268 for(i=0;i<3;i++)
15269 {
15270 hbox = create_hbox(vboxframe);
15271 label = gtk_label_new (tlabel[i]);
15272 gtk_widget_show (label);
15273 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
15274
15275 entrys[i] = gtk_entry_new ();
15276 gtk_widget_show (entrys[i]);
15277 gtk_box_pack_start (GTK_BOX (hbox), entrys[i], FALSE, TRUE, 0);
15278
15279 gtk_entry_set_text(GTK_ENTRY(entrys[i]),"1.0");
15280 }
15281 hbox = create_hbox(vboxall);
15282
15283 button = create_button(Fenetre,_("Close"));
15284 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
15285 g_signal_connect_swapped(G_OBJECT(button), "clicked",G_CALLBACK(gtk_widget_destroy),GTK_OBJECT(fp));
15286
15287 button = create_button(Fenetre,_("Apply"));
15288 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
15289 g_signal_connect(G_OBJECT(button), "clicked",G_CALLBACK(scale_cell),(gpointer)entrys);
15290 gtk_widget_show (button);
15291
15292 button = create_button(Fenetre,_("OK"));
15293 gtk_box_pack_start (GTK_BOX( hbox), button, TRUE, TRUE, 3);
15294 g_signal_connect(G_OBJECT(button), "clicked",G_CALLBACK(scale_cell),(gpointer)entrys);
15295 g_signal_connect_swapped(G_OBJECT(button), "clicked",G_CALLBACK(gtk_widget_destroy),GTK_OBJECT(fp));
15296 gtk_widget_show (button);
15297 gtk_widget_show_all(fp);
15298 return fp;
15299 }
15300