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:	1221
Committed:	Wed Jun 2 14:56:18 2004 UTC (20 years, 1 month ago) by chrisfen
File size:	1970 byte(s)
Log Message:	Formatting Changes, removed writeRaw
#	Content
1	#ifndef __READWRITE_H__
2	#define __READWRITE_H__
3	#define _LARGEFILE_SOURCE64
4	#define _FILE_OFFSET_BITS 64
5	#include <iostream>
6	#include <fstream>
7	#include <string>
8	#include <string.h>
9	#include <stdio.h>
10	#include <stdlib.h>
11	#include <unistd.h>
12	#include <sys/types.h>
13	#include <sys/stat.h>
14
15
16	#include "Atom.hpp"
17	#include "SimInfo.hpp"
18	#include "Thermo.hpp"
19	#include "StuntDouble.hpp"
20
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	void writeFinal( double currentTime);
31	void writeFrame( vector<ofstream*>& outFile, double finalTime );
32
33	#ifdef IS_MPI
34	void update();
35	#endif
36
37	private:
38
39	#ifdef IS_MPI
40	void sortByGlobalIndex();
41	#endif
42
43	SimInfo* entry_plug;
44	ofstream dumpFile;
45
46	#ifdef IS_MPI
47	vector<pair<int, int> > indexArray;
48	#endif
49	};
50
51	class StatWriter{
52
53	public:
54	StatWriter( SimInfo* the_entry_plug );
55	~StatWriter();
56
57	void writeStat( double currentTime );
58
59	private:
60
61	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	void readInit( SimInfo* the_entry_plug );
75
76	private:
77	char* parseDumpLine(char* line, StuntDouble* sd);
78	char* parseCommentLine(char* line, SimInfo* entry_plug);
79	FILE *c_in_file;
80	char c_in_name[500];
81	SimInfo* simnfo;
82	};
83
84	class DumpReader{
85
86	public:
87	DumpReader(const char *in_name );
88	~DumpReader();
89
90	int getNframes();
91	void scanFile( void );
92
93	void getNextFrame() {}
94	void readFrame(SimInfo* the_simnfo, int whichFrame);
95
96	#ifdef IS_MPI
97	void anonymousNodeDie( void );
98	void nodeZeroError( void );
99	#endif
100	private:
101
102	void readSet( int whichFrame );
103	char* parseDumpLine(char* readLine, StuntDouble* sd);
104	char* parseCommentLine(char* readLine, SimInfo* entry_plug);
105	FILE *inFile;
106	string inFileName;
107	bool isScanned;
108
109	vector<fpos_t*> framePos;
110	SimInfo *simnfo;
111	};
112
113
114
115	#endif