src/io/EAMAtomTypesSectionParser.cpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
 
#include "io/EAMAtomTypesSectionParser.hpp"

namespace oopse {

EAMAtomTypesSectionParser::EAMAtomTypesSectionParser() {
    setSectionName("EAMAtomTypes");
}

void EAMAtomTypesSectionParser::parseLine(ForceField& ff,const std::string& line, int lineNo){
            AtomType* atomType;
            std::string atomTypeName;
            double mass;        
            StringTokenizer tokenizer(line);
            
            if (tokenizer.countTokens() >= 2) {
                atomTypeName = tokenizer.nextToken();
                std::string potentialParamFile = tokenizer.nextToken();

                AtomType* atomType = ff.getAtomType(atomTypeName);
                if (atomType != NULL) {
                    atomType->setEAM();                            
                    parseEAMParamFile(atomType, potentialParamFile, atomType->getIdent());                                                    
                } else {

                }
                
            } else {
                sprintf( painCave.errMsg,
                       "Not enough tokens when parsing EAM Force Field : %s\n"
                       "in line %d : %s\n",
                       filename.c_str(), lineNo, line);
                painCave.severity = OOPSE_ERROR;
                painCave.isFatal = 1;
                simError();                
            }
            

}

void EAMAtomTypesSectionParser::parseEAMParamFile(AtomType* atomType, 
    const std::string& potentialParamFile, int ident) {

    ifstrstream* ppfStream;
    ppfStream = openForceFiledFile(potentialParamFile);
    const int bufferSize = 65535;
    char buffer[bufferSize];
    std::string line;

    //skip first line
    ppfStream->getline(buffer, bufferSize);


    //The Second line contains atomic number, atomic mass, a lattice constant and lattic type
    int junk;
    double mass;
    double latticeConstant; 
    std::string lattice;
    if (ppfStream->getline(buffer, bufferSize)) {       
        StringTokenizer tokenizer1(buffer);
        ident = tokenizer1.nextTokenAsInt();
        
        if (tokenizer1.countTokens() >= 4) {
            junk = tokenizer1.nextTokenAsInt();
            mass = tokenizer1.nextTokenAsDouble();
            latticeConstant = tokenizer1.nextTokenAsDouble();
            lattice = tokenizer1.nextToken();
        }else {
            std::cerr << "Not enought tokens" << std::endl;
        }
    } else {

    }
    
    // The third line is nrho, drho, nr, dr and rcut
    EAMParam eamParam;
    eamParam.latticeConstant = latticeConstant;
    
    if (ppfStream->getline(buffer, bufferSize)) {
        StringTokenizer tokenizer2(buffer);

        if (tokenizer2.countTokens() >= 5){
            eamParam.nrho = tokenizer2.nextTokenAsInt();
            eamParam.drho = tokenizer2.nextTokenAsDouble();
            eamParam.nr = tokenizer2.nextTokenAsInt();
            eamParam.dr = tokenizer2.nextTokenAsDouble();
            eamParam.rcut = tokenizer2.nextTokenAsDouble();
        }else {
            std::cerr << "Not enought tokens" << std::endl;
        }
    } else {

    }
    
    parseEAMArray(ppfStream, eamParam.rvals, eamParam.nr);
    parseEAMArray(ppfStream, eamParam.rhovals, eamParam.nr);
    parseEAMArray(ppfStream, eamParam.Frhovals, eamParam.nrho);
    
    atomType->addProperty(EAMParamGenericData("EAM", eamParam));
}

void EAMAtomTypesSectionParser::parseEAMArray(ifstrstream* ppfStream, 
    std::vector<double>& array, int num) {
    
    const int dataPerLine = 5;
    if (num % dataPerLine != 0) {

    }
    
    const int bufferSize = 65535;
    char buffer[bufferSize];
    std::string line;
    int readLines = num/dataPerLine;
    int lineCount = 0;
    while(ffStream.getline(buffer, bufferSize) && lineCount < num){

        StringTokenizer tokenizer(buffer);
        if (tokenizer.countTokens() >= dataPerLine) {
            for (int i = 0; i < dataPerLine; ++i) {
                array.push_back(tokenizer.nextTokenAsDouble()));
            }
        } else {

        }
        ++lineCount;
    }

    if (lineCount < num) {
        
    }
    
}


} //end namespace oopse

