MAIA bb96820c
Multiphysics at AIA
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
maia::fc::collector::FcCellCollector< nDim > Class Template Reference

Class that represents FC cell collector. More...

#include <fccellcollector.h>

Inheritance diagram for maia::fc::collector::FcCellCollector< nDim >:
[legend]
Collaboration diagram for maia::fc::collector::FcCellCollector< nDim >:
[legend]

Public Types

template<class T >
using Invalid = typename maia::fc::collector::Invalid< T >
 

Public Member Functions

constexpr FcCellCollector ()=default
 Default c'tor does nothing. More...
 
MFloat & alpha (const MInt id)
 Accessor for alpha. More...
 
MFloat alpha (const MInt id) const
 Accessor for alpha (const version). More...
 
MFloat & poissonRatio (const MInt id)
 Accessor for poissonRatio. More...
 
MFloat poissonRatio (const MInt id) const
 Accessor for poissonRatio (const version). More...
 
MFloat & invJacobian (const MInt id)
 Accessor for inverse jacobian. More...
 
MFloat invJacobian (const MInt id) const
 Accessor for inverse jacobian (const version). More...
 
MInt & pRfnmnt (const MInt id)
 Accessor for pRfnmnt. More...
 
MInt pRfnmnt (const MInt id) const
 Accessor for pRfnmnt (const version). More...
 
MInt & maxSubCellLvl (const MInt id)
 Accessor for maxSubCellLvl. More...
 
MInt maxSubCellLvl (const MInt id) const
 Accessor for maxSubCellLvl (const version). More...
 
MInt & noNodesPerCell (const MInt id)
 Accessor for number of elements. More...
 
MInt noNodesPerCell (const MInt id) const
 Accessor for number of elements (const version). More...
 
MInt & bndId (const MInt id)
 Accessor for bndId. More...
 
MInt bndId (const MInt id) const
 Accessor for bndId (const version). More...
 
MInt & nodeIdsLoc (const MInt id, const MInt eid)
 Accessor for local nodeIds. More...
 
MInt nodeIdsLoc (const MInt id, const MInt eid) const
 Accessor for local nodeIds (const version). More...
 
MInt & nodeIdsGlob (const MInt id, const MInt eid)
 Accessor for global nodeIds. More...
 
MInt nodeIdsGlob (const MInt id, const MInt eid) const
 Accessor for global nodeIds (const version). More...
 
MFloat & elementDisplacements (const MInt id, const MInt eid)
 Accessor for element displacements. More...
 
MFloat elementDisplacements (const MInt id, const MInt eid) const
 Accessor for element displacements (const version). More...
 
MFloat & elementStrains (const MInt id, const MInt eid)
 Accessor for element strains, i.e., cell based strains. More...
 
MFloat elementStrains (const MInt id, const MInt eid) const
 Accessor for element strains, i.e., cell based strains (const version) More...
 
MFloat & nodalStrains (const MInt id, const MInt nid, const MInt eid)
 Accessor for nodal strains, i.e., node based strains. More...
 
MFloat nodalStrains (const MInt id, const MInt nid, const MInt eid) const
 Accessor for nodal strains, i.e., node based strains (const version) More...
 
MFloat & elementStresses (const MInt id, const MInt eid)
 Accessor for element stresses, i.e., cell based stresses. More...
 
MFloat elementStresses (const MInt id, const MInt eid) const
 Accessor for element stresses, i.e., cell based stresses (const version) More...
 
MFloat & nodalStresses (const MInt id, const MInt nid, const MInt eid)
 Accessor for nodal stresses, i.e., node based stresses. More...
 
MFloat nodalStresses (const MInt id, const MInt nid, const MInt eid) const
 Accessor for nodal stresses, i.e., node based stresses (const version) More...
 
MFloat & nodePosition (const MInt id, const MInt eid)
 Accessor for the node position. More...
 
MFloat nodePosition (const MInt id, const MInt eid) const
 Accessor for the node position (const version) More...
 
MFloat & deltaGamma (const MInt id, const MInt eid)
 Accessor for delta gamma, a factor in plasticity models. More...
 
MFloat deltaGamma (const MInt id, const MInt eid) const
 Accessor for delta gamma, a factor in plasticity models (const version) More...
 
MFloat & epsilonBarP (const MInt id, const MInt eid)
 Accessor for epsilon bar, a factor in plasticity models. More...
 
MFloat epsilonBarP (const MInt id, const MInt eid) const
 Accessor for epsilon bar, a factor in plasticity models (const version) More...
 
BitsetType::reference hasProperty (const MInt id, const FcCell p)
 Accessor for properties. More...
 
MBool hasProperty (const MInt id, const FcCell p) const
 Accessor for properties (const version). More...
 
void resetProperties (const MInt id)
 Reset all properties. More...
 
BitsetType & allProperties (const MInt id)
 Accessor for properties. More...
 
void setThermal (const MBool isThermal_)
 Allow setting whether to support thermal computations. More...
 
void setPlasticity (const MBool isPlastic_)
 Allow setting whether to support plastic computations. More...
 
void setMaxPRfnmnt (const MInt maxPRfnmnt_)
 Sets the number of strains. More...
 
constexpr MBool isThermal () const
 Return if simulation is thermal. More...
 
constexpr MBool isPlastic () const
 Return if simulation is plastic. More...
 
constexpr MBool isPRefined () const
 Return if simulation is p-refined. More...
 
constexpr MInt noVariables () const
 Return number of variables. More...
 
constexpr MInt noStrains () const
 Return number of strains. More...
 
constexpr MInt noStresses () const
 Return number of stresses. More...
 
