Line data Source code
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 : #include "WCNSFV2PMomentumDriftFlux.h"
11 : #include "INSFVRhieChowInterpolator.h"
12 : #include "NS.h"
13 : #include "SystemBase.h"
14 : #include "RelationshipManager.h"
15 : #include "Factory.h"
16 :
17 : registerMooseObject("NavierStokesApp", WCNSFV2PMomentumDriftFlux);
18 :
19 : InputParameters
20 328 : WCNSFV2PMomentumDriftFlux::validParams()
21 : {
22 328 : auto params = INSFVFluxKernel::validParams();
23 328 : params.addClassDescription("Implements the drift momentum flux source.");
24 656 : params.addRequiredParam<MooseFunctorName>("u_slip", "The slip velocity in the x direction.");
25 656 : params.addParam<MooseFunctorName>("v_slip", "The slip velocity in the y direction.");
26 656 : params.addParam<MooseFunctorName>("w_slip", "The slip velocity in the z direction.");
27 656 : params.addRequiredParam<MooseFunctorName>("rho_d", "Dispersed phase density.");
28 656 : params.addParam<MooseFunctorName>("fd", 0.0, "Fraction dispersed phase.");
29 :
30 656 : params.renameParam("fd", "fraction_dispersed", "");
31 :
32 656 : MooseEnum coeff_interp_method("average harmonic", "harmonic");
33 656 : params.addParam<MooseEnum>("density_interp_method",
34 : coeff_interp_method,
35 : "Switch that can select face interpolation method for the density.");
36 :
37 328 : return params;
38 328 : }
39 :
40 176 : WCNSFV2PMomentumDriftFlux::WCNSFV2PMomentumDriftFlux(const InputParameters & params)
41 : : INSFVFluxKernel(params),
42 176 : _dim(_subproblem.mesh().dimension()),
43 352 : _rho_d(getFunctor<ADReal>("rho_d")),
44 352 : _f_d(getFunctor<ADReal>("fd")),
45 352 : _u_slip(getFunctor<ADReal>("u_slip")),
46 704 : _v_slip(isParamValid("v_slip") ? &getFunctor<ADReal>("v_slip") : nullptr),
47 352 : _w_slip(isParamValid("w_slip") ? &getFunctor<ADReal>("w_slip") : nullptr),
48 176 : _density_interp_method(
49 704 : Moose::FV::selectInterpolationMethod(getParam<MooseEnum>("density_interp_method")))
50 : {
51 176 : if (_dim >= 2 && !_v_slip)
52 0 : mooseError("In two or more dimensions, the v_slip velocity must be supplied using the 'v_slip' "
53 : "parameter");
54 176 : if (_dim >= 3 && !_w_slip)
55 0 : mooseError(
56 : "In three dimensions, the w_slip velocity must be supplied using the 'w_slip' parameter");
57 :
58 : // Phase fraction could be a nonlinear variable
59 176 : const auto & fraction_name = getParam<MooseFunctorName>("fraction_dispersed");
60 528 : if (isParamValid("fraction_dispersed") && _fe_problem.hasVariable(fraction_name))
61 352 : addMooseVariableDependency(&_fe_problem.getVariable(_tid, fraction_name));
62 176 : }
63 :
64 : ADReal
65 495100 : WCNSFV2PMomentumDriftFlux::computeStrongResidual(const bool populate_a_coeffs)
66 : {
67 495100 : _normal = _face_info->normal();
68 495100 : const auto state = determineState();
69 :
70 : Moose::FaceArg face_arg;
71 495100 : if (onBoundary(*_face_info))
72 78590 : face_arg = singleSidedFaceArg();
73 : else
74 416510 : face_arg = makeCDFace(*_face_info);
75 :
76 : ADRealVectorValue u_slip_vel_vec;
77 495100 : if (_dim == 1)
78 0 : u_slip_vel_vec = ADRealVectorValue(_u_slip(face_arg, state), 0.0, 0.0);
79 495100 : else if (_dim == 2)
80 990200 : u_slip_vel_vec = ADRealVectorValue(_u_slip(face_arg, state), (*_v_slip)(face_arg, state), 0.0);
81 : else
82 0 : u_slip_vel_vec = ADRealVectorValue(
83 0 : _u_slip(face_arg, state), (*_v_slip)(face_arg, state), (*_w_slip)(face_arg, state));
84 :
85 495100 : const auto uslipdotn = _normal * u_slip_vel_vec;
86 :
87 : ADReal face_rho_fd;
88 495100 : if (onBoundary(*_face_info))
89 157180 : face_rho_fd = _rho_d(makeCDFace(*_face_info), state) * _f_d(makeCDFace(*_face_info), state);
90 : else
91 416510 : Moose::FV::interpolate(_density_interp_method,
92 : face_rho_fd,
93 416510 : _rho_d(elemArg(), state) * _f_d(elemArg(), state),
94 833020 : _rho_d(neighborArg(), state) * _f_d(neighborArg(), state),
95 416510 : *_face_info,
96 : true);
97 :
98 495100 : if (populate_a_coeffs)
99 : {
100 495100 : if (_face_type == FaceInfo::VarFaceNeighbors::ELEM ||
101 : _face_type == FaceInfo::VarFaceNeighbors::BOTH)
102 : {
103 495100 : const auto dof_number = _face_info->elem().dof_number(_sys.number(), _var.number(), 0);
104 495100 : if (_index == 0)
105 495100 : _ae = (uslipdotn * _u_slip(elemArg(), state)).derivatives()[dof_number];
106 247550 : else if (_index == 1)
107 495100 : _ae = (uslipdotn * (*_v_slip)(elemArg(), state)).derivatives()[dof_number];
108 : else
109 0 : _ae = (uslipdotn * (*_w_slip)(elemArg(), state)).derivatives()[dof_number];
110 495100 : _ae *= -face_rho_fd;
111 : }
112 495100 : if (_face_type == FaceInfo::VarFaceNeighbors::NEIGHBOR ||
113 : _face_type == FaceInfo::VarFaceNeighbors::BOTH)
114 : {
115 416510 : const auto dof_number = _face_info->neighbor().dof_number(_sys.number(), _var.number(), 0);
116 416510 : if (_index == 0)
117 416510 : _an = (uslipdotn * _u_slip(neighborArg(), state)).derivatives()[dof_number];
118 208255 : else if (_index == 1)
119 416510 : _an = (uslipdotn * (*_v_slip)(neighborArg(), state)).derivatives()[dof_number];
120 : else
121 0 : _an = (uslipdotn * (*_w_slip)(neighborArg(), state)).derivatives()[dof_number];
122 416510 : _an *= face_rho_fd;
123 : }
124 : }
125 :
126 990200 : return -face_rho_fd * uslipdotn * u_slip_vel_vec(_index);
127 : }
128 :
129 : void
130 547490 : WCNSFV2PMomentumDriftFlux::gatherRCData(const FaceInfo & fi)
131 : {
132 547490 : if (skipForBoundary(fi))
133 : return;
134 :
135 495100 : _face_info = &fi;
136 495100 : _normal = fi.normal();
137 495100 : _face_type = fi.faceType(std::make_pair(_var.number(), _var.sys().number()));
138 :
139 990200 : addResidualAndJacobian(computeStrongResidual(true) * (fi.faceArea() * fi.faceCoord()));
140 :
141 495100 : if (_face_type == FaceInfo::VarFaceNeighbors::ELEM ||
142 : _face_type == FaceInfo::VarFaceNeighbors::BOTH)
143 990200 : _rc_uo.addToA(&fi.elem(), _index, _ae * (fi.faceArea() * fi.faceCoord()));
144 495100 : if (_face_type == FaceInfo::VarFaceNeighbors::NEIGHBOR ||
145 : _face_type == FaceInfo::VarFaceNeighbors::BOTH)
146 1249530 : _rc_uo.addToA(fi.neighborPtr(), _index, _an * (fi.faceArea() * fi.faceCoord()));
147 : }
148 :
149 : ADReal
150 0 : WCNSFV2PMomentumDriftFlux::computeSegregatedContribution()
151 : {
152 0 : return computeStrongResidual(false);
153 : }
|
