src/io/ReadWrite.hpp

#ifndef __READWRITE_H__
#define __READWRITE_H__
#define _LARGEFILE_SOURCE64
#ifndef _FILE_OFFSET_BITS
#define _FILE_OFFSET_BITS 64
#endif
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>


#include "primitives/Atom.hpp"
#include "brains/SimInfo.hpp"
#include "brains/Thermo.hpp"
#include "primitives/StuntDouble.hpp"

using namespace std;

class DumpWriter{

public:
  DumpWriter( SimInfo* the_entry_plug );
  ~DumpWriter();

  void writeDump( double currentTime );
  void writeFinal( double currentTime);
  void writeFrame( vector<ofstream*>& outFile, double finalTime );

#ifdef IS_MPI
  void update();
#endif

private:

#ifdef IS_MPI
  void sortByGlobalIndex();
#endif

  SimInfo* entry_plug;
  ofstream dumpFile;

#ifdef IS_MPI 
  vector<pair<int, int> > indexArray;
#endif
};

class StatWriter{

public:
  StatWriter( SimInfo* the_entry_plug );
  ~StatWriter();

  void writeStat( double currentTime );

private:

  SimInfo* entry_plug;
  ofstream outFile;
  string outName;
  Thermo* tStats;

};

class RestraintWriter{

public:
  RestraintWriter( SimInfo* the_entry_plug );
  ~RestraintWriter();

  void writeZangle( double currentTime );
  void writeZangle(double currentTime, const char *in_name);
  void writeFrame( vector<ofstream*>& outFile, double finalTime );

#ifdef IS_MPI
  void update();
#endif

private:

#ifdef IS_MPI
  void sortByGlobalIndex();
  vector<pair<int, int> > indexArray;
#endif

  SimInfo* entry_plug;
  ofstream zAngFile;

};

class InitializeFromFile{

public:
  InitializeFromFile( char *in_name );
  ~InitializeFromFile();

  void readInit( SimInfo* the_entry_plug );

private:
  char* parseDumpLine(char* line, StuntDouble* sd);
  char* parseCommentLine(char* line, SimInfo* entry_plug);
  FILE *c_in_file;
  char c_in_name[500];
  SimInfo* simnfo;
};

class DumpReader{

public:
  DumpReader(const char *in_name );
  ~DumpReader();

  int getNframes();
  void scanFile( void );

  void getNextFrame() {}
  void readFrame(SimInfo* the_simnfo, int whichFrame);

#ifdef IS_MPI
  void anonymousNodeDie( void );
  void nodeZeroError( void );
#endif
private:

  void readSet( int whichFrame );
  char* parseDumpLine(char* readLine, StuntDouble* sd);
  char* parseCommentLine(char* readLine, SimInfo* entry_plug);
  FILE *inFile;
  string inFileName;
  bool isScanned;

  vector<fpos_t*> framePos;
  SimInfo *simnfo;
};

class RestraintReader{

public:
  RestraintReader( SimInfo* the_simnfo  );
  ~RestraintReader();

  void readIdealCrystal();
  void readZangle( const char *in_name );
  void zeroZangle();

#ifdef IS_MPI
  void anonymousNodeDie( void );
  void nodeZeroError( void );
#endif

private:
  char* parseIdealLine(char* readLine, StuntDouble* sd);
  char *idealName;
  FILE *inFile;
  FILE *inAngFile;
  FILE *inIdealFile;
  string inFileName;
  string inAngFileName;
  string inIdealFileName;
  bool isScanned;

  double angleTransfer;
  vector<fpos_t*> framePos;
  SimInfo *simnfo;
};