constexpr MInt noNodes () const
 
constexpr MInt maxPRfnmnt () const
 Return max pRfnmnt. More...
 
- Public Member Functions inherited from maia::container::Container< FcCellCollector< nDim >, Invalid >
constexpr Container ()=default
 Default c'tor does nothing. More...
 
constexpr MInt capacity () const
 Return capacity (i.e., maximum number of nodes) More...
 
void reset (const MInt capacity)
 Reset tree, re-create data structures with given capacity, and set size to zero. More...
 
void resize (const MInt capacity)
 Resize the container capacity. More...
 
constexpr MInt size () const
 Return size (i.e., currently used number of nodes) More...
 
void size (const MInt size_)
 Resize tree WITHOUT CONSIDERING ANY NODE CONSISTENCY! Use at own risk and remove ASAP... More...
 
void append (const MInt count)
 Append nodes to end of tree. More...
 
void append ()
 
void shrink (const MInt count)
 Remove nodes from end of tree. More...
 
void shrink ()
 
void copy (const T &source, const MInt begin, const MInt end, const MInt to)
 Copy nodes to another location without changing any parent/child/neighbor information. More...
 
void copy (const T &source, const MInt from, const MInt to)
 
void copy (const MInt begin, const MInt end, const MInt to)
 
void copy (const MInt from, const MInt to)
 
void move (const MInt begin, const MInt end, const MInt to)
 Move nodes to another location and update parent/child/neighbor information accordingly. More...
 
void move (const MInt from, const MInt to)
 
void swap (const MInt a, const MInt b)
 Swap two nodes and update parent/child/neighbor information accordingly. More...
 
void insert (const MInt begin, const MInt count)
 
void insert (const MInt id)
 
void erase (const MInt begin, const MInt end)
 Erase nodes in range [begin, end) and update parent/child/neighbor information. More...
 
void erase (const MInt id)
 
void removeAndShift (const MInt begin, const MInt end)
 
void removeAndShift (const MInt id)
 
void removeAndFill (const MInt begin, const MInt end)
 
void removeAndFill (const MInt id)
 
void clear ()
 Clear tree by invalidating all nodes and setting size to zero. More...
 
FcCellCollector< nDim > & derived ()
 
const FcCellCollector< nDim > & derived () const
 
void rawCopy (const T &source, const MInt begin, const MInt end, const MInt to)
 Copy range of nodes [begin, end) to range starting at 'to'. More...
 
void rawCopy (const T &source, const MInt from, const MInt to)
 
void deleteConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end))
 
void moveConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end), const MInt NotUsed(to))
 
void moveConnectivity (const MInt from, const MInt to)
 
constexpr MInt dummy () const
 

Static Public Member Functions

static constexpr MInt noProperties ()
 Return number of properties defined for each node. More...
 

Private Types

using Base = maia::container::Container< FcCellCollector< nDim >, Invalid >
 
template<class T >
using Storage = typename Base::template Storage< T >
 
using BitsetType = maia::fc::cell::BitsetType
 

Private Member Functions

void reset ()
 Reset tree, re-create data structures with given capacity, and set size to zero. More...
 
void invalidate (const MInt begin, const MInt end)
 Erase range of nodes such that they contain no sensible values anymore. More...
 
template<class Functor , class T >
void rawCopyGeneric (Functor &&c, const T &source, const MInt begin, const MInt end, const MInt destination)
 Helper function for rawCopy(). Destination may refer to beginning or end of target range. More...
 

Private Attributes

MInt m_noVariables = 1
 Number of variables. More...
 
MInt m_noStrainsPerCell = (nDim == 2) ? (nDim + 1) : (nDim * 2)
 
MInt m_noStressesPerCell = m_noStrainsPerCell
 
MInt m_maxPRfnmnt = 0
 
MInt m_numberOfNodes = 0
 
MBool m_isThermal = false
 Use thermal model. More...
 
MBool m_isPlastic = false
 Use plastic model. More...
 
MBool m_isPRefined = false
 Use p-refinement. More...
 
Storage< MFloat > m_alpha {}
 
Storage< MFloat > m_poissonRatio {}
 
Storage< MFloat > m_invJacobian {}
 
Storage< MInt > m_pRfnmnt {}
 
Storage< MInt > m_maxSubCellLvl {}
 
Storage< MInt > m_noNodesPerCell {}
 
Storage< MInt > m_bndId {}
 
Storage< MInt > m_nodeIdsLoc {}
 
Storage< MInt > m_nodeIdsGlob {}
 
Storage< MFloat > m_elementDisplacements {}
 
Storage< MFloat > m_elementStrains {}
 
Storage< MFloat > m_nodalStrains {}
 
Storage< MFloat > m_elementStresses {}
 
Storage< MFloat > m_nodalStresses {}
 
Storage< MFloat > m_nodePosition {}
 
Storage< MFloat > m_deltaGamma {}
 
Storage< MFloat > m_epsilonBarP {}
 
Storage< BitsetType > m_properties {}
 

Friends

class maia::container::Container< FcCellCollector< nDim >, Invalid >
 

Additional Inherited Members

- Protected Types inherited from maia::container::Container< FcCellCollector< nDim >, Invalid >
using Storage = std::vector< T >
 
- Protected Member Functions inherited from maia::container::Container< FcCellCollector< nDim >, Invalid >
virtual void resize ()
 
void resetStorage (const MInt n, Storage< T > &c)
 Create new container with given size and replace original one. More...
 
void resizeStorage (const MInt n, Storage< T > &c)
 Resize container with given size. More...
 
