Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/Inciter/Discretization.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 : : \details Data and functionality common to all discretization schemes
9 : : The Discretization class contains data and functionality common to all
10 : : discretization schemes.
11 : : */
12 : : // *****************************************************************************
13 : : #ifndef Discretization_h
14 : : #define Discretization_h
15 : :
16 : : #include <brigand/algorithms/for_each.hpp>
17 : :
18 : : #include "Types.hpp"
19 : : #include "Timer.hpp"
20 : : #include "Keywords.hpp"
21 : : #include "Fields.hpp"
22 : : #include "PUPUtil.hpp"
23 : : #include "PDFReducer.hpp"
24 : : #include "UnsMesh.hpp"
25 : : #include "CommMap.hpp"
26 : : #include "History.hpp"
27 : : #include "Inciter/InputDeck/InputDeck.hpp"
28 : :
29 : : #include "NoWarning/discretization.decl.h"
30 : : #include "NoWarning/refiner.decl.h"
31 : :
32 : : namespace inciter {
33 : :
34 : : extern ctr::InputDeck g_inputdeck;
35 : :
36 : : //! \brief Discretization Charm++ chare array holding common functinoality to
37 : : //! all discretization schemes
38 : : class Discretization : public CBase_Discretization {
39 : :
40 : : public:
41 : : #if defined(__clang__)
42 : : #pragma clang diagnostic push
43 : : #pragma clang diagnostic ignored "-Wunused-parameter"
44 : : #pragma clang diagnostic ignored "-Wdeprecated-declarations"
45 : : #elif defined(STRICT_GNUC)
46 : : #pragma GCC diagnostic push
47 : : #pragma GCC diagnostic ignored "-Wunused-parameter"
48 : : #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
49 : : #elif defined(__INTEL_COMPILER)
50 : : #pragma warning( push )
51 : : #pragma warning( disable: 1478 )
52 : : #endif
53 : : // Include Charm++ SDAG code. See http://charm.cs.illinois.edu/manuals/html/
54 : : // charm++/manual.html, Sec. "Structured Control Flow: Structured Dagger".
55 : : Discretization_SDAG_CODE
56 : : #if defined(__clang__)
57 : : #pragma clang diagnostic pop
58 : : #elif defined(STRICT_GNUC)
59 : : #pragma GCC diagnostic pop
60 : : #elif defined(__INTEL_COMPILER)
61 : : #pragma warning( pop )
62 : : #endif
63 : :
64 : : //! Constructor
65 : : explicit
66 : : Discretization(
67 : : std::size_t meshid,
68 : : const std::vector< CProxy_Discretization >& disc,
69 : : const CProxy_DistFCT& fctproxy,
70 : : const CProxy_ALE& aleproxy,
71 : : const tk::CProxy_ConjugateGradients& conjugategradientsproxy,
72 : : const CProxy_Transporter& transporter,
73 : : const tk::CProxy_MeshWriter& meshwriter,
74 : : const tk::UnsMesh::CoordMap& coordmap,
75 : : const tk::UnsMesh::Chunk& el,
76 : : const tk::CommMaps& msum,
77 : : int nc );
78 : :
79 : : #if defined(__clang__)
80 : : #pragma clang diagnostic push
81 : : #pragma clang diagnostic ignored "-Wundefined-func-template"
82 : : #endif
83 : : //! Migrate constructor
84 : : // cppcheck-suppress uninitMemberVar
85 : 17914 : explicit Discretization( CkMigrateMessage* ) {}
86 : : #if defined(__clang__)
87 : : #pragma clang diagnostic pop
88 : : #endif
89 : :
90 : : //! Configure Charm++ reduction types
91 : : static void registerReducers();
92 : :
93 : : //! Start computing new mesh veloctity for ALE mesh motion
94 : : void meshvelStart(
95 : : const tk::UnsMesh::Coords vel,
96 : : const std::vector< tk::real >& soundspeed,
97 : : const std::unordered_map< int,
98 : : std::unordered_map< std::size_t, std::array< tk::real, 4 > > >& bnorm,
99 : : tk::real adt,
100 : : CkCallback done ) const;
101 : :
102 : : //! Query the mesh velocity
103 : : const tk::Fields& meshvel() const;
104 : :
105 : : //! \brief Query ALE mesh velocity boundary condition node lists and node
106 : : //! lists at which ALE moves boundaries
107 : : void meshvelBnd(
108 : : const std::map< int, std::vector< std::size_t > >& bface,
109 : : const std::map< int, std::vector< std::size_t > >& bnode,
110 : : const std::vector< std::size_t >& triinpoel ) const;
111 : :
112 : : //! Assess and record mesh velocity linear solver convergence
113 : : void meshvelConv();
114 : :
115 : : //! \brief Our mesh has been registered with the mesh-to-mesh transfer
116 : : //! library (if coupled to other solver)
117 : : void transferInit();
118 : :
119 : : //! Receive a list of callbacks from our own child solver
120 : : void transferCallback( std::vector< CkCallback >& cb );
121 : :
122 : : //! Receive mesh transfer callbacks from source mesh/solver
123 : : void comcb( std::size_t srcmeshid, CkCallback c );
124 : :
125 : : //! Start solution transfer (if coupled)
126 : : void transfer( const tk::Fields& u );
127 : :
128 : : //! Resize mesh data structures after mesh refinement
129 : : void resizePostAMR( const tk::UnsMesh::Chunk& chunk,
130 : : const tk::UnsMesh::Coords& coord,
131 : : const tk::NodeCommMap& nodeCommMap );
132 : :
133 : : //! Get ready for (re-)computing/communicating nodal volumes
134 : : void startvol();
135 : :
136 : : //! Sum mesh volumes to nodes, start communicating them on chare-boundaries
137 : : void vol();
138 : :
139 : : //! Set Refiner Charm++ proxy
140 : : void setRefiner( const CProxy_Refiner& ref );
141 : :
142 : : //! Collect nodal volumes across chare boundaries
143 : : void comvol( const std::vector< std::size_t >& gid,
144 : : const std::vector< tk::real >& nodevol );
145 : :
146 : : //! Sum mesh volumes and contribute own mesh volume to total volume
147 : : void totalvol();
148 : :
149 : : //! Compute mesh cell statistics
150 : : void stat( tk::real mesh_volume );
151 : :
152 : : //! Compute total box IC volume
153 : : void
154 : : boxvol( const std::vector< std::unordered_set< std::size_t > >& nodes );
155 : :
156 : : /** @name Accessors */
157 : : ///@{
158 : : //! Coordinates accessor as const-ref
159 : 18283 : const tk::UnsMesh::Coords& Coord() const { return m_coord; }
160 : : //! Coordinates accessor as reference
161 [ + - ][ - - ]: 262328 : tk::UnsMesh::Coords& Coord() { return m_coord; }
162 : : //! Coordinates at time n accessor as const-ref
163 : : const tk::UnsMesh::Coords& Coordn() const { return m_coordn; }
164 : :
165 : : //! Global ids accessors as const-ref
166 : : const std::vector< std::size_t >& Gid() const { return m_gid; }
167 : :
168 : : //! Local ids accessors as const-ref
169 : : const std::unordered_map< std::size_t, std::size_t >& Lid() const
170 : : { return m_lid; }
171 : :
172 : : //! Tetrahedron element connectivity (with local ids) accessors as const-ref
173 : : const std::vector< std::size_t >& Inpoel() const { return m_inpoel; }
174 : :
175 : : //! Mesh chunk accessor as const-ref
176 [ + - ]: 2731 : const tk::UnsMesh::Chunk& Chunk() const { return m_el; }
177 : :
178 : : //! Total mesh volume accessor
179 : : tk::real meshvol() const { return m_meshvol; }
180 : :
181 : : //! Nodal mesh volume accessors const-ref
182 : : const std::vector< tk::real >& V() const { return m_v; }
183 : :
184 : : //! Nodal mesh volumes at current time step accessors as const-ref
185 [ + - ][ + - ]: 465473 : const std::vector< tk::real >& Vol() const { return m_vol; }
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
186 : : //! Nodal mesh volumes at previous time step accessors as const-ref
187 : : const std::vector< tk::real >& Voln() const { return m_voln; }
188 : : //! Nodal mesh volumes at previous time step accessors as ref
189 : 40930 : std::vector< tk::real >& Voln() { return m_voln; }
190 : : //! Element mesh volumes at t=t0 accessors as const-ref
191 : : const std::vector< tk::real >& Vol0() const { return m_vol0; }
192 : :
193 : : //! Set 'initial' flag
194 : : //! \param[in] i Value to put in 'initial'
195 : 534 : void Initial( std::size_t i ) { m_initial = i; }
196 : : //! Query 'initial' flag
197 : : //! \return True during setup, false durign time stepping
198 : : bool Initial() const { return m_initial; }
199 : :
200 : : //! Update coordinates at time n
201 : : void UpdateCoordn() { m_coordn = m_coord; }
202 : :
203 : : //! History points data accessor as const-ref
204 [ + - ]: 898 : const std::vector< HistData >& Hist() const { return m_histdata; }
205 : :
206 : : //! Box volume accessor
207 : : tk::real& Boxvol() { return m_boxvol; }
208 : :
209 : : //! Mesh ID accessor
210 : : std::size_t MeshId() const { return m_meshid; }
211 : :
212 : : //! Time step size accessor
213 : : tk::real Dt() const { return m_dt; }
214 : : //! Time step size at previous time step accessor
215 : : tk::real Dtn() const { return m_dtn; }
216 : : //! Physical time accessor
217 : : tk::real T() const { return m_t; }
218 : : //! Iteration count accessor
219 : : uint64_t It() const { return m_it; }
220 : :
221 : : //! Non-const-ref refinement iteration count accessor
222 : : uint64_t& Itr() { return m_itr; }
223 : : //! Non-const-ref field-output iteration count accessor
224 : : uint64_t& Itf() { return m_itf; }
225 : :
226 : : //! Non-const-ref number of restarts accessor
227 : : int& Nrestart() { return m_nrestart; }
228 : :
229 : : //! Timer accessor as const-ref
230 : : const tk::Timer& Timer() const { return m_timer; }
231 : : //! Timer accessor as non-const-ref
232 : 2106 : tk::Timer& Timer() { return m_timer; }
233 : :
234 : : //! Accessor to flag indicating if the mesh was refined as a value
235 : : int refined() const { return m_refined; }
236 : : //! Accessor to flag indicating if the mesh was refined as non-const-ref
237 : : int& refined() { return m_refined; }
238 : :
239 : : //! Transporter proxy accessor as const-ref
240 : : const CProxy_Transporter& Tr() const { return m_transporter; }
241 : : //! Transporter proxy accessor as non-const-ref
242 [ - - ]: 0 : CProxy_Transporter& Tr() { return m_transporter; }
243 : :
244 : : //! Access bound Refiner class pointer
245 : 2450 : Refiner* Ref() const {
246 : : Assert( m_refiner[ thisIndex ].ckLocal() != nullptr,
247 : : "Refiner ckLocal() null" );
248 : 4900 : return m_refiner[ thisIndex ].ckLocal();
249 : : }
250 : :
251 : : //! Access bound DistFCT class pointer
252 : 75488 : DistFCT* FCT() const {
253 : : Assert(m_fct[ thisIndex ].ckLocal() != nullptr, "DistFCT ckLocal() null");
254 : 150976 : return m_fct[ thisIndex ].ckLocal();
255 : : }
256 : :
257 : : //! Access Discretization proxy for a mesh
258 : : CProxy_Discretization coupled( std::size_t meshid ) const {
259 : : Assert( meshid < m_disc.size(),
260 : : "No proxy for mesh ID " + std::to_string(meshid) );
261 : : return m_disc[ meshid ];
262 : : }
263 : :
264 : : //! Const-ref accessor to solver/mesh transfer configuration
265 : : const std::vector< Transfer >& Transfers() const { return m_transfer; }
266 : :
267 : : //! Boundary node ids accessor as const-ref
268 : : const std::unordered_map< std::size_t, std::size_t >& Bid() const
269 : 138448 : { return m_bid; }
270 : :
271 : : //! Node communication map accessor as const-ref
272 [ + - ]: 2731 : const tk::NodeCommMap& NodeCommMap() const { return m_nodeCommMap; }
273 : :
274 : : //! Edge communication map accessor as const-ref
275 : : const tk::EdgeCommMap& EdgeCommMap() const { return m_edgeCommMap; }
276 : : //@}
277 : :
278 : : //! Set time step size
279 : : void setdt( tk::real newdt );
280 : :
281 : : //! Prepare for next step
282 : : void next();
283 : :
284 : : //! Otput one-liner status report
285 : : void status();
286 : :
287 : : //! Construct history output filename
288 : : std::string histfilename( const std::string& id,
289 : : kw::precision::info::expect::type precision );
290 : :
291 : : //! Output headers for time history files (one for each point)
292 : : void histheader( std::vector< std::string >&& names );
293 : :
294 : : //! Output time history for a time step
295 : : void history( std::vector< std::vector< tk::real > >&& data );
296 : :
297 : : //! Output mesh and fields data (solution dump) to file(s)
298 : : void write( const std::vector< std::size_t >& inpoel,
299 : : const tk::UnsMesh::Coords& coord,
300 : : const std::map< int, std::vector< std::size_t > >& bface,
301 : : const std::map< int, std::vector< std::size_t > >& bnode,
302 : : const std::vector< std::size_t >& triinpoel,
303 : : const std::vector< std::string>& elemfieldnames,
304 : : const std::vector< std::string>& nodefieldnames,
305 : : const std::vector< std::string>& nodesurfnames,
306 : : const std::vector< std::vector< tk::real > >& elemfields,
307 : : const std::vector< std::vector< tk::real > >& nodefields,
308 : : const std::vector< std::vector< tk::real > >& nodesurfs,
309 : : CkCallback c );
310 : :
311 : : //! Zero grind-timer
312 : : void grindZero();
313 : :
314 : : //! Detect if just returned from a checkpoint and if so, zero timers
315 : : bool restarted( int nrestart );
316 : :
317 : : //! Remap mesh data due to new local ids
318 : : void remap( const std::unordered_map< std::size_t, std::size_t >& map );
319 : :
320 : : //! \brief Function object for querying the node ids that belong to side
321 : : //! sets of the same type, called for each PDE type
322 : : template< typename... tags >
323 : : struct SidesetNodes {
324 : :
325 : : const std::map< int, std::vector< std::size_t > >& m_bface;
326 : : const std::vector< std::size_t >& m_triinpoel;
327 : : std::unordered_map< int, std::unordered_set< std::size_t > >& m_nodes;
328 : :
329 : : explicit
330 : : SidesetNodes( const std::map< int, std::vector< std::size_t > >& bface,
331 : : const std::vector< std::size_t >& triinpoel,
332 : : std::unordered_map< int,
333 : : std::unordered_set< std::size_t > >& nodes )
334 : : : m_bface(bface), m_triinpoel(triinpoel), m_nodes(nodes) {}
335 : :
336 : 443592 : template< typename Eq > void operator()( brigand::type_<Eq> ) {
337 : : const auto& ss =
338 : : g_inputdeck.template get< tag::param, Eq, tags... >();
339 [ + + ]: 464032 : for (const auto& eq : ss) {
340 [ + + ]: 60702 : for (const auto& s : eq) {
341 [ + - ]: 40262 : auto k = m_bface.find( std::stoi(s) );
342 [ + + ]: 40262 : if (k != end(m_bface)) {
343 [ + - ]: 30452 : auto& n = m_nodes[ k->first ]; // associate set id
344 [ + + ]: 5680984 : for (auto f : k->second) { // face ids on side set
345 [ + - ]: 5650532 : n.insert( m_triinpoel[f*3+0] );
346 [ + - ]: 5650532 : n.insert( m_triinpoel[f*3+1] );
347 [ + - ]: 5650532 : n.insert( m_triinpoel[f*3+2] );
348 : : }
349 : : }
350 : : }
351 : : }
352 : 443592 : }
353 : : };
354 : :
355 : : //! \brief Query nodes that belong to side sets of the same type for all
356 : : //! PDE types
357 : : //! \tparam tags Tags addressing the location of a vector of vectors of
358 : : //! side set ids in the input deck
359 : : //! \param[in] bface Boundary-faces mapped to side set ids
360 : : //! \param[in] triinpoel Boundary-face connectivity
361 : : //! \return Node ids that belong side sets of the same type (value),
362 : : //! associated to sides set id (key)
363 : : template< typename... tags >
364 : : std::unordered_map< int, std::unordered_set< std::size_t > >
365 : : bcnodes( const std::map< int, std::vector< std::size_t > >& bface,
366 : : const std::vector< std::size_t >& triinpoel ) const
367 : : {
368 : : using PDETypes = ctr::parameters::Keys;
369 : : std::unordered_map< int, std::unordered_set< std::size_t > > nodes;
370 : : brigand::for_each< PDETypes >(
371 : : SidesetNodes< tags... >( bface, triinpoel, nodes ) );
372 : : return nodes;
373 : : }
374 : :
375 : : //! Find elements along our mesh chunk boundary
376 : : std::vector< std::size_t > bndel() const;
377 : :
378 : : //! Decide if field output iteration count interval is hit
379 : : bool fielditer() const;
380 : :
381 : : //! Decide if field output physics time interval is hit
382 : : bool fieldtime() const;
383 : :
384 : : //! Decide if physics time falls into a field output time range
385 : : bool fieldrange() const;
386 : :
387 : : //! Decide if history output iteration count interval is hit
388 : : bool histiter() const;
389 : :
390 : : //! Decide if history output physics time interval is hit
391 : : bool histtime() const;
392 : :
393 : : //! Decide if physics time falls into a history output time range
394 : : bool histrange() const;
395 : :
396 : : //! Decide if this is the last time step
397 : : bool finished() const;
398 : :
399 : : /** @name Charm++ pack/unpack serializer member functions */
400 : : ///@{
401 : : //! \brief Pack/Unpack serialize member function
402 : : //! \param[in,out] p Charm++'s PUP::er serializer object reference
403 : 26871 : void pup( PUP::er &p ) override {
404 : 26871 : p | m_meshid;
405 : 26871 : p | m_transfer_complete;
406 : 26871 : p | m_transfer;
407 : 26871 : p | m_mytransfer;
408 : 26871 : p | m_disc;
409 : 26871 : p | m_nchare;
410 : 26871 : p | m_it;
411 : 26871 : p | m_itr;
412 : 26871 : p | m_itf;
413 : 26871 : p | m_initial;
414 : 26871 : p | m_t;
415 : 26871 : p | m_lastDumpTime;
416 : 26871 : p | m_physFieldFloor;
417 : 26871 : p | m_physHistFloor;
418 : 26871 : p | m_rangeFieldFloor;
419 : 26871 : p | m_rangeHistFloor;
420 : 26871 : p | m_dt;
421 : 26871 : p | m_dtn;
422 : 26871 : p | m_nvol;
423 : : p | m_fct;
424 : : p | m_ale;
425 : : p | m_transporter;
426 : : p | m_meshwriter;
427 : : p | m_refiner;
428 : 26871 : p | m_el;
429 [ + + ]: 26871 : if (p.isUnpacking()) {
430 : 8957 : m_inpoel = std::get< 0 >( m_el );
431 : 8957 : m_gid = std::get< 1 >( m_el );
432 [ - + ]: 8957 : m_lid = std::get< 2 >( m_el );
433 : : }
434 : : p | m_coord;
435 : : p | m_coordn;
436 : : p | m_nodeCommMap;
437 : 26871 : p | m_edgeCommMap;
438 : 26871 : p | m_meshvol;
439 : 26871 : p | m_v;
440 : 26871 : p | m_vol;
441 : 26871 : p | m_volc;
442 : 26871 : p | m_voln;
443 : 26871 : p | m_vol0;
444 : 26871 : p | m_boxvol;
445 : 26871 : p | m_bid;
446 : : p | m_timer;
447 : 26871 : p | m_refined;
448 : 26871 : p( reinterpret_cast<char*>(&m_prevstatus), sizeof(Clock::time_point) );
449 : 26871 : p | m_nrestart;
450 : 26871 : p | m_histdata;
451 : 26871 : p | m_nsrc;
452 : 26871 : p | m_ndst;
453 : 26871 : p | m_meshvel;
454 : 26871 : p | m_meshvel_converged;
455 : 26871 : }
456 : : //! \brief Pack/Unpack serialize operator|
457 : : //! \param[in,out] p Charm++'s PUP::er serializer object reference
458 : : //! \param[in,out] i Discretization object reference
459 : : friend void operator|( PUP::er& p, Discretization& i ) { i.pup(p); }
460 : : //@}
461 : :
462 : : private:
463 : : // Shorthand for clock, setting an internal clock type
464 : : using Clock = std::chrono::high_resolution_clock;
465 : :
466 : : //! Mesh ID
467 : : std::size_t m_meshid;
468 : : //! Function to continue with if not coupled to any other solver
469 : : CkCallback m_transfer_complete;
470 : : //! Solution/mesh transfer (coupling) information
471 : : //! \details This has the same size with the same src/dst information on
472 : : //! all solvers.
473 : : std::vector< Transfer > m_transfer;
474 : : //! My solution transfer/mesh (coupling) information
475 : : //! \details This is a subset of m_transfer, holding only those entries
476 : : //! that this solver is involved in (either a source or a destination).
477 : : std::vector< Transfer > m_mytransfer;
478 : : //! Discretization proxies (one per mesh)
479 : : std::vector< CProxy_Discretization > m_disc;
480 : : //! Total number of Discretization chares
481 : : int m_nchare;
482 : : //! Iteration count
483 : : uint64_t m_it;
484 : : //! Iteration count with mesh refinement
485 : : //! \details Used as the restart sequence number {RS} in saving output in
486 : : //! an ExodusII sequence
487 : : //! \see https://www.paraview.org/Wiki/Restarted_Simulation_Readers
488 : : uint64_t m_itr;
489 : : //! Field output iteration count without mesh refinement
490 : : //! \details Counts the number of field outputs to file during two
491 : : //! time steps with mesh efinement
492 : : uint64_t m_itf;
493 : : //! Flag that is nonzero during setup and zero during time stepping
494 : : std::size_t m_initial;
495 : : //! Physical time
496 : : tk::real m_t;
497 : : //! Physics time at last field output
498 : : tk::real m_lastDumpTime;
499 : : //! Recent floor of physics time divided by field output interval time
500 : : tk::real m_physFieldFloor;
501 : : //! Recent floor of physics time divided by history output interval time
502 : : tk::real m_physHistFloor;
503 : : //! Recent floors of physics time divided by field output time for ranges
504 : : std::vector< tk::real > m_rangeFieldFloor;
505 : : //! Recent floors of physics time divided by history output time for ranges
506 : : std::vector< tk::real > m_rangeHistFloor;
507 : : //! Physical time step size
508 : : tk::real m_dt;
509 : : //! Physical time step size at the previous time step
510 : : tk::real m_dtn;
511 : : //! \brief Number of chares from which we received nodal volume
512 : : //! contributions on chare boundaries
513 : : std::size_t m_nvol;
514 : : //! Distributed FCT proxy
515 : : CProxy_DistFCT m_fct;
516 : : //! Distributed ALE proxy
517 : : CProxy_ALE m_ale;
518 : : //! Transporter proxy
519 : : CProxy_Transporter m_transporter;
520 : : //! Mesh writer proxy
521 : : tk::CProxy_MeshWriter m_meshwriter;
522 : : //! Mesh refiner proxy
523 : : CProxy_Refiner m_refiner;
524 : : //! \brief Elements of the mesh chunk we operate on
525 : : //! \details Initialized by the constructor. The first vector is the element
526 : : //! connectivity (local IDs), the second vector is the global node IDs of
527 : : //! owned elements, while the third one is a map of global->local node
528 : : //! IDs.
529 : : tk::UnsMesh::Chunk m_el;
530 : : //! Alias to element connectivity
531 : : std::vector< std::size_t >& m_inpoel = std::get<0>( m_el );
532 : : //! Alias to global node IDs of owned elements
533 : : std::vector< std::size_t >& m_gid = std::get<1>( m_el );
534 : : //! \brief Alias to local node ids associated to the global ones of owned
535 : : //! elements
536 : : std::unordered_map< std::size_t, std::size_t >& m_lid = std::get<2>( m_el );
537 : : //! Mesh point coordinates
538 : : tk::UnsMesh::Coords m_coord;
539 : : //! Mesh coordinates at the time n for ALE
540 : : tk::UnsMesh::Coords m_coordn;
541 : : //! \brief Global mesh node IDs bordering the mesh chunk held by fellow
542 : : //! Discretization chares associated to their chare IDs
543 : : tk::NodeCommMap m_nodeCommMap;
544 : : //! \brief Edges with global node IDs bordering the mesh chunk held by
545 : : //! fellow Discretization chares associated to their chare IDs
546 : : tk::EdgeCommMap m_edgeCommMap;
547 : : //! Total mesh volume
548 : : tk::real m_meshvol;
549 : : //! Nodal mesh volumes
550 : : //! \details This is the volume of the mesh associated to nodes of owned
551 : : //! elements (sum of surrounding cell volumes / 4) without contributions
552 : : //! from other chares on chare-boundaries
553 : : std::vector< tk::real > m_v;
554 : : //! Volume of nodes
555 : : //! \details This is the volume of the mesh associated to nodes of owned
556 : : //! elements (sum of surrounding cell volumes / 4) with contributions from
557 : : //! other chares on chare-boundaries
558 : : std::vector< tk::real > m_vol;
559 : : //! Receive buffer for volume of nodes (with global node id as key)
560 : : //! \details This is a communication buffer used to compute the volume of
561 : : //! the mesh associated to nodes of owned elements (sum of surrounding
562 : : //! cell volumes / 4) with contributions from other chares on
563 : : //! chare-boundaries.
564 : : std::unordered_map< std::size_t, tk::real > m_volc;
565 : : //! Volume of nodes at previous time step
566 : : //! \details This is the volume of the mesh associated to nodes of owned
567 : : //! elements (sum of surrounding cell volumes / 4) with contributions from
568 : : //! other chares on chare-boundaries at the previous time step stage
569 : : std::vector< tk::real > m_voln;
570 : : //! Mesh element volumes at t=t0
571 : : std::vector< tk::real > m_vol0;
572 : : //! Volume of user-defined box IC
573 : : tk::real m_boxvol;
574 : : //! \brief Local chare-boundary mesh node IDs at which we receive
575 : : //! contributions associated to global mesh node IDs of elements we
576 : : //! contribute to
577 : : std::unordered_map< std::size_t, std::size_t > m_bid;
578 : : //! Timer measuring a time step
579 : : tk::Timer m_timer;
580 : : //! 1 if mesh was refined in a time step, 0 if it was not
581 : : int m_refined;
582 : : //! Time point storing clock state at status()
583 : : Clock::time_point m_prevstatus;
584 : : //! Number of times restarted
585 : : int m_nrestart;
586 : : //! Data at history point locations
587 : : std::vector< HistData > m_histdata;
588 : : //! Number of transfers requested as a source
589 : : std::size_t m_nsrc;
590 : : //! Number of transfers requested as a destination
591 : : std::size_t m_ndst;
592 : : //! Mesh velocity if ALE is not enabled
593 : : tk::Fields m_meshvel;
594 : : //! \brief True if all stages of the time step converged the mesh velocity
595 : : //! linear solve in ALE
596 : : bool m_meshvel_converged;
597 : :
598 : : //! Generate {A,x,b} for Laplacian mesh velocity smoother
599 : : std::tuple< tk::CSR, std::vector< tk::real >, std::vector< tk::real > >
600 : : Laplacian( std::size_t ncomp ) const;
601 : :
602 : : //! Set mesh coordinates based on coordinates map
603 : : tk::UnsMesh::Coords setCoord( const tk::UnsMesh::CoordMap& coordmap );
604 : :
605 : : //! Determine if communication of mesh transfer callbacks is complete
606 : : bool transferCallbacksComplete() const;
607 : :
608 : : //! Finish setting up communication maps and solution transfer callbacks
609 : : void comfinal();
610 : : };
611 : :
612 : : } // inciter::
613 : :
614 : : #endif // Discretization_h
|
