* Copy operator for meshes implemented

AMDiS/src/DOFAdmin.cc

@@ -23,7 +23,7 @@ namespace AMDiS {
     init(); 
   }
 
-  DOFAdmin::DOFAdmin(Mesh* m,std::string aName) 
+  DOFAdmin::DOFAdmin(Mesh* m, std::string aName) 
     : name(aName), 
       mesh(m), 
       nrDOF(mesh->getDim(), NO_INIT),
@@ -34,7 +34,11 @@ namespace AMDiS {
 
   void DOFAdmin::init()
   {
-    firstHole = size = usedCount = holeCount = sizeUsed = 0;
+    firstHole = 0;
+    size = 0;
+    usedCount = 0;
+    holeCount = 0;
+    sizeUsed = 0;
     dofFree.clear();
   }
 
@@ -75,6 +79,9 @@ namespace AMDiS {
 
   DOFAdmin::DOFAdmin(const DOFAdmin&)
   {
+    FUNCNAME("DOFAdmin::DOFAdmin()");
+
+    ERROR_EXIT("TODO\n");
   }
 
   void DOFAdmin::freeDOFIndex(int dof) {

AMDiS/src/DOFAdmin.h

@@ -152,14 +152,14 @@ namespace AMDiS {
      */
     std::list<DOFIndexedBase*>::iterator beginDOFIndexed() {
       return dofIndexedList.begin();
-    };
+    }
 
     /** \brief
      * Returns an iterator to the end of \ref dofIndexedList
      */
     std::list<DOFIndexedBase*>::iterator endDOFIndexed() {
       return dofIndexedList.end();
-    };
+    }
 
     // ===== getting methods ======================================================
 
@@ -172,38 +172,39 @@ namespace AMDiS {
      */
     inline const int getUsedSize() const { 
       return sizeUsed; 
-    };
+    }
 
     /** \brief 
      * Returns \ref size
      */
     inline const int getSize() const { 
       return size; 
-    };
+    }
 
     /** \brief 
      * Returns \ref usedCount
      */
     inline const int getUsedDOFs() const { 
       return usedCount; 
-    };
+    }
 
     /** \brief 
      * Returns \ref holeCount
      */
     inline const int getHoleCount() const { 
       return holeCount; 
-    };
+    }
 
     /** \brief 
      * Returns \ref name
      */
     inline const std::string& getName() const { 
       return name; 
-    };
+    }
 
     /** \brief 
-     * Returns \ref nrDOF[i]
+     * Returns \ref nrDOF[i], i.e., the number of dofs for the
+     * position i.
      */
     inline const int getNumberOfDOFs(int i) const {
       return nrDOF[i];
@@ -214,7 +215,7 @@ namespace AMDiS {
      */
     inline const DimVec<int>& getNumberOfDOFs() const { 
       return nrDOF; 
-    };
+    }
  
     /** \brief
      * Returns \ref nr0DOF[i]
@@ -228,28 +229,28 @@ namespace AMDiS {
      */
     inline const DimVec<int>& getNumberOfPreDOFs() const { 
       return nr0DOF; 
-    };
+    }
 
     /** \brief
      * Returns \ref mesh 
      */
     inline const Mesh* getMesh() const { 
       return mesh; 
-    };
+    }
 
     /** \brief
      * Returns \ref dofFree, the array denoting DOFs to be either free or used.
      */
     inline const std::vector<bool>& getDOFFree() const { 
       return dofFree; 
-    };
+    }
 
     /** \brief
      * Returns if the given DOF is free.
      */
     inline const bool isDOFFree(int i) const {
       return dofFree[i];
-    };
+    }
 
     /** \} */
 
