src/expde/grid/printpa.cc

Go to the documentation of this file.

//    expde: expression templates for partial differential equations.
//    Copyright (C) 2001  Christoph Pflaum
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//                 SEE  Notice1.doc made by 
//                 LAWRENCE LIVERMORE NATIONAL LABORATORY
//

// ------------------------------------------------------------
//
// print_pa.cc
//
// ------------------------------------------------------------



// Include level 0:
#ifdef COMP_GNUOLD
 #include <iostream.h>
 #include <fstream.h>
 #include <time.h>
 #include <math.h>
 #define Problemzeile  Datei->setf(ios::scientific,ios::floatfield);       
#else
 #include <iostream>
 #include <fstream>
 #include <ctime>
 #include <cmath>
 #define Problemzeile  Datei->setf(std::ios::scientific,std::ios::floatfield);
#endif 
  
// Include level 0:
#include "../parser.h"

// Include level 1:
#include "../paramete.h"
#include "../abbrevi.h"
#include "../math_lib/math_lib.h"
 
// Include level 2:
#include "../basic/basic.h"

// Include level 3:
#include "../domain/domain.h"

// Include level 4:
#include "../formulas/boundy.h"
#include "../formulas/loc_sten.h"

// Include level 5:
#include "gpar.h"
#include "parallel.h"
#include "mgcoeff.h"
#include "sto_man.h"
#include "gridbase.h"
#include "grid.h"


// 1. coarese level
// 2. finest  level
// 3. region  level
// 4. surface level
// 5. cells



// 1. coarese level


void Grid_base::Print_Variable_AVS_parallel(ofstream *Datei, int number_var,
                                            int level) {
  int number_cells;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind, I;

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print_Variable_AVS! Initialisierung fehlt! "
         << endl;
    return;
  }
  if(Give_max_num_var() <= number_var) {
    cout << " \n Fehler in Print_Variable_AVS! number_var zu gross! " << endl;
  }
  else {
    // Teil 0: Write information
    if(my_rank==0) {
      *Datei << "# File created by ExPDE " << endl;
      *Datei << "# UCD file format for AVS parallel " << endl;
      *Datei << "# scalar value " << endl;
    }

    /* Teil 1: Anzahl der Zellen zaehlen */
    number_cells = 0;
    if(I_am_active()) {
      /* Teil 1.1: Innerer Zellen */
      iterate_hash0 {
        I = point0->Give_Index();
        if(I<<my_index && I.Cell_index() 
           && (Celltype)point0->typ == int_cell && I.Tiefe() == level+1) {
          number_cells = number_cells + 6;
        }
      }
    }
    /* Teil 1.3: Anzahl der Punkte */
    number_points=0;
    if(I_am_active()) {
      /* a) innen und randnah */
      iterate_hash1 {
        I = point1->Give_Index();
        if(point1->typ != exterior 
           && I.Tiefe()            <= level // for excluding too fine points
           && point1->finest_level >= level // for excluding too coarse
           && I<<my_index) {                // for responsibility
          point1->nummer = number_points;
          number_points++;
        }
        else point1->nummer = -1;
      }
    }
    /* Teil 1.5: gather data */  
    n_proc = give_number_of_processes(); 
    number_cells_process = new int[n_proc]; 
    number_points_process = new int[n_proc]; 
    MPI_Gather(&number_points,1,MPI_INT,number_points_process,1,MPI_INT, 
               0,comm); 
    MPI_Gather(&number_cells,1,MPI_INT,number_cells_process,1,MPI_INT, 
               0,comm); 
    total_number_points =0; 
    total_number_cells =0; 
    max_number_points =0; 
    max_number_cells =0; 
    for(i=0;i<n_proc;++i) { 
      total_number_points = total_number_points + number_points_process[i]; 
      total_number_cells  = total_number_cells  + number_cells_process[i]; 
    } 
    for(i=0;i<n_proc;++i) { 
      if(number_points_process[i] > max_number_points) 
        max_number_points = number_points_process[i]; 
      if(number_cells_process[i] > max_number_cells) 
        max_number_cells = number_cells_process[i]; 
    } 
    /* Teil 1.7: make buffer */
    if(my_rank==0) { 
      buffer_rec_int    = new int[max_number_cells  * 4]; 
      buffer_rec_double = new double[max_number_points * 3]; 
    } 
    buffer_send_int    = new int[number_cells  * 4]; 
    buffer_send_double = new double[number_points * 3]; 
    /* Teil 1.6: Kopfzeile schreiben */  
    if(my_rank==0) { 
      *Datei << total_number_points << " " 
             << total_number_cells << " 1 0 0" << endl; 
    } 
    /* Teil 2: Koordinaten der Punkte eingeben */ 
    /* a) set values in buffer */ 
    if(I_am_active()) { 
      /* i) alle inneren Punkte */
      iterate_hash1 { 
        if(point1->nummer != -1) { 
          loc = transform_coord(point1->ind.coordinate()); 
          buffer_send_double[point1->nummer*3]   = loc.x; 
          buffer_send_double[point1->nummer*3+1] = loc.y; 
          buffer_send_double[point1->nummer*3+2] = loc.z; 
        } 
      } 
    }
    /* b) send */
    if(my_rank!=0) { 
      MPI_Send(buffer_send_double,number_points * 3, 
               MPI_DOUBLE,0,50,comm); 
    } 
    else { 
      start_num=0; 
      for(i=0;i<n_proc;++i) { 
        /* c) receive */
        if(i!=0) { 
          MPI_Recv(buffer_rec_double,number_points_process[i] * 3, 
                   MPI_DOUBLE,i,50,comm,&status); 
        } 
        else { 
          for(num=0;num<number_points_process[i];++num) { 
            buffer_rec_double[num*3]   = buffer_send_double[num*3]; 
            buffer_rec_double[num*3+1] = buffer_send_double[num*3+1]; 
            buffer_rec_double[num*3+2] = buffer_send_double[num*3+2]; 
          } 
        } 
        /* d) print in file */ 
        for(num=0;num<number_points_process[i];++num) { 
          loc.x =  buffer_rec_double[num*3]; 
          loc.y =  buffer_rec_double[num*3+1]; 
          loc.z =  buffer_rec_double[num*3+2];
          
          *Datei << start_num+num 
                 << " " << fixed << loc.x   
                 << " " << fixed << loc.y   
                 << " " << fixed << loc.z 
                 << "\n"; 
        } 
        start_num = start_num + number_points_process[i]; 
      } 
    } 
    /* Teil 3: Zellen ausgeben */    
    /* a) set values in buffer */    
    if(I_am_active()) {
      number_cells = 0;
      /* Teil 1.1: Innerer Zellen */
      iterate_hash0 {
        I = point0->Give_Index();
        if(I<<my_index && I.Cell_index() 
           && (Celltype)point0->typ == int_cell && I.Tiefe() == level+1) {
          number_cells = Write_Cells_AVS_parallel(I,
                                                  number_cells,
                                                  buffer_send_int);
        }
      }
    }
    /* b) send */  
    if(my_rank!=0) {  
      MPI_Send(buffer_send_int,number_cells * 4, 
               MPI_INT,0,51,comm); 
    } 
    else { 
      start_num=0; 
      start_poi=0; 
      for(i=0;i<n_proc;++i) { 
        /* c) receive */ 
        if(i!=0) { 
          MPI_Recv(buffer_rec_int,number_cells_process[i] * 4, 
                   MPI_INT,i,51,comm,&status); 
        } 
        else { 
          for(num=0;num<number_cells_process[i];++num) { 
            buffer_rec_int[num*4]   = buffer_send_int[num*4];  
            buffer_rec_int[num*4+1] = buffer_send_int[num*4+1];  
            buffer_rec_int[num*4+2] = buffer_send_int[num*4+2];  
            buffer_rec_int[num*4+3] = buffer_send_int[num*4+3];  
          } 
        } 
       /* d) print in file */   
        if(i<n_proc) { 
          for(num=0;num<number_cells_process[i];++num) { 
            *Datei << start_num+num+1 << " 1 tet " 
                   << " " << start_poi + buffer_rec_int[num*4]  
                   << " " << start_poi + buffer_rec_int[num*4+1]  
                   << " " << start_poi + buffer_rec_int[num*4+2]  
                   << " " << start_poi + buffer_rec_int[num*4+3]  
                   << "\n"; 
          } 
        } 
        start_num = start_num + number_cells_process[i]; 
        start_poi = start_poi + number_points_process[i]; 
      } 
    } 
    if(my_rank==0) { 
      /* Teil 4: */
      *Datei << "1 1" << "\n";


      /*
      // Teil 5:
      *Datei << "processes " << "\n";

      // Teil 6: Print number of processor
      start_num=0;
      for(i=0;i<n_proc;++i) {
        for(num=0;num<number_points_process[i];++num) {
          *Datei << start_num+num << "   " << i  << "\n";
        }
        start_num = start_num + number_points_process[i];
      }
      *Datei << endl;
      */

     // Teil 5:
      *Datei << "variable, unit " << "\n";
    }

    if(I_am_active()) {
      // Teil 2: Koordinaten der Punkte eingeben
      // a) set values in buffer
      // i) alle inneren Punkte
      iterate_hash1 {
        if(point1->nummer != -1) {
          buffer_send_double[point1->nummer] = 
            Give_variable(point1->ind,level)[number_var];
        }
      }
    }

    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,number_points,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,number_points_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<number_points_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_points_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[num]
                   << "\n";
          }
        }
        start_num = start_num + number_points_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
      delete(number_cells_process);
      delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }
  MPI_Barrier(comm);
}


