OOPSE/libmdtools/GenericData.hpp

#ifndef __GENERICDATA_H__
#define __GENERICDATA_H__

#include <algorithm>
#include <string>
#include <vector>

#define ZCONSTIME_ID            "ZCONSTIME"
#define ZCONSPARADATA_ID    "ZCONSPARA"
#define ZCONSFILENAME_ID     "ZCONSFILENAME"
#define ZCONSTOL_ID              "ZCONSTOL"
#define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
#define ZCONSGAP_ID "ZCONSGAP"
#define ZCONSFIXTIME_ID "ZCONSFIXTIME"
#define ZCONSUSINGSMD_ID "ZCONSUSINGSMD"

#define CHIVALUE_ID "CHIVALUE"
#define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
#define ETAVALUE_ID "ETAVALUE"

using namespace std;

class GenericData
{
  public:
    GenericData();
    GenericData(const GenericData& rhs)  {  id = rhs.getID(); }
    GenericData& operator =(const GenericData& rhs);
    virtual ~GenericData() {}

    const string& getID() const {  return id; }
    void setID(string rhs)     {  id = rhs;  }

  protected:
    string id;
};

/** Something we can improve it here is to use template
 **
 */

class IntData : public GenericData{

  public:

    double getData()         { return data; }
    void setData(int rhs) { data = rhs;  }

  protected:
    int data;
};

class DoubleData : public GenericData{

  public:

    double getData()         { return data; }
    void setData(double rhs) { data = rhs;  }

  protected:
    double data;
};

class StringData : public GenericData{

  public:
    const string& getData() const  {  return data; }
    void setData(const string& rhs) {  data = rhs;  }
  protected:
    string data;
};

struct ZConsParaItem {
  int zconsIndex;
  bool havingZPos;
  double zPos;
  double kRatio;
  bool havingCantVel;
  double cantVel;
};

class ZConsParaData : public GenericData{

  public:
    ZConsParaData();
    void addItem(ZConsParaItem& item) {data.push_back(item);}
    vector<ZConsParaItem>* getData() {return &data;}
    void setData(vector<ZConsParaItem>& theData) {data = theData;}
    void sortByIndex();
    bool isIndexUnique();

  private:
    vector<ZConsParaItem> data;
  };

class ZConsParaSortCriterion{
  public:
    bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
      return item1.zconsIndex < item2.zconsIndex;
    }

};

class DoubleArrayData : public GenericData{

 public:
   vector<double> getData() const  {  return data; }
   void setData(double* source, int num){
    data.clear();
    for(int i = 0; i < num; i++)
     data.push_back(source[i]);
   }
 protected:
   vector<double> data;
};

struct AtomInfo : public GenericData{
  public:
    string AtomType;
    double pos[3];
    double dipole[3];  
};

class AtomData : public GenericData{
  public:
    ~AtomData();
    void addAtomInfo(AtomInfo* info) {data.push_back(info);}
    void clearAllAtomInfo();
    AtomInfo* beginAtomInfo(vector<AtomInfo*>::iterator& i){
      i = data.begin();
      return i != data.end()? *i : NULL;
    }
    AtomInfo* nextAtomInfo(vector<AtomInfo*>::iterator& i){
      ++i;
      return i != data.end()? *i: NULL;
    }
    vector<AtomInfo*> getData() {return data;}
    int getSize() {return data.size();}
  protected:
    vector<AtomInfo*> data;
};