#endif
Revision:	1772
Committed:	Tue Nov 23 22:48:31 2004 UTC (19 years, 7 months ago) by chrisfen
File size:	3072 byte(s)
Log Message:	Improvements to restraints
#	User	Rev	Content
1	gezelter	1490	#ifndef __READWRITE_H__
2			#define __READWRITE_H__
3			#define _LARGEFILE_SOURCE64
4			#ifndef _FILE_OFFSET_BITS
5			#define _FILE_OFFSET_BITS 64
6			#endif
7			#include <iostream>
8			#include <fstream>
9			#include <string>
10			#include <string.h>
11			#include <stdio.h>
12			#include <stdlib.h>
13			#include <unistd.h>
14			#include <sys/types.h>
15			#include <sys/stat.h>
16
17
18	tim	1492	#include "primitives/Atom.hpp"
19			#include "brains/SimInfo.hpp"
20			#include "brains/Thermo.hpp"
21			#include "primitives/StuntDouble.hpp"
22	gezelter	1490
23			using namespace std;
24
25			class DumpWriter{
26
27			public:
28			DumpWriter( SimInfo* the_entry_plug );
29			~DumpWriter();
30
31			void writeDump( double currentTime );
32			void writeFinal( double currentTime);
33			void writeFrame( vector<ofstream*>& outFile, double finalTime );
34
35			#ifdef IS_MPI
36			void update();
37			#endif
38
39			private:
40
41			#ifdef IS_MPI
42			void sortByGlobalIndex();
43			#endif
44
45			SimInfo* entry_plug;
46			ofstream dumpFile;
47
48			#ifdef IS_MPI
49			vector<pair<int, int> > indexArray;
50			#endif
51			};
52
53			class StatWriter{
54
55			public:
56			StatWriter( SimInfo* the_entry_plug );
57			~StatWriter();
58
59			void writeStat( double currentTime );
60
61			private:
62
63			SimInfo* entry_plug;
64			ofstream outFile;
65			string outName;
66			Thermo* tStats;
67
68			};
69
70	chrisfen	1772	class RestraintWriter{
71
72			public:
73			RestraintWriter( SimInfo* the_entry_plug );
74			~RestraintWriter();
75
76			void writeZangle( double currentTime );
77			void writeZangle(double currentTime, const char *in_name);
78			void writeFrame( vector<ofstream*>& outFile, double finalTime );
79
80			#ifdef IS_MPI
81			void update();
82			#endif
83
84			private:
85
86			#ifdef IS_MPI
87			void sortByGlobalIndex();
88			vector<pair<int, int> > indexArray;
89			#endif
90
91			SimInfo* entry_plug;
92			ofstream zAngFile;
93
94			};
95
96	gezelter	1490	class InitializeFromFile{
97
98			public:
99			InitializeFromFile( char *in_name );
100			~InitializeFromFile();
101
102			void readInit( SimInfo* the_entry_plug );
103
104			private:
105			char* parseDumpLine(char* line, StuntDouble* sd);
106			char* parseCommentLine(char* line, SimInfo* entry_plug);
107			FILE *c_in_file;
108			char c_in_name[500];
109			SimInfo* simnfo;
110			};
111
112			class DumpReader{
113
114			public:
115			DumpReader(const char *in_name );
116			~DumpReader();
117
118			int getNframes();
119			void scanFile( void );
120
121			void getNextFrame() {}
122			void readFrame(SimInfo* the_simnfo, int whichFrame);
123
124			#ifdef IS_MPI
125			void anonymousNodeDie( void );
126			void nodeZeroError( void );
127			#endif
128			private:
129
130			void readSet( int whichFrame );
131			char* parseDumpLine(char* readLine, StuntDouble* sd);
132			char* parseCommentLine(char* readLine, SimInfo* entry_plug);
133			FILE *inFile;
134			string inFileName;
135			bool isScanned;
136
137			vector<fpos_t*> framePos;
138			SimInfo *simnfo;
139			};
140
141	chrisfen	1772	class RestraintReader{
142	gezelter	1490
143	chrisfen	1772	public:
144			RestraintReader( SimInfo* the_simnfo );
145			~RestraintReader();
146	gezelter	1490
147	chrisfen	1772	void readIdealCrystal();
148			void readZangle( const char *in_name );
149			void zeroZangle();
150
151			#ifdef IS_MPI
152			void anonymousNodeDie( void );
153			void nodeZeroError( void );
154	gezelter	1490	#endif
155	chrisfen	1772
156			private:
157			char* parseIdealLine(char* readLine, StuntDouble* sd);
158			char *idealName;
159			FILE *inFile;
160			FILE *inAngFile;
161			FILE *inIdealFile;
162			string inFileName;
163			string inAngFileName;
164			string inIdealFileName;
165			bool isScanned;
166
167			double angleTransfer;
168			vector<fpos_t*> framePos;
169			SimInfo *simnfo;
170			};
171
172			#endif