src/types/AtomType.hpp

#ifndef TYPES_ATOMTYPE_HPP

#define TYPES_ATOMTYPE_HPP

#include <string>

#include "utils/PropertyMap.hpp"

#define __C
#include "types/AtomTypeProperties.h"
#include "UseTheForce/DarkSide/atype_interface.h"

namespace oopse {
    /**
     * @class AtomType
     * AtomType is what OOPSE looks to for unchanging data about an atom.
     * Things that belong to AtomType are universal properties (i.e. does
     * this atom have a Charge?  What is it's mass_?)  Dynamic properties of
     * an atom are not intended to be properties of an atom type
     */
    class AtomType {
        public:

            AtomType();

            virtual ~AtomType() { } ;

            virtual void complete();

            /**
             * Finishes off the AtomType by communicating the logical portions of the
             * structure to the Fortran atype module
             */
            void makeFortranAtomType();
            
            void setMass(double m) {
                mass_ = m;
            }

            double getMass(void) {
                return mass_;
            }

            void setIdent(int id) {
                atp.ident = id;
            }

            int getIdent() {
                return atp.ident;
            }

            void setName(const std::string&name) {
                name_ = name;
            }

            std::string getName() {
                return name_;
            }

            void setLennardJones() {
                atp.is_LennardJones = 1;
            }

            bool isLennardJones() {
                return atp.is_LennardJones;
            }


            bool isElectrostatic() {
                return isCharge() || isMultipole();
            }

            void setEAM() {
                atp.is_EAM = 1;
            }

            bool isEAM() {
                return atp.is_EAM;
            }

            void setCharge() {
                atp.is_Charge = 1;
            }

            bool isCharge() {
                return atp.is_Charge;
            }

            bool isDirectional() {
                return atp.is_Directional;
            }

            bool isDipole() {
                return atp.is_Dipole;
            }

            bool isQuadrupole() {
                return atp.is_Quadrupole;
            }
            
            bool isMultipole() {
                return isDipole() || isQuadrupole();
            }

            bool isGayBerne() {
                return atp.is_GayBerne;
            }

            bool isSticky() {
                return atp.is_Sticky;
            }

            bool isShape() {
                return atp.is_Shape;
            }

            //below functions are just forward functions
            /**
             * Adds property into property map
             * @param genData GenericData to be added into PropertyMap
             */
            void addProperty(GenericData* genData);

            /**
             * Removes property from PropertyMap by name
             * @param propName the name of property to be removed
             */
            void removeProperty(const std::string& propName);

            /**
             * clear all of the properties
             */
            void clearProperties();

            /**
             * Returns all names of properties
             * @return all names of properties
             */
            std::vector<std::string> getPropertyNames();

            /**
             * Returns all of the properties in PropertyMap
             * @return all of the properties in PropertyMap
             */      
            std::vector<GenericData*> getProperties();

            /**
             * Returns property 
             * @param propName name of property
             * @return a pointer point to property with propName. If no property named propName
             * exists, return NULL
             */      
        GenericData* getPropertyByName(const std::string& propName);

        protected:

            AtomTypeProperties atp;
            double mass_;
            std::string name_;

        private:
            //prevent copy construction and copy assignment, since property map contains
            //pointers which can not be copied and managered safely, except make the generic data
            //at PropertyMap as copy on write shared pointer
            AtomType(const AtomType&);
            AtomType& operator=(const AtomType& atomType);

            
            PropertyMap properties_;
             
    };

    struct LJParam {
        double epsilon;
        double sigma;
    };
    typedef SimpleTypeData<LJParam> LJParamGenericData;

    struct EAMParam {
        double latticeConstant;         
        int nrho;
        double drho;
        int nr;
        double dr;
        double rcut;
        std::vector<double> rvals; 
        std::vector<double> rhovals;
        std::vector<double> Frhovals;    
    };

    typedef SimpleTypeData<EAMParam> EAMParamGenericData;
}

