src/types/AtomType.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>

#include "types/AtomType.hpp"
#include "utils/simError.h"
#define __C
#include "UseTheForce/DarkSide/atype_interface.h"

name_space oopse {
  AtomType::AtomType(){
    
    // initialize to an error:
    atp_.ident = -1;

    // and mass_less:
    mass_ = 0.0;
    
    // atom type is a Tabula Rasa:
    atp_.is_Directional = 0;
    atp_.is_LennardJones = 0;
    atp_.is_Electrostatic = 0;
    atp_.is_Charge = 0;
    atp_.is_Dipole = 0;
    atp_.is_Sticky = 0;
    atp_.is_GayBerne = 0;
    atp_.is_EAM = 0;
    atp_.is_Shape = 0;
    atp_.is_FLARB = 0;  
  }
    
  void AtomType::makeFortranAtomType() {
    
    int status;

    if (name_.empty()) {
      sprintf( painCave.errMsg,
               "Attempting to complete an AtomType without giving "
               "it a name_!\n");
      painCave.severity = OOPSE_ERROR;
      painCave.isFatal = 1;
      simError();
    }
    
    if (atp_.ident == -1) {
      sprintf( painCave.errMsg,
               "Attempting to complete AtomType %s without setting the"
               " ident!/n", name_.c_str());
      painCave.severity = OOPSE_ERROR;
      painCave.isFatal = 1;
      simError();          
    }
 
    status = 0;

    makeAtype(&atp_, &status);   
    
    if (status != 0) {
      sprintf( painCave.errMsg,
               "Fortran rejected AtomType %s!\n", name_.c_str());
      painCave.severity = OOPSE_ERROR;
      painCave.isFatal = 1;
      simError();          
    }
  }


void AtomType::complete() {
    int isError;
    GenericData* data;
    
    //notify a new LJtype atom type is created
    if (isLennardJones()) {
        data = getPropertyByName("LennardJones");
        if (data != NULL) {
            LJParamGenericData* ljData = dynamic_cast<LJParamGenericData*>(data);

            if (ljData != NULL) {
                LJParam ljParam = ljData->getData();
                
                newLJtype(&atp_.ident, &ljParam.sigma, &ljParam.epsilon, &isError);

                if (isError != 0) {
                    sprintf( painCave.errMsg,
                           "Fortran rejected newLJtype\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
                }
                
            } else {
                    sprintf( painCave.errMsg,
                           "Can not cast GenericData to LJParam\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
            }            
        } else {
            sprintf( painCave.errMsg, "Can not find Parameters for LennardJones\n");
            painCave.severity = OOPSE_ERROR;
            painCave.isFatal = 1;
            simError();          
        }
    }

    if (isCharge()) {
        data = getPropertyByName("Charge");
        if (data != NULL) {
            DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data);

            if (doubleData != NULL) {
                double charge = doubleData->getData();
                newChargeType(&atp_.ident,, &charge, &isError);

                if (isError != 0) {
                    sprintf( painCave.errMsg,
                           "Fortran rejected newChargeType\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
                }
            } else {
                    sprintf( painCave.errMsg,
                           "Can not cast GenericData to DoubleGenericData\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
            }
        } else {
            sprintf( painCave.errMsg, "Can not find Charge Parameters\n");
            painCave.severity = OOPSE_ERROR;
            painCave.isFatal = 1;
            simError();          
        }
    }

    if (isEAM()) {
        data = getPropertyByName("EAM");
        if (data != NULL) {
            EAMParamGenericData* eamData = dynamic_cast<EAMParamGenericData*>(data);

            if (eamData != NULL) {

                EAMParam eamParam = eamData->getData();
                

                newEAMtype(&eamParam.latticeConstant, &eamParam.nrho, &eamParam.drho,  &eamParam.nr, &eamParam.dr, &eamParam.rcut,
                                &eamParam.rvals[0], &eamParam.rhovals[0], &eamParam.Frhovals[0], &atp_.ident,, &isError );

                if (isError != 0) {
                    sprintf( painCave.errMsg,
                           "Fortran rejected newEAMtype\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
                }
            } else {
                    sprintf( painCave.errMsg,
                           "Can not cast GenericData to EAMParam\n");
                    painCave.severity = OOPSE_ERROR;
                    painCave.isFatal = 1;
                    simError();          
            }
        } else {
            sprintf( painCave.errMsg, "Can not find EAM Parameters\n");
            painCave.severity = OOPSE_ERROR;
            painCave.isFatal = 1;
            simError();          
        }
    }

    
}

void AtomType::addProperty(GenericData* genData) {
    properties_.addProperty(genData);  
}

void AtomType::removeProperty(const std::string& propName) {
    properties_.removeProperty(propName);  
}

void AtomType::clearProperties() {
    properties_.clearProperties(); 
}

std::vector<std::string> AtomType::getPropertyNames() {
    return properties_.getPropertyNames();  
}
      
std::vector<GenericData*> AtomType::getProperties() { 
    return properties_.getProperties(); 
}

GenericData* AtomType::getPropertyByName(const std::string& propName) {
    return properties_.getPropertyByName(propName); 
}  
}
Revision:	1769
Committed:	Tue Nov 23 06:03:47 2004 UTC (19 years, 9 months ago) by tim
File size:	5994 byte(s)
Log Message:	add EAM AtomType Section Parser
#	User	Rev	Content
1	gezelter	1632	#include <stdlib.h>
2			#include <stdio.h>
3			#include <string.h>
4			#include <iostream>
5
6			#include "types/AtomType.hpp"
7			#include "utils/simError.h"
8			#define __C
9			#include "UseTheForce/DarkSide/atype_interface.h"
10
11	tim	1740	name_space oopse {
12	gezelter	1632	AtomType::AtomType(){
13
14			// initialize to an error:
15	tim	1740	atp_.ident = -1;
16	gezelter	1652
17	tim	1740	// and mass_less:
18			mass_ = 0.0;
19	gezelter	1632
20			// atom type is a Tabula Rasa:
21	tim	1740	atp_.is_Directional = 0;
22			atp_.is_LennardJones = 0;
23			atp_.is_Electrostatic = 0;
24			atp_.is_Charge = 0;
25			atp_.is_Dipole = 0;
26			atp_.is_Sticky = 0;
27			atp_.is_GayBerne = 0;
28			atp_.is_EAM = 0;
29			atp_.is_Shape = 0;
30			atp_.is_FLARB = 0;
31	gezelter	1632	}
32
33	tim	1769	void AtomType::makeFortranAtomType() {
34	gezelter	1632
35			int status;
36
37	tim	1740	if (name_.empty()) {
38	gezelter	1632	sprintf( painCave.errMsg,
39			"Attempting to complete an AtomType without giving "
40	tim	1740	"it a name_!\n");
41	gezelter	1632	painCave.severity = OOPSE_ERROR;
42			painCave.isFatal = 1;
43			simError();
44			}
45
46	tim	1740	if (atp_.ident == -1) {
47	gezelter	1632	sprintf( painCave.errMsg,
48			"Attempting to complete AtomType %s without setting the"
49	tim	1740	" ident!/n", name_.c_str());
50	gezelter	1632	painCave.severity = OOPSE_ERROR;
51			painCave.isFatal = 1;
52			simError();
53			}
54
55			status = 0;
56
57	tim	1740	makeAtype(&atp_, &status);
58	gezelter	1632
59			if (status != 0) {
60			sprintf( painCave.errMsg,
61	tim	1740	"Fortran rejected AtomType %s!\n", name_.c_str());
62	gezelter	1632	painCave.severity = OOPSE_ERROR;
63			painCave.isFatal = 1;
64			simError();
65			}
66			}
67	tim	1740
68	tim	1769
69			void AtomType::complete() {
70			int isError;
71			GenericData* data;
72
73			//notify a new LJtype atom type is created
74			if (isLennardJones()) {
75			data = getPropertyByName("LennardJones");
76			if (data != NULL) {
77			LJParamGenericData* ljData = dynamic_cast<LJParamGenericData*>(data);
78
79			if (ljData != NULL) {
80			LJParam ljParam = ljData->getData();
81
82			newLJtype(&atp_.ident, &ljParam.sigma, &ljParam.epsilon, &isError);
83
84			if (isError != 0) {
85			sprintf( painCave.errMsg,
86			"Fortran rejected newLJtype\n");
87			painCave.severity = OOPSE_ERROR;
88			painCave.isFatal = 1;
89			simError();
90			}
91
92			} else {
93			sprintf( painCave.errMsg,
94			"Can not cast GenericData to LJParam\n");
95			painCave.severity = OOPSE_ERROR;
96			painCave.isFatal = 1;
97			simError();
98			}
99			} else {
100			sprintf( painCave.errMsg, "Can not find Parameters for LennardJones\n");
101			painCave.severity = OOPSE_ERROR;
102			painCave.isFatal = 1;
103			simError();
104			}
105			}
106
107			if (isCharge()) {
108			data = getPropertyByName("Charge");
109			if (data != NULL) {
110			DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data);
111
112			if (doubleData != NULL) {
113			double charge = doubleData->getData();
114			newChargeType(&atp_.ident,, &charge, &isError);
115
116			if (isError != 0) {
117			sprintf( painCave.errMsg,
118			"Fortran rejected newChargeType\n");
119			painCave.severity = OOPSE_ERROR;
120			painCave.isFatal = 1;
121			simError();
122			}
123			} else {
124			sprintf( painCave.errMsg,
125			"Can not cast GenericData to DoubleGenericData\n");
126			painCave.severity = OOPSE_ERROR;
127			painCave.isFatal = 1;
128			simError();
129			}
130			} else {
131			sprintf( painCave.errMsg, "Can not find Charge Parameters\n");
132			painCave.severity = OOPSE_ERROR;
133			painCave.isFatal = 1;
134			simError();
135			}
136			}
137
138			if (isEAM()) {
139			data = getPropertyByName("EAM");
140			if (data != NULL) {
141			EAMParamGenericData* eamData = dynamic_cast<EAMParamGenericData*>(data);
142
143			if (eamData != NULL) {
144
145			EAMParam eamParam = eamData->getData();
146
147
148			newEAMtype(&eamParam.latticeConstant, &eamParam.nrho, &eamParam.drho, &eamParam.nr, &eamParam.dr, &eamParam.rcut,
149			&eamParam.rvals[0], &eamParam.rhovals[0], &eamParam.Frhovals[0], &atp_.ident,, &isError );
150
151			if (isError != 0) {
152			sprintf( painCave.errMsg,
153			"Fortran rejected newEAMtype\n");
154			painCave.severity = OOPSE_ERROR;
155			painCave.isFatal = 1;
156			simError();
157			}
158			} else {
159			sprintf( painCave.errMsg,
160			"Can not cast GenericData to EAMParam\n");
161			painCave.severity = OOPSE_ERROR;
162			painCave.isFatal = 1;
163			simError();
164			}
165			} else {
166			sprintf( painCave.errMsg, "Can not find EAM Parameters\n");
167			painCave.severity = OOPSE_ERROR;
168			painCave.isFatal = 1;
169			simError();
170			}
171			}
172
173
174			}
175
176	tim	1740	void AtomType::addProperty(GenericData* genData) {
177			properties_.addProperty(genData);
178	gezelter	1632	}
179	tim	1740
180			void AtomType::removeProperty(const std::string& propName) {
181			properties_.removeProperty(propName);
182			}
183
184			void AtomType::clearProperties() {
185			properties_.clearProperties();
186			}
187
188			std::vector<std::string> AtomType::getPropertyNames() {
189			return properties_.getPropertyNames();
190			}
191
192			std::vector<GenericData*> AtomType::getProperties() {
193			return properties_.getProperties();
194			}
195
196			GenericData* AtomType::getPropertyByName(const std::string& propName) {
197			return properties_.getPropertyByName(propName);
198			}
199			}