11 #ifndef PANZER_STK_MODEL_EVALUATOR_FACTORY_T_HPP
12 #define PANZER_STK_MODEL_EVALUATOR_FACTORY_T_HPP
14 #include "Thyra_ModelEvaluator.hpp"
15 #include "Teuchos_Assert.hpp"
18 #include "Teuchos_AbstractFactoryStd.hpp"
20 #include "PanzerAdaptersSTK_config.hpp"
31 #include "Panzer_TpetraLinearObjFactory.hpp"
57 #ifdef PANZER_HAVE_TEMPUS
63 #include "Panzer_ClosureModel_Factory_Composite.hpp"
74 #include "Piro_ConfigDefs.hpp"
75 #include "Piro_NOXSolver.hpp"
76 #include "Piro_LOCASolver.hpp"
77 #ifdef PANZER_HAVE_TEMPUS
78 #include "Piro_TempusSolverForwardOnly.hpp"
81 #ifdef PANZER_HAVE_EPETRA_STACK
83 #include "Thyra_EpetraModelEvaluator.hpp"
90 namespace panzer_stk {
92 template<
typename ScalarT>
99 if(!paramList->
sublist(
"Initial Conditions").
isType<
bool>(
"Zero Initial Conditions"))
100 paramList->
sublist(
"Initial Conditions").
set<
bool>(
"Zero Initial Conditions",
false);
103 getValidParameters()->sublist(
"Initial Conditions").sublist(
"Vector File"));
105 this->setMyParamList(paramList);
108 template<
typename ScalarT>
111 m_stratimikos_params = paramList;
114 template<
typename ScalarT>
125 pl->
set<
bool>(
"Use Discrete Adjoint",
false);
129 pl->
sublist(
"Initial Conditions").
set<
bool>(
"Zero Initial Conditions",
false);
133 pl->
sublist(
"Initial Conditions").
sublist(
"Vector File").
set<
bool>(
"Enabled",
false);
136 pl->
sublist(
"Output").
set(
"File Name",
"panzer.exo");
137 pl->
sublist(
"Output").
set(
"Write to Exodus",
true);
147 p.
set<
int>(
"Workset Size", 1);
148 p.
set<
int>(
"Default Integration Order",-1);
149 p.
set<std::string>(
"Field Order",
"");
150 p.
set<std::string>(
"Auxiliary Field Order",
"");
151 p.
set<
bool>(
"Use DOFManager FEI",
false);
152 p.
set<
bool>(
"Load Balance DOFs",
false);
153 p.
set<
bool>(
"Use Tpetra",
false);
154 p.
set<
bool>(
"Use Epetra ME",
true);
155 p.
set<
bool>(
"Lump Explicit Mass",
false);
156 p.
set<
bool>(
"Constant Mass Matrix",
true);
157 p.
set<
bool>(
"Apply Mass Matrix Inverse in Explicit Evaluator",
true);
158 p.
set<
bool>(
"Use Conservative IMEX",
false);
159 p.
set<
bool>(
"Compute Real Time Derivative",
false);
160 p.
set<
bool>(
"Use Time Derivative in Explicit Model",
false);
161 p.
set<
bool>(
"Compute Time Derivative at Time Step",
false);
165 p.
set<std::string>(
"Excluded Blocks",
"");
183 bool hasInterfaceCondition(
const std::vector<panzer::BC>& bcs)
185 for (std::vector<panzer::BC>::const_iterator bcit = bcs.begin(); bcit != bcs.end(); ++bcit)
195 Teuchos::rcp_dynamic_cast<STKConnManager>(conn_mgr);
197 "There are interface conditions, but the connection manager"
198 " does not support the necessary connections.");
202 void buildInterfaceConnections(
const std::vector<panzer::BC>& bcs,
206 for (std::vector<panzer::BC>::const_iterator bcit = bcs.begin(); bcit != bcs.end(); ++bcit)
216 if ( ! sidesets.empty()) {
217 std::stringstream ss;
219 for (std::size_t i = 0; i < sidesets.size(); ++i)
220 ss <<
" " << sidesets[i];
221 ss <<
" did not yield associations, but these sidesets correspond to BCT_Interface BCs.";
227 template<
typename ScalarT>
233 bool meConstructionOn)
236 "ParameterList must be set before objects can be built!");
244 m_global_data = global_data;
270 std::size_t workset_size = Teuchos::as<std::size_t>(assembly_params.
get<
int>(
"Workset Size"));
271 std::string field_order = assembly_params.
get<std::string>(
"Field Order");
273 bool use_dofmanager_fei = assembly_params.
get<
bool>(
"Use DOFManager FEI");
274 bool use_load_balance = assembly_params.
get<
bool>(
"Load Balance DOFs");
275 bool useTpetra = assembly_params.
get<
bool>(
"Use Tpetra");
276 bool useThyraME = !assembly_params.
get<
bool>(
"Use Epetra ME");
280 bool is_transient = (solncntl_params.
get<std::string>(
"Piro Solver") ==
"Tempus") ?
true :
false;
282 if (solncntl_params.
get<std::string>(
"Piro Solver") ==
"NOX") {
283 if (solncntl_params.
sublist(
"NOX").
get<std::string>(
"Nonlinear Solver") ==
"Pseudo-Transient")
288 if (solncntl_params.
get<std::string>(
"Piro Solver") ==
"LOCA") {
289 if (solncntl_params.
sublist(
"LOCA").
sublist(
"Stepper").
get<
bool>(
"Compute Eigenvalues"))
292 m_is_transient = is_transient;
294 useDiscreteAdjoint = p.
get<
bool>(
"Use Discrete Adjoint");
315 m_eqset_factory = eqset_factory;
320 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
323 std::map<std::string,std::string> block_ids_to_physics_ids;
327 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
328 for(std::map<std::string,std::string>::const_iterator itr=block_ids_to_physics_ids.begin();
329 itr!=block_ids_to_physics_ids.end();++itr) {
330 block_ids_to_cell_topo[itr->first] = mesh->
getCellTopology(itr->first);
331 TEUCHOS_ASSERT(block_ids_to_cell_topo[itr->first]!=Teuchos::null);
336 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
337 block_ids_to_cell_topo,
339 assembly_params.
get<
int>(
"Default Integration Order"),
345 m_physics_blocks = physicsBlocks;
350 addUserFieldsToMesh(*mesh,output_list);
357 this->finalizeMeshConstruction(*mesh_factory,physicsBlocks,*mpi_comm,*mesh);
359 fout <<
"*****************************************\n\n";
360 fout <<
"Element block exception, could not finalize the mesh, printing block and sideset information:\n";
368 fout <<
"*****************************************\n\n";
369 fout <<
"Sideset exception, could not finalize the mesh, printing block and sideset information:\n";
379 if(p.
sublist(
"Output").
get<
bool>(
"Write to Exodus"))
384 p.
sublist(
"User Data").
set(
"panzer_stk::STK_Interface",mesh);
390 if(m_user_wkst_factory==Teuchos::null)
393 wkstFactory = m_user_wkst_factory;
400 std::vector<panzer::BC> bcs;
401 panzer::buildBCs(bcs, p.
sublist(
"Boundary Conditions"), global_data);
406 m_conn_manager = conn_manager;
414 std::string loadBalanceString =
"";
415 bool blockedAssembly =
false;
417 const bool has_interface_condition = hasInterfaceCondition(bcs);
421 #ifdef PANZER_HAVE_EPETRA_STACK
425 "ERROR: Blocked Epetra systems cannot handle interface conditions.");
428 blockedAssembly =
true;
434 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
435 globalIndexer = dofManager;
439 Teuchos::rcp_dynamic_cast<panzer::BlockedDOFManager>(dofManager)));
442 const std::string excludedBlocks = assembly_params.
get<std::string>(
"Excluded Blocks");
443 std::vector<std::string> stringPairs;
445 for(std::size_t i=0;i<stringPairs.size();i++) {
446 std::vector<std::string> sPair;
447 std::vector<int> iPair;
452 "Input Error: The correct format for \"Excluded Blocks\" parameter in \"Assembly\" sub list is:\n"
453 " <int>,<int>; <int>,<int>; ...; <int>,<int>\n"
454 "Failure on string pair " << stringPairs[i] <<
"!");
456 bloLinObjFactory->addExcludedPair(iPair[0],iPair[1]);
459 linObjFactory = bloLinObjFactory;
472 "ERROR: Blocked Tpetra system cannot handle interface conditions.");
475 blockedAssembly =
true;
482 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
483 globalIndexer = dofManager;
487 Teuchos::rcp_dynamic_cast<panzer::BlockedDOFManager>(dofManager)));
490 const std::string excludedBlocks = assembly_params.
get<std::string>(
"Excluded Blocks");
491 std::vector<std::string> stringPairs;
493 for(std::size_t i=0;i<stringPairs.size();i++) {
494 std::vector<std::string> sPair;
495 std::vector<int> iPair;
500 "Input Error: The correct format for \"Excluded Blocks\" parameter in \"Assembly\" sub list is:\n"
501 " <int>,<int>; <int>,<int>; ...; <int>,<int>\n"
502 "Failure on string pair " << stringPairs[i] <<
"!");
504 bloLinObjFactory->addExcludedPair(iPair[0],iPair[1]);
507 linObjFactory = bloLinObjFactory;
514 if (has_interface_condition)
515 buildInterfaceConnections(bcs, conn_manager);
524 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
525 globalIndexer = dofManager;
527 if (has_interface_condition)
528 checkInterfaceConnections(conn_manager, dofManager->
getComm());
538 #ifdef PANZER_HAVE_EPETRA_STACK
539 if (has_interface_condition)
540 buildInterfaceConnections(bcs, conn_manager);
548 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,
550 globalIndexer = dofManager;
552 if (has_interface_condition)
553 checkInterfaceConnections(conn_manager, dofManager->
getComm());
566 m_global_indexer = globalIndexer;
567 m_lin_obj_factory = linObjFactory;
568 m_blockedAssembly = blockedAssembly;
571 fout <<
"Degree of freedom load balancing: " << loadBalanceString << std::endl;
577 std::map<std::string,panzer::WorksetNeeds> needs;
578 for(std::size_t i=0;i<physicsBlocks.size();i++)
579 needs[physicsBlocks[i]->elementBlockID()] = physicsBlocks[i]->getWorksetNeeds();
587 m_wkstContainer = wkstContainer;
590 std::size_t max_wksets = 0;
591 for(std::size_t pb=0;pb<physicsBlocks.size();pb++) {
594 max_wksets = std::max(max_wksets,works->size());
596 user_data_params.
set<std::size_t>(
"Max Worksets",max_wksets);
597 wkstContainer->
clear();
604 useDynamicCoordinates_ =
false;
605 for(std::size_t pb=0;pb<physicsBlocks.size();pb++) {
606 if(physicsBlocks[pb]->getCoordinateDOFs().size()>0) {
608 useDynamicCoordinates_ =
true;
609 wkstContainer->
clear();
618 panzer_data_params.
set(
"STK Mesh", mesh);
619 panzer_data_params.
set(
"DOF Manager", globalIndexer);
620 panzer_data_params.
set(
"Linear Object Factory", linObjFactory);
625 if(!meConstructionOn)
631 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
632 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
636 int num_param_vecs = active_params.
get<
int>(
"Number of Parameter Vectors",0);
637 p_names.resize(num_param_vecs);
638 p_values.resize(num_param_vecs);
639 for (
int i=0; i<num_param_vecs; i++) {
640 std::stringstream ss;
641 ss <<
"Parameter Vector " << i;
643 int numParameters = pList.
get<
int>(
"Number");
646 std::endl <<
"Error! panzer::ModelEvaluator::ModelEvaluator(): " <<
647 "Parameter vector " << i <<
" has zero parameters!" << std::endl);
652 for (
int j=0; j<numParameters; j++) {
653 std::stringstream ss2;
654 ss2 <<
"Parameter " << j;
655 (*p_names[i])[j] = pList.
get<std::string>(ss2.str());
658 ss2 <<
"Initial Value " << j;
659 (*p_values[i])[j] = pList.
get<
double>(ss2.str());
679 bool write_dot_files = p.
sublist(
"Options").
get(
"Write Volume Assembly Graphs",
false);
680 std::string dot_file_prefix = p.
sublist(
"Options").
get(
"Volume Assembly Graph Prefix",
"Panzer_AssemblyGraph");
681 bool write_fm_files = p.
sublist(
"Options").
get(
"Write Field Manager Files",
false);
682 std::string fm_file_prefix = p.
sublist(
"Options").
get(
"Field Manager File Prefix",
"Panzer_AssemblyGraph");
686 auto check_write_dag = std::getenv(
"PANZER_WRITE_DAG");
687 if (check_write_dag !=
nullptr) {
688 write_dot_files =
true;
689 write_fm_files =
true;
693 fmb = buildFieldManagerBuilder(wkstContainer,physicsBlocks,bcs,*eqset_factory,bc_factory,cm_factory,
694 user_cm_factory,p.
sublist(
"Closure Models"),*linObjFactory,user_data_params,
695 write_dot_files,dot_file_prefix,
696 write_fm_files,fm_file_prefix);
705 bool write_dot_files =
false;
706 std::string prefix =
"Panzer_ResponseGraph_";
707 write_dot_files = p.
sublist(
"Options").
get(
"Write Volume Response Graphs",write_dot_files);
708 prefix = p.
sublist(
"Options").
get(
"Volume Response Graph Prefix",prefix);
711 user_data.
set<
int>(
"Workset Size",workset_size);
725 t_init = this->getInitialTime(p.
sublist(
"Initial Conditions").
sublist(
"Transient Parameters"), *mesh);
727 if(blockedAssembly || useTpetra)
731 = buildPhysicsModelEvaluator(useThyraME,
751 model_it!=models.
end(); ++model_it) {
752 std::string key = model_it->first;
753 if (model_it->first !=
"Global MMS Parameters")
754 cl_models.
setEntry(key,model_it->second);
756 bool write_dot_files =
false;
757 std::string prefix =
"Panzer_AssemblyGraph_";
758 setupInitialConditions(*thyra_me,*wkstContainer,physicsBlocks,user_cm_factory,*linObjFactory,
760 p.
sublist(
"Initial Conditions"),
762 p.
sublist(
"Options").
get(
"Write Volume Assembly Graphs",write_dot_files),
763 p.
sublist(
"Options").
get(
"Volume Assembly Graph Prefix",prefix));
768 writeInitialConditions(*thyra_me,physicsBlocks,wkstContainer,globalIndexer,linObjFactory,mesh,user_cm_factory,
770 p.
sublist(
"User Data"),workset_size);
772 m_physics_me = thyra_me;
775 template<
typename ScalarT>
782 itr!=cellAvgQuants.
end();++itr) {
783 const std::string & blockId = itr->first;
784 const std::string & fields = Teuchos::any_cast<std::string>(itr->second.getAny());
785 std::vector<std::string> tokens;
790 for(std::size_t i=0;i<tokens.size();i++)
799 itr != cellAvgVectors.
end(); ++itr) {
800 const std::string & blockId = itr->first;
801 const std::string & fields = Teuchos::any_cast<std::string>(itr->second.getAny());
802 std::vector<std::string> tokens;
807 for(std::size_t i = 0; i < tokens.size(); i++) {
808 std::string d_mod[3] = {
"X",
"Y",
"Z"};
817 itr!=cellQuants.
end();++itr) {
818 const std::string & blockId = itr->first;
819 const std::string & fields = Teuchos::any_cast<std::string>(itr->second.getAny());
820 std::vector<std::string> tokens;
825 for(std::size_t i=0;i<tokens.size();i++)
832 itr!=nodalQuants.
end();++itr) {
833 const std::string & blockId = itr->first;
834 const std::string & fields = Teuchos::any_cast<std::string>(itr->second.getAny());
835 std::vector<std::string> tokens;
840 for(std::size_t i=0;i<tokens.size();i++)
846 itr!=allocNodalQuants.
end();++itr) {
847 const std::string & blockId = itr->first;
848 const std::string & fields = Teuchos::any_cast<std::string>(itr->second.getAny());
849 std::vector<std::string> tokens;
854 for(std::size_t i=0;i<tokens.size();i++)
859 template<
typename ScalarT>
869 bool write_dot_files,
const std::string & dot_file_prefix)
const
873 Thyra::ModelEvaluatorBase::InArgs<double> nomValues = model.getNominalValues();
876 if(initial_cond_pl.
get<
bool>(
"Zero Initial Conditions")) {
878 Thyra::assign(x_vec.
ptr(),0.0);
880 else if(!initial_cond_pl.
sublist(
"Vector File").
get<
bool>(
"Enabled")) {
883 std::map<std::string, Teuchos::RCP< PHX::FieldManager<panzer::Traits> > > phx_ic_field_managers;
894 phx_ic_field_managers);
910 tloc->set_x_th(x_vec);
915 const std::string & vectorFile = initial_cond_pl.
sublist(
"Vector File").
get<std::string>(
"File Name");
917 "If \"Read From Vector File\" is true, then parameter \"Vector File\" cannot be the empty string.");
922 tloc->set_x_th(x_vec);
929 template<
typename ScalarT>
940 int workset_size)
const
947 = initializeSolnWriterResponseLibrary(wc,ugi,lof,mesh);
951 user_data.
set<
int>(
"Workset Size",workset_size);
953 finalizeSolnWriterResponseLibrary(*solnWriter,physicsBlocks,cm_factory,closure_model_pl,workset_size,user_data);
960 ae_inargs.
alpha = 0.0;
961 ae_inargs.
beta = 1.0;
976 template<
typename ScalarT>
982 if (mesh_params.
get<std::string>(
"Source") ==
"Exodus File") {
983 mesh_factory =
Teuchos::rcp(
new panzer_stk::STK_ExodusReaderFactory());
986 else if (mesh_params.
get<std::string>(
"Source") ==
"Pamgen Mesh") {
987 mesh_factory =
Teuchos::rcp(
new panzer_stk::STK_ExodusReaderFactory());
989 pamgenList->
set(
"File Type",
"Pamgen");
992 else if (mesh_params.
get<std::string>(
"Source") ==
"Inline Mesh") {
994 int dimension = mesh_params.
sublist(
"Inline Mesh").
get<
int>(
"Mesh Dimension");
995 std::string typeStr =
"";
997 typeStr = mesh_params.
sublist(
"Inline Mesh").
get<std::string>(
"Type");
999 if (dimension == 1) {
1002 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1005 else if (dimension == 2 && typeStr==
"Tri") {
1008 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1011 else if (dimension == 2) {
1014 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1017 else if (dimension == 3 && typeStr==
"Tet") {
1020 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1023 else if(dimension == 3) {
1026 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1029 else if(dimension==4) {
1032 *in_mesh = mesh_params.
sublist(
"Inline Mesh").
sublist(
"Mesh Factory Parameter List");
1036 else if (mesh_params.
get<std::string>(
"Source") ==
"Custom Mesh") {
1046 if(mesh_params.
isSublist(
"Rebalance")) {
1050 bool enabled =
false;
1051 if(rebalance.
isType<
bool>(
"Enabled"))
1052 enabled = rebalance.
get<
bool>(
"Enabled");
1056 if(enabled && rebalance.
isSublist(
"Cycles"))
1063 return mesh_factory;
1066 template<
typename ScalarT>
1074 std::vector<Teuchos::RCP<panzer::PhysicsBlock> >::const_iterator physIter;
1075 for(physIter=physicsBlocks.begin();physIter!=physicsBlocks.end();++physIter) {
1077 double blockWeight = 0.0;
1080 const std::vector<panzer::StrPureBasisPair> & blockFields = pb->
getProvidedDOFs();
1081 const std::vector<std::vector<std::string> > & coordinateDOFs = pb->
getCoordinateDOFs();
1085 std::set<panzer::StrPureBasisPair,panzer::StrPureBasisComp> fieldNames;
1086 fieldNames.insert(blockFields.begin(),blockFields.end());
1091 std::set<std::string> fields_to_remove;
1095 for(std::size_t i=0;i<coordinateDOFs.size();i++) {
1097 for(std::size_t j=0;j<coordinateDOFs[i].size();j++)
1098 fields_to_remove.insert(coordinateDOFs[i][j]);
1102 std::set<std::string>::const_iterator rmItr;
1103 for (rmItr=fields_to_remove.begin();rmItr!=fields_to_remove.end();++rmItr)
1108 std::set<panzer::StrPureBasisPair,panzer::StrPureBasisComp>::const_iterator fieldItr;
1109 for (fieldItr=fieldNames.begin();fieldItr!=fieldNames.end();++fieldItr) {
1111 if(fieldItr->second->isScalarBasis() &&
1115 else if(fieldItr->second->isScalarBasis()) {
1118 else if(fieldItr->second->isVectorBasis()) {
1119 std::string d_mod[3] = {
"X",
"Y",
"Z"};
1120 for(
int d=0;d<fieldItr->second->dimension();d++)
1125 blockWeight += double(fieldItr->second->cardinality());
1138 template<
typename ScalarT>
1142 "Objects are not built yet! Please call buildObjects() member function.");
1143 return m_physics_me;
1146 template<
typename ScalarT>
1149 m_nox_observer_factory = nox_observer_factory;
1152 #ifdef PANZER_HAVE_TEMPUS
1153 template<
typename ScalarT>
1156 m_tempus_observer_factory = tempus_observer_factory;
1160 template<
typename ScalarT>
1163 m_user_wkst_factory = user_wkst_factory;
1166 template<
typename ScalarT>
1169 if(m_rome_me==Teuchos::null)
1170 m_rome_me = buildResponseOnlyModelEvaluator(m_physics_me,m_global_data);
1175 template<
typename ScalarT>
1179 #ifdef PANZER_HAVE_TEMPUS
1180 const Teuchos::RCP<Piro::TempusSolverForwardOnly<ScalarT> > tempusSolver,
1183 #ifdef PANZER_HAVE_TEMPUS
1192 "Objects are not built yet! Please call buildObjects() member function.");
1194 "Objects are not built yet! Please call buildObjects() member function.");
1196 "Objects are not built yet! Please call buildObjects() member function.");
1198 =
is_null(in_nox_observer_factory) ? m_nox_observer_factory.ptr() : in_nox_observer_factory;
1199 #ifdef PANZER_HAVE_TEMPUS
1201 =
is_null(in_tempus_observer_factory) ? m_tempus_observer_factory.ptr() : in_tempus_observer_factory;
1209 std::string solver = solncntl_params.
get<std::string>(
"Piro Solver");
1211 = Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me);
1212 if ( (solver==
"NOX") || (solver ==
"LOCA") ) {
1215 "No NOX obersver built! Please call setNOXObserverFactory() member function if you plan to use a NOX solver.");
1218 piro_params->
sublist(
"NOX").
sublist(
"Solver Options").
set(
"User Defined Pre/Post Operator", ppo);
1221 piro =
Teuchos::rcp(
new Piro::NOXSolver<double>(piro_params,
1222 Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me_db)));
1223 else if (solver ==
"LOCA")
1224 piro =
Teuchos::rcp(
new Piro::LOCASolver<double>(piro_params,
1225 Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me_db),
1234 #ifdef PANZER_HAVE_TEMPUS
1235 else if (solver==
"Tempus") {
1238 "No Tempus observer built! Please call setTempusObserverFactory() member function if you plan to use a Tempus solver.");
1243 piro_params->
sublist(
"NOX").
sublist(
"Solver Options").
set(
"User Defined Pre/Post Operator", ppo);
1254 if(tempusSolver==Teuchos::null)
1257 Teuchos::rcp(
new Piro::TempusSolverForwardOnly<double>(piro_params, thyra_me,
1258 tempus_observer_factory->
buildTempusObserver(m_mesh,m_global_indexer,m_lin_obj_factory)));
1262 piro_tempus = tempusSolver;
1263 piro_tempus->initialize(piro_params, thyra_me,
1272 "Error: Unknown Piro Solver : " << solver);
1277 template<
typename ScalarT>
1281 "Objects are not built yet! Please call buildObjects() member function.");
1283 return m_response_library;
1286 template<
typename ScalarT>
1290 "Objects are not built yet! Please call buildObjects() member function.");
1292 return m_physics_blocks;
1295 template<
typename ScalarT>
1300 const std::vector<panzer::BC> & bcs,
1308 bool writeGraph,
const std::string & graphPrefix,
1309 bool write_field_managers,
const std::string & field_manager_prefix)
const
1314 fmb->
setupBCFieldManagers(bcs,physicsBlocks,eqset_factory,bc_cm_factory,bc_factory,closure_models,lo_factory,user_data);
1321 if (write_field_managers){
1329 template<
typename ScalarT>
1337 bool is_transient,
bool is_explicit,
1348 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
1353 std::map<std::string,std::string> block_ids_to_physics_ids;
1357 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
1358 for(std::map<std::string,std::string>::const_iterator itr=block_ids_to_physics_ids.begin();
1359 itr!=block_ids_to_physics_ids.end();++itr) {
1360 block_ids_to_cell_topo[itr->first] = m_mesh->getCellTopology(itr->first);
1361 TEUCHOS_ASSERT(block_ids_to_cell_topo[itr->first]!=Teuchos::null);
1364 std::size_t workset_size = Teuchos::as<std::size_t>(assembly_params.
get<
int>(
"Workset Size"));
1366 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
1367 block_ids_to_cell_topo,
1368 physics_block_plist,
1369 assembly_params.
get<
int>(
"Default Integration Order"),
1382 bool write_dot_files =
false;
1383 std::string prefix =
"Cloned_";
1385 std::vector<panzer::BC> bcs;
1386 if(bc_list==Teuchos::null) {
1387 panzer::buildBCs(bcs, p.
sublist(
"Boundary Conditions"), m_global_data);
1390 panzer::buildBCs(bcs, *bc_list, m_global_data);
1393 fmb = buildFieldManagerBuilder(
1406 write_dot_files,prefix,
1407 write_dot_files,prefix);
1413 m_lin_obj_factory));
1421 Thyra::ModelEvaluatorBase::InArgs<ScalarT> nomVals = physics_me->getNominalValues();
1426 bool useThyra =
true;
1427 #ifdef PANZER_HAVE_EPETRA_STACK
1429 if(ep_thyra_me!=Teuchos::null)
1434 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names(physics_me->Np());
1435 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values(physics_me->Np());
1436 for(std::size_t i=0;i<p_names.size();i++) {
1442 = buildPhysicsModelEvaluator(useThyra,
1454 thyra_me->getNominalValues() = nomVals;
1459 bool lumpExplicitMass = assembly_params.
get<
bool>(
"Lump Explicit Mass");
1467 template<
typename ScalarT>
1478 bool is_transient,
double t_init)
const
1482 #ifdef PANZER_HAVE_EPETRA_STACK
1490 thyra_me = Thyra::epetraModelEvaluator(ep_me,solverFactory);
1497 (fmb,rLibrary,lof,p_names,p_values,solverFactory,global_data,is_transient,t_init));
1503 template<
typename ScalarT>
1510 validPL.
set<std::string>(
"Start Time Type",
"From Input File",
"Set the start time",
1513 validPL.
set<
double>(
"Start Time",0.0);
1518 std::string t_init_type = p.
get<std::string>(
"Start Time Type");
1519 double t_init = 10.0;
1521 if (t_init_type ==
"From Input File")
1522 t_init = p.
get<
double>(
"Start Time");
1524 if (t_init_type ==
"From Exodus File")
1532 template<
typename ScalarT>
1542 std::vector<std::string> eBlocks;
1546 builder.
mesh = mesh;
1547 stkIOResponseLibrary->addResponse(
"Main Field Output",eBlocks,builder);
1549 return stkIOResponseLibrary;
1552 template<
typename ScalarT>
1560 user_data.
set<
int>(
"Workset Size",workset_size);
1571 template<
typename EvalT>
1576 if (mesh_accessor) {
1585 for (
auto sub_factory : sub_factories) {
1586 Sacado::mpl::for_each_no_kokkos<panzer::Traits::EvalTypes>(
SetMeshFunctor(
mesh_,*sub_factory));
1593 template<
typename ScalarT>
1598 Sacado::mpl::for_each_no_kokkos<panzer::Traits::EvalTypes>(
SetMeshFunctor(mesh,user_cm_factory));
1601 template<
typename ScalarT>
1608 #ifdef PANZER_HAVE_TEKO
1619 if (
nonnull(m_stratimikos_params)) {
1620 strat_params = m_stratimikos_params;
1624 sublist(
"Newton").
sublist(
"Stratimikos Linear Solver").
sublist(
"Stratimikos")));
1627 bool writeCoordinates =
false;
1629 writeCoordinates = p.
sublist(
"Options").
get<
bool>(
"Write Coordinates");
1631 bool writeTopo =
false;
1633 writeTopo = p.
sublist(
"Options").
get<
bool>(
"Write Topology");
1637 blockedAssembly,globalIndexer,conn_manager,
1638 Teuchos::as<int>(mesh->
getDimension()), mpi_comm, strat_params,
1639 #ifdef PANZER_HAVE_TEKO
1647 template<
typename ScalarT>
1650 const bool write_graphviz_file,
1651 const std::string& graphviz_file_prefix)
1664 panzer_me->buildResponses(m_physics_blocks,*m_eqset_factory,cm_factory,closure_models,user_data,write_graphviz_file,graphviz_file_prefix);
1667 #ifdef PANZER_HAVE_EPETRA_STACK
1671 if(epetra_me!=Teuchos::null) {
1674 epetra_me->uninitialize(&const_ep_me,&solveFactory);
1678 ep_panzer_me->
buildResponses(m_physics_blocks,*m_eqset_factory,cm_factory,closure_models,user_data,write_graphviz_file,graphviz_file_prefix);
1681 epetra_me->initialize(ep_me,solveFactory);
const std::string & name() const
virtual Teuchos::RCP< panzer::GlobalIndexer > buildGlobalIndexer(const Teuchos::RCP< const Teuchos::OpaqueWrapper< MPI_Comm > > &mpiComm, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const Teuchos::RCP< ConnManager > &connMngr, const std::string &fieldOrder="") const
void TokensToInts(std::vector< int > &values, const std::vector< std::string > &tokens)
Turn a vector of tokens into a vector of ints.
Interface for constructing a BCStrategy_TemplateManager.
virtual Teuchos::RCP< Teuchos::Comm< int > > getComm() const =0
virtual void completeMeshConstruction(STK_Interface &mesh, stk::ParallelMachine parallelMach) const =0
void setupVolumeFieldManagers(const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &closure_models, const LinearObjFactory< panzer::Traits > &lo_factory, const Teuchos::ParameterList &user_data)
Allocates and initializes an equation set template manager.
void print(std::ostream &os) const
ParameterList & setEntry(const std::string &name, U &&entry)
void setStratimikosList(const Teuchos::RCP< Teuchos::ParameterList > ¶mList)
Set the Stratimikos Linear Solver sublist used to create the LinearOpWithSolve factory.
bool evaluate_transient_terms
ConstIterator end() const
bool is_null(const boost::shared_ptr< T > &p)
Teuchos::RCP< Thyra::ModelEvaluator< ScalarT > > getPhysicsModelEvaluator()
void setGlobalIndexer(const Teuchos::RCP< const panzer::GlobalIndexer > &ugi)
Teuchos::RCP< panzer::ParamLib > pl
Sacado scalar parameter library.
ParameterList & disableRecursiveValidation()
Teuchos::RCP< typename Sacado::mpl::apply< ObjectT, ScalarT >::type > getAsObject()
static bool requiresBlocking(const std::string &fieldorder)
void getElementBlockNames(std::vector< std::string > &names) const
void setUseTieBreak(bool flag)
void evaluateInitialCondition(WorksetContainer &wkstContainer, const std::map< std::string, Teuchos::RCP< PHX::FieldManager< panzer::Traits > > > &phx_ic_field_managers, Teuchos::RCP< panzer::LinearObjContainer > loc, const panzer::LinearObjFactory< panzer::Traits > &lo_factory, const double time_stamp, const double step_size, const int stage_number)
T & get(const std::string &name, T def_value)
Teuchos::RCP< Teuchos::FancyOStream > os
ostream for redirecting all panzer output for a particular instantiation.
void buildBlockIdToPhysicsIdMap(std::map< std::string, std::string > &b_to_p, const Teuchos::ParameterList &p)
bool is_null(const std::shared_ptr< T > &p)
void writeVolumeGraphvizDependencyFiles(std::string filename_prefix, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks) const
Teuchos::RCP< Thyra::LinearOpWithSolveFactoryBase< double > > buildLOWSFactory(bool blockedAssembly, const Teuchos::RCP< const panzer::GlobalIndexer > &globalIndexer, const Teuchos::RCP< panzer::ConnManager > &conn_manager, const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, const Teuchos::RCP< const Teuchos::MpiComm< int > > &mpi_comm) const
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
void finalizeSolnWriterResponseLibrary(panzer::ResponseLibrary< panzer::Traits > &rl, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &closure_models, int workset_size, Teuchos::ParameterList &user_data) const
void printMetaData(std::ostream &os) const
void addSolutionField(const std::string &fieldName, const std::string &blockId)
Teuchos::RCP< STK_MeshFactory > buildSTKMeshFactory(const Teuchos::ParameterList &mesh_params) const
build STK mesh factory from a mesh parameter list
void writeBCGraphvizDependencyFiles(std::string filename_prefix) const
void setParameterList(Teuchos::RCP< Teuchos::ParameterList > const ¶mList)
ParameterList & set(std::string const &name, T &&value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Teuchos::RCP< panzer::LinearObjContainer > ghostedContainer_
Teuchos::RCP< panzer_stk::STK_Interface > mesh
SetMeshFunctor(const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &user_cm_factory)
virtual Teuchos::RCP< NOX::Abstract::PrePostOperator > buildNOXObserver(const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, const Teuchos::RCP< const panzer::GlobalIndexer > &dof_manager, const Teuchos::RCP< const panzer::LinearObjFactory< panzer::Traits > > &lof) const =0
std::vector< std::string > checkAssociateElementsInSidesets(const Teuchos::Comm< int > &comm) const
void setWorksetSize(std::size_t worksetSize)
set the workset size
Class that provides access to worksets on each element block and side set.
void set_t_init(double t)
Set initial time value.
void writeBCTextDependencyFiles(std::string filename_prefix) const
Teuchos::RCP< panzer::LinearObjContainer > container_
void setWorksetContainer(const Teuchos::RCP< WorksetContainer > &wc)
bool isParameter(const std::string &name) const
virtual void setParameterList(const RCP< ParameterList > ¶mList)=0
void buildResponseEvaluators(const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &closure_models, const Teuchos::ParameterList &user_data, const bool write_graphviz_file=false, const std::string &graphviz_file_prefix="")
unsigned getDimension() const
get the dimension
void buildResponses(const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::EquationSetFactory &eqset_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &closure_models, const Teuchos::ParameterList &user_data, const bool write_graphviz_file=false, const std::string &graphviz_file_prefix="")
void registerMeshWithClosureModelFactories(const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &user_cm_factory)
Teuchos::RCP< Thyra::ModelEvaluator< ScalarT > > getResponseOnlyModelEvaluator()
void setupExodusFile(const std::string &filename, const bool append=false, const bool append_after_restart_time=false, const double restart_time=0.0)
Set up an output Exodus file for writing results.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
void setUseFieldCoordinates(bool useFieldCoordinates)
void writeVolumeTextDependencyFiles(std::string filename_prefix, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks) const
Teuchos::RCP< Thyra::ModelEvaluator< double > > cloneWithNewPhysicsBlocks(const Teuchos::RCP< Thyra::LinearOpWithSolveFactoryBase< ScalarT > > &solverFactory, const Teuchos::RCP< Teuchos::ParameterList > &physics_block_plist, const Teuchos::RCP< const panzer::EquationSetFactory > &eqset_factory, const panzer::BCStrategyFactory &bc_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &user_cm_factory, bool is_transient, bool is_explicit, const Teuchos::Ptr< const Teuchos::ParameterList > &bc_list=Teuchos::null, const Teuchos::RCP< Thyra::ModelEvaluator< ScalarT > > &physics_me=Teuchos::null) const
bool isSublist(const std::string &name) const
void setUseNeighbors(bool flag)
std::string elementBlockID() const
const std::vector< std::vector< std::string > > & getCoordinateDOFs() const
void addUserFieldsToMesh(panzer_stk::STK_Interface &mesh, const Teuchos::ParameterList &output_list) const
Add the user fields specified by output_list to the mesh.
void setNOXObserverFactory(const Teuchos::RCP< const panzer_stk::NOXObserverFactory > &nox_observer_factory)
params_t::ConstIterator ConstIterator
virtual Teuchos::RCP< panzer::GlobalIndexer > buildGlobalIndexer(const Teuchos::RCP< const Teuchos::OpaqueWrapper< MPI_Comm > > &mpiComm, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const Teuchos::RCP< ConnManager > &connMngr, const std::string &fieldOrder="") const
void buildObjects(const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< panzer::GlobalData > &global_data, const Teuchos::RCP< const panzer::EquationSetFactory > &eqset_factory, const panzer::BCStrategyFactory &bc_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, bool meConstructionOn=true)
Builds the model evaluators for a panzer assembly.
Teuchos::RCP< std::vector< Workset > > getWorksets(const WorksetDescriptor &wd)
Access to volume worksets.
virtual Teuchos::RCP< LinearObjContainer > buildLinearObjContainer() const =0
void validateParametersAndSetDefaults(ParameterList const &validParamList, int const depth=1000)
ConstIterator begin() const
int getOutputToRootOnly() const
void setBlockWeight(const std::string &blockId, double weight)
Teuchos::RCP< Thyra::LinearOpWithSolveFactoryBase< double > > buildLOWSFactory(bool blockedAssembly, const Teuchos::RCP< const panzer::GlobalIndexer > &globalIndexer, const Teuchos::RCP< panzer_stk::STKConnManager > &stkConn_manager, int spatialDim, const Teuchos::RCP< const Teuchos::MpiComm< int > > &mpi_comm, const Teuchos::RCP< Teuchos::ParameterList > &strat_params, bool writeCoordinates, bool writeTopo, const Teuchos::RCP< const panzer::GlobalIndexer > &auxGlobalIndexer, bool useCoordinates)
Teuchos::RCP< Thyra::ModelEvaluator< ScalarT > > buildResponseOnlyModelEvaluator(const Teuchos::RCP< Thyra::ModelEvaluator< ScalarT > > &thyra_me, const Teuchos::RCP< panzer::GlobalData > &global_data, const Teuchos::Ptr< const panzer_stk::NOXObserverFactory > &in_nox_observer_factory=Teuchos::null)
void operator()(EvalT t) const
double getInitialStateTime() const
virtual void readVector(const std::string &identifier, LinearObjContainer &loc, int id) const =0
virtual bool useNOXObserver() const =0
Use the NOX observer as well?
void buildObjects(const BuilderOpT &builder)
bool nonnull(const boost::shared_ptr< T > &p)
void addMeshCoordFields(const std::string &blockId, const std::vector< std::string > &coordField, const std::string &dispPrefix)
const Teuchos::RCP< panzer_stk::STK_Interface > & mesh_
std::vector< Teuchos::RCP< panzer::ClosureModelFactory_TemplateManager< panzer::Traits > > > & getFactories()
void setupInitialConditionFieldManagers(WorksetContainer &wkstContainer, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &ic_block_closure_models, const panzer::LinearObjFactory< panzer::Traits > &lo_factory, const Teuchos::ParameterList &user_data, const bool write_graphviz_file, const std::string &graphviz_file_prefix, std::map< std::string, Teuchos::RCP< PHX::FieldManager< panzer::Traits > > > &phx_ic_field_managers)
Builds PHX::FieldManager objects for inital conditions and registers evaluators.
void buildResponses(const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const bool write_graphviz_file=false, const std::string &graphviz_file_prefix="")
virtual void setMesh(const Teuchos::RCP< const panzer_stk::STK_Interface > &mesh)
const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > & getPhysicsBlocks() const
bool isType(const std::string &name) const
void enableRebalance(bool enable, const Teuchos::RCP< const Teuchos::ParameterList > &rebalanceList=Teuchos::null)
std::pair< std::string, Teuchos::RCP< panzer::PureBasis > > StrPureBasisPair
void finalizeMeshConstruction(const STK_MeshFactory &mesh_factory, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const Teuchos::MpiComm< int > mpi_comm, STK_Interface &mesh) const
void writeInitialConditions(const Thyra::ModelEvaluator< ScalarT > &model, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const Teuchos::RCP< panzer::WorksetContainer > &wc, const Teuchos::RCP< const panzer::GlobalIndexer > &ugi, const Teuchos::RCP< const panzer::LinearObjFactory< panzer::Traits > > &lof, const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const Teuchos::ParameterList &closure_model_pl, const Teuchos::ParameterList &user_data_pl, int workset_size) const
Write the initial conditions to exodus. Note that this is entirely self contained.
WorksetDescriptor blockDescriptor(const std::string &eBlock)
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
void StringTokenizer(std::vector< std::string > &tokens, const std::string &str, const std::string delimiters, bool trim)
Tokenize a string, put tokens in a vector.
Teuchos::RCP< panzer::ResponseLibrary< panzer::Traits > > initializeSolnWriterResponseLibrary(const Teuchos::RCP< panzer::WorksetContainer > &wc, const Teuchos::RCP< const panzer::GlobalIndexer > &ugi, const Teuchos::RCP< const panzer::LinearObjFactory< panzer::Traits > > &lof, const Teuchos::RCP< panzer_stk::STK_Interface > &mesh) const
void setupBCFieldManagers(const std::vector< panzer::BC > &bcs, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::EquationSetFactory &eqset_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const panzer::BCStrategyFactory &bc_factory, const Teuchos::ParameterList &closure_models, const LinearObjFactory< panzer::Traits > &lo_factory, const Teuchos::ParameterList &user_data)
void setUseDOFManagerFEI(bool flag)
#define TEUCHOS_ASSERT(assertion_test)
void setupInitialConditions(Thyra::ModelEvaluator< ScalarT > &model, panzer::WorksetContainer &wkstContainer, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &cm_factory, const panzer::LinearObjFactory< panzer::Traits > &lof, const Teuchos::ParameterList &closure_pl, const Teuchos::ParameterList &initial_cond_pl, const Teuchos::ParameterList &user_data_pl, bool write_dot_files, const std::string &dot_file_prefix) const
Setup the initial conditions in a model evaluator. Note that this is entirely self contained...
void addCellField(const std::string &fieldName, const std::string &blockId)
Teuchos::RCP< panzer::FieldManagerBuilder > buildFieldManagerBuilder(const Teuchos::RCP< panzer::WorksetContainer > &wc, const std::vector< Teuchos::RCP< panzer::PhysicsBlock > > &physicsBlocks, const std::vector< panzer::BC > &bcs, const panzer::EquationSetFactory &eqset_factory, const panzer::BCStrategyFactory &bc_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &volume_cm_factory, const panzer::ClosureModelFactory_TemplateManager< panzer::Traits > &bc_cm_factory, const Teuchos::ParameterList &closure_models, const panzer::LinearObjFactory< panzer::Traits > &lo_factory, const Teuchos::ParameterList &user_data, bool writeGraph, const std::string &graphPrefix, bool write_field_managers, const std::string &field_manager_prefix) const
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
void registerScalarParameter(const std::string name, panzer::ParamLib &pl, double realValue)
virtual Teuchos::RCP< Tempus::IntegratorObserver< double > > buildTempusObserver(const Teuchos::RCP< panzer_stk::STK_Interface > &mesh, const Teuchos::RCP< const panzer::GlobalIndexer > &dof_manager, const Teuchos::RCP< const panzer::LinearObjFactory< panzer::Traits > > &lof) const =0
void setUserWorksetFactory(Teuchos::RCP< panzer_stk::WorksetFactory > &user_wkst_factory)
Set user defined workset factory.
void setMesh(const Teuchos::RCP< STK_Interface > &mesh)
void setUseDOFManagerFEI(bool flag)
double getInitialTime(Teuchos::ParameterList &transient_ic_params, const panzer_stk::STK_Interface &mesh) const
Gets the initial time from either the input parameter list or an exodus file.
Teuchos::RCP< panzer::ResponseLibrary< panzer::Traits > > getResponseLibrary()
panzer::ClosureModelFactory_TemplateManager< panzer::Traits > & user_cm_factory_
Teuchos::RCP< const shards::CellTopology > getCellTopology(const std::string &eBlock) const
const std::vector< StrPureBasisPair > & getProvidedDOFs() const
void associateElementsInSideset(const std::string sideset_id)
std::string printUGILoadBalancingInformation(const GlobalIndexer &ugi)
Teuchos::RCP< Thyra::ModelEvaluatorDefaultBase< double > > buildPhysicsModelEvaluator(bool buildThyraME, const Teuchos::RCP< panzer::FieldManagerBuilder > &fmb, const Teuchos::RCP< panzer::ResponseLibrary< panzer::Traits > > &rLibrary, const Teuchos::RCP< panzer::LinearObjFactory< panzer::Traits > > &lof, const std::vector< Teuchos::RCP< Teuchos::Array< std::string > > > &p_names, const std::vector< Teuchos::RCP< Teuchos::Array< double > > > &p_values, const Teuchos::RCP< Thyra::LinearOpWithSolveFactoryBase< ScalarT > > &solverFactory, const Teuchos::RCP< panzer::GlobalData > &global_data, bool is_transient, double t_init) const