Panzer Version of the Day
Loading...
Searching...
No Matches
Panzer_Integrator_CurlBasisDotVector_impl.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Panzer: A partial differential equation assembly
5// engine for strongly coupled complex multiphysics systems
6// Copyright (2011) Sandia Corporation
7//
8// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9// the U.S. Government retains certain rights in this software.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and
39// Eric C. Cyr (eccyr@sandia.gov)
40// ***********************************************************************
41// @HEADER
42
43#ifndef Panzer_Integrator_CurlBasisDotVector_impl_hpp
44#define Panzer_Integrator_CurlBasisDotVector_impl_hpp
45
47//
48// Include Files
49//
51
52// Intrepid2
53#include "Intrepid2_FunctionSpaceTools.hpp"
54
55// Panzer
60
61// Phalanx
62#include "Phalanx_KokkosDeviceTypes.hpp"
63
64namespace panzer
65{
67 //
68 // Main Constructor
69 //
71 template<typename EvalT, typename Traits>
75 const std::string& resName,
76 const std::string& valName,
77 const panzer::BasisIRLayout& basis,
79 const double& multiplier, /* = 1 */
80 const std::vector<std::string>& fmNames /* =
81 std::vector<std::string>() */)
82 :
83 evalStyle_(evalStyle),
84 useDescriptors_(false),
85 multiplier_(multiplier),
86 basisName_(basis.name())
87 {
88 using PHX::View;
89 using panzer::BASIS;
90 using panzer::Cell;
91 using panzer::Dim;
93 using panzer::IP;
95 using PHX::MDField;
96 using std::invalid_argument;
97 using std::logic_error;
98 using std::string;
99 using Teuchos::RCP;
100
101 // Ensure the input makes sense.
102 TEUCHOS_TEST_FOR_EXCEPTION(resName == "", invalid_argument, "Error: " \
103 "Integrator_CurlBasisDotVector called with an empty residual name.")
104 TEUCHOS_TEST_FOR_EXCEPTION(valName == "", invalid_argument, "Error: " \
105 "Integrator_CurlBasisDotVector called with an empty value name.")
106 RCP<const PureBasis> tmpBasis = basis.getBasis();
107 TEUCHOS_TEST_FOR_EXCEPTION(not tmpBasis->isVectorBasis(), logic_error,
108 "Error: Integrator_CurlBasisDotVector: Basis of type \""
109 << tmpBasis->name() << "\" is not a vector basis.")
110 TEUCHOS_TEST_FOR_EXCEPTION(not tmpBasis->requiresOrientations(),
111 logic_error, "Error: Integrator_CurlBasisDotVector: Basis of type \""
112 << tmpBasis->name() << "\" does not require orientations, though it " \
113 "should for its use in this Evaluator.")
114 TEUCHOS_TEST_FOR_EXCEPTION(not tmpBasis->supportsCurl(), logic_error,
115 "Error: Integrator_CurlBasisDotVector: Basis of type \""
116 << tmpBasis->name() << "\" does not support curl.")
117 TEUCHOS_TEST_FOR_EXCEPTION(not ((tmpBasis->dimension() == 2) or
118 (tmpBasis->dimension() == 3)), logic_error,
119 "Error: Integrator_CurlBasisDotVector requires either a two- or " \
120 "three-dimensional basis. The basis \"" << tmpBasis->name()
121 << "\" is neither.")
122
123 // Use a scalar field only if we're dealing with a two-dimensional case.
124 spaceDim_ = tmpBasis->dimension();
125
126 // Create the field for the vector-values quantity we're integrating.
127 if (spaceDim_ == 2)
128 {
129 vector2D_ = MDField<const ScalarT, Cell, IP>(valName, ir.dl_scalar);
130 this->addDependentField(vector2D_);
131 }
132 else // if (spaceDim_ == 3)
133 {
134 vector3D_ = MDField<const ScalarT, Cell, IP, Dim>(valName, ir.dl_vector);
135 this->addDependentField(vector3D_);
136 } // end if spaceDim_ is 2 or 3
137
138 // Create the field that we're either contributing to or evaluating
139 // (storing).
140 field_ = MDField<ScalarT, Cell, BASIS>(resName, basis.functional);
142 this->addContributedField(field_);
143 else // if (evalStyle == EvaluatorStyle::EVALUATES)
144 this->addEvaluatedField(field_);
145
146 // Add the dependent field multipliers, if there are any.
147 int i(0);
148 fieldMults_.resize(fmNames.size());
149 kokkosFieldMults_ = View<Kokkos::View<const ScalarT**, typename PHX::DevLayout<ScalarT>::type, Kokkos::MemoryUnmanaged>*>(
150 "CurlBasisDotVector::KokkosFieldMultipliers", fmNames.size());
151 for (const auto& name : fmNames)
152 {
153 fieldMults_[i++] = MDField<const ScalarT, Cell, IP>(name, ir.dl_scalar);
154 this->addDependentField(fieldMults_[i - 1]);
155 } // end loop over the field multipliers
156
157 // Set the name of this object.
158 string n("Integrator_CurlBasisDotVector (");
160 n += "CONTRIBUTES";
161 else // if (evalStyle == EvaluatorStyle::EVALUATES)
162 n += "EVALUATES";
163 n += "): " + field_.fieldTag().name();
164 this->setName(n);
165 } // end of Main Constructor
166
168 //
169 // ParameterList Constructor
170 //
172 template<typename EvalT, typename Traits>
175 const Teuchos::ParameterList& p)
176 :
179 p.get<std::string>("Residual Name"),
180 p.get<std::string>("Value Name"),
181 (*p.get<Teuchos::RCP<panzer::BasisIRLayout>>("Basis")),
182 (*p.get<Teuchos::RCP<panzer::IntegrationRule>>("IR")),
183 p.get<double>("Multiplier"),
184 p.isType<Teuchos::RCP<const std::vector<std::string>>>
185 ("Field Multipliers") ?
186 (*p.get<Teuchos::RCP<const std::vector<std::string>>>
187 ("Field Multipliers")) : std::vector<std::string>())
188 {
189 using Teuchos::ParameterList;
190 using Teuchos::RCP;
191
192 // Ensure that the input ParameterList didn't contain any bogus entries.
193 RCP<ParameterList> validParams = this->getValidParameters();
194 p.validateParameters(*validParams);
195 } // end of ParameterList Constructor
196
198 //
199 // FieldTag Constructor
200 //
202 template<typename EvalT, typename TRAITS>
206 const PHX::FieldTag& resTag,
207 const PHX::FieldTag& valTag,
208 const panzer::BasisDescriptor& bd,
210 const int& spaceDim, /* = 3 */
211 const double& multiplier, /* = 1 */
212 const std::vector<PHX::FieldTag>& multipliers /* =
213 std::vector<PHX::FieldTag>() */)
214 :
215 evalStyle_(evalStyle),
216 useDescriptors_(true),
217 bd_(bd),
218 id_(id),
219 multiplier_(multiplier),
220 spaceDim_(spaceDim)
221 {
222 using PHX::View;
224 using std::logic_error;
225 using std::string;
226
227 // Ensure the input makes sense.
228 TEUCHOS_TEST_FOR_EXCEPTION(bd_.getType() != "HCurl", logic_error,
229 "Error: Integrator_CurlBasisDotVector: Basis of type \""
230 << bd_.getType() << "\" does not support curl.")
231 TEUCHOS_TEST_FOR_EXCEPTION(not ((spaceDim == 2) or (spaceDim == 3)),
232 logic_error, "Error: Integrator_CurlBasisDotVector works on either " \
233 "two- or three-dimensional problems. You've provided spaceDim = "
234 << spaceDim << ".")
235
236 // Create the field for the vector-valued quantity we're integrating.
237 if (spaceDim_ == 2)
238 {
239 vector2D_ = valTag;
240 this->addDependentField(vector2D_);
241 }
242 else // if (spaceDim_ == 3)
243 {
244 vector3D_ = valTag;
245 this->addDependentField(vector3D_);
246 } // end if spaceDim_ is 2 or 3
247
248 // Create the field that we're either contributing to or evaluating
249 // (storing).
250 field_ = resTag;
252 this->addContributedField(field_);
253 else // if (evalStyle == EvaluatorStyle::EVALUATES)
254 this->addEvaluatedField(field_);
255
256 // Add the dependent field multipliers, if there are any.
257 int i(0);
258 fieldMults_.resize(multipliers.size());
259 kokkosFieldMults_ = View<Kokkos::View<const ScalarT**, typename PHX::DevLayout<ScalarT>::type, Kokkos::MemoryUnmanaged>*>(
260 "CurlBasisDotVector::KokkosFieldMultipliers", multipliers.size());
261 for (const auto& fm : multipliers)
262 {
263 fieldMults_[i++] = fm;
264 this->addDependentField(fieldMults_[i - 1]);
265 } // end loop over the field multipliers
266
267 // Set the name of this object.
268 string n("Integrator_CurlBasisDotVector (");
270 n += "CONTRIBUTES";
271 else // if (evalStyle == EvaluatorStyle::EVALUATES)
272 n += "EVALUATES";
273 n += "): " + field_.fieldTag().name();
274 this->setName(n);
275 } // end of Other Constructor
276
278 //
279 // postRegistrationSetup()
280 //
282 template<typename EvalT, typename Traits>
283 void
286 typename Traits::SetupData sd,
288 {
290 using PHX::MDField;
291 using std::vector;
292
293 // Get the PHX::Views of the field multipliers.
294 auto kokkosFieldMults_h = Kokkos::create_mirror_view(kokkosFieldMults_);
295 for (size_t i(0); i < fieldMults_.size(); ++i)
296 kokkosFieldMults_h(i) = fieldMults_[i].get_static_view();
297 Kokkos::deep_copy(kokkosFieldMults_, kokkosFieldMults_h);
298 // Determine the index in the Workset bases for our particular basis
299 // name.
300 if (not useDescriptors_)
301 basisIndex_ = getBasisIndex(basisName_, (*sd.worksets_)[0], this->wda);
302
303 // Set up the field that will be used to build of the result of this
304 // integration.
306 fm.template getKokkosExtendedDataTypeDimensions<EvalT>(), true);
307 if (spaceDim_ == 2)
308 result2D_ = af.buildStaticArray<ScalarT, Cell, IP>(
309 "Integrator_CurlBasisDotVector: 2-D Result", vector2D_.extent(0),
310 vector2D_.extent(1));
311 else // if (spaceDim_ == 3)
312 result3D_ = af.buildStaticArray<ScalarT, Cell, IP, Dim>(
313 "Integrator_CurlBasisDotVector: 3-D Result", vector3D_.extent(0),
314 vector3D_.extent(1), 3);
315 } // end of postRegistrationSetup()
316
318 //
319 // Anonymous namespace containing classes for performing the integration.
320 //
322 namespace
323 {
335 template<typename ScalarT>
336 class PreMultiply2D
337 {
338 public:
339
344 struct ScalarMultiplierTag
345 {
346 }; // end of struct ScalarMultiplierTag
347
352 struct FieldMultiplierTag
353 {
354 }; // end of struct FieldMultiplierTag
355
367 KOKKOS_INLINE_FUNCTION
368 void operator()(const ScalarMultiplierTag, const unsigned cell) const
369 {
370 int numQP(result.extent(1));
371 for (int qp(0); qp < numQP; ++qp)
372 result(cell, qp) = multiplier * vectorField(cell, qp);
373 } // end of ScalarMultiplierTag operator()()
374
387 KOKKOS_INLINE_FUNCTION
388 void operator()(const FieldMultiplierTag, const unsigned cell) const
389 {
390 int numQP(result.extent(1));
391 for (int qp(0); qp < numQP; ++qp)
392 result(cell, qp) *= fieldMult(cell, qp);
393 } // end of FieldMultiplierTag operator()()
394
399 using execution_space = PHX::Device;
400
405 PHX::MDField<ScalarT, panzer::Cell, panzer::IP> result;
406
412
417 PHX::MDField<const ScalarT, panzer::Cell, panzer::IP> vectorField;
418
423 PHX::MDField<const ScalarT, panzer::Cell, panzer::IP> fieldMult;
424 }; // end of class PreMultiply2D
425
437 template<typename ScalarT>
438 class PreMultiply3D
439 {
440 public:
441
446 struct ScalarMultiplierTag
447 {
448 }; // end of struct ScalarMultiplierTag
449
454 struct FieldMultiplierTag
455 {
456 }; // end of struct FieldMultiplierTag
457
469 KOKKOS_INLINE_FUNCTION
470 void operator()(const ScalarMultiplierTag, const unsigned cell) const
471 {
472 int numQP(result.extent(1)), numDim(result.extent(2));
473 for (int qp(0); qp < numQP; ++qp)
474 for (int dim(0); dim < numDim; ++dim)
475 result(cell, qp, dim) = multiplier * vectorField(cell, qp, dim);
476 } // end of ScalarMultiplierTag operator()()
477
490 KOKKOS_INLINE_FUNCTION
491 void operator()(const FieldMultiplierTag, const unsigned cell) const
492 {
493 int numQP(result.extent(1)), numDim(result.extent(2));
494 for (int qp(0); qp < numQP; ++qp)
495 for (int dim(0); dim < numDim; ++dim)
496 result(cell, qp, dim) *= fieldMult(cell, qp);
497 } // end of FieldMultiplierTag operator()()
498
503 using execution_space = PHX::Device;
504
509 PHX::MDField<ScalarT, panzer::Cell, panzer::IP, panzer::Dim> result;
510
515 double multiplier;
516
521 PHX::MDField<const ScalarT, panzer::Cell, panzer::IP, panzer::Dim>
523
528 PHX::MDField<const ScalarT, panzer::Cell, panzer::IP> fieldMult;
529 }; // end of class PreMultiply3D
530
542 template<typename ScalarT, int spaceDim>
543 class Integrate3D
544 {
545 public:
546
559 KOKKOS_INLINE_FUNCTION
560 void operator()(const unsigned cell) const
561 {
563 int numBases(weightedCurlBasis.extent(1)),
564 numQP(weightedCurlBasis.extent(2));
565 for (int basis(0); basis < numBases; ++basis)
566 {
567 if (evalStyle == EvaluatorStyle::EVALUATES)
568 field(cell, basis) = 0.0;
569 for (int qp(0); qp < numQP; ++qp)
570 for (int dim(0); dim < spaceDim; ++dim)
571 field(cell, basis) += result(cell, qp, dim) *
572 weightedCurlBasis(cell, basis, qp, dim);
573 } // end loop over the basis functions
574 } // end of operator()
575
580 using execution_space = PHX::Device;
581
585 PHX::MDField<ScalarT, panzer::Cell, panzer::IP, panzer::Dim> result;
586
591 PHX::MDField<ScalarT, panzer::Cell, panzer::BASIS> field;
592
596 PHX::MDField<const double, panzer::Cell, panzer::BASIS, panzer::IP,
598
604 }; // end of class Integrate3D
605
617 template<typename ScalarT>
618 class Integrate2D
619 {
620 public:
621
633 KOKKOS_INLINE_FUNCTION
634 void operator()(const unsigned cell) const
635 {
637 int numBases(weightedCurlBasis.extent(1)),
638 numQP(weightedCurlBasis.extent(2));
639 for (int basis(0); basis < numBases; ++basis)
640 {
642 field(cell, basis) = 0.0;
643 for (int qp(0); qp < numQP; ++qp)
644 field(cell, basis) += result(cell, qp) *
645 weightedCurlBasis(cell, basis, qp);
646 } // end loop over the basis functions
647 } // end of operator()
648
653 using execution_space = PHX::Device;
654
658 PHX::MDField<ScalarT, panzer::Cell, panzer::IP> result;
659
664 PHX::MDField<ScalarT, panzer::Cell, panzer::BASIS> field;
665
669 PHX::MDField<const double, panzer::Cell, panzer::BASIS, panzer::IP>
671
677 }; // end of class Integrate2D
678
679 } // end of anonymous namespace
680
682 //
683 // evaluateFields()
684 //
686 template<typename EvalT, typename Traits>
687 void
690 typename Traits::EvalData workset)
691 {
692 using Kokkos::parallel_for;
693 using Kokkos::RangePolicy;
695 using PHX::Device;
696 using PHX::MDField;
697 using std::vector;
698
699 // Grab the basis information.
700 const BasisValues2<double>& bv = useDescriptors_ ?
701 this->wda(workset).getBasisValues(bd_, id_) :
702 *this->wda(workset).bases[basisIndex_];
703
704 // If we're dealing with a two- or three-dimensional problem...
705 if (spaceDim_ == 2)
706 {
707 // Create an object to multiply the integrand by the scalar multiplier
708 // and any field multipliers out in front of the integral.
709 using PreMultiply = PreMultiply2D<ScalarT>;
710 using ScalarMultiplierTag = typename PreMultiply::ScalarMultiplierTag;
711 using FieldMultiplierTag = typename PreMultiply::FieldMultiplierTag;
712 PreMultiply preMultiply;
713 preMultiply.result = result2D_;
714 preMultiply.multiplier = multiplier_;
715 preMultiply.vectorField = vector2D_;
716
717 // Multiply the integrand by the scalar multiplier out in front of the
718 // integral.
719 parallel_for(RangePolicy<Device, ScalarMultiplierTag>(0,
720 workset.num_cells), preMultiply);
721
722 // Multiply the integrand by any field multipliers out in front of the
723 // integral.
724 for (const auto& field : fieldMults_)
725 {
726 preMultiply.fieldMult = field;
727 parallel_for(RangePolicy<Device, FieldMultiplierTag>(0,
728 workset.num_cells), preMultiply);
729 } // end loop over the field multipliers
730
731 // Create an object to do the actual integration and then do it.
732 Integrate2D<ScalarT> integrate;
733 integrate.result = result2D_;
734 integrate.field = field_;
736 integrate.weightedCurlBasis = useDescriptors_ ? bv.getCurl2DVectorBasis(true) : Array(bv.weighted_curl_basis_scalar);
737 integrate.evalStyle = evalStyle_;
738 parallel_for(workset.num_cells, integrate);
739 }
740 else // if (spaceDim_ == 3)
741 {
742 // Create an object to multiply the integrand by the scalar multiplier
743 // and any field multipliers out in front of the integral.
744 using PreMultiply = PreMultiply3D<ScalarT>;
745 using ScalarMultiplierTag = typename PreMultiply::ScalarMultiplierTag;
746 using FieldMultiplierTag = typename PreMultiply::FieldMultiplierTag;
747 PreMultiply preMultiply;
748 preMultiply.result = result3D_;
749 preMultiply.multiplier = multiplier_;
750 preMultiply.vectorField = vector3D_;
751
752 // Multiply the integrand by the scalar multiplier out in front of the
753 // integral.
754 parallel_for(RangePolicy<Device, ScalarMultiplierTag>(0,
755 workset.num_cells), preMultiply);
756
757 // Multiply the integrand by any field multipliers out in front of the
758 // integral.
759 for (const auto& field : fieldMults_)
760 {
761 preMultiply.fieldMult = field;
762 parallel_for(RangePolicy<Device, FieldMultiplierTag>(0,
763 workset.num_cells), preMultiply);
764 } // end loop over the field multipliers
765
766 // Create an object to do the actual integration and then do it.
767 Integrate3D<ScalarT, 3> integrate;
768 integrate.result = result3D_;
769 integrate.field = field_;
771 integrate.weightedCurlBasis = useDescriptors_ ? bv.getCurlVectorBasis(true) : Array(bv.weighted_curl_basis_vector);
772 integrate.evalStyle = evalStyle_;
773 parallel_for(workset.num_cells, integrate);
774 } // end if spaceDim_ is 2 or 3
775 } // end of evaluateFields()
776
778 //
779 // getValidParameters()
780 //
782 template<typename EvalT, typename TRAITS>
783 Teuchos::RCP<Teuchos::ParameterList>
786 {
789 using std::string;
790 using std::vector;
791 using Teuchos::ParameterList;
792 using Teuchos::RCP;
793 using Teuchos::rcp;
794
795 RCP<ParameterList> p = rcp(new ParameterList);
796 p->set<string>("Residual Name", "?");
797 p->set<string>("Value Name", "?");
798 RCP<BasisIRLayout> basis;
799 p->set("Basis", basis);
800 RCP<IntegrationRule> ir;
801 p->set("IR", ir);
802 p->set<double>("Multiplier", 1.0);
803 RCP<const vector<string>> fms;
804 p->set("Field Multipliers", fms);
805 return p;
806 } // end of getValidParameters()
807
808} // end of namespace panzer
809
810#endif // Panzer_Integrator_CurlBasisDotVector_impl_hpp
PHX::MDField< const double, panzer::Cell, panzer::BASIS, panzer::IP, panzer::Dim > weightedCurlBasis
The vector basis information necessary for integration.
PHX::MDField< const ScalarT, panzer::Cell, panzer::IP > vectorField
A field representing the vector-valued function we're integrating ( ).
PHX::MDField< ScalarT, panzer::Cell, panzer::IP > result
A field that will be used to build up the result of the integral we're performing.
panzer::EvaluatorStyle evalStyle
The EvaluatorStyle of the parent Integrator_CurlBasisDotVector object.
double multiplier
The scalar multiplier out in front of the integral ( ).
PHX::MDField< ScalarT, panzer::Cell, panzer::BASIS > field
A field to which we'll contribute, or in which we'll store, the result of computing this integral.
PHX::MDField< const ScalarT, panzer::Cell, panzer::IP > fieldMult
One of the field multipliers ( , , etc.) out in front of the integral.
const std::string & getType() const
Get type of basis.
Teuchos::RCP< PHX::DataLayout > functional
<Cell,Basis>
Teuchos::RCP< const PureBasis > getBasis() const
PHX::MDField< const Scalar, Cell, BASIS, IP > ConstArray_CellBasisIP
Array_CellBasisIPDim weighted_curl_basis_vector
Array_CellBasisIP weighted_curl_basis_scalar
ConstArray_CellBasisIPDim getCurlVectorBasis(const bool weighted, const bool cache=true, const bool force=false) const
Get the curl of a 3D vector basis evaluated at mesh points.
ConstArray_CellBasisIP getBasisValues(const bool weighted, const bool cache=true, const bool force=false) const
Get the basis values evaluated at mesh points.
PHX::MDField< const Scalar, Cell, BASIS, IP, Dim > ConstArray_CellBasisIPDim
ConstArray_CellBasisIP getCurl2DVectorBasis(const bool weighted, const bool cache=true, const bool force=false) const
Get the curl of a 2D vector basis evaluated at mesh points.
PHX::View< Kokkos::View< const ScalarT **, typename PHX::DevLayout< ScalarT >::type, Kokkos::MemoryUnmanaged > * > kokkosFieldMults_
The PHX::View representation of the (possibly empty) list of fields that are multipliers out in front...
PHX::MDField< const ScalarT, panzer::Cell, panzer::IP, panzer::Dim > vector3D_
A field representing the vector-valued function we're integrating ( ) in a three-dimensional problem.
std::vector< PHX::MDField< const ScalarT, panzer::Cell, panzer::IP > > fieldMults_
The (possibly empty) list of fields that are multipliers out in front of the integral ( ,...
PHX::MDField< const ScalarT, panzer::Cell, panzer::IP > vector2D_
A field representing the vector-valued function we're integrating ( ) in a two-dimensional problem.
Teuchos::RCP< Teuchos::ParameterList > getValidParameters() const
Get Valid Parameters.
void postRegistrationSetup(typename Traits::SetupData sd, PHX::FieldManager< Traits > &fm)
Post-Registration Setup.
panzer::BasisDescriptor bd_
The BasisDescriptor for the basis to use.
int spaceDim_
The spatial dimension of the vector-valued function we're integrating, either 2 or 3.
PHX::MDField< ScalarT, panzer::Cell, panzer::BASIS > field_
A field to which we'll contribute, or in which we'll store, the result of computing this integral.
void evaluateFields(typename Traits::EvalData d)
Evaluate Fields.
Integrator_CurlBasisDotVector(const panzer::EvaluatorStyle &evalStyle, const std::string &resName, const std::string &valName, const panzer::BasisIRLayout &basis, const panzer::IntegrationRule &ir, const double &multiplier=1, const std::vector< std::string > &fmNames=std::vector< std::string >())
Main Constructor.
PHX::MDField< Scalar, T0 > buildStaticArray(const std::string &str, int d0) const
Teuchos::RCP< PHX::DataLayout > dl_vector
Data layout for vector fields.
Teuchos::RCP< PHX::DataLayout > dl_scalar
Data layout for scalar fields.
Description and data layouts associated with a particular basis.
int num_cells
DEPRECATED - use: numCells()
std::vector< std::string >::size_type getBasisIndex(std::string basis_name, const panzer::Workset &workset, WorksetDetailsAccessor &wda)
Returns the index in the workset bases for a particular BasisIRLayout name.
EvaluatorStyle
An indication of how an Evaluator will behave.
Teuchos::RCP< const std::vector< panzer::Workset > > worksets_