OOPSE/libmdtools/ReadWrite.hpp

#ifndef __READWRITE_H__
#define __READWRITE_H__

#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"

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

private:
  SimInfo* entry_plug;
  ofstream outFile;
  char outName[500];
};

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, int atomIndex);
  char* parseCommentLine(char* line, SimInfo* entry_plug);
  FILE *c_in_file;
  char c_in_name[500];
  SimInfo* simnfo;
};

class DumpReader{

public:
  DumpReader( 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:	837
Committed:	Wed Oct 29 00:19:10 2003 UTC (20 years, 8 months ago) by tim
File size:	2241 byte(s)
Log Message:	add chi and eta to the comment line of dump file.
#	User	Rev	Content
1	mmeineke	377	#ifndef __READWRITE_H__
2			#define __READWRITE_H__
3
4			#include <iostream>
5			#include <fstream>
6
7	gezelter	829	#include <string.h>
8			#include <stdio.h>
9			#include <stdlib.h>
10	mmeineke	804	#include <unistd.h>
11			#include <sys/types.h>
12			#include <sys/stat.h>
13	mmeineke	377
14	mmeineke	646
15	mmeineke	377	#include "Atom.hpp"
16			#include "SimInfo.hpp"
17			#include "Thermo.hpp"
18
19			using namespace std;
20
21	mmeineke	804	class FilePos{
22	tim	837
23	mmeineke	804	public:
24	tim	837	FilePos(){
25	mmeineke	804	myPos = NULL;
26			next = NULL;
27			}
28	tim	837	FilePos( fpos_t* thePos ) {
29			myPos = thePos;
30	mmeineke	804	next = NULL;
31			}
32	tim	837	~FilePos(){
33	mmeineke	804	if( next != NULL ) delete next;
34			if( myPos != NULL ) delete myPos;
35			}
36	tim	837
37	mmeineke	804	void add( fpos_t *thePos ){
38	tim	837	if( next != NULL )
39	mmeineke	804	next->add( thePos );
40			else
41			next = new FilePos( thePos );
42			}
43	tim	837
44	mmeineke	804	FilePos &operator=(fpos_t thePos){ myPos = thePos; return this; }
45	tim	837
46	mmeineke	804	void setPos( fpos_t *thePos ){ myPos = thePos; }
47			fpos_t *getPos( void ){ return myPos; }
48	tim	837
49	mmeineke	804	FilePos* getNext( void ) { return next; }
50			private:
51	tim	837
52	mmeineke	804	fpos_t *myPos;
53			FilePos* next;
54	tim	837
55	mmeineke	804	};
56	mmeineke	646
57	mmeineke	377	class DumpWriter{
58
59			public:
60			DumpWriter( SimInfo* the_entry_plug );
61			~DumpWriter();
62
63			void writeDump( double currentTime );
64	mmeineke	572	void writeFinal( double finalTime );
65	mmeineke	377
66			private:
67			SimInfo* entry_plug;
68			ofstream outFile;
69			char outName[500];
70			};
71
72			class StatWriter{
73
74			public:
75			StatWriter( SimInfo* the_entry_plug );
76			~StatWriter();
77
78			void writeStat( double currentTime );
79	tim	837
80	mmeineke	377	private:
81	tim	837
82	mmeineke	377	SimInfo* entry_plug;
83			ofstream outFile;
84			char outName[500];
85			Thermo* tStats;
86
87			};
88
89			class InitializeFromFile{
90
91			public:
92			InitializeFromFile( char *in_name );
93			~InitializeFromFile();
94
95	mmeineke	641	void readInit( SimInfo* the_entry_plug );
96	tim	837
97	mmeineke	377	private:
98			char* parseDumpLine(char* line, int atomIndex);
99	tim	837	char* parseCommentLine(char* line, SimInfo* entry_plug);
100	mmeineke	377	FILE *c_in_file;
101			char c_in_name[500];
102	mmeineke	586	SimInfo* simnfo;
103	mmeineke	377	};
104
105	gezelter	637	class DumpReader{
106	mmeineke	644
107			public:
108	gezelter	637	DumpReader( char *in_name );
109			~DumpReader();
110	mmeineke	377
111	gezelter	637	int getNframes();
112	mmeineke	646	void scanFile( void );
113	mmeineke	377
114	mmeineke	656	void getNextFrame() {}
115			void readFrame(SimInfo* the_simnfo, int whichFrame);
116
117	gezelter	637	private:
118	mmeineke	647
119	chuckv	657	void readSet( int whichFrame );
120	gezelter	637	char* parseDumpLine(char* line, int atomIndex);
121	mmeineke	644	char* parseCommentLine(char* line, double &time, double boxMat[9] );
122	mmeineke	647	FILE *inFile;
123			char inName[500];
124			bool isScanned;
125			int nFrames;
126	tim	837
127	mmeineke	804	FilePos** frameStart;
128			FilePos* headFP;
129	mmeineke	647
130			SimInfo *simnfo;
131	gezelter	637	};
132
133
134	mmeineke	644
135	mmeineke	377	#endif