@@ -262,7 +263,7 @@ namespace AMDiS {
     /** \brief
      * Sets \ref nrDOF[i] = v
      */
-    void setNumberOfDOFs(int i,int v); 
+    void setNumberOfDOFs(int i, int v); 
 
     /** \brief
      * Sets \ref nr0DOF[i] = v
@@ -274,14 +275,14 @@ namespace AMDiS {
      */
     inline void setName(const std::string& n) { 
       name = n; 
-    };
+    }
 
     /** \brief
      * Sets \ref mesh = m
      */
     inline void setMesh(Mesh* m) { 
       mesh = m; 
-    };
+    }
 
     /** \} */
 
@@ -350,7 +351,8 @@ namespace AMDiS {
     int sizeUsed;
 
     /** \brief
-     * dofs from THIS DOFAdmin
+     * Number of dofs for each position, i.e., vertex, 
+     * edge, ..., center, for this DOFAdmin.
      */
     DimVec<int> nrDOF;
 

AMDiS/src/Element.cc

@@ -64,6 +64,72 @@ namespace AMDiS {
     }
   }
 
+  Element* Element::cloneWithDOFs()
+  {
+    Element *el;
+
+    if (isLine()) {
+      el = NEW Line(mesh);
+    } else if (isTriangle()) {
+      el = NEW Triangle(mesh);
+    } else {
+      el = NEW Tetrahedron(mesh);
+    }
+    el->index = index;
+    el->mark = mark;
+    if (newCoord) {
+      WorldVector<double> *nc = NEW WorldVector<double>();
+      *nc = *newCoord;
+      el->newCoord = nc;
+    }
+
+    /* =========== And here we clone the DOFs =========== */
+
+    el->dof = GET_MEMORY(DegreeOfFreedom*, mesh->getNumberOfNodes());
+
+    int dim = mesh->getDim();
+    int j = 0;
+
+    for (int pos = 0; pos <= dim; pos++) {
+      GeoIndex position = INDEX_OF_DIM(pos, dim);
+      int ndof = 0;
+
+      for (int i = 0; i < mesh->getNumberOfDOFAdmin(); i++) {
+	ndof += mesh->getDOFAdmin(i).getNumberOfDOFs(position);
+      }
+
+      if (ndof > 0) {
+	for (int i = 0; i < mesh->getGeo(position); i++) {
+	  if (dof[j] != NULL) {
+	    if (Mesh::serializedDOFs[dof[j][0]] == NULL) {
+	      el->dof[j] = GET_MEMORY(DegreeOfFreedom, ndof);
+	      for (int k = 0; k < ndof; k++) {
+		el->dof[j][k] = dof[j][k];
+	      }
+	      Mesh::serializedDOFs[dof[j][0]] = el->dof[j];
+	    } else {
+	      el->dof[j] = Mesh::serializedDOFs[dof[j][0]];
+	    }
+	  } else {
+	    el->dof[j] = NULL;
+	  }
+	  j++;
+	}
+      }
+    }
+
+    /* =========== And clone the children ============= */
+
+    if (child[0]) {
+      el->child[0] = child[0]->clone();
+    }
+    if (child[1]) {
+      el->child[1] = child[1]->clone();
+    }
+
+    return el;
+  }
+
   /****************************************************************************/
   /*  ATTENTION:                                                              */
   /*  new_dof_fct() destroys new_dof !!!!!!!!!!                               */
