crdfactory.cpp

Go to the documentation of this file.

/***************************************************************************
                        crdfactory.cpp  -  description
                             -------------------
    begin                : Sat Jan 17 2004
    copyright            : (C) 2004-2006 by Ben Swerts
    email                : bswerts@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/






// C++ header files
#include <cmath>
#include <iostream>

// Qt header files
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <qstring.h>
#include <qstringlist.h>

#include <qdatetime.h>

#ifdef USE_OPENBABEL1
 // Open Babel 1.100.2 header files
 #ifdef Q_OS_WIN32
   #include <mol.h>
   #include <molvector.h>
   #include <obutil.h>
   #include <parsmart.h>
   #include <rotor.h>
   #include <binary.h>
 #else
   #include <openbabel/mol.h>
   #include <openbabel/molvector.h>
   #include <openbabel/obutil.h>
   #include <openbabel/parsmart.h>
   #include <openbabel/rotor.h>
   #include <openbabel/binary.h>
 #endif
 using namespace OpenBabel; // to be changed to a number of 'using <class>' lines
#endif
#ifdef USE_OPENBABEL2
  // Open Babel 2.x header files
  #ifdef Q_OS_WIN32
    #include <mol.h>
    #include <obconversion.h>
  #else
    #include <openbabel/mol.h>
    #include <openbabel/obconversion.h>
  #endif
  using namespace OpenBabel;
#endif

// CrdView header files
#include "atomset.h"
#include "crdfactory.h"
#include "version.h"



CrdFactory::~CrdFactory()
{

}

unsigned int CrdFactory::readFromFile(AtomSet* atoms, QString filename)
{
  // choose a filename if none was specified
  if(filename.isEmpty())
  {
    QStringList filterList = supportedInputFormats();
    QString fileFilter = filterList.join(";;");
    QString fileTitle = QFileDialog::tr("Choose coordinates");
    filename = QFileDialog::getOpenFileName(QString::null, fileFilter, 0, 0, fileTitle);
    if(filename.isEmpty())
      return Cancelled; 
  }

  // validate the filename
  if(!validInputFormat(filename))    
    return UnknownExtension; 
  
  // check whether the Xbrabo or Open Babel reading routines should be used
  if(braboExtension(filename))
  {
    return readBraboFile(atoms, filename);
  }
  else if(xmolExtension(filename))
  {
    return readXmolFile(atoms, filename);
  } 
  else if(gaussianExtension(filename))
  {
    return readGaussianFile(atoms, filename);
  }
#ifdef USE_OPENBABEL1
  else
  {
    // read the file
    char* fn = qstrdup(filename.latin1()); // put the filename QString into a non-const char*
    io_type fileType = extab.FilenameToType(fn);
    delete fn;
    std::ifstream inFileStream;
    inFileStream.open(filename.latin1());
    if(!inFileStream)
      return ErrorOpen;
    OBMol* mol = new OBMol(fileType);
    if(!OBFileFormat::ReadMolecule(inFileStream, *mol)) // only read the first molecule
    {
      delete mol;
      return ErrorRead;
    }
    // fill the AtomSet
    atoms->clear();
    atoms->reserve(mol->NumAtoms());
    vector<OBNodeBase*>::iterator it;
    for(OBAtom* atom  = mol->BeginAtom(it); atom; atom = mol->NextAtom(it))
      atoms->addAtom(atom->GetX(), atom->GetY(), atom->GetZ(), static_cast<unsigned int>(atom->GetAtomicNum()));
    delete mol;
  }  
#endif
#ifdef USE_OPENBABEL2
  else
  {
    QTime timer;
    timer.start();
    // read the file
    OBConversion conv;
    OBFormat* fileFormat = conv.FormatFromExt(filename.latin1());
    if(!fileFormat || !conv.SetInFormat(fileFormat))
      return UnknownExtension;
    // delete fileFormat; ???
    std::ifstream inFileStream;
    inFileStream.open(filename.latin1());
    if(!inFileStream)
      return ErrorOpen;
    OBMol mol;
    if(!conv.Read(&mol, &inFileStream))
      return ErrorRead;
    qDebug("time to read the OpenBabel file: %f seconds", timer.restart()/1000.f);
    // fill the AtomSet
    atoms->clear();
    atoms->reserve(mol.NumAtoms());
    for(OBMolAtomIter atom(mol); atom; atom++)
      atoms->addAtom(atom->x(), atom->y(), atom->z(), atom->GetAtomicNum());
    qDebug("time to fill the AtomSet: %f seconds", timer.restart()/1000.f);
  }  
#endif
  return OK;
}

unsigned int CrdFactory::readFromFile(AtomSet* atoms)
{  
  QString emptyString;
  return readFromFile(atoms, QString::null);
}

unsigned int CrdFactory::writeToFile(AtomSet* atoms, QString filename, bool extendedFormat)
{
  if(filename.isEmpty())
  {
    QStringList filterList = supportedOutputFormats();
    QString fileFilter = filterList.join(";;");
    QString fileTitle = QFileDialog::tr("Choose a filename");
    QString selectedFilter;
    filename = QFileDialog::getSaveFileName(0, fileFilter, 0, 0, fileTitle, &selectedFilter);
    if(filename.isEmpty())
      return Cancelled;
      
    // fix the extension
    QString selectedExtension = selectedFilter.section(".", -1).section(")",0);
    if(!filename.section(".", -1).contains(selectedExtension))
      filename += "." + selectedExtension;

    // ask the format if it's a Brabo extension
    if(braboExtension(filename))
    {
      extendedFormat = false;
      // check whether the coordinates fit in normal format
      // if not force extended format
      if(atoms->needsExtendedFormat())
        extendedFormat = true;
      else if(QMessageBox::information(0, Version::appName,
                                     QMessageBox::tr("Do you want to save the coordinates in extended or normal format?"),
                                     QMessageBox::tr("Extended format"), QMessageBox::tr("Normal format")) == 0)
        extendedFormat = true;  
    }  
  }
  else
  {
    // validate the filename
    if(!validOutputFormat(filename))
      return UnknownExtension; 
  }   

  // check whether the Xbrabo or Open Babel writing routines should be used
  if(braboExtension(filename))
  {
    return writeBraboFile(atoms, filename, extendedFormat);
  }
#ifdef USE_OPENBABEL1  
  else
  {
    // determine the Open Babel file type
    char* fn = qstrdup(filename.latin1()); // put the filename QString into a non-const char*
    io_type fileType = extab.FilenameToType(fn);
    delete fn;   
    // construct an Open Babel molecule and fill it with the contents of the AtomSet
    OBMol* mol = new OBMol(fileType, fileType);
    OBAtom* atom;
    for(unsigned int i = 0; i < atoms->count(); i++)
    {
      atom = mol->NewAtom();
      atom->SetVector(atoms->x(i), atoms->y(i), atoms->z(i));
      atom->SetAtomicNum(atoms->atomicNumber(i));
    }   
    // write the file
    std::ofstream outFileStream;
    outFileStream.open(filename.latin1());
    if(!outFileStream)
      return ErrorOpen;
    if(!OBFileFormat::WriteMolecule(outFileStream, *mol))
    {
      delete mol;
      return ErrorWrite;
    }  
    delete mol;      
  }
#endif  
#ifdef USE_OPENBABEL2  
  else
  {
    // determine the Open Babel file type
    OBConversion conv;
    OBFormat* fileFormat = conv.FormatFromExt(filename.latin1());
    if(!fileFormat || !conv.SetOutFormat(fileFormat))
      return UnknownExtension;
    // delete fileFormat; ???
    std::ofstream outFileStream;
    outFileStream.open(filename.latin1());
    if(!outFileStream)
      return ErrorOpen;
    OBMol mol;
    OBAtom* atom;
    for(unsigned int i = 0; i < atoms->count(); i++)
    {
      atom = mol.NewAtom();
      atom->SetVector(atoms->x(i), atoms->y(i), atoms->z(i));
      atom->SetAtomicNum(atoms->atomicNumber(i));
    }   
    if(!conv.Write(&mol, &outFileStream))
      return ErrorWrite;  
  }
#endif
  return OK;
}

unsigned int CrdFactory::convert(const QString inputFileName, const QString outputFileName, const bool extendedFormat)
{
  if(!validInputFormat(inputFileName))
    return UnknownExtension;
  if(!validOutputFormat(outputFileName))
    return UnknownExtension;  
  
  if(braboExtension(inputFileName) || braboExtension(outputFileName) || xmolExtension(inputFileName))
  {
    
    // read the input file into the AtomSet
    AtomSet* atoms = new AtomSet();
    QString tempInput = inputFileName;
    unsigned int result = readFromFile(atoms, tempInput);
    if(result != OK)
      return result;

    // save the AtomSet to the output file
    return writeToFile(atoms, outputFileName, extendedFormat);
       
  }
#ifdef USE_OPENBABEL1  
  else
  {
    
    // determine the file types of the in- & output files
    char* inFile = qstrdup(inputFileName.latin1()); 
    io_type inFileType = extab.FilenameToType(inFile);
    delete inFile;
    char* outFile = qstrdup(outputFileName.latin1());
    io_type outFileType = extab.FilenameToType(outFile);
    delete outFile;

    // open both files
    std::ifstream inFileStream;
    inFileStream.open(inputFileName.latin1());
    if(!inFileStream)
      return ErrorOpen;
    std::ofstream outFileStream;
    outFileStream.open(outputFileName.latin1());
    if(!outFileStream)
      return ErrorOpen;      
    
    // construct an OBMol object
    OBMol* mol = new OBMol(inFileType, outFileType);

    // read the coordinates   
    if(!OBFileFormat::ReadMolecule(inFileStream, *mol)) // only read the first molecule
    {
      delete mol;
      return ErrorRead;
    }

    // write the coordinates
    if(!OBFileFormat::WriteMolecule(outFileStream, *mol))
    {
      delete mol;
      return ErrorWrite;
    }

    // delete the OBMol object again
    delete mol;        
  }
#endif  
#ifdef USE_OPENBABEL2 
  else
  {
    // open both files
    std::ifstream inFileStream;
    inFileStream.open(inputFileName.latin1());
    if(!inFileStream)
      return ErrorOpen;
    std::ofstream outFileStream;
    outFileStream.open(outputFileName.latin1());
    if(!outFileStream)
      return ErrorOpen;      
    // create a conversion object
    OBConversion conv(&inFileStream, &outFileStream);
    // set the filetypes
    OBFormat* inFormat = conv.FormatFromExt(inputFileName.latin1());
    OBFormat* outFormat = conv.FormatFromExt(outputFileName.latin1());
    if(!inFormat || !outFormat || !conv.SetInAndOutFormats(inFormat, outFormat))
      return UnknownExtension;
    conv.Convert(); 
  }
#endif
  return OK;
}

unsigned int CrdFactory::readForces(AtomSet* atoms, QString filename)
{ 
  // validate the filename
  if(!validForceInputFormat(filename))
    return UnknownExtension;

  // check whether the Xbrabo or Open Babel reading routines should be used
  if(braboExtension(filename))
  {
    return readBraboForces(atoms, filename);
  }
   
  return OK;
}


CrdFactory::CrdFactory()
{

}

QStringList CrdFactory::supportedInputFormats()
{
  QStringList result = "Brabo (*.crd *.c00)";
  result += "Gaussian Checkpoint (*.fchk)";
#ifdef USE_OPENBABEL1  
  for(unsigned int i = 0; i < extab.Count(); i++)
  {
    if(extab.IsReadable(i))
    {
      QString inputFormat = ";;";
      inputFormat += extab.GetDescription(i);
      inputFormat += " (*.";
      inputFormat += extab.GetExtension(i);
      inputFormat += ")";
      result += inputFormat;
    }  
  }
#endif
#ifdef USE_OPENBABEL2 
  OBConversion conv; // here only because of initialisation bug in OBConversion::GetNextFormat (v2.0.0)
  //OBConversion::RegisterFormat("alc",this, "chemical/x-alchemy"); // test for initialisation of OBConversion
  
  const char* str = NULL;
  Formatpos pos;
  OBFormat* format;
  while(OBConversion::GetNextFormat(pos, str, format))
  {
    if(!(format->Flags() & NOTREADABLE))
    {
      // description
      QString desc = QString(format->Description());
      desc.truncate(desc.find("\n")); // stop at the first newline
      desc = desc.remove("format", false).stripWhiteSpace(); // remove unnecessary stuff
      // extension
      QString ext = QString(str);
      ext.truncate(ext.find(" "));
      // combined
      result += QString(";;" + desc + " (*." + ext + ")");
    }
  }
#endif
  return result;
}

QStringList CrdFactory::supportedOutputFormats()
{
  QStringList result = "Brabo (*.crd)";
#ifdef USE_OPENBABEL1  
  for(unsigned int i = 0; i < extab.Count(); i++)
  {
    if(extab.IsWritable(i))
    {
      QString outputFormat = ";;";
      outputFormat += extab.GetDescription(i);
      outputFormat += " (*.";
      outputFormat += extab.GetExtension(i);
      outputFormat += ")";
      result += outputFormat;
    }
  }
#endif  
#ifdef USE_OPENBABEL2  
  const char* str = NULL;
  Formatpos pos;
  OBFormat* format;
  OBConversion conv; // here only because of initialisation bug in OBConversion::GetNextFormat (v2.0.0)
  while(OBConversion::GetNextFormat(pos, str, format))
  {
    if(!(format->Flags() & NOTWRITABLE))
    {
      // description
      QString desc = QString(format->Description());
      desc.truncate(desc.find("\n")); // stop at the first newline
      desc = desc.remove("format", false).stripWhiteSpace(); // remove unnecessary stuff
      // extension
      QString ext = QString(str);
      ext.truncate(ext.find(" "));
      // combined
      result += QString(";;" + desc + " (*." + ext + ")");
    }
  }
#endif
  return result;
}

bool CrdFactory::validInputFormat(const QString filename)
{
  // check for Brabo formats
  if(braboExtension(filename) || xmolExtension(filename) || gaussianExtension(filename))
    return true;

#ifdef USE_OPENBABEL1    
  // check for Open Babel formats
  char* fn = qstrdup(filename.latin1()); // put the filename QString into a non-const char*
  if(extab.CanReadExtension(fn))
  {
    delete fn;
    return true;
  }  
  delete fn;
#endif
#ifdef USE_OPENBABEL2    
  // check for Open Babel formats
  OBConversion conv; // here only because of initialisation bug in OBConversion::FileFormat (called by FormatFromExt) (v2.0.0)
  OBFormat* format = OBConversion::FormatFromExt(filename.latin1());
  if(format || !(format->Flags() | NOTREADABLE))
    return true;
#endif
  return false;
}

bool CrdFactory::validForceInputFormat(const QString filename)
{
  // check for Brabo formats
  if(braboExtension(filename))
    return true;

  return false;
}

bool CrdFactory::validOutputFormat(const QString filename)
{  
  // check for Brabo formats
  if(braboExtension(filename))
    return true;

#ifdef USE_OPENBABEL1
  // check for Open Babel formats
  char* fn = qstrdup(filename.latin1()); // put the filename QString into a non-const char*
  if(extab.CanWriteExtension(fn))
  {
    delete fn;
    return true;
  }
  delete fn;
#endif
#ifdef USE_OPENBABEL2    
  // check for Open Babel formats
  OBConversion conv; // here only because of initialisation bug in OBConversion::FileFormat (called by FormatFromExt) (v2.0.0)
  OBFormat* format = OBConversion::FormatFromExt(filename.latin1());
  if(format || !(format->Flags() | NOTWRITABLE))
    return true;
#endif
  return false;
}

bool CrdFactory::braboExtension(const QString filename)
{
  QString extension = filename.section(".", -1).lower();
  if(extension == "crd" || extension == "c00" || extension == "ncr" || extension == "crdcrd" ||
     extension == "pun" || extension == "f00")
    return true;

  return false;
}

bool CrdFactory::xmolExtension(const QString filename)
{
  QString extension = filename.section(".", -1).lower();
  if(extension == "xyz")
    return true;

  return false;
}

bool CrdFactory::gaussianExtension(const QString filename)
{
  QString extension = filename.section(".", -1).lower();
  if(extension == "fchk")
    return true;

  return false;
}

unsigned int CrdFactory::readBraboFile(AtomSet* atoms, const QString filename)
{
  QTime timer;
  timer.start();
  QFile file(filename);
  if(!file.open(IO_ReadOnly))
    return ErrorOpen;

  QTextStream stream(&file);
  QStringList allLines;
  QString line;
  while(!stream.eof() && allLines.size() < 101)
  {
    line = stream.readLine();
    if(line.left(4).lower() == "stop")
      break;
    else if(line.left(1).lower() == "n" && line.mid(1,1) == "=")
      allLines += line;
  }

  unsigned int format = determineCrdFormat(allLines);
  if(format == UnknownFormat) // format not determinable => error out or ask format
    return UnknownFormat;
  
  if(format == NormalFormat)
    readCrdAtoms(atoms, allLines, false); // using normal format
  else if(format == ExtendedFormat)
    readCrdAtoms(atoms, allLines, true); // using extended format

  vector<unsigned int>* bonds1;
  vector<unsigned int>* bonds2;
  atoms->bonds(bonds1, bonds2);
  double toAngstrom = 1.0;
  if(bonds1->empty() && atoms->count() > 1)
  {
    // rescale all coordinates
    toAngstrom = 0.529177249;
    for(unsigned int i = 0; i < atoms->count(); i++)
    {
      atoms->setX(i,atoms->x(i) * toAngstrom);
      atoms->setY(i,atoms->y(i) * toAngstrom);
      atoms->setZ(i,atoms->z(i) * toAngstrom);
    }
  }

  if(line.left(4).lower() != "stop" && !stream.eof())
  {
    double x, y, z, atomNum;
    unsigned int atomicNumber;

    while(!stream.eof())
    {
      line = stream.readLine();
      if(line.left(4).lower() == "stop")
        break;
      else if(line.left(1).lower() == "n" && line.mid(1,1) == "=")
      {
        atomNum = line.mid(10,10).toDouble();
        if(atomNum < 1.0)
          atomicNumber = 0;
        else
        {
          if(atomNum - floor(atomNum) > 0.00001)
            atomicNumber = 0;
          else
            atomicNumber = static_cast<unsigned int>(atomNum);
        }
        if(format == NormalFormat)
        {
          x = line.mid(20,10).toDouble() * toAngstrom;
          y = line.mid(30,10).toDouble() * toAngstrom;
          z = line.mid(40,10).toDouble() * toAngstrom;
        }
        else
        {
          x = line.mid(20,20).toDouble() * toAngstrom;
          y = line.mid(40,20).toDouble() * toAngstrom;
          z = line.mid(60,20).toDouble() * toAngstrom;
        }
        atoms->addAtom(x, y, z, atomicNumber);
      }
    }
  }

  qDebug("time to read the BRABO file: %f seconds", timer.restart()/1000.f);
  return OK;
}

unsigned int CrdFactory::writeBraboFile(AtomSet* atoms, const QString filename, const bool extendedFormat)
{
  QFile file(filename);
  if(!file.open(IO_WriteOnly))
    return ErrorOpen;

  QTextStream stream(&file);
  QString line;

  for(unsigned int i = 0; i < atoms->count(); i++)
  {
    if(extendedFormat)
      line = QString("N=%1      %2%3%4%5").arg(AtomSet::numToAtom(atoms->atomicNumber(i)), 2)
                                          .arg(static_cast<double>(atoms->atomicNumber(i)), -10, 'f', 1)
                                          .arg(atoms->x(i), 20, 'f', 12)
                                          .arg(atoms->y(i), 20, 'f', 12)
                                          .arg(atoms->z(i), 20, 'f', 12);
    else
      line = QString("N=%1      %2%3%4%5").arg(AtomSet::numToAtom(atoms->atomicNumber(i)), 2)
                                          .arg(static_cast<double>(atoms->atomicNumber(i)), -10, 'f', 1)
                                          .arg(atoms->x(i), 10, 'f', 7)
                                          .arg(atoms->y(i), 10, 'f', 7)
                                          .arg(atoms->z(i), 10, 'f', 7);
    stream << line << "\n";
  }
  stream << "STOP\n";
  file.close();
  return OK;
}

unsigned int CrdFactory::readBraboForces(AtomSet* atoms, const QString filename)
{
  //qDebug("CrdFactory:: readBraboForces - entering");
  QFile file(filename);
  if(!file.open(IO_ReadOnly))
    return ErrorOpen;

  QTextStream stream(&file);
  QStringList allLines;
  QString line;
  while(!stream.eof())
  {
    line = stream.readLine();
    if(line.left(8).lower() == "****forc")
      break;
  }
  while(!stream.eof())    
  {
    line = stream.readLine();  
    if(line.left(4) == "****")
      break;
    allLines += line;
  }
  file.close();

  unsigned int format = determinePunchFormat(allLines);
  if(format == UnknownFormat) // format not determinable => error out or ask format
    return UnknownFormat;

  if(format == NormalFormat)
    readPunchForces(atoms, allLines, false); // using normal format
  else if(format == ExtendedFormat)
    readPunchForces(atoms, allLines, true); // using extended format

  return OK;
}

void CrdFactory::readCrdAtoms(AtomSet* atoms, QStringList &lines, const bool extendedFormat)
{
  double x, y, z, atomNum;
  unsigned int atomicNumber;
  QString line;

  atoms->clear();
  atoms->reserve(lines.size());
  for(QStringList::iterator it = lines.begin(); it != lines.end(); it++)
  {
    line = *it;
    atomNum = line.mid(10,10).toDouble();
    if(atomNum < 1.0)
     atomicNumber = 0;
    else
    {
      if(atomNum - floor(atomNum) > 0.00001)
        atomicNumber = 0;
      else
        atomicNumber = static_cast<unsigned int>(atomNum);
    }
    //atomicNumber = static_cast<unsigned int>(line.mid(10,10).toDouble());
    if(!extendedFormat)
    {
      x = line.mid(20,10).toDouble();
      y = line.mid(30,10).toDouble();
      z = line.mid(40,10).toDouble();
    }
    else
    {
      x = line.mid(20,20).toDouble();
      y = line.mid(40,20).toDouble();
      z = line.mid(60,20).toDouble();
    }
    atoms->addAtom(x, y, z, atomicNumber);
  }
}

void CrdFactory::readPunchForces(AtomSet* atoms, QStringList &lines, const bool extendedFormat)
{
  double dx, dy, dz;
  QString line;
  unsigned int index = 0;
  
  for(QStringList::iterator it = lines.begin(); it != lines.end(); it++)
  {    
    line = *it;
    if(!extendedFormat)
    {
      dx = line.mid(0,10).toDouble();
      dy = line.mid(10,10).toDouble();
      dz = line.mid(20,10).toDouble();
    }
    else
    {
      dx = line.mid(0,20).toDouble();
      dy = line.mid(20,20).toDouble();
      dz = line.mid(40,20).toDouble();
    }
    atoms->setForces(index++, dx, dy, dz);    
  }
}

unsigned int CrdFactory::determineCrdFormat(QStringList& lines)
{
  QString line;
  unsigned int returnVal = UnknownFormat;
  unsigned int linesChecked = 0;

  for(QStringList::iterator it = lines.begin(); it != lines.end(); it++)
  {
    line = *it;
    if(possiblyNormalCrd(line.mid(20,30)))
    {
      if(!possiblyExtendedCrd(line.mid(20,60)))
      {
        if(returnVal != 1)
          returnVal = NormalFormat;
        else
          return UnknownFormat;
      }
    }
    else
    {
      if(possiblyExtendedCrd(line.mid(20,60)))
      {
        if(returnVal != 0)
          returnVal = ExtendedFormat;
        else
          return UnknownFormat;
      }
      else
        return UnknownFormat;
    }
    if(++linesChecked == 100)
      return returnVal;
  }

  return returnVal;
}

unsigned int CrdFactory::determinePunchFormat(QStringList& lines)
{
  QString line;
  unsigned int returnVal = UnknownFormat;
  unsigned int linesChecked = 0;

  for(QStringList::iterator it = lines.begin(); it != lines.end(); it++)
  {
    line = *it;
    if(possiblyNormalCrd(line.mid(0,30)))
    {
      if(!possiblyExtendedCrd(line.mid(0,60)))
      {
        if(returnVal != 1)
          returnVal = NormalFormat;
        else
          return UnknownFormat;
      }
    }
    else
    {
      if(possiblyExtendedCrd(line.mid(0,60)))
      {
        if(returnVal != 0)
          returnVal = ExtendedFormat;
        else
          return UnknownFormat;
      }
      else
        return UnknownFormat;
    }
    if(++linesChecked == 100)
      return returnVal;
  }

  return returnVal;
}

bool CrdFactory::possiblyNormalCrd(const QString line)
{
  QString field1 = line.mid(0,10).stripWhiteSpace();
  QString field2 = line.mid(10,10).stripWhiteSpace();
  QString field3 = line.mid(20,10).stripWhiteSpace();

  if(field1.contains(".", false) != 1 && !field1.isEmpty())
    return false;
  if(field2.contains(".", false) != 1 && !field2.isEmpty())
    return false;
  if(field3.contains(".", false) != 1 && !field3.isEmpty())
    return false;

  return true;
}

bool CrdFactory::possiblyExtendedCrd(const QString line)
{
  QString field1 = line.mid(0,20).stripWhiteSpace();
  QString field2 = line.mid(20,20).stripWhiteSpace();
  QString field3 = line.mid(40,20).stripWhiteSpace();

  if(field1.contains(".", false) != 1 && !field1.isEmpty())
    return false;
  if(field2.contains(".", false) != 1 && !field2.isEmpty())
    return false;
  if(field3.contains(".", false) != 1 && !field3.isEmpty())
    return false;

  return true;
}

unsigned int CrdFactory::readXmolFile(AtomSet* atoms, const QString filename)
{
  QFile file(filename);
  if(!file.open(IO_ReadOnly))
    return ErrorOpen;

  QTextStream stream(&file);
  bool convOK;  
  unsigned int natoms = stream.readLine().toUInt(&convOK);
  if(!convOK || natoms == 0)
    return ErrorRead;

  stream.readLine();

  QStringList allLines;
  for(unsigned int i = 0; i < natoms; i++)
  {
    // read the next line
    QString line = stream.readLine().simplifyWhiteSpace();
    if(line.isEmpty())
      return ErrorRead;

    allLines += line;
  }
  file.close();
  
  for(QStringList::iterator it = allLines.begin(); it != allLines.end(); it++)
  {
    // split it by whitespace
    QStringList sections = QStringList::split(" ", *it);
    if(sections.count() != 4 && sections.count() != 7)
      return ErrorRead;
  }

  atoms->clear();
  atoms->reserve(allLines.size());
  for(QStringList::iterator it = allLines.begin(); it != allLines.end(); it++)
  {
    // split it again by whitespace
    QStringList sections = QStringList::split(" ", *it);
    // only read the coordinates ATM, ignoring the forces
    QStringList::iterator it2 = sections.begin();
    unsigned int atomnum = AtomSet::atomToNum(*it2);
    double x = (*(++it2)).toDouble();
    double y = (*(++it2)).toDouble();
    double z = (*(++it2)).toDouble();
    atoms->addAtom(x, y, z, atomnum);   
  } 
  return OK;
}

unsigned int CrdFactory::readGaussianFile(AtomSet* atoms, const QString filename)
{
  QFile file(filename);
  if(!file.open(IO_ReadOnly))
    return ErrorOpen;

  QTextStream stream(&file);
  QString line;
  while(line.left(15) != "Number of atoms")
    line = stream.readLine();
  bool convOK;
  unsigned int natoms = line.mid(49,12).toUInt(&convOK);
  if(!convOK || natoms == 0)
    return ErrorRead;

  while(line.left(14) != "Atomic numbers")
    line = stream.readLine();
  unsigned int natoms2 = line.mid(49,12).toUInt(&convOK);
  if(!convOK || natoms2 != natoms)
    return ErrorRead;
  
  vector<unsigned int> atomnums;
  unsigned int atomnum;
  for(unsigned int i = 0; i < natoms; i++)
  {
    stream >> atomnum;
        atomnums.push_back(atomnum);
  }

  while(line.left(29) != "Current cartesian coordinates")
    line = stream.readLine();
  unsigned int natoms3 = line.mid(49,12).toUInt(&convOK);
  if(!convOK || natoms3 != 3*natoms)
    return ErrorRead;
  
  atoms->clear();
  atoms->reserve(natoms);
  double x, y, z;
  for(unsigned int i = 0; i < natoms; i++)
  {
    stream >> x >> y >> z;
        x *= AUTOANG;
        y *= AUTOANG;
        z *= AUTOANG;
        atoms->addAtom(x, y, z, atomnums[i]);
  }

  return OK;
}

const double CrdFactory::AUTOANG = 1.0/1.889726342; 

---