// 2. finest level

#define Macro_PRINT_Einsetzen  \
    /* Teil 1: Anzahl der Zellen zaehlen */ \
    number_cells = 0; \
    if(I_am_active()) { \
    /* Teil 1.1: Innerer Zellen */ \
    ind = my_index; \
    number_cells = Recursion_Count_Cells(ind); \
    /* Teil 1.2: Randzellen */  \
    iterate_hash2 { \
        if(bocell->Give_Index()<<my_index) \
          number_cells = avs_bo_cell(bocell,Datei,false,number_cells); \
      } \
    } \
    /* Teil 1.3: Anzahl der Punkte */ \
    number_points=0; \
    if(I_am_active()) { \
      /* a) innen und randnah */ \
      iterate_hash1 { \
        if((point1->typ >= interior || point1->typ==parallel_p) && \
           point1->Give_Index()<<my_index && \
           point1->finest_level == max_level) { \
          point1->nummer = number_points; \
          number_points++; \
        } \
        else point1->nummer = -1; \
      } \
    /* b) Randpunkte */  \
      iterate_hash3 {  \
        bo2point->Set_number_avs(number_points);  \
        ++number_points;  \
      }  \
    /* c) Randzellfreiheitsgrad */  \
      iterate_hash2 {  \
        if(bocell->Give_Index()<<my_index) {  \
          if(bocell->Exists_bocellpoint()) {  \
            bocell->Set_number_avs(number_points);  \
            number_points++;  \
          } \
        } \
      } \
    } \
    /* Teil 1.5: gather data */   \
    n_proc = give_number_of_processes();  \
    number_cells_process = new int[n_proc];  \
    number_points_process = new int[n_proc];  \
    MPI_Gather(&number_points,1,MPI_INT,number_points_process,1,MPI_INT,  \
               0,comm);  \
    MPI_Gather(&number_cells,1,MPI_INT,number_cells_process,1,MPI_INT,  \
               0,comm);  \
    total_number_points =0;  \
    total_number_cells =0;  \
    max_number_points =0;  \
    max_number_cells =0;  \
    for(i=0;i<n_proc;++i) {  \
      total_number_points = total_number_points + number_points_process[i];  \
      total_number_cells  = total_number_cells  + number_cells_process[i];  \
    }  \
    for(i=0;i<n_proc;++i) {  \
      if(number_points_process[i] > max_number_points)  \
        max_number_points = number_points_process[i];  \
      if(number_cells_process[i] > max_number_cells)  \
        max_number_cells = number_cells_process[i];  \
    }  \
    /* Teil 1.7: make buffer */ \
    if(my_rank==0) {  \
      buffer_rec_int    = new int[max_number_cells  * 4];  \
      buffer_rec_double = new double[max_number_points * 3];  \
    }  \
    buffer_send_int    = new int[number_cells  * 4];  \
    buffer_send_double = new double[number_points * 3];  \
    /* Teil 1.6: Kopfzeile schreiben */   \
    if(my_rank==0) {  \
      *Datei << total_number_points << " "  \
             << total_number_cells << " " \
             << number_of_vars << " 0 0" << endl;  \
    }  \
    /* Teil 2: Koordinaten der Punkte eingeben */  \
    /* a) set values in buffer */  \
    if(I_am_active()) {  \
      /* i) alle inneren Punkte */ \
      iterate_hash1 {  \
        if(point1->nummer != -1) {  \
          loc = transform_coord(point1->ind.coordinate());  \
          buffer_send_double[point1->nummer*3]   = loc.x;  \
          buffer_send_double[point1->nummer*3+1] = loc.y;  \
          buffer_send_double[point1->nummer*3+2] = loc.z;  \
        }  \
      }  \
    /* ii) alle Randpunkte */   \
      iterate_hash3 {  \
        loc = bo2point->transform_coord(Give_A(),H_mesh());  \
        buffer_send_double[bo2point->nummer*3]   = loc.x;  \
        buffer_send_double[bo2point->nummer*3+1] = loc.y;  \
        buffer_send_double[bo2point->nummer*3+2] = loc.z;  \
      }  \
    /* iii) alle Randzellfreiheitsgrad */   \
      iterate_hash2 {  \
        if(bocell->Give_Index()<<my_index) {  \
          if(bocell->Exists_bocellpoint()) {  \
            loc =  transform_coord(bocell->ind.coordinate()) +   \
              bocell->Local_coord_bocellpoint();  \
            buffer_send_double[bocell->Number_avs()*3]   = loc.x;  \
            buffer_send_double[bocell->Number_avs()*3+1] = loc.y;  \
            buffer_send_double[bocell->Number_avs()*3+2] = loc.z;  \
          }  \
        }  \
      }  \
    }  \
    /* b) send */ \
    if(my_rank!=0) {  \
      MPI_Send(buffer_send_double,number_points * 3,  \
               MPI_DOUBLE,0,50,comm);  \
    }  \
    else {  \
      start_num=0;  \
      for(i=0;i<n_proc;++i) {  \
        /* c) receive */ \
        if(i!=0) {  \
          MPI_Recv(buffer_rec_double,number_points_process[i] * 3,  \
                   MPI_DOUBLE,i,50,comm,&status);  \
        }  \
        else {  \
          for(num=0;num<number_points_process[i];++num) {  \
            buffer_rec_double[num*3]   = buffer_send_double[num*3];  \
            buffer_rec_double[num*3+1] = buffer_send_double[num*3+1];  \
            buffer_rec_double[num*3+2] = buffer_send_double[num*3+2];  \
          }  \
        }  \
        /* d) print in file */  \
        for(num=0;num<number_points_process[i];++num) {  \
          loc.x =  buffer_rec_double[num*3];  \
          loc.y =  buffer_rec_double[num*3+1];  \
          loc.z =  buffer_rec_double[num*3+2];  \
          *Datei << start_num+num  \
                 << " " << fixed << loc.x    \
                 << " " << fixed << loc.y    \
                 << " " << fixed << loc.z  \
                 << "\n";  \
        }  \
        start_num = start_num + number_points_process[i];  \
      }  \
    }  \
    /* Teil 3: Zellen ausgeben */     \
    /* a) set values in buffer */     \
    if(I_am_active()) { \
      /* Teil 3.1: Innere Zellen ausgeben */ \
      ind = my_index;  \
      number=Recursion_Cells_AVS_parallel(ind,0,buffer_send_int);  \
      /* Teil 3.2: Randzellen */   \
      iterate_hash2 {  \
        if(bocell->Give_Index()<<my_index)  \
          number = avs_bo_cell_parallel(bocell,number,buffer_send_int);  \
      }  \
    }  \
    /* b) send */   \
    if(my_rank!=0) {   \
      MPI_Send(buffer_send_int,number_cells * 4,  \
               MPI_INT,0,51,comm);  \
    }  \
    else {  \
      start_num=0;  \
      start_poi=0;  \
      for(i=0;i<n_proc;++i) {  \
        /* c) receive */  \
        if(i!=0) {  \
          MPI_Recv(buffer_rec_int,number_cells_process[i] * 4,  \
                   MPI_INT,i,51,comm,&status);  \
        }  \
        else {  \
          for(num=0;num<number_cells_process[i];++num) {  \
            buffer_rec_int[num*4]   = buffer_send_int[num*4];   \
            buffer_rec_int[num*4+1] = buffer_send_int[num*4+1];   \
            buffer_rec_int[num*4+2] = buffer_send_int[num*4+2];   \
            buffer_rec_int[num*4+3] = buffer_send_int[num*4+3];   \
          }  \
        }  \
       /* d) print in file */    \
        if(i<n_proc) {  \
          for(num=0;num<number_cells_process[i];++num) {  \
            *Datei << start_num+num+1 << " 1 tet "  \
                   << " " << start_poi + buffer_rec_int[num*4]   \
                   << " " << start_poi + buffer_rec_int[num*4+1]   \
                   << " " << start_poi + buffer_rec_int[num*4+2]   \
                   << " " << start_poi + buffer_rec_int[num*4+3]   \
                   << "\n";  \
          }  \
        }  \
        start_num = start_num + number_cells_process[i];  \
        start_poi = start_poi + number_points_process[i];  \
      }  \
    }  \
    if(my_rank==0) {





// Ausgabe der Tetraeder
int Grid_base::avs_bo_cell_parallel(BoCell* bo, int number, int* buffer) {
  Tetraeder_storage* tets;
  int num;
  Index3D I;
  Cell_type_points typ;
  
  I = bo->Give_Index();

#ifdef PERIODIC
  if(I.neighbour_non_periodic(WSDd).Is_non_periodic()) {
    return number;
  }
#endif

  for(tets = bo->Give_tets();tets!=NULL;tets = tets->Next()) {
    // Punkt 0:
    num = tets->N0();
    typ = bo->edge_point(num);
    if(typ==edge_poi_typ) {
      buffer[number*4  ] =Give_Nummer(I.neighbour(bo->corner(num)),
                                      bo->edge_dir(num));
    }
    if(typ==corner_poi_typ) {
      buffer[number*4  ] =Give_Nummer(I.neighbour(bo->corner(num)));    
    }
    if(typ==cell_poi_typ) {
      buffer[number*4  ] =Give_Nummer_cellpoi(I);       
    }
    // Punkt 1:
    num = tets->N1();
    typ = bo->edge_point(num);
    if(typ==edge_poi_typ) {
      buffer[number*4+1] =Give_Nummer(I.neighbour(bo->corner(num)),
                            bo->edge_dir(num));
    }
    if(typ==corner_poi_typ) {
      buffer[number*4+1] =Give_Nummer(I.neighbour(bo->corner(num)));    
    }
    if(typ==cell_poi_typ) {
      buffer[number*4+1] =Give_Nummer_cellpoi(I);       
    }
    // Punkt 2:
    num = tets->N2();
    typ = bo->edge_point(num);
    if(typ==edge_poi_typ) {
      buffer[number*4+2] =Give_Nummer(I.neighbour(bo->corner(num)),
                            bo->edge_dir(num));
    }
    if(typ==corner_poi_typ) {
      buffer[number*4+2] =Give_Nummer(I.neighbour(bo->corner(num)));
    }
    if(typ==cell_poi_typ) {
      buffer[number*4+2] =Give_Nummer_cellpoi(I);       
    }
    // Punkt 3:
    num = tets->N3();
    typ = bo->edge_point(num);
    if(typ==edge_poi_typ) {
      buffer[number*4+3] =Give_Nummer(I.neighbour(bo->corner(num)),
                            bo->edge_dir(num));
    }
    if(typ==corner_poi_typ) {
      buffer[number*4+3] =Give_Nummer(I.neighbour(bo->corner(num)));
    }
    if(typ==cell_poi_typ) {
      buffer[number*4+3] =Give_Nummer_cellpoi(I);       
    }

    ++number; 
  }
  return number;
}



int Grid_base::Recursion_Cells_AVS_parallel(Index3D I,
                                            int nummer,int* buffer) {
  int i;
  Index3D Ison;
  for(i=0;i<8;++i) {
    if(Exists_Point(I.son((dir_sons)i)))
      nummer = Recursion_Cells_AVS_parallel(I.son((dir_sons)i),nummer,buffer);
    else {
      Ison = I.son((dir_sons)i);
#ifdef PERIODIC
      if(Ison.neighbour_non_periodic(WSDd).Is_non_periodic()
         && Give_cell_typ(Ison) == int_cell) {
#else
      if(Give_cell_typ(Ison) == int_cell) {
#endif
        Ison = I.son((dir_sons)i);

        // 0. Tet: WND, WNT, WST, EST 
        buffer[nummer*4]   = Give_Nummer(Ison.neighbour(WNTd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WNDd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(WSTd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ESTd));
        nummer++;

        // 1. Tet: EST, WND, WST, ESD  
        buffer[nummer*4  ] = Give_Nummer(Ison.neighbour(ESTd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WNDd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(WSTd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ESDd));
        nummer++;

        // 2. Tet: WND, WSD, WST, ESD        
        buffer[nummer*4  ] = Give_Nummer(Ison.neighbour(WNDd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WSDd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(WSTd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ESDd));
        nummer++;

        // 3. Tet: EST, WND, ESD, END
        buffer[nummer*4  ] = Give_Nummer(Ison.neighbour(ESTd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WNDd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(ESDd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ENDd));
        nummer++;

        // 4. Tet: ENT, WNT, EST, END
        buffer[nummer*4  ] = Give_Nummer(Ison.neighbour(ENTd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WNTd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(ESTd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ENDd));
        nummer++;
        
        // 5. Tet: WNT, WND, EST, END
        buffer[nummer*4  ] = Give_Nummer(Ison.neighbour(WNTd));
        buffer[nummer*4+1] = Give_Nummer(Ison.neighbour(WNDd));
        buffer[nummer*4+2] = Give_Nummer(Ison.neighbour(ESTd));
        buffer[nummer*4+3] = Give_Nummer(Ison.neighbour(ENDd));
        nummer++;
      }
    }
  }
  return nummer;
}


int Grid_base::Write_Cells_AVS_parallel(Index3D I,
                                        int nummer,int* buffer) {
  // 0. Tet: WND, WNT, WST, EST 
  buffer[nummer*4]   = Give_Nummer(I.neighbour(WNTd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WNDd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(WSTd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ESTd));
  nummer++;
  
  // 1. Tet: EST, WND, WST, ESD  
  buffer[nummer*4  ] = Give_Nummer(I.neighbour(ESTd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WNDd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(WSTd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ESDd));
  nummer++;
  
  // 2. Tet: WND, WSD, WST, ESD        
  buffer[nummer*4  ] = Give_Nummer(I.neighbour(WNDd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WSDd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(WSTd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ESDd));
  nummer++;
  
  // 3. Tet: EST, WND, ESD, END
  buffer[nummer*4  ] = Give_Nummer(I.neighbour(ESTd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WNDd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(ESDd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ENDd));
  nummer++;
  
  // 4. Tet: ENT, WNT, EST, END
  buffer[nummer*4  ] = Give_Nummer(I.neighbour(ENTd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WNTd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(ESTd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ENDd));
  nummer++;
  
  // 5. Tet: WNT, WND, EST, END
  buffer[nummer*4  ] = Give_Nummer(I.neighbour(WNTd));
  buffer[nummer*4+1] = Give_Nummer(I.neighbour(WNDd));
  buffer[nummer*4+2] = Give_Nummer(I.neighbour(ESTd));
  buffer[nummer*4+3] = Give_Nummer(I.neighbour(ENDd));
  nummer++;

  return nummer;
}
 





void Grid_base::Print_Variable_AVS_parallel(ofstream *Datei, int number_var) {
  int number_cells, number, ebene;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;
  int number_of_vars;   // wird in der Kopfzeile eingesetzt

  number_of_vars=1;

  MPI_Barrier(comm);

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print_Variable_AVS! Initialisierung fehlt! "
         << endl;
    return;
  }
  if(Give_max_num_var() <= number_var) {
    cout << " \n Fehler in Print_Variable_AVS! number_var zu gross! " << endl;
  }
  else {
    // Teil 0: Write information
    if(my_rank==0) {
      *Datei << "# File created by ExPDE " << endl;
      *Datei << "# UCD file format for AVS parallel " << endl;
      *Datei << "# scalar value " << endl;
    }
  MPI_Barrier(comm);
    Macro_PRINT_Einsetzen 

      /* Teil 4: */
      *Datei << "1 1" << "\n";
      // Teil 5:
      *Datei << "variable, unit " << "\n";
    }

    if(I_am_active()) {
    // Teil 2: Werte der Punkte ausgeben
    // a) set values in buffer
    // i) alle inneren Punkte
    iterate_hash1 {
      if(point1->nummer != -1) {
        ebene = Give_finest_level(point1->ind);
        buffer_send_double[point1->nummer] = 
          Give_variable(point1->ind,ebene)[number_var];
      }
    }
    // ii) alle Randpunkte
    iterate_hash3 {
      buffer_send_double[bo2point->nummer] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_var];
    }
    // iii alle Randzellfreiheitsgrad
    iterate_hash2 {
      if(bocell->Give_Index()<<my_index) {
        if(bocell->Exists_bocellpoint()) {
          buffer_send_double[bocell->Number_avs()] =
            bocell->Give_var()[number_var];
        }
      }
    }
    }

    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,number_points,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,number_points_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<number_points_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_points_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[num]
                   << "\n";
          }
        }
        start_num = start_num + number_points_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
       delete(number_cells_process);
       delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }

  MPI_Barrier(comm);
}


void Grid_base::Print_Variable_AVS_moved_parallel(ofstream *Datei, 
                                                  int number_var,
                                                  int number_var_a, 
                                                  int number_var_b, 
                                                  int number_var_c) {
  int number_cells, number, ebene;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;
  double *zeiger;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;
  int number_of_vars;   // wird in der Kopfzeile eingesetzt

  number_of_vars=1;

  MPI_Barrier(comm);

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print_Variable_AVS! Initialisierung fehlt! "
         << endl;
    return;
  }
  if(Give_max_num_var() <= number_var) {
    cout << " \n Fehler in Print_Variable_AVS! number_var zu gross! " << endl;
  }
  else {
    // Teil 0: Write information
    if(my_rank==0) {
      *Datei << "# File created by ExPDE " << endl;
      *Datei << "# UCD file format for AVS parallel " << endl;
      *Datei << "# scalar value moved by a vector" << endl;
    }
  MPI_Barrier(comm);

    /* Teil 1: Anzahl der Zellen zaehlen */ 
    number_cells = 0; 
    if(I_am_active()) { 
    /* Teil 1.1: Innerer Zellen */ 
    ind = my_index; 
    number_cells = Recursion_Count_Cells(ind); 
    /* Teil 1.2: Randzellen */  
    iterate_hash2 { 
        if(bocell->Give_Index()<<my_index) 
          number_cells = avs_bo_cell(bocell,Datei,false,number_cells); 
      } 
    } 
    /* Teil 1.3: Anzahl der Punkte */ 
    number_points=0; 
    if(I_am_active()) { 
      /* a) innen und randnah */ 
      iterate_hash1 { 
        if((point1->typ >= interior || point1->typ==parallel_p) && 
           point1->Give_Index()<<my_index &&
           point1->finest_level == max_level) { 
          point1->nummer = number_points; 
          number_points++; 
        } 
        else point1->nummer = -1; 
      } 
    /* b) Randpunkte */  
      iterate_hash3 {  
        bo2point->Set_number_avs(number_points);  
        ++number_points;  
      }  
    /* c) Randzellfreiheitsgrad */  
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index) {  
          if(bocell->Exists_bocellpoint()) {  
            bocell->Set_number_avs(number_points);  
            number_points++;  
          } 
        } 
      } 
    } 
    /* Teil 1.5: gather data */   
    n_proc = give_number_of_processes();  
    number_cells_process = new int[n_proc];  
    number_points_process = new int[n_proc];  
    MPI_Gather(&number_points,1,MPI_INT,number_points_process,1,MPI_INT,  
               0,comm);  
    MPI_Gather(&number_cells,1,MPI_INT,number_cells_process,1,MPI_INT,  
               0,comm);  
    total_number_points =0;  
    total_number_cells =0;  
    max_number_points =0;  
    max_number_cells =0;  
    for(i=0;i<n_proc;++i) {  
      total_number_points = total_number_points + number_points_process[i];  
      total_number_cells  = total_number_cells  + number_cells_process[i];  
    }  
    for(i=0;i<n_proc;++i) {  
      if(number_points_process[i] > max_number_points)  
        max_number_points = number_points_process[i];  
      if(number_cells_process[i] > max_number_cells)  
        max_number_cells = number_cells_process[i];  
    }  
    /* Teil 1.7: make buffer */ 
    if(my_rank==0) {  
      buffer_rec_int    = new int[max_number_cells  * 4];  
      buffer_rec_double = new double[max_number_points * 3];  
    }  
    buffer_send_int    = new int[number_cells  * 4];  
    buffer_send_double = new double[number_points * 3];  
    /* Teil 1.6: Kopfzeile schreiben */   
    if(my_rank==0) {  
      *Datei << total_number_points << " "  
             << total_number_cells << " " 
             << number_of_vars << " 0 0" << endl;  
    }  
    /* Teil 2: Koordinaten der Punkte eingeben */  
    /* a) set values in buffer */  
    if(I_am_active()) {  
      /* i) alle inneren Punkte */ 
      iterate_hash1 {  
        if(point1->nummer != -1) {  
          zeiger = Give_variable(point1->ind,Max_level());
          loc = transform_coord(point1->ind.coordinate()) +
            D3vector(zeiger[number_var_a],
                     zeiger[number_var_b],
                     zeiger[number_var_c]);
 
          buffer_send_double[point1->nummer*3]   = loc.x;  
          buffer_send_double[point1->nummer*3+1] = loc.y;  
          buffer_send_double[point1->nummer*3+2] = loc.z;  
        }  
      }  
    /* ii) alle Randpunkte */   
      iterate_hash3 {
        zeiger = Give_variable(bo2point->ind,bo2point->direction);
        loc = bo2point->transform_coord(Give_A(),H_mesh()) +
          D3vector(zeiger[number_var_a],
                   zeiger[number_var_b],
                   zeiger[number_var_c]);
 
        buffer_send_double[bo2point->nummer*3]   = loc.x;  
        buffer_send_double[bo2point->nummer*3+1] = loc.y;  
        buffer_send_double[bo2point->nummer*3+2] = loc.z;  
      }  
    /* iii) alle Randzellfreiheitsgrad */   
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index) {  
          if(bocell->Exists_bocellpoint()) {
            zeiger = bocell->Give_var();
            loc =  transform_coord(bocell->ind.coordinate()) +   
              bocell->Local_coord_bocellpoint() +
              D3vector(zeiger[number_var_a],
                       zeiger[number_var_b],
                       zeiger[number_var_c]);
            buffer_send_double[bocell->Number_avs()*3]   = loc.x;  
            buffer_send_double[bocell->Number_avs()*3+1] = loc.y;  
            buffer_send_double[bocell->Number_avs()*3+2] = loc.z;  
          }  
        }  
      }  
    }  
    /* b) send */ 
    if(my_rank!=0) {  
      MPI_Send(buffer_send_double,number_points * 3,  
               MPI_DOUBLE,0,50,comm);  
    }  
    else {  
      start_num=0;  
      for(i=0;i<n_proc;++i) {  
        /* c) receive */ 
        if(i!=0) {  
          MPI_Recv(buffer_rec_double,number_points_process[i] * 3,  
                   MPI_DOUBLE,i,50,comm,&status);  
        }  
        else {  
          for(num=0;num<number_points_process[i];++num) {  
            buffer_rec_double[num*3]   = buffer_send_double[num*3];  
            buffer_rec_double[num*3+1] = buffer_send_double[num*3+1];  
            buffer_rec_double[num*3+2] = buffer_send_double[num*3+2];  
          }  
        }  
        /* d) print in file */  
        for(num=0;num<number_points_process[i];++num) {  
          loc.x =  buffer_rec_double[num*3];  
          loc.y =  buffer_rec_double[num*3+1];  
          loc.z =  buffer_rec_double[num*3+2];  
          *Datei << start_num+num  
                 << " " << fixed << loc.x    
                 << " " << fixed << loc.y    
                 << " " << fixed << loc.z  
                 << "\n";  
        }  
        start_num = start_num + number_points_process[i];  
      }  
    }  
    /* Teil 3: Zellen ausgeben */     
    /* a) set values in buffer */     
    if(I_am_active()) { 
      /* Teil 3.1: Innere Zellen ausgeben */ 
      ind = my_index;  
      number=Recursion_Cells_AVS_parallel(ind,0,buffer_send_int);  
      /* Teil 3.2: Randzellen */   
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index)  
          number = avs_bo_cell_parallel(bocell,number,buffer_send_int);  
      }  
    }  
    /* b) send */   
    if(my_rank!=0) {   
      MPI_Send(buffer_send_int,number_cells * 4,  
               MPI_INT,0,51,comm);  
    }  
    else {  
      start_num=0;  
      start_poi=0;  
      for(i=0;i<n_proc;++i) {  
        /* c) receive */  
        if(i!=0) {  
          MPI_Recv(buffer_rec_int,number_cells_process[i] * 4,  
                   MPI_INT,i,51,comm,&status);  
        }  
        else {  
          for(num=0;num<number_cells_process[i];++num) {  
            buffer_rec_int[num*4]   = buffer_send_int[num*4];   
            buffer_rec_int[num*4+1] = buffer_send_int[num*4+1];   
            buffer_rec_int[num*4+2] = buffer_send_int[num*4+2];   
            buffer_rec_int[num*4+3] = buffer_send_int[num*4+3];   
          }  
        }  
       /* d) print in file */    
        if(i<n_proc) {  
          for(num=0;num<number_cells_process[i];++num) {  
            *Datei << start_num+num+1 << " 1 tet "  
                   << " " << start_poi + buffer_rec_int[num*4]   
                   << " " << start_poi + buffer_rec_int[num*4+1]   
                   << " " << start_poi + buffer_rec_int[num*4+2]   
                   << " " << start_poi + buffer_rec_int[num*4+3]   
                   << "\n";  
          }  
        }  
        start_num = start_num + number_cells_process[i];  
        start_poi = start_poi + number_points_process[i];  
      }  
    }  
    if(my_rank==0) {
      /* Teil 4: */
      *Datei << "1 1" << "\n";
      // Teil 5:
      *Datei << "variable, unit " << "\n";
    }

    if(I_am_active()) {
    // Teil 2: Werte der Punkte ausgeben
    // a) set values in buffer
    // i) alle inneren Punkte
    iterate_hash1 {
      if(point1->nummer != -1) {
        ebene = Give_finest_level(point1->ind);
        buffer_send_double[point1->nummer] = 
          Give_variable(point1->ind,ebene)[number_var];
      }
    }
    // ii) alle Randpunkte
    iterate_hash3 {
      buffer_send_double[bo2point->nummer] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_var];
    }
    // iii alle Randzellfreiheitsgrad
    iterate_hash2 {
      if(bocell->Give_Index()<<my_index) {
        if(bocell->Exists_bocellpoint()) {
          buffer_send_double[bocell->Number_avs()] =
            bocell->Give_var()[number_var];
        }
      }
    }
    }

    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,number_points,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,number_points_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<number_points_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_points_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[num]
                   << "\n";
          }
        }
        start_num = start_num + number_points_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
       delete(number_cells_process);
       delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }

  MPI_Barrier(comm);
}



