diff --git a/src/adapter/4C_adapter_str_structure_new.cpp b/src/adapter/4C_adapter_str_structure_new.cpp
index 117e46efba0..977129b393f 100644
--- a/src/adapter/4C_adapter_str_structure_new.cpp
+++ b/src/adapter/4C_adapter_str_structure_new.cpp
@@ -820,21 +820,39 @@ void Adapter::StructureBaseAlgorithmNew::create_wrapper(
     case Core::ProblemType::thermo_fsi:
     case Core::ProblemType::fsi_xfem:
     {
+      const Teuchos::ParameterList& fsidyn = problem->fsi_dynamic_params();
+      auto coupling = Teuchos::getIntegralValue<FsiCoupling>(fsidyn, "COUPALGO");
+
+      if (Core::Communication::my_mpi_rank((actdis_->get_comm())) == 0)
+        Core::IO::cout << "Using StructureNOXCorrectionWrapper()..." << Core::IO::endl;
+
       // Are there any constraint conditions active?
       const std::set<Inpar::Solid::ModelType>& modeltypes =
           ti_strategy->get_data_sdyn().get_model_types();
       if (modeltypes.find(Inpar::Solid::model_lag_pen_constraint) != modeltypes.end())
       {
-        if (Core::Communication::my_mpi_rank((actdis_->get_comm())) == 0)
-          Core::IO::cout << "Using StructureNOXCorrectionWrapper()..." << Core::IO::endl;
-
         str_wrapper_ = std::make_shared<StructureConstrMerged>(
             std::make_shared<StructureNOXCorrectionWrapper>(ti_strategy));
       }
       else
       {
-        // case of partitioned fsi
-        str_wrapper_ = std::make_shared<FSIStructureWrapper>(ti_strategy);
+        // case of monolithic fsi
+        if (coupling == fsi_iter_mortar_monolithicfluidsplit or
+            coupling == fsi_iter_mortar_monolithicstructuresplit or
+            coupling == fsi_iter_monolithicfluidsplit or
+            coupling == fsi_iter_monolithicstructuresplit or
+            coupling == fsi_iter_sliding_monolithicfluidsplit or
+            coupling == fsi_iter_sliding_monolithicstructuresplit or
+            coupling == fsi_iter_mortar_monolithicfluidsplit_saddlepoint)
+        {
+          str_wrapper_ = std::make_shared<FSIStructureWrapper>(
+              std::make_shared<StructureNOXCorrectionWrapper>(ti_strategy));
+        }
+        else
+        {
+          // case of partitioned fsi
+          str_wrapper_ = std::make_shared<FSIStructureWrapper>(ti_strategy);
+        }
       }
       break;
     }
diff --git a/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.cpp b/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.cpp
index 0e909f2f538..ef75b322626 100644
--- a/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.cpp
+++ b/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.cpp
@@ -55,6 +55,76 @@ std::shared_ptr<Core::LinAlg::SparseMatrix> Core::LinAlg::BlockSparseMatrixBase:
   return sparse;
 }
 
+/*----------------------------------------------------------------------*
+ *----------------------------------------------------------------------*/
+std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase>
+Core::LinAlg::copy_sparse_to_block_sparse_matrix(const Core::LinAlg::SparseMatrix& sparse_matrix,
+    const Core::LinAlg::MultiMapExtractor& domainmaps,
+    const Core::LinAlg::MultiMapExtractor& rangemaps)
+{
+  // Step 1: Precompute the number of max number of entries per row in the blocks
+
+  const int number_of_domain_maps = domainmaps.num_maps();
+
+  const auto& epetra_matrix = sparse_matrix.epetra_matrix();
+  const Map& sparse_matrix_col_map = sparse_matrix.col_map();
+  const int nummyrows = epetra_matrix.NumMyRows();
+  std::vector<int> max_num_entries_per_row_per_block(number_of_domain_maps, 0);
+  std::vector<int> num_entries_per_row_per_block(number_of_domain_maps, 0);
+  for (int iRow = 0; iRow < nummyrows; ++iRow)
+  {
+    int num_entries_per_row;
+    double* values;
+    int* indices;
+    epetra_matrix.ExtractMyRowView(iRow, num_entries_per_row, values, indices);
+    num_entries_per_row_per_block.assign(number_of_domain_maps, 0);
+    for (int iCol = 0; iCol < num_entries_per_row; ++iCol)
+    {
+      int col_gid = sparse_matrix_col_map.gid(indices[iCol]);
+      for (int m = 0; m < number_of_domain_maps; ++m)
+      {
+        if (domainmaps.map(m)->my_gid(col_gid))
+        {
+          ++num_entries_per_row_per_block[m];
+          break;
+        }
+      }
+    }
+    // check whether this works element wise ?!?!
+    max_num_entries_per_row_per_block =
+        std::max(num_entries_per_row_per_block, max_num_entries_per_row_per_block);
+  }
+
+  int max_num_entries_per_row = *std::ranges::max_element(
+      max_num_entries_per_row_per_block.begin(), max_num_entries_per_row_per_block.end());
+
+  // allocate block matrix with educated guess for number of non-zeros per row
+  auto block_matrix =
+      std::make_shared<Core::LinAlg::BlockSparseMatrix<Core::LinAlg::DefaultBlockMatrixStrategy>>(
+          domainmaps, rangemaps, max_num_entries_per_row, false, true);
+
+  // Step 2: Copy sparse matrix to block structure
+
+  for (int iRow = 0; iRow < nummyrows; ++iRow)
+  {
+    int num_entries_per_row;
+    double* values;
+    int* indices;
+
+    epetra_matrix.ExtractMyRowView(iRow, num_entries_per_row, values, indices);
+    const int row_gid = epetra_matrix.RowMap().GID(iRow);
+
+    for (int iCol = 0; iCol < num_entries_per_row; ++iCol)
+    {
+      int col_gid = sparse_matrix_col_map.gid(indices[iCol]);
+      block_matrix->assemble(values[iCol], row_gid, col_gid);
+    }
+  }
+
+  if (sparse_matrix.filled()) block_matrix->complete();
+
+  return block_matrix;
+}
 
 /*----------------------------------------------------------------------*
  *----------------------------------------------------------------------*/
@@ -348,6 +418,35 @@ const Epetra_Map& Core::LinAlg::BlockSparseMatrixBase::OperatorRangeMap() const
   return full_range_map().get_epetra_map();
 }
 
+void Core::LinAlg::BlockSparseMatrixBase::print(std::ostream& os) const
+{
+  for (int row = 0; row < rows(); row++)
+  {
+    for (int col = 0; col < cols(); col++)
+    {
+      for (int proc = 0; proc < Core::Communication::num_mpi_ranks(get_comm()); ++proc)
+      {
+        Core::Communication::barrier(get_comm());
+        if (proc == Core::Communication::my_mpi_rank(get_comm()))
+        {
+          if (matrix(row, col).num_my_nonzeros() == 0)
+          {
+            os << "\nBlockSparseMatrix row, col: " << row << ", " << col << " on rank "
+               << Core::Communication::my_mpi_rank(get_comm()) << " is empty" << std::endl;
+          }
+          else
+          {
+            os << "\nBlockSparseMatrix row, col: " << row << ", " << col << " on rank "
+               << Core::Communication::my_mpi_rank(get_comm()) << std::endl;
+
+            matrix(row, col).print(os);
+          }
+        }
+        Core::Communication::barrier(get_comm());
+      }
+    }
+  }
+}
 
 /*----------------------------------------------------------------------*
  *----------------------------------------------------------------------*/
