GridBDataWriter.h

#ifndef gridripper_amr1d_io_GridBDataWriter_h
#define gridripper_amr1d_io_GridBDataWriter_h

#include <gridripper/io/BDataFlags.h>
#include <gridripper/amr1d/Grid.h>
#include <gridripper/amr1d/GridIterator.h>
#include <gridripper/io/IOException.h>
#include <gridripper/tvalarray.h>
#include <iostream>

namespace gridripper { namespace amr1d { namespace io {

using namespace gridripper::io;
using namespace gridripper::amr1d;

class GridBDataWriter
{
    // File format.
    //
    // Header Block
    //      0   8 double T
    //      8   4 int    numGridPoints
    //     12   2 short  nc    (number of components)
    //     14   4 int    flags
    //     18   4 int    baseGrid.maxi + 1
    //     22   4 int    xmultiplier = r^maxAllowedLevel
    //     26   8 double dx
    // end
    // Block 1 if (flags & 2) != 0
    //      0   4 int    numBytes
    //      4   4 int    numLevels
    //     for i to numLevels
    //         x   4 int    numGrids
    //         for j to numGrids
    //             x   4 int timeStepCount
    //             x   4 int lastRegridTime
    //         end
    //     end
    // end
    // Block 2 if (flags & 32) != 0
    //      0   2 int    numConstraintEqs
    //      2   2 int    numAuxQuantities (unused)
    // end
    // Block 3 if (flags & 128) != 0
    //      for i to nc
    //             x   2     short   size
    //             x   size  byte[]  <name of field i>
    //      end
    // end
    // Main Block
    //      for i to numGridPoints
    //          if (flags & 1024) == 0
    //              0           4 int    kx = x/dx
    //          for j to nc
    //              if (flags & (256|512)) == BDATA_FIELD_PREC_FLOAT (=256)
    //                  0       4 float f[i]
    //              else if (flags & (256|512)) == BDATA_FIELD_PREC_DOUBLE (=0)
    //                  0       8 double f[i]
    //          end
    //          for j to numConstraintEqs
    //              x       4 float constraintEqLHS
    //              x       4 float constraintEqRHS
    //              if (flags & 64) != 0
    //                  x       4 float constraintEqLHS-constraintEqRHS
    //              end
    //          end
    //          Block 4 if (flags & 4) != 0
    //              0       8 double energyDensity
    //          end
    //          Block 5 if (flags & 1) != 0 && kx % xmultiplier == 0
    //              0       8 double energyLoss[kx/xmultiplier]
    //          end
    //      end
    // end

private:
    static int MAXBUFSIZE;

    int refinementRatio;
    int maxAllowedLevel;

    const tvalarray< tvector<Grid*> >& grids;
    int finestLevel;
    GridIterator gridIterator;
    int numGridPoints;
    int block1NumBytes;

public:
    GridBDataWriter(int r, int maxlevel, const tvalarray< tvector<Grid*> >& g,
                int finestl);

    int getBestBufSize() const;

    void write(ostream& os) throw(IOException&);
};

} } } // namespace gridripper::amr1d::io

#endif /* gridripper_amr1d_io_GridBDataWriter_h */