Merge branch 'trilinos/improvement-trilinos-space' into trilinos/use-space-refactoring

Author: loumalouomega

applications/TrilinosApplication/custom_python/add_trilinos_space_to_python.cpp

@@ -178,6 +178,26 @@ AuxiliaryVectorWrapper ReadMatrixMarketVector(TrilinosSparseSpaceType& dummy, co
     return AuxiliaryVectorWrapper(dummy.ReadMatrixMarketVector(FileName, Comm, n));
 }
 
+AuxiliaryVectorWrapper CreateVectorCopy(TrilinosSparseSpaceType& dummy, const TrilinosSparseSpaceType::VectorType& rV)
+{
+    return AuxiliaryVectorWrapper(dummy.CreateVectorCopy(rV));
+}
+
+AuxiliaryVectorWrapper CreateVector(TrilinosSparseSpaceType& dummy, TrilinosSparseSpaceType::MapPointerType& pMap)
+{
+    return AuxiliaryVectorWrapper(dummy.CreateVector(pMap));
+}
+
+AuxiliaryMatrixWrapper CreateMatrix(TrilinosSparseSpaceType& dummy, TrilinosSparseSpaceType::GraphPointerType& pGraph)
+{
+    return AuxiliaryMatrixWrapper(dummy.CreateMatrix(pGraph));
+}
+
+AuxiliaryMatrixWrapper CreateMatrixCopy(TrilinosSparseSpaceType& dummy, const TrilinosSparseSpaceType::MatrixType& rA)
+{
+    return AuxiliaryMatrixWrapper(dummy.CreateMatrixCopy(rA));
+}
+
 Epetra_FECrsMatrix& GetMatRef(AuxiliaryMatrixWrapper& dummy)
 {
     return dummy.GetReference();
@@ -363,6 +383,10 @@ void  AddBasicOperations(pybind11::module& m)
     .def("ScaleAndAdd", ScaleAndAdd)
     .def("CreateEmptyMatrixPointer", CreateEmptyMatrixPointer)
     .def("CreateEmptyVectorPointer", CreateEmptyVectorPointer)
+    .def("CreateVectorCopy", CreateVectorCopy)
+    .def("CreateVector", CreateVector)
+    .def("CreateMatrix", CreateMatrix)
+    .def("CreateMatrixCopy", CreateMatrixCopy)
     .def("ReadMatrixMarketMatrix", ReadMatrixMarketMatrix)
     .def("ReadMatrixMarketVector", ReadMatrixMarketVector)
     .def("WriteMatrixMarketMatrix", WriteMatrixMarketMatrixHelper)

applications/TrilinosApplication/tests/cpp_tests/test_trilinos_space.cpp

@@ -760,7 +760,6 @@ KRATOS_TEST_CASE_IN_SUITE(TrilinosMatrixMarketVector, KratosTrilinosApplicationM
     }
 }
 