void fill_invalid (Container_ &c, const MInt begin, const MInt end, const MInt solverSize=1, const T value=Invalid< T >::value())
 
void copyData (const Container_ &source, Container_ &target, Functor &&f, const MInt begin, const MInt end, const MInt dest, const MInt solverSize=1)
 Copy [begin, end) range with given solver size from source to dest position of target. More...
 
MBool isValidId (const MInt id) const
 Return whether given id refers to a valid node (auxiliary method). More...
 

Detailed Description

template<MInt nDim>
class maia::fc::collector::FcCellCollector< nDim >

Definition at line 113 of file fccellcollector.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>
using maia::fc::collector::FcCellCollector< nDim >::Base = maia::container::Container<FcCellCollector<nDim>, Invalid>
private

Definition at line 118 of file fccellcollector.h.

◆ BitsetType

template<MInt nDim>
using maia::fc::collector::FcCellCollector< nDim >::BitsetType = maia::fc::cell::BitsetType
private

Definition at line 122 of file fccellcollector.h.

◆ Invalid

template<MInt nDim>
template<class T >
using maia::fc::collector::FcCellCollector< nDim >::Invalid = typename maia::fc::collector::Invalid<T>

Definition at line 128 of file fccellcollector.h.

◆ Storage

template<MInt nDim>
template<class T >
using maia::fc::collector::FcCellCollector< nDim >::Storage = typename Base::template Storage<T>
private

Definition at line 121 of file fccellcollector.h.

Constructor & Destructor Documentation

◆ FcCellCollector()

template<MInt nDim>
constexpr maia::fc::collector::FcCellCollector< nDim >::FcCellCollector ( )
constexprdefault

Member Function Documentation

◆ allProperties()

template<MInt nDim>
BitsetType & maia::fc::collector::FcCellCollector< nDim >::allProperties ( const MInt  id)

Definition at line 692 of file fccellcollector.h.

692 {
693 ENSURE_VALID_ID_ACCESSOR(id);
694 return m_properties[id];
695}
id
MInt id
Definition: maiatypes.h:71

◆ alpha() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::alpha ( const MInt  id)

Definition at line 294 of file fccellcollector.h.

294 {
295// Prevent accidental compilation without support for SoA layout
296#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
297#error Missing implementation for structure-of-arrays memory layout.
298#endif
299 ENSURE_VALID_ID_ACCESSOR(id);
300 return m_alpha[id];
301}

◆ alpha() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::alpha ( const MInt  id) const

Definition at line 304 of file fccellcollector.h.

304 {
305// Prevent accidental compilation without support for SoA layout
306#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
307#error Missing implementation for structure-of-arrays memory layout.
308#endif
309 ENSURE_VALID_ID_ACCESSOR(id);
310 return m_alpha[id];
311}

◆ bndId() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::bndId ( const MInt  id)

Definition at line 420 of file fccellcollector.h.

420 {
421 // Prevent accidental compilation without support for SoA layout
422#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
423#error Missing implementation for structure-of-arrays memory layout.
424#endif
425 ENSURE_VALID_ID_ACCESSOR(id);
426 return m_bndId[id];
427}

◆ bndId() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::bndId ( const MInt  id) const

Definition at line 430 of file fccellcollector.h.

430 {
431 // Prevent accidental compilation without support for SoA layout
432#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
433#error Missing implementation for structure-of-arrays memory layout.
434#endif
435 ENSURE_VALID_ID_ACCESSOR(id);
436 return m_bndId[id];
437}

◆ deltaGamma() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::deltaGamma ( const MInt  id,
const MInt  eid 
)

Definition at line 625 of file fccellcollector.h.

625 {
626 // Prevent accidental compilation without support for SoA layout
627#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
628#error Missing implementation for structure-of-arrays memory layout.
629#endif
630 ENSURE_VALID_ID_ACCESSOR(id);
631 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
632 return m_deltaGamma[id * noNodes() + eid];
633}

◆ deltaGamma() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::deltaGamma ( const MInt  id,
const MInt  eid 
) const

Definition at line 636 of file fccellcollector.h.

636 {
637 // Prevent accidental compilation without support for SoA layout
638#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
639#error Missing implementation for structure-of-arrays memory layout.
640#endif
641 ENSURE_VALID_ID_ACCESSOR(id);
642 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
643 return m_deltaGamma[id * noNodes() + eid];
644}

◆ elementDisplacements() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::elementDisplacements ( const MInt  id,
const MInt  eid 
)

Definition at line 487 of file fccellcollector.h.

487 {
488 // Prevent accidental compilation without support for SoA layout
489#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
490#error Missing implementation for structure-of-arrays memory layout.
491#endif
492 ENSURE_VALID_ID_ACCESSOR(id);
493 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
494 return m_elementDisplacements[id * nDim + eid];
495}

◆ elementDisplacements() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::elementDisplacements ( const MInt  id,
const MInt  eid 
) const

Definition at line 498 of file fccellcollector.h.

498 {
499 // Prevent accidental compilation without support for SoA layout
500#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
501#error Missing implementation for structure-of-arrays memory layout.
502#endif
503 ENSURE_VALID_ID_ACCESSOR(id);
504 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
505 return m_elementDisplacements[id * nDim + eid];
506}

◆ elementStrains() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::elementStrains ( const MInt  id,
const MInt  eid 
)

Definition at line 510 of file fccellcollector.h.

510 {
511 // Prevent accidental compilation without support for SoA layout
512#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
513#error Missing implementation for structure-of-arrays memory layout.
514#endif
515 ENSURE_VALID_ID_ACCESSOR(id);
516 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
517 return m_elementStrains[id * noStrains() + eid];
518}
maia::fc::collector::FcCellCollector::noStrains
constexpr MInt noStrains() const
Return number of strains.
Definition: fccellcollector.h:204

