---

FluxBox.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/

// FluxBox.H

//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//
// Dan Martin, Fri, Jan 14, 2000

#ifndef _FluxBox_H_
#define _FluxBox_H_

#include "Box.H"
#include "Vector.H"
#include "FArrayBox.H"

class FluxBox
{

public:
  FluxBox();

  FluxBox(const Box& bx, int n=1);

  ~FluxBox();

  void resize(const Box& bx, int n=1);

  void define(const Box& bx, int n=1);

  void clear();


  int nComp() const;

  const Box& box() const;

  FArrayBox& getFlux(const int dir);

  const FArrayBox& getFlux(const int dir) const;

  FArrayBox& operator[] (const int dir);

  const FArrayBox& operator[] (const int dir) const;


  void setVal(const Real val);

  void setVal(const Real val, const int dir);

  void setVal(const Real val, const int dir, const int startComp,
              const int nComp);

  void setVal(const Real val, const Box& bx);

  /*@ManMemo: most specific setVal -- sets fluxes on edges surrounding 
    cell-centered box bx */
  void setVal(const Real val, const Box& bx, const int dir, 
              const int startComp, const int nComp);

  void copy(const FluxBox& src);

  void copy(const FluxBox& src, const int srcComp, 
            const int destComp, const int numComp);

  void copy(const FluxBox& src, const int dir, const int srcComp,
            const int destComp, const int numComp);

  /*@ManMemo: copies from a subsection of one box into another. 
    Assumes the boxes are both in the same index space, and that 
    box R is completely contained in both the src and destination 
    boxes.  This function required by BoxLayoutData */
  void copy(const Box& R, const Interval& Cdest,  const FluxBox& src,
            const Interval& Csrc);

  /*@ManDoc: Modifies this FluxBox by coping the contents of the
               argument FluxBox into it.  This, the most general form
               of copy, specifies the contents of any sub-box srcbox
               in `FluxBox' src may be copied into a (possibly
               different) destbox in the destination `FluxBox'.  Note
               that although the srcbox and the destbox may be
               disjoint, they must be the same size and shape.  If the
               sizes differ, the copy is undefined and a runtime error
               results.  This copy function is the only one of the
               copy functions to allow a copy between differing
               boxes. The user also specifies how many components are
               copied, starting at component srccomp in src and stored
               starting at component destcomp.  The results are
               UNDEFINED if the src and dest FluxBoxes are the same and
               the srcbox and destbox overlap.
*/
  void copy (const Box&        srcbox,
             const Interval&   srccomps,
             const Box&        destbox,
             const FluxBox&    src,
             const Interval&    destcomps);

  


  FluxBox& shift (const IntVect& v);


  
  /*@ManMemo: returns size, in number of bytes, of a flat linear
    representation of data in components comps in edges around 
    cell-centered box R */
  int size(const Box& bx, const Interval& comps) const;


  /*@ManMemo:Write a linear representaion of the internal data for
    the edges surrounding cell-centered box R.  Assumes that sufficient
    memory for the buffer has already been allocated by the caller */
  void linearOut(void*buf, const Box& R, const Interval& comps) const;
  
  void linearIn(void* buf);

  void linearIn(void*buf, const Box& R, const Interval& comps);

  static int preAllocatable() {return 0;}

  

protected:
  Box m_bx;

  int m_nvar;

  Vector<FArrayBox*> m_fluxes;


private:
  
  FluxBox (const FluxBox&);
  FluxBox& operator = (const FluxBox&);

};

  

#endif

---