#endif
Revision:	1816
Committed:	Wed Dec 1 19:10:51 2004 UTC (19 years, 7 months ago) by tim
File size:	4996 byte(s)
Log Message:	spell check
#	Content
1	#ifndef TYPES_ATOMTYPE_HPP
2
3	#define TYPES_ATOMTYPE_HPP
4
5	#include <string>
6
7	#include "utils/PropertyMap.hpp"
8
9	#define __C
10	#include "types/AtomTypeProperties.h"
11	#include "UseTheForce/DarkSide/atype_interface.h"
12
13	namespace oopse {
14	/**
15	* @class AtomType
16	* AtomType is what OOPSE looks to for unchanging data about an atom.
17	* Things that belong to AtomType are universal properties (i.e. does
18	* this atom have a Charge? What is it's mass_?) Dynamic properties of
19	* an atom are not intended to be properties of an atom type
20	*/
21	class AtomType {
22	public:
23
24	AtomType();
25
26	virtual ~AtomType() { } ;
27
28	virtual void complete();
29
30	/**
31	* Finishes off the AtomType by communicating the logical portions of the
32	* structure to the Fortran atype module
33	*/
34	void makeFortranAtomType();
35
36	void setMass(double m) {
37	mass_ = m;
38	}
39
40	double getMass(void) {
41	return mass_;
42	}
43
44	void setIdent(int id) {
45	atp.ident = id;
46	}
47
48	int getIdent() {
49	return atp.ident;
50	}
51
52	void setName(const std::string&name) {
53	name_ = name;
54	}
55
56	std::string getName() {
57	return name_;
58	}
59
60	void setLennardJones() {
61	atp.is_LennardJones = 1;
62	}
63
64	bool isLennardJones() {
65	return atp.is_LennardJones;
66	}
67
68
69	bool isElectrostatic() {
70	return isCharge() \|\| isMultipole();
71	}
72
73	void setEAM() {
74	atp.is_EAM = 1;
75	}
76
77	bool isEAM() {
78	return atp.is_EAM;
79	}
80
81	void setCharge() {
82	atp.is_Charge = 1;
83	}
84
85	bool isCharge() {
86	return atp.is_Charge;
87	}
88
89	bool isDirectional() {
90	return atp.is_Directional;
91	}
92
93	bool isDipole() {
94	return atp.is_Dipole;
95	}
96
97	bool isQuadrupole() {
98	return atp.is_Quadrupole;
99	}
100
101	bool isMultipole() {
102	return isDipole() \|\| isQuadrupole();
103	}
104
105	bool isGayBerne() {
106	return atp.is_GayBerne;
107	}
108
109	bool isSticky() {
110	return atp.is_Sticky;
111	}
112
113	bool isShape() {
114	return atp.is_Shape;
115	}
116
117	//below functions are just forward functions
118	/**
119	* Adds property into property map
120	* @param genData GenericData to be added into PropertyMap
121	*/
122	void addProperty(GenericData* genData);
123
124	/**
125	* Removes property from PropertyMap by name
126	* @param propName the name of property to be removed
127	*/
128	void removeProperty(const std::string& propName);
129
130	/**
131	* clear all of the properties
132	*/
133	void clearProperties();
134
135	/**
136	* Returns all names of properties
137	* @return all names of properties
138	*/
139	std::vector<std::string> getPropertyNames();
140
141	/**
142	* Returns all of the properties in PropertyMap
143	* @return all of the properties in PropertyMap
144	*/
145	std::vector<GenericData*> getProperties();
146
147	/**
148	* Returns property
149	* @param propName name of property
150	* @return a pointer point to property with propName. If no property named propName
151	* exists, return NULL
152	*/
153	GenericData* getPropertyByName(const std::string& propName);
154
155	protected:
156
157	AtomTypeProperties atp;
158	double mass_;
159	std::string name_;
160
161	private:
162	//prevent copy construction and copy assignment, since property map contains
163	//pointers which can not be copied and managered safely, except make the generic data
164	//at PropertyMap as copy on write shared pointer
165	AtomType(const AtomType&);
166	AtomType& operator=(const AtomType& atomType);
167
168
169	PropertyMap properties_;
170
171	};
172
173	struct LJParam {
174	double epsilon;
175	double sigma;
176	};
177	typedef SimpleTypeData<LJParam> LJParamGenericData;
178
179	struct EAMParam {
180	double latticeConstant;
181	int nrho;
182	double drho;
183	int nr;
184	double dr;
185	double rcut;
186	std::vector<double> rvals;
187	std::vector<double> rhovals;
188	std::vector<double> Frhovals;
189	};
190
191	typedef SimpleTypeData<EAMParam> EAMParamGenericData;
192	}
193
194	#endif