◆ elementStrains() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::elementStrains ( const MInt  id,
const MInt  eid 
) const

Definition at line 521 of file fccellcollector.h.

521 {
522 // Prevent accidental compilation without support for SoA layout
523#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
524#error Missing implementation for structure-of-arrays memory layout.
525#endif
526 ENSURE_VALID_ID_ACCESSOR(id);
527 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
528 return m_elementStrains[id * noStrains() + eid];
529}

◆ elementStresses() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::elementStresses ( const MInt  id,
const MInt  eid 
)

Definition at line 556 of file fccellcollector.h.

556 {
557 // Prevent accidental compilation without support for SoA layout
558#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
559#error Missing implementation for structure-of-arrays memory layout.
560#endif
561 ENSURE_VALID_ID_ACCESSOR(id);
562 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
563 return m_elementStresses[id * noStresses() + eid];
564}
maia::fc::collector::FcCellCollector::noStresses
constexpr MInt noStresses() const
Return number of stresses.
Definition: fccellcollector.h:207

◆ elementStresses() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::elementStresses ( const MInt  id,
const MInt  eid 
) const

Definition at line 567 of file fccellcollector.h.

567 {
568 // Prevent accidental compilation without support for SoA layout
569#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
570#error Missing implementation for structure-of-arrays memory layout.
571#endif
572 ENSURE_VALID_ID_ACCESSOR(id);
573 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
574 return m_elementStresses[id * noStresses() + eid];
575}

◆ epsilonBarP() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::epsilonBarP ( const MInt  id,
const MInt  eid 
)

Definition at line 648 of file fccellcollector.h.

648 {
649 // Prevent accidental compilation without support for SoA layout
650#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
651#error Missing implementation for structure-of-arrays memory layout.
652#endif
653 ENSURE_VALID_ID_ACCESSOR(id);
654 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
655 return m_epsilonBarP[id * noNodes() + eid];
656}

◆ epsilonBarP() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::epsilonBarP ( const MInt  id,
const MInt  eid 
) const

Definition at line 659 of file fccellcollector.h.

659 {
660 // Prevent accidental compilation without support for SoA layout
661#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
662#error Missing implementation for structure-of-arrays memory layout.
663#endif
664 ENSURE_VALID_ID_ACCESSOR(id);
665 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
666 return m_epsilonBarP[id * noNodes() + eid];
667}

◆ hasProperty() [1/2]

template<MInt nDim>
FcCellCollector< nDim >::BitsetType::reference maia::fc::collector::FcCellCollector< nDim >::hasProperty ( const MInt  id,
const FcCell  p 
)

Definition at line 671 of file fccellcollector.h.

671 {
672 ENSURE_VALID_ID_ACCESSOR(id);
673 ENSURE_VALID_PROPERTY_ACCESSOR(p);
674 return m_properties[id][maia::fc::cell::p(p)];
675}
maia::fc::cell::p
constexpr std::underlying_type< FcCell >::type p(const FcCell property)
Converts property name to underlying integer value.
Definition: fccellproperties.h:32

◆ hasProperty() [2/2]

template<MInt nDim>
MBool maia::fc::collector::FcCellCollector< nDim >::hasProperty ( const MInt  id,
const FcCell  p 
) const

Definition at line 678 of file fccellcollector.h.

678 {
679 ENSURE_VALID_ID_ACCESSOR(id);
680 ENSURE_VALID_PROPERTY_ACCESSOR(p);
681 return m_properties[id][maia::fc::cell::p(p)];
682}

◆ invalidate()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::invalidate ( const MInt  begin,
const MInt  end 
)
private

Definition at line 722 of file fccellcollector.h.

722 {
723// Prevent accidental compilation without support for SoA layout
724#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
725#error Missing implementation for structure-of-arrays memory layout.
726#endif
727
728 fill_invalid(m_alpha, begin, end, 1, 1.);
729 fill_invalid(m_poissonRatio, begin, end, 1, 0.);
730 fill_invalid(m_invJacobian, begin, end, 1, 0.);
731 fill_invalid(m_pRfnmnt, begin, end, 1, 0);
732 fill_invalid(m_maxSubCellLvl, begin, end, 1, 0);
733 fill_invalid(m_noNodesPerCell, begin, end, 1, -1);
734 fill_invalid(m_bndId, begin, end, 1, -1);
735 fill_invalid(m_nodeIdsLoc, begin, end, noNodes(), -1);
736 fill_invalid(m_nodeIdsGlob, begin, end, noNodes(), -1);
737 fill_invalid(m_elementDisplacements, begin, end, nDim, 0.);
738 fill_invalid(m_elementStrains, begin, end, noStrains(), 0.);
739 fill_invalid(m_nodePosition, begin, end, maxPRfnmnt() + 2, 0.);
740 fill_invalid(m_elementStresses, begin, end, noStresses(), 0.);
741
742 if(isPlastic()) {
743 fill_invalid(m_deltaGamma, begin, end, noNodes(), 0.);
744 fill_invalid(m_epsilonBarP, begin, end, noNodes(), 0.);
745 fill_invalid(m_nodalStrains, begin, end, noStrains() * noNodes(), 0.);
746 fill_invalid(m_nodalStresses, begin, end, noStresses() * noNodes(), 0.);
747 }
748
749 // Properties
750 fill_invalid(m_properties, begin, end);
751}
maia::container::Container< FcCellCollector< nDim >, Invalid >::fill_invalid
void fill_invalid(Container_ &c, const MInt begin, const MInt end, const MInt solverSize=1, const T value=Invalid< T >::value())
Definition: container.h:131
maia::fc::collector::FcCellCollector::isPlastic
constexpr MBool isPlastic() const
Return if simulation is plastic.
Definition: fccellcollector.h:195
maia::fc::collector::FcCellCollector::maxPRfnmnt
constexpr MInt maxPRfnmnt() const
Return max pRfnmnt.
Definition: fccellcollector.h:212

