src/utils/ElementsTable.cpp

/**********************************************************************

This basic Periodic Table class was originally taken from the data.cpp
file in OpenBabel. The code has been modified to match the OpenMD coding style.

We have retained the OpenBabel copyright and GPL license on this class:  

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.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 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.
***********************************************************************/

/**
 * @file ElementsTable.cpp
 * @author gezelter
 * @date 12/21/2007
 * @version 1.0
 */

#include "config.h"

#include <iostream>
#include <cstdlib>
#include <string>
#include <fstream>
#include <cstdlib>
#include "utils/ElementsTable.hpp"
#include "utils/simError.h"
#include "io/ifstrstream.hpp"

#ifdef _MSC_VER
#define strncasecmp _strnicmp
#define strcasecmp _stricmp
#endif


#ifdef WIN32
#define FILE_SEP_CHAR "\\"
#else
#define FILE_SEP_CHAR "/"
#endif

#ifndef BUFF_SIZE
#define BUFF_SIZE 32768
#endif

namespace OpenMD {

  ElementsTable etab;

  ElementsTable::ElementsTable() {
    init_ = false;
    dir_ = std::string("TO_STRING(FRC_PATH)");
    envvar_ = "FORCE_PARAM_PATH";
    filename_ = "element.txt";
  }
  
  ElementsTable::~ElementsTable() {
    std::vector<Element*>::iterator i;
    for (i = elements_.begin(); i != elements_.end(); ++i)
      delete *i;
  }
  
  void ElementsTable::ParseLine(const char *line) {
    int num, maxbonds;
    char symbol[6];
    char name[256];
    RealType Rcov,Rvdw,mass, elNeg, ionize, elAffin;
    RealType red, green, blue;

    // skip comment line (at the top)
    if (line[0] != '#')  {
      sscanf(line,"%d %5s %lf %*f %lf %d %lf %lf %lf %lf %lf %lf %lf %255s",
             &num,
             symbol,
             &Rcov,
             &Rvdw,
             &maxbonds,
             &mass,
             &elNeg,
             &ionize,
             &elAffin,
             &red,
             &green,
             &blue,
             name);
    
      Element *ele = new Element(num, symbol, Rcov, Rvdw, maxbonds, mass, 
                                 elNeg, ionize, elAffin, red, green, blue, 
                                 name);
      elements_.push_back(ele);

    }
  }

  unsigned int ElementsTable::GetNumberOfElements() { 
    if (!init_)
      Init();
    
    return elements_.size();
  }

  const char *ElementsTable::GetSymbol(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return("\0");
    
    return(elements_[atomicnum]->GetSymbol());
  }

  int ElementsTable::GetMaxBonds(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0);
    
