diff --git a/packages/panzer/adapters-stk/test/evaluator_tests/CMakeLists.txt b/packages/panzer/adapters-stk/test/evaluator_tests/CMakeLists.txt
index d871d0375cb0..079cdad0848b 100644
--- a/packages/panzer/adapters-stk/test/evaluator_tests/CMakeLists.txt
+++ b/packages/panzer/adapters-stk/test/evaluator_tests/CMakeLists.txt
@@ -57,6 +57,13 @@ TRIBITS_ADD_EXECUTABLE_AND_TEST(
   NUM_MPI_PROCS 2
   )
 
+TRIBITS_ADD_EXECUTABLE_AND_TEST(
+  tScatterResidual_BlockedTpetra
+  SOURCES tpetra_blocked_scatter_residual.cpp ${UNIT_TEST_DRIVER}
+  COMM serial mpi
+  NUM_MPI_PROCS 2
+  )
+
 TRIBITS_ADD_EXECUTABLE_AND_TEST(
   tScatterDirichletResidual_Tpetra
   SOURCES tpetra_scatter_dirichlet_residual.cpp ${UNIT_TEST_DRIVER}
diff --git a/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_scatter_residual.cpp b/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_scatter_residual.cpp
new file mode 100644
index 000000000000..a5e3d75d2362
--- /dev/null
+++ b/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_scatter_residual.cpp
@@ -0,0 +1,546 @@
+// @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 <Teuchos_ConfigDefs.hpp>
+#include <Teuchos_UnitTestHarness.hpp>
+#include <Teuchos_RCP.hpp>
+#include <Teuchos_TimeMonitor.hpp>
+
+using Teuchos::RCP;
+using Teuchos::rcp;
+
+#include "Teuchos_DefaultComm.hpp"
+#include "Teuchos_GlobalMPISession.hpp"
+
+#include "Panzer_FieldManagerBuilder.hpp"
+#include "Panzer_BlockedDOFManager.hpp"
+#include "Panzer_BlockedTpetraLinearObjFactory.hpp"
+#include "Panzer_PureBasis.hpp"
+#include "Panzer_BasisIRLayout.hpp"
+#include "Panzer_Workset.hpp"
+#include "Panzer_GatherOrientation.hpp"
+#include "Panzer_ScatterResidual_BlockedTpetra.hpp"
+#include "Panzer_GatherSolution_BlockedTpetra.hpp"
+#include "Panzer_GlobalEvaluationDataContainer.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_ProductVectorBase.hpp"
+#include "Thyra_SpmdVectorBase.hpp"
+
+#include "user_app_EquationSetFactory.hpp"
+
+#include <cstdio> // for get char
+#include <vector>
+#include <string>
+
+#include "Panzer_Evaluator_WithBaseImpl.hpp"
+
+namespace panzer
+{
+   typedef Teuchos::ArrayRCP<const double>::size_type size_type;
+
+   using TpetraBlockedLinObjFactoryType = panzer::BlockedTpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
+   using TpetraBlockedLinObjContainerType = panzer::BlockedTpetraLinearObjContainer<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
+
+   Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName);
+   void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb);
+   Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY);
+
+   TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_residual)
+   {
+
+#ifdef HAVE_MPI
+      Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(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<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
+
+      // build input physics block
+      Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
+      Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
+
+      Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
+      testInitialization(ipb);
+
+      const int default_int_order = 1;
+      std::string eBlockID = "eblock-0_0";
+      Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
+      panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
+      Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
+      Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
+          Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
+
+      Teuchos::RCP<std::vector<panzer::Workset>> 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<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
+      RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(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<std::vector<std::string>> fieldOrder(3);
+      fieldOrder[0].push_back(fieldName1_q1);
+      fieldOrder[1].push_back(fieldName_qedge1);
+      fieldOrder[2].push_back(fieldName2_q1);
+      dofManager->setFieldOrder(fieldOrder);
+
+      // dofManager->setOrientationsRequired(true);
+      dofManager->buildGlobalUnknowns();
+
+      // setup linear object factory
+      /////////////////////////////////////////////////////////////
+      Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
+      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
+      Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
+      bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
+      loc->initialize();
+
+      Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
+
+      Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
+      Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
+      Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
+      Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
+
+      // setup field manager, add evaluator under test
+      /////////////////////////////////////////////////////////////
+
+      PHX::FieldManager<panzer::Traits> fm;
+
+      std::string resName = "";
+      Teuchos::RCP<std::map<std::string, std::string>> names_map =
+          Teuchos::rcp(new std::map<std::string, std::string>);
+      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<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
+         fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
+      }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
+         fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
+      }
+
+      // support evaluators
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
+
+         fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
+      }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
+
+         fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
+      }
+
+      std::vector<PHX::index_size_type> derivative_dimensions;
+      derivative_dimensions.push_back(12);
+      fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
+
+      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<panzer::Traits::Residual>(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<panzer::Traits::Residual>(workset);
+
+      // test Residual fields
+      Teuchos::ArrayRCP<const double> data;
+      Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
+
+      // 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<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
+      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::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
+      for (size_type i = 0; i < data.size(); i++)
+      {
+         double target = 456.0 + myRank;
+         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
+      }
+
+      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
+      for (size_type i = 0; i < data.size(); i++)
+      {
+         double target = 789.0 + myRank;
+         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
+      }
+   }
+
+   TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_jacobian)
+   {
+
+#ifdef HAVE_MPI
+      Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(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<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
+
+      // build input physics block
+      Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
+      Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
+
+      Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
+      testInitialization(ipb);
+
+      const int default_int_order = 1;
+      std::string eBlockID = "eblock-0_0";
+      Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
+      panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
+      Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
+      Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
+          Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
+
+      Teuchos::RCP<std::vector<panzer::Workset>> 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<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
+      RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(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<std::vector<std::string>> fieldOrder(3);
+      fieldOrder[0].push_back(fieldName1_q1);
+      fieldOrder[1].push_back(fieldName_qedge1);
+      fieldOrder[2].push_back(fieldName2_q1);
+      dofManager->setFieldOrder(fieldOrder);
+
+      // dofManager->setOrientationsRequired(true);
+      dofManager->buildGlobalUnknowns();
+
+      // setup linear object factory
+      /////////////////////////////////////////////////////////////
+
+      Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
+      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
+      Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
+      bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
+      loc->initialize();
+
+      Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
+
+      Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
+      Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
+      Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
+      Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
+
+      // setup field manager, add evaluator under test
+      /////////////////////////////////////////////////////////////
+
+      PHX::FieldManager<panzer::Traits> fm;
+
+      std::string resName = "";
+      Teuchos::RCP<std::map<std::string, std::string>> names_map =
+          Teuchos::rcp(new std::map<std::string, std::string>);
+      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<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
+         fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
+      }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
+         fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
+      }
+
+      // support evaluators
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
+
+         fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
+      }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
+
+         fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
+      }
+
+      std::vector<PHX::index_size_type> derivative_dimensions;
+      derivative_dimensions.push_back(12);
+      fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
+
+      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<panzer::Traits::Jacobian>(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<panzer::Traits::Jacobian>(workset);
+
+      // test Jacobian fields
+      Teuchos::ArrayRCP<const double> data;
+      Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
+
+      // 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<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
+      out << std::endl;
+      for (size_type i = 0; i < data.size(); i++)
+      {
+         double target = 123.0 + myRank;
+         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
+         out << data[i] << std::endl;
+      }
+
+      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
+      out << std::endl;
+      for (size_type i = 0; i < data.size(); i++)
+      {
+         double target = 456.0 + myRank;
+         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
+         out << data[i] << std::endl;
+      }
+
+      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
+      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
+      out << std::endl;
+      for (size_type i = 0; i < data.size(); i++)
+      {
+         double target = 789.0 + myRank;
+         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
+         out << data[i] << std::endl;
+      }
+   }
+
+   Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName)
+   {
+      Teuchos::RCP<shards::CellTopology> topo =
+          Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4>>()));
+
+      panzer::CellData cellData(worksetSize, topo);
+      return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData));
+   }
+
+   Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY)
+   {
+      RCP<Teuchos::ParameterList> 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<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
+      factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD);
+
+      return mesh;
+   }
+
+   void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &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);
+      }
+   }
+
+}
diff --git a/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_scatter_residual.cpp b/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_scatter_residual.cpp
index a5e3d75d2362..1e86353a14bc 100644
--- a/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_scatter_residual.cpp
+++ b/packages/panzer/adapters-stk/test/evaluator_tests/tpetra_scatter_residual.cpp
@@ -20,15 +20,17 @@ using Teuchos::rcp;
 #include "Teuchos_GlobalMPISession.hpp"
 
 #include "Panzer_FieldManagerBuilder.hpp"