#endif
Revision:	1126
Committed:	Tue Apr 20 05:39:38 2004 UTC (20 years, 2 months ago) by tim
File size:	3109 byte(s)
Log Message:	DUMP2XYZ 0.99 version
#	User	Rev	Content
1	tim	658	#ifndef __GENERICDATA_H__
2			#define __GENERICDATA_H__
3
4	tim	682	#include <algorithm>
5	tim	658	#include <string>
6			#include <vector>
7
8	tim	682	#define ZCONSTIME_ID "ZCONSTIME"
9			#define ZCONSPARADATA_ID "ZCONSPARA"
10			#define ZCONSFILENAME_ID "ZCONSFILENAME"
11			#define ZCONSTOL_ID "ZCONSTOL"
12	tim	699	#define ZCONSFORCEPOLICY_ID "ZCONSFORCEPOLICY"
13	tim	1091	#define ZCONSGAP_ID "ZCONSGAP"
14			#define ZCONSFIXTIME_ID "ZCONSFIXTIME"
15	tim	1093	#define ZCONSUSINGSMD_ID "ZCONSUSINGSMD"
16	tim	682
17	tim	837	#define CHIVALUE_ID "CHIVALUE"
18			#define INTEGRALOFCHIDT_ID "INTEGRALOFCHIDT"
19			#define ETAVALUE_ID "ETAVALUE"
20
21	tim	658	using namespace std;
22
23			class GenericData
24			{
25			public:
26			GenericData();
27			GenericData(const GenericData& rhs) { id = rhs.getID(); }
28			GenericData& operator =(const GenericData& rhs);
29			virtual ~GenericData() {}
30	tim	837
31	tim	658	const string& getID() const { return id; }
32	tim	837	void setID(string rhs) { id = rhs; }
33
34	tim	658	protected:
35			string id;
36			};
37
38			/** Something we can improve it here is to use template
39	tim	837	**
40	tim	658	*/
41	tim	1093
42			class IntData : public GenericData{
43
44			public:
45
46			double getData() { return data; }
47			void setData(int rhs) { data = rhs; }
48
49			protected:
50			int data;
51			};
52
53	tim	658	class DoubleData : public GenericData{
54
55			public:
56
57			double getData() { return data; }
58			void setData(double rhs) { data = rhs; }
59	tim	837
60	tim	658	protected:
61			double data;
62			};
63
64			class StringData : public GenericData{
65	tim	837
66			public:
67	tim	658	const string& getData() const { return data; }
68			void setData(const string& rhs) { data = rhs; }
69			protected:
70	tim	837	string data;
71	tim	658	};
72	tim	682
73	mmeineke	789	struct ZConsParaItem {
74	tim	682	int zconsIndex;
75			bool havingZPos;
76			double zPos;
77			double kRatio;
78	tim	1093	bool havingCantVel;
79			double cantVel;
80	tim	682	};
81
82			class ZConsParaData : public GenericData{
83	tim	837
84			public:
85	tim	682	ZConsParaData();
86			void addItem(ZConsParaItem& item) {data.push_back(item);}
87			vector<ZConsParaItem>* getData() {return &data;}
88			void setData(vector<ZConsParaItem>& theData) {data = theData;}
89			void sortByIndex();
90	tim	736	bool isIndexUnique();
91	tim	837
92			private:
93	tim	682	vector<ZConsParaItem> data;
94			};
95
96			class ZConsParaSortCriterion{
97			public:
98			bool operator ()(const ZConsParaItem& item1, const ZConsParaItem& item2){
99			return item1.zconsIndex < item2.zconsIndex;
100			}
101
102			};
103
104	tim	837	class DoubleArrayData : public GenericData{
105
106			public:
107			vector<double> getData() const { return data; }
108			void setData(double* source, int num){
109			data.clear();
110			for(int i = 0; i < num; i++)
111			data.push_back(source[i]);
112			}
113			protected:
114			vector<double> data;
115			};
116	tim	1118
117			struct AtomInfo : public GenericData{
118			public:
119			string AtomType;
120			double pos[3];
121			double dipole[3];
122			};
123
124			class AtomData : public GenericData{
125			public:
126			~AtomData();
127			void addAtomInfo(AtomInfo* info) {data.push_back(info);}
128			void clearAllAtomInfo();
129			AtomInfo* beginAtomInfo(vector<AtomInfo*>::iterator& i){
130			i = data.begin();
131			return i != data.end()? *i : NULL;
132			}
133			AtomInfo* nextAtomInfo(vector<AtomInfo*>::iterator& i){
134	tim	1126	++i;
135	tim	1118	return i != data.end()? *i: NULL;
136			}
137			vector<AtomInfo*> getData() {return data;}
138			int getSize() {return data.size();}
139			protected:
140			vector<AtomInfo*> data;
141			};
142
143
144
145	tim	658	#endif