All files for dune interface of ALU3DGrid.

git-svn-id: https://dune.mathematik.uni-freiburg.de/svn/alugrid/trunk@150 0d966ed9-3843-0410-af09-ebfb50bd7c74

src/duneinterface/gitter_dune_impl.cc

+// Robert Kloefkorn (c) 2004 - 2005 
+#ifndef GITTER_DUNE_IMPL_CC_INCLUDED
+#define GITTER_DUNE_IMPL_CC_INCLUDED
+
+#include "gitter_dune_impl.h"
+
+void GitterDuneBasis :: backupIndices (ostream & out)
+{
+  // backup indices 
+  bool indices = true; out.put(indices);  // indices == true
+
+  // store max indices 
+  for(int i=0; i< numOfIndexManager ; i++)
+    indexManager(i).backupIndexSet(out);
+
+  { // backup index of elements 
+    AccessIterator <helement_STI> :: Handle ew (container ()) ;
+    for (ew.first () ; ! ew.done () ; ew.next ()) ew.item ().backupIndex (out) ;
+  }
+  {
+    // backup index of vertices 
+    LeafIterator < vertex_STI > w ( *this );
+    for( w->first(); ! w->done() ; w->next () ) w->item().backupIndex(out);
+  }
+
+  return ;
+}
+
+// go down all children and check index 
+inline void GitterDuneBasis :: 
+goDownHelement( Gitter::helement_STI & el , vector<bool> & idxcheck)
+{
+  typedef Gitter :: helement_STI ElType;
+  assert( (static_cast<size_t> (el.getIndex())) < idxcheck.size() );
+  idxcheck[ el.getIndex() ] = false;
+  for( ElType * ch = el.down() ; ch ; ch = ch->next())
+    goDownHelement( *ch , idxcheck );
+
+  return ;
+}
+
+void GitterDuneBasis ::restoreIndices (istream & in) 
+{
+  bool indices = in.get();
+  if(indices)
+  {
+    for(int i=0; i< numOfIndexManager ; i++)
+      this->indexManager(i).restoreIndexSet( in );
+
+    // restore index of elements 
+    {
+      AccessIterator < helement_STI >:: Handle ew(container());
+      for ( ew.first(); !ew.done(); ew.next()) ew.item().restoreIndex (in);
+    }
+    // restore index of vertices
+    {
+      LeafIterator < vertex_STI > w ( *this );
+      for( w->first(); ! w->done() ; w->next () ) w->item().restoreIndex(in);
+    }
+
+    { // reconstruct holes 
+      {
+        enum { elements = 0 };
+        // for elements 
+        int idxsize = this->indexManager(elements).getMaxIndex();
+        vector < bool > checkidx ( idxsize );
+        for(int i=0; i<idxsize; i++) checkidx[i] = true;
+
+        AccessIterator < helement_STI >:: Handle ew(container());
+        for ( ew.first(); !ew.done(); ew.next())
+        {
+          goDownHelement( ew.item() , checkidx );
+        }
+
+        for(int i=0; i<idxsize; i++)
+        {
+          if(checkidx[i] == true)
+            this->indexManager(elements).freeIndex(i);
+        }
+      }
+      {
+        enum { vertices = 3 };
+        // for vertices 
+        LeafIterator < vertex_STI > w ( *this );
+        int idxsize = this->indexManager(vertices).getMaxIndex();
+
+        vector < bool > checkidx ( idxsize );
+        for(int i=0; i<idxsize; i++) checkidx[i] = true;
+        for( w->first(); ! w->done() ; w->next () )
+        {
+          assert( (static_cast<size_t> (w->item().getIndex())) < checkidx.size() );
+          checkidx[ w->item().getIndex() ] = false;
+        }
+
+        for(int i=0; i<idxsize; i++)
+        {
+          if(checkidx[i] == true)
+            this->indexManager(vertices).freeIndex(i);
+        }
+      }
+    }
+  }
+  else 
+  {
+    cerr<< "WARNING: indices not read! file = "<< __FILE__ << ", line = " << __LINE__ << "\n";
+  }
+    
+  return ;
+}
+
+// wird von Dune verwendet 
+void GitterDuneBasis :: duneBackup (const char * fileName)
+{
+  // diese Methode wird von der Dune Schnittstelle aufgerufen und ruft
+  // intern lediglich backup (siehe oben) und backupCMode des Makrogitters
+  // auf, allerdings wird hier der path und filename in einer variablen
+  // uebergeben 
+
+  assert (debugOption (20) ? (cout << "**INFO GitterDuneBasis :: duneBackup (const char * = \""
+                       << fileName << "\") " << endl, 1) : 1) ;
+
+  ofstream out (fileName) ;
+  if (!out) {
+    cerr << "**WARNUNG (IGNORIERT) GitterDuneBasis :: duneBackup (const char *, double) Fehler beim Anlegen von < "
+         << (fileName ? fileName : "null") << " >" << endl ;
+  }
+  else
+  {
+    FSLock lock (fileName) ;
+    Gitter :: backup (out) ;
+    GitterDuneBasis :: backupIndices (out) ;
+
+    {
+      char *fullName = new char[strlen(fileName)+20];
+      if(!fullName)
+      {
+        cerr << "**WARNUNG GitterDuneBasis :: duneBackup (, const char *, double) :";
+        cerr << "couldn't allocate fullName! " << endl;
+        abort();
+      }
+      sprintf(fullName,"%s.macro",fileName);
+      ofstream macro (fullName) ;
+
+      if(!macro)
+      {
+        cerr << "**WARNUNG (IGNORIERT) GitterDuneBasis :: duneBackup (const char *, const char *) Fehler beim Anlegen von < "
+         << (fullName ? fullName : "null") << " >" << endl ;
+      }
+      else
+      {
+        container ().backupCMode (macro) ;
+      }
+      delete [] fullName;
+    }
+  }
+  return ;
+}
+
+// wird von Dune verwendet 
+void GitterDuneBasis :: duneRestore (const char * fileName)
+{
+  // diese Methode wird von der Dune Schnittstelle aufgerufen 
+  // diese Methode ruft intern restore auf, hier wird lediglich 
+  // der path und filename in einer variablen uebergeben
+
+  assert (debugOption (20) ? (cout << "**INFO GitterDuneBasis :: duneRestore (const char * = \""
+                 << fileName << "\") " << endl, 1) : 1) ;
+
+  ifstream in (fileName) ;
+  if (!in) {
+    cerr << "**WARNUNG (IGNORIERT) GitterDuneBasis :: duneRestore (const char *, double & ) Fehler beim \"Offnen von < "
+         << (fileName ? fileName : "null") << " > " << endl ;
+  } else {
+    Gitter :: restore (in) ;
+    GitterDuneBasis :: restoreIndices (in);
+  }
+  return ;
+}
+
+
+#endif

