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 OOPSE 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 <cstdlib>
#include <string>
#include <fstream>
#include <cstdlib>
#include "utils/ElementsTable.hpp"
#include "utils/simError.h"
#include "io/basic_ifstrstream.hpp"

#if !HAVE_STRNCASECMP
extern "C" int strncasecmp(const char *s1, const char *s2, size_t n);
#endif

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

#ifndef BUFF_SIZE
#define BUFF_SIZE 32768
#endif

namespace oopse {

  ElementsTable etab;

  ElementsTable::ElementsTable() {
    init_ = false;
    STR_DEFINE(dir_, 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();
  }

  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)) {
        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:	3448
Committed:	Thu Sep 11 19:40:59 2008 UTC (15 years, 9 months ago) by gezelter
File size:	8389 byte(s)
Log Message:	Added some logic to print out a special pair distance as a column in the stat file. To use this feature, use taggedAtomPair = "0, 10" and printTaggedPairDistance = "true" in the md file. Then, the distance between integrableObjects 0 and 10 will be computed and printed in the stat file on each statWrite.
#	Content
1	/**********************************************************************
2
3	This basic Periodic Table class was originally taken from the data.cpp
4	file in OpenBabel. The code has been modified to match the OOPSE coding style.
5
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	#include "config.h"
33	#include <cstdlib>
34	#include <string>
35	#include <fstream>
36	#include <cstdlib>
37	#include "utils/ElementsTable.hpp"
38	#include "utils/simError.h"
39	#include "io/basic_ifstrstream.hpp"
40
41	#if !HAVE_STRNCASECMP
42	extern "C" int strncasecmp(const char s1, const char s2, size_t n);
43	#endif
44
45	#ifdef WIN32
46	#define FILE_SEP_CHAR "\\"
47	#else
48	#define FILE_SEP_CHAR "/"
49	#endif
50
51	#ifndef BUFF_SIZE
52	#define BUFF_SIZE 32768
53	#endif
54
55	namespace oopse {
56
57	ElementsTable etab;
58
59	ElementsTable::ElementsTable() {
60	init_ = false;
61	STR_DEFINE(dir_, FRC_PATH );
62	envvar_ = "FORCE_PARAM_PATH";
63	filename_ = "element.txt";
64	}
65
66	ElementsTable::~ElementsTable() {
67	std::vector<Element*>::iterator i;
68	for (i = elements_.begin(); i != elements_.end(); i++)
69	delete *i;
70	}
71
72	void ElementsTable::ParseLine(const char *line) {
73	int num, maxbonds;
74	char symbol[5];
75	char name[256];
76	RealType Rcov,Rvdw,mass, elNeg, ionize, elAffin;
77	RealType red, green, blue;
78
79	// skip comment line (at the top)
80
81	if (line[0] != '#') {
82	sscanf(line,"%d %5s %lf %*f %lf %d %lf %lf %lf %lf %lf %lf %lf %255s",
83	&num,
84	symbol,
85	&Rcov,
86	&Rvdw,
87	&maxbonds,
88	&mass,
89	&elNeg,
90	&ionize,
91	&elAffin,
92	&red,
93	&green,
94	&blue,
95	name);
96
97	Element *ele = new Element(num, symbol, Rcov, Rvdw, maxbonds, mass,
98	elNeg, ionize, elAffin, red, green, blue,
99	name);
100	elements_.push_back(ele);
101	}
102	}
103
104	unsigned int ElementsTable::GetNumberOfElements() {
105	if (!init_)
106	Init();
107
108	return elements_.size();
109	}
110
111	char *ElementsTable::GetSymbol(int atomicnum) {
112	if (!init_)
113	Init();
114
115	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
116	return("\0");
117
118	return(elements_[atomicnum]->GetSymbol());
119	}
120
121	int ElementsTable::GetMaxBonds(int atomicnum) {
122	if (!init_)
123	Init();
124
125	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
126	return(0);
127
128	return(elements_[atomicnum]->GetMaxBonds());
129	}
130
131	RealType ElementsTable::GetElectroNeg(int atomicnum) {
132	if (!init_)
133	Init();
134
135	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
136	return(0.0);
137
138	return(elements_[atomicnum]->GetElectroNeg());
139	}
140
141	RealType ElementsTable::GetIonization(int atomicnum) {
142	if (!init_)
143	Init();
144
145	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
146	return(0.0);
147
148	return(elements_[atomicnum]->GetIonization());
149	}
150
151
152	RealType ElementsTable::GetElectronAffinity(int atomicnum) {
153	if (!init_)
154	Init();
155
156	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
157	return(0.0);
158
159	return(elements_[atomicnum]->GetElectronAffinity());
160	}
161
162	std::vector<RealType> ElementsTable::GetRGB(int atomicnum) {
163	if (!init_)
164	Init();
165
166	std::vector <RealType> colors;
167	colors.reserve(3);
168
169	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size())) {
170	colors.push_back(0.0);
171	colors.push_back(0.0);
172	colors.push_back(0.0);
173	return(colors);
174	}
175
176	colors.push_back(elements_[atomicnum]->GetRed());
177	colors.push_back(elements_[atomicnum]->GetGreen());
178	colors.push_back(elements_[atomicnum]->GetBlue());
179
180	return (colors);
181	}
182
183	std::string ElementsTable::GetName(int atomicnum) {
184	if (!init_)
185	Init();
186
187	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
188	return("Unknown");
189
190	return(elements_[atomicnum]->GetName());
191	}
192
193	RealType ElementsTable::GetVdwRad(int atomicnum) {
194	if (!init_)
195	Init();
196
197	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
198	return(0.0);
199
200	return(elements_[atomicnum]->GetVdwRad());
201	}
202
203	RealType ElementsTable::CorrectedBondRad(int atomicnum, int hyb) {
204	RealType rad;
205	if (!init_)
206	Init();
207
208	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
209	return(1.0);
210
211	rad = elements_[atomicnum]->GetCovalentRad();
212
213	if (hyb == 2)
214	rad *= 0.95;
215	else if (hyb == 1)
216	rad *= 0.90;
217
218	return(rad);
219	}
220
221	RealType ElementsTable::CorrectedVdwRad(int atomicnum, int hyb) {
222	RealType rad;
223	if (!init_)
224	Init();
225
226	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
227	return(1.95);
228
229	rad = elements_[atomicnum]->GetVdwRad();
230
231	if (hyb == 2)
232	rad *= 0.95;
233	else if (hyb == 1)
234	rad *= 0.90;
235
236	return(rad);
237	}
238
239	RealType ElementsTable::GetCovalentRad(int atomicnum) {
240	if (!init_)
241	Init();
242
243	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
244	return(0.0);
245
246	return(elements_[atomicnum]->GetCovalentRad());
247	}
248
249	RealType ElementsTable::GetMass(int atomicnum) {
250	if (!init_)
251	Init();
252
253	if (atomicnum < 0 \|\| atomicnum > static_cast<int>(elements_.size()))
254	return(0.0);
255
256	return(elements_[atomicnum]->GetMass());
257	}
258
259	int ElementsTable::GetAtomicNum(const char *sym) {
260	int temp;
261	return GetAtomicNum(sym, temp);
262	}
263
264	int ElementsTable::GetAtomicNum(const char *sym, int &iso) {
265	if (!init_)
266	Init();
267
268	std::vector<Element*>::iterator i;
269	for (i = elements_.begin();i != elements_.end();i++)
270	if (!strncasecmp(sym,(*i)->GetSymbol(),2))
271	return((*i)->GetAtomicNum());
272
273	if (strcasecmp(sym, "D") == 0) {
274	iso = 2;
275	return(1);
276	} else if (strcasecmp(sym, "T") == 0) {
277	iso = 3;
278	return(1);
279	} else
280	iso = 0;
281	return(0);
282	}
283
284	void ElementsTable::Init() {
285	if (init_)
286	return;
287	init_ = true;
288
289	std::string buffer, subbuffer;
290	ifstrstream ifs1, ifs2, ifs3, ifs4, *ifsP;
291	// First, look for an environment variable
292	if (getenv(envvar_.c_str()) != NULL) {
293	buffer = getenv(envvar_.c_str());
294	buffer += FILE_SEP_CHAR;
295
296	if (!subdir_.empty()) {
297	subbuffer = buffer;
298	subbuffer += subdir_;
299	subbuffer += FILE_SEP_CHAR;
300	}
301
302	buffer += filename_;
303	subbuffer += filename_;
304
305	ifs1.open(subbuffer.c_str());
306	ifsP= &ifs1;
307	if (!(*ifsP)) {
308	ifs2.open(buffer.c_str());
309	ifsP = &ifs2;
310	}
311	} else {
312	sprintf( painCave.errMsg,
313	"ElementsTable error.\n"
314	"\tunable to open datafile %s \n", filename_.c_str());
315	painCave.isFatal = 0;
316	simError();
317	}
318
319	char charBuffer[BUFF_SIZE];
320	if ((*ifsP)) {
321	while(ifsP->getline(charBuffer,BUFF_SIZE))
322	ParseLine(charBuffer);
323
324	if (ifs1)
325	ifs1.close();
326	if (ifs2)
327	ifs2.close();
328	if (ifs3)
329	ifs3.close();
330	if (ifs4)
331	ifs4.close();
332
333	if (GetSize() == 0) {
334	sprintf( painCave.errMsg,
335	"ElementsTable error.\n"
336	"\tCannot initialize database %s \n", filename_.c_str());
337	painCave.isFatal = 0;
338	simError();
339	}
340
341	}
342
343	}
344	}