OOPSE/libmdtools/ReadWrite.hpp

#ifndef __READWRITE_H__
#define __READWRITE_H__

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

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