1 /* MolcasGateWay.c */
2 /**********************************************************************************************************
3 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
4
5 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
8 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9
10 The above copyright notice and this permission notice shall be included in all copies or substantial portions
11 of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
16 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17 DEALINGS IN THE SOFTWARE.
18 ************************************************************************************************************/
19
20 #include <stdlib.h>
21 #include <ctype.h>
22
23 #include "../../Config.h"
24 #include "../Common/Global.h"
25 #include "../Molcas/MolcasTypes.h"
26 #include "../Molcas/MolcasGlobal.h"
27 #include "../Molcas/MolcasBasis.h"
28 #include "../Molcas/MolcasScf.h"
29 #include "../Geometry/GeomGlobal.h"
30 #include "../Geometry/GeomConversion.h"
31 #include "../Geometry/GeomXYZ.h"
32 #include "../Geometry/GeomZmatrix.h"
33 #include "../Geometry/Fragments.h"
34 #include "../Geometry/DrawGeom.h"
35 #include "../Utils/Utils.h"
36 #include "../Utils/UtilsInterface.h"
37 #include "../Utils/Constants.h"
38 #include "../Geometry/InterfaceGeom.h"
39 #include "../Common/Windows.h"
40 #include "../Utils/AtomsProp.h"
41 #include "../Utils/GabeditTextEdit.h"
42 #include "../Symmetry/MoleculeSymmetry.h"
43 #include "../Symmetry/MoleculeSymmetryInterface.h"
44
45 /************************************************************************************************************/
46 /* 0-> Full (find maximum) ;
47 * 1-> with a fixed symmetry
48 2-> Witout symmetry ; */
49 static gint typeOfSymmetry[] = { 0,1,2};
50
51 static gint groupSymmetry = 0;
52
53 static GtkWidget* labelSymmetry = NULL;
54 static GtkWidget *buttonTolerance = NULL;
55 static GtkWidget *buttonView = NULL;
56 static GtkWidget *buttonBasis = NULL;
57 /************************************************************************************************************/
initGateWayButtons()58 void initGateWayButtons()
59 {
60 labelSymmetry = NULL;
61 buttonTolerance = NULL;
62 buttonView = NULL;
63 }
64 /************************************************************************************************************/
initMolcasMolecule()65 void initMolcasMolecule()
66 {
67 gint i;
68
69 molcasMolecule.listOfAtoms = NULL;
70 molcasMolecule.totalNumberOfElectrons = 0;
71 molcasMolecule.numberOfValenceElectrons = 0;
72 molcasMolecule.numberOfAtoms = 0;
73 molcasMolecule.numberOfDifferentKindsOfAtoms=0;
74 molcasMolecule.symbol = NULL;
75 molcasMolecule.groupSymbol = NULL;
76 molcasMolecule.numberOfAtomsOfEachType = NULL;
77 molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms = NULL;
78 molcasMolecule.numberOfMolcasGenerators = 0;
79 for(i=0; i<3; i++)
80 molcasMolecule.molcasGenerators[i] = NULL;
81 molcasMolecule.basis = NULL;
82 }
83 /************************************************************************************************************/
freeMolcasMolecule()84 void freeMolcasMolecule()
85 {
86 gint i;
87 static gboolean first = TRUE;
88
89 if(first)
90 {
91 initMolcasMolecule();
92 first = FALSE;
93 return;
94 }
95
96 if(molcasMolecule.listOfAtoms) g_free(molcasMolecule.listOfAtoms);
97 molcasMolecule.numberOfAtoms = 0;
98 if(molcasMolecule.groupSymbol)
99 g_free(molcasMolecule.groupSymbol);
100
101 if(molcasMolecule.symbol)
102 {
103 for(i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms; i++)
104 if(molcasMolecule.symbol[i]) g_free(molcasMolecule.symbol[i]);
105
106 g_free(molcasMolecule.symbol);
107 }
108 if(molcasMolecule.numberOfAtomsOfEachType ) g_free(molcasMolecule.numberOfAtomsOfEachType);
109 if(molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms ) g_free(molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms);
110 for(i=0; i<3; i++)
111 if(molcasMolecule.molcasGenerators[i]) g_free(molcasMolecule.molcasGenerators[i]);
112 if(molcasMolecule.basis)
113 {
114 for(i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms; i++)
115 if(molcasMolecule.basis[i]) g_free(molcasMolecule.basis[i]);
116
117 g_free(molcasMolecule.basis);
118 }
119 initMolcasMolecule();
120 }
121 /************************************************************************************************************/
setMolcasMoleculeDefaultBasis()122 static gint setMolcasMoleculeDefaultBasis()
123 {
124 gint i;
125
126 if(molcasMolecule.numberOfDifferentKindsOfAtoms<1) return 0;
127 molcasMolecule.basis = g_malloc(molcasMolecule.numberOfDifferentKindsOfAtoms*sizeof(gchar*));
128
129 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
130 molcasMolecule.basis[i] = g_strdup_printf("%s.sto-3g....",molcasMolecule.symbol[i]);
131 return 0;
132 }
133 /************************************************************************************************************/
removePointFromString(gchar * buffer,gchar * buffer2)134 static void removePointFromString(gchar* buffer, gchar* buffer2)
135 {
136 gint len;
137 gint k;
138 gint i;
139
140 len = strlen(buffer);
141 k = 0;
142 for(i=0; i<len; i++)
143 {
144 if(buffer[i]!='.')
145 {
146 buffer2[k] = buffer[i];
147 k++;
148 }
149 else
150 {
151 if(i<len-1 && buffer[i+1]=='.')
152 {
153 buffer2[k] = ' ';
154 k++;
155 buffer2[k] = 'U';
156 k++;
157 buffer2[k] = 'N';
158 k++;
159 buffer2[k] = 'K';
160 k++;
161 }
162 else
163 {
164 buffer2[k] = ' ';
165 k++;
166 }
167 }
168 }
169 buffer2[k] = '\0';
170 }
171 /************************************************************************************************************/
resetNumberOfValenceElectrons()172 gint resetNumberOfValenceElectrons()
173 {
174 gint i;
175 gint n;
176 gchar symbol[BSIZE];
177 gchar type[BSIZE];
178 gchar pseudo[BSIZE];
179 gchar* dump[3];
180 gchar buffer[BSIZE];
181 gchar buffer2[BSIZE];
182 SAtomsProp prop;
183
184 for (i=0;i<3;i++)
185 dump[i] = g_malloc(BSIZE*sizeof(gchar));
186
187 if(molcasMolecule.basis)
188 {
189 molcasMolecule.numberOfValenceElectrons = molcasMolecule.totalNumberOfElectrons;
190 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
191 {
192 sprintf(buffer,"%s",molcasMolecule.basis[i]);
193 removePointFromString(buffer,buffer2);
194 n = sscanf(buffer2,"%s %s %s %s %s %s",symbol,type,dump[0],dump[1],dump[2],pseudo);
195 if(n==6 && strcmp(type,"ECP")==0)
196 {
197 gint nElectrons = atoi(pseudo);
198 prop = prop_atom_get(symbol);
199
200 molcasMolecule.numberOfValenceElectrons += nElectrons*molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms[i];
201 molcasMolecule.numberOfValenceElectrons -= prop.atomicNumber*molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms[i];
202 }
203 }
204 }
205 activateScfEntryType();
206 for (i=0;i<3;i++)
207 g_free(dump[i]);
208 return 0;
209 }
210 /************************************************************************************************************/
setnumberOfAtomsOfEachTypeForAllAtomsFromGeomXYZ()211 static gint setnumberOfAtomsOfEachTypeForAllAtomsFromGeomXYZ()
212 {
213 gint i;
214 gint n;
215
216 molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms = (gint*)g_malloc(sizeof(gint)*(molcasMolecule.numberOfAtoms));
217 if(molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms == NULL) return -1;
218
219 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
220 molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms[i] = 0;
221
222 for(n=0; n<(gint)NcentersXYZ; n++)
223 {
224 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
225 {
226 if ((strcmp(GeomXYZ[n].Symb,molcasMolecule.symbol[i]))==0)
227 {
228 molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms[i]++;
229 break;
230 }
231 }
232 }
233
234 return 0;
235 }
236 /************************************************************************************************************/
setMolcasMoleculeFromSXYZ(gint nAtoms,gchar ** symbols,gdouble * X,gdouble * Y,gdouble * Z)237 static gint setMolcasMoleculeFromSXYZ(gint nAtoms, gchar** symbols, gdouble* X, gdouble* Y, gdouble* Z)
238 {
239 gint i;
240 gint n;
241 MolcasAtom* atomList = NULL;
242
243 molcasMolecule.listOfAtoms = NULL;
244 molcasMolecule.numberOfAtoms = 0;
245 molcasMolecule.numberOfDifferentKindsOfAtoms=0;
246 molcasMolecule.symbol = NULL;
247 molcasMolecule.numberOfAtomsOfEachType = NULL;
248
249 molcasMolecule.listOfAtoms = (MolcasAtom*)g_malloc(sizeof(MolcasAtom)*(nAtoms));
250 if(molcasMolecule.listOfAtoms==NULL) return -1;
251
252 molcasMolecule.numberOfAtoms = nAtoms;
253
254 molcasMolecule.symbol = (gchar**)g_malloc(sizeof(gchar*)*(molcasMolecule.numberOfAtoms));
255 if( molcasMolecule.symbol == NULL) return -1;
256 for(n=0; n<molcasMolecule.numberOfAtoms; n++) molcasMolecule.symbol[n] = NULL;
257
258 molcasMolecule.numberOfAtomsOfEachType = (gint*)g_malloc(sizeof(gint)*(molcasMolecule.numberOfAtoms));
259 if(molcasMolecule.numberOfAtomsOfEachType == NULL) return -1;
260
261 atomList = molcasMolecule.listOfAtoms;
262 for(n=0; n<molcasMolecule.numberOfAtoms; n++)
263 {
264 atomList->position[0] = X[n];
265 atomList->position[1] = Y[n];
266 atomList->position[2] = Z[n];
267 i = 0;
268 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++) /* search symbol */
269 {
270 if ((strcmp(symbols[n],molcasMolecule.symbol[i]))==0)
271 {
272 molcasMolecule.numberOfAtomsOfEachType[i]++;
273 break;
274 }
275 }
276 if (i==molcasMolecule.numberOfDifferentKindsOfAtoms)
277 {
278 molcasMolecule.symbol[i] = g_strdup(symbols[n]);
279 molcasMolecule.numberOfAtomsOfEachType[i] = 1;
280 molcasMolecule.numberOfDifferentKindsOfAtoms++;
281 }
282 atomList->type = i;
283 atomList++;
284 }
285 /*
286 atomList = molcasMolecule.listOfAtoms;
287 for(n=0; n<molcasMolecule.numberOfAtoms; n++)
288 {
289 printf("TODEL %s %f %f %f\n",
290 molcasMolecule.symbol[atomList->type],
291 atomList->position[0],
292 atomList->position[1],
293 atomList->position[2]);
294 atomList++;
295 }
296 */
297
298 return 0;
299 }
300 /************************************************************************************************************/
setXYZFromGeomXYZ(gint i,gdouble * x,gdouble * y,gdouble * z)301 static void setXYZFromGeomXYZ(gint i, gdouble* x, gdouble* y, gdouble *z)
302 {
303 if(!test(GeomXYZ[i].X))
304 *x = get_value_variableXYZ(GeomXYZ[i].X);
305 else
306 *x = atof(GeomXYZ[i].X);
307 if(!test(GeomXYZ[i].Y))
308 *y = get_value_variableXYZ(GeomXYZ[i].Y);
309 else
310 *y = atof(GeomXYZ[i].Y);
311 if(!test(GeomXYZ[i].Z))
312 *z = get_value_variableXYZ(GeomXYZ[i].Z);
313 else
314 *z = atof(GeomXYZ[i].Z);
315
316 if(Units==0)
317 {
318 *x *= BOHR_TO_ANG;
319 *y *= BOHR_TO_ANG;
320 *z *= BOHR_TO_ANG;
321 }
322 }
323 /************************************************************************************************************/
setMolcasMoleculeFromGeomXYZ()324 static gboolean setMolcasMoleculeFromGeomXYZ()
325 {
326 gint i;
327 gchar** symbols = NULL;
328 gdouble* X = NULL;
329 gdouble* Y = NULL;
330 gdouble* Z = NULL;
331 gint numberOfAtoms = NcentersXYZ;
332 gchar pointGroupSymbol[BSIZE];
333 gchar abelianPointGroupSymbol[BSIZE];
334 gchar message[BSIZE];
335 gint maximalOrder = 20;
336 gint nGenerators;
337 gint nMolcas = 0;
338 gint nElements;
339 gchar* generators[3];
340 gchar* molcasGenerators[3];
341 gchar* elements[8];
342 gdouble principalAxisTolerance = getTolerancePrincipalAxis();
343 gdouble positionTolerance = getTolerancePosition();
344
345 if(numberOfAtoms<1) return FALSE;
346
347 for(i=0;i<3;i++)
348 {
349 generators[i] = g_malloc(100*sizeof(gchar));
350 molcasGenerators[i] = g_malloc(100*sizeof(gchar));
351 }
352 for(i=0;i<8;i++)
353 elements[i] = g_malloc(100*sizeof(gchar));
354
355 symbols = (gchar**)g_malloc(sizeof(gchar*)*(numberOfAtoms));
356 if(symbols == NULL) return FALSE;
357
358 X = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
359 if(X == NULL) return FALSE;
360 Y = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
361 if(Y == NULL) return FALSE;
362 Z = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
363 if(Z == NULL) return FALSE;
364
365 molcasMolecule.totalNumberOfElectrons = 0;
366 for(i=0; i<numberOfAtoms; i++)
367 {
368 SAtomsProp prop = prop_atom_get(GeomXYZ[i].Symb);
369
370 symbols[i] = g_strdup(GeomXYZ[i].Symb);
371 setXYZFromGeomXYZ(i, &X[i] , &Y[i] , &Z[i]);
372 molcasMolecule.totalNumberOfElectrons += prop.atomicNumber;
373 }
374 molcasMolecule.numberOfValenceElectrons = molcasMolecule.totalNumberOfElectrons;
375 if(groupSymmetry==1)
376 computeAbelianGroup(principalAxisTolerance, pointGroupSymbol, abelianPointGroupSymbol, maximalOrder, TRUE,
377 &numberOfAtoms, symbols, X, Y, Z,
378 &nGenerators, generators, &nMolcas, molcasGenerators, &nElements, elements, &positionTolerance, message);
379
380 setMolcasMoleculeFromSXYZ(numberOfAtoms, symbols, X, Y, Z);
381
382 if(groupSymmetry==1) molcasMolecule.groupSymbol = g_strdup(abelianPointGroupSymbol);
383 else if(groupSymmetry==2) molcasMolecule.groupSymbol = g_strdup("Full");
384 else molcasMolecule.groupSymbol = g_strdup(_("Sorry, No Symmetry"));
385
386 molcasMolecule.numberOfMolcasGenerators = nMolcas;
387 for(i=0; i<nMolcas; i++)
388 molcasMolecule.molcasGenerators[i] = g_strdup(molcasGenerators[i]);
389
390 for(i=0;i<3;i++)
391 {
392 g_free(generators[i]);
393 g_free(molcasGenerators[i]);
394 }
395 for(i=0;i<8;i++)
396 g_free(elements[i]);
397
398 for (i=0;i<(gint)NcentersXYZ;i++) g_free( symbols[i]);
399 g_free( symbols);
400 g_free(X);
401 g_free(Y);
402 g_free(Z);
403 setMolcasMoleculeDefaultBasis();
404 setnumberOfAtomsOfEachTypeForAllAtomsFromGeomXYZ();
405 return TRUE;
406 }
407 /************************************************************************************************************/
setMolcasMoleculeFromGeomZMatrix()408 static gboolean setMolcasMoleculeFromGeomZMatrix()
409 {
410 if(!zmat_to_xyz()) return FALSE;
411 delete_dummy_atoms();
412 /* MethodeGeom = GEOM_IS_XYZ;*/
413 if(GeomIsOpen) create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
414 return setMolcasMoleculeFromGeomXYZ();
415 }
416 /************************************************************************************************************/
setMolcasMolecule()417 gboolean setMolcasMolecule()
418 {
419 freeMolcasMolecule();
420 if(setMolcasMoleculeFromGeomXYZ()) return TRUE;
421 if(setMolcasMoleculeFromGeomZMatrix()) return TRUE;
422 return FALSE;
423 }
424 /************************************************************************************************************/
setGeneratorsAndAbelianGroup(gchar * groupName,gint * nGenerators,gchar ** generators,gint * nMolcas,gchar ** molcasGenerators,gint * nElements,gchar ** elements)425 static void setGeneratorsAndAbelianGroup(gchar* groupName,
426 gint* nGenerators, gchar** generators,
427 gint* nMolcas, gchar** molcasGenerators,
428 gint* nElements, gchar** elements
429 )
430 {
431
432 int i;
433
434 for (i=0;i<*nMolcas; i++) uppercase(molcasGenerators[i]);
435
436 if(*nMolcas == 0)
437 {
438 sprintf(groupName,"C1");
439 *nGenerators = 0;
440 *nElements = 0;
441 return;
442 }
443 if(*nMolcas == 3)
444 {
445 sprintf(groupName,"D2h");
446
447 *nGenerators = 3;
448 sprintf(generators[0],"C2z");
449 sprintf(generators[1],"C2y");
450 sprintf(generators[2],"i");
451
452 *nElements = 8;
453 sprintf(elements[0],"E");
454 sprintf(elements[1],"C2z");
455 sprintf(elements[2],"C2y");
456 sprintf(elements[3],"C2x");
457 sprintf(elements[4],"i");
458 sprintf(elements[5],"Sigma xy");
459 sprintf(elements[6],"Sigma xz");
460 sprintf(elements[7],"Sigma yz");
461 return;
462 }
463 if(*nMolcas == 1)
464 {
465 if(strstr(molcasGenerators[0],"XYZ"))
466 {
467 sprintf(groupName,"Ci");
468
469 *nGenerators = 1;
470 sprintf(generators[0],"i");
471
472 *nElements = 2;
473 sprintf(elements[0],"E");
474 sprintf(elements[1],"i");
475 return;
476 }
477 else
478 if(strstr(molcasGenerators[0],"XY"))
479 {
480 sprintf(groupName,"C2");
481
482 *nGenerators = 1;
483 sprintf(generators[0],"C2z");
484
485 *nElements = 2;
486 sprintf(elements[0],"E");
487 sprintf(elements[1],"C2");
488 return;
489 }
490 else
491 if(strstr(molcasGenerators[0],"X"))
492 {
493 sprintf(groupName,"Cs");
494 *nGenerators = 1;
495 sprintf(generators[0],"Sigma");
496
497 *nElements = 2;
498 sprintf(elements[0],"E");
499 sprintf(elements[1],"Sigma");
500 return;
501 }
502 else
503 {
504 sprintf(groupName,"C1");
505 *nGenerators = 0;
506 *nElements = 0;
507 *nMolcas = 0;
508 }
509 }
510 if(*nMolcas == 2)
511 {
512 if(strstr(molcasGenerators[0],"XY") && strstr(molcasGenerators[1],"XYZ"))
513 {
514 sprintf(groupName,"C2h");
515
516 *nGenerators = 2;
517 sprintf(generators[0],"C2z");
518 sprintf(generators[1],"i");
519
520 *nElements = 4;
521 sprintf(elements[0],"E");
522 sprintf(elements[1],"C2z");
523 sprintf(elements[2],"i");
524 sprintf(elements[3],"Sigma h");
525 return;
526 }
527 else
528 if(strstr(molcasGenerators[0],"XY") && strstr(molcasGenerators[1],"Y"))
529 {
530 sprintf(groupName,"C2v");
531
532 *nGenerators = 2;
533 sprintf(generators[0],"C2z");
534 sprintf(generators[1],"Sigma v");
535
536 *nElements = 4;
537 sprintf(elements[0],"E");
538 sprintf(elements[1],"C2z");
539 sprintf(elements[2],"Sigma v");
540 sprintf(elements[3],"Sigma' v");
541 return;
542 }
543 else
544 if(strstr(molcasGenerators[0],"XY") && strstr(molcasGenerators[1],"XZ"))
545 {
546 sprintf(groupName,"D2");
547
548 *nGenerators = 2;
549 sprintf(generators[0],"C2z");
550 sprintf(generators[1],"C2y");
551
552 *nElements = 4;
553 sprintf(elements[0],"E");
554 sprintf(elements[1],"C2z");
555 sprintf(elements[2],"C2y");
556 sprintf(elements[3],"C2z");
557 return;
558 }
559 else
560 if(*nMolcas == 0)
561 {
562 sprintf(groupName,"C1");
563 *nGenerators = 0;
564 *nElements = 0;
565 *nMolcas = 0;
566 return;
567 }
568 }
569 }
570 /************************************************************************************************************/
setSymbolsXYZFromMolcasMolecule(gchar ** symbols,gdouble * X,gdouble * Y,gdouble * Z)571 static gint setSymbolsXYZFromMolcasMolecule(gchar** symbols, gdouble* X, gdouble* Y, gdouble* Z)
572 {
573 gchar symb[BSIZE];
574 gint i;
575
576 if(molcasMolecule.numberOfAtoms<1) return 0;
577
578 for(i=0;i<molcasMolecule.numberOfAtoms;i++)
579 {
580 sprintf(symb,"%s",molcasMolecule.symbol[molcasMolecule.listOfAtoms[i].type]);
581 symbols[i] = g_strdup(symb);
582 X[i]=molcasMolecule.listOfAtoms[i].position[0];
583 Y[i]=molcasMolecule.listOfAtoms[i].position[1];
584 Z[i]=molcasMolecule.listOfAtoms[i].position[2];
585 }
586 return molcasMolecule.numberOfAtoms;
587 }
588 /************************************************************************************************************/
setGeomXYZFromSXYZ(gint numberOfAtoms,gchar ** symbols,gdouble * X,gdouble * Y,gdouble * Z)589 static gboolean setGeomXYZFromSXYZ(gint numberOfAtoms, gchar** symbols, gdouble* X, gdouble* Y, gdouble* Z)
590 {
591 gint i;
592
593 if(numberOfAtoms<1) return FALSE;
594
595 if(GeomXYZ) freeGeomXYZ();
596 if(VariablesXYZ) freeVariablesXYZ(VariablesXYZ);
597
598 init_dipole();
599 GeomXYZ=g_malloc(numberOfAtoms*sizeof(GeomXYZAtomDef));
600
601 for(i=0;i<numberOfAtoms;i++)
602 {
603 GeomXYZ[i].Nentry=NUMBER_LIST_XYZ;
604 GeomXYZ[i].Symb=g_strdup(symbols[i]);
605 GeomXYZ[i].mmType=g_strdup(symbols[i]);
606 GeomXYZ[i].pdbType=g_strdup(symbols[i]);
607 GeomXYZ[i].Residue=g_strdup(symbols[i]);
608 GeomXYZ[i].ResidueNumber=0;
609 if(Units==1)
610 {
611 GeomXYZ[i].X=g_strdup_printf("%f",X[i]);
612 GeomXYZ[i].Y=g_strdup_printf("%f",Y[i]);
613 GeomXYZ[i].Z=g_strdup_printf("%f",Z[i]);
614 }
615 else
616 {
617 GeomXYZ[i].X=g_strdup_printf("%f",X[i]*ANG_TO_BOHR);
618 GeomXYZ[i].Y=g_strdup_printf("%f",Y[i]*ANG_TO_BOHR);
619 GeomXYZ[i].Z=g_strdup_printf("%f",Z[i]*ANG_TO_BOHR);
620 }
621 GeomXYZ[i].Charge=g_strdup("0.0");
622 GeomXYZ[i].Layer=g_strdup(" ");
623 GeomXYZ[i].typeConnections = NULL;
624 }
625 NcentersXYZ = numberOfAtoms;
626 MethodeGeom = GEOM_IS_XYZ;
627
628 if(GeomIsOpen)
629 {
630 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
631 }
632 if(GeomDrawingArea != NULL)
633 rafresh_drawing();
634
635 return TRUE;
636 }
637 /************************************************************************************************************/
setGeomXYZFromMolcasMolecule()638 static gboolean setGeomXYZFromMolcasMolecule()
639 {
640 gint i;
641 gchar symb[BSIZE];
642
643 if(molcasMolecule.numberOfAtoms<1) return FALSE;
644 if(molcasMolecule.numberOfMolcasGenerators != 0) return FALSE;
645
646 if(GeomXYZ) freeGeomXYZ();
647 if(VariablesXYZ) freeVariablesXYZ(VariablesXYZ);
648 init_dipole();
649 GeomXYZ=g_malloc(molcasMolecule.numberOfAtoms*sizeof(GeomXYZAtomDef));
650 for(i=0;i<molcasMolecule.numberOfAtoms;i++)
651 {
652 sprintf(symb,"%s",molcasMolecule.symbol[molcasMolecule.listOfAtoms[i].type]);
653 GeomXYZ[i].Nentry=NUMBER_LIST_XYZ;
654 GeomXYZ[i].Symb=g_strdup(symb);
655 GeomXYZ[i].mmType=g_strdup(symb);
656 GeomXYZ[i].pdbType=g_strdup(symb);
657 GeomXYZ[i].Residue=g_strdup(symb);
658 GeomXYZ[i].ResidueNumber=0;
659 if(Units==1)
660 {
661 GeomXYZ[i].X=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[0]);
662 GeomXYZ[i].Y=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[1]);
663 GeomXYZ[i].Z=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[2]);
664 }
665 else
666 {
667 GeomXYZ[i].X=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[0]*ANG_TO_BOHR);
668 GeomXYZ[i].Y=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[1]*ANG_TO_BOHR);
669 GeomXYZ[i].Z=g_strdup_printf("%f",molcasMolecule.listOfAtoms[i].position[2]*ANG_TO_BOHR);
670 }
671 GeomXYZ[i].Charge=g_strdup("0.0");
672 GeomXYZ[i].Layer=g_strdup(" ");
673 GeomXYZ[i].typeConnections = NULL;
674 }
675 NcentersXYZ = molcasMolecule.numberOfAtoms;
676 MethodeGeom = GEOM_IS_XYZ;
677
678 if(GeomIsOpen)
679 {
680 create_geomXYZ_interface (GABEDIT_TYPEFILEGEOM_UNKNOWN);
681 }
682 if(GeomDrawingArea != NULL)
683 rafresh_drawing();
684
685 return TRUE;
686 }
687 /************************************************************************************************************/
testMolcasGeometryAvailableInInputFile(gchar * fileName)688 static gint testMolcasGeometryAvailableInInputFile(gchar* fileName)
689 {
690 gchar t[BSIZE];
691 FILE* file = NULL;
692 gboolean Ok = FALSE;
693 gboolean OkGateWayKeyWord = FALSE;
694 gboolean OkBasisKeyWord = FALSE;
695 gboolean OkEndBasisKeyWord = FALSE;
696 gboolean OkEndInputKeyWord = FALSE;
697 gboolean OkZMat = FALSE;
698
699 file = FOpen(fileName, "r");
700 if(!file) return FALSE;
701
702 while(!feof(file))
703 {
704 if(!fgets(t, BSIZE, file)) break;
705 uppercase(t);
706 if( strstr(t, "&GATEWAY")) OkGateWayKeyWord = TRUE;
707 if( strstr(t, "&SEWARD")) OkGateWayKeyWord = TRUE;
708 if(OkGateWayKeyWord)
709 {
710 while(!feof(file))
711 {
712 if(!fgets(t, BSIZE, file)) break;
713 uppercase(t);
714 if( strstr(t, "ZMAT"))
715 {
716 OkZMat = TRUE;
717 OkBasisKeyWord = TRUE;
718 }
719 if( strstr(t, "BASIS") && strstr(t, "SET"))
720 {
721 OkBasisKeyWord = TRUE;
722 OkEndBasisKeyWord = FALSE;
723 }
724 if( strstr(t, "BASIS") && strstr(t, "="))
725 {
726 OkBasisKeyWord = TRUE;
727 OkEndBasisKeyWord = TRUE;
728 }
729 if( strstr(t, "END") && strstr(t, "OF") && strstr(t, "BASIS"))
730 {
731 if(OkBasisKeyWord)
732 {
733 OkBasisKeyWord = FALSE;
734 OkEndBasisKeyWord = TRUE;
735 }
736 else
737 break;
738 }
739 if( strstr(t, "END") && strstr(t, "OF") && strstr(t, "INPUT") && !strstr(t,"-"))
740 {
741 OkEndInputKeyWord = TRUE;
742 break;
743 }
744 if( strstr(t, "&"))
745 {
746 Ok = FALSE;
747 break;
748 }
749 }
750 if(OkGateWayKeyWord && OkEndBasisKeyWord && OkEndInputKeyWord) Ok = TRUE;
751 break;
752 }
753 }
754 fclose(file);
755 if(!Ok) return 0;
756 if(Ok && !OkZMat ) return 1;
757 return 2;
758 }
759 /************************************************************************************************************/
getMolcasGeometryListOfAtomsFromInputFile(gchar * fileName,gint * numberOfAtoms,gint ** basisNumber,gint * numberOfBasis,gchar *** listOfBasis,gint * numberOfMolcasGenerators,gchar * molcasGenerators[])760 static gchar** getMolcasGeometryListOfAtomsFromInputFile(gchar* fileName,
761 gint* numberOfAtoms,
762 gint** basisNumber,
763 gint* numberOfBasis,
764 gchar*** listOfBasis,
765 gint* numberOfMolcasGenerators, gchar* molcasGenerators[])
766 {
767 gchar t[BSIZE];
768 FILE* file = NULL;
769 gboolean Ok = FALSE;
770 gboolean OkGateWayKeyWord = FALSE;
771 gint nAtoms = 0;
772 gint nBas = 0;
773 gchar** listOfAtoms = NULL;
774 long gateWayPos = 0;
775 gint i;
776
777 *numberOfBasis = 0;
778 *listOfBasis = NULL;
779 *numberOfAtoms = 0;
780 *numberOfMolcasGenerators = 0;
781 *basisNumber = NULL;
782
783 #ifdef G_OS_WIN32
784 file = FOpen(fileName, "rb");
785 #else
786 file = FOpen(fileName, "r");
787 #endif
788 if(!file) return listOfAtoms;
789 while(!feof(file))
790 {
791 if(!fgets(t, BSIZE, file)) { Ok = FALSE; break;}
792 uppercase(t);
793 if( strstr(t, "&GATEWAY"))
794 {
795 OkGateWayKeyWord = TRUE;
796 gateWayPos = ftell(file);
797 }
798 if( strstr(t, "&SEWARD") && strstr(t, "&END"))
799 {
800 OkGateWayKeyWord = TRUE;
801 gateWayPos = ftell(file);
802 }
803 if(OkGateWayKeyWord)
804 {
805 Ok = TRUE;
806 while(Ok && !feof(file) && ( ! (strstr(t,"END") && strstr(t,"OF") && strstr(t,"INPUT") && !strstr(t,"-")) ) )
807 {
808 if(!fgets(t, BSIZE, file)){Ok = FALSE; break;}
809 uppercase(t);
810 if(strstr(t, "SYMMETRY"))
811 {
812 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;}
813 *numberOfMolcasGenerators = sscanf(t,"%s %s %s",
814 molcasGenerators[0], molcasGenerators[1],molcasGenerators[2]);
815 }
816 if( strstr(t, "BASIS") && strstr(t, "SET"))
817 {
818 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;} /* Basis Name */
819 nBas++;
820 *listOfBasis = g_realloc(*listOfBasis, nBas*sizeof(gchar*));
821 str_delete_n(t);
822 (*listOfBasis)[nBas-1] = g_strdup(t);
823
824 while(!feof(file))
825 {
826 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;}
827 uppercase(t);
828 if(strstr(t,"END") && strstr(t,"OF") && strstr(t,"BASIS")) break;
829
830 nAtoms++;
831 listOfAtoms = g_realloc(listOfAtoms, nAtoms*sizeof(gchar*));
832 str_delete_n(t);
833 listOfAtoms[nAtoms-1] = g_strdup(t);
834
835 *basisNumber = g_realloc(*basisNumber, nAtoms*sizeof(gint));
836 (*basisNumber)[nAtoms-1] = nBas-1;
837 }
838 }
839 if( strstr(t, "COORD"))
840 {
841 gint n = 0;
842 gint nb = 0;
843 gchar symb[10];
844 gchar symbOld[10]="H";
845 gint c;
846 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;} /* number of Atoms */
847 n = atoi(t);
848 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;} /* Comments */
849 for(i=0;i<n;i++)
850 {
851 if(!fgets(t, BSIZE, file)){ Ok = FALSE; break;}
852 uppercase(t);
853 if(strstr(t,"END") && strstr(t,"OF") && strstr(t,"COORD")) break;
854 nAtoms++;
855 listOfAtoms = g_realloc(listOfAtoms, nAtoms*sizeof(gchar*));
856 str_delete_n(t);
857 listOfAtoms[nAtoms-1] = g_strdup_printf("%s /ANG",t);
858 sscanf(t,"%s",symb);
859 for(c=0;c<(gint)strlen(symb);c++) if(isdigit(symb[c])) symb[c] = ' ';
860 delete_all_spaces(symb);
861 for(c=0;c<(gint)strlen(symb);c++) symb[c] = tolower(symb[c]);
862 if(i>0 && strcmp(symb,symbOld)) nb++;
863 sprintf(symbOld,"%s",symb);
864 *basisNumber = g_realloc(*basisNumber, nAtoms*sizeof(gint));
865 (*basisNumber)[nAtoms-1] = nb;
866 }
867 }
868 }
869 break;
870 }
871 }
872 if(!Ok && nAtoms > 0)
873 {
874 if(listOfAtoms)
875 {
876 for(i=0 ; i<nAtoms; i++)
877 if(listOfAtoms[i]) g_free(listOfAtoms[i]);
878 g_free(listOfAtoms);
879 }
880 listOfAtoms = NULL;
881 nAtoms = 0;
882 if(*listOfBasis)
883 {
884 for(i=0 ; i<nBas; i++)
885 if((*listOfBasis)[i]) g_free((*listOfBasis)[i]);
886 g_free((*listOfBasis));
887 }
888 if(*basisNumber)
889 g_free((*basisNumber));
890 *basisNumber = NULL;
891 nBas = 0;
892 *numberOfMolcasGenerators = 0;
893 }
894 *numberOfAtoms = nAtoms;
895 *numberOfBasis = nBas;
896 fclose(file);
897 return listOfAtoms;
898 }
899 /************************************************************************************************************/
setMolcasMoleculeFromListOfAtoms(gint numberOfAtoms,gchar ** listOfAtoms,gint * basisNumber,gint numberOfBasis,gchar ** listOfBasis,gint numberOfMolcasGenerators,gchar * molcasGenerators[])900 static gint setMolcasMoleculeFromListOfAtoms(
901 gint numberOfAtoms, gchar** listOfAtoms,gint* basisNumber,
902 gint numberOfBasis, gchar** listOfBasis,
903 gint numberOfMolcasGenerators, gchar* molcasGenerators[])
904 {
905 gint i;
906 gint n;
907 MolcasAtom* atomList = NULL;
908 gchar symb[5];
909
910 molcasMolecule.listOfAtoms = NULL;
911 molcasMolecule.numberOfAtoms = 0;
912 molcasMolecule.numberOfDifferentKindsOfAtoms=0;
913 molcasMolecule.symbol = NULL;
914 molcasMolecule.numberOfAtomsOfEachType = NULL;
915
916 molcasMolecule.listOfAtoms = (MolcasAtom*)g_malloc(sizeof(MolcasAtom)*(numberOfAtoms));
917 if(molcasMolecule.listOfAtoms==NULL) return -1;
918
919 molcasMolecule.numberOfAtoms = numberOfAtoms;
920
921 molcasMolecule.symbol = (gchar**)g_malloc(sizeof(gchar*)*(molcasMolecule.numberOfAtoms));
922 if( molcasMolecule.symbol == NULL) return -1;
923 for(n=0; n<molcasMolecule.numberOfAtoms; n++) molcasMolecule.symbol[n] = NULL;
924
925 molcasMolecule.numberOfAtomsOfEachType = (gint*)g_malloc(sizeof(gint)*(molcasMolecule.numberOfAtoms));
926 if(molcasMolecule.numberOfAtomsOfEachType == NULL) return -1;
927
928 molcasMolecule.numberOfDifferentKindsOfAtoms = numberOfBasis;
929
930
931 atomList = molcasMolecule.listOfAtoms;
932 for(n=0; n<molcasMolecule.numberOfAtoms; n++)
933 {
934 molcasMolecule.symbol[basisNumber[n]] = g_malloc(BSIZE*sizeof(gchar));
935 sscanf(listOfAtoms[n],"%s %lf %lf %lf",
936 symb,
937 &(atomList->position[0]),
938 &(atomList->position[1]),
939 &(atomList->position[2]));
940 if(!strstr(listOfAtoms[n],"/ANG"))
941 {
942 atomList->position[0] *= BOHR_TO_ANG;
943 atomList->position[1] *= BOHR_TO_ANG;
944 atomList->position[2] *= BOHR_TO_ANG;
945 }
946
947 atomList->type = basisNumber[n];
948 atomList++;
949 for(i=0;i<(gint)strlen(symb);i++)
950 if(isdigit(symb[i])) symb[i] = ' ';
951
952 delete_all_spaces(symb);
953 for(i=1;i<(gint)strlen(symb);i++)
954 symb[i] = tolower(symb[i]);
955
956 molcasMolecule.symbol[basisNumber[n]] = g_strdup(symb);
957 }
958 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
959 {
960 molcasMolecule.numberOfAtomsOfEachType[i] = 0;
961 for(n=0;n<numberOfAtoms; n++)
962 {
963 if (i==basisNumber[n])
964 molcasMolecule.numberOfAtomsOfEachType[i]++;
965 }
966 }
967 if(molcasMolecule.numberOfDifferentKindsOfAtoms<1) return 0;
968
969 molcasMolecule.basis = g_malloc(molcasMolecule.numberOfDifferentKindsOfAtoms*sizeof(gchar*));
970
971 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
972 molcasMolecule.basis[i] = g_strdup(listOfBasis[i]);
973
974 resetNumberOfValenceElectrons();
975
976 molcasMolecule.numberOfMolcasGenerators = numberOfMolcasGenerators;
977 for(i=0; i<molcasMolecule.numberOfMolcasGenerators; i++)
978 molcasMolecule.molcasGenerators[i] = g_strdup(molcasGenerators[i]);
979
980 /*
981 atomList = molcasMolecule.listOfAtoms;
982 for(n=0; n<molcasMolecule.numberOfAtoms; n++)
983 {
984 printf("TODEL %s %f %f %f\n",
985 molcasMolecule.symbol[atomList->type],
986 atomList->position[0],
987 atomList->position[1],
988 atomList->position[2]);
989 atomList++;
990 }
991
992 printf("TODEL SYMMETRY : ");
993 for(n=0; n<molcasMolecule.numberOfMolcasGenerators; n++)
994 printf("%s ",molcasMolecule.molcasGenerators[n]);
995 printf("\n");
996 */
997
998 return 0;
999 }
1000 /********************************************************************************/
read_charge_and_multiplicity_from_molcas_input_file(gchar * fileName)1001 static void read_charge_and_multiplicity_from_molcas_input_file(gchar* fileName)
1002 {
1003 gchar t[BSIZE];
1004 FILE* file = NULL;
1005
1006 TotalCharges[0] = 0;
1007 SpinMultiplicities[0] =1;
1008
1009 file = FOpen(fileName, "r");
1010 if(!file) return;
1011 while(!feof(file) )
1012 {
1013 if(!fgets(t, BSIZE, file)) return;
1014 uppercase(t);
1015 if ( strstr(t,"CHARGE") && strstr(t,"="))
1016 {
1017 gchar* p = strstr(t,"=")+1;
1018 TotalCharges[0] = atoi(p);
1019 }
1020 if ( strstr(t,"ZSPIN") && strstr(t,"="))
1021 {
1022 gchar* p = strstr(t,"=")+1;
1023 SpinMultiplicities[0] = atoi(p)+1;
1024 }
1025 }
1026 fclose(file);
1027 }
1028 /************************************************************************************************************/
readMolcasGeometryXYZFromInputFile(gchar * fileName)1029 static void readMolcasGeometryXYZFromInputFile(gchar* fileName)
1030 {
1031 gchar** listOfAtoms = NULL;
1032 gint numberOfAtoms = 0;
1033 gint numberOfBasis = 0;
1034 gchar** listOfBasis = NULL;
1035 gint* basisNumber = NULL;
1036
1037 gint numberOfMolcasGenerators = 0;
1038 gchar* molcasGenerators[3];
1039
1040 gint numberOfGenerators = 0;
1041 gchar* generators[3];
1042
1043 gint numberOfElements = 0;
1044 gchar* elements[8];
1045
1046 gchar groupName[BSIZE];
1047
1048 gint i;
1049
1050
1051 for(i=0;i<3;i++) molcasGenerators[i] = g_malloc(BSIZE*sizeof(gchar));
1052 for(i=0;i<3;i++) generators[i] = g_malloc(BSIZE*sizeof(gchar));
1053 for(i=0;i<8;i++) elements[i] = g_malloc(BSIZE*sizeof(gchar));
1054
1055 listOfAtoms = getMolcasGeometryListOfAtomsFromInputFile(fileName, &numberOfAtoms,&basisNumber,
1056 &numberOfBasis, &listOfBasis,
1057 &numberOfMolcasGenerators, molcasGenerators);
1058
1059 /* print All */
1060 /*
1061 printf("TODEL : nAtoms = %d nBas = %d\n",numberOfAtoms, numberOfBasis);
1062 printf("TODEL Basis List\n");
1063 for(i=0;i<numberOfBasis;i++)
1064 printf("TODEL : %s\n",listOfBasis[i]);
1065 printf("\nTODEL Atom List\n");
1066 for(i=0;i<numberOfAtoms;i++)
1067 printf("TODEL : %s Basis Number = %d \n",listOfAtoms[i], basisNumber[i]);
1068 */
1069
1070 if(numberOfAtoms>0)
1071 {
1072 freeMolcasMolecule();
1073 setMolcasMoleculeFromListOfAtoms(
1074 numberOfAtoms, listOfAtoms, basisNumber,
1075 numberOfBasis,listOfBasis,
1076 numberOfMolcasGenerators, molcasGenerators);
1077 /*
1078 printf("numberOfMolcasGenerators = %d\n",numberOfMolcasGenerators);
1079 for(i=0;i<numberOfMolcasGenerators;i++)
1080 printf("%s\n",molcasGenerators[i]);
1081 */
1082 }
1083
1084 setGeneratorsAndAbelianGroup(groupName,
1085 &numberOfGenerators, generators,
1086 &numberOfMolcasGenerators, molcasGenerators,
1087 &numberOfElements, elements);
1088
1089 /*
1090 printf("groupName = %s\n",groupName);
1091 */
1092
1093 if(numberOfMolcasGenerators==0)
1094 {
1095 setGeomXYZFromMolcasMolecule();
1096 }
1097 else
1098 if(molcasMolecule.numberOfAtoms>0)
1099 {
1100 gchar** symbols = g_malloc(molcasMolecule.numberOfAtoms*sizeof(gchar*));
1101 gdouble* X = g_malloc(molcasMolecule.numberOfAtoms*sizeof(gdouble));
1102 gdouble* Y = g_malloc(molcasMolecule.numberOfAtoms*sizeof(gdouble));
1103 gdouble* Z = g_malloc(molcasMolecule.numberOfAtoms*sizeof(gdouble));
1104 gint numberOfAtoms = molcasMolecule.numberOfAtoms;
1105
1106 setSymbolsXYZFromMolcasMolecule(symbols,X,Y, Z);
1107
1108 generateMoleculeUsingAbelianGroup(groupName, &numberOfAtoms, &symbols, &X, &Y, &Z);
1109
1110 /*
1111 printf("Molecule generate Using groupe Symmetry\n");
1112 for(i=0;i<numberOfAtoms;i++)
1113 {
1114 printf("%s %f %f %f\n",symbols[i], X[i], Y[i], Z[i]);
1115 }
1116 */
1117
1118 setGeomXYZFromSXYZ(numberOfAtoms, symbols, X, Y, Z);
1119 if(symbols)
1120 {
1121 for(i=0;i<numberOfAtoms; i++)
1122 if(symbols[i]) g_free(symbols[i]);
1123 g_free(symbols);
1124 }
1125 if(X) g_free(X);
1126 if(Y) g_free(Y);
1127 if(Z) g_free(Z);
1128 }
1129 setnumberOfAtomsOfEachTypeForAllAtomsFromGeomXYZ();
1130
1131 /* free All local variable */
1132 for(i=0;i<3;i++) if( molcasGenerators[i]) g_free( molcasGenerators[i]);
1133 for(i=0;i<3;i++) if( generators[i]) g_free( generators[i]);
1134 for(i=0;i<8;i++) if( elements[i]) g_free( elements[i]);
1135
1136 if(listOfAtoms)
1137 {
1138 for(i=0 ; i<numberOfAtoms; i++)
1139 if(listOfAtoms[i]) g_free(listOfAtoms[i]);
1140 g_free(listOfAtoms);
1141 }
1142 if(listOfBasis)
1143 {
1144 for(i=0 ; i<numberOfBasis; i++)
1145 if(listOfBasis[i]) g_free(listOfBasis[i]);
1146 g_free(listOfBasis);
1147 }
1148 if(basisNumber)
1149 g_free(basisNumber);
1150 read_charge_and_multiplicity_from_molcas_input_file(fileName);
1151
1152 }
1153 /************************************************************************************************************/
getGroupSymmetry(gchar * fileName)1154 static gint getGroupSymmetry(gchar* fileName)
1155 {
1156 gchar t[BSIZE];
1157 FILE* file = NULL;
1158 gint g = 1;
1159
1160 file = FOpen(fileName, "r");
1161 if(!file) return 0;
1162
1163 while(!feof(file))
1164 {
1165 if(!fgets(t, BSIZE, file)) break;
1166 uppercase(t);
1167 if( strstr(t, "GROUP=") && strstr(t, "FULL"))
1168 {
1169 g = 0;
1170 break;
1171 }
1172 if( strstr(t, "GROUP=") && strstr(t, "NOSYM"))
1173 {
1174 g = 2;
1175 break;
1176 }
1177 if( strstr(t, "GROUP"))
1178 {
1179 { char* e = fgets(t,BSIZE,file);}
1180 if( strstr(t, "FULL"))
1181 {
1182 g = 0;
1183 break;
1184 }
1185 else if( strstr(t, "NOSYM"))
1186 {
1187 g = 2;
1188 break;
1189 }
1190 }
1191 }
1192 fclose(file);
1193 return g;
1194 }
1195 /************************************************************************************************************/
setMolcasGeometryFromInputFile(gchar * fileName)1196 void setMolcasGeometryFromInputFile(gchar* fileName)
1197 {
1198 gint available = testMolcasGeometryAvailableInInputFile(fileName);
1199
1200 /* printf("available =%d\n",available);*/
1201 if(available<1)
1202 {
1203 gchar buffer[BSIZE];
1204 sprintf(buffer,_("Sorry, I can not read geometry from %s file"),fileName);
1205 Message(buffer,_("Warning"),TRUE);
1206 return;
1207 }
1208 if(available==2) /* ZMatrix */
1209 {
1210 if(0==read_Zmat_from_molcas_input_file(fileName))
1211 {
1212 setMolcasMoleculeFromGeomZMatrix();
1213 groupSymmetry = 0;
1214 }
1215 return;
1216 }
1217 readMolcasGeometryXYZFromInputFile(fileName);
1218 groupSymmetry = getGroupSymmetry(fileName);
1219 }
1220 /**************************************************************************************************************************************/
activateRadioButton(GtkWidget * button,gpointer data)1221 static void activateRadioButton(GtkWidget *button, gpointer data)
1222 {
1223 gint* type = NULL;
1224 GtkWidget* label = NULL;
1225 gchar buffer[BSIZE];
1226
1227 if(!GTK_IS_WIDGET(button)) return;
1228
1229 type = g_object_get_data(G_OBJECT (button), "Type");
1230 label = g_object_get_data(G_OBJECT (button), "Label");
1231 if(type)
1232 {
1233 groupSymmetry = *type;
1234 setMolcasMolecule();
1235
1236 if(label) gtk_label_set_text(GTK_LABEL(label)," ");
1237 if(buttonTolerance && groupSymmetry == 1 ) gtk_widget_set_sensitive(buttonTolerance, TRUE);
1238 if(buttonTolerance && groupSymmetry != 1 ) gtk_widget_set_sensitive(buttonTolerance, FALSE);
1239
1240 if(buttonView) gtk_widget_set_sensitive(buttonView, TRUE);
1241
1242 if(label && groupSymmetry == 1 )
1243 {
1244 sprintf(buffer,"%s group",molcasMolecule.groupSymbol);
1245 gtk_label_set_text(GTK_LABEL(label),buffer);
1246 }
1247
1248
1249 }
1250 }
1251 /************************************************************************************************************/
addRadioButtonToATable(GtkWidget * table,GtkWidget * friendButton,gchar * label,gint i,gint j,gint k)1252 static GtkWidget* addRadioButtonToATable(GtkWidget* table, GtkWidget* friendButton, gchar* label, gint i, gint j, gint k)
1253 {
1254 GtkWidget *newButton;
1255
1256 if(friendButton)
1257 newButton = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (friendButton)), label);
1258 else
1259 newButton = gtk_radio_button_new_with_label( NULL, label);
1260
1261 gtk_table_attach(GTK_TABLE(table),newButton,j,j+k,i,i+1,
1262 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1263 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1264 3,3);
1265
1266 g_object_set_data(G_OBJECT (newButton), "Label",NULL);
1267 g_object_set_data(G_OBJECT (newButton), "Type",NULL);
1268 return newButton;
1269 }
1270 /**************************************************************************************************************************************/
resetTolerance(GtkWidget * win)1271 static void resetTolerance(GtkWidget *win)
1272 {
1273 gchar buffer[BSIZE];
1274
1275 setMolcasMolecule();
1276 if(labelSymmetry)
1277 {
1278 sprintf(buffer,"%s group",molcasMolecule.groupSymbol);
1279 gtk_label_set_text(GTK_LABEL(labelSymmetry),buffer);
1280 }
1281 }
1282 /**************************************************************************************************************************************/
activateToleranceButton(GtkWidget * button,gpointer data)1283 static void activateToleranceButton(GtkWidget *button, gpointer data)
1284 {
1285 if(!GTK_IS_WIDGET(button)) return;
1286 createToleranceWindow(molcasWin, resetTolerance);
1287 }
1288 /**************************************************************************************************************************************/
activateSolvConductorButton(GtkWidget * button,gpointer data)1289 static void activateSolvConductorButton(GtkWidget *button, gpointer data)
1290 {
1291 if(!GTK_IS_WIDGET(button)) return;
1292
1293 sprintf(molcasSolvation.method,"PCM");
1294 if(GTK_TOGGLE_BUTTON (button)->active)
1295 sprintf(molcasSolvation.method,"CPCM");
1296 }
1297 /**************************************************************************************************************************************/
activateSolvRadioButton(GtkWidget * button,gpointer data)1298 static void activateSolvRadioButton(GtkWidget *button, gpointer data)
1299 {
1300 gchar* type = NULL;
1301 GtkWidget *entrySolvation = NULL;
1302 GtkWidget *buttonConductor = NULL;
1303
1304 if(!GTK_IS_WIDGET(button)) return;
1305
1306 entrySolvation = g_object_get_data(G_OBJECT (button), "EntrySolvent");
1307 buttonConductor = g_object_get_data(G_OBJECT (button), "ButtonConductor");
1308 type = g_object_get_data(G_OBJECT (button), "Type");
1309
1310 if(type && !strcmp(type,"PCM"))
1311 {
1312 if(entrySolvation) gtk_widget_set_sensitive(entrySolvation, TRUE);
1313 if(buttonConductor) gtk_widget_set_sensitive(buttonConductor, TRUE);
1314 sprintf(molcasSolvation.method,"PCM");
1315 if(buttonConductor && GTK_TOGGLE_BUTTON (buttonConductor)->active)
1316 sprintf(molcasSolvation.method,"CPCM");
1317 }
1318 else
1319 {
1320 if(entrySolvation) gtk_widget_set_sensitive(entrySolvation, FALSE);
1321 if(buttonConductor) gtk_widget_set_sensitive(buttonConductor, FALSE);
1322 sprintf(molcasSolvation.method,"Nothing");
1323 }
1324 }
1325 /***************************************************************************************/
changedEntrySolvent(GtkWidget * entry,gpointer data)1326 static void changedEntrySolvent(GtkWidget *entry, gpointer data)
1327 {
1328 G_CONST_RETURN gchar* entryText = NULL;
1329 gchar* tmp = NULL;
1330
1331 if(!GTK_IS_WIDGET(entry)) return;
1332
1333 entryText = gtk_entry_get_text(GTK_ENTRY(entry));
1334 if(strlen(entryText)<1)return;
1335
1336 tmp = g_strdup(entryText);
1337 delete_all_spaces(tmp);
1338 sprintf(molcasSolvation.solvent,"%s",tmp);
1339 g_free(tmp);
1340 }
1341 /*********************************************************************************************/
addComboListToATable(GtkWidget * table,gchar ** list,gint nlist,gint i,gint j,gint k)1342 static GtkWidget* addComboListToATable(GtkWidget* table,
1343 gchar** list, gint nlist, gint i, gint j, gint k)
1344 {
1345 GtkWidget *entry = NULL;
1346 GtkWidget *combo = NULL;
1347
1348 combo = create_combo_box_entry(list, nlist, TRUE, -1, -1);
1349
1350 gtk_table_attach(GTK_TABLE(table),combo,j,j+k,i,i+1,
1351 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1352 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1353 3,3);
1354 entry = GTK_BIN (combo)->child;
1355 g_object_set_data(G_OBJECT (entry), "Combo",combo);
1356
1357 return entry;
1358 }
1359 /************************************************************************************************************************/
createSolvationFrame(GtkWidget * win,GtkWidget * box)1360 void createSolvationFrame(GtkWidget *win, GtkWidget *box)
1361 {
1362 GtkWidget* button;
1363 GtkWidget* frame;
1364 GtkWidget* vboxFrame;
1365 GtkWidget *table = gtk_table_new(1,5,FALSE);
1366 GtkWidget* entrySolvent = NULL;
1367 GtkWidget* buttonConductor = gtk_check_button_new_with_label ("Conductor Version");
1368 static gchar* types[] ={"Nothing","PCM"};
1369 gchar* listSolvents[] = { "Water", "Acetonitrile", "Methanol", "Ethanol", "IsoQuinoline", "Quinoline",
1370 "Chloroform", "EthylEther", "MethyleneChloride", "DiChloroEthane", "CarbonTetraChloride",
1371 "Benzene", "Toluene", "ChloroBenzene", "NitroMethane", "Heptane",
1372 "CycloHexane", "Aniline", "Acetone", "TetraHydroFuran", "DiMethylSulfoxide",
1373 "Argon", "Krypton", "Xenon" };
1374 gint nlistSolvents = G_N_ELEMENTS (listSolvents);
1375
1376 frame = gtk_frame_new ("Solvation");
1377 gtk_widget_show (frame);
1378 gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
1379 gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
1380
1381 vboxFrame = gtk_vbox_new (FALSE, 3);
1382 gtk_widget_show (vboxFrame);
1383 gtk_container_add (GTK_CONTAINER (frame), vboxFrame);
1384
1385 gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);
1386
1387 entrySolvent = addComboListToATable(table, listSolvents, nlistSolvents, 0, 2, 1);
1388 add_widget_table(table, buttonConductor, 0, 3);
1389
1390 button = addRadioButtonToATable(table, NULL, _("Nothing"), 0, 0,1);
1391 g_object_set_data(G_OBJECT (button), "Type",types[0]);
1392 g_object_set_data(G_OBJECT (button), "EntrySolvent",entrySolvent);
1393 g_object_set_data(G_OBJECT (button), "ButtonConductor",buttonConductor);
1394 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1395 g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateSolvRadioButton),NULL);
1396
1397 button = addRadioButtonToATable(table, button, "PCM", 0, 1, 1);
1398 g_object_set_data(G_OBJECT (button), "Type",types[1]);
1399 g_object_set_data(G_OBJECT (button), "EntrySolvent",entrySolvent);
1400 g_object_set_data(G_OBJECT (button), "ButtonConductor",buttonConductor);
1401 g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateSolvRadioButton),NULL);
1402 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
1403
1404 g_signal_connect(G_OBJECT(entrySolvent),"changed", G_CALLBACK(changedEntrySolvent),button);
1405 gtk_entry_set_text(GTK_ENTRY(entrySolvent),"Water");
1406 gtk_widget_set_sensitive(entrySolvent, FALSE);
1407 gtk_widget_set_sensitive(buttonConductor, FALSE);
1408 sprintf(molcasSolvation.method,"Nothing");
1409 sprintf(molcasSolvation.solvent,"Water");
1410 g_signal_connect(G_OBJECT(buttonConductor),"clicked", G_CALLBACK(activateSolvConductorButton),NULL);
1411 }
1412 /************************************************************************************************************/
putSolvationSewardInTextEditor()1413 static void putSolvationSewardInTextEditor()
1414 {
1415 gchar buffer[BSIZE];
1416 if(!strcmp(molcasSolvation.method,"Nothing")) return;
1417 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "RF-Input\n",-1);
1418 if(!strcmp(molcasSolvation.method,"PCM") || !strcmp(molcasSolvation.method,"CPCM"))
1419 {
1420 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " PCM-Model\n",-1);
1421 sprintf(buffer," Solvent=%s\n",molcasSolvation.solvent);
1422 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
1423 if(!strcmp(molcasSolvation.method,"CPCM"))
1424 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " Conductor Version\n",-1);
1425 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " AARE=0.4\n",-1);
1426 }
1427 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of RF-Input\n",-1);
1428
1429 }
1430 /************************************************************************************************************/
putInfoInTextWidget(GtkWidget * textWid)1431 static void putInfoInTextWidget(GtkWidget* textWid)
1432 {
1433 gchar buffer[BSIZE];
1434 MolcasAtom* atomList = NULL;
1435 gint i;
1436 gint k;
1437 gint n;
1438 gdouble principalAxisTolerance = getTolerancePrincipalAxis();
1439 gdouble positionTolerance = getTolerancePosition();
1440
1441 /* if(molcasMolecule.numberOfMolcasGenerators<1) return;*/
1442 if(molcasMolecule.numberOfAtoms<1) return;
1443
1444 sprintf(buffer,_("Group symbol = %s\n"),molcasMolecule.groupSymbol);
1445 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1446
1447 sprintf(buffer,_("Tolerance for principal axis classification : %0.5f\n"),principalAxisTolerance);
1448 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL,buffer,-1);
1449
1450
1451 if(positionTolerance<0)
1452 sprintf(buffer,_("Precision for atom position : Min distance between atoms\n\n"));
1453 else
1454 sprintf(buffer,_("Precision for atom position : %0.5f\n\n"),positionTolerance);
1455
1456 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer,-1);
1457
1458 sprintf(buffer,_("Total number of electrons : %d\n\n"),molcasMolecule.totalNumberOfElectrons);
1459 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL,buffer,-1);
1460
1461 sprintf(buffer,"================================================================\n");
1462 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer,-1);
1463
1464 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, &molcasColorFore.subProgram, NULL, _("Generators : "),-1);
1465 if(molcasMolecule.numberOfMolcasGenerators==0)
1466 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, _("Nothing"), -1);
1467
1468 for (i=0;i<molcasMolecule.numberOfMolcasGenerators;i++)
1469 {
1470 sprintf(buffer,"%s ",molcasMolecule.molcasGenerators[i]);
1471 uppercase(buffer);
1472 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1473 }
1474 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, "\n",-1);
1475
1476 sprintf(buffer,"================================================================\n");
1477 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer,-1);
1478
1479 atomList = molcasMolecule.listOfAtoms;
1480 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
1481 {
1482
1483 sprintf(buffer,_("Type n %d\n"),i+1);
1484 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1485 sprintf(buffer,_("Basis = %s\n"),molcasMolecule.basis[i]);
1486 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1487
1488 sprintf(buffer,_("Number of atoms (without reduction ) for %s = %d \n"),
1489 molcasMolecule.symbol[i],
1490 molcasMolecule.numberOfAtomsOfEachTypeForAllAtoms[i]);
1491 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1492 sprintf(buffer,_("Number of atoms (with reduction ) for %s = %d \n"),
1493 molcasMolecule.symbol[i],
1494 molcasMolecule.numberOfAtomsOfEachType[i]);
1495 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1496 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, "\n\n", -1);
1497
1498 n = 1;
1499 for(k=0; k<molcasMolecule.numberOfAtoms; k++)
1500 {
1501 if(atomList[k].type == i)
1502 {
1503
1504 sprintf(buffer,"%s%d %f %f %f /Angstrom\n",molcasMolecule.symbol[i], n,
1505 atomList[k].position[0], atomList[k].position[1], atomList[k].position[2]);
1506
1507 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer, -1);
1508 n++;
1509 }
1510 }
1511 }
1512 sprintf(buffer,"================================================================\n");
1513 gabedit_text_insert (GABEDIT_TEXT(textWid), NULL, NULL, NULL, buffer,-1);
1514 }
1515 /************************************************************************************************************/
createBasisWindow(GtkWidget * win,gpointer data)1516 static void createBasisWindow(GtkWidget* win, gpointer data)
1517 {
1518
1519 GtkWidget* winBasis = createMolcasBasisWindow();
1520 if(GTK_IS_WIDGET(win))
1521 gtk_window_set_transient_for(GTK_WINDOW(winBasis),GTK_WINDOW(win));
1522 gtk_window_set_modal (GTK_WINDOW (winBasis), TRUE);
1523 gtk_window_set_position(GTK_WINDOW(winBasis),GTK_WIN_POS_CENTER);
1524 }
1525 /************************************************************************************************************/
createViewInfoAbelianGroupWindow(GtkWidget * win,gpointer data)1526 static void createViewInfoAbelianGroupWindow(GtkWidget* win, gpointer data)
1527 {
1528 GtkWidget *Dialogue = NULL;
1529 GtkWidget *Bouton;
1530 GtkWidget *frame;
1531 GtkWidget *TextWid;
1532 gchar * title = NULL;
1533
1534 if(molcasMolecule.numberOfAtoms<1)
1535 {
1536 Message(_("Sorry Number of atoms is not positive"),_("Error"),TRUE);
1537 return;
1538 }
1539 Dialogue = gtk_dialog_new();
1540 gtk_widget_realize(GTK_WIDGET(Dialogue));
1541 title = g_strdup(_("Point group, abelian point group & Geometry with reduction (using abelian group)"));
1542
1543 gtk_window_set_title(GTK_WINDOW(Dialogue),title);
1544
1545 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
1546 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
1547
1548 g_signal_connect(G_OBJECT(Dialogue), "delete_event", (GCallback)destroy_button_windows, NULL);
1549 g_signal_connect(G_OBJECT(Dialogue), "delete_event", (GCallback)gtk_widget_destroy, NULL);
1550
1551 TextWid = create_text_widget(GTK_WIDGET(GTK_DIALOG(Dialogue)->vbox),NULL,&frame);
1552 gabedit_text_set_editable(GABEDIT_TEXT(TextWid), TRUE);
1553
1554 gtk_box_set_homogeneous (GTK_BOX( GTK_DIALOG(Dialogue)->action_area), FALSE);
1555
1556 Bouton = create_button(Dialogue,"OK");
1557 gtk_box_pack_end (GTK_BOX( GTK_DIALOG(Dialogue)->action_area), Bouton, FALSE, TRUE, 5);
1558 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
1559 gtk_widget_grab_default(Bouton);
1560 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)destroy_button_windows, GTK_OBJECT(Dialogue));
1561 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)gtk_widget_destroy, GTK_OBJECT(Dialogue));
1562
1563 add_button_windows(title,Dialogue);
1564
1565 putInfoInTextWidget(TextWid);
1566
1567 gtk_window_set_default_size (GTK_WINDOW(Dialogue), ScreenWidth/2, ScreenHeight/2);
1568 gtk_widget_show_all(Dialogue);
1569 g_free(title);
1570 if(GTK_IS_WIDGET(win))
1571 gtk_window_set_transient_for(GTK_WINDOW(Dialogue),GTK_WINDOW(win));
1572 }
1573 /**************************************************************************************************************************************/
createSymmetryFrame(GtkWidget * win,GtkWidget * box)1574 void createSymmetryFrame(GtkWidget *win, GtkWidget *box)
1575 {
1576 GtkWidget* button;
1577 GtkWidget* frame;
1578 GtkWidget* vboxFrame;
1579 GtkWidget* label = gtk_label_new(" ");
1580 GtkWidget* label0 = gtk_label_new(_("Find maximum"));
1581 GtkWidget* label2 = gtk_label_new(_("C1 group"));
1582 GtkWidget *table = gtk_table_new(4,3,FALSE);
1583 gint i=0;
1584
1585 frame = gtk_frame_new (_("Geometry& basis"));
1586 gtk_widget_show (frame);
1587 gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
1588 gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
1589
1590 vboxFrame = gtk_vbox_new (FALSE, 3);
1591 gtk_widget_show (vboxFrame);
1592 gtk_container_add (GTK_CONTAINER (frame), vboxFrame);
1593
1594 gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);
1595
1596 i = 0;
1597 button = addRadioButtonToATable(table, NULL, _("Full symmetry"), i, 0,1);
1598 add_widget_table(table, label0, i, 1);
1599 g_object_set_data(G_OBJECT (button), "Label",label);
1600 g_object_set_data(G_OBJECT (button), "Type",&typeOfSymmetry[0]);
1601 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), typeOfSymmetry[0]==groupSymmetry);
1602 g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateRadioButton),NULL);
1603
1604
1605 i = 1;
1606 button = addRadioButtonToATable(table, button, _("Fixed symmetry"), i, 0, 1);
1607 add_widget_table(table, label, i, 1);
1608 g_object_set_data(G_OBJECT (button), "Label",label);
1609 g_object_set_data(G_OBJECT (button), "Type",&typeOfSymmetry[1]);
1610 g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateRadioButton),NULL);
1611 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), typeOfSymmetry[1]==groupSymmetry);
1612
1613 buttonTolerance = create_button(win,_(" Tolerance "));
1614 add_widget_table(table, buttonTolerance, i, 2);
1615 g_signal_connect(G_OBJECT(buttonTolerance),"clicked", G_CALLBACK(activateToleranceButton),NULL);
1616 gtk_widget_set_sensitive(buttonTolerance, FALSE);
1617
1618 i = 2;
1619 button = addRadioButtonToATable(table, button, _("Without symmetry"), i, 0,1);
1620 add_widget_table(table, label2, i, 1);
1621 g_object_set_data(G_OBJECT (button), "Label",label);
1622 g_object_set_data(G_OBJECT (button), "Type",&typeOfSymmetry[2]);
1623 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), typeOfSymmetry[2]==groupSymmetry);
1624 g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateRadioButton),NULL);
1625
1626 i = 3;
1627 buttonView = create_button(win,_(" Show result "));
1628 gtk_table_attach(GTK_TABLE(table),buttonView,1,1+2,i,i+1,
1629 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1630 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
1631 3,3);
1632 /* add_widget_table(table, buttonView, 2, 2);*/
1633 g_signal_connect_swapped(G_OBJECT(buttonView),"clicked", G_CALLBACK(createViewInfoAbelianGroupWindow),GTK_OBJECT(win));
1634 buttonBasis = create_button(win,_(" Set Basis "));
1635 add_widget_table(table, buttonBasis, i, 0);
1636 g_signal_connect_swapped(G_OBJECT(buttonBasis),"clicked", G_CALLBACK(createBasisWindow),GTK_OBJECT(win));
1637
1638 labelSymmetry = label;
1639 }
1640 /************************************************************************************************************/
putSymmetryInTextEditor()1641 void putSymmetryInTextEditor()
1642 {
1643 gchar buffer[BSIZE];
1644 gint i;
1645
1646 if(groupSymmetry==0) gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Group=Full\n",-1);
1647 else if (groupSymmetry==2)
1648 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Group=Nosym\n",-1);
1649 /*
1650 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Group=Generators\n",-1);
1651 */
1652
1653
1654 if(groupSymmetry!=1) return;
1655 if(molcasMolecule.numberOfMolcasGenerators<1) return;
1656 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Symmetry\n",-1);
1657 for (i=0;i<molcasMolecule.numberOfMolcasGenerators;i++)
1658 {
1659 sprintf(buffer,"%s ",molcasMolecule.molcasGenerators[i]);
1660 uppercase(buffer);
1661 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1662 }
1663 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n",-1);
1664 }
1665 /************************************************************************************************************/
putVariableConstantsZMatInTextEditor()1666 void putVariableConstantsZMatInTextEditor()
1667 {
1668 gint i;
1669 gint j;
1670 gint k;
1671 gint l;
1672 gint nVar = 0;
1673 gint nFix = 0;
1674 gchar* line = NULL;
1675
1676 if(MethodeGeom==GEOM_IS_XYZ) return;
1677 if(groupSymmetry==1) return;
1678 for(i=0;i<NcentersZmat;i++)
1679 {
1680 if(Geom[i].Nentry<NUMBER_ENTRY_R) continue;
1681 if(!test(Geom[i].R)) nVar++;
1682 else nFix++;
1683 if(Geom[i].Nentry<NUMBER_ENTRY_ANGLE) continue;
1684 if(!test(Geom[i].Angle)) nVar++;
1685 else nFix++;
1686 if(Geom[i].Nentry<NUMBER_ENTRY_DIHEDRAL) continue;
1687 if(!test(Geom[i].Dihedral)) nVar++;
1688 else nFix++;
1689 }
1690 /*
1691 printf("nVar = %d\n",nVar);
1692 printf("nFix = %d\n",nFix);
1693 */
1694 if(nFix==0 || nVar==0) return;
1695 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Internal Coordinates\n",-1);
1696
1697 for(i=1;i<NcentersZmat;i++)
1698 {
1699 j = atoi(Geom[i].NR)-1;
1700 line=g_strdup_printf(" %s%d%s%d = Bond %s%d %s%d\n",
1701 Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1702 Geom[j].Symb,j+1,Geom[i].Symb,i+1
1703 );
1704 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1705 if(line)g_free(line);
1706 if(Geom[i].Nentry<NUMBER_ENTRY_ANGLE) continue;
1707 k = atoi(Geom[i].NAngle)-1;
1708 line=g_strdup_printf(" %s%d%s%d%s%d = Angle %s%d %s%d %s%d\n",
1709 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1710 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1711 );
1712 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1713 if(line)g_free(line);
1714 if(Geom[i].Nentry<NUMBER_ENTRY_DIHEDRAL) continue;
1715 l = atoi(Geom[i].NDihedral)-1;
1716 line=g_strdup_printf(" %s%d%s%d%s%d%s%d = Dihedral %s%d %s%d %s%d %s%d\n",
1717 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1718 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1719 );
1720 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1721 if(line)g_free(line);
1722 }
1723 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL," Vary\n",-1);
1724 for(i=0;i<NcentersZmat;i++)
1725 {
1726 if(Geom[i].Nentry<NUMBER_ENTRY_R) continue;
1727 j = atoi(Geom[i].NR)-1;
1728 if(!test(Geom[i].R))
1729 {
1730 line=g_strdup_printf(" r%s%d%s%d = 1.0 %s%d%s%d\n",
1731 Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1732 Geom[j].Symb,j+1,Geom[i].Symb,i+1
1733 );
1734 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1735 if(line)g_free(line);
1736 }
1737 if(Geom[i].Nentry<NUMBER_ENTRY_ANGLE) continue;
1738 k = atoi(Geom[i].NAngle)-1;
1739 if(!test(Geom[i].Angle))
1740 {
1741 line=g_strdup_printf(" a%s%d%s%d%s%d = 1.0 %s%d%s%d%s%d\n",
1742 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1743 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1744 );
1745 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1746 if(line)g_free(line);
1747 }
1748 if(Geom[i].Nentry<NUMBER_ENTRY_DIHEDRAL) continue;
1749 l = atoi(Geom[i].NDihedral)-1;
1750 if(!test(Geom[i].Dihedral))
1751 {
1752 line=g_strdup_printf(" d%s%d%s%d%s%d%s%d = 1.0 %s%d%s%d%s%d%s%d\n",
1753 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1754 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1755 );
1756 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1757 if(line)g_free(line);
1758 }
1759 }
1760 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL," Fix\n",-1);
1761 for(i=0;i<NcentersZmat;i++)
1762 {
1763 if(Geom[i].Nentry<NUMBER_ENTRY_R) continue;
1764 j = atoi(Geom[i].NR)-1;
1765 if(test(Geom[i].R))
1766 {
1767 line=g_strdup_printf(" r%s%d%s%d = 1.0 %s%d%s%d\n",
1768 Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1769 Geom[j].Symb,j+1,Geom[i].Symb,i+1
1770 );
1771 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1772 if(line)g_free(line);
1773 }
1774 if(Geom[i].Nentry<NUMBER_ENTRY_ANGLE) continue;
1775 k = atoi(Geom[i].NAngle)-1;
1776 if(test(Geom[i].Angle))
1777 {
1778 line=g_strdup_printf(" a%s%d%s%d%s%d = 1.0 %s%d%s%d%s%d\n",
1779 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1780 Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1781 );
1782 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1783 if(line)g_free(line);
1784 }
1785 if(Geom[i].Nentry<NUMBER_ENTRY_DIHEDRAL) continue;
1786 l = atoi(Geom[i].NDihedral)-1;
1787 if(test(Geom[i].Dihedral))
1788 {
1789 line=g_strdup_printf(" d%s%d%s%d%s%d%s%d = 1.0 %s%d%s%d%s%d%s%d\n",
1790 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1,
1791 Geom[l].Symb,l+1,Geom[k].Symb,k+1,Geom[j].Symb,j+1,Geom[i].Symb,i+1
1792 );
1793 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, NULL,line,-1);
1794 if(line)g_free(line);
1795 }
1796 }
1797 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of Internal Coordinates\n",-1);
1798 }
1799 /************************************************************************************************************/
getV(gchar * source)1800 static gdouble getV(gchar* source)
1801 {
1802 if(!test(source)) return get_value_variableZmat(source);
1803 else return atof(source);
1804 }
1805 /************************************************************************************************************/
putMoleculeZMatBasisInTextEditor()1806 static void putMoleculeZMatBasisInTextEditor()
1807 {
1808 gchar buffer[BSIZE];
1809 gint i;
1810 gchar* line = NULL;
1811 SAtomsProp prop;
1812
1813 if(molcasMolecule.numberOfAtoms<1) return;
1814 if(NcentersZmat<1) return;
1815
1816 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "zMat\n",-1);
1817 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
1818 {
1819 sprintf(buffer,"%s\n",molcasMolecule.basis[i]);
1820 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1821 }
1822 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of basis\n",-1);
1823 for(i=0;i<NcentersZmat;i++)
1824 {
1825 line=g_strdup_printf("%s%d",Geom[i].Symb,i+1);
1826
1827 if(Geom[i].Nentry>NUMBER_ENTRY_0)
1828 line=g_strdup_printf("%s\t%s\t%f",line,Geom[i].NR,getV(Geom[i].R));
1829 if(Geom[i].Nentry>NUMBER_ENTRY_R)
1830 line=g_strdup_printf("%s\t%s\t%f",line,Geom[i].NAngle,getV(Geom[i].Angle));
1831 if(Geom[i].Nentry>NUMBER_ENTRY_ANGLE)
1832 line=g_strdup_printf("%s\t%s\t%f",line,Geom[i].NDihedral,getV(Geom[i].Dihedral));
1833 prop = prop_atom_get(Geom[i].Symb);
1834 gabedit_text_insert (GABEDIT_TEXT(text), NULL,NULL, &prop.color,line,-1);
1835 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n",-1);
1836 }
1837 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of Z-Matrix\n",-1);
1838 }
1839 /************************************************************************************************************/
putMoleculeCoordBasisInTextEditor()1840 static void putMoleculeCoordBasisInTextEditor()
1841 {
1842 gchar buffer[BSIZE];
1843 MolcasAtom* atomList = NULL;
1844 gint i;
1845 gint k;
1846
1847 if(molcasMolecule.numberOfAtoms<1) return;
1848
1849 atomList = molcasMolecule.listOfAtoms;
1850 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Coord\n",-1);
1851 sprintf(buffer,"%d\n",molcasMolecule.numberOfAtoms);
1852 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
1853 sprintf(buffer,"Coordinates in Angstrom units\n");
1854 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
1855 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
1856 {
1857 for(k=0; k<molcasMolecule.numberOfAtoms; k++)
1858 {
1859 if(atomList[k].type == i)
1860 {
1861 sprintf(buffer,"%s %f %f %f\n",molcasMolecule.symbol[i],
1862 atomList[k].position[0], atomList[k].position[1], atomList[k].position[2]);
1863 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1864 }
1865 }
1866 }
1867 /* gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of coordinates\n",-1);*/
1868 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Basis=",-1);
1869 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
1870 {
1871 sprintf(buffer,"%s, ",molcasMolecule.basis[i]);
1872 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1873 }
1874 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n", -1);
1875 }
1876 /************************************************************************************************************/
putMoleculeGeneratorInTextEditor()1877 static void putMoleculeGeneratorInTextEditor()
1878 {
1879 gchar buffer[BSIZE];
1880 MolcasAtom* atomList = NULL;
1881 gint i;
1882 gint k;
1883
1884 if(molcasMolecule.numberOfAtoms<1) return;
1885
1886 atomList = molcasMolecule.listOfAtoms;
1887 for (i=0;i<molcasMolecule.numberOfDifferentKindsOfAtoms;i++)
1888 {
1889 gint n = 1;
1890 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Basis set\n",-1);
1891 sprintf(buffer,"%s\n",molcasMolecule.basis[i]);
1892 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1893 for(k=0; k<molcasMolecule.numberOfAtoms; k++)
1894 {
1895 if(atomList[k].type == i)
1896 {
1897
1898 sprintf(buffer,"%s%d %f %f %f /Angstrom\n",molcasMolecule.symbol[i], n,
1899 atomList[k].position[0], atomList[k].position[1], atomList[k].position[2]);
1900
1901 /*
1902 sprintf(buffer,"%s %f %f %f /Angstrom\n",molcasMolecule.symbol[i],
1903 atomList[k].position[0], atomList[k].position[1], atomList[k].position[2]);
1904 */
1905 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
1906 n++;
1907 }
1908 }
1909 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "End of basis\n",-1);
1910 }
1911 }
1912 /************************************************************************************************************/
putMoleculeInTextEditor()1913 void putMoleculeInTextEditor()
1914 {
1915 if(groupSymmetry==1) putMoleculeGeneratorInTextEditor();
1916 else
1917 {
1918 if(MethodeGeom==GEOM_IS_XYZ) putMoleculeCoordBasisInTextEditor();
1919 else putMoleculeZMatBasisInTextEditor();
1920 }
1921
1922 }
1923 /************************************************************************************************************/
putBeginGateWayInTextEditor()1924 static void putBeginGateWayInTextEditor()
1925 {
1926 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.program, &molcasColorBack.program, " &GATEWAY\n",-1);
1927 }
1928 /************************************************************************************************************/
putTitleGateWayInTextEditor()1929 static void putTitleGateWayInTextEditor()
1930 {
1931 gchar buffer[BSIZE];
1932
1933 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.subProgram, NULL, "Title=",-1);
1934
1935 sprintf(buffer,"GateWay data By Gabedit\n");
1936 gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
1937
1938 }
1939 /************************************************************************************************************/
putEndGateWayInTextEditor()1940 static void putEndGateWayInTextEditor()
1941 {
1942 gabedit_text_insert (GABEDIT_TEXT(text), NULL, &molcasColorFore.program, &molcasColorBack.program, "End of input\n\n",-1);
1943 }
1944 /************************************************************************************************************/
putGateWayInfoInTextEditor()1945 void putGateWayInfoInTextEditor()
1946 {
1947 putBeginGateWayInTextEditor();
1948 putSolvationSewardInTextEditor();
1949 putMoleculeInTextEditor();
1950 putTitleGateWayInTextEditor();
1951 if(MethodeGeom==GEOM_IS_XYZ || groupSymmetry==1) putSymmetryInTextEditor();
1952 putEndGateWayInTextEditor();
1953 }
1954 /************************************************************************************************************/
1955