43 #ifndef __Panzer_GatherSolution_Epetra_impl_hpp__
44 #define __Panzer_GatherSolution_Epetra_impl_hpp__
53 #include "Epetra_Vector.h"
65 #include "Teuchos_Assert.hpp"
68 #include "Thyra_SpmdVectorBase.hpp"
75 template<
typename TRAITS,
typename LO,
typename GO>
81 globalIndexer_(indexer),
82 hasTangentFields_(false)
91 using vvstring = std::vector<std::vector<std::string>>;
107 MDField<ScalarT, Cell, NODE>(names[fd], basis->functional);
108 this->addEvaluatedField(gatherFields_[fd]);
112 if (tangentFieldNames.size() > 0)
115 hasTangentFields_ =
true;
116 tangentFields_.resize(numFields);
119 int numTangentFields(tangentFieldNames[fd].size());
120 tangentFields_[fd].resize(numTangentFields);
121 for (
int i(0); i < numTangentFields; ++i)
123 tangentFields_[fd][i] =
124 MDField<const ScalarT, Cell, NODE>(tangentFieldNames[fd][i],
126 this->addDependentField(tangentFields_[fd][i]);
132 string firstName(
"<none>");
134 firstName = names[0];
135 string n(
"GatherSolution (Epetra): " + firstName +
" (Residual)");
144 template<
typename TRAITS,
typename LO,
typename GO>
148 typename TRAITS::SetupData ,
151 using std::logic_error;
160 const string& fieldName(indexerNames_[fd]);
161 fieldIds_[fd] = globalIndexer_->getFieldNum(fieldName);
165 "GatherSolution_Epetra<Residual>: Could not find field \"" +
166 fieldName +
"\" in the global indexer. ")
168 indexerNames_.clear();
176 template<
typename TRAITS,
typename LO,
typename GO>
180 typename TRAITS::PreEvalData d)
184 using Teuchos::rcp_dynamic_cast;
193 string post(useTimeDerivativeSolutionVector_ ?
" - Xdot" :
" - X");
194 if (d.gedc->containsDataObject(globalDataKey_ + post))
196 ged = d.gedc->getDataObject(globalDataKey_ + post);
197 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
202 ged = d.gedc->getDataObject(globalDataKey_);
205 auto epetraContainer = rcp_dynamic_cast<ELOC>(ged);
206 auto locPair = rcp_dynamic_cast<LPGED>(ged);
207 if (not locPair.is_null())
209 RCP<LOC> loc = locPair->getGhostedLOC();
210 epetraContainer = rcp_dynamic_cast<ELOC>(loc);
212 if (not epetraContainer.is_null())
214 if (useTimeDerivativeSolutionVector_)
215 x_ = epetraContainer->get_dxdt();
217 x_ = epetraContainer->get_x();
224 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
232 template<
typename TRAITS,
typename LO,
typename GO>
236 typename TRAITS::EvalData workset)
243 using Teuchos::ptrFromRef;
245 using Teuchos::rcp_dynamic_cast;
246 using Thyra::SpmdVectorBase;
249 string blockId(this->wda(workset).block_id);
250 const vector<size_t>& localCellIds = this->wda(workset).cell_local_ids;
251 int numCells(localCellIds.size()),
numFields(gatherFields_.size());
257 auto LIDs = globalIndexer_->getLIDs();
258 auto LIDs_h = Kokkos::create_mirror_view(LIDs);
259 Kokkos::deep_copy(LIDs_h, LIDs);
261 for (
int fieldInd(0); fieldInd <
numFields; ++fieldInd)
263 MDField<ScalarT, Cell, NODE>&
field = gatherFields_[fieldInd];
264 auto field_h = Kokkos::create_mirror_view(field.get_static_view());
265 int fieldNum(fieldIds_[fieldInd]);
266 const vector<int>& elmtOffset =
267 globalIndexer_->getGIDFieldOffsets(blockId, fieldNum);
268 int numBases(elmtOffset.size());
270 for (
int cell(0); cell < numCells; ++cell)
272 size_t cellLocalId(localCellIds[cell]);
274 for (
int basis(0); basis < numBases; ++basis)
276 int offset(elmtOffset[basis]), lid(LIDs_h(cellLocalId, offset));
278 field_h(cell, basis) = (*xEvRoGed_)[lid];
280 field_h(cell, basis) = (*x_)[lid];
283 Kokkos::deep_copy(field.get_static_view(), field_h);
293 template<
typename TRAITS,
typename LO,
typename GO>
299 globalIndexer_(indexer),
300 hasTangentFields_(false)
309 using vvstring = std::vector<std::vector<std::string>>;
325 MDField<ScalarT, Cell, NODE>(names[fd], basis->functional);
326 this->addEvaluatedField(gatherFields_[fd]);
330 if (tangentFieldNames.size() > 0)
333 hasTangentFields_ =
true;
334 tangentFields_.resize(numFields);
337 int numTangentFields(tangentFieldNames[fd].size());
338 tangentFields_[fd].resize(numTangentFields);
339 for (
int i(0); i < numTangentFields; ++i)
341 tangentFields_[fd][i] =
342 MDField<const ScalarT, Cell, NODE>(tangentFieldNames[fd][i],
344 this->addDependentField(tangentFields_[fd][i]);
350 string firstName(
"<none>");
352 firstName = names[0];
353 string n(
"GatherSolution (Epetra): " + firstName +
" (" +
354 print<EvalT>() +
")");
363 template<
typename TRAITS,
typename LO,
typename GO>
367 typename TRAITS::SetupData ,
370 using std::logic_error;
379 const string& fieldName(indexerNames_[fd]);
380 fieldIds_[fd] = globalIndexer_->getFieldNum(fieldName);
384 "GatherSolution_Epetra<Tangent>: Could not find field \"" + fieldName
385 +
"\" in the global indexer. ")
387 indexerNames_.clear();
395 template<
typename TRAITS,
typename LO,
typename GO>
399 typename TRAITS::PreEvalData d)
403 using Teuchos::rcp_dynamic_cast;
412 string post(useTimeDerivativeSolutionVector_ ?
" - Xdot" :
" - X");
413 if (d.gedc->containsDataObject(globalDataKey_ + post))
415 ged = d.gedc->getDataObject(globalDataKey_ + post);
416 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
421 ged = d.gedc->getDataObject(globalDataKey_);
424 auto epetraContainer = rcp_dynamic_cast<ELOC>(ged);
425 auto locPair = rcp_dynamic_cast<LPGED>(ged);
426 if (not locPair.is_null())
428 RCP<LOC> loc = locPair->getGhostedLOC();
429 epetraContainer = rcp_dynamic_cast<ELOC>(loc);
431 if (not epetraContainer.is_null())
433 if (useTimeDerivativeSolutionVector_)
434 x_ = epetraContainer->get_dxdt();
436 x_ = epetraContainer->get_x();
443 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
451 template<
typename TRAITS,
typename LO,
typename GO>
455 typename TRAITS::EvalData workset)
462 using Teuchos::ptrFromRef;
464 using Teuchos::rcp_dynamic_cast;
465 using Thyra::SpmdVectorBase;
468 string blockId(this->wda(workset).block_id);
469 const vector<size_t>& localCellIds = this->wda(workset).cell_local_ids;
470 int numCells(localCellIds.size()),
numFields(gatherFields_.size());
475 auto LIDs = globalIndexer_->getLIDs();
476 auto LIDs_h = Kokkos::create_mirror_view(LIDs);
477 Kokkos::deep_copy(LIDs_h, LIDs);
479 for (
int fieldInd(0); fieldInd <
numFields; ++fieldInd)
481 MDField<ScalarT, Cell, NODE>&
field = gatherFields_[fieldInd];
482 auto field_h = Kokkos::create_mirror_view(field.get_static_view());
483 int fieldNum(fieldIds_[fieldInd]);
484 const vector<int>& elmtOffset =
485 globalIndexer_->getGIDFieldOffsets(blockId, fieldNum);
486 int numBases(elmtOffset.size());
488 for (
int cell(0); cell < numCells; ++cell)
490 size_t cellLocalId(localCellIds[cell]);
492 for (
int basis(0); basis < numBases; ++basis)
494 int offset(elmtOffset[basis]), lid(LIDs_h(cellLocalId, offset));
496 field_h(cell, basis) = (*xEvRoGed_)[lid];
498 field_h(cell, basis) = (*x_)[lid];
503 if (hasTangentFields_) {
505 int numTangentFields(tangentFields_[fieldInd].size());
506 for (
int i(0); i < numTangentFields; ++i){
507 auto tf = Kokkos::create_mirror_view(tangentFields_[fieldInd][i].get_static_view());
508 Kokkos::deep_copy(tf, tangentFields_[fieldInd][i].get_static_view());
510 for (
int cell(0); cell < numCells; ++cell) {
512 int fieldNum(fieldIds_[fieldInd]);
513 const vector<int>& elmtOffset =
514 globalIndexer_->getGIDFieldOffsets(blockId, fieldNum);
515 int numBases(elmtOffset.size());
518 for (
int basis(0); basis < numBases; ++basis){
519 field_h(cell, basis).fastAccessDx(i) =
520 tf(cell, basis).val();
525 Kokkos::deep_copy(field.get_static_view(), field_h);
534 template<
typename TRAITS,
typename LO,
typename GO>
540 globalIndexer_(indexer)
565 MDField<ScalarT, Cell, NODE> f(names[fd], basis->functional);
566 gatherFields_[fd] = f;
567 this->addEvaluatedField(gatherFields_[fd]);
571 string firstName(
"<none>"), n(
"GatherSolution (Epetra");
573 firstName = names[0];
574 if (disableSensitivities_)
575 n +=
", No Sensitivities";
576 n +=
"): " + firstName +
" (Jacobian)";
585 template<
typename TRAITS,
typename LO,
typename GO>
589 typename TRAITS::SetupData ,
592 using std::logic_error;
601 const string& fieldName(indexerNames_[fd]);
602 fieldIds_[fd] = globalIndexer_->getFieldNum(fieldName);
606 "GatherSolution_Epetra<Jacobian>: Could not find field \"" +
607 fieldName +
"\" in the global indexer. ")
609 indexerNames_.clear();
617 template<
typename TRAITS,
typename LO,
typename GO>
621 typename TRAITS::PreEvalData d)
625 using Teuchos::rcp_dynamic_cast;
633 applySensitivities_ =
false;
634 if ((not disableSensitivities_ ) and
635 (d.first_sensitivities_name == sensitivitiesName_))
636 applySensitivities_ =
true;
640 string post(useTimeDerivativeSolutionVector_ ?
" - Xdot" :
" - X");
641 if (d.gedc->containsDataObject(globalDataKey_ + post))
643 ged = d.gedc->getDataObject(globalDataKey_ + post);
644 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
649 ged = d.gedc->getDataObject(globalDataKey_);
652 auto epetraContainer = rcp_dynamic_cast<ELOC>(ged);
653 auto locPair = rcp_dynamic_cast<LPGED>(ged);
654 if (not locPair.is_null())
656 RCP<LOC> loc = locPair->getGhostedLOC();
657 epetraContainer = rcp_dynamic_cast<ELOC>(loc);
659 if (not epetraContainer.is_null())
661 if (useTimeDerivativeSolutionVector_)
662 x_ = epetraContainer->get_dxdt();
664 x_ = epetraContainer->get_x();
671 xEvRoGed_ = rcp_dynamic_cast<EVROGED>(ged,
true);
679 template<
typename TRAITS,
typename LO,
typename GO>
683 typename TRAITS::EvalData workset)
690 using Teuchos::ptrFromRef;
692 using Teuchos::rcp_dynamic_cast;
693 using Thyra::SpmdVectorBase;
696 string blockId(this->wda(workset).block_id);
697 const vector<size_t>& localCellIds = this->wda(workset).cell_local_ids;
698 int numFields(gatherFields_.size()), numCells(localCellIds.size());
702 if (applySensitivities_)
704 if ((useTimeDerivativeSolutionVector_) and (gatherSeedIndex_ < 0))
705 seedValue = workset.alpha;
706 else if (gatherSeedIndex_ < 0)
707 seedValue = workset.beta;
708 else if (not useTimeDerivativeSolutionVector_)
709 seedValue = workset.gather_seeds[gatherSeedIndex_];
717 if (not applySensitivities_)
724 if (this->wda.getDetailsIndex() == 1)
727 dos = globalIndexer_->getElementBlockGIDCount(workset.details(0).block_id);
733 auto LIDs = globalIndexer_->getLIDs();
734 auto LIDs_h = Kokkos::create_mirror_view(LIDs);
735 Kokkos::deep_copy(LIDs_h, LIDs);
737 for (
int fieldInd(0); fieldInd <
numFields; ++fieldInd)
739 MDField<ScalarT, Cell, NODE>&
field = gatherFields_[fieldInd];
740 auto field_h = Kokkos::create_mirror_view(field.get_static_view());
741 int fieldNum(fieldIds_[fieldInd]);
742 const vector<int>& elmtOffset =
743 globalIndexer_->getGIDFieldOffsets(blockId, fieldNum);
744 int numBases(elmtOffset.size());
746 for (
int cell(0); cell < numCells; ++cell)
748 size_t cellLocalId(localCellIds[cell]);
750 for (
int basis(0); basis < numBases; ++basis)
752 int offset(elmtOffset[basis]), lid(LIDs_h(cellLocalId, offset));
754 field_h(cell, basis) = (*xEvRoGed_)[lid];
756 field_h(cell, basis) = (*x_)[lid];
761 if (applySensitivities_) {
762 int fieldNum(fieldIds_[fieldInd]);
763 const vector<int>& elmtOffset =
764 globalIndexer_->getGIDFieldOffsets(blockId, fieldNum);
765 int numBases(elmtOffset.size());
768 for (
int cell(0); cell < numCells; ++cell)
771 for (
int basis(0); basis < numBases; ++basis)
774 int offset(elmtOffset[basis]);
776 field_h(cell, basis).fastAccessDx(dos + offset) = seedValue;
780 Kokkos::deep_copy(field.get_static_view(), field_h);
785 #endif // __Panzer_GatherSolution_Epetra_impl_hpp__
Gathers solution values from the Newton solution vector into the nodal fields of the field manager...
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
This class provides a boundary exchange communication mechanism for vectors.
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...
Description and data layouts associated with a particular basis.
#define TEUCHOS_ASSERT(assertion_test)