[Core] Neighbor MPC Assigner: A process and utility for assigning MPCs to neighbouring nodes #11083

SADPR · 2023-05-05T09:01:40Z

DESCRIPTION:

Utility:

This pull request adds a new class that provides a method to search for neighboring nodes of a given nodes structure within a specified radius and assign a multipoint constraint (MPC). The MPC weights are calculated based on a spatial function that employs radial basis functions.

Process:

This pull request enhances the functionality of the master-slave MPC algorithm by facilitating the discovery of neighboring nodes in a master model part within a designated radius for each node in the slave model part. The process involves the following steps:

For each node in the slave model part, the utility searches for neighboring nodes in the master model part within a specified radius.
The utility then establishes an MPC between the slave node and its neighboring master nodes, and calculates the MPC weights based on a spatial function that employs radial basis functions.
The process repeats for all nodes in the slave model part.

Added files:

assign_mpcs_to_neighbours_utility.cpp: This file contains all the functions to look for neighboring nodes and apply multipoint constraints (MPCs) using radial basis functions.
assign_mpcs_to_neighbours_utility.h: This header file defines the functions and data structures used in assign_mpcs_to_neighbours_utility.cpp`.
assign_mpcs_to_neighbours_process.py: This Python script calls the functions in assign_mpcs_to_neighbours_utility.cpp in the appropriate order to assign MPCs to neighboring nodes.
assign_mpcs_to_neighbours_process.mdpa: This is an MDPA file used for testing the MPC algorithm.

Modified files:

add_geometrical_utilities_to_python.cpp: This file was modified to export the functions in assign_mpcs_to_neighbours_utility.cpp to Python, so that they can be called from assign_mpcs_to_neighbours_process.py.
test_processes.py: This file was modified to include a small test to validate the functionality of assign_mpcs_to_neighbours_process.py.

It is currently done in serial.

It worked when using vector variable, e.g. VELOCITY

loumalouomega · 2023-05-05T09:04:23Z

@KratosMultiphysics/altair and specially @ddiezrod

loumalouomega · 2023-05-05T09:17:36Z

kratos/python_scripts/assign_mpcs_to_neighbours_process.py

+        for constraint in self.computing_model_part.MasterSlaveConstraints:
+            constraint.Set(KM.TO_ERASE)


Use VariableUtils

loumalouomega · 2023-05-05T09:18:56Z

...s/tests/auxiliar_files_for_python_unittest/mdpa_files/assign_mpcs_to_neighbours_process.mdpa

@@ -0,0 +1,3308 @@
+Begin Properties 0


Please, can you consider a smaller mesh?, you can put this one in the Example repository

loumalouomega · 2023-05-05T09:20:51Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    ModelPart::MasterSlaveConstraintType const& r_clone_constraint = KratosComponents<MasterSlaveConstraint>::Get("LinearMasterSlaveConstraint");
+
+    #pragma omp parallel


Please ParallelUtilities

loumalouomega · 2023-05-05T09:21:10Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+DofPointerVectorType& rCloud_of_dofs,
+array_1d<double,3>& rSlave_coordinates
+){
+KRATOS_TRY;


Tabs missing (spaces)

loumalouomega · 2023-05-05T09:21:29Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+Matrix& rCloud_of_nodes_coordinates
+)
+{
+KRATOS_TRY;


Tabs missing (spaces)

loumalouomega · 2023-05-05T09:21:52Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+)
+{
+//TODO: Do it in parallel
+KRATOS_TRY;


Tabs missing (spaces)

loumalouomega

Some comments

SADPR · 2023-05-05T09:47:57Z

I will use a smaller mesh for the test and update to Parallel Utilities.
I will upload this case to the Kratos Examples.

loumalouomega · 2023-05-05T09:53:48Z

I cannot unsee:

…Assign_MPCs

rubenzorrilla · 2023-05-05T16:10:07Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+        Matrix r_cloud_of_nodes_coordinates;
+        array_1d<double,3> r_slave_coordinates;
+        GetDofsAndCoordinatesForNode(pNode, rVariable, r_slave_dof, r_slave_coordinates);
+        KRATOS_WATCH(i)


Suggested change

KRATOS_WATCH(i)

Debugging leftover.

Way slower than OMP and I couldn't manage to do the omp critical for adding the MPCs.

SADPR · 2023-05-07T12:30:23Z

I've been trying to switch from OMP to block_for_each the implementation, and I did the following tests to have a counter "i" that could be thread-safe. The reason for using the "i" counter is to avoid repeating an MPC's Id.

Using std::atomic<int>: This test showed repeating values in some threads, which means it's not thread-safe in this case.
Using std::atomic_flag: This test showed repeating values in some threads as well, indicating it's not thread-safe either.
Using a std::mutex with std::lock_guard: This test worked correctly but was around 50 times slower than using pragma omp.
Using a std::mutex with std::unique_lock: This test did not work, as it resulted in repeating values in some threads.
Using #pragma omp parallel for: This test worked correctly and was faster than using std::mutex with std::lock_guard.

Overall, it seems like using std::mutex with std::lock_guard is the only method that worked correctly for this particular use case, but it comes with a significant performance penalty. The pragma omp approach was faster, but you mentioned you wanted to avoid using OpenMP.

For the current implementation, I kept the original code using #pragma omp in the function AssignMPCsToNodes, and I added the implementation with block_for_each (std::mutex and std::lock_guard) in the function AssignMPCsToNodesParallelUtilities. Additionally, I have tried to use the KRATOS_CRITICAL_SECTION as a replacement for the #pragma omp critical section in order to add the MPCs thread-safely, but I haven't been successful yet. I am still looking for a way to substitute the OMP critical section for adding the MPCs thread-safely. If you can point me in the right direction, it would be greatly appreciated.

rubenzorrilla · 2023-05-10T08:18:49Z

kratos/utilities/assign_mpcs_to_neighbours_utility.h

+       * @param RotationMatrix 3x3 rotation matrix to be applied to the nodes' positions.
+       **/
+      void AssignRotationToNodes(
+          NodesContainerType pNodes,


This should be a reference. Indeed it is strange to me that this works if you pass it by copy...

Not used anymore.

rubenzorrilla · 2023-05-10T08:19:42Z

kratos/utilities/assign_mpcs_to_neighbours_utility.h

+
+      // Search for the neighbouring nodes (in rStructureNodes) of each rNode on a given array of rNodes
+      void SearchNodesInRadiusForNodes(
+          NodesContainerType const& rNodes,


Though it is valid, in Kratos we normally put the const in front.

rubenzorrilla · 2023-05-10T08:20:45Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+// Search for the neighbouring nodes (in rStructureNodes) of each rNode on a given array of rNodes
+void AssignMPCsToNeighboursUtility::SearchNodesInRadiusForNodes(
+    NodesContainerType const& rNodes,


Normally in Kratos we put the const in front.

rubenzorrilla · 2023-05-10T08:21:25Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    VectorResultNodesContainerType& rResults,
+    const double MinNumOfNeighNodes)


It is a good programming practice to put the results arguments after the input (const ones).

rubenzorrilla · 2023-05-10T08:21:42Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    const double MinNumOfNeighNodes)
+{
+    KRATOS_TRY;
+    NodesContainerType::ContainerType& nodes_array     = const_cast<NodesContainerType::ContainerType&>(rNodes.GetContainer());


auto& r_nodes_array

And why you need the const_cast?

Resolved, changed to:

KRATOS_TRY; auto& r_nodes_array = rNodes.GetContainer(); rResults.resize(r_nodes_array.size()); // Declare a counter variable outside the loop as std::atomic<int> std::atomic<int> i(0); block_for_each(r_nodes_array, [&](const Node<3>::Pointer& pNode) {

rubenzorrilla · 2023-05-10T08:22:57Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    block_for_each(nodes_array, [&](Node<3>::Pointer& pNode)
+    {
+        double localRadius = Radius;


Please follow the style guide (local_radius).

rubenzorrilla · 2023-05-10T08:24:25Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    KRATOS_TRY;
+    NodesContainerType::ContainerType& nodes_array     = const_cast<NodesContainerType::ContainerType&>(rNodes.GetContainer());
+
+    rResults.resize(nodes_array.size());


This means you're allocating much memory than needed. I'd do a shrink_to_fit at the end of this function to avoid so.

I am allocating what I need. Nonetheless, I could updated it to this:

// Resize rResults vector rResults.resize(r_nodes_array.size()); // Declare a counter variable outside the loop as std::atomic<int> std::atomic<int> i(0); block_for_each(r_nodes_array, [&](const Node<3>::Pointer& pNode) { double local_radius = Radius; IndexType it = i.fetch_add(1); // Atomically increment the counter and get the previous value while (rResults[it].size()<MinNumOfNeighNodes){ rResults[it].clear(); SearchNodesInRadiusForNode(pNode, local_radius, rResults[it]); local_radius += Radius; } }); // Optimize memory usage rResults.shrink_to_fit();

No. You are allocating much more than what you need since you're resizing the vector to the number of nodes, which would only be the case if all the nodes are found. Indeed, the proper usage would be

rResults.reserve(r_nodes_array.size()); // ... your stuff in here ... rResults.shrink_to_fit();

I am changing the names of the functions to make them more self-explanatory. In this function, we retrieve the degrees of freedom (DOFs) and coordinates of the cloud of nodes. Therefore, we already know the size.

rubenzorrilla · 2023-05-10T08:26:06Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+//Search for the neighbouring nodes (in rStructureNodes) of the given rNode
+void AssignMPCsToNeighboursUtility::SearchNodesInRadiusForNode(
+    NodeType::Pointer pNode,


I'd pass a constant reference instead. Note that the SearchInRadius supports it.

Do you find it necesarry, since this is a constant pointer. Isn't it okay like this?

I don't think it is a constant pointer but nevermind, leave it like this.

rubenzorrilla · 2023-05-10T08:28:17Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    if (ComponentIndex < 3) {
+        std::string component_variable_name = rVectorVariable.Name() + component_suffixes[ComponentIndex];
+        return KratosComponents<Variable<double>>::Get(component_variable_name);


This is extremely expensive and being done, if I'm not wrong, inside a loop. An alternative approach must be used.

After a long afternoon, I managed to do it. Now it only acces the Kratos components once and has a pointer in the loop.

rubenzorrilla · 2023-05-10T08:29:30Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    rCloud_of_dofs.push_back(pNode->pGetDof(rVariable));
+    rSlave_coordinates = pNode->Coordinates();


I don't see the point on doing a function of two lines. IMO it only makes more complex browsing the code with no advantage at all.

It is to preserve similarity. Is it really necessary to undo this function? I know it is not typical to have a two line function, but for me, it preserves similarity.

I don't get your point on "similarity"... I'd remove it but if you really require it leave it. Up to you.

rubenzorrilla · 2023-05-10T08:30:19Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    if (pNode->HasDofFor(GetComponentVariable(rVariable, 0)) &&
+        pNode->HasDofFor(GetComponentVariable(rVariable, 1)) &&
+        pNode->HasDofFor(GetComponentVariable(rVariable, 2))) {


What would happen in the 2D case in which the third component DOF might not be present?

Is this really something that happens?
The user can also specify ["DISPLACEMENT_X","DISPLACEMENT_Y"].

I thought the 2D also 3 components. But solves only for X and Y components.

Depends on the implementation so you cannot take it as granted.

rubenzorrilla · 2023-05-10T08:30:43Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    DofPointerVectorType& rCloud_of_dofs_x,
+    DofPointerVectorType& rCloud_of_dofs_y,
+    DofPointerVectorType& rCloud_of_dofs_z,
+    array_1d<double,3>& rSlave_coordinates


Please follow the style guide for function arguments.

rubenzorrilla · 2023-05-10T08:31:57Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+
+void AssignMPCsToNeighboursUtility::GetDofsAndCoordinatesForNodes(
+    ResultNodesContainerType nodes_array,


Why passing by copy?

rubenzorrilla · 2023-05-10T08:37:25Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    rCloud_of_dofs_x.resize(nodes_array.size());
+    rCloud_of_dofs_y.resize(nodes_array.size());
+    rCloud_of_dofs_z.resize(nodes_array.size());
+    rCloud_of_nodes_coordinates.resize(nodes_array.size(), 3);


I'd try to shrink these containers afterwards.

(same reseve and shrink_to_fit comment).

rubenzorrilla · 2023-05-10T08:38:02Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+        // Check if the node has the required DOFs
+        if (pNode->HasDofFor(GetComponentVariable(rVariable, 0)) &&
+            pNode->HasDofFor(GetComponentVariable(rVariable, 1)) &&
+            pNode->HasDofFor(GetComponentVariable(rVariable, 2))) {


Same comment about the 2D third component.

rubenzorrilla · 2023-05-10T08:38:19Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+{
+    //TODO: Do it in parallel
+    KRATOS_TRY;
+    NodesContainerType::ContainerType& nodes_array     = const_cast<NodesContainerType::ContainerType&>(pNodes.GetContainer());


auto& r_nodes_array

Why the const_cast?

rubenzorrilla · 2023-05-10T08:39:36Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    // Assign rotation to given nodes
+    for(unsigned int i = 0; i < nodes_array.size(); i++){
+        auto coordinate_vector = nodes_array[i]->GetInitialPosition().Coordinates();


You are allocating/deallocating an unnecessary copy for each node.

rubenzorrilla · 2023-05-10T08:39:55Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    // Assign rotation to given nodes
+    for(unsigned int i = 0; i < nodes_array.size(); i++){
+        auto coordinate_vector = nodes_array[i]->GetInitialPosition().Coordinates();
+        Vector rotated_position(coordinate_vector.size());


Can't this be an array_1d<double,3>?

rubenzorrilla · 2023-05-10T08:42:40Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+        nodes_array[i]->X() = rotated_position[0];
+        nodes_array[i]->Y() = rotated_position[1];
+        nodes_array[i]->Z() = rotated_position[2];


noalias(nodes_array[i]->Coordinates()) = rotated_position; I think this should work.

rubenzorrilla · 2023-05-10T08:44:49Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+void AssignMPCsToNeighboursUtility::AssignMPCsToNodes(
+    NodesContainerType pNodes,
+    double const Radius,
+    ModelPart& rComputingModelPart,
+    const Variable<array_1d<double, 3>>& rVariable,
+    double const MinNumOfNeighNodes
+    )


This is basically copy & paste of the above function but modifying the section in which the Master-Slave Constraints are created. I'd do the creation within a private auxiliary function and have a unique implementation of AssignMPCsToNodes.

I have a concern here, at first I though of the user passing a variable which could be either array_1d or double.
If array_1d, then you have to create the variable components lists, etc. If double, you can directly retrieve the varible with GetDof. Now I am thinking to always create a list of variables, e.g, if ["VELOCITY","PRESSURE], then create a list:
["DISPLACEMENT_X","DISPLACEMENT_Y","PRESSURE"] for 2D.
Or:
["DISPLACEMENT_X","DISPLACEMENT_Y","DISPLACEMENT_Z","PRESSURE"] for 3D.
We can discuss this in person, since it is taking a lot of time.

rubenzorrilla · 2023-05-10T08:45:52Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    // Add the constraints to the rComputingModelPart in a single call
+    rComputingModelPart.AddMasterSlaveConstraints(temp_constraints.begin(), temp_constraints.end());
+
+    KRATOS_INFO("AssignMPCsToNeighboursUtility") << "Build and Assign MPCs Time: " << build_and_assign_mpcs.ElapsedSeconds() << std::endl;


This may result in a too verbose output. If you want to output this, I'd introduce an echo level.

rubenzorrilla · 2023-05-10T08:47:14Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    BuiltinTimer build_and_assign_mpcs;
+
+    int prev_num_mpcs = rComputingModelPart.NumberOfMasterSlaveConstraints();


In here you are assuming that your new MPCs are not interacting with previous ones. Though this might be a valid assumption, I'd throw a warning message if the previous number of MPCs is non-zero to inform about this.

rubenzorrilla · 2023-05-10T08:47:27Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    int prev_num_mpcs = rComputingModelPart.NumberOfMasterSlaveConstraints();
+
+    NodesContainerType::ContainerType& nodes_array = const_cast<NodesContainerType::ContainerType&>(pNodes.GetContainer());


auto& r_nodes_array.

rubenzorrilla · 2023-05-10T08:47:44Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+
+    NodesContainerType::ContainerType& nodes_array = const_cast<NodesContainerType::ContainerType&>(pNodes.GetContainer());
+
+    ModelPart::MasterSlaveConstraintType const& r_clone_constraint = KratosComponents<MasterSlaveConstraint>::Get("LinearMasterSlaveConstraint");


const auto& r_clone_constraint`.