@@ -92,9 +158,8 @@ namespace AMDiS {
 
   void Element::newDOFFct1(const DOFAdmin* admin)
   {
-    int     i, j, k, n0, nd, nd0;
-    DegreeOfFreedom     *ldof;
-  
+    int j, k, n0, nd, nd0;
+    DegreeOfFreedom *ldof;  
     int vertices = mesh->getGeo(VERTEX);
     int edges = mesh->getGeo(EDGE); 
     int faces = mesh->getGeo(FACE);
@@ -102,7 +167,7 @@ namespace AMDiS {
     if ((nd = admin->getNumberOfDOFs(VERTEX)))  {
       nd0 = admin->getNumberOfPreDOFs(VERTEX);
       n0 = admin->getMesh()->getNode(VERTEX);
-      for (i = 0; i < vertices; i++) {
+      for (int i = 0; i < vertices; i++) {
 	CHANGE_DOFS_1(this);
       }
     }
@@ -111,7 +176,7 @@ namespace AMDiS {
       if ((nd = admin->getNumberOfDOFs(EDGE)))  {
 	nd0 = admin->getNumberOfPreDOFs(EDGE);
 	n0 = admin->getMesh()->getNode(EDGE);
-	for (i = 0; i < edges; i++) {
+	for (int i = 0; i < edges; i++) {
 	  CHANGE_DOFS_1(this);
 	}
       }
@@ -121,7 +186,7 @@ namespace AMDiS {
       if ((nd = admin->getNumberOfDOFs(FACE)))  {
 	nd0 = admin->getNumberOfPreDOFs(FACE);
 	n0 = admin->getMesh()->getNode(FACE);
-	for (i = 0; i < faces; i++) {
+	for (int i = 0; i < faces; i++) {
 	  CHANGE_DOFS_1(this);
 	}
       }
@@ -130,7 +195,7 @@ namespace AMDiS {
     if ((nd = admin->getNumberOfDOFs(CENTER)))  {
       nd0 = admin->getNumberOfPreDOFs(CENTER);
       n0 = admin->getMesh()->getNode(CENTER);
-      i = 0;          /* only one center */
+      int i = 0;          /* only one center */
       CHANGE_DOFS_1(this);
     }
   }
@@ -138,9 +203,8 @@ namespace AMDiS {
 
   void Element::newDOFFct2(const DOFAdmin* admin)
   {
-    int     i, j, k, n0, nd, nd0;
-    DegreeOfFreedom     *ldof;
-   
+    int i, j, k, n0, nd, nd0;
+    DegreeOfFreedom  *ldof;
     int vertices = mesh->getGeo(VERTEX);
     int edges = mesh->getGeo(EDGE); 
     int faces = mesh->getGeo(FACE);
@@ -191,13 +255,13 @@ namespace AMDiS {
 
   int Element::oppVertex(FixVec<DegreeOfFreedom*, DIMEN> pdof) const
   {
-    int nv = 0, ov = 0;
-
+    int nv = 0;
+    int ov = 0;
     int vertices = mesh->getGeo(VERTEX);
     int dim = mesh->getDim();
 
     for (int i = 0; i < vertices; i++) {
-      if (nv < i-1)  
+      if (nv < i - 1)  
 	return(-1);
 
       for (int j = 0; j < dim; j++) {
@@ -225,10 +289,10 @@ namespace AMDiS {
       return ov;
       break;
     case 2:
-      return 3-ov;
+      return 3 - ov;
       break;
     case 3:
-      return 6-ov;
+      return 6 - ov;
       break;
     default:
       ERROR_EXIT("invalid dim\n");
@@ -237,19 +301,19 @@ namespace AMDiS {
   }
 
   double Element::getNewCoord(int j) const {
-    if (j >=0 ) {
+    if (j >= 0) {
       TEST_EXIT_DBG(newCoord)("newCoord = NULL\n");
       return (*newCoord)[j];
     } else { 
-      return (newCoord!=NULL);
+      return (newCoord != NULL);
     }
   }
 
   void Element::eraseNewCoord() {
-    if (newCoord!=NULL) {
+    if (newCoord != NULL) {
       DELETE newCoord;
-      newCoord=NULL;
-    };
+      newCoord = NULL;
+    }
   }
  
   void Element::serialize(std::ostream &out) 
@@ -270,13 +334,11 @@ namespace AMDiS {
     out.write(reinterpret_cast<const char*>(&nodes), sizeof(int));
    
     for (int pos = 0; pos <= dim; pos++) {
-      GeoIndex position = INDEX_OF_DIM(pos ,dim);
+      GeoIndex position = INDEX_OF_DIM(pos, dim);
       int ndof = 0;
 
       for (int i = 0; i < mesh->getNumberOfDOFAdmin(); i++) {
-	const DOFAdmin *localAdmin = &mesh->getDOFAdmin(i);
-	TEST_EXIT_DBG(localAdmin)("no admin[%d]\n", i);
-	ndof += localAdmin->getNumberOfDOFs(position);	
+	ndof += mesh->getDOFAdmin(i).getNumberOfDOFs(position);	
       }
 
       if (ndof > 0) {
@@ -285,8 +347,7 @@ namespace AMDiS {
 	    if (Mesh::serializedDOFs[dof[j][0]] == NULL) {
 	      Mesh::serializedDOFs[dof[j][0]] = dof[j];
 	      out.write(reinterpret_cast<const char*>(&ndof), sizeof(int));
-	      out.write(reinterpret_cast<const char*>(dof[j]), 
-			ndof * sizeof(DegreeOfFreedom));
+	      out.write(reinterpret_cast<const char*>(dof[j]), ndof * sizeof(DegreeOfFreedom));
 	    } else {
 	      int minusOne = -1;
 	      out.write(reinterpret_cast<const char*>(&minusOne), sizeof(int));
@@ -334,17 +395,17 @@ namespace AMDiS {
 
     if (typeName != "NULL") {
       if (typeName == "Line") {
-	child[0] = new Line(NULL);
-	child[1] = new Line(NULL);      
-      };
+	child[0] = NEW Line(NULL);
+	child[1] = NEW Line(NULL);      
+      }
       if (typeName == "Triangle") {
-	child[0] = new Triangle(NULL);
-	child[1] = new Triangle(NULL);      
-      };
+	child[0] = NEW Triangle(NULL);
+	child[1] = NEW Triangle(NULL);      
+      }
       if (typeName == "Tetrahedron") {
-	child[0] = new Tetrahedron(NULL);
-	child[1] = new Tetrahedron(NULL);      
-      };
+	child[0] = NEW Tetrahedron(NULL);
+	child[1] = NEW Tetrahedron(NULL);      
+      }
       child[0]->deserialize(in);
       child[1]->deserialize(in);
     } else {
@@ -357,22 +418,21 @@ namespace AMDiS {
 
     dof = GET_MEMORY(DegreeOfFreedom*, nodes); 
 
-    int i;
-    for(i = 0; i < nodes; i++) {
+    for (int i = 0; i < nodes; i++) {
       int dofs;
       in.read(reinterpret_cast<char*>(&dofs), sizeof(int));
 
-      if(dofs) {
-	if(dofs != -1) {
+      if (dofs) {
+	if (dofs != -1) {
 	  dof[i] = GET_MEMORY(DegreeOfFreedom, dofs);
 	  in.read(reinterpret_cast<char*>(dof[i]), dofs * sizeof(DegreeOfFreedom));
-	  if(Mesh::serializedDOFs[dof[i][0]] != NULL) {
-	    //WARNING("christina -> dofs already deserialized\n");
+	  if (Mesh::serializedDOFs[dof[i][0]] != NULL) {
 	    DegreeOfFreedom *dofPtr = Mesh::serializedDOFs[dof[i][0]];
 	    FREE_MEMORY(dof[i], DegreeOfFreedom, dofs);
 	    dof[i] = dofPtr;
+	  } else {
+	    Mesh::serializedDOFs[dof[i][0]] = dof[i];
 	  }
-	  Mesh::serializedDOFs[dof[i][0]] = dof[i];
 	} else {
 	  DegreeOfFreedom index;
 	  in.read(reinterpret_cast<char*>(&index), sizeof(DegreeOfFreedom));
@@ -393,8 +453,8 @@ namespace AMDiS {
     in >> typeName;
     in.get();
 
-    if(typeName != "NULL") {
-      if(typeName == "WorldVector") {
+    if (typeName != "NULL") {
+      if (typeName == "WorldVector") {
 	newCoord = NEW WorldVector<double>;