◆ invJacobian() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::invJacobian ( const MInt  id)

Definition at line 336 of file fccellcollector.h.

336 {
337// Prevent accidental compilation without support for SoA layout
338#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
339#error Missing implementation for structure-of-arrays memory layout.
340#endif
341 ENSURE_VALID_ID_ACCESSOR(id);
342 return m_invJacobian[id];
343}

◆ invJacobian() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::invJacobian ( const MInt  id) const

Definition at line 346 of file fccellcollector.h.

346 {
347// Prevent accidental compilation without support for SoA layout
348#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
349#error Missing implementation for structure-of-arrays memory layout.
350#endif
351 ENSURE_VALID_ID_ACCESSOR(id);
352 return m_invJacobian[id];
353}

◆ isPlastic()

template<MInt nDim>
constexpr MBool maia::fc::collector::FcCellCollector< nDim >::isPlastic ( ) const
inlineconstexpr

Definition at line 195 of file fccellcollector.h.

195{ return m_isPlastic; }
maia::fc::collector::FcCellCollector::m_isPlastic
MBool m_isPlastic
Use plastic model.
Definition: fccellcollector.h:239

◆ isPRefined()

template<MInt nDim>
constexpr MBool maia::fc::collector::FcCellCollector< nDim >::isPRefined ( ) const
inlineconstexpr

Definition at line 198 of file fccellcollector.h.

198{ return m_isPRefined; }

◆ isThermal()

template<MInt nDim>
constexpr MBool maia::fc::collector::FcCellCollector< nDim >::isThermal ( ) const
inlineconstexpr

Definition at line 192 of file fccellcollector.h.

192{ return m_isThermal; }
maia::fc::collector::FcCellCollector::m_isThermal
MBool m_isThermal
Use thermal model.
Definition: fccellcollector.h:236

◆ maxPRfnmnt()

template<MInt nDim>
constexpr MInt maia::fc::collector::FcCellCollector< nDim >::maxPRfnmnt ( ) const
inlineconstexpr

Definition at line 212 of file fccellcollector.h.

212{ return m_maxPRfnmnt; }

◆ maxSubCellLvl() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::maxSubCellLvl ( const MInt  id)

Definition at line 378 of file fccellcollector.h.

378 {
379// Prevent accidental compilation without support for SoA layout
380#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
381#error Missing implementation for structure-of-arrays memory layout.
382#endif
383 ENSURE_VALID_ID_ACCESSOR(id);
384 return m_maxSubCellLvl[id];
385}

◆ maxSubCellLvl() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::maxSubCellLvl ( const MInt  id) const

Definition at line 388 of file fccellcollector.h.

388 {
389// Prevent accidental compilation without support for SoA layout
390#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
391#error Missing implementation for structure-of-arrays memory layout.
392#endif
393 ENSURE_VALID_ID_ACCESSOR(id);
394 return m_maxSubCellLvl[id];
395}

◆ nodalStrains() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::nodalStrains ( const MInt  id,
const MInt  nid,
const MInt  eid 
)

Definition at line 533 of file fccellcollector.h.

533 {
534 // Prevent accidental compilation without support for SoA layout
535#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
536#error Missing implementation for structure-of-arrays memory layout.
537#endif
538 ENSURE_VALID_ID_ACCESSOR(id);
539 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(nid * noStrains() + eid);
540 return m_nodalStrains[id * noStrains() * noNodes() + nid * noStrains() + eid];
541}

◆ nodalStrains() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::nodalStrains ( const MInt  id,
const MInt  nid,
const MInt  eid 
) const

Definition at line 544 of file fccellcollector.h.

544 {
545 // Prevent accidental compilation without support for SoA layout
546#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
547#error Missing implementation for structure-of-arrays memory layout.
548#endif
549 ENSURE_VALID_ID_ACCESSOR(id);
550 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(nid * noStrains() + eid);
551 return m_nodalStrains[id * noStrains() * noNodes() + nid * noStrains() + eid];
552}

◆ nodalStresses() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::nodalStresses ( const MInt  id,
const MInt  nid,
const MInt  eid 
)

Definition at line 579 of file fccellcollector.h.

579 {
580 // Prevent accidental compilation without support for SoA layout
581#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
582#error Missing implementation for structure-of-arrays memory layout.
583#endif
584 ENSURE_VALID_ID_ACCESSOR(id);
585 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(nid * noStresses() + eid);
586 return m_nodalStresses[id * noStresses() * noNodes() + nid * noStresses() + eid];
587}

◆ nodalStresses() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::nodalStresses ( const MInt  id,
const MInt  nid,
const MInt  eid 
) const

Definition at line 590 of file fccellcollector.h.

590 {
591 // Prevent accidental compilation without support for SoA layout
592#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
593#error Missing implementation for structure-of-arrays memory layout.
594#endif
595 ENSURE_VALID_ID_ACCESSOR(id);
596 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(nid * noStresses() + eid);
597 return m_nodalStresses[id * noStresses() * noNodes() + nid * noStresses() + eid];
598}

◆ nodeIdsGlob() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::nodeIdsGlob ( const MInt  id,
const MInt  eid 
)

Definition at line 464 of file fccellcollector.h.

