Debug.h 7.24 KB
Newer Older
1
2
3
4
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
5
// ==  http://www.amdis-fem.org                                              ==
6
7
// ==                                                                        ==
// ============================================================================
8
9
10
11
12
13
14
15
16
17
18
19
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.


20
21
22
23
24
25

/** \file Debug.h */

#ifndef AMDIS_DEBUG_H
#define AMDIS_DEBUG_H

26
#include <set>
27
28
29
30
31
32
#include "AMDiS_fwd.h"
#include "Global.h"

namespace AMDiS {
  
  namespace debug {
33
34
35
36
37
38
39
40
41
42

    struct DofPtrSortFct {
      bool operator() (const DegreeOfFreedom *dof0, const DegreeOfFreedom *dof1) 
      {
	return (*dof0 < *dof1);
      }
    };

    typedef std::map<int, DofContainer> ElementIdxToDofs;

43
44
45
46
47
#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
    void writeLocalElementDofs(int rank, int elIdx, FiniteElemSpace *feSpace);
    
    void writeMesh(FiniteElemSpace *feSpace, int rank, std::string filename);
    
48
49
50
51
52
53
54
55
56
57
    /** \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.
     */
58
59
    void writeDofMesh(int rank, DegreeOfFreedom dof, FiniteElemSpace *feSpace);
#endif
60
61
62

    /** \brief
     * Create a vtu file with name 'dofindex.vtu'. All nodes in the mesh are colored
63
     * by the global DOF index.
64
65
66
67
68
     *
     * \param[in]  feSpace  The FE space to be used.
     */
    void writeDofIndexMesh(FiniteElemSpace *feSpace);

69
70
71
72
73
    void colorEdgeInMesh(FiniteElemSpace *feSpace,
			 Element *el, 
			 int localEdgeNo, 
			 std::string filename);

74
75
76
77
78
79
    /** \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.
80
81
     * \param[in]  level     If level is -1, all leaf elements will be put to the
     *                       output file, otherwise the elements with the given level.
82
     */
83
    void writeElementIndexMesh(Mesh *mesh, std::string filename, int level = -1);
84

85
    void highlightElementIndexMesh(Mesh *mesh, int idx, std::string filename);
86

87
88
    void colorMeshByMacroIndex(Mesh *mesh, std::string filename);

89
90
91
92
93
94
95
96
97
    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);
98

99
100
    Element* getLevel0ParentElement(Mesh *mesh, int elIndex);

101
102
103
104
    Element* getParentElement(Mesh *mesh, Element *el);

    Element* getParentElement(Mesh *mesh, int elIndex);

Thomas Witkowski's avatar
Thomas Witkowski committed
105
106
    Element* getElement(Mesh *mesh, int elIndex);

107
    void printElementInfo(Element *el);
108
109

    void printElementCoords(const FiniteElemSpace *feSpace, Element *el);
110
111
    
    void printInfoByDof(FiniteElemSpace *feSpace, DegreeOfFreedom dof);
Thomas Witkowski's avatar
Thomas Witkowski committed
112
113

    void printMatValuesStatistics(Matrix<DOFMatrix*> *mat);
114

115
116
117
118
    void printAllDofCoords(FiniteElemSpace *feSpace);

    void getAllDofs(FiniteElemSpace *feSpace, std::set<const DegreeOfFreedom*>& dofs);

Thomas Witkowski's avatar
Thomas Witkowski committed
119
120
121
122
123
124
125
126
127
    /** \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.
     */
128
129
    void writeMatlabMatrix(DOFMatrix &mat, std::string filename);

Thomas Witkowski's avatar
Thomas Witkowski committed
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
    /** \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
     *
     */
146
    void writeMatlabVector(DOFVector<double> &vec, std::string filename);
147

148
149
    void writeMatlabVector(SystemVector &vec, std::string filename);

Thomas Witkowski's avatar
Thomas Witkowski committed
150
151
    void writeCoordsFile(const FiniteElemSpace *feSpace, std::string filename);

Thomas Witkowski's avatar
Thomas Witkowski committed
152
153
    void printElementHierarchie(Mesh *mesh, int elIndex);    

Thomas Witkowski's avatar
Thomas Witkowski committed
154
    void printElementRefinementSequence(Mesh *mesh, Element *el);
155

156
157
    int getLocalNeighbourIndex(Mesh *mesh, int elIndex, int neighIndex);

158
159
    void importDofVectorByCoords(DOFVector<double>* vec, std::string filename);

160
161
162
    void exportDofVectorByCoords(const DOFVector<double>* vec, 
				 std::string filename);

163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
    /** \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);    

203
204
205
    void testDofsByCoords(FiniteElemSpace *feSpace,
			  DofContainer &dofs0, DofContainer &dofs1);

206
207
208
209
  }
}

#endif