void Grid_base::Print_Variable_AVS_parallel(ofstream *Datei, int number_var,
                                            int number_varb, int number_varc) {
  int number_cells, number, ebene;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;
  int number_of_vars;   // wird in der Kopfzeile eingesetzt

  number_of_vars=3;

  Datei->precision(3);

  Problemzeile

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print_Variable_AVS! Initialisierung fehlt! "
         << endl;
    return;
  }
  if(Give_max_num_var() <= number_var) {
    cout << " \n Fehler in Print_Variable_AVS! number_var zu gross! " << endl;
  }
  else {
    // Teil 0: Write information
    if(my_rank==0) {
      *Datei << "# File created by ExPDE " << endl;
      *Datei << "# UCD file format for AVS parallel " << endl;
      *Datei << "# vector field " << endl;
    }
    Macro_PRINT_Einsetzen 
      /* Teil 4: */ 
      *Datei << "3 1 1 1" << "\n";
      // Teil 5:
      *Datei << "x-coord " << "\n";
      *Datei << "y-coord " << "\n";
      *Datei << "z-coord " << "\n";
    }

    if(I_am_active()) {
    // Teil 2: Werte der Punkte ausgeben
    // a) set values in buffer
    // i) alle inneren Punkte
    iterate_hash1 {
      if(point1->nummer != -1) {
        ebene = Give_finest_level(point1->ind);
        buffer_send_double[3*point1->nummer] = 
          Give_variable(point1->ind,ebene)[number_var];
        buffer_send_double[3*point1->nummer+1] = 
          Give_variable(point1->ind,ebene)[number_varb];
        buffer_send_double[3*point1->nummer+2] = 
          Give_variable(point1->ind,ebene)[number_varc];
      }
    }
    // ii) alle Randpunkte
    iterate_hash3 {
      buffer_send_double[3*bo2point->nummer] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_var];
      buffer_send_double[3*bo2point->nummer+1] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_varb];
      buffer_send_double[3*bo2point->nummer+2] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_varc];
    }
    // iii alle Randzellfreiheitsgrad
    iterate_hash2 {
      if(bocell->Give_Index()<<my_index) {
        if(bocell->Exists_bocellpoint()) {
          buffer_send_double[3*bocell->Number_avs()] =
            bocell->Give_var()[number_var];
          buffer_send_double[3*bocell->Number_avs()+1] =
            bocell->Give_var()[number_varb];
          buffer_send_double[3*bocell->Number_avs()+2] =
            bocell->Give_var()[number_varc];
        }
      }
    }
    }

    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,3*number_points,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,3*number_points_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<3*number_points_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_points_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[3*num]
                   << " " << buffer_rec_double[3*num+1]
                   << " " << buffer_rec_double[3*num+2]
                   << "\n";
          }
        }
        start_num = start_num + number_points_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
       delete(number_cells_process);
       delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }

  MPI_Barrier(comm);
}


