Logo Search packages:      
Sourcecode: gabedit version File versions  Download package

PCGamessMolecule.c

/* PCGamessMolecule.c */
/**********************************************************************************************************
Copyright (c) 2002-2007 Abdul-Rahman Allouche. All rights reserved

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all copies or substantial portions
  of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
************************************************************************************************************/

#include <stdlib.h>
#include <ctype.h>
#include <math.h>

#include "../../Config.h"
#include "../Common/Global.h"
#include "../PCGamess/PCGamessTypes.h"
#include "../PCGamess/PCGamessGlobal.h"
#include "../PCGamess/PCGamessControl.h"
#include "../Geometry/GeomGlobal.h"
#include "../Geometry/GeomConversion.h"
#include "../Geometry/GeomXYZ.h"
#include "../Geometry/Fragments.h"
#include "../Geometry/DrawGeom.h"
#include "../Utils/Utils.h"
#include "../Utils/UtilsInterface.h"
#include "../Utils/Constantes.h"
#include "../Utils/GabeditTextEdit.h"
#include "../Geometry/InterfaceGeom.h"
#include "../Common/Windows.h"
#include "../Utils/Constantes.h"
#include "../Utils/AtomsProp.h"
#include "../Symmetry/MoleculeSymmetry.h"
#include "../Symmetry/MoleculeSymmetryInterface.h"

/************************************************************************************************************/
typedef enum
{
      GABEDIT = 0, FIXED
}TypeOfSymmetryButton;