464 {
465 // Prevent accidental compilation without support for SoA layout
466#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
467#error Missing implementation for structure-of-arrays memory layout.
468#endif
469 ENSURE_VALID_ID_ACCESSOR(id);
470 ENSURE_VALID_VARIABLE_ID_ACCESSOR(eid);
471 return m_nodeIdsGlob[id * noNodes() + eid];
472}

◆ nodeIdsGlob() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::nodeIdsGlob ( const MInt  id,
const MInt  eid 
) const

Definition at line 475 of file fccellcollector.h.

475 {
476 // Prevent accidental compilation without support for SoA layout
477#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
478#error Missing implementation for structure-of-arrays memory layout.
479#endif
480 ENSURE_VALID_ID_ACCESSOR(id);
481 ENSURE_VALID_VARIABLE_ID_ACCESSOR(eid);
482 return m_nodeIdsGlob[id * noNodes() + eid];
483}

◆ nodeIdsLoc() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::nodeIdsLoc ( const MInt  id,
const MInt  eid 
)

Definition at line 441 of file fccellcollector.h.

441 {
442 // Prevent accidental compilation without support for SoA layout
443#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
444#error Missing implementation for structure-of-arrays memory layout.
445#endif
446 ENSURE_VALID_ID_ACCESSOR(id);
447 ENSURE_VALID_VARIABLE_ID_ACCESSOR(eid);
448 return m_nodeIdsLoc[id * noNodes() + eid];
449}

◆ nodeIdsLoc() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::nodeIdsLoc ( const MInt  id,
const MInt  eid 
) const

Definition at line 452 of file fccellcollector.h.

452 {
453 // Prevent accidental compilation without support for SoA layout
454#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
455#error Missing implementation for structure-of-arrays memory layout.
456#endif
457 ENSURE_VALID_ID_ACCESSOR(id);
458 ENSURE_VALID_VARIABLE_ID_ACCESSOR(eid);
459 return m_nodeIdsLoc[id * noNodes() + eid];
460}

◆ nodePosition() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::nodePosition ( const MInt  id,
const MInt  eid 
)

Definition at line 602 of file fccellcollector.h.

602 {
603 // Prevent accidental compilation without support for SoA layout
604#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
605#error Missing implementation for structure-of-arrays memory layout.
606#endif
607 ENSURE_VALID_ID_ACCESSOR(id);
608 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
609 return m_nodePosition[id * (maxPRfnmnt() + 2) + eid];
610}

◆ nodePosition() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::nodePosition ( const MInt  id,
const MInt  eid 
) const

Definition at line 613 of file fccellcollector.h.

613 {
614 // Prevent accidental compilation without support for SoA layout
615#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
616#error Missing implementation for structure-of-arrays memory layout.
617#endif
618 ENSURE_VALID_ID_ACCESSOR(id);
619 ENSURE_VALID_DISTRIBUTION_ID_ACCESSOR(eid);
620 return m_nodePosition[id * (maxPRfnmnt() + 2) + eid];
621}

◆ noNodes()

template<MInt nDim>
constexpr MInt maia::fc::collector::FcCellCollector< nDim >::noNodes ( ) const
inlineconstexpr

Definition at line 209 of file fccellcollector.h.

209{ return m_numberOfNodes; }

◆ noNodesPerCell() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::noNodesPerCell ( const MInt  id)

Definition at line 399 of file fccellcollector.h.

399 {
400 // Prevent accidental compilation without support for SoA layout
401#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
402#error Missing implementation for structure-of-arrays memory layout.
403#endif
404 ENSURE_VALID_ID_ACCESSOR(id);
405 return m_noNodesPerCell[id];
406}

◆ noNodesPerCell() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::noNodesPerCell ( const MInt  id) const

Definition at line 409 of file fccellcollector.h.

409 {
410 // Prevent accidental compilation without support for SoA layout
411#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
412#error Missing implementation for structure-of-arrays memory layout.
413#endif
414 ENSURE_VALID_ID_ACCESSOR(id);
415 return m_noNodesPerCell[id];
416}

◆ noProperties()

template<MInt nDim>
static constexpr MInt maia::fc::collector::FcCellCollector< nDim >::noProperties ( )
inlinestaticconstexpr

Definition at line 215 of file fccellcollector.h.

215{ return maia::fc::cell::p(FcCell::NumProperties); }

◆ noStrains()

template<MInt nDim>
constexpr MInt maia::fc::collector::FcCellCollector< nDim >::noStrains ( ) const
inlineconstexpr

Definition at line 204 of file fccellcollector.h.

204{ return m_noStrainsPerCell; }

◆ noStresses()

template<MInt nDim>
constexpr MInt maia::fc::collector::FcCellCollector< nDim >::noStresses ( ) const
inlineconstexpr

Definition at line 207 of file fccellcollector.h.

207{ return m_noStressesPerCell; }

◆ noVariables()

template<MInt nDim>
constexpr MInt maia::fc::collector::FcCellCollector< nDim >::noVariables ( ) const
inlineconstexpr

Definition at line 201 of file fccellcollector.h.

201{ return m_noVariables; }
maia::fc::collector::FcCellCollector::m_noVariables
MInt m_noVariables
Number of variables.
Definition: fccellcollector.h:225

◆ poissonRatio() [1/2]

template<MInt nDim>
MFloat & maia::fc::collector::FcCellCollector< nDim >::poissonRatio ( const MInt  id)

Definition at line 315 of file fccellcollector.h.

315 {
316// Prevent accidental compilation without support for SoA layout
317#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
318#error Missing implementation for structure-of-arrays memory layout.
319#endif
320 ENSURE_VALID_ID_ACCESSOR(id);
321 return m_poissonRatio[id];
322}