-#include "Panzer_BlockedDOFManager.hpp"
-#include "Panzer_BlockedTpetraLinearObjFactory.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_BlockedTpetra.hpp"
-#include "Panzer_GatherSolution_BlockedTpetra.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"
@@ -41,7 +43,7 @@ using Teuchos::rcp;
 #include "Teuchos_OpaqueWrapper.hpp"
 
 #include "Thyra_VectorStdOps.hpp"
-#include "Thyra_ProductVectorBase.hpp"
+#include "Thyra_VectorBase.hpp"
 #include "Thyra_SpmdVectorBase.hpp"
 
 #include "user_app_EquationSetFactory.hpp"
@@ -56,14 +58,14 @@ namespace panzer
 {
    typedef Teuchos::ArrayRCP<const double>::size_type size_type;
 
-   using TpetraBlockedLinObjFactoryType = panzer::BlockedTpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
-   using TpetraBlockedLinObjContainerType = panzer::BlockedTpetraLinearObjContainer<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
+   using TpetraLinObjFactoryType = panzer::TpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
+   using TpetraLinObjContainerType = panzer::TpetraLinearObjContainer<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
 
    Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName);
    void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb);
    Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY);
 
-   TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_residual)
+   TEUCHOS_UNIT_TEST(assembly, scatter_solution_residual)
    {
 
 #ifdef HAVE_MPI
@@ -102,35 +104,32 @@ namespace panzer
 
       // build connection manager and field manager
       const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
-      RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
+      RCP<panzer::DOFManager> 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<std::vector<std::string>> fieldOrder(3);
-      fieldOrder[0].push_back(fieldName1_q1);
-      fieldOrder[1].push_back(fieldName_qedge1);
-      fieldOrder[2].push_back(fieldName2_q1);
+      std::vector<std::string> fieldOrder;
+      fieldOrder.push_back(fieldName1_q1);
+      fieldOrder.push_back(fieldName_qedge1);
+      fieldOrder.push_back(fieldName2_q1);
       dofManager->setFieldOrder(fieldOrder);
 
-      // dofManager->setOrientationsRequired(true);
       dofManager->buildGlobalUnknowns();
 
       // setup linear object factory
       /////////////////////////////////////////////////////////////
-      Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
-      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
-      Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
-      bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
+      Teuchos::RCP<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
+      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
+      Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
+      t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
       loc->initialize();
 
-      Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
+      Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
 
-      Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
-      Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
-      Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
-      Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
+      Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
+      Thyra::assign(x_vec.ptr(), 123.0 + myRank);
 
       // setup field manager, add evaluator under test
       /////////////////////////////////////////////////////////////
@@ -218,10 +217,6 @@ namespace panzer
          fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
       }
 
