FArrayBox.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_FARRAYBOX_H
#define BL_FARRAYBOX_H

//
// $Id: FArrayBox.H,v 1.29 2001/08/02 16:01:43 car Exp $
//

#include <Pointers.H>
#include <Box.H>
#include <BaseFab.H>
#include <REAL.H>
#include <SPACE.H>

class FArrayBox;

//
// :

class FABio
{
public:
    enum Precision
    {
        FAB_FLOAT = 0,
        FAB_DOUBLE
    };
    enum Format
    {
        FAB_ASCII = 0,
        FAB_IEEE,
        FAB_NATIVE,
        //
        // This is set to four so that when reading in an old FAB,
        // we don't get confused when we see an old FAB\_8BITRLE file.
        //
        FAB_8BIT = 4,
        FAB_IEEE_32
    };
    enum Ordering
    {
        FAB_NORMAL_ORDER,
        FAB_REVERSE_ORDER,
        FAB_REVERSE_ORDER_2
    };

    //
    // None of the member functions here are documented with doc++
    // as this class really isn't meant for users.

    //
    //The virtual destructor.
    //
    virtual ~FABio ();
    //
    // Pure virtual function.  Derived classes MUST override this
    // function to read an FArrayBox from the istream, under the
    // assumption that the header has alread been read.
    //
    virtual void read (std::istream& is,
                       FArrayBox&    fb) const = 0;
    //
    // Pure virtual function.  Derived classes MUST override this
    // function to write the FArrayBox to the ostream, under the
    // assumption that the header for the FAB has already been
    // written.  Write it out as if it only had num_comp components
    // with component comp being the first one.
    //
    virtual void write (std::ostream&    os,
                        const FArrayBox& fb,
                        int              comp,
                        int              num_comp) const = 0;
    //
    // Pure virtual function.  Derived classes MUST override this
    // function to skip over the next FAB f in the istream, under the
    // assumption that the header for the FAB f has already been
    // skpped over.
    //
    virtual void skip (std::istream& is,
                       FArrayBox&    f) const = 0;

    virtual void skip (std::istream& is,
                       FArrayBox&    f,
               int           nCompToSkip) const = 0;
    //
    // Write out a header describing FArrayBox f that contains
    // nvar components.  It must be the case that nvar <= f.nComp().
    //
    virtual void write_header (std::ostream&    os,
                               const FArrayBox& f,
                               int              nvar) const;
    //
    // Read in the header from the istream.
    // Returns a new'd FABio of the written-out type.
    // Complements write_header.  The user is responsible
    // for delete'ing the returned FABio*.  The FArrayBox f is
    // resized to be on the Box and number of components read
    // in from the header file.  This is in preparation for
    // next doing a read.  This is split up so that we can make
    // the read functions virtual, while having all the code for
    // detailing the type of FArrayBox that was written out in one place.
    //
    static FABio* read_header (std::istream& is,
                               FArrayBox&    f);

    // Same as above except create a single component fab with
    // data from the compIndex component of the istream fab.
    // Return the number of available components in the istream fab.
    static FABio* read_header (std::istream& is,
                               FArrayBox&    f,
                   int           compIndex,
                   int&          nCompAvailable);
};

// :

class FArrayBox
    :
    public BaseFab<Real>
{
    //
    // FABio is a friend of ours.
    //
    friend class FABio;
public:
    //
    //
    FArrayBox ();
    //
    explicit FArrayBox (const Box& b,
                        int        ncomp=1);
    //
    FArrayBox (const FArrayBox&);
    //
    FArrayBox& operator= (const FArrayBox&);
    FArrayBox& operator= (const Real& r);
    //
    //
    ~FArrayBox ();
    //
    // For debugging purposes we hide BaseFab version and do some extra work.
    //
    void resize (const Box& b,
                 int        N = 1);

    Real norm (int p     = 2,
               int scomp = 0,
               int ncomp = 1) const;
    //
    //
    Real norm (const Box& subbox,
               int        p     = 2,
               int        scomp = 0,
               int        ncomp = 1) const;
    //
    //
    friend std::ostream& operator<< (std::ostream&    os,
                                     const FArrayBox& fb);
    //
    //
    friend std::istream& operator>> (std::istream& is,
                                     FArrayBox&    fb);

    void writeOn (std::ostream& of) const;

    void writeOn (std::ostream& of,
                  int           comp,
                  int           num_comp=1) const;
    //
    //
    void readFrom (std::istream& is);

    int readFrom (std::istream& is, int compIndex);

    static Box skipFAB (std::istream& is,
                        int&          num_comp);
    //
    //
    static void skipFAB (std::istream& is);

    static void setFormat (FABio::Format fmt);
    //
    //
    static FABio::Format getFormat ();

    static void setOrdering (FABio::Ordering ordering);

    static FABio::Ordering getOrdering ();

    static void setPrecision (FABio::Precision precision);

    static FABio::Precision getPrecision ();
    //
    //
    static const FABio& getFABio ();

    static void setFABio (FABio* rd);

    static bool set_do_initval (bool tf);
    static bool get_do_initval ();
    static Real set_initval    (Real iv);
    static Real get_initval    ();
    //
    // Initialize from ParmParse with "fab" prefix.
    //
    static void Initialize ();
    static void Finalize ();

protected:
    //
    // Format and ordering for all FAB output.
    // This stuff exists solely to support reading old FABs.
    //
    static FABio::Format   format;
    static FABio::Ordering ordering;
    //
    // The FABio pointer describing our output format.
    //
    static FABio* fabio;
    //
    // initial value
    //
    static bool do_initval;
    static Real initval;
};

#endif /*BL_FARRAYBOX_H*/

---