Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/Inciter/DG.hpp
4 : : \copyright 2012-2015 J. Bakosi,
5 : : 2016-2018 Los Alamos National Security, LLC.,
6 : : 2019-2021 Triad National Security, LLC.
7 : : All rights reserved. See the LICENSE file for details.
8 : : \brief DG advances a system of PDEs with the discontinuous Galerkin scheme
9 : : \details DG advances a system of partial differential equations (PDEs) using
10 : : discontinuous Galerkin (DG) finite element (FE) spatial discretization (on
11 : : tetrahedron elements) combined with Runge-Kutta (RK) time stepping.
12 : :
13 : : There are a potentially large number of DG Charm++ chares created by
14 : : Transporter. Each DG gets a chunk of the full load (part of the mesh)
15 : : and does the same: initializes and advances a number of PDE systems in time.
16 : :
17 : : The implementation uses the Charm++ runtime system and is fully
18 : : asynchronous, overlapping computation and communication. The algorithm
19 : : utilizes the structured dagger (SDAG) Charm++ functionality. The high-level
20 : : overview of the algorithm structure and how it interfaces with Charm++ is
21 : : discussed in the Charm++ interface file src/Inciter/dg.ci.
22 : : */
23 : : // *****************************************************************************
24 : : #ifndef DG_h
25 : : #define DG_h
26 : :
27 : : #include <array>
28 : : #include <set>
29 : : #include <unordered_set>
30 : : #include <unordered_map>
31 : :
32 : : #include "DerivedData.hpp"
33 : : #include "FaceData.hpp"
34 : : #include "ElemDiagnostics.hpp"
35 : :
36 : : #include "NoWarning/dg.decl.h"
37 : :
38 : : namespace inciter {
39 : :
40 : : //! DG Charm++ chare array used to advance PDEs in time with DG+RK
41 : : class DG : public CBase_DG {
42 : :
43 : : public:
44 : : #if defined(__clang__)
45 : : #pragma clang diagnostic push
46 : : #pragma clang diagnostic ignored "-Wunused-parameter"
47 : : #pragma clang diagnostic ignored "-Wdeprecated-declarations"
48 : : #elif defined(STRICT_GNUC)
49 : : #pragma GCC diagnostic push
50 : : #pragma GCC diagnostic ignored "-Wunused-parameter"
51 : : #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
52 : : #elif defined(__INTEL_COMPILER)
53 : : #pragma warning( push )
54 : : #pragma warning( disable: 1478 )
55 : : #endif
56 : : // Include Charm++ SDAG code. See http://charm.cs.illinois.edu/manuals/html/
57 : : // charm++/manual.html, Sec. "Structured Control Flow: Structured Dagger".
58 : : DG_SDAG_CODE
59 : : #if defined(__clang__)
60 : : #pragma clang diagnostic pop
61 : : #elif defined(STRICT_GNUC)
62 : : #pragma GCC diagnostic pop
63 : : #elif defined(__INTEL_COMPILER)
64 : : #pragma warning( pop )
65 : : #endif
66 : :
67 : : //! Constructor
68 : : explicit DG( const CProxy_Discretization& disc,
69 : : const std::map< int, std::vector< std::size_t > >& bface,
70 : : const std::map< int, std::vector< std::size_t > >& /* bnode */,
71 : : const std::vector< std::size_t >& triinpoel );
72 : :
73 : : #if defined(__clang__)
74 : : #pragma clang diagnostic push
75 : : #pragma clang diagnostic ignored "-Wundefined-func-template"
76 : : #endif
77 : : //! Migrate constructor
78 : : // cppcheck-suppress uninitMemberVar
79 : 10828 : explicit DG( CkMigrateMessage* msg ) : CBase_DG( msg ) {}
80 : : #if defined(__clang__)
81 : : #pragma clang diagnostic pop
82 : : #endif
83 : :
84 : : //! Return from migration
85 : : void ResumeFromSync() override;
86 : :
87 : : //! Start sizing communication buffers and setting up ghost data
88 : : void resizeComm();
89 : :
90 : : //! Receive unique set of faces we potentially share with/from another chare
91 : : void comfac( int fromch, const tk::UnsMesh::FaceSet& infaces );
92 : :
93 : : //! Receive ghost data on chare boundaries from fellow chare
94 : : void comGhost( int fromch, const GhostData& ghost );
95 : :
96 : : //! Receive requests for ghost data
97 : : void reqGhost();
98 : :
99 : : //! Send all of our ghost data to fellow chares
100 : : void sendGhost();
101 : :
102 : : //! Setup node-neighborhood (esup)
103 : : void nodeNeighSetup();
104 : :
105 : : //! Receive element-surr-points data on chare boundaries from fellow chare
106 : : void comEsup( int fromch,
107 : : const std::unordered_map< std::size_t, std::vector< std::size_t > >&
108 : : bndEsup,
109 : : const std::unordered_map< std::size_t, std::vector< tk::real > >&
110 : : nodeBndCells );
111 : :
112 : : //! Configure Charm++ reduction types for concatenating BC nodelists
113 : : static void registerReducers();
114 : :
115 : : //! Setup: query boundary conditions, output mesh, etc.
116 : : void setup();
117 : :
118 : : //! Receive total box IC volume and set conditions in box
119 : : void box( tk::real v );
120 : :
121 : : // Evaluate whether to do load balancing
122 : : void evalLB( int nrestart );
123 : :
124 : : //! Start time stepping
125 : : void start();
126 : :
127 : : //! Continue to next time step
128 : : void next();
129 : :
130 : : //! Receive chare-boundary limiter function data from neighboring chares
131 : : void comlim( int fromch,
132 : : const std::vector< std::size_t >& tetid,
133 : : const std::vector< std::vector< tk::real > >& u,
134 : : const std::vector< std::vector< tk::real > >& prim,
135 : : const std::vector< std::size_t >& ndof );
136 : :
137 : : //! Receive chare-boundary reconstructed data from neighboring chares
138 : : void comreco( int fromch,
139 : : const std::vector< std::size_t >& tetid,
140 : : const std::vector< std::vector< tk::real > >& u,
141 : : const std::vector< std::vector< tk::real > >& prim,
142 : : const std::vector< std::size_t >& ndof );
143 : :
144 : : //! Receive chare-boundary ghost data from neighboring chares
145 : : void comsol( int fromch,
146 : : std::size_t fromstage,
147 : : const std::vector< std::size_t >& tetid,
148 : : const std::vector< std::vector< tk::real > >& u,
149 : : const std::vector< std::vector< tk::real > >& prim,
150 : : const std::vector< std::size_t >& ndof );
151 : :
152 : : //! Receive contributions to nodal gradients on chare-boundaries
153 : : void
154 : : comnodalExtrema( const std::vector< std::size_t >& gid,
155 : : const std::vector< std::vector< tk::real > >& G1,
156 : : const std::vector< std::vector< tk::real > >& G2 );
157 : :
158 : : //! Initialize the vector of nodal extrema
159 : : void resizeNodalExtremac();
160 : :
161 : : //! Compute the nodal extrema for chare-boundary nodes
162 : : void evalNodalExtrm( const std::size_t ncomp,
163 : : const std::size_t nprim,
164 : : const std::size_t ndof_NodalExtrm,
165 : : const std::vector< std::size_t >& bndel,
166 : : const std::vector< std::size_t >& inpoel,
167 : : const tk::UnsMesh::Coords& coord,
168 : : const std::vector< std::size_t >& gid,
169 : : const std::unordered_map< std::size_t, std::size_t >&
170 : : bid,
171 : : const tk::Fields& U,
172 : : const tk::Fields& P,
173 : : std::vector< std::vector<tk::real> >& uNodalExtrm,
174 : : std::vector< std::vector<tk::real> >& pNodalExtrm );
175 : :
176 : : //! \brief Receive nodal solution (ofor field output) contributions from
177 : : //! neighboring chares
178 : : void comnodeout( const std::vector< std::size_t >& gid,
179 : : const std::vector< std::size_t >& nesup,
180 : : const std::vector< std::vector< tk::real > >& L );
181 : :
182 : : //! Optionally refine/derefine mesh
183 : : void refine( const std::vector< tk::real >& l2res );
184 : :
185 : : //! Receive new mesh from Refiner
186 : : void resizePostAMR(
187 : : const std::vector< std::size_t >& /* ginpoel */,
188 : : const tk::UnsMesh::Chunk& chunk,
189 : : const tk::UnsMesh::Coords& coord,
190 : : const std::unordered_map< std::size_t, tk::UnsMesh::Edge >& /* addedNodes */,
191 : : const std::unordered_map< std::size_t, std::size_t >& addedTets,
192 : : const std::set< std::size_t >& /*removedNodes*/,
193 : : const tk::NodeCommMap& nodeCommMap,
194 : : const std::map< int, std::vector< std::size_t > >& bface,
195 : : const std::map< int, std::vector< std::size_t > >& /* bnode */,
196 : : const std::vector< std::size_t >& triinpoel );
197 : :
198 : : //! Extract field output going to file
199 : : void extractFieldOutput(
200 : : const std::vector< std::size_t >& /* ginpoel */,
201 : : const tk::UnsMesh::Chunk& chunk,
202 : : const tk::UnsMesh::Coords& coord,
203 : : const std::unordered_map< std::size_t, tk::UnsMesh::Edge >& /* addedNodes */,
204 : : const std::unordered_map< std::size_t, std::size_t >& addedTets,
205 : : const tk::NodeCommMap& nodeCommMap,
206 : : const std::map< int, std::vector< std::size_t > >& bface,
207 : : const std::map< int, std::vector< std::size_t > >& /* bnode */,
208 : : const std::vector< std::size_t >& triinpoel,
209 : : CkCallback c );
210 : :
211 : : //! Const-ref access to current solution
212 : : //! \return Const-ref to current solution
213 : : const tk::Fields& solution() const { return m_u; }
214 : :
215 : : //! Compute left hand side
216 : : void lhs();
217 : :
218 : : //! Unused in DG
219 : : void resized() {}
220 : :
221 : : //! Compute right hand side and solve system
222 : : void solve( tk::real newdt );
223 : :
224 : : //! Evaluate whether to continue with next time step
225 : : void step();
226 : :
227 : : /** @name Charm++ pack/unpack serializer member functions */
228 : : ///@{
229 : : //! \brief Pack/Unpack serialize member function
230 : : //! \param[in,out] p Charm++'s PUP::er serializer object reference
231 : 16242 : void pup( PUP::er &p ) override {
232 : : p | m_disc;
233 : 16242 : p | m_ndof_NodalExtrm;
234 : 16242 : p | m_ncomfac;
235 : 16242 : p | m_nadj;
236 : 16242 : p | m_ncomEsup;
237 : 16242 : p | m_nsol;
238 : 16242 : p | m_ninitsol;
239 : 16242 : p | m_nlim;
240 : 16242 : p | m_nnod;
241 : 16242 : p | m_nreco;
242 : 16242 : p | m_nnodalExtrema;
243 : 16242 : p | m_inpoel;
244 : : p | m_coord;
245 : : p | m_fd;
246 : 16242 : p | m_u;
247 : 16242 : p | m_un;
248 : 16242 : p | m_p;
249 : 16242 : p | m_geoFace;
250 : 16242 : p | m_geoElem;
251 : 16242 : p | m_lhs;
252 : 16242 : p | m_uNodalExtrm;
253 : 16242 : p | m_pNodalExtrm;
254 : 16242 : p | m_uNodalExtrmc;
255 : 16242 : p | m_pNodalExtrmc;
256 : 16242 : p | m_rhs;
257 : 16242 : p | m_nfac;
258 : 16242 : p | m_nunk;
259 : 16242 : p | m_npoin;
260 : 16242 : p | m_ipface;
261 : 16242 : p | m_bndFace;
262 : 16242 : p | m_ghostData;
263 : 16242 : p | m_sendGhost;
264 : 16242 : p | m_ghostReq;
265 : 16242 : p | m_ghost;
266 : 16242 : p | m_exptGhost;
267 : 16242 : p | m_recvGhost;
268 : : p | m_diag;
269 : 16242 : p | m_stage;
270 : 16242 : p | m_ndof;
271 : 16242 : p | m_numEqDof;
272 : 16242 : p | m_bid;
273 : : p | m_uc;
274 : : p | m_pc;
275 : : p | m_ndofc;
276 : : p | m_initial;
277 : 16242 : p | m_expChBndFace;
278 : 16242 : p | m_infaces;
279 : 16242 : p | m_esup;
280 : 16242 : p | m_esupc;
281 : 16242 : p | m_elemfields;
282 : 16242 : p | m_nodefields;
283 : 16242 : p | m_nodefieldsc;
284 : 16242 : p | m_outmesh;
285 : 16242 : p | m_boxelems;
286 : 16242 : p | m_shockmarker;
287 : 16242 : }
288 : : //! \brief Pack/Unpack serialize operator|
289 : : //! \param[in,out] p Charm++'s PUP::er serializer object reference
290 : : //! \param[in,out] i DG object reference
291 : : friend void operator|( PUP::er& p, DG& i ) { i.pup(p); }
292 : : //@}
293 : :
294 : : private:
295 : : //! Local face & tet IDs associated to 3 global node IDs
296 : : //! \details This map stores tetrahedron cell faces (map key) and their
297 : : //! associated local face ID and inner local tet id adjacent to the face
298 : : //! (map value). A face is given by 3 global node IDs.
299 : : using FaceMap =
300 : : std::unordered_map< tk::UnsMesh::Face, // 3 global node IDs
301 : : std::array< std::size_t, 2 >, // local face & tet ID
302 : : tk::UnsMesh::Hash<3>,
303 : : tk::UnsMesh::Eq<3> >;
304 : :
305 : : //! Storage type for refined mesh used for field output
306 : : struct OutMesh {
307 : : //! Element connectivity, local->global node ids, global->local nodes ids
308 : : tk::UnsMesh::Chunk chunk;
309 : : //! Node coordinates
310 : : tk::UnsMesh::Coords coord;
311 : : //! Triangle element connectivity
312 : : std::vector< std::size_t > triinpoel;
313 : : //! Boundary-face connectivity
314 : : std::map< int, std::vector< std::size_t > > bface;
315 : : //! Node communinaction map
316 : : tk::NodeCommMap nodeCommMap;
317 : : //! \brief Pack/Unpack serialize member function
318 : : //! \param[in,out] p Charm++'s PUP::er serializer object reference
319 : 16242 : void pup( PUP::er& p ) {
320 : 32484 : p|chunk; p|coord; p|triinpoel; p|bface; p|nodeCommMap;
321 : 16242 : }
322 : : //! Destroyer
323 [ + + ]: 25778 : void destroy() {
324 : : tk::destroy( std::get<0>(chunk) );
325 : : tk::destroy( std::get<1>(chunk) );
326 : 25778 : tk::destroy( std::get<2>(chunk) );
327 : : tk::destroy( coord[0] );
328 : : tk::destroy( coord[1] );
329 : : tk::destroy( coord[2] );
330 : : tk::destroy( triinpoel );
331 : 25778 : tk::destroy( bface );
332 : 25778 : tk::destroy( nodeCommMap );
333 : 25778 : }
334 : : };
335 : :
336 : : //! Discretization proxy
337 : : CProxy_Discretization m_disc;
338 : : //! \brief Degree of freedom for nodal extrema vector. When DGP1 is applied,
339 : : //! there is one degree of freedom for cell average variable. When DGP2 is
340 : : //! applied, the degree of freedom is 4 which refers to cell average and
341 : : //! gradients in three directions
342 : : std::size_t m_ndof_NodalExtrm;
343 : : //! Counter for face adjacency communication map
344 : : std::size_t m_ncomfac;
345 : : //! Counter signaling that all ghost data have been received
346 : : std::size_t m_nadj;
347 : : //! Counter for element-surr-node adjacency communication map
348 : : std::size_t m_ncomEsup;
349 : : //! Counter signaling that we have received all our solution ghost data
350 : : std::size_t m_nsol;
351 : : //! \brief Counter signaling that we have received all our solution ghost
352 : : //! data during setup
353 : : std::size_t m_ninitsol;
354 : : //! \brief Counter signaling that we have received all our limiter function
355 : : //! ghost data
356 : : std::size_t m_nlim;
357 : : //! \brief Counter signaling that we have received all our node solution
358 : : //! contributions
359 : : std::size_t m_nnod;
360 : : //! Counter signaling that we have received all our reconstructed ghost data
361 : : std::size_t m_nreco;
362 : : //! \brief Counter signaling that we have received all our nodal extrema from
363 : : //! ghost chare partitions
364 : : std::size_t m_nnodalExtrema;
365 : : //! Mesh connectivity extended
366 : : std::vector< std::size_t > m_inpoel;
367 : : //! Node coordinates extended
368 : : tk::UnsMesh::Coords m_coord;
369 : : //! Face data
370 : : FaceData m_fd;
371 : : //! Vector of unknown/solution average over each mesh element
372 : : tk::Fields m_u;
373 : : //! Vector of unknown at previous time-step
374 : : tk::Fields m_un;
375 : : //! Vector of primitive quantities over each mesh element
376 : : tk::Fields m_p;
377 : : //! Face geometry
378 : : tk::Fields m_geoFace;
379 : : //! Element geometry
380 : : tk::Fields m_geoElem;
381 : : //! Left-hand side mass-matrix which is a diagonal matrix
382 : : tk::Fields m_lhs;
383 : : //! Vector of right-hand side
384 : : tk::Fields m_rhs;
385 : : //! Vector of nodal extrema for conservative variables
386 : : std::vector< std::vector<tk::real> > m_uNodalExtrm;
387 : : //! Vector of nodal extrema for primitive variables
388 : : std::vector< std::vector<tk::real> > m_pNodalExtrm;
389 : : //! Buffer for vector of nodal extrema for conservative variables
390 : : std::unordered_map< std::size_t, std::vector< tk::real > > m_uNodalExtrmc;
391 : : //! Buffer for vector of nodal extrema for primitive variables
392 : : std::unordered_map< std::size_t, std::vector< tk::real > > m_pNodalExtrmc;
393 : : //! Counter for number of faces on this chare (including chare boundaries)
394 : : std::size_t m_nfac;
395 : : //! Counter for number of unknowns on this chare (including ghosts)
396 : : std::size_t m_nunk;
397 : : //! Counter for number of nodes on this chare excluding ghosts
398 : : std::size_t m_npoin;
399 : : //! Internal + physical boundary faces (inverse of inpofa)
400 : : tk::UnsMesh::FaceSet m_ipface;
401 : : //! Face & tet IDs associated to global node IDs of the face for each chare
402 : : //! \details This map stores not only the unique faces associated to
403 : : //! fellow chares, but also a newly assigned local face ID and adjacent
404 : : //! local tet ID.
405 : : std::unordered_map< int, FaceMap > m_bndFace;
406 : : //! Ghost data associated to chare IDs we communicate with
407 : : std::unordered_map< int, GhostData > m_ghostData;
408 : : //! Elements which are ghosts for other chares associated to those chare IDs
409 : : std::unordered_map< int, std::unordered_set< std::size_t > > m_sendGhost;
410 : : //! Number of chares requesting ghost data
411 : : std::size_t m_ghostReq;
412 : : //! Local element id associated to ghost remote id charewise
413 : : //! \details This map associates the local element id (inner map value) to
414 : : //! the (remote) element id of the ghost (inner map key) based on the
415 : : //! chare id (outer map key) this remote element lies in.
416 : : std::unordered_map< int,
417 : : std::unordered_map< std::size_t, std::size_t > > m_ghost;
418 : : //! Expected ghost tet ids (used only in DEBUG)
419 : : std::set< std::size_t > m_exptGhost;
420 : : //! Received ghost tet ids (used only in DEBUG)
421 : : std::set< std::size_t > m_recvGhost;
422 : : //! Diagnostics object
423 : : ElemDiagnostics m_diag;
424 : : //! Runge-Kutta stage counter
425 : : std::size_t m_stage;
426 : : //! Vector of local number of degrees of freedom for each element
427 : : std::vector< std::size_t > m_ndof;
428 : : //! Vector of number of degrees of freedom for each PDE equation/component
429 : : std::vector< std::size_t > m_numEqDof;
430 : : //! Map local ghost tet ids (value) and zero-based boundary ids (key)
431 : : std::unordered_map< std::size_t, std::size_t > m_bid;
432 : : //! Solution receive buffers for ghosts only
433 : : std::array< std::vector< std::vector< tk::real > >, 3 > m_uc;
434 : : //! Primitive-variable receive buffers for ghosts only
435 : : std::array< std::vector< std::vector< tk::real > >, 3 > m_pc;
436 : : //! \brief Number of degrees of freedom (for p-adaptive) receive buffers
437 : : //! for ghosts only
438 : : std::array< std::vector< std::size_t >, 3 > m_ndofc;
439 : : //! 1 if starting time stepping, 0 if during time stepping
440 : : std::size_t m_initial;
441 : : //! Unique set of chare-boundary faces this chare is expected to receive
442 : : tk::UnsMesh::FaceSet m_expChBndFace;
443 : : //! Incoming communication buffer during chare-boundary face communication
444 : : std::unordered_map< int, tk::UnsMesh::FaceSet > m_infaces;
445 : : //! Elements (value) surrounding point (key) data-structure
446 : : std::map< std::size_t, std::vector< std::size_t > > m_esup;
447 : : //! Communication buffer for esup data-structure
448 : : std::map< std::size_t, std::vector< std::size_t > > m_esupc;
449 : : //! Elem output fields
450 : : std::vector< std::vector< tk::real > > m_elemfields;
451 : : //! Node output fields
452 : : std::vector< std::vector< tk::real > > m_nodefields;
453 : : //! Receive buffer for communication of node output fields
454 : : //! \details Key: global node id, value: output fields and number of
455 : : //! elements surrounding the node
456 : : std::unordered_map< std::size_t, std::pair< std::vector< tk::real >,
457 : : std::size_t > > m_nodefieldsc;
458 : : //! Storage for refined mesh used for field output
459 : : OutMesh m_outmesh;
460 : : //! Element ids at which box ICs are defined by user (multiple boxes)
461 : : std::vector< std::unordered_set< std::size_t > > m_boxelems;
462 : : //! Shock detection marker for field output
463 : : std::vector< std::size_t > m_shockmarker;
464 : :
465 : : //! Access bound Discretization class pointer
466 : 2002800 : Discretization* Disc() const {
467 : : Assert( m_disc[ thisIndex ].ckLocal() != nullptr, "ckLocal() null" );
468 : 4005600 : return m_disc[ thisIndex ].ckLocal();
469 : : }
470 : :
471 : : //! Compute partial boundary surface integral and sum across all chares
472 : : void bndIntegral();
473 : :
474 : : //! Compute chare-boundary faces
475 : : void bndFaces();
476 : :
477 : : //! Perform leak test on chare-boundary faces
478 : : bool leakyAdjacency();
479 : :
480 : : //! Check if esuf of chare-boundary faces matches
481 : : bool faceMatch();
482 : :
483 : : //! Verify that all chare-boundary faces have been received
484 : : bool receivedChBndFaces();
485 : :
486 : : //! Check if entries in inpoel, inpofa and node-triplet are consistent
487 : : std::size_t
488 : : nodetripletMatch( const std::array< std::size_t, 2 >& id,
489 : : const tk::UnsMesh::Face& t );
490 : :
491 : : //! Find any chare for face (given by 3 global node IDs)
492 : : int findchare( const tk::UnsMesh::Face& t );
493 : :
494 : : //! Setup own ghost data on this chare
495 : : void setupGhost();
496 : :
497 : : //! Continue after face adjacency communication map completed on this chare
498 : : void faceAdj();
499 : :
500 : : //! Continue after node adjacency communication map completed on this chare
501 : : void adj();
502 : :
503 : : //! Fill elements surrounding a face along chare boundary
504 : : void addEsuf( const std::array< std::size_t, 2 >& id, std::size_t ghostid );
505 : :
506 : : //! Fill elements surrounding a element along chare boundary
507 : : void addEsuel( const std::array< std::size_t, 2 >& id,
508 : : std::size_t ghostid,
509 : : const tk::UnsMesh::Face& t );
510 : :
511 : : void addEsup();
512 : :
513 : : //! Fill face geometry data along chare boundary
514 : : void addGeoFace( const tk::UnsMesh::Face& t,
515 : : const std::array< std::size_t, 2 >& id );
516 : :
517 : : //! Output mesh field data
518 : : void writeFields( CkCallback c );
519 : :
520 : : //! Compute solution reconstructions
521 : : void reco();
522 : :
523 : : //! Compute nodal extrema at chare-boundary nodes
524 : : void nodalExtrema();
525 : :
526 : : //! Compute limiter function
527 : : void lim();
528 : :
529 : : //! Compute time step size
530 : : void dt();
531 : :
532 : : //! Evaluate whether to continue with next time step stage
533 : : void stage();
534 : :
535 : : //! Evaluate whether to save checkpoint/restart
536 : : void evalRestart();
537 : :
538 : : //! p-refine all elements that are adjacent to p-refined elements
539 : : void propagate_ndof();
540 : :
541 : : //! Evaluate solution on incomping (a potentially refined) mesh
542 : : std::tuple< tk::Fields, tk::Fields, tk::Fields, tk::Fields >
543 : : evalSolution(
544 : : const std::vector< std::size_t >& inpoel,
545 : : const tk::UnsMesh::Coords& coord,
546 : : const std::unordered_map< std::size_t, std::size_t >& addedTets );
547 : :
548 : : //! Decide wether to output field data
549 : : bool fieldOutput() const;
550 : :
551 : : //! Decide if we write field output using a refined mesh
552 : : bool refinedOutput() const;
553 : :
554 : : //! Start preparing fields for output to file
555 : : void startFieldOutput( CkCallback c );
556 : : };
557 : :
558 : : } // inciter::
559 : :
560 : : #endif // DG_h
|
