OOPSE/libmdtools/ReadWrite.hpp

#ifndef __READWRITE_H__
#define __READWRITE_H__
#define _LARGEFILE_SOURCE64
#define _FILE_OFFSET_BITS 64
#include <iostream>
#include <fstream>

#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 FilePos{

public:
  FilePos(){
    myPos = NULL;
    next = NULL;
  }
  FilePos( fpos_t* thePos ) {
    myPos = thePos;
    next = NULL;
  }
  ~FilePos(){
    if( next  != NULL ) delete next;
    if( myPos != NULL ) delete myPos;
  }

  void add( fpos_t *thePos ){
    if( next != NULL )
      next->add( thePos );
    else
      next = new FilePos( thePos );
  }

  FilePos &operator=(fpos_t *thePos){ myPos = thePos; return *this; }

  void setPos( fpos_t *thePos ){ myPos = thePos; }
  fpos_t *getPos( void ){ return myPos; }

  FilePos* getNext( void ) { return next; }
private:

  fpos_t *myPos;
  FilePos* next;

};

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

private:

  void readSet( int whichFrame );
  char* parseDumpLine(char* line, int atomIndex);
  char* parseCommentLine(char* line, double &time, double boxMat[9] );
  FILE *inFile;
  char inName[500];
  bool isScanned;
  int nFrames;

  FilePos** frameStart;
  FilePos* headFP;

  SimInfo *simnfo;
};


#endif
Revision:	1108
Committed:	Wed Apr 14 15:37:41 2004 UTC (20 years, 2 months ago) by tim
File size:	2530 byte(s)
Log Message:	Change DumpWriter and InitFromFile
#	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
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	mmeineke	804	class FilePos{
24	tim	837
25	mmeineke	804	public:
26	tim	837	FilePos(){
27	mmeineke	804	myPos = NULL;
28			next = NULL;
29			}
30	tim	837	FilePos( fpos_t* thePos ) {
31			myPos = thePos;
32	mmeineke	804	next = NULL;
33			}
34	tim	837	~FilePos(){
35	mmeineke	804	if( next != NULL ) delete next;
36			if( myPos != NULL ) delete myPos;
37			}
38	tim	837
39	mmeineke	804	void add( fpos_t *thePos ){
40	tim	837	if( next != NULL )
41	mmeineke	804	next->add( thePos );
42			else
43			next = new FilePos( thePos );
44			}
45	tim	837
46	mmeineke	804	FilePos &operator=(fpos_t thePos){ myPos = thePos; return this; }
47	tim	837
48	mmeineke	804	void setPos( fpos_t *thePos ){ myPos = thePos; }
49			fpos_t *getPos( void ){ return myPos; }
50	tim	837
51	mmeineke	804	FilePos* getNext( void ) { return next; }
52			private:
53	tim	837
54	mmeineke	804	fpos_t *myPos;
55			FilePos* next;
56	tim	837
57	mmeineke	804	};
58	mmeineke	646
59	mmeineke	377	class DumpWriter{
60
61			public:
62			DumpWriter( SimInfo* the_entry_plug );
63			~DumpWriter();
64
65			void writeDump( double currentTime );
66	tim	929	void writeFinal( double currentTime);
67	tim	934	void writeFrame( vector<ofstream*>& outFile, double finalTime );
68	mmeineke	377
69	tim	929	#ifdef IS_MPI
70			void update();
71			#endif
72
73	mmeineke	377	private:
74	tim	929
75			#ifdef IS_MPI
76			void sortByGlobalIndex();
77			#endif
78
79	mmeineke	377	SimInfo* entry_plug;
80	tim	929	ofstream dumpFile;
81	tim	934
82			#ifdef IS_MPI
83	tim	929	vector<pair<int, int> > indexArray;
84	tim	934	#endif
85	mmeineke	377	};
86
87			class StatWriter{
88
89			public:
90			StatWriter( SimInfo* the_entry_plug );
91			~StatWriter();
92
93			void writeStat( double currentTime );
94	tim	837
95	mmeineke	377	private:
96	tim	837
97	mmeineke	377	SimInfo* entry_plug;
98			ofstream outFile;
99			char outName[500];
100			Thermo* tStats;
101
102			};
103
104			class InitializeFromFile{
105
106			public:
107			InitializeFromFile( char *in_name );
108			~InitializeFromFile();
109
110	mmeineke	641	void readInit( SimInfo* the_entry_plug );
111	tim	837
112	mmeineke	377	private:
113	tim	1108	char* parseDumpLine(char* line, StuntDouble* sd);
114	tim	837	char* parseCommentLine(char* line, SimInfo* entry_plug);
115	mmeineke	377	FILE *c_in_file;
116			char c_in_name[500];
117	mmeineke	586	SimInfo* simnfo;
118	mmeineke	377	};
119
120	gezelter	637	class DumpReader{
121	mmeineke	644
122			public:
123	tim	1074	DumpReader(const char *in_name );
124	gezelter	637	~DumpReader();
125	mmeineke	377
126	gezelter	637	int getNframes();
127	mmeineke	646	void scanFile( void );
128	mmeineke	377
129	mmeineke	656	void getNextFrame() {}
130			void readFrame(SimInfo* the_simnfo, int whichFrame);
131
132	gezelter	637	private:
133	mmeineke	647
134	chuckv	657	void readSet( int whichFrame );
135	gezelter	637	char* parseDumpLine(char* line, int atomIndex);
136	mmeineke	644	char* parseCommentLine(char* line, double &time, double boxMat[9] );
137	mmeineke	647	FILE *inFile;
138			char inName[500];
139			bool isScanned;
140			int nFrames;
141	tim	837
142	mmeineke	804	FilePos** frameStart;
143			FilePos* headFP;
144	mmeineke	647
145			SimInfo *simnfo;
146	gezelter	637	};
147
148
149	mmeineke	644
150	mmeineke	377	#endif