void Grid_base::Print_processes_UCD(ofstream *Datei) {
  int number_cells, number;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;
  int number_of_vars;   // wird in der Kopfzeile eingesetzt

  number_of_vars=1;


  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print...! Initialisierung fehlt! "
         << endl;
    return;
  }
  else {
    if(my_rank==0) {
      // Teil 0: Write information
      *Datei << "# File created by ExPDE PARALLEL" << endl;
      *Datei << "# UCD file format for AVS " << endl;
      *Datei << "# processes colored " << endl;
    }
    Macro_PRINT_Einsetzen 
      /* Teil 4: */
      *Datei << "1 1" << "\n";
      // Teil 5:
      *Datei << "processes " << "\n";

      // Teil 6: Print number of processor
      start_num=0;
      for(i=0;i<n_proc;++i) {
        for(num=0;num<number_points_process[i];++num) {
          *Datei << start_num+num << "   " << i  << "\n";
        }
        start_num = start_num + number_points_process[i];
      }
      *Datei << endl;
    }

    // Teil 7:
    if(I_am_active()) {
      delete(number_cells_process);
      delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }
  MPI_Barrier(comm);
}


// 3. region

void Grid_base::Print_region_processes_UCD(ofstream *Datei) {
  int i;
  D3vector v;

  if(my_rank==0) {
    // Teil 0: Write information
    *Datei << "# File created by ExPDE PARALLEL" << endl;
    *Datei << "# UCD file format for AVS " << endl;
    *Datei << "# scalar value " << endl;
    
    // Teil 1: Kopfzeile schreiben
    *Datei << 8*give_number_of_active_processes() << " "
           <<   give_number_of_active_processes() << " 1 0 0" << endl;

    // Teil 2: Koordinaten der Punkte ausgeben
    iterate_hash_proc {
      if(point_proc!=NULL)
        if(point_proc->Give_Index().Tiefe()==n_parallel) {
          for(i=0;i<8;++i) {
            v = transform_coord(
                  point_proc->Give_Index().neighbour_non_periodic(
                  (dir_sons)i).coordinate());
                 *Datei << point_proc->Give_num_proc()*8+i
                 << " " << fixed << v.x  
                 << " " << fixed << v.y  
                 << " " << fixed << v.z
                 << "\n";
        }
      }
    }
    
    // Teil 3: Zellen ausgeben
    iterate_hash_proc {
     if(point_proc!=NULL)
       if(point_proc->Give_Index().Tiefe()==n_parallel) {
        *Datei << point_proc->Give_num_proc() << "  1  hex  "
               << point_proc->Give_num_proc()*8+WNTd << " "
               << point_proc->Give_num_proc()*8+WSTd << " "
               << point_proc->Give_num_proc()*8+ESTd << " "
               << point_proc->Give_num_proc()*8+ENTd << " "
               << point_proc->Give_num_proc()*8+WNDd << " "
               << point_proc->Give_num_proc()*8+WSDd << " "
               << point_proc->Give_num_proc()*8+ESDd << " "
               << point_proc->Give_num_proc()*8+ENDd << " "
               << "\n";
      }
    }

    // Teil 4:
    *Datei << "1 1" << "\n";
    *Datei << "processes " << "\n";
    
    // Teil 5:  Nummer der Prozesses an Punkten ausgeben
    iterate_hash_proc {
      if(point_proc!=NULL)
       if(point_proc->Give_Index().Tiefe()==n_parallel) {
        for(i=0;i<8;++i) {
          *Datei << point_proc->Give_num_proc()*8+i << " " 
                 << point_proc->Give_num_proc()
                 << "\n";
        }
      }
    }
    *Datei << endl;
  }
}