◆ poissonRatio() [2/2]

template<MInt nDim>
MFloat maia::fc::collector::FcCellCollector< nDim >::poissonRatio ( const MInt  id) const

Definition at line 325 of file fccellcollector.h.

325 {
326// Prevent accidental compilation without support for SoA layout
327#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
328#error Missing implementation for structure-of-arrays memory layout.
329#endif
330 ENSURE_VALID_ID_ACCESSOR(id);
331 return m_poissonRatio[id];
332}

◆ pRfnmnt() [1/2]

template<MInt nDim>
MInt & maia::fc::collector::FcCellCollector< nDim >::pRfnmnt ( const MInt  id)

Definition at line 357 of file fccellcollector.h.

357 {
358// Prevent accidental compilation without support for SoA layout
359#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
360#error Missing implementation for structure-of-arrays memory layout.
361#endif
362 ENSURE_VALID_ID_ACCESSOR(id);
363 return m_pRfnmnt[id];
364}

◆ pRfnmnt() [2/2]

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::pRfnmnt ( const MInt  id) const

Definition at line 367 of file fccellcollector.h.

367 {
368// Prevent accidental compilation without support for SoA layout
369#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
370#error Missing implementation for structure-of-arrays memory layout.
371#endif
372 ENSURE_VALID_ID_ACCESSOR(id);
373 return m_pRfnmnt[id];
374}

◆ rawCopyGeneric()

template<MInt nDim>
template<class Functor , class T >
void maia::fc::collector::FcCellCollector< nDim >::rawCopyGeneric ( Functor &&  c,
const T &  source,
const MInt  begin,
const MInt  end,
const MInt  destination 
)
private

Definition at line 757 of file fccellcollector.h.

758 {
759// Prevent accidental compilation without support for SoA layout
760#ifdef FCCOLLECTOR_SOA_MEMORY_LAYOUT
761#error Missing implementation for structure-of-arrays memory layout.
762#endif
763
764 copyData(source.m_alpha, m_alpha, c, begin, end, destination);
765 copyData(source.m_poissonRatio, m_poissonRatio, c, begin, end, destination);
766 copyData(source.m_invJacobian, m_invJacobian, c, begin, end, destination);
767 copyData(source.m_pRfnmnt, m_pRfnmnt, c, begin, end, destination);
768 copyData(source.m_maxSubCellLvl, m_maxSubCellLvl, c, begin, end, destination);
769 copyData(source.m_noNodesPerCell, m_noNodesPerCell, c, begin, end, destination);
770 copyData(source.m_bndId, m_bndId, c, begin, end, destination);
771 copyData(source.m_nodeIdsLoc, m_nodeIdsLoc, c, begin, end, destination, noNodes());
772 copyData(source.m_nodeIdsGlob, m_nodeIdsGlob, c, begin, end, destination, noNodes());
773 copyData(source.m_elementDisplacements, m_elementDisplacements, c, begin, end, destination, nDim);
774 copyData(source.m_elementStrains, m_elementStrains, c, begin, end, destination, noStrains());
775 copyData(source.m_nodePosition, m_nodePosition, c, begin, end, destination, maxPRfnmnt() + 2);
776 copyData(source.m_elementStresses, m_elementStresses, c, begin, end, destination, noStresses());
777
778 if(isPlastic()) {
779 copyData(source.m_deltaGamma, m_deltaGamma, c, begin, end, destination);
780 copyData(source.m_epsilonBarP, m_epsilonBarP, c, begin, end, destination);
781 copyData(source.m_nodalStrains, m_nodalStrains, c, begin, end, destination);
782 copyData(source.m_nodalStresses, m_nodalStresses, c, begin, end, destination);
783 }
784
785
786 // Properties
787 copyData(source.m_properties, m_properties, c, begin, end, destination);
788}
maia::container::Container< FcCellCollector< nDim >, Invalid >::copyData
void copyData(const Container_ &source, Container_ &target, Functor &&f, const MInt begin, const MInt end, const MInt dest, const MInt solverSize=1)
Copy [begin, end) range with given solver size from source to dest position of target.
Definition: container.h:138

◆ reset()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::reset
private

Definition at line 267 of file fccellcollector.h.

267 {
268 resetStorage(1, m_alpha);
269 resetStorage(1, m_poissonRatio);
270 resetStorage(1, m_invJacobian);
271 resetStorage(1, m_pRfnmnt);
272 resetStorage(1, m_maxSubCellLvl);
273 resetStorage(1, m_noNodesPerCell);
274 resetStorage(1, m_bndId);
275 resetStorage(noNodes(), m_nodeIdsLoc);
276 resetStorage(noNodes(), m_nodeIdsGlob);
277 resetStorage(nDim, m_elementDisplacements);
278 resetStorage(noStrains(), m_elementStrains);
279 resetStorage(maxPRfnmnt() + 2, m_nodePosition);
280 resetStorage(noStresses(), m_elementStresses);
281 if(isPlastic()) {
282 resetStorage(noNodes(), m_deltaGamma);
283 resetStorage(noNodes(), m_epsilonBarP);
284 resetStorage(noStrains() * noNodes(), m_nodalStrains);
285 resetStorage(noStresses() * noNodes(), m_nodalStresses);
286 }
287
288 resetStorage(1, m_properties);
289}
maia::container::Container< FcCellCollector< nDim >, Invalid >::resetStorage
void resetStorage(const MInt n, Storage< T > &c)
Create new container with given size and replace original one.
Definition: container.h:420

