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
 * @time 11:30am
 * @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[5];
    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();
    }
      
    char charBuffer[BUFF_SIZE];
    if ((*ifsP)) {
      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:	1782
Committed:	Wed Aug 22 02:28:28 2012 UTC (12 years, 8 months ago) by gezelter
File size:	8379 byte(s)
Log Message:	MERGE OpenMD development branch 1465:1781 into trunk
#	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			* @time 11:30am
29			* @version 1.0
30			*/
31
32	gezelter	1782	#include "config.h"
33
34	chuckv	1293	#include <iostream>
35	cli2	1290	#include <cstdlib>
36	gezelter	1210	#include <string>
37			#include <fstream>
38	gezelter	1291	#include <cstdlib>
39	gezelter	1210	#include "utils/ElementsTable.hpp"
40			#include "utils/simError.h"
41	gezelter	1782	#include "io/ifstrstream.hpp"
42	gezelter	1210
43	gezelter	1782	#ifdef _MSC_VER
44			#define strncasecmp _strnicmp
45			#define strcasecmp _stricmp
46	gezelter	1210	#endif
47
48	gezelter	1782
49	gezelter	1210	#ifdef WIN32
50			#define FILE_SEP_CHAR "\\"
51			#else
52			#define FILE_SEP_CHAR "/"
53			#endif
54
55			#ifndef BUFF_SIZE
56			#define BUFF_SIZE 32768
57			#endif
58
59	gezelter	1390	namespace OpenMD {
60	gezelter	1210
61			ElementsTable etab;
62
63			ElementsTable::ElementsTable() {
64			init_ = false;
65	gezelter	1442	dir_ = std::string("TO_STRING(FRC_PATH)");
66	gezelter	1210	envvar_ = "FORCE_PARAM_PATH";
67			filename_ = "element.txt";
68			}
69
70			ElementsTable::~ElementsTable() {
71			std::vector<Element*>::iterator i;
72			for (i = elements_.begin(); i != elements_.end(); i++)
73			delete *i;
74			}
75
76			void ElementsTable::ParseLine(const char *line) {
77			int num, maxbonds;
78			char symbol[5];
79			char name[256];
80			RealType Rcov,Rvdw,mass, elNeg, ionize, elAffin;
81			RealType red, green, blue;
82
83			// skip comment line (at the top)
84			if (line[0] != '#') {
85			sscanf(line,"%d %5s %lf %*f %lf %d %lf %lf %lf %lf %lf %lf %lf %255s",
86			&num,
87			symbol,
88			&Rcov,
89			&Rvdw,
90			&maxbonds,
91			&mass,
92			&elNeg,
93			&ionize,
94			&elAffin,
95			&red,
96			&green,
97			&blue,
98			name);
99
100			Element *ele = new Element(num, symbol, Rcov, Rvdw, maxbonds, mass,
101			elNeg, ionize, elAffin, red, green, blue,
102			name);
103			elements_.push_back(ele);
104	chuckv	1293
105	gezelter	1210	}
106			}
107
108			unsigned int ElementsTable::GetNumberOfElements() {
109			if (!init_)
110			Init();
111
112			return elements_.size();
113			}
114
115	skuang	1305	const char *ElementsTable::GetSymbol(int atomicnum) {
116	gezelter	1210	if (!init_)
117			Init();
118
119			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
120			return("\0");
121
122			return(elements_[atomicnum]->GetSymbol());
123			}
124
125			int ElementsTable::GetMaxBonds(int atomicnum) {
126			if (!init_)
127			Init();
128
129			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
130			return(0);
131
132			return(elements_[atomicnum]->GetMaxBonds());
133			}
134
135			RealType ElementsTable::GetElectroNeg(int atomicnum) {
136			if (!init_)
137			Init();
138
139			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
140			return(0.0);
141
142			return(elements_[atomicnum]->GetElectroNeg());
143			}
144
145			RealType ElementsTable::GetIonization(int atomicnum) {
146			if (!init_)
147			Init();
148
149			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
150			return(0.0);
151
152			return(elements_[atomicnum]->GetIonization());
153			}
154
155
156			RealType ElementsTable::GetElectronAffinity(int atomicnum) {
157			if (!init_)
158			Init();
159
160			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
161			return(0.0);
162
163			return(elements_[atomicnum]->GetElectronAffinity());
164			}
165
166			std::vector<RealType> ElementsTable::GetRGB(int atomicnum) {
167			if (!init_)
168			Init();
169
170			std::vector <RealType> colors;
171			colors.reserve(3);
172
173			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size())) {
174			colors.push_back(0.0);
175			colors.push_back(0.0);
176			colors.push_back(0.0);
177			return(colors);
178			}
179
180			colors.push_back(elements_[atomicnum]->GetRed());
181			colors.push_back(elements_[atomicnum]->GetGreen());
182			colors.push_back(elements_[atomicnum]->GetBlue());
183
184			return (colors);
185			}
186
187			std::string ElementsTable::GetName(int atomicnum) {
188			if (!init_)
189			Init();
190
191			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
192			return("Unknown");
193
194			return(elements_[atomicnum]->GetName());
195			}
196
197			RealType ElementsTable::GetVdwRad(int atomicnum) {
198			if (!init_)
199			Init();
200
201			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
202			return(0.0);
203
204			return(elements_[atomicnum]->GetVdwRad());
205			}
206
207			RealType ElementsTable::CorrectedBondRad(int atomicnum, int hyb) {
208			RealType rad;
209			if (!init_)
210			Init();
211
212			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
213			return(1.0);
214
215			rad = elements_[atomicnum]->GetCovalentRad();
216
217			if (hyb == 2)
218			rad *= 0.95;
219			else if (hyb == 1)
220			rad *= 0.90;
221
222			return(rad);
223			}
224
225			RealType ElementsTable::CorrectedVdwRad(int atomicnum, int hyb) {
226			RealType rad;
227			if (!init_)
228			Init();
229
230			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
231			return(1.95);
232
233			rad = elements_[atomicnum]->GetVdwRad();
234
235			if (hyb == 2)
236			rad *= 0.95;
237			else if (hyb == 1)
238			rad *= 0.90;
239
240			return(rad);
241			}
242
243			RealType ElementsTable::GetCovalentRad(int atomicnum) {
244			if (!init_)
245			Init();
246
247			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
248			return(0.0);
249
250			return(elements_[atomicnum]->GetCovalentRad());
251			}
252
253			RealType ElementsTable::GetMass(int atomicnum) {
254			if (!init_)
255			Init();
256
257			if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
258			return(0.0);
259
260			return(elements_[atomicnum]->GetMass());
261			}
262
263			int ElementsTable::GetAtomicNum(const char *sym) {
264			int temp;
265			return GetAtomicNum(sym, temp);
266			}
267
268			int ElementsTable::GetAtomicNum(const char *sym, int &iso) {
269			if (!init_)
270			Init();
271
272			std::vector<Element*>::iterator i;
273			for (i = elements_.begin();i != elements_.end();i++)
274			if (!strncasecmp(sym,(*i)->GetSymbol(),2))
275			return((*i)->GetAtomicNum());
276
277			if (strcasecmp(sym, "D") == 0) {
278			iso = 2;
279			return(1);
280			} else if (strcasecmp(sym, "T") == 0) {
281			iso = 3;
282			return(1);
283			} else
284			iso = 0;
285			return(0);
286			}
287
288			void ElementsTable::Init() {
289			if (init_)
290			return;
291			init_ = true;
292
293			std::string buffer, subbuffer;
294	chuckv	1224	ifstrstream ifs1, ifs2, ifs3, ifs4, *ifsP;
295	gezelter	1210	// First, look for an environment variable
296			if (getenv(envvar_.c_str()) != NULL) {
297			buffer = getenv(envvar_.c_str());
298			buffer += FILE_SEP_CHAR;
299
300	chuckv	1296
301
302
303	gezelter	1210	if (!subdir_.empty()) {
304			subbuffer = buffer;
305			subbuffer += subdir_;
306			subbuffer += FILE_SEP_CHAR;
307			}
308
309	chuckv	1296
310
311	gezelter	1210	buffer += filename_;
312			subbuffer += filename_;
313	chuckv	1296
314	gezelter	1210
315			ifs1.open(subbuffer.c_str());
316			ifsP= &ifs1;
317	chuckv	1296	if (!(ifsP->is_open())) {
318	gezelter	1210	ifs2.open(buffer.c_str());
319			ifsP = &ifs2;
320			}
321	chuckv	1296
322	gezelter	1210	} else {
323			sprintf( painCave.errMsg,
324			"ElementsTable error.\n"
325			"\tunable to open datafile %s \n", filename_.c_str());
326			painCave.isFatal = 0;
327			simError();
328			}
329
330			char charBuffer[BUFF_SIZE];
331			if ((*ifsP)) {
332			while(ifsP->getline(charBuffer,BUFF_SIZE))
333			ParseLine(charBuffer);
334	chuckv	1296
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			}