https://mooseframework.inl.gov
Loading...
Searching...
No Matches
VectorCompositeFunctor.h
Go to the documentation of this file.
1//* This file is part of the MOOSE framework
2//* https://mooseframework.inl.gov
3//*
4//* All rights reserved, see COPYRIGHT for full restrictions
5//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6//*
7//* Licensed under LGPL 2.1, please see LICENSE for details
8//* https://www.gnu.org/licenses/lgpl-2.1.html
9
10#pragma once
11
12#include "MooseFunctor.h"
13#include "libmesh/vector_value.h"
14
15using libMesh::VectorValue;
16
17namespace Moose
18{
22template <typename T>
23class VectorCompositeFunctor : public FunctorBase<VectorValue<T>>
24{
25public:
26 template <typename U>
27 using FunctorBase = FunctorBase<U>;
28
29 using typename FunctorBase<VectorValue<T>>::ValueType;
30 using typename FunctorBase<VectorValue<T>>::GradientType;
31 using typename FunctorBase<VectorValue<T>>::DotType;
32
36 VectorCompositeFunctor(const MooseFunctorName & name,
37 const FunctorBase<T> & x_comp,
38 const FunctorBase<T> & y_comp,
39 const FunctorBase<T> & z_comp);
40
44 VectorCompositeFunctor(const MooseFunctorName & name,
45 const FunctorBase<T> & x_comp,
46 const FunctorBase<T> & y_comp);
47
51 VectorCompositeFunctor(const MooseFunctorName & name, const FunctorBase<T> & x_comp);
52
53 virtual bool hasBlocks(SubdomainID sub_id) const override
54 {
55 const bool ret = _x_comp.hasBlocks(sub_id);
56 if (_has_y)
57 mooseAssert(ret == _y_comp.hasBlocks(sub_id), "x and y block restriction don't agree");
58 if (_has_z)
59 mooseAssert(ret == _z_comp.hasBlocks(sub_id), "x and z block restriction don't agree");
60 return ret;
61 }
62
63 bool supportsFaceArg() const override;
64 bool supportsElemSideQpArg() const override;
65
66private:
67 ValueType evaluate(const ElemArg & elem_arg, const StateArg & state) const override;
68 ValueType evaluate(const FaceArg & face, const StateArg & state) const override;
69 ValueType evaluate(const ElemQpArg & elem_qp, const StateArg & state) const override;
70 ValueType evaluate(const ElemSideQpArg & elem_side_qp, const StateArg & state) const override;
71 ValueType evaluate(const ElemPointArg & elem_point_arg, const StateArg & state) const override;
72 ValueType evaluate(const NodeArg & node_arg, const StateArg & state) const override;
73
74 using FunctorBase<VectorValue<T>>::evaluateGradient;
75 GradientType evaluateGradient(const ElemArg & elem_arg, const StateArg & state) const override;
76
77 using FunctorBase<VectorValue<T>>::evaluateDot;
78 DotType evaluateDot(const FaceArg & face_arg, const StateArg & state) const override;
79 DotType evaluateDot(const ElemArg & elem_arg, const StateArg & state) const override;
80
83 std::unique_ptr<ConstantFunctor<T>> _y_constant;
84
87 std::unique_ptr<ConstantFunctor<T>> _z_constant;
88
90 const FunctorBase<T> & _x_comp;
92 const FunctorBase<T> & _y_comp;
94 const FunctorBase<T> & _z_comp;
95
97 const bool _has_y;
98
100 const bool _has_z;
101};
102
103template <typename T>
104VectorCompositeFunctor<T>::VectorCompositeFunctor(const MooseFunctorName & name,
105 const FunctorBase<T> & x_comp,
106 const FunctorBase<T> & y_comp,
107 const FunctorBase<T> & z_comp)
108 : FunctorBase<VectorValue<T>>(name),
109 _x_comp(x_comp),
110 _y_comp(y_comp),
111 _z_comp(z_comp),
112 _has_y(true),
113 _has_z(true)
114{
115}
116
117template <typename T>
118VectorCompositeFunctor<T>::VectorCompositeFunctor(const MooseFunctorName & name,
119 const FunctorBase<T> & x_comp,
120 const FunctorBase<T> & y_comp)
121 : FunctorBase<VectorValue<T>>(name),
122 _z_constant(std::make_unique<ConstantFunctor>(T(0))),
123 _x_comp(x_comp),
124 _y_comp(y_comp),
125 _z_comp(*_z_constant),
126 _has_y(true),
127 _has_z(false)
128{
129}
130
131template <typename T>
132VectorCompositeFunctor<T>::VectorCompositeFunctor(const MooseFunctorName & name,
133 const FunctorBase<T> & x_comp)
134 : FunctorBase<VectorValue<T>>(name),
135 _y_constant(std::make_unique<ConstantFunctor>(T(0))),
136 _z_constant(std::make_unique<ConstantFunctor>(T(0))),
137 _x_comp(x_comp),
138 _y_comp(*_y_constant),
139 _z_comp(*_z_constant),
140 _has_y(false),
141 _has_z(false)
142{
143}
144
145template <typename T>
146bool
147VectorCompositeFunctor<T>::supportsFaceArg() const
148{
149 if (!_x_comp.supportsFaceArg())
150 return false;
151 if (_has_y && !_y_comp.supportsFaceArg())
152 return false;
153 if (_has_z && !_z_comp.supportsFaceArg())
154 return false;
155 return true;
156}
157
158template <typename T>
159bool
160VectorCompositeFunctor<T>::supportsElemSideQpArg() const
161{
162 if (!_x_comp.supportsElemSideQpArg())
163 return false;
164 if (_has_y && !_y_comp.supportsElemSideQpArg())
165 return false;
166 if (_has_z && !_z_comp.supportsElemSideQpArg())
167 return false;
168 return true;
169}
170
171template <typename T>
172typename VectorCompositeFunctor<T>::ValueType
173VectorCompositeFunctor<T>::evaluate(const ElemArg & elem_arg, const StateArg & state) const
174{
175 return {_x_comp(elem_arg, state), _y_comp(elem_arg, state), _z_comp(elem_arg, state)};
176}
177
178template <typename T>
179typename VectorCompositeFunctor<T>::ValueType
180VectorCompositeFunctor<T>::evaluate(const FaceArg & face, const StateArg & state) const
181{
182 return {_x_comp(face, state), _y_comp(face, state), _z_comp(face, state)};
183}
184
185template <typename T>
186typename VectorCompositeFunctor<T>::ValueType
187VectorCompositeFunctor<T>::evaluate(const ElemQpArg & elem_qp, const StateArg & state) const
188{
189 return {_x_comp(elem_qp, state), _y_comp(elem_qp, state), _z_comp(elem_qp, state)};
190}
191
192template <typename T>
193typename VectorCompositeFunctor<T>::ValueType
194VectorCompositeFunctor<T>::evaluate(const ElemSideQpArg & elem_side_qp,
195 const StateArg & state) const
196{
197 return {_x_comp(elem_side_qp, state), _y_comp(elem_side_qp, state), _z_comp(elem_side_qp, state)};
198}
199
200template <typename T>
201typename VectorCompositeFunctor<T>::ValueType
202VectorCompositeFunctor<T>::evaluate(const ElemPointArg & elem_point_arg,
203 const StateArg & state) const
204{
205 return {_x_comp(elem_point_arg, state),
206 _y_comp(elem_point_arg, state),
207 _z_comp(elem_point_arg, state)};
208}
209
210template <typename T>
211typename VectorCompositeFunctor<T>::ValueType
212VectorCompositeFunctor<T>::evaluate(const NodeArg & node_arg, const StateArg & state) const
213{
214 return {_x_comp(node_arg, state), _y_comp(node_arg, state), _z_comp(node_arg, state)};
215}
216
217template <typename T>
218typename VectorCompositeFunctor<T>::GradientType
219VectorCompositeFunctor<T>::evaluateGradient(const ElemArg & elem_arg, const StateArg & state) const
220{
221 return {_x_comp.gradient(elem_arg, state),
222 _y_comp.gradient(elem_arg, state),
223 _z_comp.gradient(elem_arg, state)};
224}
225
226template <typename T>
227typename VectorCompositeFunctor<T>::DotType
228VectorCompositeFunctor<T>::evaluateDot(const FaceArg & face_arg, const StateArg & state) const
229{
230 return {_x_comp.dot(face_arg, state), _y_comp.dot(face_arg, state), _z_comp.dot(face_arg, state)};
231}
232
233template <typename T>
234typename VectorCompositeFunctor<T>::DotType
235VectorCompositeFunctor<T>::evaluateDot(const ElemArg & elem_arg, const StateArg & state) const
236{
237 return {_x_comp.dot(elem_arg, state), _y_comp.dot(elem_arg, state), _z_comp.dot(elem_arg, state)};
238}
239}
Moose::ConstantFunctor
Class template for creating constant functors.
Definition MooseFunctor.h:1274
Moose::FunctorBase
Base class template for functor objects.
Definition MooseFunctor.h:138
Moose::FunctorBase< VectorValue< T > >::GradientType
typename FunctorReturnType< VectorValue< T >, FunctorEvaluationKind::Gradient >::type GradientType
This rigmarole makes it so that a user can create functors that return containers (std::vector,...
Definition MooseFunctor.h:149
Moose::VectorCompositeFunctor
A functor that returns a vector composed of its component functor evaluations.
Definition VectorCompositeFunctor.h:24
Moose::VectorCompositeFunctor::_y_comp
const FunctorBase< T > & _y_comp
The y-component functor.
Definition VectorCompositeFunctor.h:92
Moose::VectorCompositeFunctor::_x_comp
const FunctorBase< T > & _x_comp
The x-component functor.
Definition VectorCompositeFunctor.h:90
Moose::VectorCompositeFunctor::_z_constant
std::unique_ptr< ConstantFunctor< T > > _z_constant
Possible holder of constant-0 z-component functor.
Definition VectorCompositeFunctor.h:87
Moose::VectorCompositeFunctor::VectorCompositeFunctor
VectorCompositeFunctor(const MooseFunctorName &name, const FunctorBase< T > &x_comp, const FunctorBase< T > &y_comp, const FunctorBase< T > &z_comp)
From xyz component constructor.
Definition VectorCompositeFunctor.h:104
Moose::VectorCompositeFunctor::supportsElemSideQpArg
bool supportsElemSideQpArg() const override
Whether this functor supports evaluation with ElemSideQpArg.
Definition VectorCompositeFunctor.h:160
Moose::VectorCompositeFunctor::evaluate
ValueType evaluate(const ElemArg &elem_arg, const StateArg &state) const override
Evaluate the functor with a given element.
Definition VectorCompositeFunctor.h:173
Moose::VectorCompositeFunctor::_y_constant
std::unique_ptr< ConstantFunctor< T > > _y_constant
Possible holder of constant-0 y-component functor.
Definition VectorCompositeFunctor.h:83
Moose::VectorCompositeFunctor::evaluateGradient
GradientType evaluateGradient(const ElemArg &elem_arg, const StateArg &state) const override
Evaluate the functor gradient with a given element.
Definition VectorCompositeFunctor.h:219
Moose::VectorCompositeFunctor::hasBlocks
virtual bool hasBlocks(SubdomainID sub_id) const override
Returns whether the functor is defined on this block.
Definition VectorCompositeFunctor.h:53
Moose::VectorCompositeFunctor::_has_y
const bool _has_y
Whether the user supplied a y-functor.
Definition VectorCompositeFunctor.h:97
Moose::VectorCompositeFunctor::_z_comp
const FunctorBase< T > & _z_comp
The z-component functor.
Definition VectorCompositeFunctor.h:94
Moose::VectorCompositeFunctor::evaluateDot
DotType evaluateDot(const FaceArg &face_arg, const StateArg &state) const override
Definition VectorCompositeFunctor.h:228
Moose::VectorCompositeFunctor::_has_z
const bool _has_z
Whether the user supplied a z-functor.
Definition VectorCompositeFunctor.h:100
Moose::VectorCompositeFunctor::supportsFaceArg
bool supportsFaceArg() const override
Whether this functor supports evaluation with FaceArg.
Definition VectorCompositeFunctor.h:147
Moose
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Definition SetAdaptivityOptionsAction.h:15
Moose::ElemArg
A structure that is used to evaluate Moose functors logically at an element/cell center.
Definition MooseFunctorArguments.h:29
Moose::ElemPointArg
A structure that is used to evaluate Moose functors at an arbitrary physical point contained within a...
Definition MooseFunctorArguments.h:54
Moose::ElemQpArg
Argument for requesting functor evaluation at a quadrature point location in an element.
Definition MooseFunctorArguments.h:284
Moose::ElemSideQpArg
Argument for requesting functor evaluation at quadrature point locations on an element side.
Definition MooseFunctorArguments.h:90
Moose::FaceArg
A structure defining a "face" evaluation calling argument for Moose functors.
Definition MooseFunctorArguments.h:189
Moose::StateArg
State argument for evaluating functors.
Definition MooseFunctorArguments.h:122
Generated on Mon Aug 24 2026 19:02:05 for https://mooseframework.inl.gov by doxygen 1.9.8