rubenzorrilla · 2023-05-10T08:48:58Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+        DofPointerVectorType r_cloud_of_dofs, r_slave_dof;
+        Matrix r_cloud_of_nodes_coordinates;
+        array_1d<double, 3> r_slave_coordinates;


You're allocating/deallocating these for each node. Declare them as a TLS outside the loop.

Master-Slave constraints require rSlaveDofs to be a DofPointerVectorType. To do r_slave_dofs thread_local I need to resize and assign to Dof::Pointer. Or:
rCloudOfDofs.resize(1);
rCloudOfDofs[0] = pNode->pGetDof(rVariable);
Which I dont like. I will fix it.

rubenzorrilla · 2023-05-10T08:51:11Z

kratos/tests/test_processes.py

+        list_of_processes = process_factory.KratosProcessFactory(current_model).ConstructListOfProcesses(settings["process_list"])
+        for process in list_of_processes:
+            process.ExecuteInitialize()
+            process.ExecuteInitializeSolutionStep()


You have a unique process. I don't see the point on doing it with a list. I'd directly call the constructor.

rubenzorrilla · 2023-05-10T08:52:05Z

kratos/tests/test_processes.py

+                    for ew, ow in zip(expected_weights, obtained_weights):
+                        self.assertAlmostEqual(ew, ow, delta=1e-6)  # Assert the weights are equal within the specified tolerance