src/duneinterface/gitter_dune_impl.h

+#ifndef GITTER_DUNE_IMPL_H_INCLUDED
+#define GITTER_DUNE_IMPL_H_INCLUDED
+
+#include "gitter_impl.h"
+#include "lock.h"
+
+class GitterDuneBasis :  public virtual GitterBasis 
+{
+protected:
+  void backupIndices  (ostream & out);
+  void restoreIndices (istream & in );
+
+  inline void goDownHelement( helement_STI & el , vector<bool> & idxcheck);
+  
+public:
+  // write status of grid  
+  virtual void duneBackup  (const char*) ; 
+
+  // read status of grid 
+  virtual void duneRestore (const char*) ;
+  // Constructor getting macro file name 
+};
+
+class GitterDuneImpl : public GitterBasisImpl , public GitterDuneBasis 
+{
+public:
+  inline GitterDuneImpl (const char *filename) : GitterBasisImpl ( filename ) {}
+};
+
+#endif

src/duneinterface/gitter_dune_pll_impl.h

+#ifndef GITTER_DUNE_PLL_IMPL_H_INCLUDED
+#define GITTER_DUNE_PLL_IMPL_H_INCLUDED
+
+#ifdef _ANSI_HEADER
+  using namespace std;
+  #include <numeric>
+#else
+#endif
+
+#include "gitter_dune_impl.h"
+ 
+#include "gitter_pll_impl.h"
+#include "gitter_pll_ldb.h"
+  
+static bool writeLogFile = false;
+
+class GitterDunePll : public GitterBasisPll , public virtual GitterDuneBasis
+{
+  
+protected:  
+  bool balanceGrid_;
+
+public:
+  typedef Gitter :: Geometric Geometric;
+  typedef GitterDuneImpl :: Objects  Objects;
+  
+  GitterDunePll (const char * filename , MpAccessLocal &mp) 
+    : GitterBasisPll (filename,mp) , balanceGrid_ (false) 
+  {
+    // logfile is defined in gitter_impl.h    
+    /*
+    char logFileName [32];
+    sprintf(logFileName,"logfile.%d",mpAccess().myrank());
+    cerr << "open logfile = " << logFileName << "\n";
+
+    logFile.close();
+    logFile.open (logFileName);
+    logFile << "logfile of processor " << mpAccess().myrank() << "\n";
+    */
+  };
+
+  ~GitterDunePll () {
+    /*
+    logFile.close();
+    */
+  }
+
+  bool refine (); 
+
+  void coarse ();
+
+  // done call notify and loadBalancer  
+  bool duneAdapt ();
+
+  // return true if grid has to be balanced again 
+  bool duneNotifyNewGrid ();
+
+  bool duneLoadBalance () ; // call loadBalancer 
+  bool duneLoadBalance (GatherScatterType & ) ; // call loadBalancer a
+
+  void duneRepartitionMacroGrid (LoadBalancer :: DataBase &, GatherScatterType & gs) ;
+  void repartitionMacroGrid (LoadBalancer :: DataBase &) ;
+ 
+  // notifyGridChanges for dune
+  void duneNotifyGridChanges (); 
+  
+  // exchange changed elements  
+  void duneExchangeDynamicState ();
+  
+  // exchange data of dune 
+  void duneExchangeData (GatherScatterType &);
+
+  // return indexmanger 
+  IndexManagerType & indexManager(int codim)
+  {
+    return containerPll().indexManager(codim);
+  }
+
+};
+#endif