Panzer  Version of the Day
Panzer_DOF_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_DOF_IMPL_HPP
44 #define PANZER_DOF_IMPL_HPP
45 
46 #include <algorithm>
47 #include "Panzer_IntegrationRule.hpp"
48 #include "Panzer_BasisIRLayout.hpp"
49 #include "Panzer_Workset_Utilities.hpp"
50 #include "Panzer_CommonArrayFactories.hpp"
51 #include "Panzer_DOF_Functors.hpp"
52 
53 #include "Intrepid2_FunctionSpaceTools.hpp"
54 
55 namespace panzer {
56 
57 //**********************************************************************
58 //* DOF evaluator
59 //**********************************************************************
60 
61 //**********************************************************************
62 // MOST EVALUATION TYPES
63 //**********************************************************************
64 
65 //**********************************************************************
66 template<typename EvalT, typename TRAITS>
67 DOF<EvalT, TRAITS>::
68 DOF(const Teuchos::ParameterList & p) :
69  use_descriptors_(false),
70  dof_basis( p.get<std::string>("Name"),
71  p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->functional),
72  basis_name(p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->name())
73 {
74  Teuchos::RCP<const PureBasis> basis
75  = p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->getBasis();
76  is_vector_basis = basis->isVectorBasis();
77 
78  // swap between scalar basis value, or vector basis value
79  if(basis->isScalarBasis()) {
80  dof_ip_scalar = PHX::MDField<ScalarT,Cell,Point>(
81  p.get<std::string>("Name"),
82  p.get< Teuchos::RCP<panzer::IntegrationRule> >("IR")->dl_scalar);
83  this->addEvaluatedField(dof_ip_scalar);
84  }
85  else if(basis->isVectorBasis()) {
86  dof_ip_vector = PHX::MDField<ScalarT,Cell,Point,Dim>(
87  p.get<std::string>("Name"),
88  p.get< Teuchos::RCP<panzer::IntegrationRule> >("IR")->dl_vector);
89  this->addEvaluatedField(dof_ip_vector);
90  }
91  else
92  { TEUCHOS_ASSERT(false); }
93 
94  this->addDependentField(dof_basis);
95 
96  std::string n = "DOF: " + dof_basis.fieldTag().name() + " ("+PHX::typeAsString<EvalT>()+")";
97  this->setName(n);
98 }
99 
100 //**********************************************************************
101 template<typename EvalT, typename TRAITS>
102 DOF<EvalT, TRAITS>::
103 DOF(const PHX::FieldTag & input,
104  const PHX::FieldTag & output,
105  const panzer::BasisDescriptor & bd,
106  const panzer::IntegrationDescriptor & id)
107  : use_descriptors_(true)
108  , bd_(bd)
109  , id_(id)
110  , dof_basis(input)
111 {
112  TEUCHOS_ASSERT(bd.getType()=="HGrad" || bd.getType()=="HCurl" ||
113  bd.getType()=="HDiv" || bd.getType()=="Const")
114 
115  is_vector_basis = (bd.getType()=="HCurl" || bd.getType()=="HDiv");
116 
117  // swap between scalar basis value, or vector basis value
118  if(not is_vector_basis) {
119  dof_ip_scalar = output;
120  this->addEvaluatedField(dof_ip_scalar);
121  }
122  else {
123  dof_ip_vector = output;
124  this->addEvaluatedField(dof_ip_vector);
125  }
126 
127  this->addDependentField(dof_basis);
128 
129  std::string n = "DOF: " + dof_basis.fieldTag().name() + " ("+PHX::typeAsString<EvalT>()+")";
130  this->setName(n);
131 }
132 
133 //**********************************************************************
134 template<typename EvalT, typename TRAITS>
135 void DOF<EvalT, TRAITS>::
136 postRegistrationSetup(typename TRAITS::SetupData sd,
137  PHX::FieldManager<TRAITS>& fm)
138 {
139  this->utils.setFieldData(dof_basis,fm);
140  if(is_vector_basis)
141  this->utils.setFieldData(dof_ip_vector,fm);
142  else
143  this->utils.setFieldData(dof_ip_scalar,fm);
144 
145  // descriptors don't access the basis values in the same way
146  if(not use_descriptors_)
147  basis_index = panzer::getBasisIndex(basis_name, (*sd.worksets_)[0], this->wda);
148 }
149 
150 //**********************************************************************
151 template<typename EvalT, typename TRAITS>
152 void DOF<EvalT, TRAITS>::
153 evaluateFields(typename TRAITS::EvalData workset)
154 {
155  const panzer::BasisValues2<double> & basisValues = use_descriptors_ ? this->wda(workset).getBasisValues(bd_,id_)
156  : *this->wda(workset).bases[basis_index];
157 
158  if(is_vector_basis) {
159  int spaceDim = basisValues.basis_vector.extent(3);
160  if(spaceDim==3) {
161  dof_functors::EvaluateDOFWithSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,3> functor(dof_basis,dof_ip_vector,basisValues.basis_vector);
162  Kokkos::parallel_for(workset.num_cells,functor);
163  }
164  else {
165  dof_functors::EvaluateDOFWithSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,2> functor(dof_basis,dof_ip_vector,basisValues.basis_vector);
166  Kokkos::parallel_for(workset.num_cells,functor);
167  }
168  }
169  else {
170  dof_functors::EvaluateDOFWithSens_Scalar<ScalarT,typename BasisValues2<double>::Array_CellBasisIP> functor(dof_basis,dof_ip_scalar,basisValues.basis_scalar);
171  Kokkos::parallel_for(workset.num_cells,functor);
172  }
173 }
174 
175 //**********************************************************************
176 
177 //**********************************************************************
178 // JACOBIAN EVALUATION TYPES
179 //**********************************************************************
180 
181 //**********************************************************************
182 template<typename TRAITS>
183 DOF<typename TRAITS::Jacobian, TRAITS>::
184 DOF(const Teuchos::ParameterList & p) :
185  use_descriptors_(false),
186  dof_basis( p.get<std::string>("Name"),
187  p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->functional),
188  basis_name(p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->name())
189 {
190  Teuchos::RCP<const PureBasis> basis
191  = p.get< Teuchos::RCP<BasisIRLayout> >("Basis")->getBasis();
192  is_vector_basis = basis->isVectorBasis();
193 
194  if(p.isType<Teuchos::RCP<const std::vector<int> > >("Jacobian Offsets Vector")) {
195  const std::vector<int> & offsets = *p.get<Teuchos::RCP<const std::vector<int> > >("Jacobian Offsets Vector");
196 
197  // allocate and copy offsets vector to Kokkos array
198  offsets_array = Kokkos::View<int*,PHX::Device>("offsets",offsets.size());
199  for(std::size_t i=0;i<offsets.size();i++)
200  offsets_array(i) = offsets[i];
201 
202  accelerate_jacobian_enabled = true; // short cut for identity matrix
203 
204  // get the sensitivities name that is valid for accelerated jacobians
205  sensitivities_name = true;
206  if (p.isType<std::string>("Sensitivities Name"))
207  sensitivities_name = p.get<std::string>("Sensitivities Name");
208  }
209  else
210  accelerate_jacobian_enabled = false; // don't short cut for identity matrix
211 
212  // swap between scalar basis value, or vector basis value
213  if(basis->isScalarBasis()) {
214  dof_ip_scalar = PHX::MDField<ScalarT,Cell,Point>(
215  p.get<std::string>("Name"),
216  p.get< Teuchos::RCP<panzer::IntegrationRule> >("IR")->dl_scalar);
217  this->addEvaluatedField(dof_ip_scalar);
218  }
219  else if(basis->isVectorBasis()) {
220  dof_ip_vector = PHX::MDField<ScalarT,Cell,Point,Dim>(
221  p.get<std::string>("Name"),
222  p.get< Teuchos::RCP<panzer::IntegrationRule> >("IR")->dl_vector);
223  this->addEvaluatedField(dof_ip_vector);
224  }
225  else
226  { TEUCHOS_ASSERT(false); }
227 
228  this->addDependentField(dof_basis);
229 
230  std::string n = "DOF: " + dof_basis.fieldTag().name()
231  + ( accelerate_jacobian_enabled ? " accel_jac " : "slow_jac" )
232  + " ("+PHX::typeAsString<panzer::Traits::Jacobian>()+")";
233  this->setName(n);
234 }
235 
236 //**********************************************************************
237 template<typename TRAITS>
238 DOF<typename TRAITS::Jacobian, TRAITS>::
239 DOF(const PHX::FieldTag & input,
240  const PHX::FieldTag & output,
241  const panzer::BasisDescriptor & bd,
242  const panzer::IntegrationDescriptor & id)
243  : use_descriptors_(true)
244  , bd_(bd)
245  , id_(id)
246  , dof_basis(input)
247 {
248  TEUCHOS_ASSERT(bd.getType()=="HGrad" || bd.getType()=="HCurl" ||
249  bd.getType()=="HDiv" || bd.getType()=="Const")
250 
251  accelerate_jacobian_enabled = false; // don't short cut for identity matrix
252 
253  is_vector_basis = (bd.getType()=="HCurl" || bd.getType()=="HDiv");
254 
255  // swap between scalar basis value, or vector basis value
256  if(not is_vector_basis) {
257  dof_ip_scalar = output;
258  this->addEvaluatedField(dof_ip_scalar);
259  }
260  else {
261  dof_ip_vector = output;
262  this->addEvaluatedField(dof_ip_vector);
263  }
264 
265  this->addDependentField(dof_basis);
266 
267  std::string n = "DOF: " + dof_basis.fieldTag().name() + " slow_jac(descriptor) ("+PHX::typeAsString<typename TRAITS::Jacobian>()+")";
268  this->setName(n);
269 }
270 
271 //**********************************************************************
272 template<typename TRAITS>
273 void DOF<typename TRAITS::Jacobian, TRAITS>::
274 postRegistrationSetup(typename TRAITS::SetupData sd,
275  PHX::FieldManager<TRAITS>& fm)
276 {
277  this->utils.setFieldData(dof_basis,fm);
278  if(is_vector_basis)
279  this->utils.setFieldData(dof_ip_vector,fm);
280  else
281  this->utils.setFieldData(dof_ip_scalar,fm);
282 
283  // descriptors don't access the basis values in the same way
284  if(not use_descriptors_)
285  basis_index = panzer::getBasisIndex(basis_name, (*sd.worksets_)[0], this->wda);
286 }
287 
288 // **********************************************************************
289 template<typename TRAITS>
290 void DOF<typename TRAITS::Jacobian, TRAITS>::
291 preEvaluate(typename TRAITS::PreEvalData d)
292 {
293  // if sensitivities were requrested for this field enable accelerated
294  // jacobian calculations
295  accelerate_jacobian = false;
296  if(accelerate_jacobian_enabled && d.first_sensitivities_name==sensitivities_name) {
297  accelerate_jacobian = true;
298  }
299 }
300 
301 //**********************************************************************
302 template<typename TRAITS>
303 void DOF<typename TRAITS::Jacobian, TRAITS>::
304 evaluateFields(typename TRAITS::EvalData workset)
305 {
306  const panzer::BasisValues2<double> & basisValues = use_descriptors_ ? this->wda(workset).getBasisValues(bd_,id_)
307  : *this->wda(workset).bases[basis_index];
308 
309  if(is_vector_basis) {
310  if(accelerate_jacobian) {
311  int spaceDim = basisValues.basis_vector.extent(3);
312  if(spaceDim==3) {
313  dof_functors::EvaluateDOFFastSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,3> functor(dof_basis,dof_ip_vector,offsets_array,basisValues.basis_vector);
314  Kokkos::parallel_for(workset.num_cells,functor);
315  }
316  else {
317  dof_functors::EvaluateDOFFastSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,2> functor(dof_basis,dof_ip_vector,offsets_array,basisValues.basis_vector);
318  Kokkos::parallel_for(workset.num_cells,functor);
319  }
320  }
321  else {
322  int spaceDim = basisValues.basis_vector.extent(3);
323  if(spaceDim==3) {
324  dof_functors::EvaluateDOFWithSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,3> functor(dof_basis,dof_ip_vector,basisValues.basis_vector);
325  Kokkos::parallel_for(workset.num_cells,functor);
326  }
327  else {
328  dof_functors::EvaluateDOFWithSens_Vector<ScalarT,typename BasisValues2<double>::Array_CellBasisIPDim,2> functor(dof_basis,dof_ip_vector,basisValues.basis_vector);
329  Kokkos::parallel_for(workset.num_cells,functor);
330  }
331  }
332  }
333  else {
334  if(accelerate_jacobian) {
335  dof_functors::EvaluateDOFFastSens_Scalar<ScalarT,typename BasisValues2<double>::Array_CellBasisIP> functor(dof_basis,dof_ip_scalar,offsets_array,basisValues.basis_scalar);
336  Kokkos::parallel_for(workset.num_cells,functor);
337  }
338  else {
339  dof_functors::EvaluateDOFWithSens_Scalar<ScalarT,typename BasisValues2<double>::Array_CellBasisIP> functor(dof_basis,dof_ip_scalar,basisValues.basis_scalar);
340  Kokkos::parallel_for(workset.num_cells,functor);
341  }
342  }
343 }
344 
345 }
346 
347 #endif
panzer::DOF::is_vector_basis
bool is_vector_basis
Definition: Panzer_DOF.hpp:95
panzer::dof_functors::EvaluateDOFWithSens_Vector
Definition: Panzer_DOF_Functors.hpp:57
panzer::DOF::evaluateFields
void evaluateFields(typename TRAITS::EvalData d)
Definition: Panzer_DOF_impl.hpp:153
panzer::DOF
Interpolates basis DOF values to IP DOF values.
Definition: Panzer_DOF.hpp:56
panzer::PointRule::dl_scalar
Teuchos::RCP< PHX::DataLayout > dl_scalar
Data layout for scalar fields.
Definition: Panzer_PointRule.hpp:112
panzer::IntegrationDescriptor
Definition: Panzer_IntegrationDescriptor.hpp:51
panzer::DOF::basis_name
std::string basis_name
Definition: Panzer_DOF.hpp:92
panzer::DOF::dof_basis
PHX::MDField< const ScalarT, Cell, Point > dof_basis
Definition: Panzer_DOF.hpp:87
Panzer_BasisIRLayout.hpp
panzer::dof_functors::EvaluateDOFFastSens_Scalar
Definition: Panzer_DOF_Functors.hpp:172
Teuchos::ParameterList::get
T & get(const std::string &name, T def_value)
TEUCHOS_ASSERT
#define TEUCHOS_ASSERT(assertion_test)
panzer::dof_functors::EvaluateDOFFastSens_Vector
Definition: Panzer_DOF_Functors.hpp:126
Panzer_Workset_Utilities.hpp
panzer::DOF::dof_ip_vector
PHX::MDField< ScalarT, Cell, Point, Dim > dof_ip_vector
Definition: Panzer_DOF.hpp:90
panzer::DOF::postRegistrationSetup
void postRegistrationSetup(typename TRAITS::SetupData d, PHX::FieldManager< TRAITS > &fm)
Definition: Panzer_DOF_impl.hpp:136
Teuchos::RCP
panzer::getBasisIndex
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.
Definition: Panzer_Workset_Utilities.cpp:80
Teuchos::ParameterList::isType
bool isType(const std::string &name) const
panzer::BasisDescriptor
Definition: Panzer_BasisDescriptor.hpp:53
panzer::BasisValues2
Definition: Panzer_BasisValues2.hpp:63
panzer::PointRule::dl_vector
Teuchos::RCP< PHX::DataLayout > dl_vector
Data layout for vector fields.
Definition: Panzer_PointRule.hpp:114
panzer::DOF::id_
panzer::IntegrationDescriptor id_
Definition: Panzer_DOF.hpp:85
panzer::DOF::use_descriptors_
bool use_descriptors_
Definition: Panzer_DOF.hpp:83
panzer::DOF::basis_index
std::size_t basis_index
Definition: Panzer_DOF.hpp:93
panzer::BasisValues2::basis_scalar
Array_CellBasisIP basis_scalar
Definition: Panzer_BasisValues2.hpp:123
panzer::dof_functors::EvaluateDOFWithSens_Scalar
Definition: Panzer_DOF_Functors.hpp:92
Panzer_DOF_Functors.hpp
std
Definition: Panzer_BasisDescriptor.hpp:117
panzer::DOF::bd_
panzer::BasisDescriptor bd_
Definition: Panzer_DOF.hpp:84
panzer::DOF::dof_ip_scalar
PHX::MDField< ScalarT, Cell, Point > dof_ip_scalar
Definition: Panzer_DOF.hpp:89
panzer::BasisValues2::basis_vector
Array_CellBasisIPDim basis_vector
Definition: Panzer_BasisValues2.hpp:126
panzer
Definition: Panzer_BasisValues_Evaluator_decl.hpp:54
Teuchos::ParameterList
panzer::EvaluatorWithBaseImpl::wda
WorksetDetailsAccessor wda
Definition: Panzer_Evaluator_WithBaseImpl.hpp:63
panzer::DOF::DOF
DOF(const Teuchos::ParameterList &p)
Definition: Panzer_DOF_impl.hpp:68
panzer::BasisDescriptor::getType
const std::string & getType() const
Get type of basis.
Definition: Panzer_BasisDescriptor.hpp:78
Teuchos
PHX::FieldManager
Definition: Panzer_BCStrategy_Base.hpp:53
Panzer_CommonArrayFactories.hpp
Panzer_IntegrationRule.hpp
panzer::BasisIRLayout
Definition: Panzer_BasisIRLayout.hpp:71
offsets
Kokkos::View< const int *, PHX::Device > offsets
Definition: Panzer_DOFCurl_impl.hpp:180
Generated by   doxygen 1.8.16