src/openbabel/xyzformat.cpp

/**********************************************************************
Copyright (C) 2000 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
Some portions Copyright (C) 2004 by Chris Morley
 
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 version 2 of the License.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#include "xyzformat.hpp"


using namespace std;
namespace OpenBabel
{

bool XYZFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv)
{
    OBMol* pmol = dynamic_cast<OBMol*>(pOb);
    if(pmol==NULL)
        return false;

    //Define some references so we can use the old parameter names
    istream &ifs = *pConv->GetInStream();
    OBMol &mol = *pmol;
    const char* title = pConv->GetTitle();
    char buffer[BUFF_SIZE];

#ifdef HAVE_SSTREAM
    stringstream errorMsg;
#else
    strstream errorMsg;
#endif

    unsigned int natoms;        // [ejk] assumed natoms could not be -ve

    if (!ifs.getline(buffer,BUFF_SIZE))
      {
        obErrorLog.ThrowError(__FUNCTION__,
                              "Problems reading an XYZ file: Cannot read the first line.", obWarning);
        return(false);
      }

    if (sscanf(buffer, "%d", &natoms) == 0 || !natoms)
    {
      obErrorLog.ThrowError(__FUNCTION__,
                            "Problems reading an XYZ file: The first line must contain the number of atoms.", obWarning);
      return(false);
    }

    mol.ReserveAtoms(natoms);

    // The next line contains a title string for the molecule. Use this
    // as the title for the molecule if the line is not
    // empty. Otherwise, use the title given by the calling function.
    if (!ifs.getline(buffer,BUFF_SIZE))
    {
      obErrorLog.ThrowError(__FUNCTION__,
                            "Problems reading an XYZ file: Could not read the second line (title/comments).", obWarning);
        return(false);
    }
    if (strlen(buffer) != 0)
        mol.SetTitle(buffer);
    else
        mol.SetTitle(title);

    mol.BeginModify();

    // The next lines contain four items each, separated by white
    // spaces: the atom type, and the coordinates of the atom
    vector<string> vs;
    for (unsigned int i = 1; i <= natoms; i ++)
    {
        if (!ifs.getline(buffer,BUFF_SIZE))
        {
          errorMsg << "Problems reading an XYZ file: "
                   << "Could not read line #" << i+2 << ", file error." << endl
                   << " According to line one, there should be " << natoms 
                   << " atoms, and therefore " << natoms+2 << " lines in the file.";

          obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
          return(false);
        }
        tokenize(vs,buffer);
        if (vs.size() < 4)
        {
          errorMsg << "Problems reading an XYZ file: "
                   << "Could not read line #" << i+2 << "." << endl
                   << "OpenBabel found the line '" << buffer << "'" << endl
                   << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
                   << "However, OpenBabel found " << vs.size() << " items.";

          obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
          return(false);
        }

        // Atom Type: get the atomic number from the element table, using
        // the first entry in the currently read line. If the entry makes
        // sense, set the atomic number and leave the atomic type open
        // (the type is then later faulted in when atom->GetType() is
        // called). If the entry does not make sense to use, set the atom
        // type manually, assuming that the author of the xyz-file had
        // something "special" in mind.
        OBAtom *atom  = mol.NewAtom();
        int atomicNum = etab.GetAtomicNum(vs[0].c_str());
        atom->SetAtomicNum(atomicNum); //set atomic number, or '0' if the atom type is not recognized
        if (atomicNum == 0)
            atom->SetType(vs[0]);

        // Read the atom coordinates
        char *endptr;
        double x = strtod((char*)vs[1].c_str(),&endptr);
        if (endptr == (char*)vs[1].c_str())
        {
          errorMsg << "Problems reading an XYZ file: "
                   << "Could not read line #" << i+2 << "." << endl
                   << "OpenBabel found the line '" << buffer << "'" << endl
                   << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
                   << "OpenBabel could not interpret item #1 as a number.";

          obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
          return(false);
        }
        double y = strtod((char*)vs[2].c_str(),&endptr);
        if (endptr == (char*)vs[2].c_str())
        {
          errorMsg << "Problems reading an XYZ file: "
                   << "Could not read line #" << i+2 << "." << endl
                   << "OpenBabel found the line '" << buffer << "'" << endl
                   << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
                   << "OpenBabel could not interpret item #2 as a number.";

          obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
          return(false);
        }
        double z = strtod((char*)vs[3].c_str(),&endptr);
        if (endptr == (char*)vs[3].c_str())
        {
          errorMsg << "Problems reading an XYZ file: "
                   << "Could not read line #" << i+2 << "." << endl
                   << "OpenBabel found the line '" << buffer << "'" << endl
                   << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
                   << "OpenBabel could not interpret item #3 as a number.";

          obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
          return(false);
        }
        atom->SetVector(x,y,z); //set coordinates
    }

    // clean out any remaining blank lines
    while(ifs.peek() != EOF && ifs.good() && 
          (ifs.peek() == '\n' || ifs.peek() == '\r'))
      ifs.getline(buffer,BUFF_SIZE);

    if (!pConv->IsOption("b",OBConversion::INOPTIONS))
      mol.ConnectTheDots();
    if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
      mol.PerceiveBondOrders();

    mol.EndModify();

    return(true);
}

////////////////////////////////////////////////////////////////

bool XYZFormat::WriteMolecule(OBBase* pOb, OBConversion* pConv)
{
    OBMol* pmol = dynamic_cast<OBMol*>(pOb);
    if(pmol==NULL)
        return false;

    //Define some references so we can use the old parameter names
    ostream &ofs = *pConv->GetOutStream();
    OBMol &mol = *pmol;

    unsigned int i;
    char buffer[BUFF_SIZE];

    sprintf(buffer,"%d", mol.NumAtoms());
    ofs << buffer << endl;
    sprintf(buffer,"%s\tEnergy: %15.7f", mol.GetTitle(), mol.GetEnergy());
    ofs << buffer << endl;

    OBAtom *atom;
    string str,str1;
    for(i = 1;i <= mol.NumAtoms(); i++)
    {
        atom = mol.GetAtom(i);
        sprintf(buffer,"%3s%15.5f%15.5f%15.5f",
                etab.GetSymbol(atom->GetAtomicNum()),
                atom->GetX(),
                atom->GetY(),
                atom->GetZ());
        ofs << buffer << endl;
    }

    return(true);
}

} //namespace OpenBabel
Revision:	770
Committed:	Fri Dec 2 15:38:03 2005 UTC (19 years, 5 months ago) by tim
File size:	7382 byte(s)
Log Message:	End of the Link --> List Return of the Oject-Oriented replace yacc/lex parser with antlr parser
#	User	Rev	Content
1	tim	741	/**********************************************************************
2			Copyright (C) 2000 by OpenEye Scientific Software, Inc.
3			Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
4			Some portions Copyright (C) 2004 by Chris Morley
5
6			This program is free software; you can redistribute it and/or modify
7			it under the terms of the GNU General Public License as published by
8			the Free Software Foundation version 2 of the License.
9
10			This program is distributed in the hope that it will be useful,
11			but WITHOUT ANY WARRANTY; without even the implied warranty of
12			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			GNU General Public License for more details.
14			***********************************************************************/
15
16	tim	746	#include "xyzformat.hpp"
17	tim	741
18
19			using namespace std;
20			namespace OpenBabel
21			{
22
23			bool XYZFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv)
24			{
25			OBMol* pmol = dynamic_cast<OBMol*>(pOb);
26			if(pmol==NULL)
27			return false;
28
29			//Define some references so we can use the old parameter names
30			istream &ifs = *pConv->GetInStream();
31			OBMol &mol = *pmol;
32			const char* title = pConv->GetTitle();
33			char buffer[BUFF_SIZE];
34
35			#ifdef HAVE_SSTREAM
36			stringstream errorMsg;
37			#else
38			strstream errorMsg;
39			#endif
40
41			unsigned int natoms; // [ejk] assumed natoms could not be -ve
42
43			if (!ifs.getline(buffer,BUFF_SIZE))
44			{
45			obErrorLog.ThrowError(__FUNCTION__,
46			"Problems reading an XYZ file: Cannot read the first line.", obWarning);
47			return(false);
48			}
49
50			if (sscanf(buffer, "%d", &natoms) == 0 \|\| !natoms)
51			{
52			obErrorLog.ThrowError(__FUNCTION__,
53			"Problems reading an XYZ file: The first line must contain the number of atoms.", obWarning);
54			return(false);
55			}
56
57			mol.ReserveAtoms(natoms);
58
59			// The next line contains a title string for the molecule. Use this
60			// as the title for the molecule if the line is not
61			// empty. Otherwise, use the title given by the calling function.
62			if (!ifs.getline(buffer,BUFF_SIZE))
63			{
64			obErrorLog.ThrowError(__FUNCTION__,
65			"Problems reading an XYZ file: Could not read the second line (title/comments).", obWarning);
66			return(false);
67			}
68			if (strlen(buffer) != 0)
69			mol.SetTitle(buffer);
70			else
71			mol.SetTitle(title);
72
73			mol.BeginModify();
74
75			// The next lines contain four items each, separated by white
76			// spaces: the atom type, and the coordinates of the atom
77			vector<string> vs;
78			for (unsigned int i = 1; i <= natoms; i ++)
79			{
80			if (!ifs.getline(buffer,BUFF_SIZE))
81			{
82			errorMsg << "Problems reading an XYZ file: "
83			<< "Could not read line #" << i+2 << ", file error." << endl
84			<< " According to line one, there should be " << natoms
85			<< " atoms, and therefore " << natoms+2 << " lines in the file.";
86
87			obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
88			return(false);
89			}
90			tokenize(vs,buffer);
91	tim	770	if (vs.size() < 4)
92	tim	741	{
93			errorMsg << "Problems reading an XYZ file: "
94			<< "Could not read line #" << i+2 << "." << endl
95			<< "OpenBabel found the line '" << buffer << "'" << endl
96			<< "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
97			<< "However, OpenBabel found " << vs.size() << " items.";
98
99			obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
100			return(false);
101			}
102
103			// Atom Type: get the atomic number from the element table, using
104			// the first entry in the currently read line. If the entry makes
105			// sense, set the atomic number and leave the atomic type open
106			// (the type is then later faulted in when atom->GetType() is
107			// called). If the entry does not make sense to use, set the atom
108			// type manually, assuming that the author of the xyz-file had
109			// something "special" in mind.
110			OBAtom *atom = mol.NewAtom();
111			int atomicNum = etab.GetAtomicNum(vs[0].c_str());
112			atom->SetAtomicNum(atomicNum); //set atomic number, or '0' if the atom type is not recognized
113			if (atomicNum == 0)
114			atom->SetType(vs[0]);
115
116			// Read the atom coordinates
117			char *endptr;
118			double x = strtod((char*)vs[1].c_str(),&endptr);
119			if (endptr == (char*)vs[1].c_str())
120			{
121			errorMsg << "Problems reading an XYZ file: "
122			<< "Could not read line #" << i+2 << "." << endl
123			<< "OpenBabel found the line '" << buffer << "'" << endl
124			<< "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
125			<< "OpenBabel could not interpret item #1 as a number.";
126
127			obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
128			return(false);
129			}
130			double y = strtod((char*)vs[2].c_str(),&endptr);
131			if (endptr == (char*)vs[2].c_str())
132			{
133			errorMsg << "Problems reading an XYZ file: "
134			<< "Could not read line #" << i+2 << "." << endl
135			<< "OpenBabel found the line '" << buffer << "'" << endl
136			<< "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
137			<< "OpenBabel could not interpret item #2 as a number.";
138
139			obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
140			return(false);
141			}
142			double z = strtod((char*)vs[3].c_str(),&endptr);
143			if (endptr == (char*)vs[3].c_str())
144			{
145			errorMsg << "Problems reading an XYZ file: "
146			<< "Could not read line #" << i+2 << "." << endl
147			<< "OpenBabel found the line '" << buffer << "'" << endl
148			<< "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
149			<< "OpenBabel could not interpret item #3 as a number.";
150
151			obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
152			return(false);
153			}
154			atom->SetVector(x,y,z); //set coordinates
155			}
156
157			// clean out any remaining blank lines
158			while(ifs.peek() != EOF && ifs.good() &&
159			(ifs.peek() == '\n' \|\| ifs.peek() == '\r'))
160			ifs.getline(buffer,BUFF_SIZE);
161
162			if (!pConv->IsOption("b",OBConversion::INOPTIONS))
163			mol.ConnectTheDots();
164			if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
165			mol.PerceiveBondOrders();
166
167			mol.EndModify();
168
169			return(true);
170			}
171
172			////////////////////////////////////////////////////////////////
173
174			bool XYZFormat::WriteMolecule(OBBase* pOb, OBConversion* pConv)
175			{
176			OBMol* pmol = dynamic_cast<OBMol*>(pOb);
177			if(pmol==NULL)
178			return false;
179
180			//Define some references so we can use the old parameter names
181			ostream &ofs = *pConv->GetOutStream();
182			OBMol &mol = *pmol;
183
184			unsigned int i;
185			char buffer[BUFF_SIZE];
186
187			sprintf(buffer,"%d", mol.NumAtoms());
188			ofs << buffer << endl;
189			sprintf(buffer,"%s\tEnergy: %15.7f", mol.GetTitle(), mol.GetEnergy());
190			ofs << buffer << endl;
191
192			OBAtom *atom;
193			string str,str1;
194			for(i = 1;i <= mol.NumAtoms(); i++)
195			{
196			atom = mol.GetAtom(i);
197			sprintf(buffer,"%3s%15.5f%15.5f%15.5f",
198			etab.GetSymbol(atom->GetAtomicNum()),
199			atom->GetX(),
200			atom->GetY(),
201			atom->GetZ());
202			ofs << buffer << endl;
203			}
204
205			return(true);
206			}
207
208			} //namespace OpenBabel