void Parallel_Info::Print_region_processes_UCD_normalized(ofstream *Datei) {
  int i;
  D3vector v;

  if(my_rank==0) {
    // Teil 0: Write information
    *Datei << "# File created by ExPDE PARALLEL" << endl;
    *Datei << "# UCD file format for AVS " << endl;
    *Datei << "# scalar value " << endl;
    
    // Teil 1: Kopfzeile schreiben
    *Datei << 8*give_number_of_active_processes() << " "
           <<   give_number_of_active_processes() << " 1 0 0" << endl;

    // Teil 2: Koordinaten der Punkte ausgeben
    iterate_hash_proc {
      if(point_proc!=NULL)
        if(point_proc->Give_Index().Tiefe()==n_parallel) {
          for(i=0;i<8;++i) {
            v = point_proc->Give_Index().neighbour(
                  (dir_sons)i).coordinate();
                 *Datei << point_proc->Give_num_proc()*8+i
                 << " " << fixed << v.x  
                 << " " << fixed << v.y  
                 << " " << fixed << v.z
                 << "\n";
        }
      }
    }
    
    // Teil 3: Zellen ausgeben
    iterate_hash_proc {
     if(point_proc!=NULL)
       if(point_proc->Give_Index().Tiefe()==n_parallel) {
        *Datei << point_proc->Give_num_proc() << "  1  hex  "
               << point_proc->Give_num_proc()*8+WNTd << " "
               << point_proc->Give_num_proc()*8+WSTd << " "
               << point_proc->Give_num_proc()*8+ESTd << " "
               << point_proc->Give_num_proc()*8+ENTd << " "
               << point_proc->Give_num_proc()*8+WNDd << " "
               << point_proc->Give_num_proc()*8+WSDd << " "
               << point_proc->Give_num_proc()*8+ESDd << " "
               << point_proc->Give_num_proc()*8+ENDd << " "
               << "\n";
      }
    }

    // Teil 4:
    *Datei << "1 1" << "\n";
    *Datei << "processes " << "\n";
    
    // Teil 5:  Nummer der Prozesses an Punkten ausgeben
    iterate_hash_proc {
      if(point_proc!=NULL)
       if(point_proc->Give_Index().Tiefe()==n_parallel) {
        for(i=0;i<8;++i) {
          *Datei << point_proc->Give_num_proc()*8+i << " " 
                 << point_proc->Give_num_proc()
                 << "\n";
        }
      }
    }
    *Datei << endl;
  }
}


