---

GenLevelOpImplem.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/
*/
//
// 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.
//

#ifndef _GENLEVELOPIMPLEM_H_
#define _GENLEVELOPIMPLEM_H_

#include "DataIterator.H"

template <class T>
void GenLevelOp<T>::setToZero(LevelData<T>& a_one)
{
  DataIterator dit = a_one.dataIterator();

  for (dit.reset(); dit.ok(); ++dit)
  {
      a_one[dit()].setVal(0.0);
  }
}

template <class T>
void GenLevelOp<T>::copy(LevelData<T>&       a_one,
                         const LevelData<T>& a_two)
{
  DataIterator dit = a_two.dataIterator();
  Interval comps(0,a_two.nComp());

  for (dit.reset(); dit.ok(); ++dit)
  {
    Box box = a_one[dit()].box();

    a_one[dit()].copy(box,comps,box,a_two[dit()],comps);
  }
}

template <class T>
void GenLevelOp<T>::scalarMul(LevelData<T>& a_one,
                              const Real    a_scalar)
{
  DataIterator dit = a_one.dataIterator();

  for (dit.reset(); dit.ok(); ++dit)
  {
      a_one[dit()] *= a_scalar;
  }
}

template <class T>
void GenLevelOp<T>::negate(LevelData<T>& a_one)
{
  DataIterator dit = a_one.dataIterator();

  for (dit.reset(); dit.ok(); ++dit)
  {
    a_one[dit()].negate();
  }
}

template <class T>
void GenLevelOp<T>::sum(LevelData<T>&       a_one,
                        const LevelData<T>& a_two)
{
  DataIterator dit = a_two.dataIterator();

  for (dit.reset(); dit.ok(); ++dit)
  {
    a_one[dit()] += a_two[dit()];
  }
}

template <class T>
void GenLevelOp<T>::diff(LevelData<T>&       a_one,
                         const LevelData<T>& a_two)
{
  DataIterator dit = a_two.dataIterator();

  for (dit.reset(); dit.ok(); ++dit)
  {
    a_one[dit()] -= a_two[dit()];
  }
}

template <class T>
Real GenLevelOp<T>::dotProduct(const LevelData<T>& a_one,
                               const LevelData<T>& a_two)
{
  DataIterator dit = a_two.dataIterator();
  Real dotProduct = 0.0;

  for (dit.reset(); dit.ok(); ++dit)
  {
    dotProduct += a_one[dit()].dotProduct(a_two[dit()]);
  }

#ifdef MPI
  Real recv;
  int result = MPI_Allreduce(&dotProduct, &recv, 1, MPI_CH_REAL,
                             MPI_SUM, Chombo_MPI::comm);

  if (result != MPI_SUCCESS)
  {
    MayDay::Error("Error in MPI_Allreduce to sum dot products");
  }

  dotProduct = recv;
#endif

  return dotProduct;
}

template <class T>
Real GenLevelOp<T>::norm(const LevelData<T>& a_one,
                         const int           a_power)
{
  const DisjointBoxLayout& boxes = a_one.disjointBoxLayout();
  Real norm = 0.0;
  int startComp = 0;
  int numComp = a_one.nComp();

  assert(a_power >= 0);

  DataIterator dit = a_one.dataIterator();

  if (a_power == 0)
  {
    for (dit.reset(); dit.ok(); ++dit)
    {
      norm = Max(norm, a_one[dit()].norm(boxes[dit()], a_power,
                                         startComp, numComp));
    }

#ifdef MPI
    Real recv;
    int result = MPI_Allreduce(&norm, &recv, 1, MPI_CH_REAL,
                               MPI_MAX, Chombo_MPI::comm);

    if (result != MPI_SUCCESS)
    {
      MayDay::Error("Error in MPI_Allreduce to sum norms");
    }

    norm = recv;
#endif
  }
  else if (a_power == 1)
  {
    for (dit.reset(); dit.ok(); ++dit)
    {
      norm += a_one[dit()].norm(boxes[dit()], a_power,
                                startComp, numComp);
    }

#ifdef MPI
    Real recv;
    int result = MPI_Allreduce(&norm, &recv, 1, MPI_CH_REAL,
                               MPI_SUM, Chombo_MPI::comm);

    if (result != MPI_SUCCESS)
    {
      MayDay::Error("Error in MPI_Allreduce to sum norms");
    }

    norm = recv;
#endif
  }
  else
  {
    for (dit.reset(); dit.ok(); ++dit)
    {
      norm += a_one[dit()].sumPow(boxes[dit()], a_power,
                                  startComp, numComp);
    }

#ifdef MPI
    Real recv;
    int result = MPI_Allreduce(&norm, &recv, 1, MPI_CH_REAL,
                               MPI_SUM, Chombo_MPI::comm);

    if (result != MPI_SUCCESS)
    {
      MayDay::Error("Error in MPI_Allreduce to sum norms");
    }

    norm = recv;
#endif

    norm = pow(norm, 1.0/a_power);
  }

  return norm;
}

template <class T>
void GenLevelOp<T>::defineOpData(LevelData<T>& a_data)
{
#if FIXIT
#endif
}

template <class T>
void GenLevelOp<T>::defineData(LevelData<T>& a_data)
{
#if FIXIT
#endif
}

#endif

---