mesh_operators.hpp

Go to the documentation of this file.

// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
// reserved. See file COPYRIGHT for details.
//
// This file is part of the MFEM library. For more information and source code
// availability see http://mfem.org.
//
// MFEM is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License (as published by the Free
// Software Foundation) version 2.1 dated February 1999.

#ifndef MFEM_MESH_OPERATORS
#define MFEM_MESH_OPERATORS

#include "../config/config.hpp"
#include "../general/array.hpp"
#include "mesh.hpp"
#include "../fem/estimators.hpp"

#include <limits>

namespace mfem
{

class MeshOperator
{
private:
   int mod;

protected:
   friend class MeshOperatorSequence;

   virtual int ApplyImpl(Mesh &mesh) = 0;

   MeshOperator() : mod(NONE) { }

public:
   enum Action
   {
      NONE        = 0, 
      CONTINUE    = 1, 
      STOP        = 2, 
      REPEAT      = 3, 
      MASK_UPDATE = 1, 
      MASK_ACTION = 3  
   };

   enum Info
   {
      REFINED     = 4*1, 
      DEREFINED   = 4*2, 
      REBALANCED  = 4*3, 
      MASK_INFO   = ~3   
   };

   bool Apply(Mesh &mesh) { return ((mod = ApplyImpl(mesh)) & MASK_UPDATE); }

   bool Stop() const { return ((mod & MASK_ACTION) == STOP); }
   bool Repeat() const { return ((mod & MASK_ACTION) == REPEAT); }
   bool Continue() const { return ((mod & MASK_ACTION) == CONTINUE); }

   bool Refined() const { return ((mod & MASK_INFO) == REFINED); }
   bool Derefined() const { return ((mod & MASK_INFO) == DEREFINED); }
   bool Rebalanced() const { return ((mod & MASK_INFO) == REBALANCED); }

   int GetActionInfo() const { return mod; }

   virtual void Reset() = 0;

   virtual ~MeshOperator() { }
};


class MeshOperatorSequence : public MeshOperator
{
protected:
   int step;
   Array<MeshOperator*> sequence; 

   MeshOperatorSequence(const MeshOperatorSequence &) { }

   virtual int ApplyImpl(Mesh &mesh);

public:
   MeshOperatorSequence() : step(-1) { }

   virtual ~MeshOperatorSequence();

   void Append(MeshOperator *mc) { sequence.Append(mc); }

   Array<MeshOperator*> &GetSequence() { return sequence; }

   virtual void Reset();
};


class ThresholdRefiner : public MeshOperator
{
protected:
   ErrorEstimator &estimator;
   AnisotropicErrorEstimator *aniso_estimator;

   double total_norm_p;
   double total_err_goal;
   double total_fraction;
   double local_err_goal;
   long   max_elements;

   double threshold;
   long num_marked_elements;

   Array<Refinement> marked_elements;
   long current_sequence;

   int non_conforming;
   int nc_limit;

   double GetNorm(const Vector &local_err, Mesh &mesh) const;

   virtual int ApplyImpl(Mesh &mesh);

public:
   ThresholdRefiner(ErrorEstimator &est);

   // default destructor (virtual)

   void SetTotalErrorNormP(double norm_p =
                              std::numeric_limits<double>::infinity())
   { total_norm_p = norm_p; }

   void SetTotalErrorGoal(double err_goal) { total_err_goal = err_goal; }

   void SetTotalErrorFraction(double fraction) { total_fraction = fraction; }

   void SetLocalErrorGoal(double err_goal) { local_err_goal = err_goal; }

   void SetMaxElements(long max_elem) { max_elements = max_elem; }

   void PreferNonconformingRefinement() { non_conforming = 1; }

   void PreferConformingRefinement() { non_conforming = -1; }

   void SetNCLimit(int nc_limit)
   {
      MFEM_ASSERT(nc_limit >= 0, "Invalid NC limit");
      this->nc_limit = nc_limit;
   }

   long GetNumMarkedElements() const { return num_marked_elements; }

   double GetThreshold() const { return threshold; }

   virtual void Reset();
};

// TODO: BulkRefiner to refine a portion of the global error


class ThresholdDerefiner : public MeshOperator
{
protected:
   ErrorEstimator &estimator;

   double threshold;
   int nc_limit, op;

   virtual int ApplyImpl(Mesh &mesh);

public:
   ThresholdDerefiner(ErrorEstimator &est)
      : estimator(est)
   {
      threshold = 0.0;
      nc_limit = 0;
      op = 1;
   }

   // default destructor (virtual)

   void SetThreshold(double thresh) { threshold = thresh; }

   void SetOp(int op) { this->op = op; }

   void SetNCLimit(int nc_limit)
   {
      MFEM_ASSERT(nc_limit >= 0, "Invalid NC limit");
      this->nc_limit = nc_limit;
   }

   virtual void Reset() { estimator.Reset(); }
};


class Rebalancer : public MeshOperator
{
protected:
   virtual int ApplyImpl(Mesh &mesh);

public:
   virtual void Reset() { }
};

} // namespace mfem

#endif // MFEM_MESH_OPERATORS