// 4. only surface


// Ausgabe der Tetraeder
int Grid_base::avs_bo_cell_parallel_surface(BoCell* bo, int number, 
      int* buffer, bool print_or_calc) {
  Tetraeder_storage* tets;
  int num, numad;
  Index3D I;
  Cell_type_points typ0, typ1, typ2, typ3;

  if(print_or_calc==false) {
    for(tets = bo->Give_tets();tets!=NULL;tets = tets->Next()) {
    // Punkt 0:
    num = tets->N0();
    typ0 = bo->edge_point(num);
    num = tets->N1();
    typ1 = bo->edge_point(num);
    num = tets->N2();
    typ2 = bo->edge_point(num);
    num = tets->N3();
    typ3 = bo->edge_point(num);
    if(((int)(typ0==edge_poi_typ) + (int)(typ1==edge_poi_typ) + 
        (int)(typ2==edge_poi_typ) + (int)(typ3==edge_poi_typ))==3) {
       number++;
    }
   }
  }
  else {
    I = bo->Give_Index();
    for(tets = bo->Give_tets();tets!=NULL;tets = tets->Next()) {
      num = tets->N0();
      typ0 = bo->edge_point(num);
      num = tets->N1();
      typ1 = bo->edge_point(num);
      num = tets->N2();
      typ2 = bo->edge_point(num);
      num = tets->N3();
      typ3 = bo->edge_point(num);
      if(((int)(typ0==edge_poi_typ) + (int)(typ1==edge_poi_typ) + 
          (int)(typ2==edge_poi_typ) + (int)(typ3==edge_poi_typ))==3) {
          numad=0;
          // Punkt 0:
          num = tets->N0();
          if(typ0==edge_poi_typ) {
          buffer[number*3+numad] = Give_Nummer(I.neighbour(bo->corner(num)),
                                   bo->edge_dir(num));
            ++numad;
          }
          // Punkt 1:
          num = tets->N1();
          if(typ1==edge_poi_typ) {
            buffer[number*3+numad] = Give_Nummer(I.neighbour(bo->corner(num)),
                                     bo->edge_dir(num));
            ++numad;
           }
          // Punkt 2:
          num = tets->N2();
          if(typ2==edge_poi_typ) {
            buffer[number*3+numad] = Give_Nummer(I.neighbour(bo->corner(num)),
                                     bo->edge_dir(num));
            ++numad;
           }
           // Punkt 3:
           num = tets->N3();
           if(typ3==edge_poi_typ) {
             buffer[number*3+numad] = Give_Nummer(I.neighbour(bo->corner(num)),
                                      bo->edge_dir(num));
             ++numad;
            }
            ++number;
         }
      }
  }
  return number;
}