-      std::vector<PHX::index_size_type> derivative_dimensions;
-      derivative_dimensions.push_back(12);
-      fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
-
       panzer::Traits::SD sd;
       sd.worksets_ = work_sets;
 
@@ -242,41 +237,27 @@ namespace panzer
       workset.evaluate_transient_terms = false;
 
       fm.evaluateFields<panzer::Traits::Residual>(workset);
+      fm.postEvaluate<panzer::Traits::Residual>(0);
 
       // test Residual fields
       Teuchos::ArrayRCP<const double> data;
-      Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
+      Teuchos::RCP<const Thyra::VectorBase<double>> 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<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
+      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(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::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
-      for (size_type i = 0; i < data.size(); i++)
-      {
-         double target = 456.0 + myRank;
-         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
-      }
-
-      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
-      for (size_type i = 0; i < data.size(); i++)
-      {
-         double target = 789.0 + myRank;
-         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
-      }
    }
 
-   TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_jacobian)
+ TEUCHOS_UNIT_TEST(assembly, scatter_solution_jacobian)
    {
+      // TODO BWR not checking the jacobian calculation, just the residual part!!!
 
 #ifdef HAVE_MPI
       Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
@@ -314,42 +295,42 @@ namespace panzer
 
       // build connection manager and field manager
       const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
-      RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
+      RCP<panzer::DOFManager> 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<std::vector<std::string>> fieldOrder(3);
-      fieldOrder[0].push_back(fieldName1_q1);
-      fieldOrder[1].push_back(fieldName_qedge1);
-      fieldOrder[2].push_back(fieldName2_q1);
+      std::vector<std::string> fieldOrder;
+      fieldOrder.push_back(fieldName1_q1);
+      fieldOrder.push_back(fieldName_qedge1);
+      fieldOrder.push_back(fieldName2_q1);
       dofManager->setFieldOrder(fieldOrder);
 
-      // dofManager->setOrientationsRequired(true);
       dofManager->buildGlobalUnknowns();
 
       // setup linear object factory
       /////////////////////////////////////////////////////////////
-
-      Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
-      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
-      Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
-      bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
+      Teuchos::RCP<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
+      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
+      Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
+      t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
       loc->initialize();
 
-      Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
+      Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
 
-      Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
-      Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
-      Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
-      Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
+      Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
+      Thyra::assign(x_vec.ptr(), 123.0 + myRank);
 
       // setup field manager, add evaluator under test
       /////////////////////////////////////////////////////////////
 
       PHX::FieldManager<panzer::Traits> fm;
 
+      std::vector<PHX::index_size_type> derivative_dimensions;
+      derivative_dimensions.push_back(12);
+      fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
+
       std::string resName = "";
       Teuchos::RCP<std::map<std::string, std::string>> names_map =
           Teuchos::rcp(new std::map<std::string, std::string>);
@@ -431,10 +412,6 @@ namespace panzer
          fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
       }
 