static gboolean symReduction = TRUE;
static GtkWidget* labelSymmetry = NULL;
static GtkWidget *buttonTolerance = NULL;
static GtkWidget *buttonSymWithCalc = NULL;
/************************************************************************************************************/
static gint totalCharge = 0;
static gint spinMultiplicity=1;
/************************************************************************************************************/
gint getPCGamessMultiplicity()
{
      return spinMultiplicity;
}
/************************************************************************************************************/
void initPCGamessMoleculeButtons()
{
      labelSymmetry = NULL;
      buttonTolerance = NULL;
      buttonSymWithCalc = NULL;
}
/************************************************************************************************************/
void initPCGamessMolecule()
{
      pcgamessMolecule.listOfAtoms = NULL;  
      pcgamessMolecule.totalNumberOfElectrons = 0;
      pcgamessMolecule.numberOfValenceElectrons = 0;
      pcgamessMolecule.numberOfAtoms = 0;
      pcgamessMolecule.groupSymmetry = NULL;
}
/************************************************************************************************************/
void freePCGamessMolecule()
{
      static gboolean first = TRUE;

      if(first)
      {
            initPCGamessMolecule();
            first = FALSE;
            return;
      }

      if(pcgamessMolecule.listOfAtoms) g_free(pcgamessMolecule.listOfAtoms);
      if(pcgamessMolecule.groupSymmetry) g_free(pcgamessMolecule.groupSymmetry);
      initPCGamessMolecule();
}
/************************************************************************************************************/
static gint setPCGamessMoleculeFromSXYZ(gint nAtoms, gchar** symbols, gdouble* X, gdouble* Y, gdouble* Z)
{
      gint n;
      PCGamessAtom* atomList = NULL;

      pcgamessMolecule.listOfAtoms = NULL;  
      pcgamessMolecule.numberOfAtoms = 0;
      if(nAtoms<1) return 1;

      pcgamessMolecule.listOfAtoms = (PCGamessAtom*)g_malloc(sizeof(PCGamessAtom)*(nAtoms));
      if(pcgamessMolecule.listOfAtoms==NULL) return -1;

      pcgamessMolecule.numberOfAtoms = nAtoms;

      atomList = pcgamessMolecule.listOfAtoms;
      for(n=0; n<pcgamessMolecule.numberOfAtoms; n++)
      {
            atomList->position[0]  = X[n];
            atomList->position[1]  = Y[n];
            atomList->position[2]  = Z[n];
            atomList->symbol  = g_strdup(symbols[n]);
            atomList++;
      }

      return 0;
}
/************************************************************************************************************/
static void setXYZFromGeomXYZ(gint i, gdouble* x, gdouble* y, gdouble *z)
{
      if(!test(GeomXYZ[i].X))
            *x = get_value_variableXYZ(GeomXYZ[i].X);
      else
            *x = atof(GeomXYZ[i].X);
      if(!test(GeomXYZ[i].Y))
            *y = get_value_variableXYZ(GeomXYZ[i].Y);
      else
            *y = atof(GeomXYZ[i].Y);
      if(!test(GeomXYZ[i].Z))
            *z = get_value_variableXYZ(GeomXYZ[i].Z);
      else
            *z = atof(GeomXYZ[i].Z);

         if(Units==0)
         {
              *x *= BOHR_TO_ANG;
              *y *= BOHR_TO_ANG;
              *z *= BOHR_TO_ANG;
         }
}
/************************************************************************************************************/
static void setPCGamessFormatGroup(gchar* pointGroupSymbol, gchar* pcgamessName)
{
      if(!pointGroupSymbol) return;
      if(strlen(pointGroupSymbol)<2 || strcmp(pointGroupSymbol,"C1")==0)
      {
            sprintf(pcgamessName,"%s",pointGroupSymbol);
            return;
      }
      if(strcmp(pointGroupSymbol,"Cinfv")==0)
      {
            sprintf(pcgamessName,"Cnv  4");
            return;
      }
      if(strcmp(pointGroupSymbol,"Dinfh")==0)
      {
            sprintf(pcgamessName,"Dnh  4");
            return;
      }
      if(isdigit(pointGroupSymbol[1]))
      {
            gchar a[3];
            sprintf(a,"%c",pointGroupSymbol[1]);
            gint n=atoi(a);
            if(pointGroupSymbol[0] !='S')
            {
                  if(strlen(pointGroupSymbol)>2)
                  sprintf(pcgamessName,"%cn%c %d",pointGroupSymbol[0],pointGroupSymbol[2],n);
                  else
                  sprintf(pcgamessName,"%cn %d",pointGroupSymbol[0],n);
            }
            else sprintf(pcgamessName,"%c2n %d",pointGroupSymbol[0],n/2);
            return;
      }
      sprintf(pcgamessName,"%s",pointGroupSymbol);
      return;
}
/************************************************************************************************************/
static gchar* computeGroupSymmetry()
{
      gint i;
      gchar** symbols = NULL;
      gdouble* X = NULL;
      gdouble* Y = NULL;
      gdouble* Z = NULL;
      gint numberOfAtoms = pcgamessMolecule.numberOfAtoms;
      gchar pointGroupSymbol[BSIZE];
      gchar message[BSIZE];
      gint maximalOrder = 8;
      gdouble principalAxisTolerance = getTolerancePrincipalAxis();
      gdouble positionTolerance = getTolerancePosition();

      if(numberOfAtoms<1) return NULL;


      symbols = (gchar**)g_malloc(sizeof(gchar*)*(numberOfAtoms));
      if(symbols == NULL) return NULL;

      X = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(X == NULL) return NULL;
      Y = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Y == NULL) return NULL;
      Z = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Z == NULL) return NULL;

      for(i=0; i<numberOfAtoms; i++)
      {
            symbols[i] = g_strdup(pcgamessMolecule.listOfAtoms[i].symbol);
            X[i] = pcgamessMolecule.listOfAtoms[i].position[0];
            Y[i] = pcgamessMolecule.listOfAtoms[i].position[1];
            Z[i] = pcgamessMolecule.listOfAtoms[i].position[2];
      }
      sprintf(pointGroupSymbol,"NO");
      computeSymmetry(principalAxisTolerance, FALSE, pointGroupSymbol,maximalOrder, TRUE, &numberOfAtoms,symbols, X, Y, Z, &positionTolerance, message);


      for (i=0;i<(gint)numberOfAtoms;i++) g_free( symbols[i]);
      g_free( symbols);
      g_free(X);
      g_free(Y);
      g_free(Z);
      return g_strdup(pointGroupSymbol);
}
/************************************************************************************************************/
static gboolean setPCGamessMoleculeFromGeomXYZ()
{
      gint i;
      gchar** symbols = NULL;
      gdouble* X = NULL;
      gdouble* Y = NULL;
      gdouble* Z = NULL;
      gint numberOfAtoms = NcentersXYZ;

      if(numberOfAtoms<1) return FALSE;

      symbols = (gchar**)g_malloc(sizeof(gchar*)*(numberOfAtoms));

      if(symbols == NULL) return FALSE;

      X = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(X == NULL) return FALSE;
      Y = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Y == NULL) return FALSE;
      Z = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Z == NULL) return FALSE;

      pcgamessMolecule.totalNumberOfElectrons = 0;
      for(i=0; i<numberOfAtoms; i++)
      {
            SAtomsProp prop = prop_atom_get(GeomXYZ[i].Symb);

            symbols[i] = g_strdup(GeomXYZ[i].Symb);
            setXYZFromGeomXYZ(i, &X[i] , &Y[i] , &Z[i]);
            pcgamessMolecule.totalNumberOfElectrons += prop.atomicNumber;
      }
      pcgamessMolecule.numberOfValenceElectrons = pcgamessMolecule.totalNumberOfElectrons;
      setPCGamessMoleculeFromSXYZ(numberOfAtoms, symbols, X, Y, Z);
      pcgamessMolecule.groupSymmetry = computeGroupSymmetry();

      for (i=0;i<(gint)NcentersXYZ;i++) g_free( symbols[i]);
      g_free( symbols);
      g_free(X);
      g_free(Y);
      g_free(Z);
      return TRUE;
}
/************************************************************************************************************/
static gboolean setPCGamessMoleculeFromGeomZMatrix()
{
      iprogram=PROG_IS_PCGAMESS;
      if(!zmat_to_xyz()) return FALSE;
      delete_dummy_atoms();
      /* conversion_zmat_to_xyz();*/
      return setPCGamessMoleculeFromGeomXYZ();
}
/************************************************************************************************************/
gboolean setPCGamessMolecule()
{
      freePCGamessMolecule();
      if(MethodeGeom==GEOM_IS_XYZ && setPCGamessMoleculeFromGeomXYZ()) return TRUE;
      if(setPCGamessMoleculeFromGeomZMatrix()) return TRUE;
      return FALSE;
}
/************************************************************************************************************/
void setPCGamessGeometryFromInputFile(gchar* fileName)
{
      read_XYZ_from_gamess_input_file(fileName);
      setPCGamessMolecule();
}
/*************************************************************************************************************/
static gdouble getMinDistance()
{
      gdouble d=0;
      gint i;
      gint k;
      PCGamessAtom* atomList = pcgamessMolecule.listOfAtoms;
      for(i=0; i<pcgamessMolecule.numberOfAtoms-1; i++)
      {
            gdouble dd = 0;
            for(k=0;k<3;k++) 
            {
                  gdouble xx = atomList->position[k]-atomList->position[k+1];
                  dd += xx*xx;
            }
            if(i==0) d = dd;
            else if(d>dd) d= dd;
            atomList++;
      }
      d = sqrt(d);

      return d;
}
/*************************************************************************************************************/
static void setFirstAtomToXAxis(gint numberOfAtoms, gdouble* X, gdouble* Y, gdouble*Z)
{
      gdouble d;
      gdouble s;
      gdouble c;
      gint i;
      gdouble positionTolerance = getTolerancePosition();

      if(numberOfAtoms<1) return;
      d = X[0]*X[0]+Y[0]*Y[0];
      if(d<1e-10) return;
      d = sqrt(d);
      if(positionTolerance<0) positionTolerance= getMinDistance()/50;

      /* perform rotation */
      s = -Y[0]/d;
      c = +X[0]/d;

      for (i=0;i<numberOfAtoms;i++)
       {
             gdouble x = X[i];
             gdouble y = Y[i];
            X[i] = c*x - s*y;
            Y[i] = s*x + c*y;
            /* if(fabs(X[i])<positionTolerance) X[i]=0.0;*/
            if(fabs(Y[i])<positionTolerance) Y[i]=0.0;
       }
      /* printf("tolerance position = %f\n",positionTolerance);*/

}
/*************************************************************************************************************/
static gint getRealNumberXYZVariables()
{
      gint k=0;
      gint i;
        for(i=0;i<NcentersXYZ;i++)
      {
            if(test(GeomXYZ[i].X))k++;
            if(test(GeomXYZ[i].Y))k++;
            if(test(GeomXYZ[i].Z))k++;
      }
      return k;
}
/*************************************************************************************************************/
static void putPCGamessMoleculeXYZFixedInTextEditor()
{
        gchar buffer[BSIZE];
      gint i,k,l;
      gint nvar = 0;
      gint nrvar = 0;
      if(MethodeGeom!=GEOM_IS_XYZ)return;
        if(NcentersXYZ<2)return;
      nrvar = getRealNumberXYZVariables();
      nvar = 3*NcentersXYZ;
      if(nrvar==nvar) return;
      if(nrvar==0) return;

        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$STATPT\n",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "   IFREEZ(1)=",-1);

      k = 0;
      l = 0;
        for(i=0;i<NcentersXYZ;i++)
      {
            k++;
            if(test(GeomXYZ[i].X))
            {
                  l++;
                  sprintf(buffer,"%d, ",k);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if(l%10==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
            k++;
            if(test(GeomXYZ[i].Y))
            {
                  l++;
                  sprintf(buffer,"%d, ",k);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if(l%10==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
            k++;
            if(test(GeomXYZ[i].Z))
            {
                  l++;
                  sprintf(buffer,"%d, ",k);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if(l%10==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
      }
      gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
}
/*************************************************************************************************************/
static gint getRealNumberZmatVariables()
{
      gint k=0;
      gint i;
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_0 && test(Geom[i].R)) k++;
            if(Geom[i].Nentry>NUMBER_ENTRY_R && test(Geom[i].Angle)) k++;
            if(Geom[i].Nentry>NUMBER_ENTRY_ANGLE && test(Geom[i].Dihedral)) k++;
      }
      return k;
}
/*************************************************************************************************************/
static void putPCGamessMoleculeZMatInTextEditor()
{
        gchar buffer[BSIZE];
      gint i,k,l;
      gint nzvar = 0;
      gint nrzvar = 0;
      if(MethodeGeom==GEOM_IS_XYZ)return;
        if(NcentersZmat<2)return;
       if(NcentersZmat==2) nzvar = 3*NcentersZmat-5;
       else nzvar = 3*NcentersZmat-6;
      nrzvar = getRealNumberZmatVariables(); 

        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$CONTRL",-1);
      sprintf(buffer," COORD=ZMT NZVAR=%d ",nzvar);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);

        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$ZMT\n",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "   IZMAT(1)=\n   ",-1);
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_0)
            {
                  sprintf(buffer,"1,%d,%s, ",i+1,Geom[i].NR);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if((i+1)%3==0)
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
      }
      if(NcentersZmat%3!=0)
            gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_R)
            {
                  sprintf(buffer,"2,%d,%s,%s, ",i+1,Geom[i].NR,Geom[i].NAngle);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if((i+1)%3==0)
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
      }
      if(NcentersZmat%3!=0)
            gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_ANGLE)
            {
                  sprintf(buffer,"3,%d,%s,%s,%s, ",i+1,Geom[i].NR,Geom[i].NAngle,Geom[i].NDihedral);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                  if((i+1)%3==0)
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
            }
      }
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
      if(nrzvar==nzvar) return;
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$STATPT\n",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "   IFREEZ(1)=",-1);

      k = 0;
      l = 0;
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_0)
            {
                  k++;
                  if(test(Geom[i].R))
                  {
                        l++;
                        sprintf(buffer,"%d, ",k);
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                        if(l%5==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
                  }
            }
      }
       if(l!=0 && l%5!=0) gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n    ", -1);
       l = 0;
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_R)
            {
                  k++;
                  if(test(Geom[i].Angle))
                  {
                        l++;
                        sprintf(buffer,"%d, ",k);
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                        if(l%5==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
                  }
            }
      }
       if(l!=0 && l%5!=0) gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
       l = 0;
        for(i=0;i<NcentersZmat;i++)
      {
            if(Geom[i].Nentry>NUMBER_ENTRY_ANGLE)
            {
                  k++;
                  if(test(Geom[i].Dihedral))
                  {
                        l++;
                        sprintf(buffer,"%d, ",k);
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
                        if(l%5==0)
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n   ", -1);
                  }
            }
      }
       gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, "\n ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
}
/*************************************************************************************************************/
static void putPCGamessMoleculeInTextEditor()
{
        gchar buffer[BSIZE];
        gchar g[BSIZE];
      gint i;
      gchar** symbols = NULL;
      gdouble* X = NULL;
      gdouble* Y = NULL;
      gdouble* Z = NULL;
      gint numberOfAtoms = pcgamessMolecule.numberOfAtoms;
      gchar pointGroupSymbol[BSIZE];
      gchar message[BSIZE];
      gint maximalOrder = 8;
      gdouble principalAxisTolerance = getTolerancePrincipalAxis();
      gdouble positionTolerance = getTolerancePosition();
      gint nrvar = 0;

      if(pcgamessMolecule.numberOfAtoms<1) return;
      nrvar = getRealNumberXYZVariables();

      symbols = (gchar**)g_malloc(sizeof(gchar*)*(numberOfAtoms));
      if(symbols == NULL) return;

      X = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(X == NULL) return;
      Y = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Y == NULL) return;
      Z = (gdouble*)g_malloc(sizeof(gdouble)*(numberOfAtoms));
      if(Z == NULL) return;
      for(i=0; i<numberOfAtoms; i++)
      {
            symbols[i] = g_strdup(pcgamessMolecule.listOfAtoms[i].symbol);
            X[i] = pcgamessMolecule.listOfAtoms[i].position[0];
            Y[i] = pcgamessMolecule.listOfAtoms[i].position[1];
            Z[i] = pcgamessMolecule.listOfAtoms[i].position[2];
      }

      if(MethodeGeom==GEOM_IS_XYZ && (nrvar== 3*NcentersXYZ || nrvar==0))
      {
            sprintf(pointGroupSymbol,pcgamessMolecule.groupSymmetry);
            computeSymmetry(principalAxisTolerance, FALSE, pointGroupSymbol,maximalOrder, TRUE, &numberOfAtoms,symbols, X, Y, Z, &positionTolerance, message);
            if(strlen(pointGroupSymbol)>1 && strcmp(pointGroupSymbol,"C1")!=0 && isdigit(pointGroupSymbol[1]))
                  setFirstAtomToXAxis(numberOfAtoms, X, Y, Z);
            setPCGamessFormatGroup(pcgamessMolecule.groupSymmetry,g);
      }
      else
      {
            sprintf(g,"C1");
      }

      if(strcmp(g,"C1")==0 || MethodeGeom!=GEOM_IS_XYZ) sprintf(buffer,"%s\n","C1");
      else sprintf(buffer,"%s\n\n",g);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
      if(MethodeGeom==GEOM_IS_XYZ)
                  for (i=0;i<numberOfAtoms;i++)
            {
                  SAtomsProp prop = prop_atom_get(symbols[i]);

                  sprintf(buffer,"%s  %f %f %f %f\n",symbols[i], (gfloat)prop.atomicNumber, X[i], Y[i], Z[i]);
                  gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer, -1);
            }
      else
      {
            for(i=0;i<NcentersZmat;i++)
            {
                  SAtomsProp prop = prop_atom_get(symbols[i]);
                  if(Geom[i].Nentry>NUMBER_ENTRY_ANGLE)
                  {
                        sprintf(buffer,"%s  %s %s %s %s %s %s\n",
                                    Geom[i].Symb,
                                    Geom[i].NR,Geom[i].R,
                                    Geom[i].NAngle,Geom[i].Angle,
                                    Geom[i].NDihedral,Geom[i].Dihedral);
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, &prop.color, buffer, -1);
                  }
                  else
                  if(Geom[i].Nentry>NUMBER_ENTRY_R)
                  {
                        sprintf(buffer,"%s  %s %s %s %s\n",
                                    Geom[i].Symb,
                                    Geom[i].NR,Geom[i].R,
                                    Geom[i].NAngle,Geom[i].Angle
                                    );
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, &prop.color, buffer, -1);
                  }
                  else
                  if(Geom[i].Nentry>NUMBER_ENTRY_0)
                  {
                        sprintf(buffer,"%s  %s %s\n",
                                    Geom[i].Symb,
                                    Geom[i].NR,Geom[i].R
                                    );
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, &prop.color, buffer, -1);
                  }
                  else
                  {
                        sprintf(buffer,"%s \n",
                                    Geom[i].Symb
                                    );
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, &prop.color, buffer, -1);
                  }
            }
            if(NVariables>0 && getRealNumberZmatVariables()>0)
            for(i=0;i<NVariables;i++)
            {
                  if(Variables[i].Used)
                  {
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL,"\n",-1);
                        break;
                  }
            }
            for(i=0;i<NVariables;i++)
            {
                  if(Variables[i].Used)
                  {
                        sprintf(buffer,"%s=%s\n",Variables[i].Name,Variables[i].Value);
                        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL,buffer,-1);
                  }
            }
      }
      for (i=0;i<(gint)numberOfAtoms;i++) g_free( symbols[i]);
      g_free( symbols);
      g_free(X);
      g_free(Y);
      g_free(Z);

}
/************************************************************************************************************/
static void putNoSymmetryWithCalcul()
{
      if(!GTK_TOGGLE_BUTTON (buttonSymWithCalc)->active ) return;
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$CONTRL",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " NOSYM=1 ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
}
/************************************************************************************************************/
static void putBeginGeometryInTextEditor()
{
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$DATA\n",-1);
}
/************************************************************************************************************/
static void putTitleGeometryInTextEditor()
{
        gchar buffer[BSIZE];

      sprintf(buffer,"Molecule specification\n");
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
}
/************************************************************************************************************/
static void putEndGeometryInTextEditor()
{
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL,  &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
}
/************************************************************************************************************/
void putPCGamessGeometryInfoInTextEditor()
{
      putNoSymmetryWithCalcul();
      if(MethodeGeom!=GEOM_IS_XYZ) putPCGamessMoleculeZMatInTextEditor();
      else putPCGamessMoleculeXYZFixedInTextEditor();

      putBeginGeometryInTextEditor();
      putTitleGeometryInTextEditor();

      putPCGamessMoleculeInTextEditor();
      putEndGeometryInTextEditor();
}
/**************************************************************************************************************************************/
static void activateRadioButton(GtkWidget *button, gpointer data)
{
      gint* type = NULL;
      GtkWidget* label = NULL;
      GtkWidget* comboSymmetry = NULL;
      gchar buffer[BSIZE];
       
      if(!GTK_IS_WIDGET(button)) return;

      type  = g_object_get_data(G_OBJECT (button), "Type");
      label = g_object_get_data(G_OBJECT (button), "Label");
      comboSymmetry = g_object_get_data(G_OBJECT (button), "ComboSymmetry");
      if(type)
      {
            setPCGamessMolecule();

            if( GTK_TOGGLE_BUTTON (button)->active && *type == FIXED)
            {
                  if(pcgamessMolecule.groupSymmetry) g_free(pcgamessMolecule.groupSymmetry);
                  pcgamessMolecule.groupSymmetry = g_strdup("C1");
                  symReduction = FALSE;
                  if(GTK_IS_WIDGET(comboSymmetry))
                        gtk_widget_set_sensitive(comboSymmetry, TRUE);
            }
            if(GTK_TOGGLE_BUTTON (button)->active &&  *type == GABEDIT)
            {
                  /* groupSymmetry define in setPCGamessMolecule */
                  symReduction = TRUE;
                  if(GTK_IS_WIDGET(comboSymmetry))
                        gtk_widget_set_sensitive(comboSymmetry, FALSE);
            }

            if(label) gtk_label_set_text(GTK_LABEL(label)," ");
            if(GTK_IS_WIDGET(buttonTolerance) && symReduction ) gtk_widget_set_sensitive(buttonTolerance, TRUE);
            if(GTK_IS_WIDGET(buttonTolerance) && !symReduction ) gtk_widget_set_sensitive(buttonTolerance, FALSE);

            if(GTK_TOGGLE_BUTTON (button)->active && label && symReduction)
            {
                  sprintf(buffer,"%s group",pcgamessMolecule.groupSymmetry);
                  gtk_label_set_text(GTK_LABEL(label),buffer);
            }
      }
}
/************************************************************************************************************/
static GtkWidget* addRadioButtonToATable(GtkWidget* table, GtkWidget* friendButton, gchar* label, gint i, gint j, gint k)
{
      GtkWidget *newButton;

      if(friendButton)
            newButton = gtk_radio_button_new_with_label( gtk_radio_button_get_group (GTK_RADIO_BUTTON (friendButton)), label);
      else
            newButton = gtk_radio_button_new_with_label( NULL, label);

      gtk_table_attach(GTK_TABLE(table),newButton,j,j+k,i,i+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
                  2,2);

      g_object_set_data(G_OBJECT (newButton), "Label",NULL);
      g_object_set_data(G_OBJECT (newButton), "Type",NULL);
      return newButton;
}
/**************************************************************************************************************************************/
static void resetTolerance(GtkWidget *win)
{
      gchar buffer[BSIZE];

      setPCGamessMolecule();
      if(labelSymmetry)
      {
            sprintf(buffer,"%s group",pcgamessMolecule.groupSymmetry);
            gtk_label_set_text(GTK_LABEL(labelSymmetry),buffer);
      }
}
/**************************************************************************************************************************************/
static void activateToleranceButton(GtkWidget *button, gpointer data)
{
      if(!GTK_IS_WIDGET(button)) return;
      createToleranceWindow(pcgamessWin, resetTolerance);
}
/********************************************************************************/
static void setComboSymmetry(GtkWidget *comboSymmetry)
{
      GList *glist = NULL;

      glist = g_list_append(glist,"C1");
      glist = g_list_append(glist,"Cs");
      glist = g_list_append(glist,"Ci");

      glist = g_list_append(glist,"C2");
      glist = g_list_append(glist,"C3");
      glist = g_list_append(glist,"C4");
      glist = g_list_append(glist,"C5");
      glist = g_list_append(glist,"C6");
      glist = g_list_append(glist,"C7");
      glist = g_list_append(glist,"C8");

      glist = g_list_append(glist,"C2v");
      glist = g_list_append(glist,"C3v");
      glist = g_list_append(glist,"C4v");
      glist = g_list_append(glist,"C5v");
      glist = g_list_append(glist,"C6v");
      glist = g_list_append(glist,"C7v");
      glist = g_list_append(glist,"C8v");

      glist = g_list_append(glist,"C2h");
      glist = g_list_append(glist,"C3h");
      glist = g_list_append(glist,"C4h");
      glist = g_list_append(glist,"C5h");
      glist = g_list_append(glist,"C6h");
      glist = g_list_append(glist,"C7h");
      glist = g_list_append(glist,"C8h");

      glist = g_list_append(glist,"D2");
      glist = g_list_append(glist,"D3");
      glist = g_list_append(glist,"D4");
      glist = g_list_append(glist,"D5");
      glist = g_list_append(glist,"D6");
      glist = g_list_append(glist,"D7");
      glist = g_list_append(glist,"D8");

      glist = g_list_append(glist,"D2h");
      glist = g_list_append(glist,"D3h");
      glist = g_list_append(glist,"D4h");
      glist = g_list_append(glist,"D5h");
      glist = g_list_append(glist,"D6h");
      glist = g_list_append(glist,"D7h");
      glist = g_list_append(glist,"D8h");

      glist = g_list_append(glist,"D2d");
      glist = g_list_append(glist,"D3d");
      glist = g_list_append(glist,"D4d");
      glist = g_list_append(glist,"D5d");
      glist = g_list_append(glist,"D6d");
      glist = g_list_append(glist,"D7d");
      glist = g_list_append(glist,"D8d");

      glist = g_list_append(glist,"S2");
      glist = g_list_append(glist,"S4");
      glist = g_list_append(glist,"S6");
      glist = g_list_append(glist,"S8");
      glist = g_list_append(glist,"S10");
      glist = g_list_append(glist,"S12");
      glist = g_list_append(glist,"S14");
      glist = g_list_append(glist,"S16");

      glist = g_list_append(glist,"T");
      glist = g_list_append(glist,"Td");
      glist = g_list_append(glist,"Th");
      glist = g_list_append(glist,"O");
      glist = g_list_append(glist,"Oh");

      gtk_combo_box_entry_set_popdown_strings( comboSymmetry, glist) ;

      g_list_free(glist);
}
/**********************************************************************/
static void changedEntrySymmetry(GtkWidget *entry, gpointer data)
{
      G_CONST_RETURN gchar* entryText = NULL;
       
      if(!GTK_IS_WIDGET(entry)) return;

      entryText = gtk_entry_get_text(GTK_ENTRY(entry));
      if(strlen(entryText)<1)return;
      if(pcgamessMolecule.groupSymmetry) g_free(pcgamessMolecule.groupSymmetry);
      pcgamessMolecule.groupSymmetry = g_strdup(entryText);

      if(strstr(entryText,"C1")) symReduction = FALSE;
      else symReduction = FALSE;
}
/************************************************************************************************************/
void createPCGamessSymmetryFrame(GtkWidget *win, GtkWidget *box)
{
      GtkWidget* button;
      GtkWidget* buttonGabedit;
      GtkWidget* frame;
      GtkWidget* vboxFrame;
      GtkWidget* sep;
      GtkWidget* comboSymmetry = NULL;
      GtkWidget* entrySymmetry = NULL;
      GtkWidget* label = gtk_label_new(" ");
      GtkWidget *table = gtk_table_new(4,3,FALSE);
      static TypeOfSymmetryButton typeOfSymmetry[] = { GABEDIT, FIXED};
      gchar* list[] = {"C1"};

      frame = gtk_frame_new ("Symmetry");
      gtk_widget_show (frame);
      gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
      gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);

      vboxFrame = gtk_vbox_new (FALSE, 3);
      gtk_widget_show (vboxFrame);
      gtk_container_add (GTK_CONTAINER (frame), vboxFrame);

      gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);

      comboSymmetry = create_combo_box_entry(list, 1, TRUE, -1, -1);
      entrySymmetry = GTK_BIN(comboSymmetry)->child;
      gtk_widget_set_sensitive(entrySymmetry, FALSE);


      if(pcgamessMolecule.groupSymmetry) g_free(pcgamessMolecule.groupSymmetry);
      pcgamessMolecule.groupSymmetry = g_strdup("C1");

      button = addRadioButtonToATable(table, NULL, "Detected by Gabedit", 0, 0, 1);
      g_object_set_data(G_OBJECT (button), "Label",label);
      g_object_set_data(G_OBJECT (button), "Type",&typeOfSymmetry[GABEDIT]);
      g_object_set_data(G_OBJECT (button), "ComboSymmetry",comboSymmetry);
      g_signal_connect(G_OBJECT(button),"clicked", GTK_SIGNAL_FUNC(activateRadioButton),NULL);
      add_widget_table(table, label, 0, 1);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
      buttonGabedit=button;

      buttonTolerance = create_button(win,"Tolerance");
      add_widget_table(table, buttonTolerance, 0, 2);
      g_signal_connect(G_OBJECT(buttonTolerance),"clicked", GTK_SIGNAL_FUNC(activateToleranceButton),NULL);

      labelSymmetry = label;
      gtk_widget_set_sensitive(buttonTolerance, FALSE);

      button = addRadioButtonToATable(table, button, "Fixed Symmetry", 1, 0,1);
      g_signal_connect(G_OBJECT(entrySymmetry),"changed", GTK_SIGNAL_FUNC(changedEntrySymmetry),NULL);
      setComboSymmetry(comboSymmetry);
      gtk_table_attach(GTK_TABLE(table),comboSymmetry,1,1+2,1,1+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
                  2,2);
      g_object_set_data(G_OBJECT (button), "Label",label);
      g_object_set_data(G_OBJECT (button), "Type",&typeOfSymmetry[FIXED]);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
      g_object_set_data(G_OBJECT (button), "ComboSymmetry",comboSymmetry);
      g_signal_connect(G_OBJECT(button),"clicked", GTK_SIGNAL_FUNC(activateRadioButton),NULL);
      gtk_widget_set_sensitive(comboSymmetry, FALSE);

      sep = gtk_hseparator_new ();;
      gtk_table_attach(GTK_TABLE(table),sep,0,0+3,2,2+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
                  2,2);

      buttonSymWithCalc = gtk_check_button_new_with_label ("Symmetry not used during calculation");
      gtk_table_attach(GTK_TABLE(table),buttonSymWithCalc,0,0+3,3,3+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
                  2,2);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonGabedit), FALSE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonGabedit), TRUE);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
}
/************************************************************************************************************/
static void setComboSpinMultiplicity(GtkWidget *comboSpinMultiplicity)
{
      GList *glist = NULL;
      gint i;
      gint nlist = 0;
      gchar** list = NULL;
      gint k;
      gint kinc;
      gint ne = pcgamessMolecule.numberOfValenceElectrons - totalCharge;

      if(ne%2==0) nlist = ne/2+1;
      else nlist = (ne+1)/2;

      if(nlist<1) return;
      list = g_malloc(nlist*sizeof(gchar*));
      if(!list) return;
      for(i=0;i<nlist;i++)
            list[i] = g_malloc(10*sizeof(gchar));


      if(GTK_IS_WIDGET(comboSpinMultiplicity)) gtk_widget_set_sensitive(comboSpinMultiplicity, TRUE);
      if(ne%2==0) k = 1;
      else k = 2;

      kinc = 2;
      for(i=0;i<nlist;i++)
      {
            sprintf(list[i],"%d",k);
            k+=kinc;
      }

      for(i=0;i<nlist;i++) glist = g_list_append(glist,list[i]);

      gtk_combo_box_entry_set_popdown_strings( comboSpinMultiplicity, glist) ;
      g_list_free(glist);
      if(list)
      {
            for(i=0;i<nlist;i++) if(list[i]) g_free(list[i]);
            g_free(list);
      }
}
/********************************************************************************/
static void setComboCharge(GtkWidget *comboCharge)
{
      GList *glist = NULL;
      gint i;
      gint nlist;
      gchar** list = NULL;
      gint k;

      nlist = pcgamessMolecule.numberOfValenceElectrons*2-2+1;

      if(nlist<1) return;
      list = g_malloc(nlist*sizeof(gchar*));
      if(!list) return;
      for(i=0;i<nlist;i++)
            list[i] = g_malloc(10*sizeof(gchar));


      sprintf(list[0],"0");
      k = 1;
      for(i=1;i<nlist-1;i+=2)
      {
            sprintf(list[i],"+%d",k);
            sprintf(list[i+1],"%d",-k);
            k += 1;
      }

      for(i=0;i<nlist;i++) glist = g_list_append(glist,list[i]);

      gtk_combo_box_entry_set_popdown_strings( comboCharge, glist) ;
      g_list_free(glist);
      if(list)
      {
            for(i=0;i<nlist;i++) if(list[i]) g_free(list[i]);
            g_free(list);
      }
}
/**********************************************************************/
static void changedEntrySpinMultiplicity(GtkWidget *entry, gpointer data)
{
      G_CONST_RETURN gchar* entryText = NULL;
       
      if(!GTK_IS_WIDGET(entry)) return;

      entryText = gtk_entry_get_text(GTK_ENTRY(entry));
      if(strlen(entryText)<1)return;

      spinMultiplicity=atoi(entryText);
      if(spinMultiplicity==1)
      {
            /* OK RHF*/
            setPCGamessSCFMethod(TRUE);
      }
      else 
      {
            /* remove RHF from list*/
            setPCGamessSCFMethod(FALSE);
      }
      if(spinMultiplicity!=1 && spinMultiplicity!=3)
            setPCGamessTD(FALSE);
      else
            setPCGamessTD(TRUE);
}
/**********************************************************************/
static void changedEntryCharge(GtkWidget *entry, gpointer data)
{
      G_CONST_RETURN gchar* entryText = NULL;
      GtkWidget* comboSpinMultiplicity = NULL;
      GtkWidget* labelNumberOfElectrons = NULL;
       
      if(!GTK_IS_WIDGET(entry)) return;

      entryText = gtk_entry_get_text(GTK_ENTRY(entry));
      if(strlen(entryText)<1)return;

      totalCharge = atoi(entryText);

      comboSpinMultiplicity  = g_object_get_data(G_OBJECT (entry), "ComboSpinMultiplicity");
      if(GTK_IS_WIDGET(comboSpinMultiplicity)) setComboSpinMultiplicity(comboSpinMultiplicity);

      labelNumberOfElectrons = g_object_get_data(G_OBJECT (entry), "LabelNumberOfElectrons");

      if(GTK_IS_WIDGET(labelNumberOfElectrons))
      {
            gint ne = pcgamessMolecule.numberOfValenceElectrons - totalCharge;
            gchar buffer[BSIZE];
            sprintf(buffer, "Number of electrons = %d",ne);
            gtk_label_set_text(GTK_LABEL(labelNumberOfElectrons),buffer);
      }
}
/**********************************************************************/
static GtkWidget* addComboListToATable(GtkWidget* table,
            gchar** list, gint nlist, gint i, gint j, gint k)
{
      GtkWidget *entry = NULL;
      GtkWidget *combo = NULL;

      combo = create_combo_box_entry(list, nlist, TRUE, -1, -1);

      gtk_table_attach(GTK_TABLE(table),combo,j,j+k,i,i+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_SHRINK),
                  2,2);
      entry = GTK_BIN (combo)->child;
      g_object_set_data(G_OBJECT (entry), "Combo",combo);
      gtk_widget_set_size_request(GTK_WIDGET(entry),(gint)(ScreenHeight*0.2),-1);

      return entry;
}
/***********************************************************************************************/
static GtkWidget *addPCGamessChargeToTable(GtkWidget *table, gint i)
{
      GtkWidget* entryCharge = NULL;
      GtkWidget* comboCharge = NULL;
      gint nlistCharge = 1;
      gchar* listCharge[] = {"0"};

      add_label_table(table,"Charge",(gushort)i,0);
      add_label_table(table,":",(gushort)i,1);
      entryCharge = addComboListToATable(table, listCharge, nlistCharge, i, 2, 1);
      comboCharge  = g_object_get_data(G_OBJECT (entryCharge), "Combo");
      gtk_widget_set_sensitive(entryCharge, FALSE);

      return comboCharge;
}
/***********************************************************************************************/
static GtkWidget *addPCGamessSpinToTable(GtkWidget *table, gint i)
{
      GtkWidget* entrySpinMultiplicity = NULL;
      GtkWidget* comboSpinMultiplicity = NULL;
      gint nlistspinMultiplicity = 1;
      gchar* listspinMultiplicity[] = {"0"};

      add_label_table(table,"Spin multiplicity",(gushort)i,0);
      add_label_table(table,":",(gushort)i,1);
      entrySpinMultiplicity = addComboListToATable(table, listspinMultiplicity, nlistspinMultiplicity, i, 2, 1);
      comboSpinMultiplicity  = g_object_get_data(G_OBJECT (entrySpinMultiplicity), "Combo");
      gtk_widget_set_sensitive(entrySpinMultiplicity, FALSE);

      g_signal_connect(G_OBJECT(entrySpinMultiplicity),"changed", GTK_SIGNAL_FUNC(changedEntrySpinMultiplicity),NULL);
      return comboSpinMultiplicity;
}
/***********************************************************************************************/
static GtkWidget *addLabelNumberOfElectronsToTable(GtkWidget *table, gint i, GtkWidget *comboCharge)
{
      GtkWidget* labelNumberOfElectrons = NULL;
      GtkWidget* hbox = NULL;
      GtkWidget* entryCharge = GTK_BIN(comboCharge)->child;

      labelNumberOfElectrons = gtk_label_new(" ");
      hbox = gtk_hbox_new(0,FALSE);
      gtk_box_pack_start (GTK_BOX (hbox), labelNumberOfElectrons, FALSE, FALSE, 0);
      gtk_table_attach(GTK_TABLE(table),hbox,0,0+3,i,i+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_SHRINK),
                  2,2);

      g_object_set_data(G_OBJECT (entryCharge), "LabelNumberOfElectrons", labelNumberOfElectrons);
      g_signal_connect(G_OBJECT(entryCharge),"changed", GTK_SIGNAL_FUNC(changedEntryCharge),NULL);
      return labelNumberOfElectrons;
}
/***********************************************************************************************/
void createPCGamessChargeMultiplicityFrame(GtkWidget *box)
{
      GtkWidget* frame;
      GtkWidget* sep;
      GtkWidget* labelNumberOfElectrons;
      GtkWidget* vboxFrame;
      GtkWidget* comboSpinMultiplicity = NULL;
      GtkWidget* comboCharge = NULL;
      GtkWidget *table = NULL;
      gint i;

      totalCharge = 0;
      spinMultiplicity=1;

      table = gtk_table_new(3,5,FALSE);

      frame = gtk_frame_new ("Charge & Multiplicty");
      gtk_widget_show (frame);
      gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
      gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);

      vboxFrame = gtk_vbox_new (FALSE, 3);
      gtk_widget_show (vboxFrame);
      gtk_container_add (GTK_CONTAINER (frame), vboxFrame);

      gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);

      i = 0;
      comboCharge = addPCGamessChargeToTable(table, i);
      i = 1;
      comboSpinMultiplicity = addPCGamessSpinToTable(table, i);
      i = 2;
      sep = gtk_hseparator_new ();;
      gtk_table_attach(GTK_TABLE(table),sep,0,0+3,i,i+1,
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
            (GtkAttachOptions)      (GTK_FILL | GTK_EXPAND),
                  2,2);

      i = 3;
      labelNumberOfElectrons=addLabelNumberOfElectronsToTable(table, i, comboCharge);

      if(GTK_IS_COMBO_BOX(comboCharge))
            g_object_set_data(G_OBJECT (GTK_BIN(comboCharge)->child), "ComboSpinMultiplicity", comboSpinMultiplicity);
      setComboCharge(comboCharge);
      setComboSpinMultiplicity(comboSpinMultiplicity);
      if(GTK_IS_WIDGET(labelNumberOfElectrons))
      {
            gint ne = pcgamessMolecule.numberOfValenceElectrons - totalCharge;
            gchar buffer[BSIZE];
            sprintf(buffer, "Number of electrons = %d",ne);
            gtk_label_set_text(GTK_LABEL(labelNumberOfElectrons),buffer);
      }

      /* activate sensitivity */
      /*
      if(GTK_IS_WIDGET(comboMethod)) setComboMethod(comboMethod);
      g_object_set_data(G_OBJECT (box), "EntryMethod", GTK_BIN(comboMethod)->child);
      */
}
/************************************************************************************************************/
void putPCGamessChargeAndSpinInfoInTextEditor()
{
      gchar buffer[BSIZE];
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, " ",-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$CONTRL",-1);
      sprintf(buffer," ICHARG=%d ",totalCharge);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
      sprintf(buffer," MULT=%d ",spinMultiplicity);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, NULL, NULL, buffer,-1);
        gabedit_text_insert (GABEDIT_TEXT(text), NULL, &pcgamessColorFore.keyWord, &pcgamessColorBack.keyWord, "$END\n",-1);
}

Generated by  Doxygen 1.6.0   Back to index