#define Macro_PRINT_sur_Einsetzen  \
  /* Teil 1: Anzahl der Zellen zaehlen */ \
    number_cells = 0; \
    if(I_am_active()) { \
    /* Teil 1.1: Randzellen */  \
    iterate_hash2 { \
        if(bocell->Give_Index()<<my_index) \
          number_cells = avs_bo_cell_parallel_surface(bocell,number_cells, \
                                                      NULL,false); \
      } \
    } \
    /* Teil 1.2: Anzahl der Punkte */ \
    number_points=0; \
    if(I_am_active()) { \
    /* a) Randpunkte */  \
      iterate_hash3 {  \
        bo2point->Set_number_avs(number_points);  \
        ++number_points;  \
      } \
    }  \
    /* Teil 1.5: gather data */   \
    n_proc = give_number_of_processes();  \
    number_cells_process = new int[n_proc];  \
    number_points_process = new int[n_proc];  \
    MPI_Gather(&number_points,1,MPI_INT,number_points_process,1,MPI_INT,  \
               0,comm);  \
    MPI_Gather(&number_cells,1,MPI_INT,number_cells_process,1,MPI_INT,  \
               0,comm);  \
    total_number_points =0;  \
    total_number_cells =0;  \
    max_number_points =0;  \
    max_number_cells =0;  \
    for(i=0;i<n_proc;++i) {  \
      total_number_points = total_number_points + number_points_process[i];  \
      total_number_cells  = total_number_cells  + number_cells_process[i];  \
    }  \
    for(i=0;i<n_proc;++i) {  \
      if(number_points_process[i] > max_number_points)  \
        max_number_points = number_points_process[i]; \
      if(number_cells_process[i] > max_number_cells)  \
        max_number_cells = number_cells_process[i];  \
    }  \
    /* Teil 1.7: make buffer */ \
    if(my_rank==0) {  \
      buffer_rec_int    = new int[max_number_cells  * 3];  \
      buffer_rec_double = new double[max_number_points * 3];  \
    }  \
    buffer_send_int    = new int[number_cells  * 3];  \
    buffer_send_double = new double[number_points * 3];  \
    /* Teil 1.6: Kopfzeile schreiben */   \
    if(my_rank==0) {  \
      *Datei << total_number_points << " "  \
             << total_number_cells << " 1 0 0" << endl;  \
    }  \
    /* Teil 2: Koordinaten der Punkte eingeben */  \
    /* a) set values in buffer */  \
    if(I_am_active()) {  \
    /* i) alle Randpunkte */   \
      iterate_hash3 {  \
        loc = bo2point->transform_coord(Give_A(),H_mesh());  \
        buffer_send_double[bo2point->nummer*3]   = loc.x;  \
        buffer_send_double[bo2point->nummer*3+1] = loc.y;  \
        buffer_send_double[bo2point->nummer*3+2] = loc.z;  \
      }  \
    }  \
    /* b) send */ \
    if(my_rank!=0) {  \
      MPI_Send(buffer_send_double,number_points * 3,  \
               MPI_DOUBLE,0,50,comm);  \
    }  \
    else {  \
      start_num=0;  \
      for(i=0;i<n_proc;++i) {  \
        /* c) receive */ \
        if(i!=0) {  \
          MPI_Recv(buffer_rec_double,number_points_process[i] * 3,  \
                   MPI_DOUBLE,i,50,comm,&status);  \
        }  \
        else {  \
          for(num=0;num<number_points_process[i];++num) {  \
            buffer_rec_double[num*3]   = buffer_send_double[num*3];  \
            buffer_rec_double[num*3+1] = buffer_send_double[num*3+1]; \
            buffer_rec_double[num*3+2] = buffer_send_double[num*3+2];  \
          }  \
        }  \
        /* d) print in file */  \
        for(num=0;num<number_points_process[i];++num) {  \
          loc.x =  buffer_rec_double[num*3];  \
          loc.y =  buffer_rec_double[num*3+1];  \
          loc.z =  buffer_rec_double[num*3+2];  \
          *Datei << start_num+num  \
                 << " " << fixed << loc.x    \
                 << " " << fixed << loc.y    \
                 << " " << fixed << loc.z  \
                 << "\n";  \
        }  \
        start_num = start_num + number_points_process[i];  \
      }  \
    }  \
    /* Teil 3: Zellen ausgeben */     \
    /* a) set values in buffer */ \
    if(I_am_active()) { \
      number=0; \
      /* Teil 3.1: Randzellen */  \
      iterate_hash2 {  \
        if(bocell->Give_Index()<<my_index)  \
          number = avs_bo_cell_parallel_surface(bocell,number,     \
                                                buffer_send_int,true);  \
      }  \
    }  \
    /* b) send */   \
    if(my_rank!=0) {   \
      MPI_Send(buffer_send_int,number_cells * 3,  \
               MPI_INT,0,51,comm);  \
    }  \
    else {  \
      start_num=0;  \
      start_poi=0;  \
      for(i=0;i<n_proc;++i) {  \
        /* c) receive */  \
        if(i!=0) {  \
          MPI_Recv(buffer_rec_int,number_cells_process[i] * 3,  \
                   MPI_INT,i,51,comm,&status);  \
        }  \
        else {  \
          for(num=0;num<number_cells_process[i];++num) {  \
            buffer_rec_int[num*3]   = buffer_send_int[num*3];   \
            buffer_rec_int[num*3+1] = buffer_send_int[num*3+1];   \
            buffer_rec_int[num*3+2] = buffer_send_int[num*3+2];   \
          }  \
        }  \
       /* d) print in file */    \
        if(i<n_proc) {  \
          for(num=0;num<number_cells_process[i];++num) {  \
            *Datei << start_num+num+1 << "  1  tri  "  \
                   << " " << start_poi + buffer_rec_int[num*3]   \
                   << " " << start_poi + buffer_rec_int[num*3+1]   \
                   << " " << start_poi + buffer_rec_int[num*3+2]   \
                   << "\n";  \
          }  \
        }  \
        start_num = start_num + number_cells_process[i];  \
        start_poi = start_poi + number_points_process[i];  \
      }  \
    }  \
    if(my_rank==0) {  \
      /* Teil 4: */ \
      *Datei << "1 1" << "\n";










void Grid_base::Print_surface_processes_UCD(ofstream *Datei) {
  int number_cells, number;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;


  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print...! Initialisierung fehlt! "
         << endl;
    return;
  }
  else {
    if(my_rank==0) {
      // Teil 0: Write information
      *Datei << "# File created by ExPDE PARALLEL" << endl;
      *Datei << "# UCD file format for AVS " << endl;
      *Datei << "# processes colored " << endl;
    }
   Macro_PRINT_sur_Einsetzen 
  

   
      // Teil 5:
      *Datei << "processes " << "\n";

      // Teil 6: Print number of processor
      start_num=0;
      for(i=0;i<n_proc;++i) {
        for(num=0;num<number_points_process[i];++num) {
          *Datei << start_num+num << "   " << i  << "\n";
        }
        start_num = start_num + number_points_process[i];
      }
      *Datei << endl;
    }

    // Teil 7:
    if(I_am_active()) {
      delete(number_cells_process);
      delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }
  MPI_Barrier(comm);
}



void Grid_base::Print_surface_Variable_AVS_parallel(ofstream *Datei,
        int number_var) {
int number_cells, number;
int number_points;
int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind;

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler in Print_Variable_AVS! Initialisierung fehlt! "
         << endl;
    return;
  }
if(Give_max_num_var() <= number_var) {
cout << " \n Fehler in Print_Variable_AVS! number_var zu gross! " << endl;
  }
  else {
    // Teil 0: Write information
    if(my_rank==0) {
      *Datei << "# File created by ExPDE " << endl;
      *Datei << "# UCD file format for AVS parallel " << endl;
      *Datei << "# scalar value " << endl;
    }
    Macro_PRINT_sur_Einsetzen 
      
      // Teil 5:
      *Datei << "variable, unit " << "\n";
    }

    if(I_am_active()) {
    // Teil 2: Koordinaten der Punkte eingeben
    // a) set values in buffer
    // ii) alle Randpunkte
    iterate_hash3 {
      buffer_send_double[bo2point->nummer] = 
        Give_variable(bo2point->ind,bo2point->direction)[number_var];
    }
    }
    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,number_points,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,number_points_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<number_points_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_points_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[num]
                   << "\n";
          }
        }
        start_num = start_num + number_points_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
      delete(number_cells_process);
      delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }

  MPI_Barrier(comm);
}


// 5. cell
// for cell variable

