252 const Teuchos::RCP<panzer::GlobalData>& global_data,
253 const Teuchos::RCP<const panzer::EquationSetFactory>& eqset_factory,
256 bool meConstructionOn)
258 TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::is_null(this->getParameterList()), std::runtime_error,
259 "ParameterList must be set before objects can be built!");
261 TEUCHOS_ASSERT(nonnull(comm));
262 TEUCHOS_ASSERT(nonnull(global_data));
263 TEUCHOS_ASSERT(nonnull(global_data->os));
264 TEUCHOS_ASSERT(nonnull(global_data->pl));
267 m_global_data = global_data;
279 Teuchos::ParameterList& p = *this->getNonconstParameterList();
282 Teuchos::ParameterList & mesh_params = p.sublist(
"Mesh");
283 Teuchos::ParameterList & assembly_params = p.sublist(
"Assembly");
284 Teuchos::ParameterList & solncntl_params = p.sublist(
"Solution Control");
285 Teuchos::ParameterList & output_list = p.sublist(
"Output");
287 Teuchos::ParameterList & user_data_params = p.sublist(
"User Data");
288 Teuchos::ParameterList & panzer_data_params = user_data_params.sublist(
"Panzer Data");
290 Teuchos::RCP<Teuchos::ParameterList> physics_block_plist = Teuchos::sublist(this->getMyNonconstParamList(),
"Physics Blocks");
293 std::size_t workset_size = Teuchos::as<std::size_t>(assembly_params.get<
int>(
"Workset Size"));
294 std::string field_order = assembly_params.get<std::string>(
"Field Order");
296 bool use_dofmanager_fei = assembly_params.get<
bool>(
"Use DOFManager FEI");
297 bool use_load_balance = assembly_params.get<
bool>(
"Load Balance DOFs");
298 bool useTpetra = assembly_params.get<
bool>(
"Use Tpetra");
299 bool useThyraME = !assembly_params.get<
bool>(
"Use Epetra ME");
303 bool is_transient = (solncntl_params.get<std::string>(
"Piro Solver") ==
"Rythmos" ||
304 solncntl_params.get<std::string>(
"Piro Solver") ==
"Tempus") ?
true :
false;
306 if (solncntl_params.get<std::string>(
"Piro Solver") ==
"NOX") {
307 if (solncntl_params.sublist(
"NOX").get<std::string>(
"Nonlinear Solver") ==
"Pseudo-Transient")
312 if (solncntl_params.get<std::string>(
"Piro Solver") ==
"LOCA") {
313 if (solncntl_params.sublist(
"LOCA").sublist(
"Stepper").get<
bool>(
"Compute Eigenvalues"))
316 m_is_transient = is_transient;
318 useDiscreteAdjoint = p.get<
bool>(
"Use Discrete Adjoint");
326 Teuchos::FancyOStream& fout = *global_data->os;
329 const Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
330 Teuchos::rcp_dynamic_cast<const Teuchos::MpiComm<int> >(comm);
335 Teuchos::RCP<panzer_stk::STK_MeshFactory> mesh_factory = this->buildSTKMeshFactory(mesh_params);
336 Teuchos::RCP<panzer_stk::STK_Interface> mesh = mesh_factory->buildUncommitedMesh(*(mpi_comm->getRawMpiComm()));
339 m_eqset_factory = eqset_factory;
344 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
347 std::map<std::string,std::string> block_ids_to_physics_ids;
351 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
352 for(std::map<std::string,std::string>::const_iterator itr=block_ids_to_physics_ids.begin();
353 itr!=block_ids_to_physics_ids.end();++itr) {
354 block_ids_to_cell_topo[itr->first] = mesh->getCellTopology(itr->first);
355 TEUCHOS_ASSERT(block_ids_to_cell_topo[itr->first]!=Teuchos::null);
360 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
361 block_ids_to_cell_topo,
363 assembly_params.get<
int>(
"Default Integration Order"),
369 m_physics_blocks = physicsBlocks;
374 addUserFieldsToMesh(*mesh,output_list);
381 this->finalizeMeshConstruction(*mesh_factory,physicsBlocks,*mpi_comm,*mesh);
383 fout <<
"*****************************************\n\n";
384 fout <<
"Element block exception, could not finalize the mesh, printing block and sideset information:\n";
386 mesh->printMetaData(fout);
392 fout <<
"*****************************************\n\n";
393 fout <<
"Sideset exception, could not finalize the mesh, printing block and sideset information:\n";
395 mesh->printMetaData(fout);
403 if(p.sublist(
"Output").get<
bool>(
"Write to Exodus"))
404 mesh->setupExodusFile(p.sublist(
"Output").get<std::string>(
"File Name"));
408 Teuchos::RCP<panzer_stk::WorksetFactory> wkstFactory;
409 if(m_user_wkst_factory==Teuchos::null)
412 wkstFactory = m_user_wkst_factory;
415 wkstFactory->setMesh(mesh);
419 std::vector<panzer::BC> bcs;
420 panzer::buildBCs(bcs, p.sublist(
"Boundary Conditions"), global_data);
425 m_conn_manager = conn_manager;
430 Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > linObjFactory;
431 Teuchos::RCP<panzer::GlobalIndexer> globalIndexer;
433 std::string loadBalanceString =
"";
434 bool blockedAssembly =
false;
436 const bool has_interface_condition = hasInterfaceCondition(bcs);
441 TEUCHOS_TEST_FOR_EXCEPTION(has_interface_condition,
442 Teuchos::Exceptions::InvalidParameter,
443 "ERROR: Blocked Epetra systems cannot handle interface conditions.");
446 blockedAssembly =
true;
451 Teuchos::RCP<panzer::GlobalIndexer> dofManager
452 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
453 globalIndexer = dofManager;
455 Teuchos::RCP<panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int> > bloLinObjFactory
457 Teuchos::rcp_dynamic_cast<panzer::BlockedDOFManager>(dofManager)));
460 const std::string excludedBlocks = assembly_params.get<std::string>(
"Excluded Blocks");
461 std::vector<std::string> stringPairs;
463 for(std::size_t i=0;i<stringPairs.size();i++) {
464 std::vector<std::string> sPair;
465 std::vector<int> iPair;
469 TEUCHOS_TEST_FOR_EXCEPTION(iPair.size()!=2,std::logic_error,
470 "Input Error: The correct format for \"Excluded Blocks\" parameter in \"Assembly\" sub list is:\n"
471 " <int>,<int>; <int>,<int>; ...; <int>,<int>\n"
472 "Failure on string pair " << stringPairs[i] <<
"!");
474 bloLinObjFactory->addExcludedPair(iPair[0],iPair[1]);
477 linObjFactory = bloLinObjFactory;
480 loadBalanceString = printUGILoadBalancingInformation(*dofManager);
485 TEUCHOS_TEST_FOR_EXCEPTION(has_interface_condition,
486 Teuchos::Exceptions::InvalidParameter,
487 "ERROR: Blocked Tpetra system cannot handle interface conditions.");
490 blockedAssembly =
true;
492 TEUCHOS_ASSERT(!use_dofmanager_fei);
496 Teuchos::RCP<panzer::GlobalIndexer> dofManager
497 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
498 globalIndexer = dofManager;
500 Teuchos::RCP<panzer::BlockedTpetraLinearObjFactory<panzer::Traits,double,int,panzer::GlobalOrdinal> > bloLinObjFactory
502 Teuchos::rcp_dynamic_cast<panzer::BlockedDOFManager>(dofManager)));
505 const std::string excludedBlocks = assembly_params.get<std::string>(
"Excluded Blocks");
506 std::vector<std::string> stringPairs;
508 for(std::size_t i=0;i<stringPairs.size();i++) {
509 std::vector<std::string> sPair;
510 std::vector<int> iPair;
514 TEUCHOS_TEST_FOR_EXCEPTION(iPair.size()!=2,std::logic_error,
515 "Input Error: The correct format for \"Excluded Blocks\" parameter in \"Assembly\" sub list is:\n"
516 " <int>,<int>; <int>,<int>; ...; <int>,<int>\n"
517 "Failure on string pair " << stringPairs[i] <<
"!");
519 bloLinObjFactory->addExcludedPair(iPair[0],iPair[1]);
522 linObjFactory = bloLinObjFactory;
525 loadBalanceString = printUGILoadBalancingInformation(*dofManager);
529 if (has_interface_condition)
530 buildInterfaceConnections(bcs, conn_manager);
534 TEUCHOS_ASSERT(!use_dofmanager_fei);
538 Teuchos::RCP<panzer::GlobalIndexer> dofManager
539 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,field_order);
540 globalIndexer = dofManager;
542 if (has_interface_condition)
543 checkInterfaceConnections(conn_manager, dofManager->getComm());
545 TEUCHOS_ASSERT(!useDiscreteAdjoint);
549 loadBalanceString = printUGILoadBalancingInformation(*dofManager);
553 if (has_interface_condition)
554 buildInterfaceConnections(bcs, conn_manager);
561 Teuchos::RCP<panzer::GlobalIndexer> dofManager
562 = globalIndexerFactory.
buildGlobalIndexer(mpi_comm->getRawMpiComm(),physicsBlocks,conn_manager,
564 globalIndexer = dofManager;
566 if (has_interface_condition)
567 checkInterfaceConnections(conn_manager, dofManager->getComm());
572 loadBalanceString = printUGILoadBalancingInformation(*dofManager);
575 TEUCHOS_ASSERT(globalIndexer!=Teuchos::null);
576 TEUCHOS_ASSERT(linObjFactory!=Teuchos::null);
577 m_global_indexer = globalIndexer;
578 m_lin_obj_factory = linObjFactory;
579 m_blockedAssembly = blockedAssembly;
582 fout <<
"Degree of freedom load balancing: " << loadBalanceString << std::endl;
588 std::map<std::string,panzer::WorksetNeeds> needs;
589 for(std::size_t i=0;i<physicsBlocks.size();i++)
590 needs[physicsBlocks[i]->elementBlockID()] = physicsBlocks[i]->getWorksetNeeds();
592 Teuchos::RCP<panzer::WorksetContainer> wkstContainer
595 wkstContainer->setWorksetSize(workset_size);
596 wkstContainer->setGlobalIndexer(globalIndexer);
598 m_wkstContainer = wkstContainer;
601 std::size_t max_wksets = 0;
602 for(std::size_t pb=0;pb<physicsBlocks.size();pb++) {
604 Teuchos::RCP< std::vector<panzer::Workset> >works = wkstContainer->getWorksets(wd);
605 max_wksets = std::max(max_wksets,works->size());
607 user_data_params.set<std::size_t>(
"Max Worksets",max_wksets);
608 wkstContainer->clear();
615 useDynamicCoordinates_ =
false;
616 for(std::size_t pb=0;pb<physicsBlocks.size();pb++) {
617 if(physicsBlocks[pb]->getCoordinateDOFs().size()>0) {
618 mesh->setUseFieldCoordinates(
true);
619 useDynamicCoordinates_ =
true;
620 wkstContainer->clear();
629 panzer_data_params.set(
"STK Mesh", mesh);
630 panzer_data_params.set(
"DOF Manager", globalIndexer);
631 panzer_data_params.set(
"Linear Object Factory", linObjFactory);
636 if(!meConstructionOn)
642 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
643 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
644 if (p.isSublist(
"Active Parameters")) {
645 Teuchos::ParameterList& active_params = p.sublist(
"Active Parameters");
647 int num_param_vecs = active_params.get<
int>(
"Number of Parameter Vectors",0);
648 p_names.resize(num_param_vecs);
649 p_values.resize(num_param_vecs);
650 for (
int i=0; i<num_param_vecs; i++) {
651 std::stringstream ss;
652 ss <<
"Parameter Vector " << i;
653 Teuchos::ParameterList& pList = active_params.sublist(ss.str());
654 int numParameters = pList.get<
int>(
"Number");
655 TEUCHOS_TEST_FOR_EXCEPTION(numParameters == 0,
656 Teuchos::Exceptions::InvalidParameter,
657 std::endl <<
"Error! panzer::ModelEvaluator::ModelEvaluator(): " <<
658 "Parameter vector " << i <<
" has zero parameters!" << std::endl);
660 Teuchos::rcp(
new Teuchos::Array<std::string>(numParameters));
662 Teuchos::rcp(
new Teuchos::Array<double>(numParameters));
663 for (
int j=0; j<numParameters; j++) {
664 std::stringstream ss2;
665 ss2 <<
"Parameter " << j;
666 (*p_names[i])[j] = pList.get<std::string>(ss2.str());
669 ss2 <<
"Initial Value " << j;
670 (*p_values[i])[j] = pList.get<
double>(ss2.str());
683 cm_factory.buildObjects(io_cm_builder);
688 Teuchos::RCP<panzer::FieldManagerBuilder> fmb;
690 bool write_dot_files = p.sublist(
"Options").get(
"Write Volume Assembly Graphs",
false);
691 std::string dot_file_prefix = p.sublist(
"Options").get(
"Volume Assembly Graph Prefix",
"Panzer_AssemblyGraph");
692 bool write_fm_files = p.sublist(
"Options").get(
"Write Field Manager Files",
false);
693 std::string fm_file_prefix = p.sublist(
"Options").get(
"Field Manager File Prefix",
"Panzer_AssemblyGraph");
697 auto check_write_dag = std::getenv(
"PANZER_WRITE_DAG");
698 if (check_write_dag !=
nullptr) {
699 write_dot_files =
true;
700 write_fm_files =
true;
704 fmb = buildFieldManagerBuilder(wkstContainer,physicsBlocks,bcs,*eqset_factory,bc_factory,cm_factory,
705 user_cm_factory,p.sublist(
"Closure Models"),*linObjFactory,user_data_params,
706 write_dot_files,dot_file_prefix,
707 write_fm_files,fm_file_prefix);
716 bool write_dot_files =
false;
717 std::string prefix =
"Panzer_ResponseGraph_";
718 write_dot_files = p.sublist(
"Options").get(
"Write Volume Response Graphs",write_dot_files);
719 prefix = p.sublist(
"Options").get(
"Volume Response Graph Prefix",prefix);
721 Teuchos::ParameterList user_data(p.sublist(
"User Data"));
722 user_data.set<
int>(
"Workset Size",workset_size);
728 Teuchos::RCP<Thyra::LinearOpWithSolveFactoryBase<double> > lowsFactory =
736 t_init = this->getInitialTime(p.sublist(
"Initial Conditions").sublist(
"Transient Parameters"), *mesh);
738 if(blockedAssembly || useTpetra)
741 Teuchos::RCP<Thyra::ModelEvaluatorDefaultBase<double> > thyra_me
742 = buildPhysicsModelEvaluator(useThyraME,
759 const Teuchos::ParameterList& models = p.sublist(
"Closure Models");
760 Teuchos::ParameterList cl_models(models.name());
761 for (Teuchos::ParameterList::ConstIterator model_it=models.begin();
762 model_it!=models.end(); ++model_it) {
763 std::string key = model_it->first;
764 if (model_it->first !=
"Global MMS Parameters")
765 cl_models.setEntry(key,model_it->second);
767 bool write_dot_files =
false;
768 std::string prefix =
"Panzer_AssemblyGraph_";
769 setupInitialConditions(*thyra_me,*wkstContainer,physicsBlocks,user_cm_factory,*linObjFactory,
771 p.sublist(
"Initial Conditions"),
772 p.sublist(
"User Data"),
773 p.sublist(
"Options").get(
"Write Volume Assembly Graphs",write_dot_files),
774 p.sublist(
"Options").get(
"Volume Assembly Graph Prefix",prefix));
779 writeInitialConditions(*thyra_me,physicsBlocks,wkstContainer,globalIndexer,linObjFactory,mesh,user_cm_factory,
780 p.sublist(
"Closure Models"),
781 p.sublist(
"User Data"),workset_size);
783 m_physics_me = thyra_me;
990 Teuchos::RCP<panzer_stk::STK_MeshFactory> mesh_factory;
993 if (mesh_params.get<std::string>(
"Source") ==
"Exodus File") {
994 mesh_factory = Teuchos::rcp(
new panzer_stk::STK_ExodusReaderFactory());
995 mesh_factory->setParameterList(Teuchos::rcp(
new Teuchos::ParameterList(mesh_params.sublist(
"Exodus File"))));
997 else if (mesh_params.get<std::string>(
"Source") ==
"Pamgen Mesh") {
998 mesh_factory = Teuchos::rcp(
new panzer_stk::STK_ExodusReaderFactory());
999 Teuchos::RCP<Teuchos::ParameterList> pamgenList = Teuchos::rcp(
new Teuchos::ParameterList(mesh_params.sublist(
"Pamgen Mesh")));
1000 pamgenList->set(
"File Type",
"Pamgen");
1001 mesh_factory->setParameterList(pamgenList);
1003 else if (mesh_params.get<std::string>(
"Source") ==
"Inline Mesh") {
1005 int dimension = mesh_params.sublist(
"Inline Mesh").get<
int>(
"Mesh Dimension");
1006 std::string typeStr =
"";
1007 if(mesh_params.sublist(
"Inline Mesh").isParameter(
"Type"))
1008 typeStr = mesh_params.sublist(
"Inline Mesh").get<std::string>(
"Type");
1010 if (dimension == 1) {
1012 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1013 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1014 mesh_factory->setParameterList(in_mesh);
1016 else if (dimension == 2 && typeStr==
"Tri") {
1018 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1019 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1020 mesh_factory->setParameterList(in_mesh);
1022 else if (dimension == 2) {
1024 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1025 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1026 mesh_factory->setParameterList(in_mesh);
1028 else if (dimension == 3 && typeStr==
"Tet") {
1030 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1031 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1032 mesh_factory->setParameterList(in_mesh);
1034 else if(dimension == 3) {
1036 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1037 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1038 mesh_factory->setParameterList(in_mesh);
1040 else if(dimension==4) {
1042 Teuchos::RCP<Teuchos::ParameterList> in_mesh = Teuchos::rcp(
new Teuchos::ParameterList);
1043 *in_mesh = mesh_params.sublist(
"Inline Mesh").sublist(
"Mesh Factory Parameter List");
1044 mesh_factory->setParameterList(in_mesh);
1047 else if (mesh_params.get<std::string>(
"Source") ==
"Custom Mesh") {
1049 mesh_factory->setParameterList(Teuchos::rcp(
new Teuchos::ParameterList(mesh_params.sublist(
"Custom Mesh"))));
1057 if(mesh_params.isSublist(
"Rebalance")) {
1058 const Teuchos::ParameterList & rebalance = mesh_params.sublist(
"Rebalance");
1061 bool enabled =
false;
1062 if(rebalance.isType<
bool>(
"Enabled"))
1063 enabled = rebalance.get<
bool>(
"Enabled");
1066 Teuchos::RCP<Teuchos::ParameterList> rebalanceCycles;
1067 if(enabled && rebalance.isSublist(
"Cycles"))
1068 rebalanceCycles = Teuchos::rcp(
new Teuchos::ParameterList(rebalance.sublist(
"Cycles")));
1071 mesh_factory->enableRebalance(enabled,rebalanceCycles);
1074 return mesh_factory;
1195 const Teuchos::RCP<panzer::GlobalData>& global_data,
1197#ifdef PANZER_HAVE_TEMPUS
1198 const Teuchos::RCP<Piro::TempusSolverForwardOnly<ScalarT> > tempusSolver,
1200 const Teuchos::Ptr<const panzer_stk::NOXObserverFactory> & in_nox_observer_factory,
1201 const Teuchos::Ptr<const panzer_stk::RythmosObserverFactory> & in_rythmos_observer_factory
1202#ifdef PANZER_HAVE_TEMPUS
1203 ,
const Teuchos::Ptr<const panzer_stk::TempusObserverFactory> & in_tempus_observer_factory
1207 using Teuchos::is_null;
1210 TEUCHOS_TEST_FOR_EXCEPTION(is_null(m_lin_obj_factory), std::runtime_error,
1211 "Objects are not built yet! Please call buildObjects() member function.");
1212 TEUCHOS_TEST_FOR_EXCEPTION(is_null(m_global_indexer), std::runtime_error,
1213 "Objects are not built yet! Please call buildObjects() member function.");
1214 TEUCHOS_TEST_FOR_EXCEPTION(is_null(m_mesh), std::runtime_error,
1215 "Objects are not built yet! Please call buildObjects() member function.");
1216 Teuchos::Ptr<const panzer_stk::NOXObserverFactory> nox_observer_factory
1217 = is_null(in_nox_observer_factory) ? m_nox_observer_factory.ptr() : in_nox_observer_factory;
1218 Teuchos::Ptr<const panzer_stk::RythmosObserverFactory> rythmos_observer_factory
1219 = is_null(in_rythmos_observer_factory) ? m_rythmos_observer_factory.ptr() : in_rythmos_observer_factory;
1220#ifdef PANZER_HAVE_TEMPUS
1221 Teuchos::Ptr<const panzer_stk::TempusObserverFactory> tempus_observer_factory
1222 = is_null(in_tempus_observer_factory) ? m_tempus_observer_factory.ptr() : in_tempus_observer_factory;
1225 Teuchos::ParameterList& p = *this->getNonconstParameterList();
1226 Teuchos::ParameterList & solncntl_params = p.sublist(
"Solution Control");
1227 Teuchos::RCP<Teuchos::ParameterList> piro_params = Teuchos::rcp(
new Teuchos::ParameterList(solncntl_params));
1228 Teuchos::RCP<Thyra::ModelEvaluatorDefaultBase<double> > piro;
1230 std::string solver = solncntl_params.get<std::string>(
"Piro Solver");
1231 Teuchos::RCP<Thyra::ModelEvaluatorDefaultBase<double> > thyra_me_db
1232 = Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me);
1233 if ( (solver==
"NOX") || (solver ==
"LOCA") ) {
1235 TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::is_null(nox_observer_factory), std::runtime_error,
1236 "No NOX obersver built! Please call setNOXObserverFactory() member function if you plan to use a NOX solver.");
1238 Teuchos::RCP<NOX::Abstract::PrePostOperator> ppo = nox_observer_factory->buildNOXObserver(m_mesh,m_global_indexer,m_lin_obj_factory);
1239 piro_params->sublist(
"NOX").sublist(
"Solver Options").set(
"User Defined Pre/Post Operator", ppo);
1242 piro = Teuchos::rcp(
new Piro::NOXSolver<double>(piro_params,
1243 Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me_db)));
1244 else if (solver ==
"LOCA")
1245 piro = Teuchos::rcp(
new Piro::LOCASolver<double>(piro_params,
1246 Teuchos::rcp_dynamic_cast<Thyra::ModelEvaluatorDefaultBase<double> >(thyra_me_db),
1248 TEUCHOS_ASSERT(nonnull(piro));
1251 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Output Stream",global_data->os);
1252 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Error Stream",global_data->os);
1253 piro_params->sublist(
"NOX").sublist(
"Printing").set<
int>(
"Output Processor",global_data->os->getOutputToRootOnly());
1255 else if (solver==
"Rythmos") {
1257 TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::is_null(rythmos_observer_factory), std::runtime_error,
1258 "No Rythmos observer built! Please call setrythmosObserverFactory() member function if you plan to use a Rythmos solver.");
1261 if(rythmos_observer_factory->useNOXObserver()) {
1262 Teuchos::RCP<NOX::Abstract::PrePostOperator> ppo = nox_observer_factory->buildNOXObserver(m_mesh,m_global_indexer,m_lin_obj_factory);
1263 piro_params->sublist(
"NOX").sublist(
"Solver Options").set(
"User Defined Pre/Post Operator", ppo);
1267 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Output Stream",global_data->os);
1268 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Error Stream",global_data->os);
1269 piro_params->sublist(
"NOX").sublist(
"Printing").set<
int>(
"Output Processor",global_data->os->getOutputToRootOnly());
1272 Teuchos::RCP<Piro::RythmosSolver<double> > piro_rythmos;
1273 if(rythmosSolver==Teuchos::null)
1276 piro_rythmos = rythmosSolver;
1279 Teuchos::RCP<Thyra::ModelEvaluator<ScalarT> > rythmos_me = thyra_me;
1280 const std::string stepper_type = piro_params->sublist(
"Rythmos").get<std::string>(
"Stepper Type");
1281 if(stepper_type==
"Explicit RK" || stepper_type==
"Forward Euler") {
1282 const Teuchos::ParameterList & assembly_params = p.sublist(
"Assembly");
1283 bool lumpExplicitMass = assembly_params.get<
bool>(
"Lump Explicit Mass");
1287 piro_rythmos->initialize(piro_params, rythmos_me, rythmos_observer_factory->buildRythmosObserver(m_mesh,m_global_indexer,m_lin_obj_factory));
1289 piro = piro_rythmos;
1291#ifdef PANZER_HAVE_TEMPUS
1292 else if (solver==
"Tempus") {
1294 TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::is_null(tempus_observer_factory), std::runtime_error,
1295 "No Tempus observer built! Please call setTempusObserverFactory() member function if you plan to use a Tempus solver.");
1298 if(tempus_observer_factory->useNOXObserver()) {
1299 Teuchos::RCP<NOX::Abstract::PrePostOperator> ppo = nox_observer_factory->buildNOXObserver(m_mesh,m_global_indexer,m_lin_obj_factory);
1300 piro_params->sublist(
"NOX").sublist(
"Solver Options").set(
"User Defined Pre/Post Operator", ppo);
1304 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Output Stream",global_data->os);
1305 piro_params->sublist(
"NOX").sublist(
"Printing").set<Teuchos::RCP<std::ostream> >(
"Error Stream",global_data->os);
1306 piro_params->sublist(
"NOX").sublist(
"Printing").set<
int>(
"Output Processor",global_data->os->getOutputToRootOnly());
1309 Teuchos::RCP<Piro::TempusSolverForwardOnly<double> > piro_tempus;
1311 if(tempusSolver==Teuchos::null)
1314 Teuchos::rcp(
new Piro::TempusSolverForwardOnly<double>(piro_params, thyra_me,
1315 tempus_observer_factory->buildTempusObserver(m_mesh,m_global_indexer,m_lin_obj_factory)));
1319 piro_tempus = tempusSolver;
1320 piro_tempus->initialize(piro_params, thyra_me,
1321 tempus_observer_factory->buildTempusObserver(m_mesh,m_global_indexer,m_lin_obj_factory));
1328 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::logic_error,
1329 "Error: Unknown Piro Solver : " << solver);
1390 const Teuchos::RCP<Teuchos::ParameterList> & physics_block_plist,
1391 const Teuchos::RCP<const panzer::EquationSetFactory>& eqset_factory,
1394 bool is_transient,
bool is_explicit,
1395 const Teuchos::Ptr<const Teuchos::ParameterList> & bc_list,
1400 Teuchos::RCP<Thyra::ModelEvaluator<ScalarT> > physics_me = physics_me_in==Teuchos::null ? m_physics_me : physics_me_in;
1402 const Teuchos::ParameterList& p = *this->getParameterList();
1405 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
1407 const Teuchos::ParameterList & assembly_params = p.sublist(
"Assembly");
1410 std::map<std::string,std::string> block_ids_to_physics_ids;
1414 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
1415 for(std::map<std::string,std::string>::const_iterator itr=block_ids_to_physics_ids.begin();
1416 itr!=block_ids_to_physics_ids.end();++itr) {
1417 block_ids_to_cell_topo[itr->first] = m_mesh->getCellTopology(itr->first);
1418 TEUCHOS_ASSERT(block_ids_to_cell_topo[itr->first]!=Teuchos::null);
1421 std::size_t workset_size = Teuchos::as<std::size_t>(assembly_params.get<
int>(
"Workset Size"));
1423 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
1424 block_ids_to_cell_topo,
1425 physics_block_plist,
1426 assembly_params.get<
int>(
"Default Integration Order"),
1435 Teuchos::RCP<panzer::FieldManagerBuilder> fmb;
1437 const Teuchos::ParameterList & user_data_params = p.sublist(
"User Data");
1439 bool write_dot_files =
false;
1440 std::string prefix =
"Cloned_";
1442 std::vector<panzer::BC> bcs;
1443 if(bc_list==Teuchos::null) {
1444 panzer::buildBCs(bcs, p.sublist(
"Boundary Conditions"), m_global_data);
1447 panzer::buildBCs(bcs, *bc_list, m_global_data);
1450 fmb = buildFieldManagerBuilder(
1460 p.sublist(
"Closure Models"),
1463 write_dot_files,prefix,
1464 write_dot_files,prefix);
1467 Teuchos::RCP<panzer::ResponseLibrary<panzer::Traits> > response_library
1470 m_lin_obj_factory));
1478 Thyra::ModelEvaluatorBase::InArgs<ScalarT> nomVals = physics_me->getNominalValues();
1481 Teuchos::RCP<Thyra::EpetraModelEvaluator> ep_thyra_me = Teuchos::rcp_dynamic_cast<Thyra::EpetraModelEvaluator>(physics_me);
1482 Teuchos::RCP<PanzerME> panzer_me = Teuchos::rcp_dynamic_cast<PanzerME>(physics_me);
1483 bool useThyra =
true;
1484 if(ep_thyra_me!=Teuchos::null)
1488 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names(physics_me->Np());
1489 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values(physics_me->Np());
1490 for(std::size_t i=0;i<p_names.size();i++) {
1491 p_names[i] = Teuchos::rcp(
new Teuchos::Array<std::string>(*physics_me->get_p_names(i)));
1492 p_values[i] = Teuchos::rcp(
new Teuchos::Array<double>(p_names[i]->size(),0.0));
1495 Teuchos::RCP<Thyra::ModelEvaluatorDefaultBase<double> > thyra_me
1496 = buildPhysicsModelEvaluator(useThyra,
1508 thyra_me->getNominalValues() = nomVals;
1512 const Teuchos::ParameterList & assembly_params = p.sublist(
"Assembly");
1513 bool lumpExplicitMass = assembly_params.get<
bool>(
"Lump Explicit Mass");