libMesh
dof_object.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2017 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either
7 // version 2.1 of the License, or (at your option) any later version.
8 
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 // Lesser General Public License for more details.
13 
14 // You should have received a copy of the GNU Lesser General Public
15 // License along with this library; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 
18 
19 
20 // C++ includes
21 
22 // Local includes
23 #include "libmesh/dof_object.h"
24 
25 
26 namespace libMesh
27 {
28 
29 
30 
31 // ------------------------------------------------------------
32 // DofObject class static member -now initialized in header
36 
37 
38 
39 // ------------------------------------------------------------
40 // DofObject class members
41 // Copy Constructor
42 DofObject::DofObject (const DofObject & dof_obj) :
44 #ifdef LIBMESH_ENABLE_AMR
45  old_dof_object (libmesh_nullptr),
46 #endif
47 #ifdef LIBMESH_ENABLE_UNIQUE_ID
48  _unique_id (dof_obj._unique_id),
49 #endif
50  _id (dof_obj._id),
51  _processor_id (dof_obj._processor_id),
52  _idx_buf (dof_obj._idx_buf)
53 {
54  // DO NOT copy old_dof_object, because this isn't a *real* copy
55  // constructor, it's a "copy almost everything" constructor that
56  // is intended to be used solely for internal construction of
57  // old_dof_object, never for a true deep copy where the newly
58  // created object really matches the source object.
59  //
60  // if (dof_obj.old_dof_object)
61  // this->old_dof_object = new DofObject(*(dof_obj.old_dof_object));
62 
63  // Check that everything worked
64 #ifdef DEBUG
65 
66  libmesh_assert_equal_to (this->n_systems(), dof_obj.n_systems());
67 
68  for (unsigned int s=0; s<this->n_systems(); s++)
69  {
70  libmesh_assert_equal_to (this->n_vars(s), dof_obj.n_vars(s));
71  libmesh_assert_equal_to (this->n_var_groups(s), dof_obj.n_var_groups(s));
72 
73  for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
74  libmesh_assert_equal_to (this->n_vars(s,vg), dof_obj.n_vars(s,vg));
75 
76  for (unsigned int v=0; v<this->n_vars(s); v++)
77  {
78  libmesh_assert_equal_to (this->n_comp(s,v), dof_obj.n_comp(s,v));
79 
80  for (unsigned int c=0; c<this->n_comp(s,v); c++)
81  libmesh_assert_equal_to (this->dof_number(s,v,c), dof_obj.dof_number(s,v,c));
82  }
83  }
84 
85 #endif
86 }
87 
88 
89 // Deep-copying assignment operator
91 {
92  if (&dof_obj == this)
93  return *this;
94 
95 #ifdef LIBMESH_ENABLE_AMR
96  this->clear_old_dof_object();
97 
98  this->old_dof_object = new DofObject(*(dof_obj.old_dof_object));
99 #endif
100 
101  _id = dof_obj._id;
102 #ifdef LIBMESH_ENABLE_UNIQUE_ID
103  _unique_id = dof_obj._unique_id;
104 #endif
105  _processor_id = dof_obj._processor_id;
106  _idx_buf = dof_obj._idx_buf;
107 
108 
109  // Check that everything worked
110 #ifdef DEBUG
111 
112  libmesh_assert_equal_to (this->n_systems(), dof_obj.n_systems());
113 
114  for (unsigned int s=0; s<this->n_systems(); s++)
115  {
116  libmesh_assert_equal_to (this->n_vars(s), dof_obj.n_vars(s));
117  libmesh_assert_equal_to (this->n_var_groups(s), dof_obj.n_var_groups(s));
118 
119  for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
120  libmesh_assert_equal_to (this->n_vars(s,vg), dof_obj.n_vars(s,vg));
121 
122  for (unsigned int v=0; v<this->n_vars(s); v++)
123  {
124  libmesh_assert_equal_to (this->n_comp(s,v), dof_obj.n_comp(s,v));
125 
126  for (unsigned int c=0; c<this->n_comp(s,v); c++)
127  libmesh_assert_equal_to (this->dof_number(s,v,c), dof_obj.dof_number(s,v,c));
128  }
129  }
130 
131 #endif
132 
133  return *this;
134 }
135 
136 
137 
138 
139 
140 #ifdef LIBMESH_ENABLE_AMR
141 
143 {
144  delete this->old_dof_object;
146 }
147 
148 
149 
151 {
152  this->clear_old_dof_object();
153 
155 
156  // Make a new DofObject, assign a copy of \p this.
157  // Make sure the copy ctor for DofObject works!!
158  this->old_dof_object = new DofObject(*this);
159 }
160 
161 #endif
162 
163 
164 
165 void DofObject::set_n_systems (const unsigned int ns)
166 {
167  // Check for trivial return
168  if (ns == this->n_systems())
169  return;
170 
171  // Clear any existing data. This is safe to call
172  // even if we don't have any data.
173  this->clear_dofs();
174 
175  // Set the new number of systems
176  _idx_buf.resize(ns, ns);
177  _idx_buf[0] = ns;
178 
179 
180 #ifdef DEBUG
181 
182  // check that all systems now exist and that they have 0 size
183  libmesh_assert_equal_to (ns, this->n_systems());
184  for (unsigned int s=0; s<this->n_systems(); s++)
185  {
186  libmesh_assert_equal_to (this->n_vars(s), 0);
187  libmesh_assert_equal_to (this->n_var_groups(s), 0);
188  }
189 
190 #endif
191 }
192 
193 
194 
196 {
197  // quick return?
198  if (this->n_systems() == 0)
199  {
200  this->set_n_systems(1);
201  return;
202  }
203 
204  DofObject::index_buffer_t::iterator it = _idx_buf.begin();
205 
206  std::advance(it, this->n_systems());
207 
208  // this inserts the current vector size at the position for the new system - creating the
209  // entry we need for the new system indicating there are 0 variables.
210  _idx_buf.insert(it, cast_int<dof_id_type>(_idx_buf.size()));
211 
212  // cache this value before we screw it up!
213  const unsigned int ns_orig = this->n_systems();
214 
215  // increment the number of systems and the offsets for each of
216  // the systems including the new one we just added.
217  for (unsigned int i=0; i<ns_orig+1; i++)
218  _idx_buf[i]++;
219 
220  libmesh_assert_equal_to (this->n_systems(), (ns_orig+1));
221  libmesh_assert_equal_to (this->n_vars(ns_orig), 0);
222  libmesh_assert_equal_to (this->n_var_groups(ns_orig), 0);
223 }
224 
225 
226 
227 void DofObject::set_n_vars_per_group(const unsigned int s,
228  const std::vector<unsigned int> & nvpg)
229 {
230 
231  libmesh_assert_less (s, this->n_systems());
232 
233  // number of variable groups for this system - inferred
234  const unsigned int nvg = cast_int<unsigned int>(nvpg.size());
235 
236  // BSK - note that for compatibility with the previous implementation
237  // calling this method when (nvars == this->n_vars()) requires that
238  // we invalidate the DOF indices and set the number of components to 0.
239  // Note this was a bit of a surprise to me - there was no quick return in
240  // the old method, which caused removal and readdition of the DOF indices
241  // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
242  // implicitly becoming 0 regardless of any previous value.
243  // quick return?
244  if (nvg == this->n_var_groups(s))
245  {
246  for (unsigned int vg=0; vg<nvg; vg++)
247  {
248  this->set_n_comp_group(s,vg,0);
249  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
250  }
251  return;
252  }
253 
254  // since there is ample opportunity to screw up other systems, let us
255  // cache their current sizes and later assert that they are unchanged.
256 #ifdef DEBUG
257  DofObject::index_buffer_t old_system_sizes;
258  old_system_sizes.reserve(this->n_systems());
259 
260  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
261  old_system_sizes.push_back(this->n_var_groups(s_ctr));
262 #endif
263 
264  // remove current indices if we have some
265  if (this->n_var_groups(s) != 0)
266  {
267  const unsigned int old_nvg_s = this->n_var_groups(s);
268 
269  DofObject::index_buffer_t::iterator
270  it = _idx_buf.begin(),
271  end = _idx_buf.begin();
272 
273  std::advance(it, this->start_idx(s));
274  std::advance(end, this->end_idx(s));
275  _idx_buf.erase(it,end);
276 
277  for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
278  _idx_buf[ctr] -= 2*old_nvg_s;
279  }
280 
281  // better not have any now!
282  libmesh_assert_equal_to (this->n_var_groups(s), 0);
283 
284  // Make sure we didn't screw up any of our sizes!
285 #ifdef DEBUG
286  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
287  if (s_ctr != s)
288  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
289 #endif
290 
291  // OK, if the user requested 0 that is what we have
292  if (nvg == 0)
293  return;
294 
295  {
296  // array to hold new indices
297  DofObject::index_buffer_t var_idxs(2*nvg);
298  for (unsigned int vg=0; vg<nvg; vg++)
299  {
300  var_idxs[2*vg ] = ncv_magic*nvpg[vg] + 0;
301  var_idxs[2*vg + 1] = invalid_id - 1;
302  }
303 
304  DofObject::index_buffer_t::iterator it = _idx_buf.begin();
305  std::advance(it, this->end_idx(s));
306  _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());
307 
308  for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
309  _idx_buf[ctr] += 2*nvg;
310 
311  // resize _idx_buf to fit so no memory is wasted.
313  }
314 
315  libmesh_assert_equal_to (nvg, this->n_var_groups(s));
316 
317 #ifdef DEBUG
318 
319  // libMesh::out << " [ ";
320  // for (std::size_t i=0; i<_idx_buf.size(); i++)
321  // libMesh::out << _idx_buf[i] << " ";
322  // libMesh::out << "]\n";
323 
324  libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());
325 
326  for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
327  {
328  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
329  libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
330  }
331 
332  for (unsigned int v=0; v<this->n_vars(s); v++)
333  libmesh_assert_equal_to (this->n_comp(s,v), 0);
334 
335  // again, all other system sizes should be unchanged!
336  for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
337  if (s_ctr != s)
338  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
339 
340 #endif
341 }
342 
343 
344 
345 void DofObject::set_n_comp(const unsigned int s,
346  const unsigned int var,
347  const unsigned int ncomp)
348 {
349  libmesh_assert_less (s, this->n_systems());
350  libmesh_assert_less (var, this->n_vars(s));
351 
352  this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
353 }
354 
355 
356 
357 void DofObject::set_n_comp_group(const unsigned int s,
358  const unsigned int vg,
359  const unsigned int ncomp)
360 {
361  libmesh_assert_less (s, this->n_systems());
362  libmesh_assert_less (vg, this->n_var_groups(s));
363 
364  // Check for trivial return
365  if (ncomp == this->n_comp_group(s,vg)) return;
366 
367 #ifndef NDEBUG
368  if (ncomp >= ncv_magic)
369  {
370  const index_t ncvm = ncv_magic;
371  libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
372  << "ncomp = " \
373  << ncomp \
374  << ", ncv_magic = " \
375  << ncvm \
376  << "\nrecompile and try again!");
377  }
378 #endif
379 
380  const unsigned int
381  start_idx_sys = this->start_idx(s),
382  n_vars_group = this->n_vars(s,vg),
383  base_offset = start_idx_sys + 2*vg;
384 
385  libmesh_assert_less ((base_offset + 1), _idx_buf.size());
386 
387  // if (ncomp)
388  // libMesh::out << "s,vg,ncomp="
389  // << s << ","
390  // << vg << ","
391  // << ncomp << '\n';
392 
393  // set the number of components, maintaining the number
394  // of variables in the group
395  _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;
396 
397  // We use (invalid_id - 1) to signify no
398  // components for this object
399  _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;
400 
401  // this->debug_buffer();
402  // libMesh::out << "s,vg = " << s << "," << vg << '\n'
403  // << "base_offset=" << base_offset << '\n'
404  // << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
405  // << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
406  // << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
407  // << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';
408 
409  libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
410 }
411 
412 
413 
414 void DofObject::set_dof_number(const unsigned int s,
415  const unsigned int var,
416  const unsigned int comp,
417  const dof_id_type dn)
418 {
419  libmesh_assert_less (s, this->n_systems());
420  libmesh_assert_less (var, this->n_vars(s));
421  libmesh_assert_less (comp, this->n_comp(s,var));
422 
423  const unsigned int
424  vg = this->var_to_vg(s,var),
425 #ifndef NDEBUG
426  ncg = this->n_comp_group(s,vg),
427 #endif
428  vig = this->system_var_to_vg_var(s,vg,var),
429  start_idx_sys = this->start_idx(s);
430 
431  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
432 
433  dof_id_type & base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
434 
435  // We intend to change all dof numbers together or not at all
436  if (comp || vig)
437  libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
438  (dn == base_idx + vig*ncg + comp));
439 
440  // only explicitly store the base index for vig==0, comp==0
441  else
442  base_idx = dn;
443 
444  // #ifdef DEBUG
445  // libMesh::out << " [ ";
446  // for (std::size_t i=0; i<_idx_buf.size(); i++)
447  // libMesh::out << _idx_buf[i] << " ";
448  // libMesh::out << "]\n";
449  // #endif
450 
451  libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
452 }
453 
454 
455 
456 // FIXME: it'll be tricky getting this to work with 64-bit dof_id_type
458 {
459  return
460  cast_int<unsigned int> (
461 #ifdef LIBMESH_ENABLE_AMR
462  ((old_dof_object == libmesh_nullptr) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
463 #else
464  1 +
465 #endif
466  _idx_buf.size());
467 }
468 
469 
470 
471 // FIXME: it'll be tricky getting this to work with 64-bit dof_id_type
472 unsigned int
473 DofObject::unpackable_indexing_size(std::vector<largest_id_type>::const_iterator begin)
474 {
475 #ifdef LIBMESH_ENABLE_AMR
476  const bool has_old_dof_object = cast_int<bool>(*begin++);
477 
478  static const int dof_header_size = 2;
479 #else
480  static const bool has_old_dof_object = false;
481  static const int dof_header_size = 1;
482 #endif
483 
484  const largest_id_type this_indexing_size = *begin++;
485 
486  return cast_int<unsigned int>
487  (dof_header_size + this_indexing_size +
488  (has_old_dof_object ?
489  unpackable_indexing_size(begin+this_indexing_size) : 0));
490 }
491 
492 
493 // FIXME: it'll be tricky getting this to work with 64-bit dof_id_type
494 void DofObject::unpack_indexing(std::vector<largest_id_type>::const_iterator begin)
495 {
496  _idx_buf.clear();
497 
498 #ifdef LIBMESH_ENABLE_AMR
499  this->clear_old_dof_object();
500  const bool has_old_dof_object = cast_int<bool>(*begin++);
501 #endif
502 
503  const largest_id_type size = *begin++;
504  _idx_buf.reserve(size);
505  std::copy(begin, begin+size, back_inserter(_idx_buf));
506 
507  // Check as best we can for internal consistency now
508  libmesh_assert(_idx_buf.empty() ||
509  (_idx_buf[0] <= _idx_buf.size()));
510 #ifdef DEBUG
511  if (!_idx_buf.empty())
512  for (unsigned int i=1; i < _idx_buf[0]; ++i)
513  {
514  libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
515  libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
516  libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
517  }
518 #endif
519 
520 #ifdef LIBMESH_ENABLE_AMR
521  if (has_old_dof_object)
522  {
523  this->old_dof_object = new DofObject();
524  this->old_dof_object->unpack_indexing(begin+size);
525  }
526 #endif
527 }
528 
529 
530 // FIXME: it'll be tricky getting this to work with 64-bit dof_id_type
531 void
532 DofObject::pack_indexing(std::back_insert_iterator<std::vector<largest_id_type>> target) const
533 {
534 #ifdef LIBMESH_ENABLE_AMR
535  // We might need to pack old_dof_object too
536  *target++ = (old_dof_object == libmesh_nullptr) ? 0 : 1;
537 #endif
538 
539  *target++ = _idx_buf.size();
540  std::copy(_idx_buf.begin(), _idx_buf.end(), target);
541 
542 #ifdef LIBMESH_ENABLE_AMR
543  if (old_dof_object)
544  old_dof_object->pack_indexing(target);
545 #endif
546 }
547 
548 
549 
551 {
552  libMesh::out << " [ ";
553  for (std::size_t i=0; i<_idx_buf.size(); i++)
554  libMesh::out << _idx_buf[i] << " ";
555  libMesh::out << "]\n";
556 }
557 
558 
559 
561 {
562  libMesh::out << this->id() << " [ ";
563 
564  for (unsigned int s=0; s<this->n_systems(); s++)
565  {
566  libMesh::out << "s:" << s << " ";
567  for (unsigned int var=0; var<this->n_vars(s); var++)
568  {
569  libMesh::out << "v:" << var << " ";
570  for (unsigned int comp=0; comp<this->n_comp(s,var); comp++)
571  {
572  libMesh::out << "c:" << comp << " dof:" << this->dof_number(s,var,comp) << " ";
573  }
574  }
575  }
576 
577  libMesh::out << "]\n";
578 }
579 
580 
581 
582 } // namespace libMesh
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:793
void set_n_comp(const unsigned int s, const unsigned int var, const unsigned int ncomp)
Sets the number of components for Variable var of system s associated with this DofObject.
Definition: dof_object.C:345
void set_old_dof_object()
Sets the old_dof_object to a copy of this.
Definition: dof_object.C:150
void clear_dofs()
Clear the DofMap data structures and return to a pristine state.
Definition: dof_object.h:598
static unsigned int unpackable_indexing_size(std::vector< largest_id_type >::const_iterator begin)
If we have indices packed into an buffer for communications, how much of that buffer applies to this ...
Definition: dof_object.C:473
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:745
uint64_t largest_id_type
Definition: id_types.h:139
uint8_t processor_id_type
Definition: id_types.h:99
const class libmesh_nullptr_t libmesh_nullptr
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:810
dof_id_type _id
The id of the DofObject.
Definition: dof_object.h:419
unsigned int system_var_to_vg_var(const unsigned int s, const unsigned int vg, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:965
IterBase * end
Also have a polymorphic pointer to the end object, this prevents iterating past the end...
void print_dof_info() const
Print out info for debugging.
Definition: dof_object.C:560
The libMesh namespace provides an interface to certain functionality in the library.
libmesh_assert(j)
unsigned int end_idx(const unsigned int s) const
The ending index for system s.
Definition: dof_object.h:889
DofObject()
Constructor.
Definition: dof_object.h:522
dof_id_type index_t
DoF index information.
Definition: dof_object.h:483
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:413
void add_system()
Adds an additional system to the DofObject.
Definition: dof_object.C:195
void pack_indexing(std::back_insert_iterator< std::vector< largest_id_type >> target) const
A method for creating packed data from our index buffer - basically a copy with prepended size with o...
Definition: dof_object.C:532
DofObject & operator=(const DofObject &dof_obj)
Deep-copying assignment operator.
Definition: dof_object.C:90
static const unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:329
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:335
void set_dof_number(const unsigned int s, const unsigned int var, const unsigned int comp, const dof_id_type dn)
Sets the global degree of freedom number for variable var, component comp for system s associated wit...
Definition: dof_object.C:414
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:735
processor_id_type _processor_id
The local processor id.
Definition: libmesh.C:252
void clear_old_dof_object()
Sets the old_dof_object to libmesh_nullptr.
Definition: dof_object.C:142
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:324
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:878
This class implements reference counting.
std::vector< index_t > index_buffer_t
Definition: dof_object.h:484
void set_n_comp_group(const unsigned int s, const unsigned int vg, const unsigned int ncomp)
Sets the number of components for VariableGroup vg of system s associated with this DofObject...
Definition: dof_object.C:357
unsigned int packed_indexing_size() const
If we pack our indices into an buffer for communications, how many ints do we need?
Definition: dof_object.C:457
void set_n_systems(const unsigned int s)
Sets the number of systems for this DofObject.
Definition: dof_object.C:165
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:946
void set_n_vars_per_group(const unsigned int s, const std::vector< unsigned int > &nvpg)
Sets number of variables in each group associated with system s for this DofObject.
Definition: dof_object.C:227
DofObject * old_dof_object
This object on the last mesh.
Definition: dof_object.h:79
OStreamProxy out
void unpack_indexing(std::vector< largest_id_type >::const_iterator begin)
A method for creating our index buffer from packed data - basically with our current implementation w...
Definition: dof_object.C:494
The DofObject defines an abstract base class for objects that have degrees of freedom associated with...
Definition: dof_object.h:51
index_buffer_t _idx_buf
Definition: dof_object.h:485
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:780
dof_id_type id() const
Definition: dof_object.h:632
unsigned int n_systems() const
Definition: dof_object.h:726
void debug_buffer() const
Print our buffer for debugging.
Definition: dof_object.C:550
uint8_t unique_id_type
Definition: id_types.h:79
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:430
uint8_t dof_id_type
Definition: id_types.h:64
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:496