If I'm not wrong, there is an assertAlmostEqualVector or something of this sort.

assertVectorAlmostEqual

rubenzorrilla

Though this is a working implementation, I think it doesn't suffice the quality requirements for being in the KratosCore. I hope you take my comments into consideration in a new PR.

rubenzorrilla · 2023-05-10T08:56:28Z

kratos/utilities/assign_mpcs_to_neighbours_utility.cpp

+    KRATOS_CATCH("");
+}
+
+void AssignMPCsToNeighboursUtility::AssignRotationToNodes(


This is not used anywhere in this process. Besides, it is a custom function for your target application. Long story short, it must be removed from here to be placed somewhere else.

SADPR added 4 commits May 3, 2023 11:32

Working Assign MPCs to niehgbors process and utility

ab3e90a

It is currently done in serial.

Cleaned. Not working in parallel.

972bd21

It worked when using vector variable, e.g. VELOCITY

Working in parallel.

d835ee6

Added test.

dac5244

SADPR requested a review from a team as a code owner May 5, 2023 09:01

loumalouomega changed the title ~~Neighbor MPC Assigner: A process and utility for assigning MPCs to neighboring nodes~~ [Core] Neighbor MPC Assigner: A process and utility for assigning MPCs to neighbouring nodes May 5, 2023

loumalouomega added Enhancement Kratos Core labels May 5, 2023

Minor changes

f04237a

loumalouomega reviewed May 5, 2023

View reviewed changes

loumalouomega requested changes May 5, 2023

View reviewed changes

Missing spaces

a9d8ef9

SADPR added 3 commits May 5, 2023 16:13

Changed to VariabelUtils.

17b817e

Merge remote-tracking branch 'origin/Kratos_Assign_MPCs' into Kratos_…

3b128f9

…Assign_MPCs

Changing to Parallel Utilities. It will fail. This is not ready.

e6e963f

rubenzorrilla reviewed May 5, 2023

View reviewed changes

SADPR added 4 commits May 5, 2023 18:23

Not working properly. Trying to incorporate KRATOS_CRITICAL_SECTION.

e0372b0

Updated header file.

4c86d7a

Added Parallel Utilities with std::mutex and std::lock_guard. Too slow.

5bf4382

Way slower than OMP and I couldn't manage to do the omp critical for adding the MPCs.

Updated the python file to use the ParallelUtilities function.

b1a9ae6

Minor change for importing to python (Name update).

1266811

rubenzorrilla reviewed May 10, 2023

View reviewed changes

SADPR mentioned this pull request May 15, 2023

Kratos Master-Slave Constraints to Neighbours Process and Utility #11129

Merged

		for constraint in self.computing_model_part.MasterSlaveConstraints:
		constraint.Set(KM.TO_ERASE)


		ModelPart::MasterSlaveConstraintType const& r_clone_constraint = KratosComponents<MasterSlaveConstraint>::Get("LinearMasterSlaveConstraint");

		#pragma omp parallel

		VectorResultNodesContainerType& rResults,
		const double MinNumOfNeighNodes)

		rCloud_of_dofs.push_back(pNode->pGetDof(rVariable));
		rSlave_coordinates = pNode->Coordinates();



		void AssignMPCsToNeighboursUtility::GetDofsAndCoordinatesForNodes(
		ResultNodesContainerType nodes_array,


		BuiltinTimer build_and_assign_mpcs;

		int prev_num_mpcs = rComputingModelPart.NumberOfMasterSlaveConstraints();


		int prev_num_mpcs = rComputingModelPart.NumberOfMasterSlaveConstraints();

		NodesContainerType::ContainerType& nodes_array = const_cast<NodesContainerType::ContainerType&>(pNodes.GetContainer());

		for ew, ow in zip(expected_weights, obtained_weights):
		self.assertAlmostEqual(ew, ow, delta=1e-6) # Assert the weights are equal within the specified tolerance

[Core] Neighbor MPC Assigner: A process and utility for assigning MPCs to neighbouring nodes #11083

[Core] Neighbor MPC Assigner: A process and utility for assigning MPCs to neighbouring nodes #11083

Conversation

SADPR commented May 5, 2023

DESCRIPTION:

loumalouomega commented May 5, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

loumalouomega May 5, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

loumalouomega left a comment

Choose a reason for hiding this comment

SADPR commented May 5, 2023

loumalouomega commented May 5, 2023

Choose a reason for hiding this comment

SADPR commented May 7, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

rubenzorrilla May 10, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

rubenzorrilla left a comment

Choose a reason for hiding this comment

rubenzorrilla May 10, 2023 • edited Loading

Choose a reason for hiding this comment

loumalouomega May 5, 2023 •

edited

Loading

rubenzorrilla May 10, 2023 •

edited

Loading

rubenzorrilla May 10, 2023 •

edited

Loading