* To write the snapshots to a file, call the prepareToWrite() method, * specifying the output stream to write. The prepareToWrite() method * returns an instance of class {@linkplain AntiprotonFile.Writer}. Call the * methods of the writer object to write the antiproton position snapshots to * the output stream. When finished, close the writer. *
* To read the snapshots from a file, call the prepareToRead() method, * specifying the input stream to read. The prepareToRead() method * returns an instance of class {@linkplain AntiprotonFile.Reader}. Call the * methods of the reader object to read the antiproton position snapshots from * the input stream. When finished, close the reader. *
* Class AntiprotonFile includes a main program to combine a group of antiproton * files into one antiproton file. You might use this main program when the * processes of a parallel program have computed slices of the antiprotons and * stored the slices in separate files, and you want to combine the slices * together into one file. *
* Antiproton File Format *
* An antiproton file is a binary file containing the following items. Each * primitive item is written as though by java.io.DataOutput (int, four * bytes; long, eight bytes; double, eight bytes; most * significant byte first). *
* Each snapshot contains the following items. A snapshot contains information * about a slice of the antiprotons. *
* For improved performance, specify an output stream with buffering, such * as an instance of class java.io.BufferedOutputStream. * * @param theStream Output stream. * * @return Writer object with which to write this antiproton file. * * @exception IllegalStateException * (unchecked exception) Thrown if this antiproton file object is * uninitialized. * @exception NullPointerException * (unchecked exception) Thrown if theStream is null. * @exception IOException * Thrown if an I/O error occurred. */ public Writer prepareToWrite (OutputStream theStream) throws IOException { verifyInitialized(); return new Writer (theStream); } /** * Prepare to read this antiproton file from the given input stream. This * antiproton file's attributes are read from the input stream at this time. * To read this antiproton file's snapshots, call methods on the returned * reader, then close the reader. *
* For improved performance, specify an input stream with buffering, such * as an instance of class java.io.BufferedInputStream. * * @param theStream Input stream. * * @return Reader object with which to read this antiproton file. * * @exception NullPointerException * (unchecked exception) Thrown if theStream is null. * @exception IOException * Thrown if an I/O error occurred. */ public Reader prepareToRead (InputStream theStream) throws IOException { return new Reader (theStream); } /** * Main program to combine a group of antiproton files into one antiproton * file. Each input file must be for an antiproton array with the same * number of elements. Each input file must contain the same number of * snapshots. *
* You might use this main program when the processes of a parallel program * have computed slices of antiprotons and stored the slices in separate * files, and you want to combine the slices together into one file. *
* Usage: java edu.rit.io.AntiprotonFile outfile infile1
* [ infile2 . . . ]
*/
public static void main
(String[] args)
throws Exception
{
// Validate command line arguments.
if (args.length < 2)
{
System.err.println ("Usage: java edu.rit.io.AntiprotonFile
* When a writer is created, the antiproton file's attributes are written to
* the output stream. Each time the writeSnapshot() method is
* called, one snapshot is written to the output stream. When finished, call
* the close() method.
*
* Note: Class AntiprotonFile.Writer is not multiple thread safe.
*
* @author Alan Kaminsky
* @version 05-Feb-2008
*/
public class Writer
{
// Hidden data members.
private OutputStream myOs;
private DataOutputStream myDos;
private int mySnaps;
// Hidden constructors.
/**
* Construct a new antiproton file writer.
*
* @param theStream Output stream.
*
* @exception NullPointerException
* (unchecked exception) Thrown if theStream is null.
* @exception IOException
* Thrown if an I/O error occurred.
*/
private Writer
(OutputStream theStream)
throws IOException
{
if (theStream == null)
{
throw new NullPointerException
("AntiprotonFile.Writer(): theStream is null");
}
myOs = theStream;
myDos = new DataOutputStream (theStream);
myDos.writeLong (seed);
myDos.writeDouble (R);
myDos.writeDouble (dt);
myDos.writeInt (steps);
myDos.writeInt (snaps);
myDos.writeInt (N);
myDos.writeInt (L);
myDos.writeInt (M);
}
// Exported operations.
/**
* Write a snapshot to the output stream.
*
* The M antiproton positions starting at index off in
* the array p are written. Note that, depending on how the
* antiproton position array p has been allocated, the argument
* off need not be the same as the attribute L. However,
* the element p[off] must contain the position of antiproton
* L, the element p[off+1] must contain the position of
* antiproton L+1, and so on.
*
* The given total momentum is also written; this must be the total
* momentum of the antiprotons L .. L+M-1.
*
* @param p Array of antiproton positions.
* @param off Index of first array element to write.
* @param mv Total momentum.
*
* @exception IllegalStateException
* (unchecked exception) Thrown if snaps snapshots have
* already been written.
* @exception NullPointerException
* (unchecked exception) Thrown if p is null. Thrown if
* mv is null.
* @exception IndexOutOfBoundsException
* (unchecked exception) Thrown if off < 0. Thrown if
* off+M > p.length.
* @exception IOException
* Thrown if an I/O error occurred.
*/
public void writeSnapshot
(Vector2D[] p,
int off,
Vector2D mv)
throws IOException
{
if (mySnaps >= snaps)
{
throw new IllegalStateException
("AntiprotonFile.Writer.writeSnapshot(): Too many snapshots");
}
if (off < 0 || off+M > p.length)
{
throw new IndexOutOfBoundsException();
}
for (int i = 0; i < M; ++ i)
{
myDos.writeDouble (p[i+off].x);
myDos.writeDouble (p[i+off].y);
}
myDos.writeDouble (mv.x);
myDos.writeDouble (mv.y);
++ mySnaps;
}
/**
* Close the output stream.
*
* @exception IOException
* Thrown if an I/O error occurred.
*/
public void close()
throws IOException
{
myDos.close();
}
}
/**
* Class AntiprotonFile.Reader provides an object with which to read an
* {@linkplain AntiprotonFile} from an input stream.
*
* When a reader is created, the antiproton file's attributes are read from
* the input stream. Each time the readSnapshot() method is
* called, one snapshot is read from the input stream. When finished, call
* the close() method.
*
* Note: Class AntiprotonFile.Reader is not multiple thread safe.
*
* @author Alan Kaminsky
* @version 05-Feb-2008
*/
public class Reader
{
// Hidden data members.
private InputStream myIs;
private DataInputStream myDis;
private int mySnaps;
// Hidden constructors.
/**
* Construct a new antiproton file reader.
*
* @param theStream Input stream.
*
* @exception NullPointerException
* (unchecked exception) Thrown if theStream is null.
* @exception IOException
* Thrown if an I/O error occurred.
*/
private Reader
(InputStream theStream)
throws IOException
{
if (theStream == null)
{
throw new NullPointerException
("AntiprotonFile.Reader(): theStream is null");
}
myIs = theStream;
myDis = new DataInputStream (theStream);
setAttributes
(/*seed */ myDis.readLong(),
/*R */ myDis.readDouble(),
/*dt */ myDis.readDouble(),
/*steps*/ myDis.readInt(),
/*snaps*/ myDis.readInt(),
/*N */ myDis.readInt(),
/*L */ myDis.readInt(),
/*M */ myDis.readInt());
}
// Exported operations.
/**
* Read a snapshot from the input stream.
*
* The M antiproton positions are stored starting at index
* off in the array p. Note that, depending on how the
* antiproton position array p has been allocated, the argument
* off need not be the same as the attribute L. However,
* the element p[off] must contain the position of antiproton
* L, the element p[off+1] must contain the position of
* antiproton L+1, and so on.
*
* The total momentum of the antiprotons L .. L+M-1
* is also read and is stored in mv.
*
* @param p Array of antiproton positions.
* @param off Index of first array element to store.
* @param mv Total momentum (output).
*
* @return The number of the just-read snapshot. Snapshot numbers start
* at 0.
*
* @exception IllegalStateException
* (unchecked exception) Thrown if snaps snapshots have
* already been read.
* @exception NullPointerException
* (unchecked exception) Thrown if p is null. Thrown if
* mv is null.
* @exception IndexOutOfBoundsException
* (unchecked exception) Thrown if off < 0. Thrown if
* off+M > p.length.
* @exception IOException
* Thrown if an I/O error occurred.
*/
public int readSnapshot
(Vector2D[] p,
int off,
Vector2D mv)
throws IOException
{
if (mySnaps >= snaps)
{
throw new IllegalStateException
("AntiprotonFile.Reader.readSnapshot(): Too many snapshots");
}
if (off < 0 || off+M > p.length)
{
throw new IndexOutOfBoundsException();
}
for (int i = 0; i < M; ++ i)
{
p[i+off].x = myDis.readDouble();
p[i+off].y = myDis.readDouble();
}
mv.x = myDis.readDouble();
mv.y = myDis.readDouble();
return mySnaps ++;
}
/**
* Close the input stream.
*
* @exception IOException
* Thrown if an I/O error occurred.
*/
public void close()
throws IOException
{
myDis.close();
}
}
// Hidden operations.
/**
* Verify whether this antiproton file is initialized.
*
* @exception IllegalStateException
* (unchecked exception) Thrown if this antiproton file is not
* initialized.
*/
private void verifyInitialized()
{
if (! iamInitialized)
{
throw new IllegalStateException
("AntiprotonFile: Not initialized");
}
}
}