diff --git a/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.hpp b/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.hpp
index da5faddc17e..6ffd72c6fb0 100644
--- a/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.hpp
+++ b/src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.hpp
@@ -18,6 +18,9 @@ FOUR_C_NAMESPACE_OPEN
 
 namespace Core::LinAlg
 {
+  // forward declaration
+  class DefaultBlockMatrixStrategy;
+
   /// Internal base class of BlockSparseMatrix that contains the non-template stuff
   /*!
 
@@ -210,6 +213,9 @@ namespace Core::LinAlg
     /// access to range map extractor in derived classes
     const MultiMapExtractor& range_extractor() const { return rangemaps_; }
 
+    //! Print to user-provided output stream
+    void print(std::ostream& os) const;
+
    private:
     /// the full domain map together with all partial domain maps
     MultiMapExtractor domainmaps_;
@@ -230,6 +236,11 @@ namespace Core::LinAlg
     bool usetranspose_;
   };
 
+  // split LinAlg::SparseMatrix into LinAlg::BlockSparseMatrix based on the given maps
+  std::shared_ptr<BlockSparseMatrixBase> copy_sparse_to_block_sparse_matrix(
+      const Core::LinAlg::SparseMatrix& sparse_matrix,
+      const Core::LinAlg::MultiMapExtractor& domainmaps,
+      const Core::LinAlg::MultiMapExtractor& rangemaps);
 
 
   /// Block matrix consisting of SparseMatrix blocks
diff --git a/src/fsi/src/monolithic/4C_fsi_monolithic.cpp b/src/fsi/src/monolithic/4C_fsi_monolithic.cpp
index 8f8d13d7695..d5d6e30afda 100644
--- a/src/fsi/src/monolithic/4C_fsi_monolithic.cpp
+++ b/src/fsi/src/monolithic/4C_fsi_monolithic.cpp
@@ -10,8 +10,10 @@
 #include "4C_adapter_ale.hpp"
 #include "4C_adapter_ale_fsi.hpp"
 #include "4C_adapter_fld_fluid_fsi.hpp"
+#include "4C_adapter_str_factory.hpp"
 #include "4C_adapter_str_fsi_timint_adaptive.hpp"
 #include "4C_adapter_str_fsiwrapper.hpp"
+#include "4C_adapter_str_structure_new.hpp"
 #include "4C_constraint_manager.hpp"
 #include "4C_coupling_adapter.hpp"
 #include "4C_fem_discretization.hpp"
@@ -55,6 +57,7 @@ FSI::MonolithicBase::MonolithicBase(MPI_Comm comm, const Teuchos::ParameterList&
       isadastructure_(false),
       isadafluid_(false),
       isadasolver_(false),
+      use_old_structure_(true),
       verbosity_(Teuchos::getIntegralValue<Inpar::FSI::Verbosity>(
           Global::Problem::instance()->fsi_dynamic_params(), "VERBOSITY"))
 {
@@ -98,18 +101,38 @@ void FSI::MonolithicBase::create_structure_time_integrator(
   // access structural dynamic params
   const Teuchos::ParameterList& sdyn = Global::Problem::instance()->structural_dynamic_params();
 
-  // ask base algorithm for the structural time integrator
-  std::shared_ptr<Adapter::StructureBaseAlgorithm> structure =
-      std::make_shared<Adapter::StructureBaseAlgorithm>(
-          timeparams, const_cast<Teuchos::ParameterList&>(sdyn), structdis);
-  structure_ =
-      std::dynamic_pointer_cast<Adapter::FSIStructureWrapper>(structure->structure_field());
-  structure_->setup();
+  if (Teuchos::getIntegralValue<Inpar::Solid::IntegrationStrategy>(sdyn, "INT_STRATEGY") ==
+      Inpar::Solid::int_standard)
+  {
+    use_old_structure_ = false;
 
-  if (structure_ == nullptr)
-    FOUR_C_THROW(
-        "Cast from Adapter::Structure to Adapter::FSIStructureWrapper "
-        "failed.");
+    std::shared_ptr<Adapter::StructureBaseAlgorithmNew> structure =
+        Adapter::build_structure_algorithm(sdyn);
+    structure->init(Global::Problem::instance()->fsi_dynamic_params(),
+        const_cast<Teuchos::ParameterList&>(sdyn), structdis);
+    structure->setup();
+
+    structure_ =
+        std::dynamic_pointer_cast<Adapter::FSIStructureWrapper>(structure->structure_field());
+
+    if (structure_ == nullptr)
+      FOUR_C_THROW("cast from ADAPTER::Structure to ADAPTER::FSIStructureWrapper failed");
+  }
+  else
+  {
+    // ask base algorithm for the structural time integrator
+    std::shared_ptr<Adapter::StructureBaseAlgorithm> structure =
+        std::make_shared<Adapter::StructureBaseAlgorithm>(
+            timeparams, const_cast<Teuchos::ParameterList&>(sdyn), structdis);
+    structure_ =
+        std::dynamic_pointer_cast<Adapter::FSIStructureWrapper>(structure->structure_field());
+    structure_->setup();
+
+    if (structure_ == nullptr)
+      FOUR_C_THROW(
+          "Cast from Adapter::Structure to Adapter::FSIStructureWrapper "
+          "failed.");
+  }
 
   return;
 }
@@ -199,7 +222,7 @@ void FSI::MonolithicBase::output()
   fluid_field()->output();
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
     structure_field()->get_constraint_manager()->compute_monitor_values(
         *structure_field()->dispnp());
@@ -625,7 +648,7 @@ void FSI::Monolithic::time_step(const std::shared_ptr<NOX::Nln::Interface::Requi
   // initial guess. (The Dirichlet conditions are already build in!)
   std::shared_ptr<Core::LinAlg::Vector<double>> initial_guess_v =
       std::make_shared<Core::LinAlg::Vector<double>>(*dof_row_map(), true);
-  initial_guess(initial_guess_v);
+  if (use_old_structure_) initial_guess(initial_guess_v);
 
   NOX::Nln::Vector noxSoln(initial_guess_v, NOX::Nln::Vector::MemoryType::View);
 
diff --git a/src/fsi/src/monolithic/4C_fsi_monolithic.hpp b/src/fsi/src/monolithic/4C_fsi_monolithic.hpp
index b39111d33df..034a608bbca 100644
--- a/src/fsi/src/monolithic/4C_fsi_monolithic.hpp
+++ b/src/fsi/src/monolithic/4C_fsi_monolithic.hpp
@@ -249,6 +249,8 @@ namespace FSI
     bool isadafluid_;      ///< Time step size adaptivity based on fluid?
     bool isadasolver_;     ///< Time step size adaptivity based on solver convergence?
 
+    bool use_old_structure_;  /// indicator if old or new time integration is used TEMPORARY
+
     //@}
 
     //! @name output related stuff
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicfluidsplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicfluidsplit.cpp
index 7a26e4c0300..a52e9364715 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicfluidsplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicfluidsplit.cpp
@@ -315,10 +315,13 @@ void FSI::MonolithicFluidSplit::setup_rhs_residual(Core::LinAlg::Vector<double>&
   const double fluidscale = fluid_field()->residual_scaling();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
   // extract only inner DOFs from fluid (=slave) and ALE field
   std::shared_ptr<Core::LinAlg::Vector<double>> fov =
       fluid_field()->interface()->extract_other_vector(fv);
@@ -1273,12 +1276,15 @@ void FSI::MonolithicFluidSplit::output()
 
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(get_comm()) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(get_comm()) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.cpp
index 4291d3d21f4..737c2f178c0 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.cpp
@@ -10,8 +10,8 @@
 #include "4C_adapter_ale_fsi.hpp"
 #include "4C_adapter_fld_fluid_fsi.hpp"
 #include "4C_adapter_str_fsiwrapper.hpp"
-#include "4C_adapter_str_structure.hpp"
 #include "4C_ale_utils_mapextractor.hpp"
+#include "4C_comm_utils.hpp"
 #include "4C_constraint_manager.hpp"
 #include "4C_coupling_adapter.hpp"
 #include "4C_coupling_adapter_converter.hpp"
@@ -34,6 +34,87 @@ FOUR_C_NAMESPACE_OPEN
 FSI::MonolithicStructureSplit::MonolithicStructureSplit(
     MPI_Comm comm, const Teuchos::ParameterList& timeparams)
     : BlockMonolithic(comm, timeparams), lambda_(nullptr), lambdaold_(nullptr), energysum_(0.0)
+{
+  sggtransform_ = std::make_shared<Coupling::Adapter::MatrixRowColTransform>();
+  sgitransform_ = std::make_shared<Coupling::Adapter::MatrixRowTransform>();
+  sigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  aigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+
+  fmiitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+
+  fsaigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fsmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+
+  fscoupfa_ = std::make_shared<Coupling::Adapter::Coupling>();
+
+  // Recovery of Lagrange multiplier happens on structure field
+  lambda_ = std::make_shared<Core::LinAlg::Vector<double>>(
+      *structure_field()->interface()->fsi_cond_map(), true);
+  lambdaold_ = std::make_shared<Core::LinAlg::Vector<double>>(
+      *structure_field()->interface()->fsi_cond_map(), true);
+  ddiinc_ = nullptr;
+  soliprev_ = nullptr;
+  ddginc_ = nullptr;
+  duginc_ = nullptr;
+  disgprev_ = nullptr;
+  sgiprev_ = nullptr;
+  sggprev_ = nullptr;
+
+#ifdef FOUR_C_ENABLE_ASSERTIONS
+  // check whether allocation was successful
+  if (sggtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'sggtransform_' failed.");
+  }
+  if (sgitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'sgitransform_' failed.");
+  }
+  if (sigtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'sigtransform_' failed.");
+  }
+  if (aigtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'aigtransform_' failed.");
+  }
+  if (fmiitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fmiitransform_' failed.");
+  }
+  if (fmgitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fmgitransform_' failed.");
+  }
+  if (fsaigtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fsaigtransform_' failed.");
+  }
+  if (fsmgitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fsmgitransform_' failed.");
+  }
+  if (fscoupfa_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fscoupfa_' failed.");
+  }
+  if (lambda_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'lambda_' failed.");
+  }
+  if (lambdaold_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'lambdaold_' failed.");
+  }
+#endif
+
+  return;
+}
+
+/*----------------------------------------------------------------------*/
+/*----------------------------------------------------------------------*/
+void FSI::MonolithicStructureSplit::check_dirichlet_boundary_conditions_on_interface()
 {
   // ---------------------------------------------------------------------------
   // FSI specific check of Dirichlet boundary conditions
@@ -130,91 +211,16 @@ FSI::MonolithicStructureSplit::MonolithicStructureSplit(
 
     FOUR_C_THROW("{}", errormsg.str());
   }
-  // ---------------------------------------------------------------------------
-
-  sggtransform_ = std::make_shared<Coupling::Adapter::MatrixRowColTransform>();
-  sgitransform_ = std::make_shared<Coupling::Adapter::MatrixRowTransform>();
-  sigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  aigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-
-  fmiitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-
-  fsaigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fsmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-
-  fscoupfa_ = std::make_shared<Coupling::Adapter::Coupling>();
-
-  // Recovery of Lagrange multiplier happens on structure field
-  lambda_ = std::make_shared<Core::LinAlg::Vector<double>>(
-      *structure_field()->interface()->fsi_cond_map(), true);
-  lambdaold_ = std::make_shared<Core::LinAlg::Vector<double>>(
-      *structure_field()->interface()->fsi_cond_map(), true);
-  ddiinc_ = nullptr;
-  soliprev_ = nullptr;
-  ddginc_ = nullptr;
-  duginc_ = nullptr;
-  disgprev_ = nullptr;
-  sgiprev_ = nullptr;
-  sggprev_ = nullptr;
-
-#ifdef FOUR_C_ENABLE_ASSERTIONS
-  // check whether allocation was successful
-  if (sggtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'sggtransform_' failed.");
-  }
-  if (sgitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'sgitransform_' failed.");
-  }
-  if (sigtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'sigtransform_' failed.");
-  }
-  if (aigtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'aigtransform_' failed.");
-  }
-  if (fmiitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fmiitransform_' failed.");
-  }
-  if (fmgitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fmgitransform_' failed.");
-  }
-  if (fsaigtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fsaigtransform_' failed.");
-  }
-  if (fsmgitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fsmgitransform_' failed.");
-  }
-  if (fscoupfa_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fscoupfa_' failed.");
-  }
-  if (lambda_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'lambda_' failed.");
-  }
-  if (lambdaold_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'lambdaold_' failed.");
-  }
-#endif
-
-  return;
 }
 
 /*----------------------------------------------------------------------*/
 /*----------------------------------------------------------------------*/
 void FSI::MonolithicStructureSplit::setup_system()
 {
-  const Teuchos::ParameterList& fsidyn = Global::Problem::instance()->fsi_dynamic_params();
+  // check for proper dirichlet boundary condition application
+  check_dirichlet_boundary_conditions_on_interface();
 
+  const Teuchos::ParameterList& fsidyn = Global::Problem::instance()->fsi_dynamic_params();
   set_default_parameters(fsidyn, nox_parameter_list());
 
   // call SetupSystem in base class
@@ -227,8 +233,8 @@ void FSI::MonolithicStructureSplit::setup_system()
   // linearization (if requested in the input file)
   fluid_field()->use_block_matrix(false);
 
-  // Use split structure matrix
-  structure_field()->use_block_matrix();
+  // Do no longer use split structure matrix for new solid time integration
+  if (use_old_structure_) structure_field()->use_block_matrix();
 
   // build ale system matrix in split system
   ale_field()->create_system_matrix(ale_field()->interface());
@@ -350,11 +356,14 @@ void FSI::MonolithicStructureSplit::setup_rhs_residual(Core::LinAlg::Vector<doub
   const double fluidscale = fluid_field()->residual_scaling();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
-  //  // extract only inner DOFs from structure (=slave) and ALE field
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
+  // extract only inner DOFs from structure (=slave) and ALE field
   std::shared_ptr<const Core::LinAlg::Vector<double>> sov =
       structure_field()->interface()->extract_other_vector(sv);
   std::shared_ptr<const Core::LinAlg::Vector<double>> aov =
@@ -424,22 +433,33 @@ void FSI::MonolithicStructureSplit::setup_rhs_firstiter(Core::LinAlg::Vector<dou
       fluid_field()->shape_derivatives();
 
   // get structure matrix
-  const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> blocks = nullptr;
+  if (use_old_structure_)
+  {
+    blocks = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    blocks = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+
+    // Take care of Dirichlet boundary conditions
+    blocks->apply_dirichlet(*structure_field()->get_dbc_map_extractor()->cond_map(), true);
+    // blocks->apply_dirichlet(*(dbcmaps_->cond_map()), true);
+  }
 
   // get ale matrix
   const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocka =
       ale_field()->block_system_matrix();
 
 #ifdef FOUR_C_ENABLE_ASSERTIONS
-  if (blocks == nullptr)
-  {
-    FOUR_C_THROW("Expected Teuchos::rcp to structure block matrix.");
-  }
-  if (blocka == nullptr)
-  {
-    FOUR_C_THROW("Expected Teuchos::rcp to ALE block matrix.");
-  }
+  if (blocks == nullptr) FOUR_C_THROW("Expected structure block matrix.");
+  if (blocka == nullptr) FOUR_C_THROW("Expected ALE block matrix.");
 #endif
 
   // extract submatrices
@@ -605,8 +625,22 @@ void FSI::MonolithicStructureSplit::setup_system_matrix(Core::LinAlg::BlockSpars
   const Coupling::Adapter::Coupling& icoupfa = interface_fluid_ale_coupling();
 
   // get single field block matrices
-  const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> s =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> s = nullptr;
+  if (use_old_structure_)
+  {
+    s = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    // get structure matrix
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    s = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+  }
+
   const std::shared_ptr<Core::LinAlg::SparseMatrix> f = fluid_field()->system_matrix();
   const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> a = ale_field()->block_system_matrix();
 
@@ -1155,12 +1189,15 @@ void FSI::MonolithicStructureSplit::output()
   fluid_field()->output();
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(get_comm()) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(get_comm()) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
@@ -1275,7 +1312,8 @@ void FSI::MonolithicStructureSplit::recover_lagrange_multiplier()
   // ---------Addressing term (3)
   std::shared_ptr<Core::LinAlg::Vector<double>> structureresidual =
       structure_field()->interface()->extract_fsi_cond_vector(*structure_field()->rhs());
-  structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
+  if (use_old_structure_)
+    structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
   tmpvec = std::make_shared<Core::LinAlg::Vector<double>>(*structureresidual);
   // ---------End of term (3)
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.hpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.hpp
index 2b5b609291d..e2199877ca7 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.hpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_monolithicstructuresplit.hpp
@@ -208,6 +208,9 @@ namespace FSI
         std::shared_ptr<const Core::LinAlg::Vector<double>> av,
         bool slave_vectors_contain_interface_dofs) final;
 
+    /// check for dirichlet conditions on solid interface
+    void check_dirichlet_boundary_conditions_on_interface();
+
     /// block system matrix
     std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> systemmatrix_;
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit.cpp
index f1be45a2be8..7a916ed1b02 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit.cpp
@@ -231,7 +231,7 @@ void FSI::MortarMonolithicFluidSplit::setup_system()
 
     /* structure to fluid
      * coupling condition at the fsi interface:
-     * displacements (=number spacial dimensions) are coupled
+     * displacements (=number spatial dimensions) are coupled
      * e.g.: 3D: coupleddof = [1, 1, 1]
      */
     std::vector<int> coupleddof(ndim, 1);
@@ -385,10 +385,13 @@ void FSI::MortarMonolithicFluidSplit::setup_rhs_residual(Core::LinAlg::Vector<do
   const std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
   // extract only inner DOFs from fluid (=slave) and ALE field
   std::shared_ptr<Core::LinAlg::Vector<double>> fov =
       fluid_field()->interface()->extract_other_vector(fv);
@@ -1488,12 +1491,15 @@ void FSI::MortarMonolithicFluidSplit::output()
 
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(comm_) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(comm_) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit_sp.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit_sp.cpp
index e127b2ff6e6..66d2e299263 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit_sp.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_fluidsplit_sp.cpp
@@ -582,7 +582,7 @@ void FSI::MortarMonolithicFluidSplitSaddlePoint::combine_field_vectors(
 void FSI::MortarMonolithicFluidSplitSaddlePoint::setup_rhs_residual(Core::LinAlg::Vector<double>& f)
 {
   // get single field residuals
-  std::shared_ptr<const Core::LinAlg::Vector<double>> solid_single_field_rhs_vector =
+  std::shared_ptr<Core::LinAlg::Vector<double>> solid_single_field_rhs_vector =
       std::make_shared<Core::LinAlg::Vector<double>>(*structure_field()->rhs());
   std::shared_ptr<const Core::LinAlg::Vector<double>> fluid_single_field_rhs_vector =
       std::make_shared<Core::LinAlg::Vector<double>>(*fluid_field()->rhs());
@@ -591,6 +591,9 @@ void FSI::MortarMonolithicFluidSplitSaddlePoint::setup_rhs_residual(Core::LinAlg
   std::shared_ptr<Core::LinAlg::Vector<double>> lag_mult_rhs_vector =
       std::make_shared<Core::LinAlg::Vector<double>>(*lag_mult_dof_map_, true);
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) solid_single_field_rhs_vector->scale(-1.0);
+
   // put the single field residuals together
   combine_field_vectors(f, solid_single_field_rhs_vector, fluid_single_field_rhs_vector,
       ale_single_field_rhs_vector, lag_mult_rhs_vector, true);
@@ -1266,12 +1269,15 @@ void FSI::MortarMonolithicFluidSplitSaddlePoint::output()
 
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(comm_) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(comm_) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.cpp
index 60995ff1e41..663d73b1961 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.cpp
@@ -23,6 +23,7 @@
 #include "4C_io.hpp"
 #include "4C_io_control.hpp"
 #include "4C_linalg_utils_sparse_algebra_create.hpp"
+#include "4C_linalg_utils_sparse_algebra_manipulation.hpp"
 #include "4C_linalg_utils_sparse_algebra_math.hpp"
 #include "4C_linear_solver_method_linalg.hpp"
 #include "4C_structure_aux.hpp"
@@ -30,6 +31,9 @@
 #include <Teuchos_StandardParameterEntryValidators.hpp>
 #include <Teuchos_TimeMonitor.hpp>
 
+#include <chrono>
+#include <thread>
+
 FOUR_C_NAMESPACE_OPEN
 
 /*----------------------------------------------------------------------------------*/
@@ -41,6 +45,73 @@ FSI::MortarMonolithicStructureSplit::MortarMonolithicStructureSplit(
       lambda_(nullptr),
       lambdaold_(nullptr),
       energysum_(0.0)
+{
+  notsetup_ = true;
+
+  coupsfm_ = std::make_shared<Coupling::Adapter::CouplingMortar>(
+      Global::Problem::instance()->n_dim(), Global::Problem::instance()->mortar_coupling_params(),
+      Global::Problem::instance()->contact_dynamic_params(),
+      Global::Problem::instance()->spatial_approximation_type());
+  fscoupfa_ = std::make_shared<Coupling::Adapter::Coupling>();
+
+  aigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fmiitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fsaigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+  fsmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
+
+  set_lambda();
+  ddiinc_ = nullptr;
+  disiprev_ = nullptr;
+  disgprev_ = nullptr;
+  sgiprev_ = nullptr;
+  sggprev_ = nullptr;
+
+#ifdef FOUR_C_ENABLE_ASSERTIONS
+  if (coupsfm_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'coupsfm_' failed.");
+  }
+  if (fscoupfa_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fscoupfa_' failed.");
+  }
+  if (aigtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'aigtransform_' failed.");
+  }
+  if (fmiitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fmiitransform_' failed.");
+  }
+  if (fmgitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fmgitransform_' failed.");
+  }
+  if (fsaigtransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fsaigtransform_' failed.");
+  }
+  if (fsmgitransform_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'fsmgitransform_' failed.");
+  }
+  if (lambda_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'lambda_' failed.");
+  }
+  if (lambdaold_ == nullptr)
+  {
+    FOUR_C_THROW("Allocation of 'lambdaold_' failed.");
+  }
+#endif
+
+  return;
+}
+
+/*----------------------------------------------------------------------*/
+/*----------------------------------------------------------------------*/
+void FSI::MortarMonolithicStructureSplit::check_dirichlet_boundary_conditions_on_interface()
 {
   // ---------------------------------------------------------------------------
   // FSI specific check of Dirichlet boundary conditions
@@ -137,69 +208,6 @@ FSI::MortarMonolithicStructureSplit::MortarMonolithicStructureSplit(
 
     FOUR_C_THROW("{}", errormsg.str());
   }
-  // ---------------------------------------------------------------------------
-
-  notsetup_ = true;
-
-  coupsfm_ = std::make_shared<Coupling::Adapter::CouplingMortar>(
-      Global::Problem::instance()->n_dim(), Global::Problem::instance()->mortar_coupling_params(),
-      Global::Problem::instance()->contact_dynamic_params(),
-      Global::Problem::instance()->spatial_approximation_type());
-  fscoupfa_ = std::make_shared<Coupling::Adapter::Coupling>();
-
-  aigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fmiitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fsaigtransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-  fsmgitransform_ = std::make_shared<Coupling::Adapter::MatrixColTransform>();
-
-  set_lambda();
-  ddiinc_ = nullptr;
-  disiprev_ = nullptr;
-  disgprev_ = nullptr;
-  sgiprev_ = nullptr;
-  sggprev_ = nullptr;
-
-#ifdef FOUR_C_ENABLE_ASSERTIONS
-  if (coupsfm_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'coupsfm_' failed.");
-  }
-  if (fscoupfa_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fscoupfa_' failed.");
-  }
-  if (aigtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'aigtransform_' failed.");
-  }
-  if (fmiitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fmiitransform_' failed.");
-  }
-  if (fmgitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fmgitransform_' failed.");
-  }
-  if (fsaigtransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fsaigtransform_' failed.");
-  }
-  if (fsmgitransform_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'fsmgitransform_' failed.");
-  }
-  if (lambda_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'lambda_' failed.");
-  }
-  if (lambdaold_ == nullptr)
-  {
-    FOUR_C_THROW("Allocation of 'lambdaold_' failed.");
-  }
-#endif
-
-  return;
 }
 
 /*----------------------------------------------------------------------------*/
@@ -218,6 +226,9 @@ void FSI::MortarMonolithicStructureSplit::set_lambda()
 /*----------------------------------------------------------------------------*/
 void FSI::MortarMonolithicStructureSplit::setup_system()
 {
+  // check for proper dirichlet boundary condition application
+  check_dirichlet_boundary_conditions_on_interface();
+
   if (notsetup_)
   {
     const Teuchos::ParameterList& fsidyn = Global::Problem::instance()->fsi_dynamic_params();
@@ -275,8 +286,8 @@ void FSI::MortarMonolithicStructureSplit::setup_system()
     // linearization (if requested in the input file)
     fluid_field()->use_block_matrix(false);
 
-    // Use split structure matrix
-    structure_field()->use_block_matrix();
+    // Do no longer use split structure matrix for new solid time integration
+    if (use_old_structure_) structure_field()->use_block_matrix();
 
     // build ale system matrix in split system
     ale_field()->create_system_matrix(ale_field()->interface());
@@ -313,7 +324,7 @@ void FSI::MortarMonolithicStructureSplit::setup_system()
     notsetup_ = false;
   }
 
-  // NOTE: if we restart from an part. fsi problem we still have to read lambda_. But since this
+  // NOTE: if we restart from a part. fsi problem we still have to read lambda_. But since this
   // requires coupsf_ in order to map the nodal fluid forces on the structure nodes we have to do it
   // e.g. in here. But:
   // TODO: Move this to read_restart() when possible
@@ -405,9 +416,8 @@ FSI::MortarMonolithicStructureSplit::system_matrix() const
 /*----------------------------------------------------------------------------*/
 void FSI::MortarMonolithicStructureSplit::setup_rhs_residual(Core::LinAlg::Vector<double>& f)
 {
-  /* get time integration parameters of structure and fluid time integrators
-   * to enable consistent time integration among the fields
-   */
+  // get time integration parameters of structure and fluid time integrators
+  // to enable consistent time integration among the fields
   const double stiparam = structure_field()->tim_int_param();
   const double ftiparam = fluid_field()->tim_int_param();
 
@@ -418,10 +428,13 @@ void FSI::MortarMonolithicStructureSplit::setup_rhs_residual(Core::LinAlg::Vecto
   const std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
   // extract only inner DOFs from structure (=slave) and ALE field
   std::shared_ptr<const Core::LinAlg::Vector<double>> sov =
       structure_field()->interface()->extract_other_vector(sv);
@@ -480,7 +493,6 @@ void FSI::MortarMonolithicStructureSplit::setup_rhs_lambda(Core::LinAlg::Vector<
   return;
 }
 
-
 /*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 void FSI::MortarMonolithicStructureSplit::setup_rhs_firstiter(Core::LinAlg::Vector<double>& f)
@@ -505,17 +517,34 @@ void FSI::MortarMonolithicStructureSplit::setup_rhs_firstiter(Core::LinAlg::Vect
       fluid_field()->shape_derivatives();
 
   // get structure matrix
-  const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> blocks = nullptr;
+  if (use_old_structure_)
+  {
+    blocks = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    blocks = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+
+    // Take care of Dirichlet boundary conditions
+    blocks->apply_dirichlet(*structure_field()->get_dbc_map_extractor()->cond_map(), true);
+    // blocks->apply_dirichlet(*(dbcmaps_->cond_map()), true);
+  }
 
   // get ale matrix
   const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocka =
       ale_field()->block_system_matrix();
 
 #ifdef FOUR_C_ENABLE_ASSERTIONS
-  if (mortarp == nullptr) FOUR_C_THROW("Expected Teuchos::rcp to mortar matrix P.");
-  if (blocks == nullptr) FOUR_C_THROW("Expected Teuchos::rcp to structure block matrix.");
-  if (blocka == nullptr) FOUR_C_THROW("Expected Teuchos::rcp to ALE block matrix.");
+  if (mortarp == nullptr) FOUR_C_THROW("Expected mortar matrix P.");
+  if (blocks == nullptr) FOUR_C_THROW("Expected structure block matrix.");
+  if (blocka == nullptr) FOUR_C_THROW("Expected ALE block matrix.");
 #endif
 
   // extract submatrices
@@ -529,8 +558,7 @@ void FSI::MortarMonolithicStructureSplit::setup_rhs_firstiter(Core::LinAlg::Vect
   std::shared_ptr<Core::LinAlg::Vector<double>> auxvec = nullptr;  // just for convenience
   std::shared_ptr<Core::LinAlg::Vector<double>> tmpvec = nullptr;  // just for convenience
 
-  /* Different contributions/terms to the rhs are separated by the following
-   * comment line */
+  // Different contributions/terms to the rhs are separated by the following comment line
   // ---------- inner structure DOFs
   /* The following terms are added to the inner structure DOFs of right hand side:
    *
@@ -707,8 +735,22 @@ void FSI::MortarMonolithicStructureSplit::setup_system_matrix(
   std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field block matrices
-  const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> s =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> s = nullptr;
+  if (use_old_structure_)
+  {
+    s = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    // get structure matrix
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    s = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+  }
+
   const std::shared_ptr<Core::LinAlg::SparseMatrix> f = fluid_field()->system_matrix();
   const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> a = ale_field()->block_system_matrix();
 
@@ -1320,12 +1362,15 @@ void FSI::MortarMonolithicStructureSplit::output()
   }
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(comm_) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(comm_) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
@@ -1461,7 +1506,8 @@ void FSI::MortarMonolithicStructureSplit::recover_lagrange_multiplier()
   std::shared_ptr<Core::LinAlg::Vector<double>> structureresidual =
       std::make_shared<Core::LinAlg::Vector<double>>(
           *structure_field()->interface()->extract_fsi_cond_vector(*structure_field()->rhs()));
-  structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
+  if (use_old_structure_)
+    structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
   tmpvec = std::make_shared<Core::LinAlg::Vector<double>>(*structureresidual);
   // ---------End of term (3)
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.hpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.hpp
index de89b1f2706..83f70dd794e 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.hpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_mortarmonolithic_structuresplit.hpp
@@ -247,6 +247,9 @@ namespace FSI
         std::shared_ptr<const Core::LinAlg::Vector<double>> av,
         const bool slave_vectors_contain_interface_dofs) final;
 
+    /// check for dirichlet conditions on solid interface
+    void check_dirichlet_boundary_conditions_on_interface();
+
     /// block system matrix
     std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> systemmatrix_;
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_fluidsplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_fluidsplit.cpp
index fc25e1bb837..6602517d9bf 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_fluidsplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_fluidsplit.cpp
@@ -373,10 +373,13 @@ void FSI::SlidingMonolithicFluidSplit::setup_rhs_residual(Core::LinAlg::Vector<d
   const std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
   // extract only inner DOFs from fluid (=slave) and ALE field
   std::shared_ptr<Core::LinAlg::Vector<double>> fov =
       fsi_fluid_field()->fsi_interface()->extract_other_vector(fv);
@@ -1486,12 +1489,15 @@ void FSI::SlidingMonolithicFluidSplit::output()
 
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(comm_) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(comm_) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
diff --git a/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_structuresplit.cpp b/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_structuresplit.cpp
index a87803ff575..c1c0558c2e8 100644
--- a/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_structuresplit.cpp
+++ b/src/fsi/src/monolithic/model_evaluator/4C_fsi_slidingmonolithic_structuresplit.cpp
@@ -273,8 +273,8 @@ void FSI::SlidingMonolithicStructureSplit::setup_system()
     // linearization (if requested in the input file)
     fluid_field()->use_block_matrix(false);
 
-    // Use split structure matrix
-    structure_field()->use_block_matrix();
+    // Do no longer use split structure matrix for new solid time integration
+    if (use_old_structure_) structure_field()->use_block_matrix();
 
     // build ale system matrix in split system
     ale_field()->create_system_matrix(ale_field()->interface());
@@ -384,10 +384,13 @@ void FSI::SlidingMonolithicStructureSplit::setup_rhs_residual(Core::LinAlg::Vect
   const std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field residuals
-  const Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
+  Core::LinAlg::Vector<double> sv(*structure_field()->rhs());
   const Core::LinAlg::Vector<double> fv(*fluid_field()->rhs());
   const Core::LinAlg::Vector<double> av(*ale_field()->rhs());
 
+  // NOX treats rhs different in new solid time integration, hence sign inversion is necessary here
+  if (!use_old_structure_) sv.scale(-1.0);
+
   // extract only inner DOFs from structure (=slave) and ALE field
   std::shared_ptr<const Core::LinAlg::Vector<double>> sov =
       structure_field()->interface()->extract_other_vector(sv);
@@ -471,8 +474,26 @@ void FSI::SlidingMonolithicStructureSplit::setup_rhs_firstiter(Core::LinAlg::Vec
       fluid_field()->shape_derivatives();
 
   // get structure matrix
-  const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> blocks = nullptr;
+  if (use_old_structure_)
+  {
+    blocks = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    // get structure matrix
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    blocks = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+
+    // Take care of Dirichlet boundary conditions
+    blocks->apply_dirichlet(*structure_field()->get_dbc_map_extractor()->cond_map(), true);
+    // blocks->apply_dirichlet(*(dbcmaps_->cond_map()), true);
+  }
 
   // get ale matrix
   const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocka =
@@ -673,8 +694,22 @@ void FSI::SlidingMonolithicStructureSplit::setup_system_matrix(
   std::shared_ptr<Core::LinAlg::SparseMatrix> mortarp = coupsfm_->get_mortar_matrix_p();
 
   // get single field block matrices
-  const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> s =
-      structure_field()->block_system_matrix();
+  std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> s = nullptr;
+  if (use_old_structure_)
+  {
+    s = structure_field()->block_system_matrix();
+  }
+  else
+  {
+    // get structure matrix
+    const std::shared_ptr<const Core::LinAlg::SparseMatrix> sparse_matrix_solid =
+        structure_field()->system_matrix();
+    // convert sparse matrix to block sparse matrix
+    // const std::shared_ptr<const Core::LinAlg::BlockSparseMatrixBase> blocks =
+    s = Core::LinAlg::copy_sparse_to_block_sparse_matrix(
+        *sparse_matrix_solid, *structure_field()->interface(), *structure_field()->interface());
+  }
+
   const std::shared_ptr<Core::LinAlg::SparseMatrix> f = fluid_field()->system_matrix();
   const std::shared_ptr<Core::LinAlg::BlockSparseMatrixBase> a = ale_field()->block_system_matrix();
 
@@ -1290,12 +1325,15 @@ void FSI::SlidingMonolithicStructureSplit::output()
   }
   ale_field()->output();
 
-  if (structure_field()->get_constraint_manager()->have_monitor())
+  if (use_old_structure_)
   {
-    structure_field()->get_constraint_manager()->compute_monitor_values(
-        *structure_field()->dispnp());
-    if (Core::Communication::my_mpi_rank(comm_) == 0)
-      structure_field()->get_constraint_manager()->print_monitor_values();
+    if (structure_field()->get_constraint_manager()->have_monitor())
+    {
+      structure_field()->get_constraint_manager()->compute_monitor_values(
+          *structure_field()->dispnp());
+      if (Core::Communication::my_mpi_rank(comm_) == 0)
+        structure_field()->get_constraint_manager()->print_monitor_values();
+    }
   }
 }
 
@@ -1429,7 +1467,8 @@ void FSI::SlidingMonolithicStructureSplit::recover_lagrange_multiplier()
   std::shared_ptr<Core::LinAlg::Vector<double>> structureresidual =
       std::make_shared<Core::LinAlg::Vector<double>>(
           *structure_field()->interface()->extract_fsi_cond_vector(*structure_field()->rhs()));
-  structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
+  if (use_old_structure_)
+    structureresidual->scale(-1.0);  // invert sign to obtain residual, not rhs
   tmpvec = std::make_shared<Core::LinAlg::Vector<double>>(*structureresidual);
   // ---------End of term (3)
 
diff --git a/tests/input_files/fsi_dc_mono_fs_ga_ga.4C.yaml b/tests/input_files/fsi_dc_mono_fs_ga_ga.4C.yaml
index 1c48c1ca7c0..d73f059f89f 100644
--- a/tests/input_files/fsi_dc_mono_fs_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_fs_ga_ga.4C.yaml
@@ -13,6 +13,7 @@ IO:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_fs_ost_ga_eos.4C.yaml b/tests/input_files/fsi_dc_mono_fs_ost_ga_eos.4C.yaml
index a5282d9bf74..5f5009cdb0b 100644
--- a/tests/input_files/fsi_dc_mono_fs_ost_ga_eos.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_fs_ost_ga_eos.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_fs_ost_ga_rsb.4C.yaml b/tests/input_files/fsi_dc_mono_fs_ost_ga_rsb.4C.yaml
index 486c86e12ab..6015dd97739 100644
--- a/tests/input_files/fsi_dc_mono_fs_ost_ga_rsb.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_fs_ost_ga_rsb.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_mtrfs_ost_ga.4C.yaml b/tests/input_files/fsi_dc_mono_mtrfs_ost_ga.4C.yaml
index aa5e78f8e07..d7669b90e67 100644
--- a/tests/input_files/fsi_dc_mono_mtrfs_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_mtrfs_ost_ga.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_mtrss_ost_ga.4C.yaml b/tests/input_files/fsi_dc_mono_mtrss_ost_ga.4C.yaml
index 994a4f5fd34..42ec76ca427 100644
--- a/tests/input_files/fsi_dc_mono_mtrss_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_mtrss_ost_ga.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_slfs_msht.4C.yaml b/tests/input_files/fsi_dc_mono_slfs_msht.4C.yaml
index 381569de45c..44cbede7fab 100644
--- a/tests/input_files/fsi_dc_mono_slfs_msht.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_slfs_msht.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_slfs_ost_ga.4C.yaml b/tests/input_files/fsi_dc_mono_slfs_ost_ga.4C.yaml
index f5c1406f46d..350c06cdbb6 100644
--- a/tests/input_files/fsi_dc_mono_slfs_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_slfs_ost_ga.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_slss_msht.4C.yaml b/tests/input_files/fsi_dc_mono_slss_msht.4C.yaml
index d7c92d6142f..8bc5ef631ef 100644
--- a/tests/input_files/fsi_dc_mono_slss_msht.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_slss_msht.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
@@ -139,7 +140,7 @@ RESULT DESCRIPTION:
       NODE: 37
       QUANTITY: "lambdax"
       VALUE: -0.0004106354936504455
-      TOLERANCE: 1e-11
+      TOLERANCE: 1e-10
   - FSI:
       NODE: 37
       QUANTITY: "lambday"
diff --git a/tests/input_files/fsi_dc_mono_slss_ost_ga.4C.yaml b/tests/input_files/fsi_dc_mono_slss_ost_ga.4C.yaml
index 6f91de54bee..1c5cacdf954 100644
--- a/tests/input_files/fsi_dc_mono_slss_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_slss_ost_ga.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_ss_ost_ga_eos.4C.yaml b/tests/input_files/fsi_dc_mono_ss_ost_ga_eos.4C.yaml
index 571b703994b..bfb3bb3f40c 100644
--- a/tests/input_files/fsi_dc_mono_ss_ost_ga_eos.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_ss_ost_ga_eos.4C.yaml
@@ -11,6 +11,7 @@ PROBLEM SIZE:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_dc_mono_ss_ost_ga_rsb.4C.yaml b/tests/input_files/fsi_dc_mono_ss_ost_ga_rsb.4C.yaml
index e94f9e31b6f..7862efa900b 100644
--- a/tests/input_files/fsi_dc_mono_ss_ost_ga_rsb.4C.yaml
+++ b/tests/input_files/fsi_dc_mono_ss_ost_ga_rsb.4C.yaml
@@ -13,6 +13,7 @@ IO:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_fs_bdf2_ga.4C.yaml b/tests/input_files/fsi_fp_mono_fs_bdf2_ga.4C.yaml
index f6e9cb185b1..faa52cc1280 100644
--- a/tests/input_files/fsi_fp_mono_fs_bdf2_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_fs_bdf2_ga.4C.yaml
@@ -45,6 +45,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "TangDis"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_fs_bdf2_ost.4C.yaml b/tests/input_files/fsi_fp_mono_fs_bdf2_ost.4C.yaml
index 337e28cd7f1..db54fcf64b5 100644
--- a/tests/input_files/fsi_fp_mono_fs_bdf2_ost.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_fs_bdf2_ost.4C.yaml
@@ -45,6 +45,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
diff --git a/tests/input_files/fsi_fp_mono_fs_ga_ga.4C.yaml b/tests/input_files/fsi_fp_mono_fs_ga_ga.4C.yaml
index 3d079d6965d..d577f5bad8d 100644
--- a/tests/input_files/fsi_fp_mono_fs_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_fs_ga_ga.4C.yaml
@@ -45,6 +45,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 SOLVER 1:
diff --git a/tests/input_files/fsi_fp_mono_fs_ost_ga.4C.yaml b/tests/input_files/fsi_fp_mono_fs_ost_ga.4C.yaml
index 97a39cacb86..ea6628bd7d6 100644
--- a/tests/input_files/fsi_fp_mono_fs_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_fs_ost_ga.4C.yaml
@@ -43,6 +43,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_fs_ost_ost.4C.yaml b/tests/input_files/fsi_fp_mono_fs_ost_ost.4C.yaml
index 117daff1881..5d97d377a65 100644
--- a/tests/input_files/fsi_fp_mono_fs_ost_ost.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_fs_ost_ost.4C.yaml
@@ -45,6 +45,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
diff --git a/tests/input_files/fsi_fp_mono_mtrfs_ga_ga.4C.yaml b/tests/input_files/fsi_fp_mono_mtrfs_ga_ga.4C.yaml
index f34de4ecf0e..30e0930613f 100644
--- a/tests/input_files/fsi_fp_mono_mtrfs_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrfs_ga_ga.4C.yaml
@@ -47,6 +47,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 SOLVER 1:
diff --git a/tests/input_files/fsi_fp_mono_mtrfs_ga_ga_sp.4C.yaml b/tests/input_files/fsi_fp_mono_mtrfs_ga_ga_sp.4C.yaml
index 5adc028e3ac..010519ab57f 100644
--- a/tests/input_files/fsi_fp_mono_mtrfs_ga_ga_sp.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrfs_ga_ga_sp.4C.yaml
@@ -48,6 +48,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 SOLVER 1:
diff --git a/tests/input_files/fsi_fp_mono_mtrfs_ost_ga.4C.yaml b/tests/input_files/fsi_fp_mono_mtrfs_ost_ga.4C.yaml
index feb8e03489c..98bd02268e9 100644
--- a/tests/input_files/fsi_fp_mono_mtrfs_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrfs_ost_ga.4C.yaml
@@ -45,6 +45,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_mtrfs_ost_ga_sp.4C.yaml b/tests/input_files/fsi_fp_mono_mtrfs_ost_ga_sp.4C.yaml
index 488ef79d700..ea6af9a46a9 100644
--- a/tests/input_files/fsi_fp_mono_mtrfs_ost_ga_sp.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrfs_ost_ga_sp.4C.yaml
@@ -45,6 +45,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_mtrss_ga_ga.4C.yaml b/tests/input_files/fsi_fp_mono_mtrss_ga_ga.4C.yaml
index e6de57af4ee..1f36156bac4 100644
--- a/tests/input_files/fsi_fp_mono_mtrss_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrss_ga_ga.4C.yaml
@@ -50,6 +50,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_mtrss_ost_ga.4C.yaml b/tests/input_files/fsi_fp_mono_mtrss_ost_ga.4C.yaml
index c31fe96d758..6abf169835c 100644
--- a/tests/input_files/fsi_fp_mono_mtrss_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_mtrss_ost_ga.4C.yaml
@@ -43,6 +43,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_ss_bdf2_ga.4C.yaml b/tests/input_files/fsi_fp_mono_ss_bdf2_ga.4C.yaml
index ff92175d783..822accec9ec 100644
--- a/tests/input_files/fsi_fp_mono_ss_bdf2_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_ss_bdf2_ga.4C.yaml
@@ -46,6 +46,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_fp_mono_ss_bdf2_ost.4C.yaml b/tests/input_files/fsi_fp_mono_ss_bdf2_ost.4C.yaml
index dbc9b94d58b..9636bf4bb6b 100644
--- a/tests/input_files/fsi_fp_mono_ss_bdf2_ost.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_ss_bdf2_ost.4C.yaml
@@ -45,6 +45,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
diff --git a/tests/input_files/fsi_fp_mono_ss_ga_ga.4C.yaml b/tests/input_files/fsi_fp_mono_ss_ga_ga.4C.yaml
index 9e2f65dcbc9..2436e861fff 100644
--- a/tests/input_files/fsi_fp_mono_ss_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_ss_ga_ga.4C.yaml
@@ -53,6 +53,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 SOLVER 1:
diff --git a/tests/input_files/fsi_fp_mono_ss_ost_ga.4C.yaml b/tests/input_files/fsi_fp_mono_ss_ost_ga.4C.yaml
index cdd004cf5ee..37fd845f4f7 100644
--- a/tests/input_files/fsi_fp_mono_ss_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_ss_ost_ga.4C.yaml
@@ -34,6 +34,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstVel"
   LINEAR_SOLVER: 1
 SOLVER 1:
diff --git a/tests/input_files/fsi_fp_mono_ss_ost_ost.4C.yaml b/tests/input_files/fsi_fp_mono_ss_ost_ost.4C.yaml
index f4a8f7a2782..8b5fb9ca4aa 100644
--- a/tests/input_files/fsi_fp_mono_ss_ost_ost.4C.yaml
+++ b/tests/input_files/fsi_fp_mono_ss_ost_ost.4C.yaml
@@ -33,6 +33,7 @@ FSI DYNAMIC/MONOLITHIC SOLVER:
 PROBLEM TYPE:
   PROBLEMTYPE: "Fluid_Structure_Interaction"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   PREDICT: "ConstAcc"
   LINEAR_SOLVER: 1
diff --git a/tests/input_files/fsi_pw_mono_fs_ga_ga.4C.yaml b/tests/input_files/fsi_pw_mono_fs_ga_ga.4C.yaml
index a91ba08c29c..512b4459b7a 100644
--- a/tests/input_files/fsi_pw_mono_fs_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_fs_ga_ga.4C.yaml
@@ -15,6 +15,7 @@ DISCRETISATION:
 MESH PARTITIONING:
   MIN_ELE_PER_PROC: 800
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_fs_ga_ga_contact.4C.yaml b/tests/input_files/fsi_pw_mono_fs_ga_ga_contact.4C.yaml
index dff88b62999..b270b4fe5f2 100644
--- a/tests/input_files/fsi_pw_mono_fs_ga_ga_contact.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_fs_ga_ga_contact.4C.yaml
@@ -16,6 +16,7 @@ IO:
   STRUCT_STRESS: "Cauchy"
   STRUCT_STRAIN: "GL"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_fs_ga_ga_muelu.4C.yaml b/tests/input_files/fsi_pw_mono_fs_ga_ga_muelu.4C.yaml
index 7dc98a6ae5f..8d57811dbf6 100644
--- a/tests/input_files/fsi_pw_mono_fs_ga_ga_muelu.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_fs_ga_ga_muelu.4C.yaml
@@ -15,6 +15,7 @@ IO:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_fs_ost_ga.4C.yaml b/tests/input_files/fsi_pw_mono_fs_ost_ga.4C.yaml
index 81419b946e6..d58cd87b2c7 100644
--- a/tests/input_files/fsi_pw_mono_fs_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_fs_ost_ga.4C.yaml
@@ -13,6 +13,7 @@ PROBLEM TYPE:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_ss_ga_ga.4C.yaml b/tests/input_files/fsi_pw_mono_ss_ga_ga.4C.yaml
index 865412609b0..5dc66d0c345 100644
--- a/tests/input_files/fsi_pw_mono_ss_ga_ga.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_ss_ga_ga.4C.yaml
@@ -15,6 +15,7 @@ IO:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_ss_ga_ga_muelu.4C.yaml b/tests/input_files/fsi_pw_mono_ss_ga_ga_muelu.4C.yaml
index f5d1b406b5d..979afd00959 100644
--- a/tests/input_files/fsi_pw_mono_ss_ga_ga_muelu.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_ss_ga_ga_muelu.4C.yaml
@@ -15,6 +15,7 @@ IO:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_ss_ost_ga.4C.yaml b/tests/input_files/fsi_pw_mono_ss_ost_ga.4C.yaml
index 3e74d766204..76b09ba2335 100644
--- a/tests/input_files/fsi_pw_mono_ss_ost_ga.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_ss_ost_ga.4C.yaml
@@ -13,6 +13,7 @@ PROBLEM TYPE:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_pw_mono_ss_ost_ga_muelu.4C.yaml b/tests/input_files/fsi_pw_mono_ss_ost_ga_muelu.4C.yaml
index b897cce04a9..e7b197ef997 100644
--- a/tests/input_files/fsi_pw_mono_ss_ost_ga_muelu.4C.yaml
+++ b/tests/input_files/fsi_pw_mono_ss_ost_ga_muelu.4C.yaml
@@ -13,6 +13,7 @@ PROBLEM TYPE:
 DISCRETISATION:
   NUMTHERMDIS: 0
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   PREDICT: "ConstDisVelAcc"
   LINEAR_SOLVER: 1
 STRUCTURAL DYNAMIC/GENALPHA:
diff --git a/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidcurr.4C.yaml b/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidcurr.4C.yaml
index 9ef0fd04372..f8ba37530e0 100644
--- a/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidcurr.4C.yaml
+++ b/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidcurr.4C.yaml
@@ -20,6 +20,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
   GHOSTING_STRATEGY: "redundant_all"
   PARALLEL_REDIST: "None"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   STC_LAYER: 2
   PREDICT: "ConstDisVelAcc"
diff --git a/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidrot.4C.yaml b/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidrot.4C.yaml
index 6dd861f936b..2ffc3ecebd7 100644
--- a/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidrot.4C.yaml
+++ b/tests/input_files/fsi_ves_mono_mtrfs_ost_ost_slidrot.4C.yaml
@@ -19,6 +19,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
   GHOSTING_STRATEGY: "redundant_all"
   PARALLEL_REDIST: "None"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   TOLDISP: 1e-06
   NORM_DISP: "Mix"
diff --git a/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidcurr.4C.yaml b/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidcurr.4C.yaml
index b46dd143673..eb76e01f799 100644
--- a/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidcurr.4C.yaml
+++ b/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidcurr.4C.yaml
@@ -20,6 +20,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
   GHOSTING_STRATEGY: "redundant_all"
   PARALLEL_REDIST: "None"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   STC_LAYER: 2
   PREDICT: "ConstDisVelAcc"
diff --git a/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidrot.4C.yaml b/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidrot.4C.yaml
index 836378a8822..4a743f37d8f 100644
--- a/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidrot.4C.yaml
+++ b/tests/input_files/fsi_ves_mono_mtrss_ost_ost_slidrot.4C.yaml
@@ -22,6 +22,7 @@ MORTAR COUPLING/PARALLEL REDISTRIBUTION:
   GHOSTING_STRATEGY: "redundant_all"
   PARALLEL_REDIST: "None"
 STRUCTURAL DYNAMIC:
+  INT_STRATEGY: "Standard"
   DYNAMICTYPE: "OneStepTheta"
   STC_LAYER: 2
   PREDICT: "ConstDisVelAcc"