◆ resetProperties()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::resetProperties ( const MInt  id)

Definition at line 685 of file fccellcollector.h.

685 {
686 ENSURE_VALID_ID_ACCESSOR(id);
687 m_properties[id].reset();
688}

◆ setMaxPRfnmnt()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::setMaxPRfnmnt ( const MInt  maxPRfnmnt_)

Set use of p-refinement and update number of variables.

Definition at line 712 of file fccellcollector.h.

712 {
713 m_maxPRfnmnt = maxPRfnmnt_;
714 m_numberOfNodes = (m_maxPRfnmnt + 2) * (m_maxPRfnmnt + 2);
715 if(nDim == 3) m_numberOfNodes *= (m_maxPRfnmnt + 2);
716
717 if(maxPRfnmnt_ > 0) m_isPRefined = true;
718}

◆ setPlasticity()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::setPlasticity ( const MBool  isPlastic_)

Set use of plastic model and update number of variables.

Definition at line 706 of file fccellcollector.h.

706 {
707 m_isPlastic = isPlastic_;
708}

◆ setThermal()

template<MInt nDim>
void maia::fc::collector::FcCellCollector< nDim >::setThermal ( const MBool  isThermal_)

Set use of thermal model and update number of variables.

Definition at line 699 of file fccellcollector.h.

699 {
700 m_isThermal = isThermal_;
701 m_noVariables = isThermal() ? 1 + 1 : 1;
702}
maia::fc::collector::FcCellCollector::isThermal
constexpr MBool isThermal() const
Return if simulation is thermal.
Definition: fccellcollector.h:192

Friends And Related Function Documentation

◆ maia::container::Container< FcCellCollector< nDim >, Invalid >

template<MInt nDim>
friend class maia::container::Container< FcCellCollector< nDim >, Invalid >
friend

Definition at line 108 of file fccellcollector.h.

Member Data Documentation

◆ m_alpha

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_alpha {}
private

Definition at line 245 of file fccellcollector.h.

◆ m_bndId

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_bndId {}
private

Definition at line 251 of file fccellcollector.h.

◆ m_deltaGamma

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_deltaGamma {}
private

Definition at line 260 of file fccellcollector.h.

◆ m_elementDisplacements

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_elementDisplacements {}
private

Definition at line 254 of file fccellcollector.h.

◆ m_elementStrains

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_elementStrains {}
private

Definition at line 255 of file fccellcollector.h.

◆ m_elementStresses

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_elementStresses {}
private

Definition at line 257 of file fccellcollector.h.

◆ m_epsilonBarP

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_epsilonBarP {}
private

Definition at line 261 of file fccellcollector.h.

◆ m_invJacobian

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_invJacobian {}
private

Definition at line 247 of file fccellcollector.h.

◆ m_isPlastic

template<MInt nDim>
MBool maia::fc::collector::FcCellCollector< nDim >::m_isPlastic = false
private

Definition at line 239 of file fccellcollector.h.

◆ m_isPRefined

template<MInt nDim>
MBool maia::fc::collector::FcCellCollector< nDim >::m_isPRefined = false
private

Definition at line 242 of file fccellcollector.h.

◆ m_isThermal

template<MInt nDim>
MBool maia::fc::collector::FcCellCollector< nDim >::m_isThermal = false
private

Definition at line 236 of file fccellcollector.h.

◆ m_maxPRfnmnt

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::m_maxPRfnmnt = 0
private

Definition at line 231 of file fccellcollector.h.

◆ m_maxSubCellLvl

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_maxSubCellLvl {}
private

Definition at line 249 of file fccellcollector.h.

◆ m_nodalStrains

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_nodalStrains {}
private

Definition at line 256 of file fccellcollector.h.

◆ m_nodalStresses

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_nodalStresses {}
private

Definition at line 258 of file fccellcollector.h.

◆ m_nodeIdsGlob

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_nodeIdsGlob {}
private

Definition at line 253 of file fccellcollector.h.

◆ m_nodeIdsLoc

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_nodeIdsLoc {}
private

Definition at line 252 of file fccellcollector.h.

◆ m_nodePosition

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_nodePosition {}
private

Definition at line 259 of file fccellcollector.h.

◆ m_noNodesPerCell

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_noNodesPerCell {}
private

Definition at line 250 of file fccellcollector.h.

◆ m_noStrainsPerCell

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::m_noStrainsPerCell = (nDim == 2) ? (nDim + 1) : (nDim * 2)
private

Definition at line 227 of file fccellcollector.h.

◆ m_noStressesPerCell

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::m_noStressesPerCell = m_noStrainsPerCell
private

Definition at line 229 of file fccellcollector.h.

◆ m_noVariables

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::m_noVariables = 1
private

Definition at line 225 of file fccellcollector.h.

◆ m_numberOfNodes

template<MInt nDim>
MInt maia::fc::collector::FcCellCollector< nDim >::m_numberOfNodes = 0
private

Definition at line 233 of file fccellcollector.h.

◆ m_poissonRatio

template<MInt nDim>
Storage<MFloat> maia::fc::collector::FcCellCollector< nDim >::m_poissonRatio {}
private

Definition at line 246 of file fccellcollector.h.

◆ m_pRfnmnt

template<MInt nDim>
Storage<MInt> maia::fc::collector::FcCellCollector< nDim >::m_pRfnmnt {}
private

Definition at line 248 of file fccellcollector.h.

◆ m_properties

template<MInt nDim>
Storage<BitsetType> maia::fc::collector::FcCellCollector< nDim >::m_properties {}
private

Definition at line 262 of file fccellcollector.h.

The documentation for this class was generated from the following file: