// @HEADER // ***************************************************************************** // Panzer: A partial differential equation assembly // engine for strongly coupled complex multiphysics systems // // Copyright 2011 NTESS and the Panzer contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @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_DOFManager.hpp" #include "Panzer_TpetraLinearObjFactory.hpp" #include "Panzer_PureBasis.hpp" #include "Panzer_BasisIRLayout.hpp" #include "Panzer_Workset.hpp" #include "Panzer_GatherOrientation.hpp" #include "Panzer_ScatterResidual_Tpetra.hpp" #include "Panzer_GatherSolution_Tpetra.hpp" #include "Panzer_GlobalEvaluationDataContainer.hpp" #include "Panzer_LOCPair_GlobalEvaluationData.hpp" #include "Panzer_ParameterList_GlobalEvaluationData.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_STKConnManager.hpp" #include "Teuchos_DefaultMpiComm.hpp" #include "Teuchos_OpaqueWrapper.hpp" #include "Thyra_VectorStdOps.hpp" #include "Thyra_VectorBase.hpp" #include "Thyra_SpmdVectorBase.hpp" #include "user_app_EquationSetFactory.hpp" #include // for get char #include #include #include "Panzer_Evaluator_WithBaseImpl.hpp" namespace panzer { typedef Teuchos::ArrayRCP::size_type size_type; using TpetraLinObjFactoryType = panzer::TpetraLinearObjFactory; using TpetraLinObjContainerType = panzer::TpetraLinearObjContainer; Teuchos::RCP buildBasis(std::size_t worksetSize, const std::string &basisName); void testInitialization(const Teuchos::RCP &ipb); Teuchos::RCP buildMesh(int elemX, int elemY); TEUCHOS_UNIT_TEST(assembly, scatter_solution_residual) { #ifdef HAVE_MPI Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); #else NOPE_PANZER_DOESNT_SUPPORT_SERIAL #endif int myRank = tComm->getRank(); const std::size_t workset_size = 4; const std::string fieldName1_q1 = "U"; const std::string fieldName2_q1 = "V"; const std::string fieldName_qedge1 = "B"; Teuchos::RCP mesh = buildMesh(2, 2); // build input physics block Teuchos::RCP basis_q1 = buildBasis(workset_size, "Q1"); Teuchos::RCP basis_qedge1 = buildBasis(workset_size, "QEdge1"); Teuchos::RCP ipb = Teuchos::parameterList(); testInitialization(ipb); const int default_int_order = 1; std::string eBlockID = "eblock-0_0"; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0")); Teuchos::RCP gd = panzer::createGlobalData(); Teuchos::RCP physicsBlock = Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false)); Teuchos::RCP> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(), physicsBlock->getWorksetNeeds()); TEST_EQUALITY(work_sets->size(), 1); // build connection manager and field manager const Teuchos::RCP conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); RCP dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD)); dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis()))); std::vector fieldOrder; fieldOrder.push_back(fieldName1_q1); fieldOrder.push_back(fieldName_qedge1); fieldOrder.push_back(fieldName2_q1); dofManager->setFieldOrder(fieldOrder); dofManager->buildGlobalUnknowns(); // setup linear object factory ///////////////////////////////////////////////////////////// Teuchos::RCP t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager)); Teuchos::RCP> lof = t_lof; Teuchos::RCP loc = t_lof->buildGhostedLinearObjContainer(); t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc); loc->initialize(); Teuchos::RCP t_loc = Teuchos::rcp_dynamic_cast(loc); Teuchos::RCP> x_vec = t_loc->get_x_th(); Thyra::assign(x_vec.ptr(), 123.0 + myRank); // setup field manager, add evaluator under test ///////////////////////////////////////////////////////////// PHX::FieldManager fm; std::string resName = ""; Teuchos::RCP> names_map = Teuchos::rcp(new std::map); names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1)); names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1)); names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1)); // evaluators under test { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName1_q1); names->push_back(resName + fieldName2_q1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQ1"); pl.set("Basis", basis_q1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm.registerEvaluator(evaluator); fm.requireField(*evaluator->evaluatedFields()[0]); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQEdge1"); pl.set("Basis", basis_qedge1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm.registerEvaluator(evaluator); fm.requireField(*evaluator->evaluatedFields()[0]); } // support evaluators { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName1_q1); names->push_back(fieldName2_q1); Teuchos::ParameterList pl; pl.set("Basis", basis_q1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm.registerEvaluator(evaluator); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Basis", basis_qedge1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm.registerEvaluator(evaluator); } panzer::Traits::SD sd; sd.worksets_ = work_sets; fm.postRegistrationSetup(sd); panzer::Traits::PED ped; ped.gedc->addDataObject("Solution Gather Container", loc); ped.gedc->addDataObject("Residual Scatter Container", loc); fm.preEvaluate(ped); // run tests ///////////////////////////////////////////////////////////// panzer::Workset &workset = (*work_sets)[0]; workset.alpha = 0.0; workset.beta = 2.0; // derivatives multiplied by 2 workset.time = 0.0; workset.evaluate_transient_terms = false; fm.evaluateFields(workset); fm.postEvaluate(0); // test Residual fields Teuchos::ArrayRCP data; Teuchos::RCP> f_vec = t_loc->get_f_th(); // check all the residual values. This is kind of crappy test since it simply checks twice the target // value and the target. Its this way because you add two entries across elements. Teuchos::rcp_dynamic_cast>(f_vec)->getLocalData(Teuchos::ptrFromRef(data)); for (size_type i = 0; i < data.size(); i++) { double target = 123.0 + myRank; TEST_ASSERT(data[i] == target || data[i] == 2.0 * target); } } TEUCHOS_UNIT_TEST(assembly, scatter_solution_jacobian) { // TODO BWR not checking the jacobian calculation, just the residual part!!! #ifdef HAVE_MPI Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); #else NOPE_PANZER_DOESNT_SUPPORT_SERIAL #endif int myRank = tComm->getRank(); const std::size_t workset_size = 4; const std::string fieldName1_q1 = "U"; const std::string fieldName2_q1 = "V"; const std::string fieldName_qedge1 = "B"; Teuchos::RCP mesh = buildMesh(2, 2); // build input physics block Teuchos::RCP basis_q1 = buildBasis(workset_size, "Q1"); Teuchos::RCP basis_qedge1 = buildBasis(workset_size, "QEdge1"); Teuchos::RCP ipb = Teuchos::parameterList(); testInitialization(ipb); const int default_int_order = 1; std::string eBlockID = "eblock-0_0"; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0")); Teuchos::RCP gd = panzer::createGlobalData(); Teuchos::RCP physicsBlock = Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false)); Teuchos::RCP> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(), physicsBlock->getWorksetNeeds()); TEST_EQUALITY(work_sets->size(), 1); // build connection manager and field manager const Teuchos::RCP conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); RCP dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD)); dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis()))); std::vector fieldOrder; fieldOrder.push_back(fieldName1_q1); fieldOrder.push_back(fieldName_qedge1); fieldOrder.push_back(fieldName2_q1); dofManager->setFieldOrder(fieldOrder); dofManager->buildGlobalUnknowns(); // setup linear object factory ///////////////////////////////////////////////////////////// Teuchos::RCP t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager)); Teuchos::RCP> lof = t_lof; Teuchos::RCP loc = t_lof->buildGhostedLinearObjContainer(); t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc); loc->initialize(); Teuchos::RCP t_loc = Teuchos::rcp_dynamic_cast(loc); Teuchos::RCP> x_vec = t_loc->get_x_th(); Thyra::assign(x_vec.ptr(), 123.0 + myRank); // setup field manager, add evaluator under test ///////////////////////////////////////////////////////////// PHX::FieldManager fm; std::vector derivative_dimensions; derivative_dimensions.push_back(12); fm.setKokkosExtendedDataTypeDimensions(derivative_dimensions); std::string resName = ""; Teuchos::RCP> names_map = Teuchos::rcp(new std::map); names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1)); names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1)); names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1)); // evaluators under test { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName1_q1); names->push_back(resName + fieldName2_q1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQ1"); pl.set("Basis", basis_q1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm.registerEvaluator(evaluator); fm.requireField(*evaluator->evaluatedFields()[0]); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQEdge1"); pl.set("Basis", basis_qedge1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm.registerEvaluator(evaluator); fm.requireField(*evaluator->evaluatedFields()[0]); } // support evaluators { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName1_q1); names->push_back(fieldName2_q1); Teuchos::ParameterList pl; pl.set("Basis", basis_q1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm.registerEvaluator(evaluator); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Basis", basis_qedge1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm.registerEvaluator(evaluator); } panzer::Traits::SD sd; sd.worksets_ = work_sets; fm.postRegistrationSetup(sd); panzer::Traits::PED ped; ped.gedc->addDataObject("Solution Gather Container", loc); ped.gedc->addDataObject("Residual Scatter Container", loc); fm.preEvaluate(ped); // run tests ///////////////////////////////////////////////////////////// panzer::Workset &workset = (*work_sets)[0]; workset.alpha = 0.0; workset.beta = 2.0; // derivatives multiplied by 2 workset.time = 0.0; workset.evaluate_transient_terms = false; fm.evaluateFields(workset); fm.postEvaluate(0); // test Jacobian fields Teuchos::ArrayRCP data; Teuchos::RCP> f_vec = t_loc->get_f_th(); // check all the residual values. This is kind of crappy test since it simply checks twice the target // value and the target. Its this way because you add two entries across elements. Teuchos::rcp_dynamic_cast>(f_vec)->getLocalData(Teuchos::ptrFromRef(data)); for (size_type i = 0; i < data.size(); i++) { double target = 123.0 + myRank; TEST_ASSERT(data[i] == target || data[i] == 2.0 * target); } } TEUCHOS_UNIT_TEST(assembly, scatter_solution_tangent) { #ifdef HAVE_MPI Teuchos::RCP> tComm = Teuchos::rcp(new Teuchos::MpiComm(MPI_COMM_WORLD)); #else NOPE_PANZER_DOESNT_SUPPORT_SERIAL #endif int myRank = tComm->getRank(); const std::size_t workset_size = 4; const std::string fieldName1_q1 = "U"; const std::string fieldName2_q1 = "V"; const std::string fieldName_qedge1 = "B"; const std::size_t numParams = 3; Teuchos::RCP mesh = buildMesh(2, 2); // build input physics block Teuchos::RCP basis_q1 = buildBasis(workset_size, "Q1"); Teuchos::RCP basis_qedge1 = buildBasis(workset_size, "QEdge1"); Teuchos::RCP ipb = Teuchos::parameterList(); testInitialization(ipb); const int default_int_order = 1; std::string eBlockID = "eblock-0_0"; Teuchos::RCP eqset_factory = Teuchos::rcp(new user_app::MyFactory); panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0")); Teuchos::RCP gd = panzer::createGlobalData(); Teuchos::RCP physicsBlock = Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false)); Teuchos::RCP> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(), physicsBlock->getWorksetNeeds()); TEST_EQUALITY(work_sets->size(), 1); // build connection manager and field manager const Teuchos::RCP conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); RCP dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD)); dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis()))); dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis()))); std::vector fieldOrder; fieldOrder.push_back(fieldName1_q1); fieldOrder.push_back(fieldName_qedge1); fieldOrder.push_back(fieldName2_q1); dofManager->setFieldOrder(fieldOrder); dofManager->buildGlobalUnknowns(); // setup linear object factory ///////////////////////////////////////////////////////////// Teuchos::RCP t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager)); Teuchos::RCP> lof = t_lof; Teuchos::RCP loc = t_lof->buildGhostedLinearObjContainer(); t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F , *loc); loc->initialize(); Teuchos::RCP t_loc = Teuchos::rcp_dynamic_cast(loc); Teuchos::RCP> x_vec = t_loc->get_x_th(); Thyra::assign(x_vec.ptr(), 123.0 + myRank); std::vector> tangentContainers; using LOCPair = panzer::LOCPair_GlobalEvaluationData; using Teuchos::rcp_dynamic_cast; // generate tangent data for (std::size_t i=0;i(locPair->getGlobalLOC()); Teuchos::RCP> global_x_vec = global_t_loc->get_x_th(); Thyra::assign(global_x_vec.ptr(), 0.123 + myRank + i); auto ghosted_t_loc = rcp_dynamic_cast(locPair->getGhostedLOC()); Teuchos::RCP> ghosted_x_vec = ghosted_t_loc->get_x_th(); Thyra::assign(ghosted_x_vec.ptr(), 0.123 + myRank + i); tangentContainers.push_back(locPair); } // setup field manager, add evaluator under test ///////////////////////////////////////////////////////////// auto fm = Teuchos::rcp(new PHX::FieldManager); std::vector derivative_dimensions; derivative_dimensions.push_back(numParams); fm->setKokkosExtendedDataTypeDimensions(derivative_dimensions); std::string resName = ""; Teuchos::RCP> names_map = Teuchos::rcp(new std::map); names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1)); names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1)); names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1)); // Guide to what's happening in this test // 1) U,V,B gathers request tangent fields so those are first gathered with gatherTangent // 2) When U,V,B gathers occur, the tangents are stored as derivatives. The first tangent is the first derivative and so on. // 3) U,V,B are overloaded to also be the residual fields we are scattering // 4) This means their derivatives, e.g., U.dx(i) are considered to be dfdp_i -> derivatives of the residuals w.r.t. parameters. // 5) dfdp_i = f.dx(i) so the number of tangents is the number of params // evaluators under test { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName1_q1); names->push_back(resName + fieldName2_q1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQ1"); pl.set("Basis", basis_q1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm->registerEvaluator(evaluator); fm->requireField(*evaluator->evaluatedFields()[0]); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(resName + fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Scatter Name", "ScatterQEdge1"); pl.set("Basis", basis_qedge1.getConst()); pl.set("Dependent Names", names); pl.set("Dependent Map", names_map); Teuchos::RCP> evaluator = lof->buildScatter(pl); TEST_EQUALITY(evaluator->evaluatedFields().size(), 1); fm->registerEvaluator(evaluator); fm->requireField(*evaluator->evaluatedFields()[0]); } // support evaluators { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName1_q1); names->push_back(fieldName2_q1); Teuchos::ParameterList pl; pl.set("Basis", basis_q1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP>> tangent_names = Teuchos::rcp(new std::vector>(2)); for (std::size_t i = 0; i < numParams; ++i) { std::stringstream ss1, ss2; ss1 << fieldName1_q1 << " Tangent " << i; ss2 << fieldName2_q1 << " Tangent " << i; (*tangent_names)[0].push_back(ss1.str()); (*tangent_names)[1].push_back(ss2.str()); } pl.set("Tangent Names", tangent_names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm->registerEvaluator(evaluator); } for (std::size_t i = 0; i < numParams; ++i) { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); RCP> tangent_names = rcp(new std::vector); names->push_back(fieldName1_q1); names->push_back(fieldName2_q1); { std::stringstream ss1, ss2; ss1 << fieldName1_q1 << " Tangent " << i; ss2 << fieldName2_q1 << " Tangent " << i; tangent_names->push_back(ss1.str()); tangent_names->push_back(ss2.str()); } Teuchos::ParameterList pl; pl.set("Basis", basis_q1); pl.set("DOF Names", tangent_names); pl.set("Indexer Names", names); std::stringstream ss; ss << "Tangent Container " << i; pl.set("Global Data Key", ss.str()); Teuchos::RCP> evaluator = lof->buildGatherTangent(pl); fm->registerEvaluator(evaluator); } { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); names->push_back(fieldName_qedge1); Teuchos::ParameterList pl; pl.set("Basis", basis_qedge1); pl.set("DOF Names", names); pl.set("Indexer Names", names); Teuchos::RCP>> tangent_names = Teuchos::rcp(new std::vector>(1)); for (std::size_t i = 0; i < numParams; ++i) { std::stringstream ss; ss << fieldName_qedge1 << " Tangent " << i; (*tangent_names)[0].push_back(ss.str()); } pl.set("Tangent Names", tangent_names); Teuchos::RCP> evaluator = lof->buildGather(pl); fm->registerEvaluator(evaluator); } for (std::size_t i = 0; i < numParams; ++i) { using Teuchos::RCP; using Teuchos::rcp; RCP> names = rcp(new std::vector); RCP> tangent_names = rcp(new std::vector); names->push_back(fieldName_qedge1); { std::stringstream ss; ss << fieldName_qedge1 << " Tangent " << i; tangent_names->push_back(ss.str()); } Teuchos::ParameterList pl; pl.set("Basis", basis_qedge1); pl.set("DOF Names", tangent_names); pl.set("Indexer Names", names); std::stringstream ss; ss << "Tangent Container " << i; pl.set("Global Data Key", ss.str()); Teuchos::RCP> evaluator = lof->buildGatherTangent(pl); fm->registerEvaluator(evaluator); } panzer::Traits::SD sd; sd.worksets_ = work_sets; fm->postRegistrationSetup(sd); panzer::Traits::PED ped; ped.gedc->addDataObject("Solution Gather Container", loc); ped.gedc->addDataObject("Residual Scatter Container", loc); for (size_t i=0; iaddDataObject(ss.str(), tangentContainers[i]); } std::vector params; std::vector> paramContainers; for (std::size_t i = 0; iaddDataObject(ss.str(),paramContainer->getGhostedLOC()); paramContainers.push_back(paramContainer); } Teuchos::RCP activeParams = Teuchos::rcp(new panzer::ParameterList_GlobalEvaluationData(params)); ped.gedc->addDataObject("PARAMETER_NAMES",activeParams); fm->preEvaluate(ped); // run tests ///////////////////////////////////////////////////////////// panzer::Workset &workset = (*work_sets)[0]; workset.alpha = 0.0; workset.beta = 2.0; // derivatives multiplied by 2 workset.time = 0.0; workset.evaluate_transient_terms = false; fm->evaluateFields(workset); fm->postEvaluate(0); fm = Teuchos::null; // test Tangent fields { Teuchos::ArrayRCP data; Teuchos::RCP> f_vec = t_loc->get_f_th(); // check all the residual values. This is kind of crappy test since it simply checks twice the target // value and the target. Its this way because you add two entries across elements. Teuchos::rcp_dynamic_cast>(f_vec)->getLocalData(Teuchos::ptrFromRef(data)); for (size_type i = 0; i < data.size(); i++) { double target = 123.0 + myRank; TEST_ASSERT(data[i] == target || data[i] == 2.0 * target); } } for (std::size_t i=0; i data; Teuchos::RCP> f_vec = Teuchos::rcp_dynamic_cast(paramContainers[i]->getGhostedLOC())->get_f_th(); Teuchos::rcp_dynamic_cast>(f_vec)->getLocalData(Teuchos::ptrFromRef(data)); for (size_type j = 0; j < data.size(); ++j) { const double target = .123 + myRank + i; TEST_ASSERT(data[j] == target || data[j] == 2.0 * target); } } } Teuchos::RCP buildBasis(std::size_t worksetSize, const std::string &basisName) { Teuchos::RCP topo = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData>())); panzer::CellData cellData(worksetSize, topo); return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData)); } Teuchos::RCP buildMesh(int elemX, int elemY) { RCP pl = rcp(new Teuchos::ParameterList); pl->set("X Blocks", 1); 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); factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD); return mesh; } void testInitialization(const Teuchos::RCP &ipb) { // Physics block ipb->setName("test physics"); { Teuchos::ParameterList &p = ipb->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 = ipb->sublist("b"); p.set("Type", "Energy"); p.set("Prefix", "ION_"); p.set("Model ID", "solid"); p.set("Basis Type", "HCurl"); p.set("Basis Order", 1); p.set("Integration Order", 1); } } }