OOPSE/libmdtools/ReadWrite.hpp

#ifndef __READWRITE_H__
#define __READWRITE_H__
#define _LARGEFILE_SOURCE64
#define _FILE_OFFSET_BITS 64
#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 "Atom.hpp"
#include "SimInfo.hpp"
#include "Thermo.hpp"
#include "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;
  char outName[500];
  Thermo* tStats;

};

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;
};


#endif
Revision:	1118
Committed:	Mon Apr 19 03:52:27 2004 UTC (20 years, 2 months ago) by tim
File size:	1970 byte(s)
Log Message:	new implement of quickLate using visitor and composite pattern
#	User	Rev	Content
1	mmeineke	377	#ifndef __READWRITE_H__
2			#define __READWRITE_H__
3	tim	1078	#define _LARGEFILE_SOURCE64
4			#define _FILE_OFFSET_BITS 64
5	mmeineke	377	#include <iostream>
6			#include <fstream>
7	tim	1118	#include <string>
8	gezelter	829	#include <string.h>
9			#include <stdio.h>
10			#include <stdlib.h>
11	mmeineke	804	#include <unistd.h>
12			#include <sys/types.h>
13			#include <sys/stat.h>
14	mmeineke	377
15	mmeineke	646
16	mmeineke	377	#include "Atom.hpp"
17			#include "SimInfo.hpp"
18			#include "Thermo.hpp"
19	tim	1108	#include "StuntDouble.hpp"
20	mmeineke	377
21			using namespace std;
22
23			class DumpWriter{
24
25			public:
26			DumpWriter( SimInfo* the_entry_plug );
27			~DumpWriter();
28
29			void writeDump( double currentTime );
30	tim	929	void writeFinal( double currentTime);
31	tim	934	void writeFrame( vector<ofstream*>& outFile, double finalTime );
32	mmeineke	377
33	tim	929	#ifdef IS_MPI
34			void update();
35			#endif
36
37	mmeineke	377	private:
38	tim	929
39			#ifdef IS_MPI
40			void sortByGlobalIndex();
41			#endif
42
43	mmeineke	377	SimInfo* entry_plug;
44	tim	929	ofstream dumpFile;
45	tim	934
46			#ifdef IS_MPI
47	tim	929	vector<pair<int, int> > indexArray;
48	tim	934	#endif
49	mmeineke	377	};
50
51			class StatWriter{
52
53			public:
54			StatWriter( SimInfo* the_entry_plug );
55			~StatWriter();
56
57			void writeStat( double currentTime );
58	tim	837
59	mmeineke	377	private:
60	tim	837
61	mmeineke	377	SimInfo* entry_plug;
62			ofstream outFile;
63			char outName[500];
64			Thermo* tStats;
65
66			};
67
68			class InitializeFromFile{
69
70			public:
71			InitializeFromFile( char *in_name );
72			~InitializeFromFile();
73
74	mmeineke	641	void readInit( SimInfo* the_entry_plug );
75	tim	837
76	mmeineke	377	private:
77	tim	1108	char* parseDumpLine(char* line, StuntDouble* sd);
78	tim	837	char* parseCommentLine(char* line, SimInfo* entry_plug);
79	mmeineke	377	FILE *c_in_file;
80			char c_in_name[500];
81	mmeineke	586	SimInfo* simnfo;
82	mmeineke	377	};
83
84	gezelter	637	class DumpReader{
85	mmeineke	644
86			public:
87	tim	1074	DumpReader(const char *in_name );
88	gezelter	637	~DumpReader();
89	mmeineke	377
90	gezelter	637	int getNframes();
91	mmeineke	646	void scanFile( void );
92	mmeineke	377
93	mmeineke	656	void getNextFrame() {}
94			void readFrame(SimInfo* the_simnfo, int whichFrame);
95
96	tim	1118	#ifdef IS_MPI
97			void anonymousNodeDie( void );
98			void nodeZeroError( void );
99			#endif
100	gezelter	637	private:
101	mmeineke	647
102	chuckv	657	void readSet( int whichFrame );
103	tim	1118	char* parseDumpLine(char* readLine, StuntDouble* sd);
104			char* parseCommentLine(char* readLine, SimInfo* entry_plug);
105	mmeineke	647	FILE *inFile;
106	tim	1118	string inFileName;
107	mmeineke	647	bool isScanned;
108	tim	837
109	tim	1118	vector<fpos_t*> framePos;
110	mmeineke	647	SimInfo *simnfo;
111	gezelter	637	};
112
113
114	mmeineke	644
115	mmeineke	377	#endif