MacroReader.cc

#include "MacroReader.h"
#include "MacroWriter.h"
#include "MacroElement.h"
#include "Boundary.h"
#include "FiniteElemSpace.h"
#include "Mesh.h"
#include <string.h>
#include "FixVec.h"
#include "FixVecConvert.h"
#include "PeriodicMap.h"
#include "ElInfo.h"
#include "Parameters.h"
#include "DOFIterator.h"
#include "SurfaceRegion_ED.h"
#include "ElementRegion_ED.h"
#include "LeafData.h"
#include "VertexVector.h"
#include <map>
#include <iostream>
#include <fstream>

namespace AMDiS {

  MacroInfo* MacroReader::readMacro(const char *filename, 
				    Mesh* mesh,
				    const char *periodicFile,
				    int check)
  {
    FUNCNAME("Mesh::readMacro()");

    TEST_EXIT(filename)("no file specified; filename NULL pointer\n");
   
    MacroInfo *macroInfo = new MacroInfo();
    macroInfo->readAMDiSMacro(filename, mesh);

    std::deque<MacroElement*>::iterator mel = macroInfo->mel.begin();
    int **melVertex = macroInfo->mel_vertex;
    WorldVector<double> *coords = macroInfo->coords;
    DegreeOfFreedom **dof = macroInfo->dof;

    // === read periodic data =================================
    if (periodicFile && (strcmp(periodicFile, "") != 0)) {
      WARNING("periodic boundaries may lead to errors in small meshes if element neighbours not set\n");
    
      FILE *file = fopen(periodicFile, "r");
      TEST_EXIT(file)("can't open file %s\n", periodicFile);

      int n;
      int dim = mesh->getDim();

      int el1, el2;
      int *verticesEl1 = new int[dim];
      int *verticesEl2 = new int[dim];
      int mode = -1; // 0: drop dofs, 1: associate dofs
      int result;
      BoundaryType boundaryType;

      fscanf(file, "%*s %d", &n);

      fscanf(file, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s");

      PeriodicMap periodicMap;
    
      for (int i = 0; i < n; i++) {
	std::map<int, int> vertexMapEl1;
	std::map<int, int> vertexMapEl2;

	result = fscanf(file, "%d", &mode);
	TEST_EXIT(result == 1)("mode?\n");
      
	result = fscanf(file, "%d", &boundaryType);
	TEST_EXIT(result == 1)("boundaryType?\n");
      
	result = fscanf(file, "%d", &el1);
	TEST_EXIT(result == 1)("el1?\n");

	for (int j = 0; j < dim; j++) {
	  result = fscanf(file, "%d", &verticesEl1[j]);
	  TEST_EXIT(result == 1)("vertEl1[%d]\n", j);
	}
	result = fscanf(file, "%d", &el2);
	TEST_EXIT(result == 1)("el2?\n");
	for (int j = 0; j < dim; j++) {
	  result = fscanf(file, "%d", &verticesEl2[j]);
	  TEST_EXIT(result == 1)("vertEl2[%d]\n", j);
	}
	for (int j = 0; j < dim; j++) {
	  if (mode == 0)
	    periodicMap.setEntry(melVertex[el1][verticesEl1[j]], 
				 melVertex[el2][verticesEl2[j]]);	  
	  vertexMapEl1[verticesEl1[j]] = verticesEl2[j];
	  vertexMapEl2[verticesEl2[j]] = verticesEl1[j];
	}

	// calculate sides of periodic vertices
	int sideEl1 = 0, sideEl2 = 0;
	if (dim == 1) {
	  sideEl1 = verticesEl1[0];
	  sideEl2 = verticesEl2[0];
	} else {
	  for (int j = 0; j < dim + 1; j++) {
	    sideEl1 += j;
	    sideEl2 += j;
	  }
	  for (int j = 0; j < dim; j++) {
	    sideEl1 -= verticesEl1[j];
	    sideEl2 -= verticesEl2[j];
	  }
	}
	
	// create periodic info
	DimVec<WorldVector<double> > periodicCoordsEl1(dim - 1, NO_INIT);
	DimVec<WorldVector<double> > periodicCoordsEl2(dim - 1, NO_INIT);

	Element *element1 = const_cast<Element*>((*(mel + el1))->getElement());
	Element *element2 = const_cast<Element*>((*(mel + el2))->getElement());
      
	// for all vertices of this side
	for (int j = 0; j < dim; j++) {
	  periodicCoordsEl1[element1->getPositionOfVertex(sideEl1, verticesEl1[j])] = 
	    coords[melVertex[el2][vertexMapEl1[verticesEl1[j]]]];
	  periodicCoordsEl2[element2->getPositionOfVertex(sideEl2, verticesEl2[j])] =
	    coords[melVertex[el1][vertexMapEl2[verticesEl2[j]]]];
	}
      
	// decorate leaf data
	ElementData *ld1 = element1->getElementData();
	ElementData *ld2 = element2->getElementData();

	LeafDataPeriodic *ldp1 = dynamic_cast<LeafDataPeriodic*>(ld1->getElementData(PERIODIC));
	LeafDataPeriodic *ldp2 = dynamic_cast<LeafDataPeriodic*>(ld2->getElementData(PERIODIC));

	if (!ldp1) {
	  ldp1 = new LeafDataPeriodic(ld1);
	  element1->setElementData(ldp1);
	}

	if (!ldp2) {
	  ldp2 = new LeafDataPeriodic(ld2);
	  element2->setElementData(ldp2);
	}

	ldp1->addPeriodicInfo(mode, boundaryType, sideEl1, &periodicCoordsEl1);
	ldp2->addPeriodicInfo(mode, boundaryType, sideEl2, &periodicCoordsEl2);

	if (mode != 0) {
	  VertexVector *associated = mesh->periodicAssociations[boundaryType];

	  if (!associated) {
	    associated = new VertexVector(mesh->getVertexAdmin(), "vertex vector");
	    mesh->periodicAssociations[boundaryType] = associated;
	    VertexVector::Iterator it(associated, ALL_DOFS);
	    for (it.reset2(); !it.end(); ++it)
	      *it = it.getDOFIndex();
	  }

	  for (int j = 0; j < dim; j++) {
	    (*associated)[melVertex[el1][verticesEl1[j]]] =
	      melVertex[el2][vertexMapEl1[verticesEl1[j]]];
	    (*associated)[melVertex[el2][verticesEl2[j]]] =
	      melVertex[el1][vertexMapEl2[verticesEl2[j]]];
	  }
	}
      }    

      delete [] verticesEl1;
      delete [] verticesEl2;

      // change periodic vertex dofs
      for (int i = 0; i < mesh->getNumberOfVertices(); i++) {
	if (periodicMap.getEntry(i) != -1) {
	  mesh->freeDOF(dof[i], VERTEX);
	  dof[i] = dof[periodicMap.getEntry(i)];

	  std::map<BoundaryType, VertexVector*>::iterator assoc;
	  std::map<BoundaryType, VertexVector*>::iterator assocEnd =
	    mesh->periodicAssociations.end();

	  for (assoc = mesh->periodicAssociations.begin(); assoc != assocEnd; ++assoc) {

	    DegreeOfFreedom a = (*(assoc->second))[i];
	    if (a != i) {
	      (*(assoc->second))[i] = i;
	      (*(assoc->second))[a] = periodicMap.getEntry(i);
	    }
	  }

	}
      }

      std::map<BoundaryType, VertexVector*>::iterator assoc;
      std::map<BoundaryType, VertexVector*>::iterator assocEnd =
	mesh->periodicAssociations.end();
      for (assoc = mesh->periodicAssociations.begin(); assoc != assocEnd; ++assoc) {
	for (int i = 0; i < mesh->getNumberOfVertices(); i++)
	  if (i != (*(assoc->second))[i])
	    MSG("association %d: vertex %d -> vertex %d\n", 
		assoc->first, i, (*(assoc->second))[i]);	
      }

      for (int i = 0; i < mesh->getNumberOfVertices(); i++)
	if (periodicMap.getEntry(i) != -1)
	  MSG("identification : vertex %d is now vertex %d\n", 
	      i, periodicMap.getEntry(i));
    }

    // =========================================================

    for (int i = 0; i < mesh->getNumberOfMacros(); i++) {
      for (int k = 0; k < mesh->getGeo(VERTEX); k++) {
	(*(mel + i))->setCoord(k, coords[melVertex[i][k]]);

	const_cast<Element*>((*(mel + i))->getElement())->
	  setDOF(k, dof[melVertex[i][k]]);
      }
    }

    if (!macroInfo->neigh_set) {
      TEST_EXIT(!periodicFile)
	("periodic boundary condition => element neighbours must be set\n");
      computeNeighbours(mesh);
    } else {
      /****************************************************************************/
      /* fill MEL oppVertex values when reading neighbour information form file  */
      /****************************************************************************/

      for (int i = 0; i < mesh->getNumberOfMacros(); i++) {
	for (int k = 0; k < mesh->getGeo(NEIGH); k++) {
	  MacroElement *neigh = const_cast<MacroElement*>(mel[i]->getNeighbour(k));

	  if (neigh) {
	    int j = 0;
	    for (; j < mesh->getGeo(NEIGH); j++)
	      if (neigh->getNeighbour(j) == *(mel + i))  
		break;
	
	    TEST_EXIT(j < mesh->getGeo(NEIGH))("el %d no neighbour of neighbour %d\n", 
					       mel[i]->getIndex(), neigh->getIndex());
	    mel[i]->setOppVertex(k, j);
	  } else {
	    mel[i]->setOppVertex(k, -1);
	  }
	}
      }
    }

    if (!macroInfo->bound_set) {
      macroInfo->dirichletBoundary();
    }
  
    if (mesh->getDim() > 1)
      boundaryDOFs(mesh);

    // initial boundary projections
    int numFaces = mesh->getGeo(FACE);
    int dim = mesh->getDim();
    mel = mesh->firstMacroElement();
    for (int i = 0; i < mesh->getNumberOfLeaves(); i++) {
      MacroElement *macroEl = *(mel+i);
      Projection *projector = macroEl->getProjection(0);
      if (projector && projector->getType() == VOLUME_PROJECTION) {
	for (int j = 0; j <= dim; j++)
	  projector->project(macroEl->getCoord(j));	
      } else {
	for (int j = 0; j < mesh->getGeo(EDGE); j++) {
	  projector = macroEl->getProjection(numFaces + j);
	  if (projector) {
	    int vertex0 = Global::getReferenceElement(dim)->getVertexOfEdge(j, 0);
	    int vertex1 = Global::getReferenceElement(dim)->getVertexOfEdge(j, 1);
	    projector->project(macroEl->getCoord(vertex0));
	    projector->project(macroEl->getCoord(vertex1));
	  }
	}
      }
    }

    macroInfo->fillBoundaryInfo(mesh);

    if (mesh->getNumberOfDOFs(CENTER)) {
      for (int i = 0; i < mesh->getNumberOfMacros(); i++)
	const_cast<Element*>(mel[i]->getElement())->
	  setDOF(mesh->getNode(CENTER), mesh->getDOF(CENTER));
    }

    /****************************************************************************/
    /* domain size                                                              */
    /****************************************************************************/

    WorldVector<double> x_min, x_max;

    for (int j = 0; j < Global::getGeo(WORLD); j++) {
      x_min[j] =  1.E30;
      x_max[j] = -1.E30;
    }

    for (int i = 0; i < mesh->getNumberOfVertices(); i++) {
      for (int j = 0; j < Global::getGeo(WORLD); j++) {
	x_min[j] = std::min(x_min[j], coords[i][j]);
	x_max[j] = std::max(x_max[j], coords[i][j]);
      }
    }

    for (int j = 0; j < Global::getGeo(WORLD); j++)
      mesh->setDiameter(j, x_max[j] - x_min[j]);

    if (check) {
      checkMesh(mesh);

      if (mesh->getDim() > 1) {
	char filenew[128];
	strncpy(filenew, filename, 128); 
	filenew[127] = 0;
	strncat(filenew, ".new", 128);   
	filenew[127] = 0;
	macroTest(mesh, filenew);
      }
    }

    return macroInfo;
  }

  /****************************************************************************/
  /*  fill macro info structure and some pointers in mesh ...                 */
  /****************************************************************************/

  void MacroInfo::fill(Mesh *pmesh, int ne, int nv)
  {
    FUNCNAME("MacroInfo::fill()");

    TEST_EXIT(pmesh)("no mesh\n");

    int dim = pmesh->getDim(); 
    mesh = pmesh;

    mesh->setNumberOfElements(ne);
    mesh->setNumberOfLeaves(ne);
    mesh->setNumberOfVertices(nv);

    for (int i = 0; i < ne; i++) {
      MacroElement *newMacro = new MacroElement(mesh->getDim());
      mel.push_back(newMacro);
      mesh->addMacroElement(mel[i]);
    }

    dof = new DegreeOfFreedom*[nv];
    coords = new WorldVector<double>[nv];
    mel_vertex = new int*[ne];

    for (int i = 0; i < ne; i++)
      mel_vertex[i] = new int[mesh->getGeo(VERTEX)];

    for (int i = 0; i < nv; i++)
      dof[i] = mesh->getDOF(VERTEX);

    for (int i = 0; i < ne; i++) {
      mel[i]->element = mesh->createNewElement();
      mel[i]->index = i;

      if (dim == 3)
	mel[i]->elType = 0;
    }
    neigh_set = false;
    bound_set = false;
  }

  void MacroInfo::clear()
  {
    for (int i = 0; i < mesh->getNumberOfMacros(); i++)
      delete [] mel_vertex[i];

    delete [] mel_vertex;
    delete [] coords;
    coords = NULL;  
    delete [] dof;
    dof = NULL;

    mesh = NULL;
    neigh_set = false;
  }

  /****************************************************************************/
  /****************************************************************************/
  /*  tool for reading macro triangulations in ALBERT-format                  */
  /****************************************************************************/
  /****************************************************************************/

  /****************************************************************************/
  /*  read_indices()  reads dim+1 indices from  file  into  id[0-dim],        */
  /*    returns true if dim+1 inputs arguments could be read successfully by  */
  /*    fscanf(), else false                                                  */
  /****************************************************************************/

  int  MacroInfo::read_indices(FILE *file, DimVec<int> &id)
  {
    int dim = mesh->getDim();

    for (int i = 0; i <= dim; i++)
      if (fscanf(file, "%d", &id[i]) != 1)
	return(false);

    return(true);
  }

#define N_KEYS      14
#define N_MIN_KEYS  7
  static const char *keys[N_KEYS] = {
    "DIM",                   //  0 
    "DIM_OF_WORLD",          //  1
    "number of vertices",    //  2
    "number of elements",    //  3
    "vertex coordinates",    //  4
    "element vertices",      //  5
    "element boundaries",    //  6
    "element neighbours",    //  7
    "element type",          //  8
    "projections",           //  9
    "element region",        // 10
    "surface region",        // 11
    "mesh name",             // 12
    "time"                   // 13
  };

  static int get_key_no(const char *key)
  {
    for (int i = 0; i < N_KEYS; i++)
      if (!strcmp(keys[i], key))  
	return i;

    return -1;
  }

#include <ctype.h>

  static const char *read_key(const char *line)
  {
    static char key[100];
    char *k = key;

    while (isspace(*line)) 
      line++;
    while ((*k++ = *line++) != ':');
    *--k = '\0';
  
    return(const_cast<const char *>( key));
  }

  /****************************************************************************/
  /*  read_albert_macro():                                                    */
  /*    read macro triangulation from ascii file in ALBERT format             */
  /*    fills macro_info structure                                            */
  /*    called by read_macro(), fills missing information                     */
  /****************************************************************************/


  void MacroInfo::readAMDiSMacro(const char *filename, Mesh* mesh)
  {
    FUNCNAME("MacroInfo::readAMDiSMacro()");

    int dim;
    int dow, nv, ne, j, k;
    double dbl;
    char line[256];
    int line_no, n_keys, sort_key[N_KEYS], nv_key, ne_key;
    int key_def[N_KEYS] = {0,0,0,0,0,0,0,0,0,0,0,0};
    const char *key;
    DimVec<int> *ind = NULL;

    TEST_EXIT(filename)("no file specified; filename NULL pointer\n");
    TEST_EXIT(strlen(filename) < static_cast<unsigned int>(127))
      ("can only handle filenames up to 127 characters\n");

    FILE *file = fopen(filename, "r");
    TEST_EXIT(file)("cannot open file %s\n", filename);

    /****************************************************************************/
    /*  looking for all keys in the macro file ...                              */
    /****************************************************************************/

    line_no = n_keys = 0;
    while (fgets(line, 255, file)) {
      line_no++;
      if (!strchr(line, ':'))  
	continue;
      key = read_key(line);
      int i_key = get_key_no(key);
      TEST_EXIT(i_key >= 0)
	("macro file %s must not contain key %s on line %d\n",
	 filename, key, line_no);
      TEST_EXIT(!key_def[i_key])("key %s defined second time on line %d in file %s\n");

      sort_key[n_keys++] = i_key;
      key_def[i_key] = true;
    }
    fclose(file);


    /*******************************************************************************/
    /*  Test, if there is data for every key and if all is defined in right order. */
    /*******************************************************************************/

    for (int i_key = 0; i_key < N_MIN_KEYS; i_key++) {
      for (j = 0; j < n_keys; j++)
	if (sort_key[j] == i_key)  break;
      TEST_EXIT(j < n_keys)("You do not have specified data for %s in %s\n",
			    keys[i_key], filename);

      for (j = 0; j < n_keys; j++)
	if (sort_key[j] == 2)  break;
      nv_key = j;
      for (j = 0; j < n_keys; j++)
	if (sort_key[j] == 3)  break;
      ne_key = j;
    
      switch (i_key) {
      case 0:
      case 1:
	TEST_EXIT(sort_key[i_key] < 2)
	  ("You have to specify DIM or mesh->getGeo(WORLD) before all other data\n");
	break;
      case 4: 
	TEST_EXIT(nv_key < i_key)
	  ("Before reading data for %s, you have to specify the %s in file\n",
	   keys[4], keys[2], filename);
	break;
      case 5: 
	TEST_EXIT(nv_key < i_key  &&  ne_key < i_key)
	  ("Before reading data for %s, you have to specify the %s and %s in file %s\n",
	   keys[5], keys[3], keys[2], filename);
      case 6:
      case 7:
      case 8:
	TEST_EXIT(ne_key < i_key)
	  ("Before reading data for %s, you have to specify the %s in file %s\n",
	   keys[i_key], keys[3], filename);
      }
    }

    for (int i_key = 0; i_key < N_KEYS; i_key++)
      key_def[i_key] = false;

    /****************************************************************************/
    /*  and now, reading data ...                                               */
    /****************************************************************************/
	
    file = fopen(filename, "r");
    TEST_EXIT(file)("cannot open file %s\n", filename);

    int result;

    for (int i_key = 0; i_key < n_keys; i_key++) {

      switch (sort_key[i_key]) {
	
      case 0:
	// line "DIM"
	result = fscanf(file, "%*s %d", &dim);
	TEST_EXIT(result == 1)("cannot read DIM correctly in file %s\n", filename);

	ind = new DimVec<int>(dim, NO_INIT);

	key_def[0] = true;
	break;

      case 1:
	// line "DIM_OF_WORLD"
	result = fscanf(file, "%*s %d", &dow);
	TEST_EXIT(result == 1)
	  ("cannot read Global::getGeo(WORLD) correctly in file %s\n", filename);
	TEST_EXIT(dow == Global::getGeo(WORLD))
	  ("dimension of world = %d != Global::getGeo(WORLD) = %d\n", 
	   dow, Global::getGeo(WORLD));

	key_def[1] = true;
	break;

      case 2:
	// line "number of vertices"
	result = fscanf(file, "%*s %*s %*s %d", &nv);
	TEST_EXIT(result == 1)
	  ("cannot read number of vertices correctly in file %s\n", filename);
	TEST_EXIT(nv > 0)
	  ("number of vertices = %d must be bigger than 0\n", nv);

	key_def[2] = true;
	if (key_def[3])
	  fill(mesh, ne, nv);
	break;

      case 3:
	// line "number of elements"
	result = fscanf(file, "%*s %*s %*s %d", &ne);
	TEST_EXIT(result == 1)
	  ("cannot read number of elements correctly in file %s\n", filename);
	TEST_EXIT(ne > 0)
	  ("number of elements = %d must be bigger than 0\n", ne);

	key_def[3] = true;
	if (key_def[2])
	  fill(mesh, ne, nv);
	break;

      case 4:
	// block "vertex coordinates"
	fscanf(file, "%*s %*s");
	for (int i = 0; i < nv; i++) {
	  for (j = 0; j <Global::getGeo(WORLD) ; j++) {
	    result = fscanf(file, "%lf", &dbl);
	    TEST_EXIT(result == 1)
	      ("error while reading coordinates, check file %s\n", filename);
	    coords[i][j] = dbl;
	  }
	}
	key_def[4] = true;
	break;

      case 5:
	// block "element vertices"
	fscanf(file, "%*s %*s");

	/****************************************************************************/
	/* global number of vertices on a single element                            */
	/****************************************************************************/

	for (int i = 0; i < ne; i++) {
	  result = read_indices(file, *ind);
	  TEST_EXIT(result)
	    ("cannot read vertex indices of element %d in file %s\n",  i, filename);

	  for (k = 0; k < mesh->getGeo(VERTEX); k++)
	    mel_vertex[i][k] = (*ind)[k];
	}

	key_def[5] = true;
	break;

      case 6:
	// block "element boundaries"
	fscanf(file, "%*s %*s");

	/****************************************************************************/
	/* MEL boundary pointers                                                    */
	/****************************************************************************/
	for (int i = 0; i < ne; i++) {  
	  // boundary information of ith element 

	  result = read_indices(file, *ind);
	  TEST_EXIT(result)
	    ("cannot read boundary type of element %d in file %s\n", i, filename);

	  // fill boundary of macro-element
	  MacroReader::fillMelBoundary(mesh, 
				       mel[i], 
				       VecConv<int,NEIGH,PARTS>::convertVec((*ind), mesh));
	}

	this->fillBoundaryInfo(mesh);
                   
	bound_set = true;
	key_def[6] = true;
	break;

      case 7:
	// block "element neighbours"
	fscanf(file, "%*s %*s");

	/****************************************************************************/
	/* fill MEL neighbour pointers:                                             */
	/*   if they are specified in the file: read them from file,                */
	/*   else init them by a call of fill_mel_neighbour()                       */
	/****************************************************************************/
	neigh_set = true;
	for (int i = 0; i < ne; i++) {
	  //  neighbour information about ith element

	  if (read_indices(file, *ind)) {
	    MacroReader::fillMelNeigh(mel[i], mel, 
				      VecConv<int,NEIGH,PARTS>::convertVec((*ind), 
									   mesh));
	  } else {
	    neigh_set = false; /* setting of neighbours fails :-( */
	    break;
	  }
	}

	key_def[7] = true;
	break;

      case 8:
	// block "element type"
	fscanf(file, "%*s %*s");
	/****************************************************************************/
	/* MEL elType                                                               */
	/****************************************************************************/

	if (dim == 2 || dim == 1)
	  ERROR("there is no element type in 2d and 2d; ignoring data for elType\n");

	for (int i = 0; i < ne; i++) {
	  result = fscanf(file, "%d", &j);
	  TEST_EXIT(result == 1)
	    ("cannot read elType of element %d in file %s\n", i, filename);
	  if (dim == 3)
	    (mel)[i]->elType = j;
	}

	key_def[8] = true;
	break;

      case 9:
	// block "projections"
	{
	  fscanf(file, "%*s");

	  int numFaces = mesh->getGeo(FACE);
	  int numEdgesAtBoundary = 0;

	  for (k = 1; k < dim; k++)
	    numEdgesAtBoundary += k;

	  for (int i = 0; i < ne; i++) {
	    result = read_indices(file, *ind);
	    TEST_EXIT(result)
	      ("cannot read boundary projector of element %d in file %s\n", i, filename);
	
	    Projection *projector = Projection::getProjection((*ind)[0]);

	    if (projector && projector->getType() == VOLUME_PROJECTION) {
	      mel[i]->setProjection(0, projector);
	    } else { // boundary projection
	      for (j = 0; j < mesh->getGeo(NEIGH); j++) {
		projector = Projection::getProjection((*ind)[j]);
		if (projector) {
		  mel[i]->setProjection(j, projector);
		  if (dim > 2) {
		    for (k = 0; k < numEdgesAtBoundary; k++) {
		      int edgeNr = Global::getReferenceElement(dim)->getEdgeOfFace(j, k);
		      mel[i]->setProjection(numFaces + edgeNr, projector);
		    }
		  }
		}
	      }
	    }
	  }
	}
	key_def[9] = true;
	break;

      case 10:
	// block "element region"
	fscanf(file, "%*s %*s");
	/****************************************************************************/
	/* MEL regions                                                              */
	/****************************************************************************/

	for (int i = 0; i < ne; i++) {
	  result = fscanf(file, "%d", &j);
	  TEST_EXIT(result == 1)
	    ("cannot read region of element %d in file %s\n", i, filename);
	  if (j >= 0) {
	    Element *el = mel[i]->getElement();
	    ElementRegion_ED *elementRegion = 
	      new ElementRegion_ED(el->getElementData());
	    elementRegion->setRegion(j);
	    el->setElementData(elementRegion);
	  }
	}
	key_def[10] = true;
	break;

      case 11:
	// block "surface region"
	fscanf(file, "%*s %*s");
	for (int i = 0; i < ne; i++) {
	  result = read_indices(file, *ind);
	  TEST_EXIT(result)
	    ("cannot read surface regions of element %d in file %s\n", i, filename);

	  Element *el = mel[i]->getElement();

	  for (j = 0; j < mesh->getGeo(NEIGH); j++) {
	    if ((*ind)[j] >= 0) {
	      SurfaceRegion_ED *surfaceRegion = 
		new SurfaceRegion_ED(el->getElementData());
	      surfaceRegion->setSide(j);
	      surfaceRegion->setRegion((*ind)[j]);
	      el->setElementData(surfaceRegion);
	    }
	  }
	}
	key_def[11] = true;
	break;

      case 12:
	// line "mesh name"
	fscanf(file, "%*s %*s %*s");
	break;

      case 13:
	// line "time"
	fscanf(file, "%*s %*s");
	break;
      }
    }

    if (ind)
      delete ind;

    fclose(file);
  }


  int macro_type(const char *filename, const char *type)
  {
    const char *fn, *t;
  
    if (strlen(filename) <= strlen(type))
      return(false);
  
    fn = filename;
    while (*fn) fn++;
    t = type;
    while (*t) t++;
  
    while (t != type  &&  *t == *fn) t--;
  
    return(t == type);
  }


  /****************************************************************************/
  /*  sets the boundary of all edges/faces with no neigbour to a straight     */
  /*  line/face with Dirichlet boundary type                                  */
  /****************************************************************************/

  void MacroInfo::dirichletBoundary()
  {
    for (int i = 0; i < static_cast<int>( mel.size()); i++) {
      for (int k = 0; k < mesh->getGeo(NEIGH); k++) {
	if (mel[i]->neighbour[k])
	  mel[i]->boundary[k] = INTERIOR;
	else
	  mel[i]->boundary[k] = DIRICHLET;
      }
    }
  }


  void MacroInfo::fillBoundaryInfo(Mesh *mesh)
  {
    int i, j, k, nv = mesh->getNumberOfVertices();

    std::deque<MacroElement*>::iterator melIt;

    BoundaryType *bound = new BoundaryType[nv];

    int dim = mesh->getDim();

    switch(dim) {
    case 1:
      break;
    case 2:
      for (i = 0; i < nv; i++)
	bound[i] = INTERIOR;

      for (i = 0, melIt = mesh->firstMacroElement(); 
	   melIt != mesh->endOfMacroElements(); 
	   ++melIt, i++) {
	for (j = 0; j < mesh->getGeo(NEIGH); j++) {
	  if ((*melIt)->getBoundary(j) != INTERIOR) {
	    if ((*melIt)->getBoundary(j) >= DIRICHLET) {
	      int j1 = mel_vertex[i][(j+1)%3];
	      int j2 = mel_vertex[i][(j+2)%3];
	      
	      bound[j1] = max(bound[j1], (*melIt)->getBoundary(j));
	      bound[j2] = max(bound[j2], (*melIt)->getBoundary(j));
	    } else if ((*melIt)->getBoundary(j) <= NEUMANN) {
	      int j1 = mel_vertex[i][(j+1)%3];
	      int j2 = mel_vertex[i][(j+2)%3];
	      
	      if (bound[j1] != INTERIOR)
		bound[j1] = max(bound[j1], (*melIt)->getBoundary(j));
	      else
		bound[j1] = (*melIt)->getBoundary(j);
	      
	      if (bound[j2] != INTERIOR)
		bound[j2] = max(bound[j2], (*melIt)->getBoundary(j));
	      else
		bound[j2] = (*melIt)->getBoundary(j);
	    }
	  }
	}
      }

      for (i = 0, melIt = mesh->firstMacroElement(); 
	   melIt != mesh->endOfMacroElements(); 
	   ++melIt, i++) 
	for (j = 0; j < mesh->getGeo(VERTEX); j++)
	  (*melIt)->setBoundary(3 + j, bound[mel_vertex[i][j]]);
	
      break;
    case 3:
      for (i = 0; i < nv; i++)
	bound[i] = INTERIOR;

      for (i = 0, melIt = mesh->firstMacroElement(); 
	   melIt != mesh->endOfMacroElements(); 
	   ++melIt, i++) {
	for (j = 0; j < mesh->getGeo(NEIGH); j++) {
	  for (k = 1; k < 4; k++)
	    bound[mel_vertex[i][(j+k)%4]] =
	      ((*melIt)->getBoundary(j) != INTERIOR) ?
	      newBound((*melIt)->getBoundary(j),
		       bound[mel_vertex[i][(j+k)%4]]) :
	      bound[mel_vertex[i][(j+k)%4]];
	}
      }

      for (i = 0, melIt = mesh->firstMacroElement(); 
	   melIt != mesh->endOfMacroElements(); 
	   ++melIt, i++) 	
	for (j = 0; j < mesh->getGeo(VERTEX); j++)
	  (*melIt)->setBoundary(10 + j, bound[mel_vertex[i][j]]);
      
      break;
    default: 
      ERROR_EXIT("invalid dim\n");
    }

    delete [] bound;
  }

  void MacroReader::computeNeighbours(Mesh *mesh)
  {
    FUNCNAME("MacroReader::computeNeighbours()");

    int dim = mesh->getDim();
    FixVec<DegreeOfFreedom*, DIMEN> dof(dim, NO_INIT);

    for (int i = 0; i < mesh->getNumberOfLeaves(); i++) {
      for (int k = 0; k < mesh->getGeo(NEIGH); k++) {
	mesh->getMacroElement(i)->setOppVertex(k, AMDIS_UNDEFINED);
	mesh->getMacroElement(i)->setNeighbour(k, NULL);
      }
    }

    for (int i = 0; i < mesh->getNumberOfLeaves(); i++) {
      for (int k = 0; k < mesh->getGeo(NEIGH); k++) {
	if (mesh->getMacroElement(i)->getBoundary(k) != INTERIOR) {
	  mesh->getMacroElement(i)->setNeighbour(k, NULL);
	  mesh->getMacroElement(i)->setOppVertex(k, -1);
	  continue;
	}

	if (mesh->getMacroElement(i)->getOppVertex(k) == AMDIS_UNDEFINED) {
	  if (dim == 1) {
	    dof[0] = const_cast<DegreeOfFreedom*>(mesh->getMacroElement(i)->
						  getElement()->getDOF(k));
	  } else {
	    for (int l = 0; l < dim; l++)
	      dof[l] = const_cast<DegreeOfFreedom*>(mesh->getMacroElement(i)->
						    getElement()->
						    getDOF((k + l + 1) % (dim + 1)));
	  }
	  
	  int j = 0;
	  for (j = i + 1; j < mesh->getNumberOfLeaves(); j++) {
	    int m = mesh->getMacroElement(j)->getElement()->oppVertex(dof);
	    if (m != -1) {
	      mesh->getMacroElement(i)->setNeighbour(k, mesh->getMacroElement(j));
	      mesh->getMacroElement(j)->setNeighbour(m, mesh->getMacroElement(i));
	      mesh->getMacroElement(i)->setOppVertex(k, m);
	      mesh->getMacroElement(j)->setOppVertex(m, k);
	      break;
	    }
	  }

	  if (j >= mesh->getNumberOfLeaves()) {
	    std::cout << "----------- ERROR ------------" << std::endl;
	    std::cout << "Cannot find neighbour " << k << " of element " << i << std::endl;
	    std::cout << "  dim = " << dim << std::endl;
	    std::cout << "  coords of element = ";
	    for (int l = 0; l <= dim; l++) {
	      std::cout << mesh->getMacroElement(i)->getCoord(l);
	      if (l < dim)
		std::cout << " / ";	      
	    }
	    std::cout << std::endl;
	    std::cout << "  dofs = ";
	    for (int l = 0; l < dim; l++)
	      std::cout << *(dof[l]) << " ";	    
	    std::cout << std::endl;

	    ERROR_EXIT("\n");
	  }    
	}
      }
    }
  }


  /****************************************************************************/
  /*  boundaryDOFs:                                                           */
  /*  adds dof's at the edges of a given macro triangulation and calculates   */
  /*  the number of edges                                                     */
  /****************************************************************************/

  void MacroReader::boundaryDOFs(Mesh *mesh)
  {
    FUNCNAME("Mesh::boundaryDOFs()");

    int lnode = mesh->getNode(EDGE);
    int k, lne = mesh->getNumberOfLeaves();
    int max_n_neigh = 0, n_neigh, ov;
    std::deque<MacroElement*>::iterator mel;
    const MacroElement* neigh;
    DegreeOfFreedom *dof;

    mesh->setNumberOfEdges(0);
    mesh->setNumberOfFaces(0);

    int dim = mesh->getDim();

    switch (dim) {
    case 2:
      for (mel = mesh->firstMacroElement(); mel != mesh->endOfMacroElements(); mel++) {
	// check for periodic boundary
	Element *el = const_cast<Element*>((*mel)->getElement());
	ElementData *ed = el->getElementData(PERIODIC);

	DimVec<bool> periodic(dim, DEFAULT_VALUE, false);

	if (ed) {
	  std::list<LeafDataPeriodic::PeriodicInfo> &periodicInfos = 
	    dynamic_cast<LeafDataPeriodic*>(ed)->getInfoList();
	  std::list<LeafDataPeriodic::PeriodicInfo>::iterator it;
	  std::list<LeafDataPeriodic::PeriodicInfo>::iterator end = periodicInfos.end();
	  for (it = periodicInfos.begin(); it != end; ++it)
	    if (it->type != 0)
	      periodic[it->elementSide] = true;
	}

	for (int i = 0; i < mesh->getGeo(NEIGH); i++) {
	  if (!(*mel)->getNeighbour(i) || 
	      ((*mel)->getNeighbour(i)->getIndex() < (*mel)->getIndex())) {

	    mesh->incrementNumberOfEdges(1);

	    if (mesh->getNumberOfDOFs(EDGE)) {
	      dof = el->setDOF(lnode + i, mesh->getDOF(EDGE));
      
	      if ((*mel)->getNeighbour(i)) {
		Element *neigh = 
		  const_cast<Element*>((*mel)->getNeighbour(i)->getElement());

		if (periodic[i])
		  neigh->setDOF(lnode + (*mel)->getOppVertex(i), mesh->getDOF(EDGE));
		else
		  neigh->setDOF(lnode + (*mel)->getOppVertex(i), dof);		
	      }
	    }
	  }  
	}
      }
      break;
    case 3:
      lnode = mesh->getNode(FACE);
      mel = mesh->firstMacroElement();
      for (int i = 0; i < lne; i++) {

	// check for periodic boundary
	Element *el = const_cast<Element*>((*(mel+i))->getElement());
	ElementData *ed = el->getElementData(PERIODIC);

	DimVec<bool> periodic(dim, DEFAULT_VALUE, false);
      
	if (ed) {
	  std::list<LeafDataPeriodic::PeriodicInfo> &periodicInfos = 
	    dynamic_cast<LeafDataPeriodic*>(ed)->getInfoList();
	  std::list<LeafDataPeriodic::PeriodicInfo>::iterator it;
	  std::list<LeafDataPeriodic::PeriodicInfo>::iterator end = periodicInfos.end();
	  for (it = periodicInfos.begin(); it != end; ++it)
	    if (it->type != 0)
	      periodic[it->elementSide] = true;
	}

	for (k = 0; k < mesh->getGeo(EDGE); k++) {      
	  /*********************************************************************/
	  /* check for not counted edges                                       */
	  /*********************************************************************/
	  n_neigh = 1;

	  if (newEdge(mesh, (*(mel + i)), k, &n_neigh)) {
	    mesh->incrementNumberOfEdges(1);
	    max_n_neigh = max(max_n_neigh, n_neigh);
	  }
	}
      
	for (k = 0; k < mesh->getGeo(NEIGH); k++) {
	  neigh = (*(mel + i))->getNeighbour(k);
	  /*********************************************************************/
	  /* face is counted and dof is added by the element with bigger index */
	  /*********************************************************************/
	  if (neigh && (neigh->getIndex() > (*(mel + i))->getIndex()))  
	    continue;
	
	  mesh->incrementNumberOfFaces(1);
	
	  if (mesh->getNumberOfDOFs(FACE)) {
	    TEST_EXIT(!(*(mel + i))->getElement()->getDOF(lnode + k))
	      ("dof %d on element %d already set\n", 
	       lnode + k, (*(mel + i))->getIndex());
	  
	    const_cast<Element*>((*(mel + i))->getElement())->setDOF(lnode + k,
								     mesh->getDOF(FACE));

	    if (neigh) {
	      ov = (*(mel + i))->getOppVertex(k);
	      TEST_EXIT(!neigh->getElement()->getDOF(lnode + ov))
		("dof %d on neighbour %d already set\n", 
		 lnode + ov, neigh->getIndex());
	    
	      Element *neighEl = 
		const_cast<Element*>((*(mel + i))->getNeighbour(k)->getElement());

	      if (periodic[k])
		neighEl->setDOF(lnode+ov, mesh->getDOF(FACE));
	      else
		neighEl->setDOF(lnode+ov, const_cast<int*>((*(mel + i))->getElement()->
							   getDOF(lnode + k)));	      
	    }
	  }
	}
      }
      break;
    default: 
      ERROR_EXIT("invalid dim\n");
    }
    
    if (3 == dim)
      mesh->setMaxEdgeNeigh(std::max(8, 2 * max_n_neigh));
    else
      mesh->setMaxEdgeNeigh(dim - 1);    
  }

  /* 
     testet mesh auf auftretende Zyklen
  
     wenn Zyklus auftritt:
     ordnet Eintraege in MacroElement-Struktur um, so dass kein Zyklus auftritt
     erzeugt neue Macro-Datei nameneu mit umgeordnetem Netz 
     (wenn nameneu=NULL wird keine MAcro-Datei erzeugt)
  */      

  void MacroReader::macroTest(Mesh *mesh, const char *nameneu)
  {
    FUNCNAME("MacroReader::macroTest()");
   
    int i = macrotest(mesh);

    if (i >= 0) {
      ERROR("There is a cycle beginning in macro element %d\n", i);
      ERROR("Entries in MacroElement structures get reordered\n");
      umb(NULL, mesh, umbVkantMacro);

      if (nameneu)
	ERROR_EXIT("mesh->feSpace\n");
    }
  }
  
  /****************************************************************************/
  /*  macro_test():                              Author: Thomas Kastl (1998)  */
  /****************************************************************************/
  /*
    testet mesh auf auftretende Zyklen
  
    wenn mesh zyklenfrei -> -1
    sonst ->  globaler Index des Macroelementes bei dem ein Zyklus beginnt 
  */

  int MacroReader::macrotest(Mesh *mesh)
  {
    FUNCNAME("MacroReader::macrotest()");

    std