diff --git a/packages/panzer/adapters-stk/src/Panzer_STK_Utilities.hpp b/packages/panzer/adapters-stk/src/Panzer_STK_Utilities.hpp index 0bd29fa0c41c..cfb3d78ebe38 100644 --- a/packages/panzer/adapters-stk/src/Panzer_STK_Utilities.hpp +++ b/packages/panzer/adapters-stk/src/Panzer_STK_Utilities.hpp @@ -8,15 +8,15 @@ // ***************************************************************************** // @HEADER -#ifdef PANZER_HAVE_EPETRA_STACK - #ifndef __Panzer_STK_Utilities_hpp__ #define __Panzer_STK_Utilities_hpp__ #include "Panzer_STK_Interface.hpp" +#ifdef PANZER_HAVE_EPETRA_STACK #include "Epetra_Vector.h" #include "Epetra_MultiVector.h" +#endif namespace panzer { class GlobalIndexer; @@ -34,9 +34,13 @@ namespace panzer_stk { */ void write_cell_data(panzer_stk::STK_Interface & mesh,const std::vector & data,const std::string & fieldName); +#ifdef PANZER_HAVE_EPETRA_STACK + void write_solution_data(const panzer::GlobalIndexer& dofMngr,panzer_stk::STK_Interface & mesh,const Epetra_MultiVector & x,const std::string & prefx="",const std::string & postfix=""); void write_solution_data(const panzer::GlobalIndexer& dofMngr,panzer_stk::STK_Interface & mesh,const Epetra_Vector & x,const std::string & prefix="",const std::string & postfix=""); +#endif // PANZER_HAVE_EPETRA_STACK + /** Using a container, compute the sorted permutation vector * do not modifiy the original container. * @@ -98,5 +102,3 @@ void sorted_permutation(const RAContainer & cont,std::vector & perm } #endif - -#endif // PANZER_HAVE_EPETRA_STACK \ No newline at end of file diff --git a/packages/panzer/adapters-stk/test/CMakeLists.txt b/packages/panzer/adapters-stk/test/CMakeLists.txt index 7f2e09c687a7..a01945825f5d 100644 --- a/packages/panzer/adapters-stk/test/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/CMakeLists.txt @@ -1,14 +1,13 @@ IF (PANZER_HAVE_EPETRA_STACK) - ADD_SUBDIRECTORY(assembly_engine) - ADD_SUBDIRECTORY(field_manager_builder) - ADD_SUBDIRECTORY(model_evaluator) ADD_SUBDIRECTORY(solver) - ADD_SUBDIRECTORY(ip_coordinates) - ADD_SUBDIRECTORY(bcstrategy) - ADD_SUBDIRECTORY(periodic_bcs) - ADD_SUBDIRECTORY(initial_condition_builder) ENDIF (PANZER_HAVE_EPETRA_STACK) +ADD_SUBDIRECTORY(model_evaluator) +ADD_SUBDIRECTORY(assembly_engine) +ADD_SUBDIRECTORY(bcstrategy) +ADD_SUBDIRECTORY(periodic_bcs) +ADD_SUBDIRECTORY(initial_condition_builder) +ADD_SUBDIRECTORY(field_manager_builder) ADD_SUBDIRECTORY(stk_interface_test) ADD_SUBDIRECTORY(stk_connmngr) ADD_SUBDIRECTORY(panzer_workset_builder) @@ -23,3 +22,4 @@ ADD_SUBDIRECTORY(projection) ADD_SUBDIRECTORY(transform_bc_names) ADD_SUBDIRECTORY(sideset_overlap) ADD_SUBDIRECTORY(interpolation) +ADD_SUBDIRECTORY(ip_coordinates) diff --git a/packages/panzer/adapters-stk/test/assembly_engine/assembly_engine.cpp b/packages/panzer/adapters-stk/test/assembly_engine/assembly_engine.cpp index 11d38fc12912..d28adb0138d6 100644 --- a/packages/panzer/adapters-stk/test/assembly_engine/assembly_engine.cpp +++ b/packages/panzer/adapters-stk/test/assembly_engine/assembly_engine.cpp @@ -29,7 +29,7 @@ using Teuchos::rcp; #include "Panzer_STK_WorksetFactory.hpp" #include "Panzer_FieldManagerBuilder.hpp" #include "Panzer_STKConnManager.hpp" -#include "Panzer_BlockedEpetraLinearObjFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" #include "Panzer_TpetraLinearObjFactory.hpp" #include "Panzer_AssemblyEngine.hpp" #include "Panzer_AssemblyEngine_InArgs.hpp" @@ -38,53 +38,59 @@ using Teuchos::rcp; #include "Panzer_DOFManagerFactory.hpp" #include "Panzer_GlobalData.hpp" #include "Panzer_PauseToAttach.hpp" +#include "Panzer_NodeType.hpp" #include "user_app_EquationSetFactory.hpp" #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" #include "user_app_BCStrategy_Factory.hpp" +#ifdef PANZER_HAVE_EPETRA_STACK #include "Epetra_Comm.h" +#include "Panzer_BlockedEpetraLinearObjFactory.hpp" #ifdef HAVE_MPI - #include "Teuchos_DefaultMpiComm.hpp" - #include "Epetra_MpiComm.h" +#include "Teuchos_DefaultMpiComm.hpp" +#include "Epetra_MpiComm.h" #else - #include "NO_SERIAL_BUILD.h" +#include "NO_SERIAL_BUILD.h" #endif +#include "Thyra_EpetraLinearOp.hpp" +#include "Thyra_EpetraThyraWrappers.hpp" +#endif // PANZER_HAVE_EPETRA_STACK + #include "Teuchos_DefaultMpiComm.hpp" #include "Teuchos_OpaqueWrapper.hpp" -#include "Thyra_EpetraLinearOp.hpp" -#include "Thyra_EpetraThyraWrappers.hpp" #include "Thyra_TpetraThyraWrappers.hpp" #include "Thyra_TpetraVector.hpp" #include "Thyra_TpetraVectorSpace.hpp" - #include "Thyra_LinearOpTester.hpp" #include "Thyra_TestingTools.hpp" #include // for get char -namespace panzer { +namespace panzer +{ - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs); + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs); - Teuchos::RCP > eLinearOp; - Teuchos::RCP > tLinearOp; + Teuchos::RCP> eLinearOp; + Teuchos::RCP> tLinearOp; - Teuchos::RCP > eVector; - Teuchos::RCP > tVector; + Teuchos::RCP> eVector; + Teuchos::RCP> tVector; + +#ifdef PANZER_HAVE_EPETRA_STACK TEUCHOS_UNIT_TEST(assembly_engine, basic_epetra) { using Teuchos::RCP; - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",6); - pl->set("Y Elements",4); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); @@ -96,20 +102,20 @@ namespace panzer { testInitialzation(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); @@ -118,25 +124,24 @@ namespace panzer { int default_integration_order = 1; panzer::buildPhysicsBlocks(block_ids_to_physics_ids, - block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, - eqset_factory, - gd, - false, - physicsBlocks); + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); // build DOF Manager @@ -144,16 +149,14 @@ namespace panzer { // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - Teuchos::RCP > eLinObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(),dofManager)); - Teuchos::RCP > linObjFactory = eLinObjFactory; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> eLinObjFactory = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(), dofManager)); + Teuchos::RCP> linObjFactory = eLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -164,34 +167,34 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); - RCP eGhosted - = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); - RCP eGlobal - = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + RCP eGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP eGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGhosted); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGhosted); eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGlobal); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGlobal); eGhosted->initialize(); eGlobal->initialize(); - panzer::AssemblyEngineInArgs input(eGhosted,eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); input.alpha = 0.0; input.beta = 1.0; @@ -199,23 +202,21 @@ namespace panzer { ae_tm.getAsObject()->evaluate(input); eLinearOp = Thyra::epetraLinearOp(eGlobal->get_A()); - eVector = Thyra::create_Vector(eGlobal->get_f(),eLinearOp->range()); - -// std::cout << *eVector << std::endl; -// std::cout << *eLinearOp << std::endl; + eVector = Thyra::create_Vector(eGlobal->get_f(), eLinearOp->range()); + // std::cout << *eVector << std::endl; + // std::cout << *eLinearOp << std::endl; } TEUCHOS_UNIT_TEST(assembly_engine, basic_epetra_in_stages) { using Teuchos::RCP; - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",6); - pl->set("Y Elements",4); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); @@ -227,20 +228,20 @@ namespace panzer { testInitialzation(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); @@ -249,25 +250,24 @@ namespace panzer { int default_integration_order = 1; panzer::buildPhysicsBlocks(block_ids_to_physics_ids, - block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, - eqset_factory, - gd, - false, - physicsBlocks); + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); // build DOF Manager @@ -275,16 +275,14 @@ namespace panzer { // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - Teuchos::RCP > eLinObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(),dofManager)); - Teuchos::RCP > linObjFactory = eLinObjFactory; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> eLinObjFactory = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(), dofManager)); + Teuchos::RCP> linObjFactory = eLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -295,49 +293,48 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); - RCP eGhosted - = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); - RCP eGlobal - = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + RCP eGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP eGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGhosted); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGhosted); eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGlobal); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGlobal); eGhosted->initialize(); eGlobal->initialize(); - panzer::AssemblyEngineInArgs input(eGhosted,eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); input.alpha = 0.0; input.beta = 1.0; - int flags1 = panzer::AssemblyEngine::EvaluationFlags::Initialize +panzer::AssemblyEngine::EvaluationFlags::VolumetricFill; + int flags1 = panzer::AssemblyEngine::EvaluationFlags::Initialize + panzer::AssemblyEngine::EvaluationFlags::VolumetricFill; int flags2 = panzer::AssemblyEngine::EvaluationFlags::All - flags1; ae_tm.getAsObject()->evaluate(input, panzer::AssemblyEngine::EvaluationFlags(flags1)); ae_tm.getAsObject()->evaluate(input, panzer::AssemblyEngine::EvaluationFlags(flags2)); ae_tm.getAsObject()->evaluate(input); eLinearOp = Thyra::epetraLinearOp(eGlobal->get_A()); - eVector = Thyra::create_Vector(eGlobal->get_f(),eLinearOp->range()); - -// std::cout << *eVector << std::endl; -// std::cout << *eLinearOp << std::endl; + eVector = Thyra::create_Vector(eGlobal->get_f(), eLinearOp->range()); + // std::cout << *eVector << std::endl; + // std::cout << *eLinearOp << std::endl; } TEUCHOS_UNIT_TEST(assembly_engine, dirichlet_only) @@ -345,12 +342,11 @@ namespace panzer { using Teuchos::RCP; using Teuchos::rcp_dynamic_cast; - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",6); - pl->set("Y Elements",4); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); @@ -362,20 +358,20 @@ namespace panzer { testInitialzation(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); @@ -384,25 +380,24 @@ namespace panzer { int default_integration_order = 1; panzer::buildPhysicsBlocks(block_ids_to_physics_ids, - block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, - eqset_factory, - gd, - false, - physicsBlocks); + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); // build DOF Manager @@ -410,16 +405,14 @@ namespace panzer { // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - Teuchos::RCP > eLinObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(),dofManager)); - Teuchos::RCP > linObjFactory = eLinObjFactory; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> eLinObjFactory = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(), dofManager)); + Teuchos::RCP> linObjFactory = eLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -430,128 +423,262 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); RCP ghosted = linObjFactory->buildGhostedLinearObjContainer(); - RCP global = linObjFactory->buildLinearObjContainer(); + RCP global = linObjFactory->buildLinearObjContainer(); eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F,*ghosted); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F, + *ghosted); eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F,*global); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F, + *global); ghosted->initialize(); global->initialize(); - Thyra::assign(Teuchos::rcp_dynamic_cast >(global,true)->get_x_th().ptr(),1.0); - Thyra::assign(Teuchos::rcp_dynamic_cast >(ghosted,true)->get_x_th().ptr(),-33.0); - panzer::AssemblyEngineInArgs input(ghosted,global); + Thyra::assign(Teuchos::rcp_dynamic_cast>(global, true)->get_x_th().ptr(), 1.0); + Thyra::assign(Teuchos::rcp_dynamic_cast>(ghosted, true)->get_x_th().ptr(), -33.0); + panzer::AssemblyEngineInArgs input(ghosted, global); input.alpha = 0.0; input.beta = 1.0; Teuchos::RCP counter = ae_tm.getAsObject()->evaluateOnlyDirichletBCs(input); - TEST_ASSERT(counter!=Teuchos::null); + TEST_ASSERT(counter != Teuchos::null); out << "evaluated" << std::endl; - RCP > count = Teuchos::rcp_dynamic_cast >(counter,true)->get_f_th(); - RCP > values = Teuchos::rcp_dynamic_cast >(global,true)->get_f_th(); + RCP> count = Teuchos::rcp_dynamic_cast>(counter, true)->get_f_th(); + RCP> values = Teuchos::rcp_dynamic_cast>(global, true)->get_f_th(); - TEST_ASSERT(count!=Teuchos::null); - TEST_ASSERT(values!=Teuchos::null); + TEST_ASSERT(count != Teuchos::null); + TEST_ASSERT(values != Teuchos::null); Teuchos::ArrayRCP count_array, values_array; - rcp_dynamic_cast >(count,true)->getNonconstLocalData(Teuchos::ptrFromRef(count_array)); - rcp_dynamic_cast >(values,true)->getNonconstLocalData(Teuchos::ptrFromRef(values_array)); + rcp_dynamic_cast>(count, true)->getNonconstLocalData(Teuchos::ptrFromRef(count_array)); + rcp_dynamic_cast>(values, true)->getNonconstLocalData(Teuchos::ptrFromRef(values_array)); bool passed = true; - TEST_EQUALITY(count_array.size(),values_array.size()); - for(Teuchos::ArrayRCP::size_type i=0;i::size_type i = 0; i < count_array.size(); i++) + { + if (count_array[i] == 0.0) + passed &= (values_array[i] == 0.0); + else + { + passed &= (std::fabs((values_array[i] - (-4.0)) / 4.0) < 1e-14); + out << values_array[i] << " " << i << std::endl; } } TEST_ASSERT(passed); - } +#endif TEUCHOS_UNIT_TEST(assembly_engine, basic_tpetra) { using Teuchos::RCP; { - // build global communicator - Teuchos::RCP > comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + // build global communicator + Teuchos::RCP> comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + RCP mesh = factory.buildMesh(MPI_COMM_WORLD); + + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzation(ipb, bcs); + + Teuchos::RCP fmb = + Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + const std::size_t workset_size = 20; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + { + const int default_integration_order = 1; + + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); + } + + // build worksets + ////////////////////////////////////////////////////////////// + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// + + // build the connection manager + const Teuchos::RCP + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + panzer::DOFManagerFactory globalIndexerFactory; + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + + Teuchos::RCP> linObjFactory = Teuchos::rcp(new panzer::TpetraLinearObjFactory(comm, dofManager)); + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::MyModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + RCP tGhosted = linObjFactory->buildGhostedLinearObjContainer(); + RCP tGlobal = linObjFactory->buildLinearObjContainer(); + linObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGhosted); + linObjFactory->initializeContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGlobal); + + tGhosted->initialize(); + tGlobal->initialize(); + + panzer::AssemblyEngineInArgs input(tGhosted, tGlobal); + input.alpha = 0.0; + input.beta = 1.0; + + ae_tm.getAsObject()->evaluate(input); + ae_tm.getAsObject()->evaluate(input); + + RCP> globalCont = Teuchos::rcp_dynamic_cast>(tGlobal); + + Teuchos::RCP> baseOp = globalCont->get_A(); + Teuchos::RCP> rangeSpace = Thyra::createVectorSpace(baseOp->getRangeMap()); + Teuchos::RCP> domainSpace = Thyra::createVectorSpace(baseOp->getDomainMap()); + + tLinearOp = Thyra::constTpetraLinearOp(rangeSpace, domainSpace, baseOp); + tVector = Thyra::constTpetraVector(Thyra::tpetraVectorSpace(baseOp->getRangeMap()).getConst(), + globalCont->get_f().getConst()); + } + } + + TEUCHOS_UNIT_TEST(assembly_engine, basic_tpetra_in_stages) + { + using Teuchos::RCP; RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",6); - pl->set("Y Elements",4); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); RCP mesh = factory.buildMesh(MPI_COMM_WORLD); + Teuchos::RCP> comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); std::vector bcs; testInitialzation(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - const int default_integration_order = 1; - - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); Teuchos::RCP gd = panzer::createGlobalData(); + int default_integration_order = 1; + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, - block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, - eqset_factory, - gd, - false, - physicsBlocks); + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); // build DOF Manager @@ -559,14 +686,14 @@ namespace panzer { // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > linObjFactory - = Teuchos::rcp(new panzer::TpetraLinearObjFactory(comm,dofManager)); + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> tLinObjFactory = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm, dofManager)); + Teuchos::RCP> linObjFactory = tLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -577,114 +704,271 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); - RCP tGhosted = linObjFactory->buildGhostedLinearObjContainer(); - RCP tGlobal = linObjFactory->buildLinearObjContainer(); - linObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | - panzer::LinearObjContainer::DxDt | - panzer::LinearObjContainer::F | - panzer::LinearObjContainer::Mat,*tGhosted); - linObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*tGlobal); - - // panzer::pauseToAttach(); + RCP tGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP tGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + tLinObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGhosted); + tLinObjFactory->initializeContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGlobal); tGhosted->initialize(); tGlobal->initialize(); - - panzer::AssemblyEngineInArgs input(tGhosted,tGlobal); + panzer::AssemblyEngineInArgs input(tGhosted, tGlobal); input.alpha = 0.0; input.beta = 1.0; - ae_tm.getAsObject()->evaluate(input); + int flags1 = panzer::AssemblyEngine::EvaluationFlags::Initialize + panzer::AssemblyEngine::EvaluationFlags::VolumetricFill; + int flags2 = panzer::AssemblyEngine::EvaluationFlags::All - flags1; + ae_tm.getAsObject()->evaluate(input, panzer::AssemblyEngine::EvaluationFlags(flags1)); + ae_tm.getAsObject()->evaluate(input, panzer::AssemblyEngine::EvaluationFlags(flags2)); ae_tm.getAsObject()->evaluate(input); - RCP > globalCont - = Teuchos::rcp_dynamic_cast >(tGlobal); + RCP> globalCont = Teuchos::rcp_dynamic_cast>(tGlobal); - Teuchos::RCP > baseOp = globalCont->get_A(); - Teuchos::RCP > rangeSpace = Thyra::createVectorSpace(baseOp->getRangeMap()); - Teuchos::RCP > domainSpace = Thyra::createVectorSpace(baseOp->getDomainMap()); + Teuchos::RCP> baseOp = globalCont->get_A(); + Teuchos::RCP> rangeSpace = Thyra::createVectorSpace(baseOp->getRangeMap()); + Teuchos::RCP> domainSpace = Thyra::createVectorSpace(baseOp->getDomainMap()); + + tLinearOp = Thyra::constTpetraLinearOp(rangeSpace, domainSpace, baseOp); + tVector = Thyra::constTpetraVector(Thyra::tpetraVectorSpace(baseOp->getRangeMap()).getConst(), + globalCont->get_f().getConst()); + } + + TEUCHOS_UNIT_TEST(assembly_engine, dirichlet_only_tpetra) + { + using Teuchos::RCP; + using Teuchos::rcp_dynamic_cast; + + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + RCP mesh = factory.buildMesh(MPI_COMM_WORLD); + Teuchos::RCP> comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzation(ipb, bcs); + + Teuchos::RCP fmb = + Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + const std::size_t workset_size = 20; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + { + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); - tLinearOp = Thyra::constTpetraLinearOp(rangeSpace, domainSpace, baseOp); - tVector = Thyra::constTpetraVector(Thyra::tpetraVectorSpace(baseOp->getRangeMap()).getConst(), - globalCont->get_f().getConst()); + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); + } + + // build worksets + ////////////////////////////////////////////////////////////// + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// + + // build the connection manager + const Teuchos::RCP + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + panzer::DOFManagerFactory globalIndexerFactory; + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> tLinObjFactory = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm, dofManager)); + Teuchos::RCP> linObjFactory = tLinObjFactory; + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::MyModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + RCP ghosted = linObjFactory->buildGhostedLinearObjContainer(); + RCP global = linObjFactory->buildLinearObjContainer(); + tLinObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F, + *ghosted); + tLinObjFactory->initializeContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F, + *global); + ghosted->initialize(); + global->initialize(); + + Thyra::assign(Teuchos::rcp_dynamic_cast>(global, true)->get_x_th().ptr(), 1.0); + Thyra::assign(Teuchos::rcp_dynamic_cast>(ghosted, true)->get_x_th().ptr(), -33.0); + panzer::AssemblyEngineInArgs input(ghosted, global); + input.alpha = 0.0; + input.beta = 1.0; + + Teuchos::RCP counter = ae_tm.getAsObject()->evaluateOnlyDirichletBCs(input); + TEST_ASSERT(counter != Teuchos::null); + + out << "evaluated" << std::endl; + RCP> count = Teuchos::rcp_dynamic_cast>(counter, true)->get_f_th(); + RCP> values = Teuchos::rcp_dynamic_cast>(global, true)->get_f_th(); + + TEST_ASSERT(count != Teuchos::null); + TEST_ASSERT(values != Teuchos::null); + + Teuchos::ArrayRCP count_array, values_array; + rcp_dynamic_cast>(count, true)->getNonconstLocalData(Teuchos::ptrFromRef(count_array)); + rcp_dynamic_cast>(values, true)->getNonconstLocalData(Teuchos::ptrFromRef(values_array)); + + bool passed = true; + TEST_EQUALITY(count_array.size(), values_array.size()); + for (Teuchos::ArrayRCP::size_type i = 0; i < count_array.size(); i++) + { + if (count_array[i] == 0.0) + passed &= (values_array[i] == 0.0); + else + { + passed &= (std::fabs((values_array[i] - (-4.0)) / 4.0) < 1e-14); + out << values_array[i] << " " << i << std::endl; + } } + TEST_ASSERT(passed); } TEUCHOS_UNIT_TEST(assembly_engine, z_basic_epetra_vtpetra) { + TEUCHOS_ASSERT(tLinearOp != Teuchos::null); + TEUCHOS_ASSERT(tVector != Teuchos::null); + +#ifdef PANZER_HAVE_EPETRA_STACK + TEUCHOS_ASSERT(eLinearOp != Teuchos::null); + TEUCHOS_ASSERT(eVector != Teuchos::null); +#endif - TEUCHOS_ASSERT(tLinearOp!=Teuchos::null); - TEUCHOS_ASSERT(eLinearOp!=Teuchos::null); - - TEUCHOS_ASSERT(tVector!=Teuchos::null); - TEUCHOS_ASSERT(eVector!=Teuchos::null); - - Thyra::LinearOpTester tester; - tester.set_all_error_tol(1e-14); - tester.show_all_tests(true); - tester.dump_all(true); - tester.num_random_vectors(200); - - { - const bool result = tester.compare( *tLinearOp, *eLinearOp, Teuchos::ptrFromRef(out) ); - TEST_ASSERT(result); - } - - { - const bool result = Thyra::testRelNormDiffErr( - "Tpetra",*tVector, - "Epetra",*eVector, - "linear_properties_error_tol()", 1e-14, - "linear_properties_warning_tol()", 1e-14, - &out); - TEST_ASSERT(result); - } - - - // Need to kill global objects so that memory leaks on kokkos ref - // count pointing doesn't trigger test failure. - eLinearOp = Teuchos::null; - tLinearOp = Teuchos::null; - eVector = Teuchos::null; - tVector = Teuchos::null; + Thyra::LinearOpTester tester; + tester.set_all_error_tol(1e-14); + tester.show_all_tests(true); + tester.dump_all(true); + tester.num_random_vectors(200); +#ifdef PANZER_HAVE_EPETRA_STACK + { + const bool result = tester.compare(*tLinearOp, *eLinearOp, Teuchos::ptrFromRef(out)); + TEST_ASSERT(result); + } + + { + const bool result = Thyra::testRelNormDiffErr( + "Tpetra", *tVector, + "Epetra", *eVector, + "linear_properties_error_tol()", 1e-14, + "linear_properties_warning_tol()", 1e-14, + &out); + TEST_ASSERT(result); + } +#endif + + // Need to kill global objects so that memory leaks on kokkos ref + // count pointing doesn't trigger test failure. +#ifdef PANZER_HAVE_EPETRA_STACK + eLinearOp = Teuchos::null; + eVector = Teuchos::null; +#endif + tLinearOp = Teuchos::null; + tLinearOp = Teuchos::null; + eVector = Teuchos::null; + tLinearOp = Teuchos::null; + eVector = Teuchos::null; + tVector = Teuchos::null; + tVector = Teuchos::null; + + tVector = Teuchos::null; } - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs) + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs) { // Physics block - Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); { - Teuchos::ParameterList& p = physics_block.sublist("a"); - p.set("Type","Energy"); - p.set("Prefix",""); - p.set("Model ID","solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",2); + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 2); } { - Teuchos::ParameterList& p = physics_block.sublist("b"); - p.set("Type","Energy"); - p.set("Prefix","ION_"); - p.set("Model ID","ion solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",1); + Teuchos::ParameterList &p = physics_block.sublist("b"); + p.set("Type", "Energy"); + p.set("Prefix", "ION_"); + p.set("Model ID", "ion solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); } // BCs @@ -697,9 +981,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -711,9 +995,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -725,9 +1009,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } } diff --git a/packages/panzer/adapters-stk/test/assembly_engine/simple_bc.cpp b/packages/panzer/adapters-stk/test/assembly_engine/simple_bc.cpp index 30272bcdc8db..28c5a0fec219 100644 --- a/packages/panzer/adapters-stk/test/assembly_engine/simple_bc.cpp +++ b/packages/panzer/adapters-stk/test/assembly_engine/simple_bc.cpp @@ -28,7 +28,7 @@ using Teuchos::rcp; #include "Panzer_Workset_Builder.hpp" #include "Panzer_WorksetContainer.hpp" #include "Panzer_STK_WorksetFactory.hpp" -#include "Panzer_BlockedEpetraLinearObjFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" #include "Panzer_FieldManagerBuilder.hpp" #include "Panzer_STKConnManager.hpp" #include "Panzer_AssemblyEngine.hpp" @@ -41,7 +41,10 @@ using Teuchos::rcp; #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" #include "user_app_BCStrategy_Factory.hpp" +#ifdef PANZER_HAVE_EPETRA_STACK #include "Epetra_MpiComm.h" +#include "Panzer_BlockedEpetraLinearObjFactory.hpp" +#endif #include "Teuchos_DefaultMpiComm.hpp" #include "Teuchos_OpaqueWrapper.hpp" @@ -49,24 +52,25 @@ using Teuchos::rcp; // This unit test set tracks some particularly nasty corner cases for // boundary conditions. -namespace panzer { +namespace panzer +{ - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs); + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs); - void testInitialzation_multiblock(const Teuchos::RCP& ipb, - std::vector& bcs); + void testInitialzation_multiblock(const Teuchos::RCP &ipb, + std::vector &bcs); +#ifdef PANZER_HAVE_EPETRA_STACK TEUCHOS_UNIT_TEST(bc_test, basic) { using Teuchos::RCP; - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",1); - pl->set("Y Blocks",1); - pl->set("X Elements",2); - pl->set("Y Elements",1); + pl->set("X Blocks", 1); + pl->set("Y Blocks", 1); + pl->set("X Elements", 2); + pl->set("Y Elements", 1); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); @@ -74,24 +78,24 @@ namespace panzer { RCP Comm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD)); Teuchos::RCP ipb = - Teuchos::parameterList("Physics Blocks"); + Teuchos::parameterList("Physics Blocks"); std::vector bcs; testInitialzation(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); Teuchos::RCP gd = panzer::createGlobalData(); @@ -100,41 +104,38 @@ namespace panzer { panzer::buildPhysicsBlocks(block_ids_to_physics_ids, block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, + ipb, + default_integration_order, + workset_size, eqset_factory, - gd, - false, + gd, + false, physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); - // build DOF Manager - ///////////////////////////////////////////////////////////// + // build DOF Manager + ///////////////////////////////////////////////////////////// - // build the connection manager + // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - Teuchos::RCP > eLinObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(),dofManager)); - Teuchos::RCP > linObjFactory = eLinObjFactory; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> eLinObjFactory = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(), dofManager)); + Teuchos::RCP> linObjFactory = eLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -145,61 +146,181 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); - RCP eGhosted - = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); - RCP eGlobal - = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + RCP eGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP eGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGhosted); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGhosted); eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGlobal); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGlobal); eGlobal->initialize(); eGhosted->initialize(); - panzer::AssemblyEngineInArgs input(eGhosted,eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); input.alpha = 0.0; input.beta = 1.0; ae_tm.getAsObject()->evaluate(input); ae_tm.getAsObject()->evaluate(input); } +#endif - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs) + TEUCHOS_UNIT_TEST(bc_test, basic_tpetra) + { + using Teuchos::RCP; + + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 1); + pl->set("Y Blocks", 1); + pl->set("X Elements", 2); + pl->set("Y Elements", 1); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + RCP mesh = factory.buildMesh(MPI_COMM_WORLD); + Teuchos::RCP> Comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + + Teuchos::RCP ipb = + Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzation(ipb, bcs); + + Teuchos::RCP fmb = + Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + const std::size_t workset_size = 20; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + { + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); + } + + // build worksets + ////////////////////////////////////////////////////////////// + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// + + // build the connection manager + const Teuchos::RCP + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + panzer::DOFManagerFactory globalIndexerFactory; + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> tLinObjFactory = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm, dofManager)); + Teuchos::RCP> linObjFactory = tLinObjFactory; + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::MyModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + RCP tGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP tGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + tLinObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGhosted); + tLinObjFactory->initializeContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGlobal); + tGlobal->initialize(); + tGhosted->initialize(); + panzer::AssemblyEngineInArgs input(tGhosted, tGlobal); + input.alpha = 0.0; + input.beta = 1.0; + + ae_tm.getAsObject()->evaluate(input); + ae_tm.getAsObject()->evaluate(input); + } + + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs) { // Physics block - Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); { - Teuchos::ParameterList& p = physics_block.sublist("a"); - p.set("Type","Energy"); - p.set("Prefix",""); - p.set("Model ID","solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",1); + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); } { - Teuchos::ParameterList& p = physics_block.sublist("b"); - p.set("Type","Energy"); - p.set("Prefix","ION_"); - p.set("Model ID","ion solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",1); + Teuchos::ParameterList &p = physics_block.sublist("b"); + p.set("Type", "Energy"); + p.set("Prefix", "ION_"); + p.set("Model ID", "ion solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); } // TEMPERATURE BCs @@ -212,9 +333,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 3.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -226,9 +347,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -240,9 +361,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 6.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -254,9 +375,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 4.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } @@ -270,9 +391,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 13.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -284,9 +405,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 15.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -298,9 +419,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 16.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -312,25 +433,25 @@ namespace panzer { std::string strategy = "Constant"; double value = 14.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } } +#ifdef PANZER_HAVE_EPETRA_STACK // ******************************************************************************* // ******************************************************************************* TEUCHOS_UNIT_TEST(bc_test, multiblock) { using Teuchos::RCP; - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",2); - pl->set("Y Elements",1); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 2); + pl->set("Y Elements", 1); panzer_stk::SquareQuadMeshFactory factory; factory.setParameterList(pl); @@ -338,27 +459,27 @@ namespace panzer { RCP Comm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD)); int myRank = Comm->MyPID(); - TEUCHOS_ASSERT(Comm->NumProc()==2); + TEUCHOS_ASSERT(Comm->NumProc() == 2); Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); std::vector bcs; testInitialzation_multiblock(ipb, bcs); Teuchos::RCP fmb = - Teuchos::rcp(new panzer::FieldManagerBuilder); + Teuchos::rcp(new panzer::FieldManagerBuilder); // build physics blocks ////////////////////////////////////////////////////////////// const std::size_t workset_size = 20; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; - std::vector > physicsBlocks; + std::vector> physicsBlocks; { - std::map block_ids_to_physics_ids; + std::map block_ids_to_physics_ids; block_ids_to_physics_ids["eblock-0_0"] = "test physics"; block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; + std::map> block_ids_to_cell_topo; block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); @@ -368,41 +489,38 @@ namespace panzer { panzer::buildPhysicsBlocks(block_ids_to_physics_ids, block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, + ipb, + default_integration_order, + workset_size, eqset_factory, - gd, - false, + gd, + false, physicsBlocks); } // build worksets ////////////////////////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physicsBlocks[i]->elementBlockID(),physicsBlocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); - // build DOF Manager - ///////////////////////////////////////////////////////////// + // build DOF Manager + ///////////////////////////////////////////////////////////// - // build the connection manager + // build the connection manager const Teuchos::RCP - conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); panzer::DOFManagerFactory globalIndexerFactory; - RCP dofManager - = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - Teuchos::RCP > eLinObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(),dofManager)); - Teuchos::RCP > linObjFactory = eLinObjFactory; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> eLinObjFactory = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tComm.getConst(), dofManager)); + Teuchos::RCP> linObjFactory = eLinObjFactory; // setup field manager build ///////////////////////////////////////////////////////////// @@ -413,131 +531,374 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb->setWorksetContainer(wkstContainer); - fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data); - fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); panzer::AssemblyEngine_TemplateManager ae_tm; - panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory); + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); ae_tm.buildObjects(builder); - RCP eGhosted - = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); - RCP eGlobal - = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + RCP eGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP eGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGhosted); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGhosted); eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X | - panzer::EpetraLinearObjContainer::DxDt | - panzer::EpetraLinearObjContainer::F | - panzer::EpetraLinearObjContainer::Mat,*eGlobal); + panzer::EpetraLinearObjContainer::DxDt | + panzer::EpetraLinearObjContainer::F | + panzer::EpetraLinearObjContainer::Mat, + *eGlobal); eGhosted->initialize(); eGlobal->initialize(); - panzer::AssemblyEngineInArgs input(eGhosted,eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); input.alpha = 0.0; input.beta = 1.0; ae_tm.getAsObject()->evaluate(input); - const Epetra_Vector & f = *eGlobal->get_f(); + const Epetra_Vector &f = *eGlobal->get_f(); std::vector GIDs; - if(myRank==0) { - dofManager->getElementGIDs(1,GIDs,"eblock-1_0"); // in eblock-1_0 + if (myRank == 0) + { + dofManager->getElementGIDs(1, GIDs, "eblock-1_0"); // in eblock-1_0 - int gid = GIDs[3]; // top left corner at block interface - int lid = f.Map().LID(gid); + int gid = GIDs[3]; // top left corner at block interface + int lid = f.Map().LID(gid); - if(lid>=0) - TEST_EQUALITY(f[lid],-3.0); + if (lid >= 0) + TEST_EQUALITY(f[lid], -3.0); } - else if(myRank==1) { - dofManager->getElementGIDs(0,GIDs,"eblock-0_0"); // in eblock-0_0 - int gid = GIDs[2]; // top right corner at block interface - int lid = f.Map().LID(gid); + else if (myRank == 1) + { + dofManager->getElementGIDs(0, GIDs, "eblock-0_0"); // in eblock-0_0 + int gid = GIDs[2]; // top right corner at block interface + int lid = f.Map().LID(gid); - if(lid>=0) - TEST_EQUALITY(f[lid],-3.0); + if (lid >= 0) + TEST_EQUALITY(f[lid], -3.0); } else - TEUCHOS_ASSERT(false); + TEUCHOS_ASSERT(false); ae_tm.getAsObject()->evaluate(input); - const Epetra_CrsMatrix & A = *eGlobal->get_A(); + const Epetra_CrsMatrix &A = *eGlobal->get_A(); - if(myRank==0) { - dofManager->getElementGIDs(1,GIDs,"eblock-1_0"); // in eblock-1_0 + if (myRank == 0) + { + dofManager->getElementGIDs(1, GIDs, "eblock-1_0"); // in eblock-1_0 + + panzer::GlobalOrdinal gid = GIDs[3]; // top left corner at block interface + int lid = f.Map().LID(gid); + + if (lid >= 0) + { + TEST_EQUALITY(f[lid], -3.0); + + int numEntries = 0; + int *indices = 0; + double *values = 0; + A.ExtractMyRowView(lid, numEntries, values, indices); + + double sum = 0.0; + for (int i = 0; i < numEntries; i++) + { + sum += values[i]; + if (values[i] != 0.0) + { + TEST_EQUALITY(values[i], 1.0); + } // diag entry should be 0 + else + { + TEST_EQUALITY(values[i], 0.0); + } // all non diag entries should be 0 + } + TEST_EQUALITY(sum, 1.0); // only one entry allowed to be 1 + } + } + else if (myRank == 1) + { + dofManager->getElementGIDs(0, GIDs, "eblock-0_0"); // in eblock-0_0 + int gid = GIDs[2]; // top right corner at block interface + int lid = f.Map().LID(gid); + + if (lid >= 0) + { + TEST_EQUALITY(f[lid], -3.0); + + int numEntries = 0; + int *indices = 0; + double *values = 0; + A.ExtractMyRowView(lid, numEntries, values, indices); + + double sum = 0.0; + for (int i = 0; i < numEntries; i++) + { + sum += values[i]; + if (values[i] != 0.0) + { + TEST_EQUALITY(values[i], 1.0); + } // diag entry should be 0 + else + { + TEST_EQUALITY(values[i], 0.0); + } // all non diag entries should be 0 + } + TEST_EQUALITY(sum, 1.0); // only one entry allowed to be 1 + } + } + else + { + TEUCHOS_ASSERT(false); + } + } +#endif - panzer::GlobalOrdinal gid = GIDs[3]; // top left corner at block interface - int lid = f.Map().LID(gid); + // ******************************************************************************* + // ******************************************************************************* + TEUCHOS_UNIT_TEST(bc_test, multiblock_tpetra) + { + using TpetraRowMatrix = Tpetra::RowMatrix; + using Teuchos::RCP; + + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 2); + pl->set("Y Elements", 1); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + RCP mesh = factory.buildMesh(MPI_COMM_WORLD); + Teuchos::RCP> Comm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + int myRank = Comm->getRank(); + + TEUCHOS_ASSERT(Comm->getSize() == 2); + + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzation_multiblock(ipb, bcs); + + Teuchos::RCP fmb = + Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + const std::size_t workset_size = 20; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + { + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physicsBlocks); + } + + // build worksets + ////////////////////////////////////////////////////////////// + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// - if(lid>=0) { - TEST_EQUALITY(f[lid],-3.0); + // build the connection manager + const Teuchos::RCP + conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + panzer::DOFManagerFactory globalIndexerFactory; + RCP dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP> tLinObjFactory = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm, dofManager)); + Teuchos::RCP> linObjFactory = tLinObjFactory; + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::MyModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, bc_factory, closure_models, *linObjFactory, user_data); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + RCP tGhosted = Teuchos::rcp_dynamic_cast(linObjFactory->buildGhostedLinearObjContainer()); + RCP tGlobal = Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + tLinObjFactory->initializeGhostedContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGhosted); + tLinObjFactory->initializeContainer(panzer::LinearObjContainer::X | + panzer::LinearObjContainer::DxDt | + panzer::LinearObjContainer::F | + panzer::LinearObjContainer::Mat, + *tGlobal); + tGhosted->initialize(); + tGlobal->initialize(); + panzer::AssemblyEngineInArgs input(tGhosted, tGlobal); + input.alpha = 0.0; + input.beta = 1.0; + + ae_tm.getAsObject()->evaluate(input); + + RCP> globalCont = Teuchos::rcp_dynamic_cast>(tGlobal); + + auto f = globalCont->get_f(); + + std::vector GIDs; + if (myRank == 0) + { + dofManager->getElementGIDs(1, GIDs, "eblock-1_0"); // in eblock-1_0 + + int gid = GIDs[3]; // top left corner at block interface + int lid = f->getMap()->getLocalElement(gid); + + if (lid >= 0) + TEST_EQUALITY(f->getData(0)[lid], -3.0); + } + else if (myRank == 1) + { + dofManager->getElementGIDs(0, GIDs, "eblock-0_0"); // in eblock-0_0 + int gid = GIDs[2]; // top right corner at block interface + int lid = f->getMap()->getLocalElement(gid); + + if (lid >= 0) + TEST_EQUALITY(f->getData(0)[lid], -3.0); + } + else + TEUCHOS_ASSERT(false); - int numEntries = 0; - int * indices = 0; - double * values = 0; - A.ExtractMyRowView(lid,numEntries,values,indices); + ae_tm.getAsObject()->evaluate(input); - double sum = 0.0; - for(int i=0;iget_A(); + + if (myRank == 0) + { + dofManager->getElementGIDs(1, GIDs, "eblock-1_0"); // in eblock-1_0 + + panzer::GlobalOrdinal gid = GIDs[3]; // top left corner at block interface + int lid = f->getMap()->getLocalElement(gid); + + if (lid >= 0) + { + TEST_EQUALITY(f->getData(0)[lid], -3.0); + + double sum = 0.0; + TpetraRowMatrix::local_inds_host_view_type indices; + TpetraRowMatrix::values_host_view_type values; + + A->getLocalRowView(lid, indices, values); + auto gI = A->getRowMap()->getGlobalElement(lid); + for (size_t j = 0; j < indices.extent(0); j++) + { + auto gJ = A->getColMap()->getGlobalElement(indices[j]); + sum += values[j]; + if (values[j] != 0.0) + { + TEST_EQUALITY(values[j], 1.0); + } // diag entry should be 0 + else + { + TEST_EQUALITY(values[j], 0.0); + } // all non diag entries should be 0 + } + TEST_EQUALITY(sum, 1.0); // only one entry allowed to be 1 + } } - else if(myRank==1) { - dofManager->getElementGIDs(0,GIDs,"eblock-0_0"); // in eblock-0_0 - int gid = GIDs[2]; // top right corner at block interface - int lid = f.Map().LID(gid); - - if(lid>=0) { - TEST_EQUALITY(f[lid],-3.0); - - int numEntries = 0; - int * indices = 0; - double * values = 0; - A.ExtractMyRowView(lid,numEntries,values,indices); - - double sum = 0.0; - for(int i=0;igetElementGIDs(0, GIDs, "eblock-0_0"); // in eblock-0_0 + int gid = GIDs[2]; // top right corner at block interface + int lid = f->getMap()->getLocalElement(gid); + + if (lid >= 0) + { + TEST_EQUALITY(f->getData(0)[lid], -3.0); + + double sum = 0.0; + TpetraRowMatrix::local_inds_host_view_type indices; + TpetraRowMatrix::values_host_view_type values; + + A->getLocalRowView(lid, indices, values); + auto gI = A->getRowMap()->getGlobalElement(lid); + for (size_t j = 0; j < indices.extent(0); j++) + { + auto gJ = A->getColMap()->getGlobalElement(indices[j]); + sum += values[j]; + if (values[j] != 0.0) + { + TEST_EQUALITY(values[j], 1.0); + } // diag entry should be 0 + else + { + TEST_EQUALITY(values[j], 0.0); + } // all non diag entries should be 0 + } + TEST_EQUALITY(sum, 1.0); // only one entry allowed to be 1 + } } - else { - TEUCHOS_ASSERT(false); + else + { + TEUCHOS_ASSERT(false); } } - void testInitialzation_multiblock(const Teuchos::RCP& ipb, - std::vector& bcs) + void testInitialzation_multiblock(const Teuchos::RCP &ipb, + std::vector &bcs) { // Physics block - Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); { - Teuchos::ParameterList& p = physics_block.sublist("a"); - p.set("Type","Energy"); - p.set("Prefix",""); - p.set("Model ID","solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",2); - p.set("Integration Order",1); + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 2); + p.set("Integration Order", 1); } // TEMPERATURE BCs @@ -550,9 +911,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 3.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -564,9 +925,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } } diff --git a/packages/panzer/adapters-stk/test/bcstrategy/CMakeLists.txt b/packages/panzer/adapters-stk/test/bcstrategy/CMakeLists.txt index 7e5e29d7de40..143886ef0272 100644 --- a/packages/panzer/adapters-stk/test/bcstrategy/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/bcstrategy/CMakeLists.txt @@ -7,18 +7,23 @@ TRIBITS_INCLUDE_DIRECTORIES(${PARENT_PACKAGE_SOURCE_DIR}/disc-fe/test/closure_mo SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) -SET(SOURCES - bcstrategy.cpp +SET(COMMON_HEADERS user_app_BCStrategy_Dirichlet_Constant.hpp user_app_BCStrategy_Dirichlet_Constant_impl.hpp user_app_BCStrategy_Neumann_Constant.hpp user_app_BCStrategy_Neumann_Constant_impl.hpp user_app_BCStrategy_Factory.hpp - ) + ) + + + +SET(SOURCES_TPETRA + bcstrategy_tpetra.cpp + ) TRIBITS_ADD_EXECUTABLE_AND_TEST( - bcstrategy - SOURCES ${SOURCES} ${UNIT_TEST_DRIVER} + bcstrategy_tpetra + SOURCES ${SOURCES_TPETRA} ${COMMON_HEADERS} ${UNIT_TEST_DRIVER} NUM_MPI_PROCS 1 ) @@ -26,4 +31,17 @@ TRIBITS_ADD_EXECUTABLE_AND_TEST( bcstrategy_composite_factory SOURCES bcstrategy_composite_factory.cpp ${UNIT_TEST_DRIVER} user_app_BCStrategy_Dirichlet_Constant.hpp user_app_BCStrategy_Dirichlet_Constant_impl.hpp user_app_BCStrategy_Factory_Physics1.hpp user_app_BCStrategy_Factory_Physics2.hpp NUM_MPI_PROCS 1 - ) \ No newline at end of file + ) + +IF (PANZER_HAVE_EPETRA) + SET(SOURCES_EPETRA + bcstrategy.cpp + ) + TRIBITS_ADD_EXECUTABLE_AND_TEST( + bcstrategy_epetra + SOURCES ${SOURCES_EPETRA} ${COMMON_HEADERS} ${UNIT_TEST_DRIVER} + NUM_MPI_PROCS 1 + ) +ENDIF(PANZER_HAVE_EPETRA) + + diff --git a/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_composite_factory.cpp b/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_composite_factory.cpp index ced2a91d3780..d1c68a2c5182 100644 --- a/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_composite_factory.cpp +++ b/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_composite_factory.cpp @@ -43,13 +43,10 @@ #include "user_app_EquationSetFactory.hpp" #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" -#include "Epetra_MpiComm.h" - namespace panzer { TEUCHOS_UNIT_TEST(bcstrategy, basic_construction) { - std::size_t bc_id = 0; panzer::BCType neumann = BCT_Dirichlet; std::string sideset_id = "4"; diff --git a/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_tpetra.cpp b/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_tpetra.cpp new file mode 100644 index 000000000000..e2d79562e103 --- /dev/null +++ b/packages/panzer/adapters-stk/test/bcstrategy/bcstrategy_tpetra.cpp @@ -0,0 +1,359 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include +#include +#include + +#include "Panzer_BC.hpp" +#include "Panzer_BCStrategy.hpp" +#include "Panzer_Traits.hpp" +#include "Tpetra_CrsMatrix.hpp" +#include "Tpetra_Vector.hpp" +#include "user_app_BCStrategy_Factory.hpp" +#include + +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_WorksetContainer.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_AssemblyEngine.hpp" +#include "Panzer_AssemblyEngine_InArgs.hpp" +#include "Panzer_AssemblyEngine_TemplateBuilder.hpp" +#include "Panzer_AssemblyEngine_TemplateManager.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_GlobalData.hpp" +#include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_EquationSetFactory.hpp" + +using ST = double; +using LO = panzer::LocalOrdinal; +using GO = panzer::GlobalOrdinal; +using NT = panzer::TpetraNodeType; +using TpetraVector = Tpetra::Vector; +using TpetraLOC = panzer::TpetraLinearObjContainer; +using TpetraRowMatrix = Tpetra::RowMatrix; + +namespace panzer { + +void testInitialzationTpetra(const Teuchos::RCP &ipb, + std::vector &bcs); + +TEUCHOS_UNIT_TEST(bcstrategy, basic_construction_tpetra) { + + std::size_t bc_id = 0; + panzer::BCType dirichlet = BCT_Dirichlet; + std::string sideset_id = "4"; + std::string element_block_id = "fluid"; + std::string dof_name = "UX"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, dirichlet, sideset_id, element_block_id, dof_name, + strategy, p); + + Teuchos::RCP> bcs; + + Teuchos::RCP gd = panzer::createGlobalData(); + + user_app::BCFactory my_factory; + bcs = my_factory.buildBCStrategy(bc, gd); +} + +TEUCHOS_UNIT_TEST(bcstrategy, constant_bc_strategy_tpetra) { + + using std::cout; + using std::endl; + using Teuchos::RCP; + + auto pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 1); + pl->set("Y Blocks", 1); + pl->set("X Elements", 1); + pl->set("Y Elements", 1); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + auto mesh = factory.buildMesh(MPI_COMM_WORLD); + + auto ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzationTpetra(ipb, bcs); + + Teuchos::RCP fmb = + Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + const std::size_t workset_size = 1; + auto eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + { + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + + std::map> + block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + const int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, block_ids_to_cell_topo, + ipb, default_integration_order, workset_size, + eqset_factory, gd, false, physicsBlocks); + } + + // build worksets + ////////////////////////////////////////////////////////////// + auto wkstFactory = Teuchos::rcp( + new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP + wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), + physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// + + // build the connection manager + const Teuchos::RCP conn_manager = + Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + auto tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + panzer::DOFManagerFactory globalIndexerFactory; + RCP dofManager = + globalIndexerFactory.buildGlobalIndexer( + Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + + // auto dofManagerCasted = + // Teuchos::rcp_dynamic_cast(dofManager); + // Teuchos::RCP + // > eLinObjFactory + // = Teuchos::rcp(new + // panzer::BlockedTpetraLinearObjFactory(tComm.getConst(), + // dofManagerCasted)); + + // and linear object factory + auto eLinObjFactory = Teuchos::rcp( + new panzer::TpetraLinearObjFactory< + panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>( + tComm.getConst(), dofManager)); + + Teuchos::RCP> linObjFactory = + eLinObjFactory; + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::MyModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid") + .sublist("SOURCE_TEMPERATURE") + .set("Value", 1.0); + closure_models.sublist("ion solid") + .sublist("SOURCE_ION_TEMPERATURE") + .set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, + *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, + bc_factory, closure_models, *linObjFactory, + user_data); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + auto eGhosted = Teuchos::rcp_dynamic_cast( + linObjFactory->buildGhostedLinearObjContainer()); + auto eGlobal = Teuchos::rcp_dynamic_cast( + linObjFactory->buildLinearObjContainer()); + eLinObjFactory->initializeGhostedContainer(TpetraLOC::X | TpetraLOC::DxDt | + TpetraLOC::F | TpetraLOC::Mat, + *eGhosted); + eLinObjFactory->initializeContainer( + TpetraLOC::X | TpetraLOC::DxDt | TpetraLOC::F | TpetraLOC::Mat, *eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); + + // MPL TORM input.container_: LinearObjContainer + const auto x = Teuchos::rcp_dynamic_cast(input.container_); + + x->get_x()->putScalar(1.0); + input.beta = 1.0; + + ae_tm.getAsObject()->evaluate(input); + ae_tm.getAsObject()->evaluate(input); + + // Check residual values. Evaluation should have put (x - 5.0) + // into each residual. With initial guess of 1.0, check to make + // sure each entry in residual has -4.0. Note that we are using + // one element with same dirichlet bc on each side, so all nodes + // have same dirichlet bc applied to it. + + auto f = Teuchos::rcp_dynamic_cast(input.container_)->get_f(); + ST tol = 10.0 * std::numeric_limits::epsilon(); + auto fData = f->getData(0); + for (int i = 0; i < fData.size(); ++i) { + TEST_FLOATING_EQUALITY(fData[i], -4.0, tol); + } + + // Check Jacobian values. Should have one on diagonal and zero + // elsewhere. + auto jac = Teuchos::rcp_dynamic_cast(input.container_)->get_A(); + for (size_t i = 0; i < jac->getLocalNumRows(); ++i) { + TpetraRowMatrix::local_inds_host_view_type indices; + TpetraRowMatrix::values_host_view_type values; + jac->getLocalRowView(i, indices, values); + GO gI = jac->getRowMap()->getGlobalElement(i); + for (size_t j = 0; j < indices.extent(0); j++) { + GO gJ = jac->getColMap()->getGlobalElement(indices[j]); + std::cout << "J(" << gI << "," << gJ << ") = " << values[j] << std::endl; + if (gI == gJ) { + // Diagonal entry; value should be row GO + TEST_FLOATING_EQUALITY(values[j], 1.0, tol); + } else { + // Nondiagonal entry; value should be 0.0 + TEST_FLOATING_EQUALITY(values[j], 0.0, tol); + } + } + } + + jac->print(std::cout); +} + +void testInitialzationTpetra(const Teuchos::RCP &ipb, + std::vector &bcs) { + // Physics block + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); + { + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); + } + + { + std::size_t bc_id = 0; + panzer::BCType dirichlet = BCT_Dirichlet; + std::string sideset_id = "left"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, dirichlet, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 1; + panzer::BCType dirichlet = BCT_Dirichlet; + std::string sideset_id = "right"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, dirichlet, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 2; + panzer::BCType dirichlet = BCT_Dirichlet; + std::string sideset_id = "top"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, dirichlet, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 3; + panzer::BCType dirichlet = BCT_Dirichlet; + std::string sideset_id = "bottom"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, dirichlet, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } +} + +} // namespace panzer diff --git a/packages/panzer/adapters-stk/test/field_manager_builder/field_manager_builder.cpp b/packages/panzer/adapters-stk/test/field_manager_builder/field_manager_builder.cpp index 3f0d2280ed3d..c5aa39c17966 100644 --- a/packages/panzer/adapters-stk/test/field_manager_builder/field_manager_builder.cpp +++ b/packages/panzer/adapters-stk/test/field_manager_builder/field_manager_builder.cpp @@ -12,6 +12,7 @@ #include #include #include +#include using Teuchos::RCP; using Teuchos::rcp; @@ -29,30 +30,27 @@ using Teuchos::rcp; #include "Panzer_FieldManagerBuilder.hpp" #include "Panzer_STKConnManager.hpp" #include "Panzer_DOFManagerFactory.hpp" -#include "Panzer_BlockedEpetraLinearObjFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" #include "Panzer_GlobalData.hpp" #include "user_app_EquationSetFactory.hpp" #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" #include "user_app_BCStrategy_Factory.hpp" -#include "Epetra_MpiComm.h" -#include "Epetra_Comm.h" - #include #include #include -namespace panzer { +namespace panzer +{ - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs); + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs); TEUCHOS_UNIT_TEST(field_manager_builder, incremental_setup_interface) { using Teuchos::RCP; - panzer_stk::SquareQuadMeshFactory mesh_factory; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); user_app::BCFactory bc_factory; @@ -64,70 +62,67 @@ namespace panzer { ///////////////////////////////////////////// RCP mesh; { - RCP pl = rcp(new Teuchos::ParameterList); - pl->set("X Blocks",2); - pl->set("Y Blocks",1); - pl->set("X Elements",6); - pl->set("Y Elements",4); - mesh_factory.setParameterList(pl); - mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 6); + pl->set("Y Elements", 4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); } // setup physic blocks ///////////////////////////////////////////// Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); std::vector bcs; - std::vector > physics_blocks; + std::vector> physics_blocks; { - testInitialzation(ipb, bcs); + testInitialzation(ipb, bcs); - std::map block_ids_to_physics_ids; - block_ids_to_physics_ids["eblock-0_0"] = "test physics"; - block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; - std::map > block_ids_to_cell_topo; - block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); - block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); - Teuchos::RCP gd = panzer::createGlobalData(); + Teuchos::RCP gd = panzer::createGlobalData(); int default_integration_order = 1; - panzer::buildPhysicsBlocks(block_ids_to_physics_ids, - block_ids_to_cell_topo, - ipb, - default_integration_order, - workset_size, - eqset_factory, - gd, - false, - physics_blocks); + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physics_blocks); } // setup worksets ///////////////////////////////////////////// - Teuchos::RCP wkstFactory - = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory - Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) - = Teuchos::rcp(new panzer::WorksetContainer); + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); wkstContainer->setFactory(wkstFactory); - for(size_t i=0;isetNeeds(physics_blocks[i]->elementBlockID(),physics_blocks[i]->getWorksetNeeds()); + for (size_t i = 0; i < physics_blocks.size(); i++) + wkstContainer->setNeeds(physics_blocks[i]->elementBlockID(), physics_blocks[i]->getWorksetNeeds()); wkstContainer->setWorksetSize(workset_size); // setup DOF manager ///////////////////////////////////////////// - const Teuchos::RCP conn_manager - = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + const Teuchos::RCP conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); - Teuchos::RCP indexerFactory - = Teuchos::rcp(new panzer::DOFManagerFactory); - const Teuchos::RCP dofManager - = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physics_blocks,conn_manager); + Teuchos::RCP indexerFactory = Teuchos::rcp(new panzer::DOFManagerFactory); + const Teuchos::RCP dofManager = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physics_blocks, conn_manager); // and linear object factory - Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); - panzer::BlockedEpetraLinearObjFactory elof(tComm.getConst(),dofManager); + std::vector> gidProviders = {dofManager}; + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + panzer::BlockedTpetraLinearObjFactory elof(tComm, gidProviders); // setup field manager builder ///////////////////////////////////////////// @@ -138,14 +133,14 @@ namespace panzer { cm_factory.buildObjects(cm_builder); Teuchos::ParameterList closure_models("Closure Models"); - closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); - closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); Teuchos::ParameterList user_data("User Data"); fmb.setWorksetContainer(wkstContainer); - fmb.setupVolumeFieldManagers(physics_blocks,cm_factory,closure_models,elof,user_data); - fmb.setupBCFieldManagers(bcs,physics_blocks,*eqset_factory,cm_factory,bc_factory,closure_models,elof, user_data); + fmb.setupVolumeFieldManagers(physics_blocks, cm_factory, closure_models, elof, user_data); + fmb.setupBCFieldManagers(bcs, physics_blocks, *eqset_factory, cm_factory, bc_factory, closure_models, elof, user_data); // run tests ///////////////////////////////// @@ -154,55 +149,54 @@ namespace panzer { fmb.writeVolumeTextDependencyFiles("FMB_Test", physics_blocks); fmb.writeBCTextDependencyFiles("FMB_Test"); - const std::vector< Teuchos::RCP< PHX::FieldManager > >& fmb_vol_fm = - fmb.getVolumeFieldManagers(); + const std::vector>> &fmb_vol_fm = + fmb.getVolumeFieldManagers(); TEST_EQUALITY(fmb_vol_fm.size(), 2); - Teuchos::RCP > fmb_vol_worksets; + Teuchos::RCP> fmb_vol_worksets; panzer::WorksetDescriptor wd = blockDescriptor("eblock-0_0"); fmb_vol_worksets = wkstContainer->getWorksets(wd); - TEST_ASSERT(fmb_vol_worksets!=Teuchos::null); + TEST_ASSERT(fmb_vol_worksets != Teuchos::null); wd = blockDescriptor("eblock-1_0"); fmb_vol_worksets = wkstContainer->getWorksets(wd); - TEST_ASSERT(fmb_vol_worksets!=Teuchos::null); - + TEST_ASSERT(fmb_vol_worksets != Teuchos::null); const std::map >, - panzer::LessBC>& fmb_bc_fm = fmb.getBCFieldManagers(); + std::map>, + panzer::LessBC> &fmb_bc_fm = fmb.getBCFieldManagers(); - std::map >, panzer::LessBC> fmb_bc_worksets; - panzer::getSideWorksetsFromContainer(*wkstContainer,bcs,fmb_bc_worksets); + std::map>, panzer::LessBC> fmb_bc_worksets; + panzer::getSideWorksetsFromContainer(*wkstContainer, bcs, fmb_bc_worksets); TEST_EQUALITY(fmb_bc_fm.size(), 3); TEST_EQUALITY(fmb_bc_fm.size(), fmb_bc_worksets.size()); } - void testInitialzation(const Teuchos::RCP& ipb, - std::vector& bcs) + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs) { // Physics block - Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); { - Teuchos::ParameterList& p = physics_block.sublist("a"); - p.set("Type","Energy"); - p.set("Prefix",""); - p.set("Model ID","solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",2); - p.set("Integration Order",1); + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 2); + p.set("Integration Order", 1); } { - Teuchos::ParameterList& p = physics_block.sublist("b"); - p.set("Type","Energy"); - p.set("Prefix","ION_"); - p.set("Model ID","ion solid"); - p.set("Basis Type","HGrad"); - p.set("Basis Order",1); - p.set("Integration Order",1); + Teuchos::ParameterList &p = physics_block.sublist("b"); + p.set("Type", "Energy"); + p.set("Prefix", "ION_"); + p.set("Model ID", "ion solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); + p.set("Integration Order", 1); } { @@ -214,9 +208,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -228,9 +222,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } { @@ -242,9 +236,9 @@ namespace panzer { std::string strategy = "Constant"; double value = 5.0; Teuchos::ParameterList p; - p.set("Value",value); + p.set("Value", value); panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, - strategy, p); + strategy, p); bcs.push_back(bc); } } diff --git a/packages/panzer/adapters-stk/test/gather_scatter_evaluators/CMakeLists.txt b/packages/panzer/adapters-stk/test/gather_scatter_evaluators/CMakeLists.txt index 7c726c0c4b79..627ade173360 100644 --- a/packages/panzer/adapters-stk/test/gather_scatter_evaluators/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/gather_scatter_evaluators/CMakeLists.txt @@ -9,14 +9,12 @@ TRIBITS_INCLUDE_DIRECTORIES(${PACKAGE_SOURCE_DIR}/test/bcstrategy) SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) -IF (PANZER_HAVE_EPETRA_STACK) - TRIBITS_ADD_EXECUTABLE_AND_TEST( - gs_evaluators - SOURCES gs_evaluators.cpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 1 +TRIBITS_ADD_EXECUTABLE_AND_TEST( + gs_evaluators_tpetra + SOURCES gs_evaluators_tpetra.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 1 ) -ENDIF(PANZER_HAVE_EPETRA_STACK) TRIBITS_ADD_EXECUTABLE_AND_TEST( scatter_field_evaluator @@ -24,3 +22,14 @@ TRIBITS_ADD_EXECUTABLE_AND_TEST( COMM serial mpi NUM_MPI_PROCS 1 ) + + +IF (PANZER_HAVE_EPETRA) + TRIBITS_ADD_EXECUTABLE_AND_TEST( + gs_evaluators + SOURCES gs_evaluators.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 1 + ) +ENDIF(PANZER_HAVE_EPETRA) + diff --git a/packages/panzer/adapters-stk/test/gather_scatter_evaluators/gs_evaluators_tpetra.cpp b/packages/panzer/adapters-stk/test/gather_scatter_evaluators/gs_evaluators_tpetra.cpp new file mode 100644 index 000000000000..8004bbd2b940 --- /dev/null +++ b/packages/panzer/adapters-stk/test/gather_scatter_evaluators/gs_evaluators_tpetra.cpp @@ -0,0 +1,361 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" + +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_WorksetContainer.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_AssemblyEngine.hpp" +#include "Panzer_AssemblyEngine_InArgs.hpp" +#include "Panzer_AssemblyEngine_TemplateBuilder.hpp" +#include "Panzer_AssemblyEngine_TemplateManager.hpp" +#include "Panzer_BasisIRLayout.hpp" +#include "Panzer_BlockedDOFManagerFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_GlobalData.hpp" + +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_STK_GatherFields.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_Version.hpp" + +#include "user_app_BCStrategy_Factory.hpp" +#include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_EquationSetFactory.hpp" + +#include "Teuchos_DefaultMpiComm.hpp" +#include "Teuchos_OpaqueWrapper.hpp" + +#include // for get char +#include +#include + +using ST = double; +using LO = panzer::LocalOrdinal; +using GO = panzer::GlobalOrdinal; +using NT = panzer::TpetraNodeType; + +namespace panzer { + +Teuchos::RCP buildLinearBasis(std::size_t worksetSize); + +void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs); + +Teuchos::RCP buildMesh(int elemX, int elemY); + +TEUCHOS_UNIT_TEST(gs_evaluators_tpetra, gather_constr) { + const std::size_t workset_size = 20; + Teuchos::RCP linBasis = buildLinearBasis(workset_size); + + auto fieldNames = Teuchos::rcp(new std::vector); + fieldNames->push_back("dog"); + + Teuchos::ParameterList pl; + pl.set("Basis", linBasis); + pl.set("Field Names", fieldNames); + + Teuchos::RCP mesh = buildMesh(2, 2); + + auto ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + testInitialzation(ipb, bcs); + + auto fmb = Teuchos::rcp(new panzer::FieldManagerBuilder); + + // build physics blocks + ////////////////////////////////////////////////////////////// + auto eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + std::vector> physicsBlocks; + + { + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map> + block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, block_ids_to_cell_topo, + ipb, default_integration_order, workset_size, + eqset_factory, gd, false, physicsBlocks); + } + auto wkstFactory = Teuchos::rcp( + new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP + wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physicsBlocks.size(); i++) + wkstContainer->setNeeds(physicsBlocks[i]->elementBlockID(), + physicsBlocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // build DOF Manager + ///////////////////////////////////////////////////////////// + + // build the connection manager + auto conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + auto tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + panzer::DOFManagerFactory globalIndexerFactory; + auto dofManager = globalIndexerFactory.buildGlobalIndexer( + Teuchos::opaqueWrapper(MPI_COMM_WORLD), physicsBlocks, conn_manager); + // MPL: 04 27 2022 : the cast to BlockedDOFManager fails probably because of + // missing parameters (field order) + // auto dofManagerCasted = + // Teuchos::rcp_dynamic_cast(dofManager); + // Teuchos::RCP + // > eLinObjFactory + // = Teuchos::rcp(new + // panzer::BlockedTpetraLinearObjFactory(tComm.getConst(), + // dofManagerCasted)); + + // and linear object factory + auto eLinObjFactory = Teuchos::rcp( + new panzer::TpetraLinearObjFactory< + panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>( + tComm.getConst(), dofManager)); + + Teuchos::RCP> linObjFactory = + eLinObjFactory; + + // setup field manager build + ///////////////////////////////////////////////////////////// + + // Add in the application specific closure model factory + user_app::MyModelFactory_TemplateBuilder cm_builder; + panzer::ClosureModelFactory_TemplateManager cm_factory; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid") + .sublist("SOURCE_TEMPERATURE") + .set("Value", 1.0); + closure_models.sublist("ion solid") + .sublist("SOURCE_ION_TEMPERATURE") + .set("Value", 1.0); + + Teuchos::ParameterList user_data("User Data"); + + fmb->setWorksetContainer(wkstContainer); + fmb->setupVolumeFieldManagers(physicsBlocks, cm_factory, closure_models, + *linObjFactory, user_data); + fmb->setupBCFieldManagers(bcs, physicsBlocks, *eqset_factory, cm_factory, + bc_factory, closure_models, *linObjFactory, + user_data); + + fmb->writeVolumeGraphvizDependencyFiles("field_manager", physicsBlocks); + + panzer::AssemblyEngine_TemplateManager ae_tm; + panzer::AssemblyEngine_TemplateBuilder builder(fmb, linObjFactory); + ae_tm.buildObjects(builder); + + typedef panzer::TpetraLinearObjContainer LOC; + + auto eGhosted = Teuchos::rcp_dynamic_cast( + linObjFactory->buildGhostedLinearObjContainer()); + auto eGlobal = + Teuchos::rcp_dynamic_cast(linObjFactory->buildLinearObjContainer()); + eLinObjFactory->initializeGhostedContainer( + LOC::X | LOC::DxDt | LOC::F | LOC::Mat, *eGhosted); + eLinObjFactory->initializeContainer(LOC::X | LOC::DxDt | LOC::F | LOC::Mat, + *eGlobal); + panzer::AssemblyEngineInArgs input(eGhosted, eGlobal); + + ae_tm.getAsObject()->evaluate(input); + ae_tm.getAsObject()->evaluate(input); +} + +Teuchos::RCP buildLinearBasis(std::size_t worksetSize) { + Teuchos::RCP topo = + Teuchos::rcp(new shards::CellTopology( + shards::getCellTopologyData>())); + + panzer::CellData cellData(worksetSize, topo); + panzer::IntegrationRule intRule(1, cellData); + + return Teuchos::rcp(new panzer::BasisIRLayout("Q1", 1, intRule)); +} + +Teuchos::RCP buildMesh(int elemX, int elemY) { + typedef panzer_stk::STK_Interface::SolutionFieldType VariableField; + typedef panzer_stk::STK_Interface::VectorFieldType CoordinateField; + + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", elemX); + pl->set("Y Elements", elemY); + + panzer_stk::SquareQuadMeshFactory factory; + factory.setParameterList(pl); + RCP mesh = + factory.buildUncommitedMesh(MPI_COMM_WORLD); + + // add in some fields + mesh->addSolutionField("dog", "eblock-0_0"); + mesh->addSolutionField("dog", "eblock-1_0"); + + factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD); + + VariableField *field = mesh->getMetaData()->get_field( + stk::topology::NODE_RANK, "dog"); + CoordinateField *cField = mesh->getMetaData()->get_field( + stk::topology::NODE_RANK, "coordinates"); + TEUCHOS_ASSERT(field != 0); + TEUCHOS_ASSERT(cField != 0); + + // fill the fields with data + const std::vector nodeData = + mesh->getBulkData()->buckets(mesh->getNodeRank()); + for (std::size_t b = 0; b < nodeData.size(); ++b) { + stk::mesh::Bucket *bucket = nodeData[b]; + + // build all buckets + for (stk::mesh::Bucket::iterator itr = bucket->begin(); + itr != bucket->end(); ++itr) { + + double *coordinates = stk::mesh::field_data(*cField, *itr); + double *dog_array = stk::mesh::field_data(*field, *itr); + + double x = coordinates[0]; + double y = coordinates[1]; + + *dog_array = 4.0 * x * x + y; + } + } + + if (mesh->isWritable()) + mesh->writeToExodus("output.exo"); + + return mesh; +} + +void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs) { + // Physics block + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); + { + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 2); + } + { + Teuchos::ParameterList &p = physics_block.sublist("b"); + p.set("Type", "Energy"); + p.set("Prefix", "ION_"); + p.set("Model ID", "ion solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); + } + + { + std::size_t bc_id = 0; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "left"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 1; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "right"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 2; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "top"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } +} + +} // namespace panzer diff --git a/packages/panzer/adapters-stk/test/initial_condition_builder/CMakeLists.txt b/packages/panzer/adapters-stk/test/initial_condition_builder/CMakeLists.txt index e13b75850969..ad3d3db543df 100644 --- a/packages/panzer/adapters-stk/test/initial_condition_builder/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/initial_condition_builder/CMakeLists.txt @@ -8,31 +8,63 @@ TRIBITS_INCLUDE_DIRECTORIES(${${PACKAGE_NAME}_SOURCE_DIR}/test/bcstrategy) SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) +SET(SOURCES + user_app_STKClosureModel_Factory.hpp + user_app_STKClosureModel_Factory_impl.hpp + user_app_STKClosureModel_Factory_TemplateBuilder.hpp + ) + + TRIBITS_ADD_EXECUTABLE_AND_TEST( - initial_condition_builder - SOURCES initial_condition_builder.cpp user_app_STKClosureModel_Factory.hpp user_app_STKClosureModel_Factory_impl.hpp user_app_STKClosureModel_Factory_TemplateBuilder.hpp ${UNIT_TEST_DRIVER} + initial_condition_builder_tpetra + SOURCES initial_condition_builder_tpetra.cpp ${SOURCES} ${UNIT_TEST_DRIVER} COMM serial mpi NUM_MPI_PROCS 1 ) TRIBITS_ADD_EXECUTABLE_AND_TEST( - initial_condition_builder2 - SOURCES initial_condition_builder2.cpp user_app_STKClosureModel_Factory.hpp user_app_STKClosureModel_Factory_impl.hpp user_app_STKClosureModel_Factory_TemplateBuilder.hpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 2 - ) + initial_condition_builder2_tpetra + SOURCES initial_condition_builder2_tpetra.cpp ${SOURCES} ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) + TRIBITS_ADD_EXECUTABLE_AND_TEST( - initial_condition_control - SOURCES initial_condition_control.cpp user_app_STKClosureModel_Factory.hpp user_app_STKClosureModel_Factory_impl.hpp user_app_STKClosureModel_Factory_TemplateBuilder.hpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 2 - ) + initial_condition_control_tpetra + SOURCES initial_condition_control_tpetra.cpp ${SOURCES} ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) + + +IF (PANZER_HAVE_EPETRA) + TRIBITS_ADD_EXECUTABLE_AND_TEST( + initial_condition_builder + SOURCES initial_condition_builder.cpp ${SOURCES} ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 1 + ) + + TRIBITS_ADD_EXECUTABLE_AND_TEST( + initial_condition_builder2 + SOURCES initial_condition_builder2.cpp ${SOURCES} ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + initial_condition_control + SOURCES initial_condition_control.cpp ${SOURCES} ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) +ENDIF(PANZER_HAVE_EPETRA) TRIBITS_COPY_FILES_TO_BINARY_DIR(ic_builder2_files SOURCE_FILES block-decomp.exo block-decomp.exo.2.0 block-decomp.exo.2.1 SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/" DEST_DIR "${CMAKE_CURRENT_BINARY_DIR}/" - EXEDEPS initial_condition_builder + EXEDEPS initial_condition_builder_tpetra ) diff --git a/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder2_tpetra.cpp b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder2_tpetra.cpp new file mode 100644 index 000000000000..a0837fbc85a3 --- /dev/null +++ b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder2_tpetra.cpp @@ -0,0 +1,281 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_ExodusReaderFactory.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_WorksetContainer.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_GlobalData.hpp" +#include "user_app_EquationSetFactory.hpp" +#include "user_app_STKClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_BCStrategy_Factory.hpp" + +#include "Panzer_InitialCondition_Builder.hpp" + +#include +#include +#include + +using ST = double; +using LO = panzer::LocalOrdinal; +using GO = panzer::GlobalOrdinal; +using NT = panzer::TpetraNodeType; +using TpetraVector = Tpetra::Vector; +using TpetraLOC = panzer::TpetraLinearObjContainer; +using TpetraRowMatrix = Tpetra::RowMatrix; + +namespace panzer { + + void testInitialzation_blockStructure_tpetra(const Teuchos::RCP& ipb, + std::vector& bcs); + + TEUCHOS_UNIT_TEST(initial_condition_builder2_tpetra, block_structure) + { + using Teuchos::RCP; + + + panzer_stk::STK_ExodusReaderFactory mesh_factory; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + const std::size_t workset_size = 20; + + panzer::FieldManagerBuilder fmb; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("File Name","block-decomp.exo"); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + mesh->writeToExodus("initial_condition_builder.exo"); + } + + // setup physic blocks + ///////////////////////////////////////////// + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + std::vector > physics_blocks; + { + testInitialzation_blockStructure_tpetra(ipb, bcs); + + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "PB A"; + block_ids_to_physics_ids["eblock-1_0"] = "PB B"; + + std::map > block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physics_blocks); + } + + // setup worksets + ///////////////////////////////////////////// + + Teuchos::RCP wkstFactory + = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for(size_t i=0;isetNeeds(physics_blocks[i]->elementBlockID(),physics_blocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // get vector of element blocks + std::vector elementBlocks; + mesh->getElementBlockNames(elementBlocks); + + // build volume worksets from container + std::map >,panzer::LessBC> bc_worksets; + panzer::getSideWorksetsFromContainer(*wkstContainer,bcs,bc_worksets); + + // setup DOF manager + ///////////////////////////////////////////// + const Teuchos::RCP conn_manager + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + Teuchos::RCP indexerFactory + = Teuchos::rcp(new panzer::DOFManagerFactory); + const Teuchos::RCP dofManager + = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physics_blocks,conn_manager); + + // and linear object factory + auto tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + auto tlof + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm.getConst(),dofManager)); + + Teuchos::RCP > lof = tlof; + + // setup field manager builder + ///////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::STKModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("SOURCE_ELECTRON_TEMPERATURE").set("Value",1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + + Teuchos::ParameterList user_data("User Data"); + user_data.sublist("Panzer Data").set("Mesh", mesh); + user_data.sublist("Panzer Data").set("DOF Manager", dofManager); + user_data.sublist("Panzer Data").set("Linear Object Factory", lof); + + fmb.setWorksetContainer(wkstContainer); + fmb.setupVolumeFieldManagers(physics_blocks,cm_factory,closure_models,*tlof,user_data); + fmb.setupBCFieldManagers(bcs,physics_blocks,*eqset_factory,cm_factory,bc_factory,closure_models,*tlof,user_data); + + Teuchos::ParameterList ic_closure_models("Initial Conditions"); + ic_closure_models.sublist("eblock-0_0").sublist("TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-0_0").sublist("ELECTRON_TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-1_0").sublist("TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-1_0").sublist("ION_TEMPERATURE").set("Value",3.0); + + std::map > > phx_ic_field_managers; + panzer::setupInitialConditionFieldManagers(*wkstContainer, + physics_blocks, + cm_factory, + ic_closure_models, + *tlof, + user_data, + true, + "initial_condition_test", + phx_ic_field_managers); + + + auto loc = tlof->buildLinearObjContainer(); + tlof->initializeContainer(TpetraLOC::X,*loc); + + auto tloc = Teuchos::rcp_dynamic_cast(loc); + tloc->get_x()->putScalar(0.0); + + panzer::evaluateInitialCondition(*wkstContainer, phx_ic_field_managers, loc, *tlof, 0.0); + + auto x = tloc->get_x(); + auto xData = x->getLocalViewHost(Tpetra::Access::ReadOnly); + out << x->getGlobalLength() << " " << xData.size(); + for (size_t i=0; i < xData.size(); ++i) + TEST_FLOATING_EQUALITY(xData(i,0), 3.0, 1.0e-10); + } + + void testInitialzation_blockStructure_tpetra(const Teuchos::RCP& ipb, + std::vector& /* bcs */) + { + // Physics block + Teuchos::ParameterList& physics_block_a = ipb->sublist("PB A"); + { + Teuchos::ParameterList& p = physics_block_a.sublist("a"); + p.set("Type","Energy"); + p.set("Prefix",""); + p.set("Model ID","solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + { + Teuchos::ParameterList& p = physics_block_a.sublist("b"); + p.set("Type","Energy"); + p.set("Prefix","ELECTRON_"); + p.set("Model ID","solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + + Teuchos::ParameterList& physics_block_b = ipb->sublist("PB B"); + { + Teuchos::ParameterList& p = physics_block_b.sublist("a"); + p.set("Type","Energy"); + p.set("Prefix",""); + p.set("Model ID","solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + { + Teuchos::ParameterList& p = physics_block_b.sublist("b"); + p.set("Type","Energy"); + p.set("Prefix","ION_"); + p.set("Model ID","ion solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + } + +} diff --git a/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder_tpetra.cpp b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder_tpetra.cpp new file mode 100644 index 000000000000..ee057795007a --- /dev/null +++ b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_builder_tpetra.cpp @@ -0,0 +1,306 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_WorksetContainer.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_GlobalData.hpp" +#include "user_app_EquationSetFactory.hpp" +#include "user_app_STKClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_BCStrategy_Factory.hpp" + +#include "Panzer_InitialCondition_Builder.hpp" + +#include +#include +#include + +using ST = double; +using LO = panzer::LocalOrdinal; +using GO = panzer::GlobalOrdinal; +using NT = panzer::TpetraNodeType; +using TpetraVector = Tpetra::Vector; +using TpetraLOC = panzer::TpetraLinearObjContainer; +using TpetraRowMatrix = Tpetra::RowMatrix; + +namespace panzer { + + void testInitialzation_tpetra(const Teuchos::RCP& ipb, + std::vector& bcs); + + TEUCHOS_UNIT_TEST(initial_condition_builder_tpetra, exodus_restart) + { + using Teuchos::RCP; + + + panzer_stk::SquareQuadMeshFactory mesh_factory; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + const std::size_t workset_size = 20; + + panzer::FieldManagerBuilder fmb; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // setup physic blocks + ///////////////////////////////////////////// + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + std::vector > physics_blocks; + { + testInitialzation_tpetra(ipb, bcs); + + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map > block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physics_blocks); + } + + // setup worksets + ///////////////////////////////////////////// + + Teuchos::RCP wkstFactory + = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for(size_t i=0;isetNeeds(physics_blocks[i]->elementBlockID(),physics_blocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // get vector of element blocks + std::vector elementBlocks; + mesh->getElementBlockNames(elementBlocks); + + // build volume worksets from container + std::map >,panzer::LessBC> bc_worksets; + panzer::getSideWorksetsFromContainer(*wkstContainer,bcs,bc_worksets); + + // setup DOF manager + ///////////////////////////////////////////// + const Teuchos::RCP conn_manager + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + Teuchos::RCP indexerFactory + = Teuchos::rcp(new panzer::DOFManagerFactory); + const Teuchos::RCP dofManager + = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physics_blocks,conn_manager); + + // and linear object factory + auto tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + auto tlof + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm.getConst(),dofManager)); + + Teuchos::RCP > lof = tlof; + + // setup field manager builder + ///////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::STKModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + + Teuchos::ParameterList user_data("User Data"); + user_data.sublist("Panzer Data").set("Mesh", mesh); + user_data.sublist("Panzer Data").set("DOF Manager", dofManager); + user_data.sublist("Panzer Data").set("Linear Object Factory", lof); + + fmb.setWorksetContainer(wkstContainer); + fmb.setupVolumeFieldManagers(physics_blocks,cm_factory,closure_models,*tlof,user_data); + fmb.setupBCFieldManagers(bcs,physics_blocks,*eqset_factory,cm_factory,bc_factory,closure_models,*tlof,user_data); + + Teuchos::ParameterList ic_closure_models("Initial Conditions"); + ic_closure_models.sublist("eblock-0_0").sublist("TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-0_0").sublist("ION_TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-1_0").sublist("TEMPERATURE").set("Value",3.0); + ic_closure_models.sublist("eblock-1_0").sublist("ION_TEMPERATURE").set("Value",3.0); + + std::map > > phx_ic_field_managers; + panzer::setupInitialConditionFieldManagers(*wkstContainer, + physics_blocks, + cm_factory, + ic_closure_models, + *tlof, + user_data, + true, + "initial_condition_test", + phx_ic_field_managers); + + + auto loc = tlof->buildLinearObjContainer(); + tlof->initializeContainer(TpetraLOC::X,*loc); + + auto tloc = Teuchos::rcp_dynamic_cast(loc); + tloc->get_x()->putScalar(0.0); + + panzer::evaluateInitialCondition(*wkstContainer, phx_ic_field_managers, loc, *tlof, 0.0); + + + auto x = tloc->get_x(); + auto xData = x->getLocalViewHost(Tpetra::Access::ReadOnly); + out << x->getGlobalLength() << " " << xData.size() << std::endl; + for (size_t i=0; i < xData.size(); ++i) + TEST_FLOATING_EQUALITY(xData(i,0), 3.0, 1.0e-10); + + } + + void testInitialzation_tpetra(const Teuchos::RCP& ipb, + std::vector& bcs) + { + // Physics block + Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + { + Teuchos::ParameterList& p = physics_block.sublist("a"); + p.set("Type","Energy"); + p.set("Prefix",""); + p.set("Model ID","solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",2); + p.set("Integration Order",1); + } + { + Teuchos::ParameterList& p = physics_block.sublist("b"); + p.set("Type","Energy"); + p.set("Prefix","ION_"); + p.set("Model ID","ion solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + + { + std::size_t bc_id = 0; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "left"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 1; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "right"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 2; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "top"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + } + +} diff --git a/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_control_tpetra.cpp b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_control_tpetra.cpp new file mode 100644 index 000000000000..31214cec4dcd --- /dev/null +++ b/packages/panzer/adapters-stk/test/initial_condition_builder/initial_condition_control_tpetra.cpp @@ -0,0 +1,215 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" + +#include "Panzer_PureBasis.hpp" +#include "Panzer_GlobalIndexer.hpp" +#include "Panzer_GlobalData.hpp" +#include "Panzer_InitialCondition_Builder.hpp" +#include "Panzer_WorksetContainer.hpp" +#include "Panzer_DOFManager.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" + +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Version.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_STKConnManager.hpp" + +#include "user_app_STKClosureModel_Factory_TemplateBuilder.hpp" + +#include +#include +#include + +using ST = double; +using LO = panzer::LocalOrdinal; +using GO = panzer::GlobalOrdinal; +using NT = panzer::TpetraNodeType; +using TpetraVector = Tpetra::Vector; +using TpetraLOC = panzer::TpetraLinearObjContainer; + +namespace panzer { + + TEUCHOS_UNIT_TEST(initial_condition_control_tpetra, control) + { + using Teuchos::RCP; + using Teuchos::rcp; + + auto tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + auto pl = rcp(new Teuchos::ParameterList); + pl->set("X Elements",2); + pl->set("Y Elements",2); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + mesh->writeToExodus("initial_condition_control.exo"); + } + + RCP ct = mesh->getCellTopology("eblock-0_0"); + + panzer::CellData cellData(4,ct); + + RCP int_rule = rcp(new panzer::IntegrationRule(2,cellData)); + + ICFieldDescriptor densDesc; + densDesc.fieldName = "DENSITY"; + densDesc.basisName = "Const"; + densDesc.basisOrder = 0; + + ICFieldDescriptor condDesc; + condDesc.fieldName = "CONDUCTIVITY"; + condDesc.basisName = "HGrad"; + condDesc.basisOrder = 1; + + RCP const_basis = rcp(new panzer::PureBasis(densDesc.basisName,densDesc.basisOrder,cellData)); + RCP hgrad_basis = rcp(new panzer::PureBasis(condDesc.basisName,condDesc.basisOrder,cellData)); + + RCP constFP = rcp(new panzer::Intrepid2FieldPattern(const_basis->getIntrepid2Basis())); + RCP hgradFP = rcp(new panzer::Intrepid2FieldPattern(hgrad_basis->getIntrepid2Basis())); + + // setup DOF manager + ///////////////////////////////////////////// + RCP conn_manager + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP dofManager + = rcp(new panzer::DOFManager(conn_manager,MPI_COMM_WORLD)); + dofManager->addField(densDesc.fieldName, constFP); + dofManager->addField(condDesc.fieldName, hgradFP); + dofManager->buildGlobalUnknowns(); + + auto tlof + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm.getConst(),dofManager)); + + Teuchos::RCP > lof = tlof; + + // setup worksets + ///////////////////////////////////////////// + + std::map needs; + needs["eblock-0_0"].cellData = cellData; + needs["eblock-0_0"].int_rules.push_back(int_rule); + needs["eblock-0_0"].bases = { const_basis, hgrad_basis}; + needs["eblock-0_0"].rep_field_name = { densDesc.fieldName, condDesc.fieldName}; + + needs["eblock-1_0"].cellData = cellData; + needs["eblock-1_0"].int_rules.push_back(int_rule); + needs["eblock-1_0"].bases = { const_basis, hgrad_basis}; + needs["eblock-1_0"].rep_field_name = { densDesc.fieldName, condDesc.fieldName}; + + Teuchos::RCP wkstFactory + = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer(wkstFactory,needs)); + + // setup field manager builder + ///////////////////////////////////////////// + + // Add in the application specific closure model factory + panzer::ClosureModelFactory_TemplateManager cm_factory; + user_app::STKModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList user_data("User Data"); + + Teuchos::ParameterList ic_closure_models("Initial Conditions"); + ic_closure_models.sublist("eblock-0_0").sublist(densDesc.fieldName).set("Value",3.0); + ic_closure_models.sublist("eblock-0_0").sublist(condDesc.fieldName).set("Value",9.0); + ic_closure_models.sublist("eblock-1_0").sublist(densDesc.fieldName).set("Value",3.0); + ic_closure_models.sublist("eblock-1_0").sublist(condDesc.fieldName).set("Value",9.0); + + std::map > block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + std::map > block_ids_to_fields; + block_ids_to_fields["eblock-0_0"] = {densDesc,condDesc}; + block_ids_to_fields["eblock-1_0"] = {densDesc,condDesc}; + + int workset_size = 4; + + auto loc = lof->buildLinearObjContainer(); + lof->initializeContainer(TpetraLOC::X,*loc); + auto tloc = Teuchos::rcp_dynamic_cast(loc); + Teuchos::RCP > vec = tloc->get_x_th(); + + // this is the Function under test + panzer::setupControlInitialCondition(block_ids_to_cell_topo, + block_ids_to_fields, + *wkstContainer, + *lof,cm_factory,ic_closure_models,user_data, + workset_size, + 0.0, // t0 + vec); + + auto x = tloc->get_x(); + auto xData = x->getLocalViewHost(Tpetra::Access::ReadOnly);; + out << x->getGlobalLength() << " " << xData.size() << std::endl; + for (size_t i=0; i < xData.size(); ++i) { + double v = xData(i,0); + TEST_ASSERT(v==3.0 || v==9.0); + } + + } + +} diff --git a/packages/panzer/adapters-stk/test/ip_coordinates/CMakeLists.txt b/packages/panzer/adapters-stk/test/ip_coordinates/CMakeLists.txt index bc5bcaf16a26..463d34d25858 100644 --- a/packages/panzer/adapters-stk/test/ip_coordinates/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/ip_coordinates/CMakeLists.txt @@ -9,10 +9,18 @@ TRIBITS_INCLUDE_DIRECTORIES(${${PACKAGE_NAME}_SOURCE_DIR}/test/bcstrategy) SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) +IF(PANZER_HAVE_EPETRA) + TRIBITS_ADD_EXECUTABLE_AND_TEST( + epetra_ip_coordinates + SOURCES epetra_ip_coordinates.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) +ENDIF(PANZER_HAVE_EPETRA) + TRIBITS_ADD_EXECUTABLE_AND_TEST( - ip_coordinates - SOURCES ip_coordinates.cpp ${UNIT_TEST_DRIVER} + tpetra_ip_coordinates + SOURCES tpetra_ip_coordinates.cpp ${UNIT_TEST_DRIVER} COMM serial mpi NUM_MPI_PROCS 2 ) - diff --git a/packages/panzer/adapters-stk/test/ip_coordinates/ip_coordinates.cpp b/packages/panzer/adapters-stk/test/ip_coordinates/epetra_ip_coordinates.cpp similarity index 99% rename from packages/panzer/adapters-stk/test/ip_coordinates/ip_coordinates.cpp rename to packages/panzer/adapters-stk/test/ip_coordinates/epetra_ip_coordinates.cpp index 6cdb14b85b80..c881b673b008 100644 --- a/packages/panzer/adapters-stk/test/ip_coordinates/ip_coordinates.cpp +++ b/packages/panzer/adapters-stk/test/ip_coordinates/epetra_ip_coordinates.cpp @@ -64,6 +64,7 @@ namespace panzer { { using Teuchos::RCP; + bool ENABLE_DEBUG_OUTPUT = false; #ifdef HAVE_MPI Teuchos::RCP > tcomm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); @@ -224,7 +225,7 @@ namespace panzer { coords["eblock-1_0"] = Teuchos::rcp_dynamic_cast >(resp10,true)->getCoords();; // Debugging - if (true) { + if (ENABLE_DEBUG_OUTPUT) { Teuchos::RCP out2 = Teuchos::getFancyOStream(Teuchos::rcp(&out,false)); out2->setOutputToRootOnly(-1); *out2 << "\nPrinting IP coordinates for block: eblock-0_0" << std::endl; diff --git a/packages/panzer/adapters-stk/test/ip_coordinates/tpetra_ip_coordinates.cpp b/packages/panzer/adapters-stk/test/ip_coordinates/tpetra_ip_coordinates.cpp new file mode 100644 index 000000000000..23670727551e --- /dev/null +++ b/packages/panzer/adapters-stk/test/ip_coordinates/tpetra_ip_coordinates.cpp @@ -0,0 +1,419 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" + +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_GlobalData.hpp" + +#include "user_app_EquationSetFactory.hpp" +#include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_BCStrategy_Factory.hpp" + +#include "Panzer_ResponseLibrary.hpp" +#include "Panzer_WorksetContainer.hpp" + +#include "Panzer_ResponseEvaluatorFactory_IPCoordinates.hpp" + +#include "TestEvaluators.hpp" + +#include +#include +#include + +namespace panzer +{ + + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs); + + struct RespFactoryIPCoords_Builder + { + int cubatureDegree; + + template + Teuchos::RCP build() const + { + return Teuchos::rcp(new ResponseEvaluatorFactory_IPCoordinates(cubatureDegree)); + } + }; + + TEUCHOS_UNIT_TEST(response_library_stk2, test) + { + using Teuchos::RCP; + + bool ENABLE_DEBUG_OUTPUT = false; + +#ifdef HAVE_MPI + Teuchos::RCP> tcomm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); +#else + Teuchos::RCP> tcomm = FAIL +#endif + + panzer_stk::SquareQuadMeshFactory mesh_factory; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + const std::size_t workset_size = 1; + + panzer::FieldManagerBuilder fmb; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks", 2); + pl->set("Y Blocks", 1); + pl->set("X Elements", 2); + pl->set("Y Elements", 2); + pl->set("X0", 0.0); + pl->set("Y0", 0.0); + pl->set("Xf", 8.0); + pl->set("Yf", 4.0); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // setup physic blocks + ///////////////////////////////////////////// + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + std::vector> physics_blocks; + { + testInitialzation(ipb, bcs); + + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map> block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physics_blocks); + } + + // setup worksets + ///////////////////////////////////////////// + + std::vector validEBlocks; + mesh->getElementBlockNames(validEBlocks); + + // build WorksetContainer + Teuchos::RCP wkstFactory = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for (size_t i = 0; i < physics_blocks.size(); i++) + wkstContainer->setNeeds(physics_blocks[i]->elementBlockID(), physics_blocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // setup DOF manager + ///////////////////////////////////////////// + const Teuchos::RCP conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + Teuchos::RCP indexerFactory = Teuchos::rcp(new panzer::DOFManagerFactory); + const Teuchos::RCP dofManager = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD), physics_blocks, conn_manager); + + RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + // and linear object factory + Teuchos::RCP> lof = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm.getConst(), dofManager)); + + // setup field manager builder + ///////////////////////////////////////////// + + // Add in the application specific closure model factory + user_app::MyModelFactory_TemplateBuilder cm_builder; + panzer::ClosureModelFactory_TemplateManager cm_factory; + cm_factory.buildObjects(cm_builder); + + Teuchos::ParameterList closure_models("Closure Models"); + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value", 1.0); + closure_models.sublist("Response Model"); + + Teuchos::ParameterList user_data("User Data"); + user_data.sublist("Panzer Data").set("Mesh", mesh); + user_data.sublist("Panzer Data").set("DOF Manager", dofManager); + user_data.sublist("Panzer Data").set("Linear Object Factory", lof); + user_data.set("Workset Size", workset_size); + + // IP is in center of element + user_data.sublist("IP Coordinates").set("Integration Order", 1); + + // setup and evaluate ResponseLibrary + /////////////////////////////////////////////////// + + out << "Adding responses" << std::endl; + + RCP> rLibrary = Teuchos::rcp(new ResponseLibrary(wkstContainer, dofManager, lof)); + + ResponseEvaluatorFactory_IPCoordinates_Builder builder; + builder.cubatureDegree = 1; + + std::vector blocks(1); + blocks[0] = "eblock-0_0"; + rLibrary->addResponse("IPCoordinates-0_0", blocks, builder); + blocks[0] = "eblock-1_0"; + rLibrary->addResponse("IPCoordinates-1_0", blocks, builder); + + Teuchos::RCP resp00 = rLibrary->getResponse("IPCoordinates-0_0"); + Teuchos::RCP resp10 = rLibrary->getResponse("IPCoordinates-1_0"); + + TEST_NOTHROW(Teuchos::rcp_dynamic_cast>(resp00, true)); + TEST_NOTHROW(Teuchos::rcp_dynamic_cast>(resp10, true)); + + rLibrary->buildResponseEvaluators(physics_blocks, + cm_factory, + closure_models, + user_data, true); + + Teuchos::RCP loc = lof->buildLinearObjContainer(); + lof->initializeContainer(panzer::LinearObjContainer::X, *loc); + Teuchos::RCP gloc = lof->buildGhostedLinearObjContainer(); + lof->initializeGhostedContainer(panzer::LinearObjContainer::X, *gloc); + + out << "evaluating VFM" << std::endl; + panzer::AssemblyEngineInArgs ae_inargs(gloc, loc); + rLibrary->addResponsesToInArgs(ae_inargs); + rLibrary->evaluate(ae_inargs); + + std::map>> coords; + coords["eblock-0_0"] = Teuchos::rcp_dynamic_cast>(resp00, true)->getCoords(); + ; + coords["eblock-1_0"] = Teuchos::rcp_dynamic_cast>(resp10, true)->getCoords(); + ; + + // Debugging + if (ENABLE_DEBUG_OUTPUT) + { + Teuchos::RCP out2 = Teuchos::getFancyOStream(Teuchos::rcp(&out, false)); + out2->setOutputToRootOnly(-1); + *out2 << "\nPrinting IP coordinates for block: eblock-0_0" << std::endl; + for (std::vector::const_iterator i = (coords["eblock-0_0"])->begin(); i != (coords["eblock-0_0"])->end(); ++i) + *out2 << "pid = " << tcomm->getRank() << ", val = " << *i << std::endl; + *out2 << "\nPrinting IP coordinates for block: eblock-1_0" << std::endl; + for (std::vector::const_iterator i = (coords["eblock-1_0"])->begin(); i != (coords["eblock-1_0"])->end(); ++i) + *out2 << "pid = " << tcomm->getSize() << ", val = " << *i << std::endl; + } + + const double double_tol = 10.0 * std::numeric_limits::epsilon(); + + // NOTE: if the ordering of elements in STK changes or the + // ordering of integration points in Intrepid2 changes, this test + // will break! It assumes a fixed deterministic ordering. + if (tcomm->getSize() == 1) + { + // eblock 1 + { + const std::vector &values = *(coords["eblock-0_0"]); + TEST_FLOATING_EQUALITY(values[0], 1.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 3.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 1.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[3], 3.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[4], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[5], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[6], 3.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[7], 3.0, double_tol); // y + } + // eblock 2 + { + const std::vector &values = *(coords["eblock-1_0"]); + TEST_FLOATING_EQUALITY(values[0], 5.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 7.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 5.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[3], 7.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[4], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[5], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[6], 3.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[7], 3.0, double_tol); // y + } + } + else if (tcomm->getSize() == 2) + { + + if (tcomm->getRank() == 0) + { + // eblock 1 + { + const std::vector &values = *(coords["eblock-0_0"]); + TEST_FLOATING_EQUALITY(values[0], 1.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 1.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[3], 3.0, double_tol); // y + } + // eblock 2 + { + const std::vector &values = *(coords["eblock-1_0"]); + TEST_FLOATING_EQUALITY(values[0], 5.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 5.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[3], 3.0, double_tol); // y + } + } + else if (tcomm->getRank() == 1) + { + // eblock 1 + { + const std::vector &values = *(coords["eblock-0_0"]); + TEST_FLOATING_EQUALITY(values[0], 3.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 3.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[3], 3.0, double_tol); // y + } + // eblock 2 + { + const std::vector &values = *(coords["eblock-1_0"]); + TEST_FLOATING_EQUALITY(values[0], 7.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[1], 7.0, double_tol); // x + TEST_FLOATING_EQUALITY(values[2], 1.0, double_tol); // y + TEST_FLOATING_EQUALITY(values[3], 3.0, double_tol); // y + } + } + } + else + { + TEUCHOS_TEST_FOR_EXCEPTION(true, std::runtime_error, "Error - this test can only be run with 1 or 2 processes!"); + } + } + + void testInitialzation(const Teuchos::RCP &ipb, + std::vector &bcs) + { + // Physics block + Teuchos::ParameterList &physics_block = ipb->sublist("test physics"); + { + Teuchos::ParameterList &p = physics_block.sublist("a"); + p.set("Type", "Energy"); + p.set("Prefix", ""); + p.set("Model ID", "solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 2); + p.set("Integration Order", 1); + } + { + Teuchos::ParameterList &p = physics_block.sublist("b"); + p.set("Type", "Energy"); + p.set("Prefix", "ION_"); + p.set("Model ID", "ion solid"); + p.set("Basis Type", "HGrad"); + p.set("Basis Order", 1); + p.set("Integration Order", 1); + } + + { + std::size_t bc_id = 0; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "left"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 1; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "right"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 2; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "top"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value", value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + } + +} diff --git a/packages/panzer/adapters-stk/test/model_evaluator/CMakeLists.txt b/packages/panzer/adapters-stk/test/model_evaluator/CMakeLists.txt index 2ab48a23520c..bebf9f6beea5 100644 --- a/packages/panzer/adapters-stk/test/model_evaluator/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/model_evaluator/CMakeLists.txt @@ -8,6 +8,7 @@ TRIBITS_INCLUDE_DIRECTORIES(${PACKAGE_SOURCE_DIR}/test/bcstrategy) SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) +IF (PANZER_HAVE_EPETRA_STACK) TRIBITS_ADD_EXECUTABLE_AND_TEST( model_evaluator SOURCES model_evaluator.cpp ${UNIT_TEST_DRIVER} @@ -29,13 +30,6 @@ TRIBITS_ADD_EXECUTABLE_AND_TEST( NUM_MPI_PROCS 4 ) -TRIBITS_ADD_EXECUTABLE_AND_TEST( - explicit_model_evaluator - SOURCES explicit_model_evaluator.cpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 4 - ) - TRIBITS_ADD_EXECUTABLE_AND_TEST( response_residual SOURCES response_residual.cpp ${UNIT_TEST_DRIVER} @@ -58,3 +52,11 @@ IF(${PARENT_PACKAGE_NAME}_BUILD_HESSIAN_SUPPORT) NUM_MPI_PROCS 4 ) ENDIF() +ENDIF (PANZER_HAVE_EPETRA_STACK) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + explicit_model_evaluator + SOURCES explicit_model_evaluator.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 4 + ) diff --git a/packages/panzer/adapters-stk/test/model_evaluator/explicit_model_evaluator.cpp b/packages/panzer/adapters-stk/test/model_evaluator/explicit_model_evaluator.cpp index 8630112000c0..be35fe4ba574 100644 --- a/packages/panzer/adapters-stk/test/model_evaluator/explicit_model_evaluator.cpp +++ b/packages/panzer/adapters-stk/test/model_evaluator/explicit_model_evaluator.cpp @@ -29,7 +29,7 @@ using Teuchos::rcp; #include "Panzer_FieldManagerBuilder.hpp" #include "Panzer_STKConnManager.hpp" #include "Panzer_TpetraLinearObjFactory.hpp" -#include "Panzer_BlockedEpetraLinearObjFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" #include "Panzer_AssemblyEngine.hpp" #include "Panzer_AssemblyEngine_TemplateManager.hpp" #include "Panzer_AssemblyEngine_TemplateBuilder.hpp" @@ -47,8 +47,6 @@ using Teuchos::rcp; #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp" #include "user_app_BCStrategy_Factory.hpp" -#include "Epetra_MpiComm.h" - #include "Teuchos_DefaultMpiComm.hpp" #include "Teuchos_OpaqueWrapper.hpp" @@ -96,7 +94,7 @@ namespace panzer { Stratimikos::DefaultLinearSolverBuilder builder; Teuchos::RCP validList = Teuchos::rcp(new Teuchos::ParameterList(*builder.getValidParameters())); builder.setParameterList(validList); - RCP > lowsFactory = builder.createLinearSolveStrategy("Amesos"); + RCP > lowsFactory = builder.createLinearSolveStrategy("Amesos2"); RCP me = Teuchos::rcp(new PME(fmb,rLibrary,lof,p_names,p_values,lowsFactory,gd,build_transient_support,0.0)); RCP exp_me = Teuchos::rcp(new ExpPME(me,true,false)); // constant mass, use lumped @@ -333,7 +331,7 @@ namespace panzer { = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager); Teuchos::RCP > linObjFactory - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(mpiComm,dofManager,false)); + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(mpiComm, dofManager)); lof = linObjFactory; rLibrary = Teuchos::rcp(new panzer::ResponseLibrary(wkstContainer,dofManager,linObjFactory)); diff --git a/packages/panzer/adapters-stk/test/periodic_bcs/CMakeLists.txt b/packages/panzer/adapters-stk/test/periodic_bcs/CMakeLists.txt index 383397852ad1..0464328a1e22 100644 --- a/packages/panzer/adapters-stk/test/periodic_bcs/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/periodic_bcs/CMakeLists.txt @@ -1,9 +1,30 @@ -IF(PANZER_HAVE_EPETRA_STACK) - TRIBITS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) +TRIBITS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) - SET(UNIT_TEST_DRIVER - ${PANZER_UNIT_TEST_MAIN}) +SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + periodic_bcs_tpetra + SOURCES periodic_bcs_tpetra.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 4 + ) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + periodic_mesh_tpetra + SOURCES periodic_mesh_tpetra.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + periodic_32bit_int_limit + SOURCES periodic_32bit_int_limit.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + ) + +IF (PANZER_HAVE_EPETRA) TRIBITS_ADD_EXECUTABLE_AND_TEST( periodic_bcs @@ -19,34 +40,19 @@ IF(PANZER_HAVE_EPETRA_STACK) NUM_MPI_PROCS 2 ) - IF(PANZER_HAVE_STKSEARCH) - TRIBITS_ADD_EXECUTABLE_AND_TEST( - periodic_search - SOURCES periodic_search.cpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 2 - ) - ENDIF() - - # TRIBITS_ADD_EXECUTABLE_AND_TEST( - # periodic_mesh_nosubcells - # SOURCES periodic_mesh_nosubcells.cpp ${UNIT_TEST_DRIVER} - # COMM serial mpi - # NUM_MPI_PROCS 1 - # ) +ENDIF(PANZER_HAVE_EPETRA) - TRIBITS_ADD_EXECUTABLE_AND_TEST( - periodic_32bit_int_limit - SOURCES periodic_32bit_int_limit.cpp ${UNIT_TEST_DRIVER} - COMM serial mpi - NUM_MPI_PROCS 2 - ) +# TRIBITS_ADD_EXECUTABLE_AND_TEST( +# periodic_mesh_nosubcells +# SOURCES periodic_mesh_nosubcells.cpp ${UNIT_TEST_DRIVER} +# COMM serial mpi +# NUM_MPI_PROCS 1 +# ) - TRIBITS_COPY_FILES_TO_BINARY_DIR(periodic_32bit_int_limit_files - SOURCE_FILES periodic_32bit_int_limit.jou periodic_32bit_int_limit.exo README.txt - SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/" - DEST_DIR "${CMAKE_CURRENT_BINARY_DIR}/" - EXEDEPS periodic_32bit_int_limit - ) -ENDIF(PANZER_HAVE_EPETRA_STACK) +TRIBITS_COPY_FILES_TO_BINARY_DIR(periodic_32bit_int_limit_files + SOURCE_FILES periodic_32bit_int_limit.jou periodic_32bit_int_limit.exo README.txt + SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/" + DEST_DIR "${CMAKE_CURRENT_BINARY_DIR}/" + EXEDEPS periodic_32bit_int_limit + ) diff --git a/packages/panzer/adapters-stk/test/periodic_bcs/periodic_bcs_tpetra.cpp b/packages/panzer/adapters-stk/test/periodic_bcs/periodic_bcs_tpetra.cpp new file mode 100644 index 000000000000..20db5ce15d99 --- /dev/null +++ b/packages/panzer/adapters-stk/test/periodic_bcs/periodic_bcs_tpetra.cpp @@ -0,0 +1,1727 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" +#include "Teuchos_Tuple.hpp" + +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_CubeHexMeshFactory.hpp" +#include "Panzer_STK_Utilities.hpp" +#include "Panzer_STK_PeriodicBC_Matcher.hpp" +#include "Panzer_STK_PeriodicBC_MatchConditions.hpp" + +using panzer_stk::CoordMatcher; +using panzer_stk::PlaneMatcher; + +namespace panzer { + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, sorted_permutation) + { + + std::vector vec(5.0); + std::vector permute; + vec[0] = 0.0; + vec[1] = 4.0; + vec[2] = 2.0; + vec[3] = 3.0; + vec[4] = 1.0; + + panzer_stk::sorted_permutation(vec,permute); + + TEST_EQUALITY(permute.size(),5); + for(std::size_t i=0;i mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // run tests (for nodes and edges) + ///////////////////////////////////////////// + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_edge = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::vector & sideIds = *idsAndCoords.first; + std::vector & sideIds_edge = *idsAndCoords_edge.first; + std::vector > & sideCoords = *idsAndCoords.second; + std::vector > & sideCoords_edge = *idsAndCoords_edge.second; + + TEST_EQUALITY(sideIds.size(),5); + TEST_EQUALITY(sideIds_edge.size(),4); + + TEST_EQUALITY(sideCoords.size(),5); + TEST_EQUALITY(sideCoords_edge.size(),4); + + std::vector permute; + panzer_stk::sorted_permutation(sideIds,permute); + for(std::size_t i=0;i permute_edge; + panzer_stk::sorted_permutation(sideIds_edge,permute_edge); + for(std::size_t i=0;i coord = sideCoords_edge[p]; // coordinate of edge + + int node_l = -1; // number for node below edge + int node_u = -1; // number for node above edge + int flag = 0; // flag should be 2 after this loop + + for(std::size_t j=0;j(MPI_COMM_WORLD)); + int rank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",8); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"left"); + RCP > locallyRequiredIds_edge = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"left","edge"); + if(rank==0) { + TEST_EQUALITY(locallyRequiredIds->size(),2); + TEST_EQUALITY(locallyRequiredIds_edge->size(),1); + } + else { + TEST_EQUALITY(locallyRequiredIds->size(),0); + TEST_EQUALITY(locallyRequiredIds_edge->size(),0); + } + + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, getLocallyMatchedSideIds) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + int rank = comm->getRank(); + int procCnt = comm->getSize(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // run tests + ///////////////////////////////////////////// + + // We need Ids and Coords on right so we can map edges to nodes + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::vector & sideIds = *idsAndCoords.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge = *idsAndCoords_edge.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector > & sideCoords = *idsAndCoords.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge = *idsAndCoords_edge.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + + CoordMatcher matcher(1); + Teuchos::RCP > > matchedIds + = panzer_stk::periodic_helpers::getLocallyMatchedSideIds(sideIds,sideCoords,*mesh,"right",matcher); + Teuchos::RCP > > matchedIds_edge + = panzer_stk::periodic_helpers::getLocallyMatchedSideIds(sideIds_edge,sideCoords_edge,*mesh,"right",matcher,"edge"); + + if(rank==procCnt-1) { + for(std::size_t i=0;isize();i++) { + std::pair pair = (*matchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second-12); + } + + std::vector permute_edge; + panzer_stk::sorted_permutation(sideIds_edge,permute_edge); + for(std::size_t i=0;isize();i++) { + std::pair pair = (*matchedIds_edge)[i]; + + // Get coordinates for matched edges + Tuple coord_left; + Tuple coord_right; + int flag0 = 0; + for(std::size_t j=0;jsize(),0) + } + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, getGlobalPairing) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + int rank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // run tests + ///////////////////////////////////////////// + Teuchos::RCP > > locallyMatchedIds; + Teuchos::RCP > > locallyMatchedIds_edge; + + // next line requires global communication + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::vector & sideIds = *idsAndCoords.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge = *idsAndCoords_edge.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector > & sideCoords = *idsAndCoords.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge = *idsAndCoords_edge.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + + CoordMatcher matcher(1); + locallyMatchedIds = panzer_stk::periodic_helpers::getLocallyMatchedSideIds(sideIds,sideCoords,*mesh,"right",matcher); + locallyMatchedIds_edge = panzer_stk::periodic_helpers::getLocallyMatchedSideIds(sideIds_edge,sideCoords_edge,*mesh,"right",matcher,"edge"); + + + Teuchos::RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"left"); + Teuchos::RCP > locallyRequiredIds_edge = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"left","edge"); + + // next line requires communication + Teuchos::RCP > > globallyMatchedIds + = panzer_stk::periodic_helpers::getGlobalPairing(*locallyRequiredIds,*locallyMatchedIds,*mesh,false); + Teuchos::RCP > > globallyMatchedIds_edge + = panzer_stk::periodic_helpers::getGlobalPairing(*locallyRequiredIds_edge,*locallyMatchedIds_edge,*mesh,false); + + if(rank==0) { + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second-12); + } + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds_edge)[i]; + + // Get coordinates for matched edges + Tuple coord_left; + Tuple coord_right; + int flag0 = 0; + for(std::size_t j=0;jsize(),0); + } + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, matchPeriodicSides) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + int rank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::vector & sideIds_left = *idsAndCoords_left.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge_left = *idsAndCoords_edge_left.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector > & sideCoords_left = *idsAndCoords_left.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge_left = *idsAndCoords_edge_left.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + + std::pair >, + RCP > > > idsAndCoords_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + std::pair >, + RCP > > > idsAndCoords_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom"); + std::pair >, + RCP > > > idsAndCoords_edge_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom","edge"); + std::vector & sideIds_top = *idsAndCoords_top.first; + std::vector & sideIds_bottom = *idsAndCoords_bottom.first; + std::vector & sideIds_edge_top = *idsAndCoords_edge_top.first; + std::vector & sideIds_edge_bottom = *idsAndCoords_edge_bottom.first; + std::vector > & sideCoords_top = *idsAndCoords_top.second; + std::vector > & sideCoords_bottom = *idsAndCoords_bottom.second; + std::vector > & sideCoords_edge_top = *idsAndCoords_edge_top.second; + std::vector > & sideCoords_edge_bottom = *idsAndCoords_edge_bottom.second; + + // run tests + + // Nodes + { + CoordMatcher matcher(1); + Teuchos::RCP > > globallyMatchedIds + = panzer_stk::periodic_helpers::matchPeriodicSides("left","right",*mesh,matcher); + + // match left & right sides + if(rank==0) { + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second-12); + } + } + else + TEST_EQUALITY(globallyMatchedIds->size(),0); + } + + // Edges + { + CoordMatcher matcher(1); + Teuchos::RCP > > globallyMatchedIds_edge + = panzer_stk::periodic_helpers::matchPeriodicSides("left","right",*mesh,matcher,"edge"); + + // match left & right sides + if(rank==0) { + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds_edge)[i]; + + // Get coordinates for matched edges + Tuple coord_left; + Tuple coord_right; + int flag0 = 0; + for(std::size_t j=0;jsize(),0); + } + + // Nodes + { + CoordMatcher matcher(0); + Teuchos::RCP > > globallyMatchedIds + = panzer_stk::periodic_helpers::matchPeriodicSides("top","bottom",*mesh,matcher); + + Teuchos::RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"top"); + + TEST_EQUALITY(globallyMatchedIds->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second+52); + } + } + + // Edges + { + CoordMatcher matcher(0); + Teuchos::RCP > > globallyMatchedIds_edge + = panzer_stk::periodic_helpers::matchPeriodicSides("top","bottom",*mesh,matcher,"edge"); + + Teuchos::RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"top","edge"); + + TEST_EQUALITY(globallyMatchedIds_edge->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds_edge)[i]; + + // Get coordinates for matched edges + Tuple coord_top; + Tuple coord_bottom; + int flag0 = 0; + for(std::size_t j=0;j mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + std::pair >, + RCP > > > idsAndCoords_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom"); + std::pair >, + RCP > > > idsAndCoords_edge_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom","edge"); + std::vector & sideIds_top = *idsAndCoords_top.first; + std::vector & sideIds_bottom = *idsAndCoords_bottom.first; + std::vector & sideIds_edge_top = *idsAndCoords_edge_top.first; + std::vector & sideIds_edge_bottom = *idsAndCoords_edge_bottom.first; + std::vector > & sideCoords_top = *idsAndCoords_top.second; + std::vector > & sideCoords_bottom = *idsAndCoords_bottom.second; + std::vector > & sideCoords_edge_top = *idsAndCoords_edge_top.second; + std::vector > & sideCoords_edge_bottom = *idsAndCoords_edge_bottom.second; + + // Nodes + { + CoordMatcher matcher(0); + Teuchos::RCP pMatch + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",matcher); + + TEST_EQUALITY(pMatch->getLeftSidesetName(),std::string("top")); + TEST_EQUALITY(pMatch->getRightSidesetName(),std::string("bottom")); + const auto* check_cast_coord = pMatch->getAs>(); + const auto* check_cast_plane = pMatch->getAs>(); + const auto* check_cast_wedge = pMatch->getAs>(); + TEST_ASSERT(check_cast_coord != nullptr); + TEST_ASSERT(check_cast_plane == nullptr); + TEST_ASSERT(check_cast_wedge == nullptr); + TEST_EQUALITY(check_cast_coord->getMatcher().getIndex(),0); + + RCP > > globallyMatchedIds = pMatch->getMatchedPair(*mesh); + + // for testing purposes! + RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"top"); + + TEST_EQUALITY(globallyMatchedIds->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second+52); + } + } + + // Edges + { + CoordMatcher matcher(0); + Teuchos::RCP pMatch + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",matcher,"edge"); + + RCP > > globallyMatchedIds_edge = pMatch->getMatchedPair(*mesh); + + // for testing purposes! + RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"top","edge"); + + TEST_EQUALITY(globallyMatchedIds_edge->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds_edge)[i]; + + // Get coordinates for matched edges + Tuple coord_top; + Tuple coord_bottom; + int flag0 = 0; + for(std::size_t j=0;j pMatch; + + pMatch = panzer_stk::buildPeriodicBC_Matcher("left","bottom",matcherX); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("top","right",matcherX); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("top","right",matcherY); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("bottom","left",matcherY); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("left","bottom",matcherX,"edge"); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("top","right",matcherX,"edge"); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("top","right",matcherY,"edge"); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + + pMatch = panzer_stk::buildPeriodicBC_Matcher("bottom","left",matcherY,"edge"); + TEST_THROW(pMatch->getMatchedPair(*mesh),std::logic_error); + } + + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, PeriodicBC_Matcher_relative) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + // make a mesh with small length-scale + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + pl->set("X0",0.0); + pl->set("Xf",1.0e-6); + pl->set("Y0",0.0); + pl->set("Yf",1.0e-6); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + std::pair >, + RCP > > > idsAndCoords_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom"); + + // Nodes + { + // set up a matcher with a tolerance of 1e-6 + std::vector params; + params.push_back("1e-6"); + CoordMatcher bad_matcher(0,params); + Teuchos::RCP bad_pMatch + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",bad_matcher); + + // matching should fail since the tolerance is larger than the mesh size + TEST_THROW(bad_pMatch->getMatchedPair(*mesh),std::logic_error); + + // make the tolerance relative, then matching shouldn't fail + params.push_back("relative"); + CoordMatcher matcher(0,params); + Teuchos::RCP pMatch + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",matcher); + + RCP > > globallyMatchedIds = pMatch->getMatchedPair(*mesh); + + // for testing purposes! + RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"top"); + + TEST_EQUALITY(globallyMatchedIds->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second+52); + } + } + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, PeriodicBC_Matcher_multi) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + { + CoordMatcher xmatcher(0); + CoordMatcher ymatcher(1); + Teuchos::RCP tb_Match + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",xmatcher); + Teuchos::RCP lr_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher); + + RCP > > globallyMatchedIds; + globallyMatchedIds = tb_Match->getMatchedPair(*mesh); + globallyMatchedIds = lr_Match->getMatchedPair(*mesh,globallyMatchedIds); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + out << pair.first << " " << pair.second << std::endl; + } + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + + if(pair.first==1 || pair.first==19) + { TEST_EQUALITY(pair.second,9); } + else if(pair.first==10) + { TEST_EQUALITY(pair.second,18); } + else + { TEST_EQUALITY(pair.second,pair.first-18); } + } + + } + } + + TEUCHOS_UNIT_TEST(periodic_bcs_tpetra, PeriodicBC_Matcher_multi_edge) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::vector & sideIds_left = *idsAndCoords_left.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge_left = *idsAndCoords_edge_left.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector > & sideCoords_left = *idsAndCoords_left.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge_left = *idsAndCoords_edge_left.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + + std::pair >, + RCP > > > idsAndCoords_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + std::pair >, + RCP > > > idsAndCoords_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom"); + std::pair >, + RCP > > > idsAndCoords_edge_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom","edge"); + std::vector & sideIds_top = *idsAndCoords_top.first; + std::vector & sideIds_bottom = *idsAndCoords_bottom.first; + std::vector & sideIds_edge_top = *idsAndCoords_edge_top.first; + std::vector & sideIds_edge_bottom = *idsAndCoords_edge_bottom.first; + std::vector > & sideCoords_top = *idsAndCoords_top.second; + std::vector > & sideCoords_bottom = *idsAndCoords_bottom.second; + std::vector > & sideCoords_edge_top = *idsAndCoords_edge_top.second; + std::vector > & sideCoords_edge_bottom = *idsAndCoords_edge_bottom.second; + + { + CoordMatcher xmatcher(0); + CoordMatcher ymatcher(1); + Teuchos::RCP tb_Match + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",xmatcher,"edge"); + Teuchos::RCP lr_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher,"edge"); + + RCP > > globallyMatchedIds_edge; + globallyMatchedIds_edge = tb_Match->getMatchedPair(*mesh); + globallyMatchedIds_edge = lr_Match->getMatchedPair(*mesh,globallyMatchedIds_edge); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + + std::pair pair = (*globallyMatchedIds_edge)[i]; + + // Get coordinates for matched edges on top and bottom + Tuple coord_top; + Tuple coord_bottom; + int flag_tb = 0; + for(std::size_t j=0;j coord_left; + Tuple coord_right; + int flag_lr = 0; + for(std::size_t j=0;j mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + pl->set("Z Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_face_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","face"); + std::pair >, + RCP > > > idsAndCoords_face_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","face"); + std::vector & sideIds_left = *idsAndCoords_left.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_face_left = *idsAndCoords_face_left.first; + std::vector & sideIds_face_right = *idsAndCoords_face_right.first; + std::vector > & sideCoords_left = *idsAndCoords_left.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_face_left = *idsAndCoords_face_left.second; + std::vector > & sideCoords_face_right = *idsAndCoords_face_right.second; + + std::pair >, + RCP > > > idsAndCoords_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + std::pair >, + RCP > > > idsAndCoords_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom"); + std::pair >, + RCP > > > idsAndCoords_face_top = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","face"); + std::pair >, + RCP > > > idsAndCoords_face_bottom = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"bottom","face"); + std::vector & sideIds_top = *idsAndCoords_top.first; + std::vector & sideIds_bottom = *idsAndCoords_bottom.first; + std::vector & sideIds_face_top = *idsAndCoords_face_top.first; + std::vector & sideIds_face_bottom = *idsAndCoords_face_bottom.first; + std::vector > & sideCoords_top = *idsAndCoords_top.second; + std::vector > & sideCoords_bottom = *idsAndCoords_bottom.second; + std::vector > & sideCoords_face_top = *idsAndCoords_face_top.second; + std::vector > & sideCoords_face_bottom = *idsAndCoords_face_bottom.second; + + { + CoordMatcher xmatcher(0); + CoordMatcher ymatcher(1); + Teuchos::RCP tb_Match + = panzer_stk::buildPeriodicBC_Matcher("top","bottom",xmatcher,"face"); + Teuchos::RCP lr_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher,"face"); + + RCP > > globallyMatchedIds_face; + globallyMatchedIds_face = tb_Match->getMatchedPair(*mesh); + globallyMatchedIds_face = lr_Match->getMatchedPair(*mesh,globallyMatchedIds_face); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + + std::pair pair = (*globallyMatchedIds_face)[i]; + + // Get coordinates for matched faces on top and bottom + Tuple coord_top; + Tuple coord_bottom; + int flag_tb = 0; + for(std::size_t j=0;j coord_left; + Tuple coord_right; + int flag_lr = 0; + for(std::size_t j=0;j mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::vector & sideIds_left = *idsAndCoords_left.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge_left = *idsAndCoords_edge_left.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector > & sideCoords_left = *idsAndCoords_left.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge_left = *idsAndCoords_edge_left.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + + + { + CoordMatcher ymatcher(1); + Teuchos::RCP node_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher); + Teuchos::RCP edge_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher,"edge"); + + RCP > > globallyMatchedIds; + globallyMatchedIds = node_Match->getMatchedPair(*mesh); + globallyMatchedIds = edge_Match->getMatchedPair(*mesh,globallyMatchedIds); + + + // match left & right sides + for(std::size_t i=0;isize();i++) { + + std::pair pair = (*globallyMatchedIds)[i]; + + // Is this a node or edge pairing? + if(pair.first < 27){ // Node + TEST_EQUALITY(pair.first,pair.second-8); + } else { //Edge + + // Get coordinates for matched edges on left and right + Tuple coord_left; + Tuple coord_right; + int flag_lr = 0; + for(std::size_t j=0;j mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + pl->set("Z Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + std::pair >, + RCP > > > idsAndCoords_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left"); + std::pair >, + RCP > > > idsAndCoords_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right"); + std::pair >, + RCP > > > idsAndCoords_edge_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","edge"); + std::pair >, + RCP > > > idsAndCoords_edge_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","edge"); + std::pair >, + RCP > > > idsAndCoords_face_left = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"left","face"); + std::pair >, + RCP > > > idsAndCoords_face_right = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"right","face"); + std::vector & sideIds_left = *idsAndCoords_left.first; + std::vector & sideIds_right = *idsAndCoords_right.first; + std::vector & sideIds_edge_left = *idsAndCoords_edge_left.first; + std::vector & sideIds_edge_right = *idsAndCoords_edge_right.first; + std::vector & sideIds_face_left = *idsAndCoords_face_left.first; + std::vector & sideIds_face_right = *idsAndCoords_face_right.first; + std::vector > & sideCoords_left = *idsAndCoords_left.second; + std::vector > & sideCoords_right = *idsAndCoords_right.second; + std::vector > & sideCoords_edge_left = *idsAndCoords_edge_left.second; + std::vector > & sideCoords_edge_right = *idsAndCoords_edge_right.second; + std::vector > & sideCoords_face_left = *idsAndCoords_face_left.second; + std::vector > & sideCoords_face_right = *idsAndCoords_face_right.second; + + { + PlaneMatcher ymatcher(1,2); + Teuchos::RCP node_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher); + Teuchos::RCP edge_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher,"edge"); + Teuchos::RCP face_Match + = panzer_stk::buildPeriodicBC_Matcher("left","right",ymatcher,"face"); + + RCP > > globallyMatchedIds; + globallyMatchedIds = node_Match->getMatchedPair(*mesh); + globallyMatchedIds = edge_Match->getMatchedPair(*mesh,globallyMatchedIds); + globallyMatchedIds = face_Match->getMatchedPair(*mesh,globallyMatchedIds); + + + // match left & right sides + for(std::size_t i=0;isize();i++) { + + std::pair pair = (*globallyMatchedIds)[i]; + // Is this a node, edge, or face pairing? + if(pair.first < 54){ // Node + TEST_EQUALITY(pair.first,pair.second-8); + } else if(pair.first < 192){ //Edge + + // Get coordinates for matched edges on left and right + Tuple coord_left; + Tuple coord_right; + int flag_lr = 0; + for(std::size_t j=0;j coord_left; + Tuple coord_right; + int flag_lr = 0; + for(std::size_t j=0;j pm; + pm = rcp(new PlaneMatcher(1,2)); + TEST_EQUALITY(pm->getPeriodicDirection(),0); + pm = rcp(new PlaneMatcher(2,1)); + TEST_EQUALITY(pm->getPeriodicDirection(),0); + pm = rcp(new PlaneMatcher(0,2)); + TEST_EQUALITY(pm->getPeriodicDirection(),1); + pm = rcp(new PlaneMatcher(2,0)); + TEST_EQUALITY(pm->getPeriodicDirection(),1); + pm = rcp(new PlaneMatcher(0,1)); + TEST_EQUALITY(pm->getPeriodicDirection(),2); + pm = rcp(new PlaneMatcher(1,0)); + TEST_EQUALITY(pm->getPeriodicDirection(),2); + + // Wedge in 2D + RCP wm; + std::vector params; + params.push_back("1.0e-8"); + params.push_back("2D"); + wm = rcp(new WedgeMatcher(WedgeMatcher::MirrorPlane::XZ_PLANE,params)); + TEST_ASSERT(wm->getMirrorPlane() == WedgeMatcher::MirrorPlane::XZ_PLANE); + TEST_ASSERT(!wm->isThreeD()); + TEST_EQUALITY(wm->getIndex(),1); + wm = rcp(new WedgeMatcher(WedgeMatcher::MirrorPlane::YZ_PLANE,params)); + TEST_ASSERT(wm->getMirrorPlane() == WedgeMatcher::MirrorPlane::YZ_PLANE); + TEST_ASSERT(!wm->isThreeD()); + TEST_EQUALITY(wm->getIndex(),0); + + // Wedge in 3D + params[1] = "3D"; + wm = rcp(new WedgeMatcher(WedgeMatcher::MirrorPlane::XZ_PLANE,params)); + TEST_ASSERT(wm->getMirrorPlane() == WedgeMatcher::MirrorPlane::XZ_PLANE); + TEST_ASSERT(wm->isThreeD()); + TEST_EQUALITY(wm->getIndex(),1); + wm = rcp(new WedgeMatcher(WedgeMatcher::MirrorPlane::YZ_PLANE,params)); + TEST_ASSERT(wm->getMirrorPlane() == WedgeMatcher::MirrorPlane::YZ_PLANE); + TEST_ASSERT(wm->isThreeD()); + TEST_EQUALITY(wm->getIndex(),0); + } +} diff --git a/packages/panzer/adapters-stk/test/periodic_bcs/periodic_mesh_tpetra.cpp b/packages/panzer/adapters-stk/test/periodic_bcs/periodic_mesh_tpetra.cpp new file mode 100644 index 000000000000..43649ab8a6ec --- /dev/null +++ b/packages/panzer/adapters-stk/test/periodic_bcs/periodic_mesh_tpetra.cpp @@ -0,0 +1,1337 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" +#include "Teuchos_Tuple.hpp" + +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_CubeHexMeshFactory.hpp" +#include "Panzer_STK_Utilities.hpp" +#include "Panzer_STK_PeriodicBC_Matcher.hpp" +#include "Panzer_STK_PeriodicBC_Parser.hpp" +#include "Panzer_STK_PeriodicBC_MatchConditions.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_IntrepidFieldPattern.hpp" +#include "Panzer_PauseToAttach.hpp" + +#include "Kokkos_DynRankView.hpp" +#include "Intrepid2_HGRAD_QUAD_C1_FEM.hpp" +#include "Intrepid2_HCURL_QUAD_I1_FEM.hpp" +#include "Intrepid2_HGRAD_HEX_C1_FEM.hpp" +#include "Intrepid2_HCURL_HEX_I1_FEM.hpp" + +#include + +typedef Kokkos::DynRankView FieldContainer; + +using Teuchos::RCP; +using Teuchos::rcp; + +namespace panzer { + + template + RCP buildFieldPattern() + { + // build a geometric pattern from a single basis + RCP > basis = rcp(new Intrepid2Type); + RCP pattern = rcp(new panzer::Intrepid2FieldPattern(basis)); + return pattern; + } + + TEUCHOS_UNIT_TEST(periodic_parser_tpetra, test_obj) + { + using Teuchos::RCP; + using Teuchos::rcp_dynamic_cast; + using namespace panzer_stk; + + panzer_stk::PeriodicBC_Parser parser; + + // test basic bc construction functionality + { + std::string matcher, bndry1, bndry2; + + parser.buildMatcher_Tokenize("x-coord left;right",matcher,bndry1,bndry2); + TEST_EQUALITY(matcher,"x-coord"); TEST_EQUALITY(bndry1,"left"); TEST_EQUALITY(bndry2,"right"); + + parser.buildMatcher_Tokenize("x-edge left;right",matcher,bndry1,bndry2); + TEST_EQUALITY(matcher,"x-edge"); TEST_EQUALITY(bndry1,"left"); TEST_EQUALITY(bndry2,"right"); + + parser.buildMatcher_Tokenize("y-coord beg ; what ",matcher,bndry1,bndry2); + TEST_EQUALITY(matcher,"y-coord"); TEST_EQUALITY(bndry1,"beg"); TEST_EQUALITY(bndry2,"what"); + + parser.buildMatcher_Tokenize("y-edge beg ; what ",matcher,bndry1,bndry2); + TEST_EQUALITY(matcher,"y-edge"); TEST_EQUALITY(bndry1,"beg"); TEST_EQUALITY(bndry2,"what"); + + RCP matcher_obj; + + matcher_obj = parser.buildMatcher("x-coord left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("xy-coord left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("(xy)z-quarter-coord left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("x-edge left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("xy-edge left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("xy-face left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("x-coord 1e-8: left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("xy-edge 1e-8: left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("x-coord 1e-8, relative: left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + matcher_obj = parser.buildMatcher("xy-edge 1e-8, relative: left;right"); + TEST_NOTHROW(rcp_dynamic_cast >(matcher_obj)); + + TEST_THROW(parser.buildMatcher("dog-coord left;right"),std::logic_error); + + TEST_THROW(parser.buildMatcher("dog-edge left;right"),std::logic_error); + + TEST_THROW(parser.buildMatcher("dog-face left;right"),std::logic_error); + + TEST_THROW(parser.buildMatcher("x-face left;right"),std::logic_error); + + TEST_THROW(parser.buildMatcher("xface left;right"),std::logic_error); + + TEST_THROW(parser.buildMatcher("x-coord 1e-8, misspelled-relatiive: left;right"),std::logic_error); + } + + // test parameter list based construction + { + RCP pl = Teuchos::rcp(new Teuchos::ParameterList("top_list")); + + pl->set("Count",8); + pl->set("Periodic Condition 1","y-coord left;right"); + pl->set("Periodic Condition 2","x-coord top;bottom"); + pl->set("Periodic Condition 3","yz-coord fake_a;fake_b"); + pl->set("Periodic Condition 4","(zy)x-quarter-coord fake_a;fake_b"); + pl->set("Periodic Condition 5","y-edge left;right"); + pl->set("Periodic Condition 6","x-edge top;bottom"); + pl->set("Periodic Condition 7","yz-edge fake_a;fake_b"); + pl->set("Periodic Condition 8","yz-face fake_a;fake_b"); + parser.setParameterList(pl); + + TEST_EQUALITY(parser.getMatchers().size(),8); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[0])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[1])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[2])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[3])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[4])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[5])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[6])); + TEST_NOTHROW(rcp_dynamic_cast >(parser.getMatchers()[7])); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, add_get_vector) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",6); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher,"edge")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher,"edge")); + + std::vector > & mod_vec = mesh->getPeriodicBCVector(); + TEST_EQUALITY(mod_vec.size(),4); + + const std::vector > & const_vec = mesh.getConst()->getPeriodicBCVector(); + TEST_EQUALITY(const_vec.size(),4); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + // mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + + if(myRank==0) { + TEST_EQUALITY(conn0[0],4); // this is periodic + TEST_EQUALITY(conn0[1],1); + TEST_EQUALITY(conn0[2],6); + TEST_EQUALITY(conn0[3],9); // this is periodic + + TEST_EQUALITY(conn1[0],2); + TEST_EQUALITY(conn1[1],3); + TEST_EQUALITY(conn1[2],8); + TEST_EQUALITY(conn1[3],7); + } + else { + TEST_EQUALITY(conn0[0],1); + TEST_EQUALITY(conn0[1],2); + TEST_EQUALITY(conn0[2],7); + TEST_EQUALITY(conn0[3],6); + + TEST_EQUALITY(conn1[0],3); + TEST_EQUALITY(conn1[1],4); + TEST_EQUALITY(conn1[2],9); + TEST_EQUALITY(conn1[3],8); + + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_edge) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + // mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher,"edge")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn3 = connMngr->getConnectivity(3); + + // test that the left-most edge has the same number as the right-most edge + if(myRank==0) { + TEST_EQUALITY(conn0[3],conn3[1]); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager2) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + + if(myRank==0) { + TEST_EQUALITY(conn0[0],0); + TEST_EQUALITY(conn0[1],1); + TEST_EQUALITY(conn0[2],1); + TEST_EQUALITY(conn0[3],0); + + TEST_EQUALITY(conn1[0],2); + TEST_EQUALITY(conn1[1],3); + TEST_EQUALITY(conn1[2],3); + TEST_EQUALITY(conn1[3],2); + } + else { + TEST_EQUALITY(conn0[0],1); + TEST_EQUALITY(conn0[1],2); + TEST_EQUALITY(conn0[2],2); + TEST_EQUALITY(conn0[3],1); + + TEST_EQUALITY(conn1[0],3); + TEST_EQUALITY(conn1[1],4); + TEST_EQUALITY(conn1[2],4); + TEST_EQUALITY(conn1[3],3); + + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager2_edge) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher,"edge")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + + // test that top edge has same number as bottom edge for each element + if(myRank==0) { + TEST_EQUALITY(conn0[0],conn0[2]); + TEST_EQUALITY(conn1[0],conn1[2]); + } else { + TEST_EQUALITY(conn0[0],conn0[2]); + TEST_EQUALITY(conn1[0],conn1[2]); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager3) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher)); + + mesh->writeToExodus("twod.exo"); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + + if(myRank==0) { + TEST_EQUALITY(conn0[0],4); // from left/right periodicity + TEST_EQUALITY(conn0[1],1); + TEST_EQUALITY(conn0[2],1); + TEST_EQUALITY(conn0[3],4); // from left/right periodicity + + TEST_EQUALITY(conn1[0],2); + TEST_EQUALITY(conn1[1],3); + TEST_EQUALITY(conn1[2],3); + TEST_EQUALITY(conn1[3],2); + } + else { + TEST_EQUALITY(conn0[0],1); + TEST_EQUALITY(conn0[1],2); + TEST_EQUALITY(conn0[2],2); + TEST_EQUALITY(conn0[3],1); + + TEST_EQUALITY(conn1[0],3); + TEST_EQUALITY(conn1[1],4); + TEST_EQUALITY(conn1[2],4); + TEST_EQUALITY(conn1[3],3); + + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager3_edge) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher,"edge")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",y_matcher,"edge")); + + mesh->writeToExodus("twod.exo"); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + const auto * conn3 = connMngr->getConnectivity(3); + + if(myRank==0) { + TEST_EQUALITY(conn0[3],conn3[1]); // from left/right periodicity + TEST_EQUALITY(conn0[0],conn0[2]); // from top/bottom periodicity + TEST_EQUALITY(conn1[0],conn1[2]); // from top/bottom periodicity + } else { + TEST_EQUALITY(conn0[0],conn0[2]); // from top/bottom periodicity + TEST_EQUALITY(conn1[0],conn1[2]); // from top/bottom periodicity + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager4) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::CoordMatcher x_matcher(0); + panzer_stk::CoordMatcher y_matcher(1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",x_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("right","left",y_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + const auto * conn0 = connMngr->getConnectivity(0); + const auto * conn1 = connMngr->getConnectivity(1); + + if(myRank==0) { + TEST_EQUALITY(conn0[0],0); // from left/right periodicity + TEST_EQUALITY(conn0[1],1); + TEST_EQUALITY(conn0[2],1); + TEST_EQUALITY(conn0[3],0); // from left/right periodicity + + TEST_EQUALITY(conn1[0],2); + TEST_EQUALITY(conn1[1],3); + TEST_EQUALITY(conn1[2],3); + TEST_EQUALITY(conn1[3],2); + } + else { + TEST_EQUALITY(conn0[0],1); + TEST_EQUALITY(conn0[1],2); + TEST_EQUALITY(conn0[2],2); + TEST_EQUALITY(conn0[3],1); + + TEST_EQUALITY(conn1[0],3); + TEST_EQUALITY(conn1[1],0); + TEST_EQUALITY(conn1[2],0); + TEST_EQUALITY(conn1[3],3); + + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_hex) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + // mesh->writeToExodus("what.exo"); + + panzer_stk::PlaneMatcher top_matcher(0,2); + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",top_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",side_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + if(myRank==0) { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(1)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(5)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(3)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(7)); + + TEST_EQUALITY(conn0[0],2); + TEST_EQUALITY(conn0[1],1); + TEST_EQUALITY(conn0[2],4); + TEST_EQUALITY(conn0[3],5); + TEST_EQUALITY(conn0[4],11); + TEST_EQUALITY(conn0[5],10); + TEST_EQUALITY(conn0[6],13); + TEST_EQUALITY(conn0[7],14); + + TEST_EQUALITY(conn1[0],11); + TEST_EQUALITY(conn1[1],10); + TEST_EQUALITY(conn1[2],13); + TEST_EQUALITY(conn1[3],14); + TEST_EQUALITY(conn1[4],2); + TEST_EQUALITY(conn1[5],1); + TEST_EQUALITY(conn1[6],4); + TEST_EQUALITY(conn1[7],5); + + TEST_EQUALITY(conn2[0],5); + TEST_EQUALITY(conn2[1],4); + TEST_EQUALITY(conn2[2],1); + TEST_EQUALITY(conn2[3],2); + TEST_EQUALITY(conn2[4],14); + TEST_EQUALITY(conn2[5],13); + TEST_EQUALITY(conn2[6],10); + TEST_EQUALITY(conn2[7],11); + + TEST_EQUALITY(conn3[0],14); + TEST_EQUALITY(conn3[1],13); + TEST_EQUALITY(conn3[2],10); + TEST_EQUALITY(conn3[3],11); + TEST_EQUALITY(conn3[4],5); + TEST_EQUALITY(conn3[5],4); + TEST_EQUALITY(conn3[6],1); + TEST_EQUALITY(conn3[7],2); + } + else { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(2)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(6)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(4)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(8)); + + TEST_EQUALITY(conn0[0],1); + TEST_EQUALITY(conn0[1],2); + TEST_EQUALITY(conn0[2],5); + TEST_EQUALITY(conn0[3],4); + TEST_EQUALITY(conn0[4],10); + TEST_EQUALITY(conn0[5],11); + TEST_EQUALITY(conn0[6],14); + TEST_EQUALITY(conn0[7],13); + // passed + + TEST_EQUALITY(conn1[0],10); + TEST_EQUALITY(conn1[1],11); + TEST_EQUALITY(conn1[2],14); + TEST_EQUALITY(conn1[3],13); + TEST_EQUALITY(conn1[4],1); + TEST_EQUALITY(conn1[5],2); + TEST_EQUALITY(conn1[6],5); + TEST_EQUALITY(conn1[7],4); + + TEST_EQUALITY(conn2[0],4); + TEST_EQUALITY(conn2[1],5); + TEST_EQUALITY(conn2[2],2); + TEST_EQUALITY(conn2[3],1); + TEST_EQUALITY(conn2[4],13); + TEST_EQUALITY(conn2[5],14); + TEST_EQUALITY(conn2[6],11); + TEST_EQUALITY(conn2[7],10); + + TEST_EQUALITY(conn3[0],13); + TEST_EQUALITY(conn3[1],14); + TEST_EQUALITY(conn3[2],11); + TEST_EQUALITY(conn3[3],10); + TEST_EQUALITY(conn3[4],4); + TEST_EQUALITY(conn3[5],5); + TEST_EQUALITY(conn3[6],2); + TEST_EQUALITY(conn3[7],1); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_hex_edge) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + // mesh->writeToExodus("what.exo"); + + panzer_stk::PlaneMatcher top_matcher(0,2); + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",top_matcher,"edge")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher,"edge")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + if(myRank==0) { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(1)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(5)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(3)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(7)); + + // top/bottom matching + TEST_EQUALITY(conn0[0],conn2[2]); + TEST_EQUALITY(conn0[9],conn2[10]); + TEST_EQUALITY(conn0[4],conn2[6]); + TEST_EQUALITY(conn0[8],conn2[11]); + TEST_EQUALITY(conn1[0],conn3[2]); + TEST_EQUALITY(conn1[9],conn3[10]); + TEST_EQUALITY(conn1[4],conn3[6]); + TEST_EQUALITY(conn1[8],conn3[11]); + + // back/front matching + TEST_EQUALITY(conn0[0],conn1[4]); + TEST_EQUALITY(conn0[1],conn1[5]); + TEST_EQUALITY(conn0[2],conn1[6]); + TEST_EQUALITY(conn0[3],conn1[7]); + TEST_EQUALITY(conn2[0],conn3[4]); + TEST_EQUALITY(conn2[1],conn3[5]); + TEST_EQUALITY(conn2[2],conn3[6]); + TEST_EQUALITY(conn2[3],conn3[7]); + } + else { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(2)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(6)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(4)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(8)); + + // top/bottom matching + TEST_EQUALITY(conn0[0],conn2[2]); + TEST_EQUALITY(conn0[9],conn2[10]); + TEST_EQUALITY(conn0[4],conn2[6]); + TEST_EQUALITY(conn0[8],conn2[11]); + TEST_EQUALITY(conn1[0],conn3[2]); + TEST_EQUALITY(conn1[9],conn3[10]); + TEST_EQUALITY(conn1[4],conn3[6]); + TEST_EQUALITY(conn1[8],conn3[11]); + + // back/front matching + TEST_EQUALITY(conn0[0],conn1[4]); + TEST_EQUALITY(conn0[1],conn1[5]); + TEST_EQUALITY(conn0[2],conn1[6]); + TEST_EQUALITY(conn0[3],conn1[7]); + TEST_EQUALITY(conn2[0],conn3[4]); + TEST_EQUALITY(conn2[1],conn3[5]); + TEST_EQUALITY(conn2[2],conn3[6]); + TEST_EQUALITY(conn2[3],conn3[7]); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_hex_face) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + // mesh->writeToExodus("what.exo"); + + panzer_stk::PlaneMatcher top_matcher(0,2); + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("top","bottom",top_matcher,"face")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher,"face")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + if(myRank==0) { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(1)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(5)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(3)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(7)); + + // top/bottom matching + TEST_EQUALITY(conn0[0],conn2[2]); + TEST_EQUALITY(conn0[2],conn2[0]); + TEST_EQUALITY(conn1[0],conn3[2]); + TEST_EQUALITY(conn1[2],conn3[0]); + + // back/front matching + TEST_EQUALITY(conn0[4],conn1[5]); + TEST_EQUALITY(conn0[5],conn1[4]); + TEST_EQUALITY(conn2[4],conn3[5]); + TEST_EQUALITY(conn2[5],conn3[4]); + } + else { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(2)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(6)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(4)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(8)); + + // top/bottom matching + TEST_EQUALITY(conn0[0],conn2[2]); + TEST_EQUALITY(conn0[2],conn2[0]); + TEST_EQUALITY(conn1[0],conn3[2]); + TEST_EQUALITY(conn1[2],conn3[0]); + + // back/front matching + TEST_EQUALITY(conn0[4],conn1[5]); + TEST_EQUALITY(conn0[5],conn1[4]); + TEST_EQUALITY(conn2[4],conn3[5]); + TEST_EQUALITY(conn2[5],conn3[4]); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_hex_quarter) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + int myRank = comm->getRank(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // mesh->writeToExodus("what.exo"); + + panzer_stk::QuarterPlaneMatcher quarter_matcher(0,2,1); // (xz)y + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("back","left",quarter_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + + if(myRank==0) { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(1)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(5)); + const auto * conn2 = connMngr->getConnectivity(mesh->elementLocalId(3)); + const auto * conn3 = connMngr->getConnectivity(mesh->elementLocalId(7)); + + TEST_EQUALITY(conn0[0],0); + TEST_EQUALITY(conn0[1],9); + TEST_EQUALITY(conn0[2],12); + TEST_EQUALITY(conn0[3],3); + TEST_EQUALITY(conn0[4],9); + TEST_EQUALITY(conn0[5],10); + TEST_EQUALITY(conn0[6],13); + TEST_EQUALITY(conn0[7],12); + + TEST_EQUALITY(conn1[0],9); + TEST_EQUALITY(conn1[1],10); + TEST_EQUALITY(conn1[2],13); + TEST_EQUALITY(conn1[3],12); + TEST_EQUALITY(conn1[4],18); + TEST_EQUALITY(conn1[5],19); + TEST_EQUALITY(conn1[6],22); + TEST_EQUALITY(conn1[7],21); + + TEST_EQUALITY(conn2[0],3); + TEST_EQUALITY(conn2[1],12); + TEST_EQUALITY(conn2[2],15); + TEST_EQUALITY(conn2[3],6); + TEST_EQUALITY(conn2[4],12); + TEST_EQUALITY(conn2[5],13); + TEST_EQUALITY(conn2[6],16); + TEST_EQUALITY(conn2[7],15); + + TEST_EQUALITY(conn3[0],12); + TEST_EQUALITY(conn3[1],13); + TEST_EQUALITY(conn3[2],16); + TEST_EQUALITY(conn3[3],15); + TEST_EQUALITY(conn3[4],21); + TEST_EQUALITY(conn3[5],22); + TEST_EQUALITY(conn3[6],25); + TEST_EQUALITY(conn3[7],24); + } + else { + const auto * conn0 = connMngr->getConnectivity(mesh->elementLocalId(2)); + const auto * conn1 = connMngr->getConnectivity(mesh->elementLocalId(4)); + + TEST_EQUALITY(conn0[0],9); + TEST_EQUALITY(conn0[1],18); + TEST_EQUALITY(conn0[2],21); + TEST_EQUALITY(conn0[3],12); + TEST_EQUALITY(conn0[4],10); + TEST_EQUALITY(conn0[5],11); + TEST_EQUALITY(conn0[6],14); + TEST_EQUALITY(conn0[7],13); + // passed + + TEST_EQUALITY(conn1[0],12); + TEST_EQUALITY(conn1[1],21); + TEST_EQUALITY(conn1[2],24); + TEST_EQUALITY(conn1[3],15); + TEST_EQUALITY(conn1[4],13); + TEST_EQUALITY(conn1[5],14); + TEST_EQUALITY(conn1[6],17); + TEST_EQUALITY(conn1[7],16); + } + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_3d_yz_xy_periodic) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + //int myRank = comm->getRank(); + + // panzer::pauseToAttach(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",2); + pl->set("Z Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + pl->set("X Procs",2); + pl->set("Y Procs",1); + pl->set("Z Procs",1); + pl->set("X0",0.0); + pl->set("Y0",0.0); + pl->set("Z0",0.0); + pl->set("Xf",4.0); + pl->set("Yf",2.0); + pl->set("Zf",0.25); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",side_matcher)); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher)); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_3d_yz_xy_periodic_edge) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + //int myRank = comm->getRank(); + + // panzer::pauseToAttach(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",2); + pl->set("Z Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + pl->set("X Procs",2); + pl->set("Y Procs",1); + pl->set("Z Procs",1); + pl->set("X0",0.0); + pl->set("Y0",0.0); + pl->set("Z0",0.0); + pl->set("Xf",4.0); + pl->set("Yf",2.0); + pl->set("Zf",0.25); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",side_matcher,"edge")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher,"edge")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, conn_manager_3d_yz_xy_periodic_face) + { + using Teuchos::RCP; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + //int myRank = comm->getRank(); + + // panzer::pauseToAttach(); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",1); + pl->set("Y Blocks",2); + pl->set("Z Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",2); + pl->set("Z Elements",2); + pl->set("X Procs",2); + pl->set("Y Procs",1); + pl->set("Z Procs",1); + pl->set("X0",0.0); + pl->set("Y0",0.0); + pl->set("Z0",0.0); + pl->set("Xf",4.0); + pl->set("Yf",2.0); + pl->set("Zf",0.25); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + panzer_stk::PlaneMatcher side_matcher(1,2); + panzer_stk::PlaneMatcher front_matcher(0,1); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("left","right",side_matcher,"face")); + mesh->addPeriodicBC(panzer_stk::buildPeriodicBC_Matcher("front","back",front_matcher,"face")); + + // connection manager + ///////////////////////////////////////////// + Teuchos::RCP connMngr + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + RCP fp + = buildFieldPattern >(); + connMngr->buildConnectivity(*fp); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, getSideIdsAndCoords) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // mesh->writeToExodus("output.exo"); + + panzer_stk::CoordMatcher x_matcher(0); + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top"); + + TEST_EQUALITY(idsAndCoords.first->size(),5); + TEST_EQUALITY(idsAndCoords.second->size(),5); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, getSideIdsAndCoords_edge) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // mesh->writeToExodus("output.exo"); + + panzer_stk::CoordMatcher x_matcher(0); + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","edge"); + + TEST_EQUALITY(idsAndCoords.first->size(),4); + TEST_EQUALITY(idsAndCoords.second->size(),4); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, getSideIdsAndCoords_face) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + TEUCHOS_ASSERT(comm->getSize()==2); + + panzer_stk::CubeHexMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("Z Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + pl->set("Z Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // mesh->writeToExodus("output.exo"); + + panzer_stk::CoordMatcher x_matcher(0); + std::pair >, + RCP > > > idsAndCoords = panzer_stk::periodic_helpers::getSideIdsAndCoords(*mesh,"top","face"); + + TEST_EQUALITY(idsAndCoords.first->size(),4); + TEST_EQUALITY(idsAndCoords.second->size(),4); + } + + TEUCHOS_UNIT_TEST(periodic_mesh_tpetra, PeriodicBC_Matcher) + { + using Teuchos::RCP; + using Teuchos::Tuple; + + auto comm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + panzer_stk::SquareQuadMeshFactory mesh_factory; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",2); + pl->set("Y Elements",1); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + { + panzer_stk::CoordMatcher matcher(1); + Teuchos::RCP pMatch + = panzer_stk::buildPeriodicBC_Matcher("left","right",matcher); + + RCP > > globallyMatchedIds = pMatch->getMatchedPair(*mesh); + + // for testing purposes! + RCP > locallyRequiredIds = panzer_stk::periodic_helpers::getLocalSideIds(*mesh,"left"); + + TEST_EQUALITY(globallyMatchedIds->size(),locallyRequiredIds->size()); + + // match top & bottom sides + for(std::size_t i=0;isize();i++) { + std::pair pair = (*globallyMatchedIds)[i]; + TEST_EQUALITY(pair.first,pair.second-4); + } + } + } + +} diff --git a/packages/panzer/adapters-stk/test/response_library/CMakeLists.txt b/packages/panzer/adapters-stk/test/response_library/CMakeLists.txt index 8600ef377bbd..f2b5d7b6f2f1 100644 --- a/packages/panzer/adapters-stk/test/response_library/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/response_library/CMakeLists.txt @@ -9,16 +9,24 @@ TRIBITS_INCLUDE_DIRECTORIES(${${PACKAGE_NAME}_SOURCE_DIR}/test/bcstrategy) SET(UNIT_TEST_DRIVER ${PANZER_UNIT_TEST_MAIN}) - -IF(PANZER_HAVE_EPETRA_STACK) + +IF(PANZER_HAVE_EPETRA) TRIBITS_ADD_EXECUTABLE_AND_TEST( - STK_ResponseLibraryTest2 - SOURCES response_library2.cpp ${UNIT_TEST_DRIVER} + STK_ResponseLibraryTest2_Epetra + SOURCES epetra_response_library2.cpp ${UNIT_TEST_DRIVER} COMM serial mpi NUM_MPI_PROCS 2 XHOST trilinos-test.sandia.gov trilinos-test2.sandia.gov zan.sandia.gov ) -ENDIF(PANZER_HAVE_EPETRA_STACK) +ENDIF(PANZER_HAVE_EPETRA) + +TRIBITS_ADD_EXECUTABLE_AND_TEST( + STK_ResponseLibraryTest2_Tpetra + SOURCES tpetra_response_library2.cpp ${UNIT_TEST_DRIVER} + COMM serial mpi + NUM_MPI_PROCS 2 + XHOST trilinos-test.sandia.gov trilinos-test2.sandia.gov zan.sandia.gov + ) TRIBITS_ADD_EXECUTABLE_AND_TEST( STK_VolumeSideResponse diff --git a/packages/panzer/adapters-stk/test/response_library/response_library2.cpp b/packages/panzer/adapters-stk/test/response_library/epetra_response_library2.cpp similarity index 100% rename from packages/panzer/adapters-stk/test/response_library/response_library2.cpp rename to packages/panzer/adapters-stk/test/response_library/epetra_response_library2.cpp diff --git a/packages/panzer/adapters-stk/test/response_library/tpetra_response_library2.cpp b/packages/panzer/adapters-stk/test/response_library/tpetra_response_library2.cpp new file mode 100644 index 000000000000..9e8a247c9025 --- /dev/null +++ b/packages/panzer/adapters-stk/test/response_library/tpetra_response_library2.cpp @@ -0,0 +1,527 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include +#include + +using Teuchos::RCP; +using Teuchos::rcp; + +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" + +#include "Tpetra_Core.hpp" + +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Interface.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_SetupUtilities.hpp" +#include "Panzer_STK_WorksetFactory.hpp" +#include "Panzer_Workset_Builder.hpp" +#include "Panzer_FieldManagerBuilder.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_DOFManagerFactory.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_GlobalData.hpp" +#include "Panzer_ResponseEvaluatorFactory_Functional.hpp" +#include "user_app_EquationSetFactory.hpp" +#include "user_app_STKClosureModel_Factory_TemplateBuilder.hpp" +#include "user_app_BCStrategy_Factory.hpp" + +#include "Panzer_ResponseLibrary.hpp" +#include "Panzer_WorksetContainer.hpp" + +#include "TestEvaluators.hpp" + +#include +#include +#include + +#include "Panzer_TypeAssocMap.hpp" + +#include "Sacado_mpl_vector.hpp" + +using Teuchos::RCP; + +namespace panzer { + + void testInitialzation(const Teuchos::RCP& ipb, + std::vector& bcs); + + std::pair >,RCP > > buildResponseLibrary( + std::vector > & physics_blocks, + panzer::ClosureModelFactory_TemplateManager & cm_factory, + Teuchos::ParameterList & closure_models, + Teuchos::ParameterList & user_data); + + struct Builder { + template + std::string build() const { return "other"; } + }; + template < > std::string Builder::build() const { return "Sint"; } + template < > std::string Builder::build() const { return "Sshort"; } + template < > std::string Builder::build() const { return "Schar"; } + + template + class FakeEpetraEnabledResponse_Functional : public Response_Functional + { + friend class ResponseMESupport_Default; + FakeEpetraEnabledResponse_Functional(const std::string &responseName, MPI_Comm comm, + const Teuchos::RCP> &linObjFact = Teuchos::null) + : Response_Functional(responseName, comm, linObjFact) + { + // Enable Epetra to simulate Response object which was already using Epetra + ResponseMESupportBase::useEpetra_(true); + } + }; + + TEUCHOS_UNIT_TEST(type_assoc_map, test) + { + typedef Sacado::mpl::vector VecType; + + + TypeAssocMap tMap; + + Builder builder; + tMap.buildObjects(builder); + + TEST_EQUALITY(tMap.get(),"Schar"); + TEST_EQUALITY(tMap.get(),"Sshort"); + + tMap.set("not char"); + TEST_EQUALITY(tMap.get(),"not char"); + } + + struct RespFactoryFunc_Builder { + MPI_Comm comm; + Teuchos::RCP > linearObjFactory; + Teuchos::RCP globalIndexer; + + template + Teuchos::RCP build() const + { return Teuchos::rcp(new ResponseEvaluatorFactory_Functional(comm,1,true,"",linearObjFactory)); } + }; + + TEUCHOS_UNIT_TEST(response_library2, test) + { + std::vector > physics_blocks; + panzer::ClosureModelFactory_TemplateManager cm_factory; + Teuchos::ParameterList closure_models("Closure Models"); + Teuchos::ParameterList user_data("User Data"); + + // setup and evaluate ResponseLibrary + /////////////////////////////////////////////////// + + out << "Adding responses" << std::endl; + + std::pair< RCP >, RCP > > data + = buildResponseLibrary(physics_blocks,cm_factory,closure_models,user_data); + RCP > rLibrary = data.first; + RCP > lof = data.second; + + RespFactoryFunc_Builder builder; + builder.comm = MPI_COMM_WORLD; + std::vector blocks(1); + blocks[0] = "eblock-0_0"; + rLibrary->addResponse("FIELD_A",blocks,builder); + blocks[0] = "eblock-1_0"; + rLibrary->addResponse("FIELD_B",blocks,builder); + + Teuchos::RCP tResp = rLibrary->getResponse("FIELD_A"); + Teuchos::RCP iResp = rLibrary->getResponse("FIELD_B"); + + TEST_ASSERT(tResp!=Teuchos::null); + TEST_ASSERT(iResp!=Teuchos::null); + + TEST_EQUALITY(tResp->getName(),"FIELD_A"); + TEST_EQUALITY(iResp->getName(),"FIELD_B"); + + TEST_EQUALITY(tResp->getLookupName(),"RESPONSE_FIELD_A"); + TEST_EQUALITY(iResp->getLookupName(),"RESPONSE_FIELD_B"); + + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(tResp,true)); + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(iResp,true)); + + RCP > tVec; + { + RCP > vs = Teuchos::rcp_dynamic_cast >(tResp)->getVectorSpace(); + + tVec = Thyra::createMember(vs); + + Teuchos::rcp_dynamic_cast >(iResp)->setVector(tVec); + Teuchos::rcp_dynamic_cast >(tResp)->setVector(tVec); + + // test thyra only logic + // Disabled until further guidance + // TEST_THROW(Teuchos::rcp_dynamic_cast >(iResp)->setVector(tVec), std::logic_error); + } + + std::vector > v; + v.push_back(Teuchos::null); + + rLibrary->getResponses(v); + TEST_EQUALITY(v.size(),2); + + TEST_ASSERT(v[0]->getName()=="FIELD_A" || v[0]->getName()=="FIELD_B"); + TEST_ASSERT(v[1]->getName()=="FIELD_A" || v[1]->getName()=="FIELD_B"); + + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(v[0],true)); + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(v[1],true)); + + TEST_ASSERT(!rLibrary->responseEvaluatorsBuilt()); + + rLibrary->buildResponseEvaluators(physics_blocks, + cm_factory, + closure_models, + user_data, true); + + TEST_ASSERT(rLibrary->responseEvaluatorsBuilt()); + + Teuchos::RCP loc = lof->buildLinearObjContainer(); + lof->initializeContainer(panzer::LinearObjContainer::X,*loc); + Teuchos::RCP gloc = lof->buildGhostedLinearObjContainer(); + lof->initializeGhostedContainer(panzer::LinearObjContainer::X,*gloc); + + panzer::AssemblyEngineInArgs ae_inargs(gloc,loc); + + rLibrary->addResponsesToInArgs(ae_inargs); + rLibrary->evaluate(ae_inargs); + + Teuchos::ArrayRCP tData; + Teuchos::rcp_dynamic_cast >(tVec)->getNonconstLocalData(Teuchos::outArg(tData)); + + double tValue = 82.9; + + TEST_FLOATING_EQUALITY(tData[0],0.5*tValue,1e-14); + } + + TEUCHOS_UNIT_TEST(response_library2, test_surface) + { + + std::vector > physics_blocks; + panzer::ClosureModelFactory_TemplateManager cm_factory; + Teuchos::ParameterList closure_models("Closure Models"); + Teuchos::ParameterList user_data("User Data"); + + // setup and evaluate ResponseLibrary + /////////////////////////////////////////////////// + + out << "Adding responses" << std::endl; + + std::pair< RCP >, RCP > > data + = buildResponseLibrary(physics_blocks,cm_factory,closure_models,user_data); + RCP > rLibrary = data.first; + RCP > lof = data.second; + RCP globalIndexer + = user_data.sublist("Panzer Data").get >("DOF Manager"); + + RespFactoryFunc_Builder builder; + builder.comm = MPI_COMM_WORLD; + builder.linearObjFactory = lof; + builder.globalIndexer = globalIndexer; + std::vector blocks(1); + blocks[0] = "eblock-0_0"; + rLibrary->addResponse("FIELD_A",blocks,builder); + + builder.linearObjFactory = Teuchos::null; + builder.globalIndexer = Teuchos::null; + std::vector > sidesets; + sidesets.push_back(std::make_pair("bottom","eblock-0_0")); // 0.5 + sidesets.push_back(std::make_pair("top","eblock-0_0")); // 0.5 + sidesets.push_back(std::make_pair("right","eblock-1_0")); // 1.0 + rLibrary->addResponse("FIELD_B",sidesets,builder); + + Teuchos::RCP blkResp = rLibrary->getResponse("FIELD_A"); + Teuchos::RCP ssResp = rLibrary->getResponse("FIELD_B"); + + Teuchos::RCP blkRespJac = rLibrary->getResponse("FIELD_A"); + TEST_ASSERT(blkRespJac!=Teuchos::null); + + // no response should be build for this one + TEST_ASSERT(rLibrary->getResponse("FIELD_B")==Teuchos::null); + + // RCP eVec, eVec2; + RCP > tVec, tVec2; + { + RCP > vs = Teuchos::rcp_dynamic_cast >(ssResp)->getVectorSpace(); + + tVec = Thyra::createMember(vs); + tVec2 = Thyra::createMember(vs); + + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(blkResp)->setVector(tVec)); + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(ssResp)->setVector(tVec2)); + + RCP > dVec = Teuchos::rcp_dynamic_cast >(blkRespJac,true)->buildDerivative(); + TEST_NOTHROW(Teuchos::rcp_dynamic_cast >(blkRespJac,true)->setDerivative(dVec)); + } + + rLibrary->buildResponseEvaluators(physics_blocks, + cm_factory, + closure_models, + user_data,true); + + TEST_ASSERT(rLibrary->responseEvaluatorsBuilt()); + + Teuchos::RCP loc = lof->buildLinearObjContainer(); + lof->initializeContainer(panzer::LinearObjContainer::X,*loc); + Teuchos::RCP gloc = lof->buildGhostedLinearObjContainer(); + lof->initializeGhostedContainer(panzer::LinearObjContainer::X,*gloc); + + + { + panzer::AssemblyEngineInArgs ae_inargs(gloc,loc); + rLibrary->addResponsesToInArgs(ae_inargs); + rLibrary->evaluate(ae_inargs); + } + + // evaluate derivatives + { + panzer::AssemblyEngineInArgs ae_inargs(gloc,loc); + rLibrary->addResponsesToInArgs(ae_inargs); + rLibrary->evaluate(ae_inargs); + } + + Teuchos::ArrayRCP tData; + Teuchos::rcp_dynamic_cast >(tVec)->getNonconstLocalData(Teuchos::outArg(tData)); + Teuchos::ArrayRCP tData2; + Teuchos::rcp_dynamic_cast >(tVec2)->getNonconstLocalData(Teuchos::outArg(tData2)); + + double iValue = -2.3; + double tValue = 82.9; + + TEST_FLOATING_EQUALITY(tData[0],0.5*tValue,1e-14); + TEST_FLOATING_EQUALITY(tData2[0],2.0*iValue,1e-14); + } + + void testInitialzation(const Teuchos::RCP& ipb, + std::vector& bcs) + { + // Physics block + Teuchos::ParameterList& physics_block = ipb->sublist("test physics"); + { + Teuchos::ParameterList& p = physics_block.sublist("a"); + p.set("Type","Energy"); + p.set("Prefix",""); + p.set("Model ID","solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",2); + p.set("Integration Order",1); + } + { + Teuchos::ParameterList& p = physics_block.sublist("b"); + p.set("Type","Energy"); + p.set("Prefix","ION_"); + p.set("Model ID","ion solid"); + p.set("Basis Type","HGrad"); + p.set("Basis Order",1); + p.set("Integration Order",1); + } + + { + std::size_t bc_id = 0; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "left"; + std::string element_block_id = "eblock-0_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 1; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "right"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + { + std::size_t bc_id = 2; + panzer::BCType neumann = BCT_Dirichlet; + std::string sideset_id = "top"; + std::string element_block_id = "eblock-1_0"; + std::string dof_name = "TEMPERATURE"; + std::string strategy = "Constant"; + double value = 5.0; + Teuchos::ParameterList p; + p.set("Value",value); + panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name, + strategy, p); + bcs.push_back(bc); + } + } + + std::pair >,RCP > > buildResponseLibrary( + std::vector > & physics_blocks, + panzer::ClosureModelFactory_TemplateManager & cm_factory, + Teuchos::ParameterList & closure_models, + Teuchos::ParameterList & user_data) + { + using Teuchos::RCP; + + #ifdef HAVE_MPI + Teuchos::RCP > tcomm = Teuchos::rcp(new Teuchos::MpiComm(Teuchos::opaqueWrapper(MPI_COMM_WORLD))); + #else + Teuchos::RCP > tcomm = Teuchos::rcp(new Teuchos::SerialComm); + #endif + + panzer_stk::SquareQuadMeshFactory mesh_factory; + Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); + user_app::BCFactory bc_factory; + const std::size_t workset_size = 20; + + panzer::FieldManagerBuilder fmb; + + // setup mesh + ///////////////////////////////////////////// + RCP mesh; + { + RCP pl = rcp(new Teuchos::ParameterList); + pl->set("X Blocks",2); + pl->set("Y Blocks",1); + pl->set("X Elements",4); + pl->set("Y Elements",4); + mesh_factory.setParameterList(pl); + mesh = mesh_factory.buildMesh(MPI_COMM_WORLD); + } + + // setup physic blocks + ///////////////////////////////////////////// + Teuchos::RCP ipb = Teuchos::parameterList("Physics Blocks"); + std::vector bcs; + { + testInitialzation(ipb, bcs); + + std::map block_ids_to_physics_ids; + block_ids_to_physics_ids["eblock-0_0"] = "test physics"; + block_ids_to_physics_ids["eblock-1_0"] = "test physics"; + + std::map > block_ids_to_cell_topo; + block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0"); + block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0"); + + Teuchos::RCP gd = panzer::createGlobalData(); + + int default_integration_order = 1; + + panzer::buildPhysicsBlocks(block_ids_to_physics_ids, + block_ids_to_cell_topo, + ipb, + default_integration_order, + workset_size, + eqset_factory, + gd, + false, + physics_blocks); + } + + // setup worksets + ///////////////////////////////////////////// + + std::vector validEBlocks; + mesh->getElementBlockNames(validEBlocks); + + // build WorksetContainer + Teuchos::RCP wkstFactory + = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory + Teuchos::RCP wkstContainer // attach it to a workset container (uses lazy evaluation) + = Teuchos::rcp(new panzer::WorksetContainer); + wkstContainer->setFactory(wkstFactory); + for(size_t i=0;isetNeeds(physics_blocks[i]->elementBlockID(),physics_blocks[i]->getWorksetNeeds()); + wkstContainer->setWorksetSize(workset_size); + + // setup DOF manager + ///////////////////////////////////////////// + const Teuchos::RCP conn_manager + = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + + Teuchos::RCP indexerFactory + = Teuchos::rcp(new panzer::DOFManagerFactory); + const Teuchos::RCP dofManager + = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physics_blocks,conn_manager); + + // and linear object factory + Teuchos::RCP > tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + Teuchos::RCP > lof + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tComm.getConst(), dofManager)); + + // setup field manager builder + ///////////////////////////////////////////// + + // Add in the application specific closure model factory + user_app::STKModelFactory_TemplateBuilder cm_builder; + cm_factory.buildObjects(cm_builder); + + double iValue = -2.3; + double tValue = 82.9; + + closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set("Value",1.0); + closure_models.sublist("solid").sublist("FIELD_A").set("Value",tValue); + closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set("Value",1.0); + closure_models.sublist("ion solid").sublist("FIELD_B").set("Value",iValue); + + user_data.sublist("Panzer Data").set("Mesh", mesh); + user_data.sublist("Panzer Data").set("DOF Manager", dofManager); + user_data.sublist("Panzer Data").set("Linear Object Factory", lof); + user_data.set("Workset Size",workset_size); + + RCP > rLibrary + = Teuchos::rcp(new ResponseLibrary(wkstContainer,dofManager,lof)); + + return std::make_pair(rLibrary,lof); + } + +} diff --git a/packages/panzer/adapters-stk/test/response_library/volumetric_side_response.cpp b/packages/panzer/adapters-stk/test/response_library/volumetric_side_response.cpp index 94b01bbe2cbe..c36a9e78bf1e 100644 --- a/packages/panzer/adapters-stk/test/response_library/volumetric_side_response.cpp +++ b/packages/panzer/adapters-stk/test/response_library/volumetric_side_response.cpp @@ -29,10 +29,7 @@ using Teuchos::rcp; #include "Panzer_FieldManagerBuilder.hpp" #include "Panzer_STKConnManager.hpp" #include "Panzer_DOFManagerFactory.hpp" - -#ifdef PANZER_HAVE_EPETRA_STACK -#include "Panzer_BlockedEpetraLinearObjFactory.hpp" -#endif +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" #include "Panzer_GlobalData.hpp" #include "Panzer_ResponseEvaluatorFactory_Functional.hpp" @@ -69,13 +66,11 @@ namespace panzer_stk { Teuchos::ParameterList & closure_models, Teuchos::ParameterList & user_data); -#ifdef PANZER_HAVE_EPETRA_STACK std::pair >,RCP > > buildResponseLibrary( std::vector > & physics_blocks, panzer::ClosureModelFactory_TemplateManager & cm_factory, Teuchos::ParameterList & closure_models, Teuchos::ParameterList & user_data); -#endif // PANZER_HAVE_EPETRA_STACK struct RespFactoryFunc_Builder { MPI_Comm comm; @@ -239,7 +234,6 @@ namespace panzer_stk { } } -#ifdef PANZER_HAVE_EPETRA_STACK TEUCHOS_UNIT_TEST(volumetric_side_response, test_eval) { @@ -326,7 +320,6 @@ namespace panzer_stk { // is computed. Essentially each element is included three times // in the workset. } -#endif // PANZER_HAVE_EPETRA_STACK void testInitialzation(const Teuchos::RCP& ipb, std::vector& bcs) @@ -476,7 +469,6 @@ namespace panzer_stk { } } -#ifdef PANZER_HAVE_EPETRA_STACK std::pair >,RCP > > buildResponseLibrary( std::vector > & physics_blocks, panzer::ClosureModelFactory_TemplateManager & cm_factory, @@ -566,10 +558,10 @@ namespace panzer_stk { = indexerFactory->buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physics_blocks,conn_manager); // and linear object factory - Teuchos::RCP > elof - = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory(tcomm.getConst(),dofManager)); + Teuchos::RCP> tlof + = Teuchos::rcp(new panzer::TpetraLinearObjFactory(tcomm, dofManager)); - Teuchos::RCP > lof = elof; + Teuchos::RCP > lof = tlof; // setup field manager builder ///////////////////////////////////////////// @@ -596,6 +588,5 @@ namespace panzer_stk { return std::make_pair(rLibrary,lof); } -#endif // PANZER_HAVE_EPETRA_STACK } diff --git a/packages/panzer/adapters-stk/test/stk_connmngr/CMakeLists.txt b/packages/panzer/adapters-stk/test/stk_connmngr/CMakeLists.txt index 4806999e70c1..41900e6a8db9 100644 --- a/packages/panzer/adapters-stk/test/stk_connmngr/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/stk_connmngr/CMakeLists.txt @@ -42,6 +42,13 @@ IF (PANZER_HAVE_EPETRA_STACK) ) ENDIF (PANZER_HAVE_EPETRA_STACK) +TRIBITS_ADD_EXECUTABLE_AND_TEST( + tTpetraLinObjFactory + SOURCES tTpetraLinearObjFactory.cpp ${UNIT_TEST_DRIVER} + NUM_MPI_PROCS 2 + COMM serial mpi + ) + TRIBITS_ADD_EXECUTABLE_AND_TEST( tCubeHexMeshDOFManager SOURCES tCubeHexMeshDOFManager.cpp ${UNIT_TEST_DRIVER} diff --git a/packages/panzer/adapters-stk/test/stk_connmngr/tTpetraLinearObjFactory.cpp b/packages/panzer/adapters-stk/test/stk_connmngr/tTpetraLinearObjFactory.cpp new file mode 100644 index 000000000000..1e7fe96fc107 --- /dev/null +++ b/packages/panzer/adapters-stk/test/stk_connmngr/tTpetraLinearObjFactory.cpp @@ -0,0 +1,215 @@ +// @HEADER +// *********************************************************************** +// +// Panzer: A partial differential equation assembly +// engine for strongly coupled complex multiphysics systems +// Copyright (2011) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and +// Eric C. Cyr (eccyr@sandia.gov) +// *********************************************************************** +// @HEADER + +#include +#include +#include "Teuchos_DefaultComm.hpp" +#include "Teuchos_GlobalMPISession.hpp" +#include "Teuchos_ParameterList.hpp" + +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_STK_Version.hpp" +#include "PanzerAdaptersSTK_config.hpp" +#include "Panzer_IntrepidFieldPattern.hpp" +#include "Panzer_DOFManager.hpp" +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STKConnManager.hpp" +#include "Panzer_BlockedTpetraLinearObjFactory.hpp" +#include "Panzer_Traits.hpp" + +#include "Intrepid2_HGRAD_QUAD_C1_FEM.hpp" + +typedef Kokkos::DynRankView FieldContainer; +typedef panzer::BlockedTpetraLinearObjFactory BTLOF; + +using Teuchos::RCP; +using Teuchos::rcp; +using Teuchos::rcpFromRef; + +namespace panzer_stk +{ + + Teuchos::RCP buildQuadMesh(stk::ParallelMachine comm, int xelmts, int yelmts, int xblocks, int yblocks) + { + Teuchos::ParameterList pl; + pl.set("X Elements", xelmts); + pl.set("Y Elements", yelmts); + pl.set("X Blocks", xblocks); + pl.set("Y Blocks", yblocks); + + panzer_stk::SquareQuadMeshFactory meshFact; + meshFact.setParameterList(Teuchos::rcpFromRef(pl)); + + Teuchos::RCP mesh = meshFact.buildMesh(comm); + return Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); + } + + template + RCP buildFieldPattern() + { + // build a geometric pattern from a single basis + RCP> basis = rcp(new Intrepid2Type); + RCP pattern = rcp(new panzer::Intrepid2FieldPattern(basis)); + return pattern; + } + + // quad tests + TEUCHOS_UNIT_TEST(tTpetraLinearObjFactory, buildTest_quad) + { + +// build global (or serial communicator) +#ifdef HAVE_MPI + stk::ParallelMachine Comm = MPI_COMM_WORLD; +#else + stk::ParallelMachine Comm = WHAT_TO_DO_COMM; +#endif + + Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); + + int numProcs = stk::parallel_machine_size(Comm); + int myRank = stk::parallel_machine_rank(Comm); + + TEUCHOS_ASSERT(numProcs <= 2); + + // build a geometric pattern from a single basis + RCP patternC1 = buildFieldPattern>(); + + RCP connManager = buildQuadMesh(Comm, 2, 2, 1, 1); + RCP dofManager = rcp(new panzer::DOFManager()); + dofManager->setConnManager(connManager, MPI_COMM_WORLD); + dofManager->addField("u", patternC1); + dofManager->buildGlobalUnknowns(); + std::vector> providers{dofManager}; + + BTLOF laFactory(tComm.getConst(), providers); + auto map = laFactory.getMap(0); + auto gMap = laFactory.getGhostedMap(0); + auto graph = laFactory.getGraph(0, 0); + auto gGraph = laFactory.getGhostedGraph(0, 0); + + std::vector owned, ownedAndGhosted; + dofManager->getOwnedIndices(owned); + dofManager->getOwnedAndGhostedIndices(ownedAndGhosted); + + // test maps + { + TEST_EQUALITY(map->getLocalNumElements(), (int)owned.size()); + TEST_EQUALITY(gMap->getLocalNumElements(), (int)ownedAndGhosted.size()); + + // test indices + TEST_EQUALITY(owned[0], 0); + TEST_EQUALITY(ownedAndGhosted[0], 0); + for (std::size_t i = 1; i < owned.size(); i++) + TEST_ASSERT(map->getGlobalElement(owned[i])); + for (std::size_t i = 1; i < ownedAndGhosted.size(); i++) + TEST_ASSERT(gMap->getGlobalElement(ownedAndGhosted[i])); + } + + // test ograph + { + TEST_ASSERT(gGraph->isFillComplete()); + + TEST_EQUALITY(gGraph->getLocalNumRows(), (int)ownedAndGhosted.size()); + TEST_EQUALITY(gGraph->getLocalMaxNumRowEntries(), numProcs == 2 ? 6 : 9); + + BTLOF::CrsGraphType::nonconst_global_inds_host_view_type indicesView("indices", 10); + size_t numIndices; + + // Take degree of freedom in middle of mesh: Then look at ghosted graph + gGraph->getGlobalRowCopy(map->getGlobalElement(3), indicesView, numIndices); + + std::vector indices; + for (int i = 0; i < numIndices; i++) + { + indices.push_back(indicesView(i)); + } + + indices.resize(numIndices); + std::sort(indices.begin(), indices.end()); + if (numProcs == 2 && myRank == 0) + { + TEST_EQUALITY(numIndices, 6); + + std::vector compare(6); + compare[0] = 0; + compare[1] = 1; + compare[2] = 2; + compare[3] = 3; + compare[4] = 4; + compare[5] = 5; + + TEST_EQUALITY(compare.size(), indices.size()); + for (int i = 0; i < numIndices; i++) + { + TEST_EQUALITY(compare[i], indices[i]); + } + } + else if (numProcs == 2 && myRank == 1) + { + TEST_EQUALITY(numIndices, 6); + + std::vector compare(6); + compare[0] = 1; + compare[1] = 3; + compare[2] = 5; + compare[3] = 6; + compare[4] = 7; + compare[5] = 8; + + TEST_EQUALITY(compare.size(), indices.size()); + for (int i = 0; i < numIndices; i++) + { + TEST_EQUALITY(compare[i], indices[i]); + } + } + } + + // test graph + { + TEST_ASSERT(graph->isFillComplete()); + + TEST_EQUALITY(graph->getLocalNumRows(), (int)owned.size()); + TEST_EQUALITY(graph->getLocalMaxNumRowEntries(), myRank == 0 ? 9 : 6); + } + } + +} diff --git a/packages/panzer/adapters-stk/test/stk_interface_test/CMakeLists.txt b/packages/panzer/adapters-stk/test/stk_interface_test/CMakeLists.txt index 897aad0c239e..66d81d8b8f53 100644 --- a/packages/panzer/adapters-stk/test/stk_interface_test/CMakeLists.txt +++ b/packages/panzer/adapters-stk/test/stk_interface_test/CMakeLists.txt @@ -146,6 +146,12 @@ IF (PANZER_HAVE_EPETRA_STACK) SOURCES tScatterSpeed_Epetra.cpp ) ENDIF() +# Disabled until further guidance +# TRIBITS_ADD_EXECUTABLE( +# ScatterSpeed_Tpetra +# SOURCES tScatterSpeed_Tpetra.cpp +# ) + #TRIBITS_ADD_EXECUTABLE_AND_TEST( # tUniformRef # SOURCES tUniformRef.cpp ${UNIT_TEST_DRIVER} diff --git a/packages/panzer/adapters-stk/test/stk_interface_test/tScatterSpeed_Tpetra.cpp b/packages/panzer/adapters-stk/test/stk_interface_test/tScatterSpeed_Tpetra.cpp new file mode 100644 index 000000000000..6ce06dc087c4 --- /dev/null +++ b/packages/panzer/adapters-stk/test/stk_interface_test/tScatterSpeed_Tpetra.cpp @@ -0,0 +1,231 @@ +// STL includes +#include +#include +#include + +// Teuchos includes +#include "Teuchos_GlobalMPISession.hpp" +#include "Teuchos_RCP.hpp" +#include "Teuchos_ParameterList.hpp" +#include "Teuchos_FancyOStream.hpp" +#include "Teuchos_TimeMonitor.hpp" +#include +#include + +// Intrepid2 includes +#include "Intrepid2_HGRAD_QUAD_C1_FEM.hpp" +#include "Intrepid2_HGRAD_QUAD_C2_FEM.hpp" +#include "Intrepid2_HGRAD_HEX_C1_FEM.hpp" +#include "Intrepid2_HGRAD_HEX_C2_FEM.hpp" + +// Panzer includes +#include "Panzer_ConnManager.hpp" +#include "Panzer_FieldPattern.hpp" +#include "Panzer_IntrepidFieldPattern.hpp" +#include "Panzer_DOFManager.hpp" + +// Panzer_STK includes +#include "Panzer_STK_SquareQuadMeshFactory.hpp" +#include "Panzer_STK_CubeHexMeshFactory.hpp" +#include "Panzer_STKConnManager.hpp" + +// Tpetra includes +#include "Tpetra_Map.hpp" +#include "Tpetra_CrsGraph.hpp" +#include "Tpetra_CrsMatrix.hpp" + +using Teuchos::Array; +using Teuchos::ArrayRCP; +using Teuchos::ArrayView; +using Teuchos::RCP; +using Teuchos::rcp; +using Teuchos::Time; +using Teuchos::TimeMonitor; + +typedef double Scalar; +typedef Kokkos::DynRankView FieldContainer; +typedef Tpetra::Map Map; +typedef Tpetra::CrsMatrix CrsMatrix; +typedef Tpetra::CrsGraph CrsGraph; + +//****************************Function Definitions****************************** +void newAssembly(Teuchos::FancyOStream &out); +// Will run the generic setup of the DOFManager through the buildGlobalUnknowns +size_t setUp1(RCP &rowmap, + RCP &colmap, + RCP &my_dofM, + RCP &conn); + +// I'm not entirely sure on this yet. +void fillMeUp1(std::vector> &gids, + std::vector> &lids, + std::vector>> &miniMat, + RCP &dofM, + const std::vector &mElem, + const RCP &mcmap); +RCP