Newer
Older
// ============================================================================
// == ==
// == AMDiS - Adaptive multidimensional simulations ==
// == ==
// ============================================================================
// == ==
// == TU Dresden ==
// == ==
// == Institut für Wissenschaftliches Rechnen ==
// == Zellescher Weg 12-14 ==
// == 01069 Dresden ==
// == germany ==
// == ==
// ============================================================================
// == ==
// == https://gforge.zih.tu-dresden.de/projects/amdis/ ==
// == ==
// ============================================================================
/** \file Debug.h */
#ifndef AMDIS_DEBUG_H
#define AMDIS_DEBUG_H
#include <set>
#include "AMDiS_fwd.h"
#include "Global.h"
namespace AMDiS {
namespace debug {

Thomas Witkowski
committed
struct DofPtrSortFct {
bool operator() (const DegreeOfFreedom *dof0, const DegreeOfFreedom *dof1)
{
return (*dof0 < *dof1);
}
};
typedef std::map<int, DofContainer> ElementIdxToDofs;
#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
void writeLocalElementDofs(int rank, int elIdx, FiniteElemSpace *feSpace);
void writeMesh(FiniteElemSpace *feSpace, int rank, std::string filename);
/** \brief
* Writes a vtu file with the mesh, where all DOFs are set to zero, and only
* one given DOF is set to one. This can be used to easily identify DOFs in
* a mesh.
*
* \param[in] rank If set to -1, the vtu files are written on all ranks.
* Otherwise, only on the given rank the mesh is written.
* \param[in] dof Defines the DOF, which value is set to one in the mesh file.
* \param[in] feSpace The FE space to be used.
*/
void writeDofMesh(int rank, DegreeOfFreedom dof, FiniteElemSpace *feSpace);
#endif
/** \brief
* Create a vtu file with name 'dofindex.vtu'. All nodes in the mesh are colored
* by the global dof index.
*
* \param[in] feSpace The FE space to be used.
*/
void writeDofIndexMesh(FiniteElemSpace *feSpace);
/** \brief
* Creates a vtu file where all elements in the mesh are colored by the global
* element indices.
*
* \param[in] feSpace The FE space to be used.
* \param[in] filename Name of the file.
*/

Thomas Witkowski
committed
void writeElementIndexMesh(Mesh *mesh, std::string filename);

Thomas Witkowski
committed
void highlightElementIndexMesh(Mesh *mesh, int idx, std::string filename);
void colorDofVectorByLocalElementDofs(DOFVector<double>& vec, Element *el);
bool colorDofVectorByLocalElementDofs(DOFVector<double>& vec,
Mesh *mesh,
int elIndex);
Element* getDofIndexElement(FiniteElemSpace *feSpace, DegreeOfFreedom dof);
Element* getLevel0ParentElement(Mesh *mesh, Element *el);
Element* getParentElement(Mesh *mesh, Element *el);
Element* getParentElement(Mesh *mesh, int elIndex);
void printElementInfo(Element *el);
void printInfoByDof(FiniteElemSpace *feSpace, DegreeOfFreedom dof);
void printMatValuesStatistics(Matrix<DOFMatrix*> *mat);
void printAllDofCoords(FiniteElemSpace *feSpace);
void getAllDofs(FiniteElemSpace *feSpace, std::set<const DegreeOfFreedom*>& dofs);
/** \brief
* Creates a text file storing the value of a sparse matrix. Each line of the file
* has three columns:
* row col value
* This file can be used in Matlab using the command "spconvert".
*
* \param[in] mat The matrix which is used the write the text file.
* \param[in] filename Name of the file to be created.
*/
void writeMatlabMatrix(DOFMatrix &mat, std::string filename);
/** \brief
* Creates a text file storing the value of a sparse matrix. Each line of the file
* has three columns:
* row col value
* This file can be used in Matlab using the command "spconvert". The function
* works only for a matrix of DOFMatrices, that are all defined from the same
* FE spaces.
*
* \param[in] mat The matrix which is used the write the text file.
* \param[in] filename Name of the file to be created.
*/
void writeMatlabMatrix(Matrix<DOFMatrix*> &mat, std::string filename);
/** \brief
*
*/
void writeMatlabVector(DOFVector<double> &vec, std::string filename);

Thomas Witkowski
committed
void writeMatlabVector(SystemVector &vec, std::string filename);
void writeCoordsFile(const FiniteElemSpace *feSpace, std::string filename);
void printElementHierarchie(Mesh *mesh, int elIndex);

Thomas Witkowski
committed
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/** \brief
* Traverse a mesh and store for each element all its vertex DOFs in local sorted
* order (by values).
*
* \param[in] mesh Mesh to be traversed.
* \param[out] elMap Stores to each element the vertex DOFs in sorted order.
*/
void createSortedDofs(Mesh *mesh, ElementIdxToDofs &elMap);
/** \brief
* Takes a map from element indices to lists of DOFs. Checks, if for each element
* in the mesh the vertex value order is still valid.
*
* The element index map must be created by the function \createSortedDofs. Using
* both functions it can be checked if a renumbering of dofs does not changes the
* local vertex value order (which is required by AMDiS to be always equal on each
* element).
*
* If the test fails, the function prints some debug information to screen and
* terminates the programm.
*
* \param[in] mesh Mesh to be traversed.
* \param[in] elMap Map from element indices to lists of DOFs. It is used to check
* the validaty as described above.
*/
void testSortedDofs(Mesh *mesh, ElementIdxToDofs &elMap);
/// Takes tree dofs and returns a list with the dofs sorted by their values.
void sortDofs(const DegreeOfFreedom* dof0,
const DegreeOfFreedom* dof1,
const DegreeOfFreedom* dof2,
DofContainer &vec);
/// Takes four dofs and returns a list with the dofs sorted by their values.
void sortDofs(const DegreeOfFreedom* dof0,
const DegreeOfFreedom* dof1,
const DegreeOfFreedom* dof2,
const DegreeOfFreedom* dof3,
DofContainer &vec);
}
}
#endif