    return(elements_[atomicnum]->GetMaxBonds());
  }
  
  RealType ElementsTable::GetElectroNeg(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);
    
    return(elements_[atomicnum]->GetElectroNeg());
  }
  
  RealType ElementsTable::GetIonization(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);
    
    return(elements_[atomicnum]->GetIonization());
  }
  

  RealType ElementsTable::GetElectronAffinity(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);

    return(elements_[atomicnum]->GetElectronAffinity());
  }
  
  std::vector<RealType> ElementsTable::GetRGB(int atomicnum) {
    if (!init_)
      Init();
    
    std::vector <RealType> colors;
    colors.reserve(3);
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size())) {
      colors.push_back(0.0);
      colors.push_back(0.0);
      colors.push_back(0.0);
      return(colors);
    }

    colors.push_back(elements_[atomicnum]->GetRed());
    colors.push_back(elements_[atomicnum]->GetGreen());
    colors.push_back(elements_[atomicnum]->GetBlue());
    
    return (colors);
  }
  
  std::string ElementsTable::GetName(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return("Unknown");
    
    return(elements_[atomicnum]->GetName());
  }

  RealType ElementsTable::GetVdwRad(int atomicnum) {
    if (!init_)
      Init();

    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);

    return(elements_[atomicnum]->GetVdwRad());
  }
  
  RealType ElementsTable::CorrectedBondRad(int atomicnum, int hyb) {
    RealType rad;
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(1.0);
    
    rad = elements_[atomicnum]->GetCovalentRad();
    
    if (hyb == 2)
      rad *= 0.95;
    else if (hyb == 1)
      rad *= 0.90;

    return(rad);
  }

  RealType ElementsTable::CorrectedVdwRad(int atomicnum, int hyb) {
    RealType rad;
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(1.95);
    
    rad = elements_[atomicnum]->GetVdwRad();
    
    if (hyb == 2)
      rad *= 0.95;
    else if (hyb == 1)
      rad *= 0.90;
    
    return(rad);
  }

  RealType ElementsTable::GetCovalentRad(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);
    
    return(elements_[atomicnum]->GetCovalentRad());
  }
  
  RealType ElementsTable::GetMass(int atomicnum) {
    if (!init_)
      Init();
    
    if (atomicnum < 0 || atomicnum > static_cast<int>(elements_.size()))
      return(0.0);
    
    return(elements_[atomicnum]->GetMass());
  }
  
  int ElementsTable::GetAtomicNum(const char *sym) {
    int temp;
    return GetAtomicNum(sym, temp);
  }

  int ElementsTable::GetAtomicNum(const char *sym, int &iso) {
    if (!init_)
      Init();
    
    std::vector<Element*>::iterator i;
    for (i = elements_.begin();i != elements_.end(); ++i)
      if (!strncasecmp(sym,(*i)->GetSymbol(),2))
        return((*i)->GetAtomicNum());

    if (strcasecmp(sym, "D") == 0) {
      iso = 2;
      return(1);
    } else if (strcasecmp(sym, "T") == 0) {
      iso = 3;
      return(1);
    } else 
      iso = 0;
    return(0);
  }

  void ElementsTable::Init() {
    if (init_)
      return;
    init_ = true;
    
    std::string buffer, subbuffer;
    ifstrstream ifs1, ifs2, ifs3, ifs4, *ifsP;
    // First, look for an environment variable
    if (getenv(envvar_.c_str()) != NULL) {
      buffer = getenv(envvar_.c_str());
      buffer += FILE_SEP_CHAR;
      

      if (!subdir_.empty()) {
        subbuffer = buffer;
        subbuffer += subdir_;
        subbuffer += FILE_SEP_CHAR;
      }
      

      buffer += filename_;
      subbuffer += filename_;

      
      ifs1.open(subbuffer.c_str());
      ifsP= &ifs1;
      if (!(ifsP->is_open())) {
        ifs2.open(buffer.c_str());
        ifsP = &ifs2;
      }
      
    } else {
      sprintf( painCave.errMsg,
               "ElementsTable error.\n"
               "\tunable to open datafile %s \n", filename_.c_str());
      painCave.isFatal = 0;
      simError();
    }
      

    if ((*ifsP)) {
      char charBuffer[BUFF_SIZE];
      while(ifsP->getline(charBuffer,BUFF_SIZE))
        ParseLine(charBuffer);
      
      if (ifs1)
        ifs1.close();
      if (ifs2)
        ifs2.close();
      if (ifs3)
        ifs3.close();
      if (ifs4)
        ifs4.close();
      
      if (GetSize() == 0) {
        sprintf( painCave.errMsg,
                 "ElementsTable error.\n"
                 "\tCannot initialize database %s \n", filename_.c_str());
        painCave.isFatal = 0;
        simError();
      }
    
    }
  
  }
}
Revision:	1874
Committed:	Wed May 15 15:09:35 2013 UTC (11 years, 11 months ago) by gezelter
File size:	8372 byte(s)
Log Message:	Fixed a bunch of cppcheck warnings.
#	User	Rev	Content
1	gezelter	1210	/**********************************************************************
2
3			This basic Periodic Table class was originally taken from the data.cpp
4	gezelter	1390	file in OpenBabel. The code has been modified to match the OpenMD coding style.
5	gezelter	1210
6			We have retained the OpenBabel copyright and GPL license on this class:
7
8			Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
9			Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
10
11			This file is part of the Open Babel project.
12			For more information, see <http://openbabel.sourceforge.net/>
13
14			This program is free software; you can redistribute it and/or modify
15			it under the terms of the GNU General Public License as published by
16			the Free Software Foundation version 2 of the License.
17
18			This program is distributed in the hope that it will be useful,
19			but WITHOUT ANY WARRANTY; without even the implied warranty of
20			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21			GNU General Public License for more details.
22			***********************************************************************/
23
24			/**
25			* @file ElementsTable.cpp
26			* @author gezelter
27			* @date 12/21/2007
28			* @version 1.0
29			*/
30
31	gezelter	1767	#include "config.h"
32
33	chuckv	1293	#include <iostream>
34	cli2	1290	#include <cstdlib>
35	gezelter	1210	#include <string>
36			#include <fstream>
37	gezelter	1291	#include <cstdlib>
38	gezelter	1210	#include "utils/ElementsTable.hpp"
39			#include "utils/simError.h"
40	gezelter	1627	#include "io/ifstrstream.hpp"
41	gezelter	1210
42	gezelter	1767	#ifdef _MSC_VER
43			#define strncasecmp _strnicmp
44			#define strcasecmp _stricmp
45	gezelter	1210	#endif
46
47	gezelter	1767
48	gezelter	1210	#ifdef WIN32
49			#define FILE_SEP_CHAR "\\"
50			#else
51			#define FILE_SEP_CHAR "/"
52			#endif
53
54			#ifndef BUFF_SIZE
55			#define BUFF_SIZE 32768
56			#endif
57
58	gezelter	1390	namespace OpenMD {
59	gezelter	1210
60			ElementsTable etab;
61
62			ElementsTable::ElementsTable() {
63			init_ = false;
64	gezelter	1442	dir_ = std::string("TO_STRING(FRC_PATH)");
65	gezelter	1210	envvar_ = "FORCE_PARAM_PATH";
66			filename_ = "element.txt";
67			}
68
69			ElementsTable::~ElementsTable() {
70			std::vector<Element*>::iterator i;
71	gezelter	1874	for (i = elements_.begin(); i != elements_.end(); ++i)
72	gezelter	1210	delete *i;
73			}
74
75			void ElementsTable::ParseLine(const char *line) {
76			int num, maxbonds;
77	gezelter	1874	char symbol[6];
78	gezelter	1210	char name[256];
79			RealType Rcov,Rvdw,mass, elNeg, ionize, elAffin;
80			RealType red, green, blue;
81
82			// skip comment line (at the top)
83			if (line[0] != '#') {
84			sscanf(line,"%d %5s %lf %*f %lf %d %lf %lf %lf %lf %lf %lf %lf %255s",
85			&num,
86			symbol,
87			&Rcov,
88			&Rvdw,
89			&maxbonds,
90			&mass,
91			&elNeg,
92			&ionize,
93			&elAffin,
94			&red,
95			&green,
96			&blue,
97			name);
98
99			Element *ele = new Element(num, symbol, Rcov, Rvdw, maxbonds, mass,
100			elNeg, ionize, elAffin, red, green, blue,
101			name);
102			elements_.push_back(ele);
103	chuckv	1293
104	gezelter	1210	}
105			}
106
107			unsigned int ElementsTable::GetNumberOfElements() {
108			if (!init_)
109			Init();
110
111			return elements_.size();
112			}
113
114	skuang	1305	const char *ElementsTable::GetSymbol(int atomicnum) {
115	gezelter	1210	if (!init_)
116			Init();
117
118			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
119			return("\0");
120
121			return(elements_[atomicnum]->GetSymbol());
122			}
123
124			int ElementsTable::GetMaxBonds(int atomicnum) {
125			if (!init_)
126			Init();
127
128			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
129			return(0);
130
131			return(elements_[atomicnum]->GetMaxBonds());
132			}
133
134			RealType ElementsTable::GetElectroNeg(int atomicnum) {
135			if (!init_)
136			Init();
137
138			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
139			return(0.0);
140
141			return(elements_[atomicnum]->GetElectroNeg());
142			}
143
144			RealType ElementsTable::GetIonization(int atomicnum) {
145			if (!init_)
146			Init();
147
148			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
149			return(0.0);
150
151			return(elements_[atomicnum]->GetIonization());
152			}
153
154
155			RealType ElementsTable::GetElectronAffinity(int atomicnum) {
156			if (!init_)
157			Init();
158
159			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
160			return(0.0);
161
162			return(elements_[atomicnum]->GetElectronAffinity());
163			}
164
165			std::vector<RealType> ElementsTable::GetRGB(int atomicnum) {
166			if (!init_)
167			Init();
168
169			std::vector <RealType> colors;
170			colors.reserve(3);
171
172			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size())) {
173			colors.push_back(0.0);
174			colors.push_back(0.0);
175			colors.push_back(0.0);
176			return(colors);
177			}
178
179			colors.push_back(elements_[atomicnum]->GetRed());
180			colors.push_back(elements_[atomicnum]->GetGreen());
181			colors.push_back(elements_[atomicnum]->GetBlue());
182
183			return (colors);
184			}
185
186			std::string ElementsTable::GetName(int atomicnum) {
187			if (!init_)
188			Init();
189
190			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
191			return("Unknown");
192
193			return(elements_[atomicnum]->GetName());
194			}
195
196			RealType ElementsTable::GetVdwRad(int atomicnum) {
197			if (!init_)
198			Init();
199
200			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
201			return(0.0);
202
203			return(elements_[atomicnum]->GetVdwRad());
204			}
205
206			RealType ElementsTable::CorrectedBondRad(int atomicnum, int hyb) {
207			RealType rad;
208			if (!init_)
209			Init();
210
211			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
212			return(1.0);
213
214			rad = elements_[atomicnum]->GetCovalentRad();
215
216			if (hyb == 2)
217			rad *= 0.95;
218			else if (hyb == 1)
219			rad *= 0.90;
220
221			return(rad);
222			}
223
224			RealType ElementsTable::CorrectedVdwRad(int atomicnum, int hyb) {
225			RealType rad;
226			if (!init_)
227			Init();
228
229			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
230			return(1.95);
231
232			rad = elements_[atomicnum]->GetVdwRad();
233
234			if (hyb == 2)
235			rad *= 0.95;
236			else if (hyb == 1)
237			rad *= 0.90;
238
239			return(rad);
240			}
241
242			RealType ElementsTable::GetCovalentRad(int atomicnum) {
243			if (!init_)
244			Init();
245
246			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
247			return(0.0);
248
249			return(elements_[atomicnum]->GetCovalentRad());
250			}
251
252			RealType ElementsTable::GetMass(int atomicnum) {
253			if (!init_)
254			Init();
255
256			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
257			return(0.0);
258
259			return(elements_[atomicnum]->GetMass());
260			}
261
262			int ElementsTable::GetAtomicNum(const char *sym) {
263			int temp;
264			return GetAtomicNum(sym, temp);
265			}
266
267			int ElementsTable::GetAtomicNum(const char *sym, int &iso) {
268			if (!init_)
269			Init();
270
271			std::vector<Element*>::iterator i;
272	gezelter	1874	for (i = elements_.begin();i != elements_.end(); ++i)
273	gezelter	1210	if (!strncasecmp(sym,(*i)->GetSymbol(),2))
274			return((*i)->GetAtomicNum());
275
276			if (strcasecmp(sym, "D") == 0) {
277			iso = 2;
278			return(1);
279			} else if (strcasecmp(sym, "T") == 0) {
280			iso = 3;
281			return(1);
282			} else
283			iso = 0;
284			return(0);
285			}
286
287			void ElementsTable::Init() {
288			if (init_)
289			return;
290			init_ = true;
291
292			std::string buffer, subbuffer;
293	chuckv	1224	ifstrstream ifs1, ifs2, ifs3, ifs4, *ifsP;
294	gezelter	1210	// First, look for an environment variable
295			if (getenv(envvar_.c_str()) != NULL) {
296			buffer = getenv(envvar_.c_str());
297			buffer += FILE_SEP_CHAR;
298
299	chuckv	1296
300
301
302	gezelter	1210	if (!subdir_.empty()) {
303			subbuffer = buffer;
304			subbuffer += subdir_;
305			subbuffer += FILE_SEP_CHAR;
306			}
307
308	chuckv	1296
309
310	gezelter	1210	buffer += filename_;
311			subbuffer += filename_;
312	chuckv	1296
313	gezelter	1210
314			ifs1.open(subbuffer.c_str());
315			ifsP= &ifs1;
316	chuckv	1296	if (!(ifsP->is_open())) {
317	gezelter	1210	ifs2.open(buffer.c_str());
318			ifsP = &ifs2;
319			}
320	chuckv	1296
321	gezelter	1210	} else {
322			sprintf( painCave.errMsg,
323			"ElementsTable error.\n"
324			"\tunable to open datafile %s \n", filename_.c_str());
325			painCave.isFatal = 0;
326			simError();
327			}
328
329	gezelter	1874
330	gezelter	1210	if ((*ifsP)) {
331	gezelter	1874	char charBuffer[BUFF_SIZE];
332	gezelter	1210	while(ifsP->getline(charBuffer,BUFF_SIZE))
333			ParseLine(charBuffer);
334	gezelter	1874
335	chuckv	1293	if (ifs1)
336			ifs1.close();
337			if (ifs2)
338			ifs2.close();
339			if (ifs3)
340			ifs3.close();
341			if (ifs4)
342			ifs4.close();
343
344			if (GetSize() == 0) {
345			sprintf( painCave.errMsg,
346			"ElementsTable error.\n"
347			"\tCannot initialize database %s \n", filename_.c_str());
348			painCave.isFatal = 0;
349			simError();
350			}
351	gezelter	1210
352			}
353
354			}
355			}