Revision:	1770
Committed:	Tue Nov 23 17:53:43 2004 UTC (19 years, 7 months ago) by tim
File size:	5281 byte(s)
Log Message:	add Electrostatic AtomType Section Parser
#	Content
1	/*
2	* Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project
3	*
4	* Contact: oopse@oopse.org
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public License
8	* as published by the Free Software Foundation; either version 2.1
9	* of the License, or (at your option) any later version.
10	* All we ask is that proper credit is given for our work, which includes
11	* - but is not limited to - adding the above copyright notice to the beginning
12	* of your source code files, and to any copyright notice that you may distribute
13	* with programs based on this work.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU Lesser General Public License for more details.
19	*
20	* You should have received a copy of the GNU Lesser General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23	*
24	*/
25
26	#include "io/EAMAtomTypesSectionParser.hpp"
27
28	namespace oopse {
29
30	EAMAtomTypesSectionParser::EAMAtomTypesSectionParser() {
31	setSectionName("EAMAtomTypes");
32	}
33
34	void EAMAtomTypesSectionParser::parseLine(ForceField& ff,const std::string& line, int lineNo){
35	AtomType* atomType;
36	std::string atomTypeName;
37	double mass;
38	StringTokenizer tokenizer(line);
39
40	if (tokenizer.countTokens() >= 2) {
41	atomTypeName = tokenizer.nextToken();
42	std::string potentialParamFile = tokenizer.nextToken();
43
44	AtomType* atomType = ff.getAtomType(atomTypeName);
45	if (atomType != NULL) {
46	atomType->setEAM();
47	parseEAMParamFile(atomType, potentialParamFile, atomType->getIdent());
48	} else {
49
50	}
51
52	} else {
53	sprintf( painCave.errMsg,
54	"Not enough tokens when parsing EAM Force Field : %s\n"
55	"in line %d : %s\n",
56	filename.c_str(), lineNo, line);
57	painCave.severity = OOPSE_ERROR;
58	painCave.isFatal = 1;
59	simError();
60	}
61
62
63	}
64
65	void EAMAtomTypesSectionParser::parseEAMParamFile(AtomType* atomType,
66	const std::string& potentialParamFile, int ident) {
67
68	ifstrstream* ppfStream;
69	ppfStream = openForceFiledFile(potentialParamFile);
70	const int bufferSize = 65535;
71	char buffer[bufferSize];
72	std::string line;
73
74	//skip first line
75	ppfStream->getline(buffer, bufferSize);
76
77
78	//The Second line contains atomic number, atomic mass, a lattice constant and lattic type
79	int junk;
80	double mass;
81	double latticeConstant;
82	std::string lattice;
83	if (ppfStream->getline(buffer, bufferSize)) {
84	StringTokenizer tokenizer1(buffer);
85	ident = tokenizer1.nextTokenAsInt();
86
87	if (tokenizer1.countTokens() >= 4) {
88	junk = tokenizer1.nextTokenAsInt();
89	mass = tokenizer1.nextTokenAsDouble();
90	latticeConstant = tokenizer1.nextTokenAsDouble();
91	lattice = tokenizer1.nextToken();
92	}else {
93	std::cerr << "Not enought tokens" << std::endl;
94	}
95	} else {
96
97	}
98
99	// The third line is nrho, drho, nr, dr and rcut
100	EAMParam eamParam;
101	eamParam.latticeConstant = latticeConstant;
102
103	if (ppfStream->getline(buffer, bufferSize)) {
104	StringTokenizer tokenizer2(buffer);
105
106	if (tokenizer2.countTokens() >= 5){
107	eamParam.nrho = tokenizer2.nextTokenAsInt();
108	eamParam.drho = tokenizer2.nextTokenAsDouble();
109	eamParam.nr = tokenizer2.nextTokenAsInt();
110	eamParam.dr = tokenizer2.nextTokenAsDouble();
111	eamParam.rcut = tokenizer2.nextTokenAsDouble();
112	}else {
113	std::cerr << "Not enought tokens" << std::endl;
114	}
115	} else {
116
117	}
118
119	parseEAMArray(ppfStream, eamParam.rvals, eamParam.nr);
120	parseEAMArray(ppfStream, eamParam.rhovals, eamParam.nr);
121	parseEAMArray(ppfStream, eamParam.Frhovals, eamParam.nrho);
122
123	atomType->addProperty(EAMParamGenericData("EAM", eamParam));
124	}
125
126	void EAMAtomTypesSectionParser::parseEAMArray(ifstrstream* ppfStream,
127	std::vector<double>& array, int num) {
128
129	const int dataPerLine = 5;
130	if (num % dataPerLine != 0) {
131
132	}
133
134	const int bufferSize = 65535;
135	char buffer[bufferSize];
136	std::string line;
137	int readLines = num/dataPerLine;
138	int lineCount = 0;
139	while(ffStream.getline(buffer, bufferSize) && lineCount < num){
140
141	StringTokenizer tokenizer(buffer);
142	if (tokenizer.countTokens() >= dataPerLine) {
143	for (int i = 0; i < dataPerLine; ++i) {
144	array.push_back(tokenizer.nextTokenAsDouble()));
145	}
146	} else {
147
148	}
149	++lineCount;
150	}
151
152	if (lineCount < num) {
153
154	}
155
156	}
157
158
159	} //end namespace oopse
160