-      std::vector<PHX::index_size_type> derivative_dimensions;
-      derivative_dimensions.push_back(12);
-      fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
-
       panzer::Traits::SD sd;
       sd.worksets_ = work_sets;
 
@@ -455,42 +432,351 @@ namespace panzer
       workset.evaluate_transient_terms = false;
 
       fm.evaluateFields<panzer::Traits::Jacobian>(workset);
+      fm.postEvaluate<panzer::Traits::Jacobian>(0);
 
       // test Jacobian fields
       Teuchos::ArrayRCP<const double> data;
-      Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
+      Teuchos::RCP<const Thyra::VectorBase<double>> 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<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
-      out << std::endl;
+      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(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);
-         out << data[i] << std::endl;
       }
 
-      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
-      out << std::endl;
-      for (size_type i = 0; i < data.size(); i++)
+   }
+
+ TEUCHOS_UNIT_TEST(assembly, scatter_solution_tangent)
+   {
+
+#ifdef HAVE_MPI
+      Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(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<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
+
+      // build input physics block
+      Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
+      Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
+
+      Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
+      testInitialization(ipb);
+
+      const int default_int_order = 1;
+      std::string eBlockID = "eblock-0_0";
+      Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
+      panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
+      Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
+      Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
+          Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
+
+      Teuchos::RCP<std::vector<panzer::Workset>> 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<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
+      RCP<panzer::DOFManager> 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<std::string> 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<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
+      Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
+      Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
+      t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F , *loc);
+      loc->initialize();
+
+      Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
+      Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
+      Thyra::assign(x_vec.ptr(), 123.0 + myRank);
+
+      std::vector<Teuchos::RCP<GlobalEvaluationData>> tangentContainers;
+
+      using LOCPair = panzer::LOCPair_GlobalEvaluationData;
+      using Teuchos::rcp_dynamic_cast;
+
+      // generate tangent data
+      for (std::size_t i=0;i<numParams; ++i){
+         auto locPair = Teuchos::rcp(new LOCPair(t_lof, panzer::LinearObjContainer::X));
+
+         auto global_t_loc = rcp_dynamic_cast<TpetraLinObjContainerType>(locPair->getGlobalLOC());
+         Teuchos::RCP<Thyra::VectorBase<double>> 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<TpetraLinObjContainerType>(locPair->getGhostedLOC());
+         Teuchos::RCP<Thyra::VectorBase<double>> 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<panzer::Traits>);
+
+      std::vector<PHX::index_size_type> derivative_dimensions;
+      derivative_dimensions.push_back(numParams);
+      fm->setKokkosExtendedDataTypeDimensions<panzer::Traits::Tangent>(derivative_dimensions);
+
+      std::string resName = "";
+      Teuchos::RCP<std::map<std::string, std::string>> names_map =
+          Teuchos::rcp(new std::map<std::string, std::string>);
+      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
       {
-         double target = 456.0 + myRank;
-         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
-         out << data[i] << std::endl;
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
+         fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
       }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         names->push_back(resName + fieldName_qedge1);
 
-      Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
-      TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
-      out << std::endl;
-      for (size_type i = 0; i < data.size(); i++)
+         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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
+
+         TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
+
+         fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
+         fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
+      }
+
+      // support evaluators
       {
-         double target = 789.0 + myRank;
-         TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
-         out << data[i] << std::endl;
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<std::vector<std::vector<std::string>>> tangent_names = 
+            Teuchos::rcp(new std::vector<std::vector<std::string>>(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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
+
+         fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
+      }
+      for (std::size_t i = 0; i < numParams; ++i) {
+        using Teuchos::RCP;
+        using Teuchos::rcp;
+        RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+        RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
+        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<PHX::Evaluator<panzer::Traits>> evaluator =
+            lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
+
+        fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
+      }
+      {
+         using Teuchos::RCP;
+         using Teuchos::rcp;
+         RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+         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<std::vector<std::vector<std::string>>> tangent_names = 
+            Teuchos::rcp(new std::vector<std::vector<std::string>>(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<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
+
+         fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
+      }
+      for (std::size_t i = 0; i < numParams; ++i) {
+        using Teuchos::RCP;
+        using Teuchos::rcp;
+        RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
+        RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
+        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<PHX::Evaluator<panzer::Traits>> evaluator =
+            lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
+
+        fm->registerEvaluator<panzer::Traits::Tangent>(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; i<numParams; ++i) {
+         std::stringstream ss;
+         ss << "Tangent Container " << i;
+         ped.gedc->addDataObject(ss.str(), tangentContainers[i]);
+      }
+      std::vector<std::string> params;
+      std::vector<Teuchos::RCP<LOCPair>> paramContainers;
+      for (std::size_t i = 0; i<numParams; ++i) {
+         std::stringstream ss;
+         ss << "param" << i;
+         params.push_back(ss.str());
+         auto paramContainer = Teuchos::rcp(new LOCPair(t_lof, panzer::LinearObjContainer::X | panzer::LinearObjContainer::F));
+         ped.gedc->addDataObject(ss.str(),paramContainer->getGhostedLOC());
+         paramContainers.push_back(paramContainer);
+      }
+      Teuchos::RCP<panzer::GlobalEvaluationData> activeParams =
+         Teuchos::rcp(new panzer::ParameterList_GlobalEvaluationData(params));
+      ped.gedc->addDataObject("PARAMETER_NAMES",activeParams);
+
+      fm->preEvaluate<panzer::Traits::Tangent>(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<panzer::Traits::Tangent>(workset);
+      fm->postEvaluate<panzer::Traits::Tangent>(0);
+
+      fm = Teuchos::null;
+
+      // test Tangent fields
+      {
+         Teuchos::ArrayRCP<const double> data;
+         Teuchos::RCP<const Thyra::VectorBase<double>> 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<const Thyra::SpmdVectorBase<double>>(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<numParams; ++i)
+      {
+         // now check the tangent values
+         Teuchos::ArrayRCP<const double> data;
+         Teuchos::RCP<const Thyra::VectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(paramContainers[i]->getGhostedLOC())->get_f_th();
+         Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(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);
+         }
       }
    }
 
diff --git a/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_BlockedTpetra_impl.hpp b/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_BlockedTpetra_impl.hpp
index 52488585d37e..9c8533419013 100644
--- a/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_BlockedTpetra_impl.hpp
+++ b/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_BlockedTpetra_impl.hpp
@@ -305,9 +305,6 @@ postRegistrationSetup(typename TRAITS::SetupData d,
                                                 maxElementBlockGIDCount);
 
   // Set up storage for tangentFields using view of views
-  // We also need storage for the number of tangent fields associated with
-  // each gatherField
-
   if (has_tangent_fields_) {
 
     size_t inner_vector_max_size = 0;
diff --git a/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_Tpetra_impl.hpp b/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_Tpetra_impl.hpp
index bdff0f73574e..21be837adf3e 100644
--- a/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_Tpetra_impl.hpp
+++ b/packages/panzer/disc-fe/src/evaluators/Panzer_GatherSolution_Tpetra_impl.hpp
@@ -263,8 +263,8 @@ postRegistrationSetup(typename TRAITS::SetupData /* d */,
   }
   Kokkos::deep_copy(tangentInnerVectorSizes_,tangentInnerVectorSizes_host);
 
-  gatherFieldsVoV_.initialize("GatherSolution_Teptra<Tangent>::gatherFieldsVoV_",gatherFields_.size());
-  tangentFieldsVoV_.initialize("GatherSolution_Teptra<Tangent>::tangentFieldsVoV_",gatherFields_.size(),inner_vector_max_size);
+  gatherFieldsVoV_.initialize("GatherSolution_Tpetra<Tangent>::gatherFieldsVoV_",gatherFields_.size());
+  tangentFieldsVoV_.initialize("GatherSolution_Tpetra<Tangent>::tangentFieldsVoV_",gatherFields_.size(),inner_vector_max_size);
 
   for (std::size_t fd = 0; fd < gatherFields_.size(); ++fd) {
     const std::string& fieldName = indexerNames_[fd];
diff --git a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_BlockedTpetra_impl.hpp b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_BlockedTpetra_impl.hpp
index 3e8633c7f3ef..743d8b30cef7 100644
--- a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_BlockedTpetra_impl.hpp
+++ b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_BlockedTpetra_impl.hpp
@@ -472,6 +472,4 @@ evaluateFields(typename TRAITS::EvalData workset)
 
 }
 
-// **********************************************************************
-
 #endif
diff --git a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_decl.hpp b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_decl.hpp
index 4ea8c009ed5c..ad06fbe8f2d7 100644
--- a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_decl.hpp
+++ b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_decl.hpp
@@ -14,6 +14,7 @@
 #include "Phalanx_config.hpp"
 #include "Phalanx_Evaluator_Macros.hpp"
 #include "Phalanx_MDField.hpp"
+#include "Phalanx_KokkosViewOfViews.hpp"
 
 #include "Teuchos_ParameterList.hpp"
 
@@ -134,6 +135,7 @@ class ScatterResidual_Tpetra<panzer::Traits::Tangent,TRAITS,LO,GO,NodeT>
 
 private:
   typedef typename panzer::Traits::Tangent::ScalarT ScalarT;
+  typedef typename panzer::Traits::RealType RealT;
 
   // dummy field so that the evaluator will have something to do
   Teuchos::RCP<PHX::FieldTag> scatterHolder_;
@@ -153,8 +155,13 @@ class ScatterResidual_Tpetra<panzer::Traits::Tangent,TRAITS,LO,GO,NodeT>
   Teuchos::RCP<const std::map<std::string,std::string> > fieldMap_;
 
   std::string globalDataKey_; // what global data does this fill?
+  Teuchos::RCP<const TpetraLinearObjContainer<double,LO,GO,NodeT> > tpetraContainer_;
+
+  /// Storage for the tangent data
+  PHX::ViewOfViews<1,Kokkos::View<RealT**,Kokkos::LayoutLeft,PHX::Device>> dfdpFieldsVoV_;
 
-  std::vector< Teuchos::ArrayRCP<double> > dfdp_vectors_;
+  PHX::View<int**> scratch_lids_;
+  std::vector<PHX::View<int*> > scratch_offsets_;
 
   ScatterResidual_Tpetra();
 };
diff --git a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_impl.hpp b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_impl.hpp
index 117f271faa56..c3655218f381 100644
--- a/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_impl.hpp
+++ b/packages/panzer/disc-fe/src/evaluators/Panzer_ScatterResidual_Tpetra_impl.hpp
@@ -130,6 +130,7 @@ ScatterResidual_Tpetra(const Teuchos::RCP<const panzer::GlobalIndexer> & indexer
   : globalIndexer_(indexer)
   , globalDataKey_("Residual Scatter Container")
 {
+
   std::string scatterName = p.get<std::string>("Scatter Name");
   scatterHolder_ =
     Teuchos::rcp(new PHX::Tag<ScalarT>(scatterName,Teuchos::rcp(new PHX::MDALayout<Dummy>(0))));
@@ -146,6 +147,7 @@ ScatterResidual_Tpetra(const Teuchos::RCP<const panzer::GlobalIndexer> & indexer
 
   // build the vector of fields that this is dependent on
   scatterFields_.resize(names.size());
+  scratch_offsets_.resize(names.size());
   for (std::size_t eq = 0; eq < names.size(); ++eq) {
     scatterFields_[eq] = PHX::MDField<const ScalarT,Cell,NODE>(names[eq],dl);
 
@@ -165,16 +167,25 @@ ScatterResidual_Tpetra(const Teuchos::RCP<const panzer::GlobalIndexer> & indexer
 // **********************************************************************
 template<typename TRAITS,typename LO,typename GO,typename NodeT>
 void panzer::ScatterResidual_Tpetra<panzer::Traits::Tangent, TRAITS,LO,GO,NodeT>::
-postRegistrationSetup(typename TRAITS::SetupData /* d */,
+postRegistrationSetup(typename TRAITS::SetupData d,
                       PHX::FieldManager<TRAITS>& /* fm */)
 {
   fieldIds_.resize(scatterFields_.size());
+  const Workset & workset_0 = (*d.worksets_)[0];
+  std::string blockId = this->wda(workset_0).block_id;
+
   // load required field numbers for fast use
   for(std::size_t fd=0;fd<scatterFields_.size();++fd) {
     // get field ID from DOF manager
     std::string fieldName = fieldMap_->find(scatterFields_[fd].fieldTag().name())->second;
     fieldIds_[fd] = globalIndexer_->getFieldNum(fieldName);
+
+    const std::vector<int> & offsets = globalIndexer_->getGIDFieldOffsets(blockId,fieldIds_[fd]);
+    scratch_offsets_[fd] = PHX::View<int*>("offsets",offsets.size());
+    Kokkos::deep_copy(scratch_offsets_[fd], Kokkos::View<const int*, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>(offsets.data(), offsets.size()));
   }
+  scratch_lids_ = PHX::View<LO**>("lids",scatterFields_[0].extent(0),
+                                                 globalIndexer_->getElementBlockGIDCount(blockId));
 }
 
 // **********************************************************************
@@ -191,50 +202,26 @@ preEvaluate(typename TRAITS::PreEvalData d)
   std::vector<std::string> activeParameters =
     rcp_dynamic_cast<ParameterList_GlobalEvaluationData>(d.gedc->getDataObject("PARAMETER_NAMES"))->getActiveParameters();
 
-  dfdp_vectors_.clear();
+  dfdpFieldsVoV_.initialize("ScatterResidual_Tpetra<Tangent>::dfdpFieldsVoV_",activeParameters.size());
+
   for(std::size_t i=0;i<activeParameters.size();i++) {
     RCP<typename LOC::VectorType> vec =
       rcp_dynamic_cast<LOC>(d.gedc->getDataObject(activeParameters[i]),true)->get_f();
-    Teuchos::ArrayRCP<double> vec_array = vec->get1dViewNonConst();
-    dfdp_vectors_.push_back(vec_array);
+    auto dfdp_view = vec->getLocalViewDevice(Tpetra::Access::ReadWrite);
+
+    dfdpFieldsVoV_.addView(dfdp_view,i);
   }
-}
 
-// **********************************************************************
-template<typename TRAITS,typename LO,typename GO,typename NodeT>
-void panzer::ScatterResidual_Tpetra<panzer::Traits::Tangent, TRAITS,LO,GO,NodeT>::
-evaluateFields(typename TRAITS::EvalData workset)
-{
-   // for convenience pull out some objects from workset
-   std::string blockId = this->wda(workset).block_id;
-   const std::vector<std::size_t> & localCellIds = this->wda(workset).cell_local_ids;
-
-   // NOTE: A reordering of these loops will likely improve performance
-   //       The "getGIDFieldOffsets may be expensive.  However the
-   //       "getElementGIDs" can be cheaper. However the lookup for LIDs
-   //       may be more expensive!
-
-   // scatter operation for each cell in workset
-   for(std::size_t worksetCellIndex=0;worksetCellIndex<localCellIds.size();++worksetCellIndex) {
-      std::size_t cellLocalId = localCellIds[worksetCellIndex];
-
-      auto LIDs = globalIndexer_->getElementLIDs(cellLocalId);
-
-      // loop over each field to be scattered
-      for (std::size_t fieldIndex = 0; fieldIndex < scatterFields_.size(); fieldIndex++) {
-         int fieldNum = fieldIds_[fieldIndex];
-         const std::vector<int> & elmtOffset = globalIndexer_->getGIDFieldOffsets(blockId,fieldNum);
-
-         // loop over basis functions
-         for(std::size_t basis=0;basis<elmtOffset.size();basis++) {
-            int offset = elmtOffset[basis];
-            LO lid = LIDs[offset];
-            ScalarT value = (scatterFields_[fieldIndex])(worksetCellIndex,basis);
-            for(int d=0;d<value.size();d++)
-              dfdp_vectors_[d][lid] += value.fastAccessDx(d);
-         }
-      }
-   }
+  dfdpFieldsVoV_.syncHostToDevice();
+
+  // extract linear object container
+  tpetraContainer_ = Teuchos::rcp_dynamic_cast<LOC>(d.gedc->getDataObject(globalDataKey_));
+
+  if(tpetraContainer_==Teuchos::null) {
+    // extract linear object container
+    Teuchos::RCP<LinearObjContainer> loc = Teuchos::rcp_dynamic_cast<LOCPair_GlobalEvaluationData>(d.gedc->getDataObject(globalDataKey_),true)->getGhostedLOC();
+    tpetraContainer_ = Teuchos::rcp_dynamic_cast<LOC>(loc);
+  }  
 }
 
 // **********************************************************************
@@ -392,7 +379,6 @@ class ScatterResidual_Residual_Functor {
   PHX::View<const int*> offsets; // how to get a particular field
   FieldType field;
 
-
   KOKKOS_INLINE_FUNCTION
   void operator()(const unsigned int cell) const
   {
@@ -407,6 +393,44 @@ class ScatterResidual_Residual_Functor {
   }
 };
 
+template <typename ScalarT,typename LO,typename GO,typename NodeT>
+class ScatterResidual_Tangent_Functor {
+public:
+  typedef typename PHX::Device execution_space;
+  typedef PHX::MDField<const ScalarT,Cell,NODE> FieldType;
+
+  bool fillResidual;
+  Kokkos::View<double**, Kokkos::LayoutLeft,PHX::Device> r_data;
+
+  Kokkos::View<const LO**> lids; // local indices for unknowns.
+  PHX::View<const int*> offsets; // how to get a particular field
+  FieldType field;
+  double num_params;
+
+  Kokkos::View<Kokkos::View<double**,Kokkos::LayoutLeft,PHX::Device>*>  dfdp_fields; // tangent fields
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const unsigned int cell) const
+  {
+
+    // loop over the basis functions (currently they are nodes)
+    for(std::size_t basis=0; basis < offsets.extent(0); basis++) {
+       typename FieldType::array_type::reference_type scatterField = field(cell,basis);
+       int offset = offsets(basis);
+       LO lid    = lids(cell,offset);
+
+       // Sum residual
+       if(fillResidual)
+         Kokkos::atomic_add(&r_data(lid,0), scatterField.val());
+
+       // loop over the tangents
+       for(int i_param=0; i_param<num_params; i_param++)
+          dfdp_fields(i_param)(lid,0) += scatterField.fastAccessDx(i_param);
+
+    } // end basis
+  }
+};
+
 }
 }
 
@@ -483,6 +507,35 @@ evaluateFields(typename TRAITS::EvalData workset)
 
 }
 
+// **********************************************************************
+template<typename TRAITS,typename LO,typename GO,typename NodeT>
+void panzer::ScatterResidual_Tpetra<panzer::Traits::Tangent, TRAITS,LO,GO,NodeT>::
+evaluateFields(typename TRAITS::EvalData workset)
+{
+  typedef TpetraLinearObjContainer<double,LO,GO,NodeT> LOC;
+
+  // for convenience pull out some objects from workset
+  std::string blockId = this->wda(workset).block_id;
+
+  Teuchos::RCP<typename LOC::VectorType> r = tpetraContainer_->get_f();
+
+  globalIndexer_->getElementLIDs(this->wda(workset).getLocalCellIDs(),scratch_lids_);
+
+  ScatterResidual_Tangent_Functor<ScalarT,LO,GO,NodeT> functor;
+  functor.r_data = r->getLocalViewDevice(Tpetra::Access::ReadWrite);
+  functor.lids = scratch_lids_;
+  functor.dfdp_fields = dfdpFieldsVoV_.getViewDevice();
+
+  // for each field, do a parallel for loop
+  for(std::size_t fieldIndex = 0; fieldIndex < scatterFields_.size(); fieldIndex++) {
+    functor.offsets = scratch_offsets_[fieldIndex];
+    functor.field = scatterFields_[fieldIndex];
+    functor.num_params = Kokkos::dimension_scalar(scatterFields_[fieldIndex].get_view())-1;
+
+    Kokkos::parallel_for(workset.num_cells,functor);
+  }
+}
+
 // **********************************************************************
 
 #endif