void Grid_base::Print_Cell_Variable_AVS_parallel(ofstream *Datei, 
              int number_cell_var) {
  int number_cells, number;
  int number_points;
  int n_proc,i;

  int *number_cells_process;
  int *number_points_process;
  int total_number_cells;
  int total_number_points;

  MPI_Status status;

  D3vector loc;
  int num, start_num, start_poi;

  int max_number_cells;
  int max_number_points;

  int*    buffer_send_int;
  double* buffer_send_double;

  int*    buffer_rec_int;
  double* buffer_rec_double;

  Index3D ind, I;

  if(Is_storage_initialized()==false) { 
    cout << " \n Fehler 1 in Print_Cell_Variable_AVS_parallel! Initialisierung fehlt! "
         << endl;
    return;
  }
  if(Give_max_num_cell_var() <= number_cell_var) {
    cout << " \n Fehler 2 in Print_Cell_Variable_AVS_parallel!  " << endl;
  }
  else {
    // Teil 0: Write information
    *Datei << "# File created by ExPDE " << endl;
    *Datei << "# UCD file format for AVS " << endl;
    *Datei << "# scalar value on cells" << endl;

    /* Teil 1: Anzahl der Zellen zaehlen */ 
    number_cells = 0; 
    if(I_am_active()) { 
    /* Teil 1.1: Innerer Zellen */ 
    ind = my_index; 
    number_cells = Recursion_Count_Cells(ind); 
    /* Teil 1.2: Randzellen */  
    iterate_hash2 { 
        if(bocell->Give_Index()<<my_index) 
          number_cells = avs_bo_cell(bocell,Datei,false,number_cells); 
      } 
    } 
    /* Teil 1.3: Anzahl der Punkte */ 
    number_points=0; 
    if(I_am_active()) { 
      /* a) innen und randnah */ 
      iterate_hash1 { 
        if((point1->typ >= interior || point1->typ==parallel_p) && 
           point1->Give_Index()<<my_index) { 
          point1->nummer = number_points; 
          number_points++; 
        } 
        else point1->nummer = -1; 
      } 
    /* b) Randpunkte */  
      iterate_hash3 {  
        bo2point->Set_number_avs(number_points);  
        ++number_points;  
      }  
    /* c) Randzellfreiheitsgrad */  
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index) {  
          if(bocell->Exists_bocellpoint()) {  
            bocell->Set_number_avs(number_points);  
            number_points++;  
          } 
        } 
      } 
    } 
    /* Teil 1.5: gather data */   
    n_proc = give_number_of_processes();  
    number_cells_process = new int[n_proc];  
    number_points_process = new int[n_proc];  
    MPI_Gather(&number_points,1,MPI_INT,number_points_process,1,MPI_INT,  
               0,comm);  
    MPI_Gather(&number_cells,1,MPI_INT,number_cells_process,1,MPI_INT,  
               0,comm);  
    total_number_points =0;  
    total_number_cells =0;  
    max_number_points =0;  
    max_number_cells =0;  
    for(i=0;i<n_proc;++i) {  
      total_number_points = total_number_points + number_points_process[i];  
      total_number_cells  = total_number_cells  + number_cells_process[i];
    }  
    for(i=0;i<n_proc;++i) {  
      if(number_points_process[i] > max_number_points)  
        max_number_points = number_points_process[i];  
      if(number_cells_process[i] > max_number_cells)  
        max_number_cells = number_cells_process[i];  
    }  
    /* Teil 1.7: make buffer */ 
    if(my_rank==0) {  
      buffer_rec_int    = new int[max_number_cells  * 4];  
      buffer_rec_double = new double[max_number_points * 3];  
    }  
    buffer_send_int    = new int[number_cells  * 4];  
    buffer_send_double = new double[number_cells * 3];  
    /* Teil 1.6: Kopfzeile schreiben */   
    if(my_rank==0) {
       *Datei << total_number_points << " "  
             << total_number_cells << " 0 1 0" << endl; 
    }  
    /* Teil 2: Koordinaten der Punkte eingeben */  
    /* a) set values in buffer */  
    if(I_am_active()) {  
      /* i) alle inneren Punkte */ 
      iterate_hash1 {  
        if(point1->nummer != -1) {  
          loc = transform_coord(point1->ind.coordinate());  
          buffer_send_double[point1->nummer*3]   = loc.x;  
          buffer_send_double[point1->nummer*3+1] = loc.y;  
          buffer_send_double[point1->nummer*3+2] = loc.z;  
        }  
      }  
    /* ii) alle Randpunkte */   
      iterate_hash3 {  
        loc = bo2point->transform_coord(Give_A(),H_mesh());  
        buffer_send_double[bo2point->nummer*3]   = loc.x;  
        buffer_send_double[bo2point->nummer*3+1] = loc.y;  
        buffer_send_double[bo2point->nummer*3+2] = loc.z;  
      }  
    /* iii) alle Randzellfreiheitsgrad */   
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index) {  
          if(bocell->Exists_bocellpoint()) {  
            loc =  transform_coord(bocell->ind.coordinate()) +   
              bocell->Local_coord_bocellpoint();  
            buffer_send_double[bocell->Number_avs()*3]   = loc.x;  
            buffer_send_double[bocell->Number_avs()*3+1] = loc.y;  
            buffer_send_double[bocell->Number_avs()*3+2] = loc.z;  
          }  
        }  
      }  
    }  
    /* b) send */ 
    if(my_rank!=0) {  
      MPI_Send(buffer_send_double,number_points * 3,  
               MPI_DOUBLE,0,50,comm);  
    }  
    else {  
      start_num=0;  
      for(i=0;i<n_proc;++i) {  
        /* c) receive */ 
        if(i!=0) {  
          MPI_Recv(buffer_rec_double,number_points_process[i] * 3,  
                   MPI_DOUBLE,i,50,comm,&status);  
        }  
        else {  
          for(num=0;num<number_points_process[i];++num) {  
            buffer_rec_double[num*3]   = buffer_send_double[num*3];  
            buffer_rec_double[num*3+1] = buffer_send_double[num*3+1];  
            buffer_rec_double[num*3+2] = buffer_send_double[num*3+2];  
          }  
        }  
        /* d) print in file */  
        for(num=0;num<number_points_process[i];++num) {  
          loc.x =  buffer_rec_double[num*3];  
          loc.y =  buffer_rec_double[num*3+1];  
          loc.z =  buffer_rec_double[num*3+2];  
          *Datei << start_num+num  
          << " " << fixed << loc.x    
          << " " << fixed << loc.y    
          << " " << fixed << loc.z  
                 << "\n";  
        }  
        start_num = start_num + number_points_process[i];  
      }  
    }  
    /* Teil 3: Zellen ausgeben */     
    /* a) set values in buffer */     
    if(I_am_active()) { 
      /* Teil 3.1: Innere Zellen ausgeben */ 
      ind = my_index;  
      number=Recursion_Cells_AVS_parallel(ind,0,buffer_send_int);  
      /* Teil 3.2: Randzellen */   
      iterate_hash2 {  
        if(bocell->Give_Index()<<my_index)  
          number = avs_bo_cell_parallel(bocell,number,buffer_send_int);  
      }  
    }  
    /* b) send */   
    if(my_rank!=0) {   
      MPI_Send(buffer_send_int,number_cells * 4,  
               MPI_INT,0,51,comm);  
    }  
    else {  
      start_num=0;  
      start_poi=0;  
      for(i=0;i<n_proc;++i) {  
        /* c) receive */  
        if(i!=0) {  
          MPI_Recv(buffer_rec_int,number_cells_process[i] * 4,  
                   MPI_INT,i,51,comm,&status);  
        }  
        else {  
          for(num=0;num<number_cells_process[i];++num) {  
            buffer_rec_int[num*4]   = buffer_send_int[num*4];   
            buffer_rec_int[num*4+1] = buffer_send_int[num*4+1];   
            buffer_rec_int[num*4+2] = buffer_send_int[num*4+2];   
            buffer_rec_int[num*4+3] = buffer_send_int[num*4+3];   
          }  
        }  
       /* d) print in file */    
        if(i<n_proc) {  
          for(num=0;num<number_cells_process[i];++num) {  
            *Datei << start_num+num+1 << " 1 tet "  
                   << " " << start_poi + buffer_rec_int[num*4]   
                   << " " << start_poi + buffer_rec_int[num*4+1]   
                   << " " << start_poi + buffer_rec_int[num*4+2]   
                   << " " << start_poi + buffer_rec_int[num*4+3]   
                   << "\n";  
          }  
        }  
        start_num = start_num + number_cells_process[i];  
        start_poi = start_poi + number_points_process[i];  
      }  
    }  
    if(my_rank==0) {  
      /* Teil 4: */ 
      *Datei << "1 1" << "\n";
    }
    
    // Teil 5:
    *Datei << "variable, unit " << "\n";

    if(I_am_active()) {
    // Teil 6: Ausgabe der Werte der Zell-Variablen
    // a) set values in buffer
    /* i)  Innere Zellen */ 
    ind = my_index; 
    number = Recursion_Cells_parallel(ind,0,number_cell_var,
                                      buffer_send_double); 
    /* ii) Randzellen */  
    iterate_hash2 { 
        if(bocell->Give_Index()<<my_index) 
          number = avs_bo_cell_parallel(bocell,number,number_cell_var,
                                        buffer_send_double); 
    }
    }
    // b) send
    if(my_rank!=0) {
      MPI_Send(buffer_send_double,number_cells,
               MPI_DOUBLE,0,52,comm);
    }
    else {
      start_num=0;
      for(i=0;i<n_proc;++i) {
        // c) receive
        if(i!=0) {
          MPI_Recv(buffer_rec_double,number_cells_process[i],
                   MPI_DOUBLE,i,52,comm,&status);       
        }
        else {
          for(num=0;num<number_cells_process[i];++num) {
            buffer_rec_double[num] = buffer_send_double[num];
          }
        }
        // d) print in file
        if(i<n_proc) {
          for(num=0;num<number_cells_process[i];++num) {
            *Datei << start_num+num
                   << " " << buffer_rec_double[num]
                   << "\n";
          }
        }
        start_num = start_num + number_cells_process[i];
      }
    }

    // Teil 7:
    if(I_am_active()) {
      delete(number_cells_process);
      delete(number_points_process);
    }
    delete(buffer_send_int);
    delete(buffer_send_double);
    if(my_rank==0) {
      delete(buffer_rec_int);
      delete(buffer_rec_double);
    }
  }
  MPI_Barrier(comm);
}


int Grid_base::avs_bo_cell_parallel(BoCell* bo,
                           int number, int number_cell_var,
                           double* buffer_send_double) {
  Tetraeder_storage* tets;

  for(tets = bo->Give_tets();tets!=NULL;tets = tets->Next()) {
    buffer_send_double[number] = tets->Give_variable()[number_cell_var];
    ++number; 
  }
  return number;
}

int Grid_base::Recursion_Cells_parallel(Index3D I, int number, 
                                        int number_cell_var,
                                        double* buffer_send_double) {
  int i;
  Index3D Ison;
  double value;

  for(i=0;i<8;++i) {
    if(Exists_Point(I.son((dir_sons)i)))
      number = Recursion_Cells_parallel(I.son((dir_sons)i),number,
                                   number_cell_var,buffer_send_double);
    else {
      if(Give_cell_typ(I.son((dir_sons)i)) == int_cell) {
        Ison = I.son((dir_sons)i);
        value = Give_cell_variable(Ison)[number_cell_var];

        buffer_send_double[number] = value;
        // 0. Tet: WND, WNT, WST, EST 
        number++;
        buffer_send_double[number] = value;
        // 1. Tet: EST, WND, WST, ESD  
        number++;
        buffer_send_double[number] = value;
        // 2. Tet: WND, WSD, WST, ESD        
        number++;
        buffer_send_double[number] = value;
        // 3. Tet: EST, WND, ESD, END
        number++;
        buffer_send_double[number] = value;
        // 4. Tet: ENT, WNT, EST, END
        number++;
        buffer_send_double[number] = value;
        // 5. Tet: WNT, WND, EST, END
        number++;
      }
    }
  }
  return number;
}

---