-
 KRATOS_TEST_CASE_IN_SUITE(TrilinosIsDistributedSpace, KratosTrilinosApplicationMPITestSuite)
 {
     KRATOS_EXPECT_TRUE(TrilinosSparseSpaceType::IsDistributedSpace());
@@ -950,6 +949,49 @@ KRATOS_TEST_CASE_IN_SUITE(TrilinosCreateVectorCopy, KratosTrilinosApplicationMPI
     TrilinosCPPTestUtilities::CheckSparseVectorFromLocalVector(*p_copy, local_vector);
 }
 
+KRATOS_TEST_CASE_IN_SUITE(TrilinosCreateVector, KratosTrilinosApplicationMPITestSuite)
+{
+    const auto& r_comm = Testing::GetDefaultDataCommunicator();
+    const int size = 2 * r_comm.Size();
+    auto raw_mpi_comm = MPIDataCommunicator::GetMPICommunicator(r_comm);
+    TrilinosSparseSpaceType::CommunicatorType epetra_comm(raw_mpi_comm);
+    auto p_map = Kratos::make_shared<TrilinosSparseSpaceType::MapType>(size, 0, epetra_comm);
+    auto p_vec = TrilinosSparseSpaceType::CreateVector(p_map);
+    KRATOS_EXPECT_FALSE(TrilinosSparseSpaceType::IsNull(p_vec));
+    KRATOS_EXPECT_EQ(static_cast<std::size_t>(size), TrilinosSparseSpaceType::Size(*p_vec));
+}
+
+KRATOS_TEST_CASE_IN_SUITE(TrilinosCreateMatrix, KratosTrilinosApplicationMPITestSuite)
+{
+    const auto& r_comm = Testing::GetDefaultDataCommunicator();
+    const int size = 2 * r_comm.Size();
+    auto matrix = TrilinosCPPTestUtilities::GenerateDummySparseMatrix(r_comm, size);
+    // Build a graph from the existing matrix and use CreateMatrix
+    auto p_graph = Kratos::make_shared<TrilinosSparseSpaceType::GraphType>(matrix.Graph());
+    auto p_new_matrix = TrilinosSparseSpaceType::CreateMatrix(p_graph);
+    KRATOS_EXPECT_FALSE(TrilinosSparseSpaceType::IsNull(p_new_matrix));
+    KRATOS_EXPECT_EQ(TrilinosSparseSpaceType::Size1(matrix), TrilinosSparseSpaceType::Size1(*p_new_matrix));
+    KRATOS_EXPECT_EQ(TrilinosSparseSpaceType::Size2(matrix), TrilinosSparseSpaceType::Size2(*p_new_matrix));
+}
+
+KRATOS_TEST_CASE_IN_SUITE(TrilinosCreateMatrixCopy, KratosTrilinosApplicationMPITestSuite)
+{
+    const auto& r_comm = Testing::GetDefaultDataCommunicator();
+    const int size = 2 * r_comm.Size();
+    auto matrix = TrilinosCPPTestUtilities::GenerateDummySparseMatrix(r_comm, size);
+    auto p_copy = TrilinosSparseSpaceType::CreateMatrixCopy(matrix);
+    // Sizes must match
+    KRATOS_EXPECT_EQ(TrilinosSparseSpaceType::Size1(matrix), TrilinosSparseSpaceType::Size1(*p_copy));
+    KRATOS_EXPECT_EQ(TrilinosSparseSpaceType::Size2(matrix), TrilinosSparseSpaceType::Size2(*p_copy));
+    // Frobenius norms must match
+    KRATOS_EXPECT_NEAR(TrilinosSparseSpaceType::TwoNorm(matrix),
+                       TrilinosSparseSpaceType::TwoNorm(*p_copy), 1.0e-12);
+    // Copy must be independent: zeroing the original does not affect the copy
+    const double original_norm = TrilinosSparseSpaceType::TwoNorm(*p_copy);
+    TrilinosSparseSpaceType::SetToZero(matrix);
+    KRATOS_EXPECT_NEAR(TrilinosSparseSpaceType::TwoNorm(*p_copy), original_norm, 1.0e-12);
+}
+
 KRATOS_TEST_CASE_IN_SUITE(TrilinosCreateEmptyPointerWithComm, KratosTrilinosApplicationMPITestSuite)
 {
     const auto& r_comm = Testing::GetDefaultDataCommunicator();

applications/TrilinosApplication/tests/cpp_tests/trilinos_cpp_test_utilities.h

@@ -187,8 +187,8 @@ class TrilinosCPPTestUtilities
     * @param rRowIndexes The row indices
     * @param rColumnIndexes The column indices
     * @param rValues The values
-    * @param PrintValues If printing the vectors, for debugging pourposes
-    * @param IncludeHardZeros If including the hard zeros (giving  a cerain threshold)
+    * @param PrintValues If printing the vectors, for debugging purposes
+    * @param IncludeHardZeros If including the hard zeros (giving  a certain threshold)
     */
     static void GenerateSparseMatrixIndexAndValuesVectors(
         const TrilinosSparseSpaceType::MatrixType& rA,

applications/TrilinosApplication/trilinos_space.h

@@ -264,9 +264,43 @@ class TrilinosSpace
      * @param src The source vector
      * @return Shared pointer to a deep copy of src
      */
-    static VectorPointerType CreateVectorCopy(const VectorType& src)
+    static VectorPointerType CreateVectorCopy(const VectorType& rVector)
     {
-        return VectorPointerType(new VectorType(src));
+        return VectorPointerType(new VectorType(rVector));
+    }
+
+    /**
+     * @brief Creates a VectorType from a given Epetra map.
+     * @param pMap The Epetra map to construct the vector from
+     * @return Shared pointer to the newly created vector
+     */
+    static VectorPointerType CreateVector(const MapPointerType& pMap)
+    {
+        return VectorPointerType(new VectorType(*pMap));
+    }
+
+    /**
+     * @brief Creates a MatrixType from a given Epetra CRS graph.
+     * @param pGraph The Epetra CRS graph to construct the matrix from
+     * @return Shared pointer to the newly created matrix
+     */
+    static MatrixPointerType CreateMatrix(const GraphPointerType& pGraph)
+    {
+        return MatrixPointerType(new TMatrixType(::Copy, *pGraph));
+    }
+
+    /**
+     * @brief Creates a deep copy of a matrix.
+     * @details Constructs a new matrix with the same sparsity pattern and values
+     *          as @p rMatrix using the existing CopyMatrixValues helper.
+     * @param rMatrix The source matrix to copy
+     * @return Shared pointer to the new matrix
+     */
+    static MatrixPointerType CreateMatrixCopy(const MatrixType& rMatrix)
+    {
+        auto p_copy = MatrixPointerType(new TMatrixType(::Copy, rMatrix.Graph()));
+        CopyMatrixValues(*p_copy, rMatrix);
+        return p_copy;
     }
 
     /**