Functionality for volumetric coupling on quadrature points of a mesh

CHANGELOG.md

@@ -10,6 +10,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Added
 
+- Added preliminary functionality to support volumetric coupling by extracting integration points from an element mesh ([#146](https://github.com/precice/calculix-adapter/pull/146)).
 - Extended velocities writing for the 2D3D case ([#137](https://github.com/precice/calculix-adapter/pull/137)).
 - Added Ubuntu 24.04 to the CI ([#140](https://github.com/precice/calculix-adapter/pull/140)).
 

Makefile

@@ -78,7 +78,7 @@ SCCXMAIN = ccx_$(CCX_VERSION).c
 
 # Append additional sources
 SCCXC += nonlingeo_precice.c dyna_precice.c CCXHelpers.c PreciceInterface.c
-SCCXF += getflux.f getkdeltatemp.f
+SCCXF += getflux.f getkdeltatemp.f getelementgausspointcoords.f
 
 
 

adapter/CCXHelpers.c

@@ -68,6 +68,16 @@ void getSurfaceElementsAndFaces(ITG setID, ITG *ialset, ITG *istartset, ITG *ien
   }
 }
 
+void getElementsIDs(ITG setID, ITG *ialset, ITG *istartset, ITG *iendset, ITG *elements)
+{
+  ITG i, k = 0;
+
+  for (i = istartset[setID] - 1; i < iendset[setID]; i++) {
+    elements[k] = ialset[i];
+    k++;
+  }
+}
+
 void getNodeCoordinates(ITG *nodes, ITG numNodes, int dim, double *co, double *v, int mt, double *coordinates)
 {
 
@@ -219,15 +229,6 @@ void getHexaFaceCenters(ITG *elements, ITG *faces, ITG numElements, ITG *kon, IT
   }
 }
 
-/*
-   void getSurfaceGaussPoints(int setID, ITG * co, ITG istartset, ITG iendset, ITG * ipkon, ITG * lakon, ITG * kon, ITG * ialset, double * coords) {
-
-        int iset = setID + 1; // plus one because of fortran indices
-        FORTRAN(getgausspointscoords,(co,&iset,istartset,iendset,ipkon,lakon,kon,ialset, coords));
-
-   }
- */
-
 void getTetraFaceNodes(ITG *elements, ITG *faces, ITG *nodes, ITG numElements, ITG numNodes, ITG *kon, ITG *ipkon, int *tetraFaceNodes)
 {
   // Assume all tetra elements -- maybe implement checking later...

adapter/CCXHelpers.h

@@ -91,6 +91,16 @@ ITG getSetID(char const *setName, char const *set, ITG nset);
  */
 ITG getNumSetElements(ITG setID, ITG *istartset, ITG *iendset);
 
+/**
+ * @brief Gets the element IDs given a set ID
+ * @param setID: input set id
+ * @param ialset: CalculiX variable
+ * @param istartset: CalculiX variable
+ * @param iendset: CalculiX variable
+ * @param elements: output element IDs
+ */
+void getElementsIDs(ITG setID, ITG *ialset, ITG *istartset, ITG *iendset, ITG *elements);
+
 /**
  * @brief Gets the element and face IDs given a set ID
  * @param setID: input set id

adapter/ConfigReader.cpp

@@ -55,6 +55,10 @@ void ConfigReader_Read(char const *configFilename, char const *participantName,
       interface.facesMeshName = NULL;
     }
 
+    if (config["participants"][participantName]["interfaces"][i].contains("elements-mesh")) {
+      interface.elementsMeshName = strdup(config["participants"][participantName]["interfaces"][i]["elements-mesh"].get_value<std::string>().c_str());
+    }
+
     if (config["participants"][participantName]["interfaces"][i].contains("mesh")) {
       interface.facesMeshName = strdup(config["participants"][participantName]["interfaces"][i]["mesh"].get_value<std::string>().c_str());
     }

adapter/ConfigReader.h

@@ -13,6 +13,7 @@
 typedef struct InterfaceConfig {
   char * facesMeshName;
   char * nodesMeshName;
+  char * elementsMeshName;
   char * patchName;
   int    map;
   int    numWriteData;

adapter/PreciceInterface.c

@@ -450,8 +450,8 @@ void Precice_FreeData(SimulationData *sim)
 void PreciceInterface_Create(PreciceInterface *interface, SimulationData *sim, InterfaceConfig const *config)
 {
   // Deduce configured dimensions
-  if (config->nodesMeshName == NULL && config->facesMeshName == NULL) {
-    printf("ERROR: You need to define either a face or a nodes mesh. Check the adapter configuration file.\n");
+  if (config->nodesMeshName == NULL && config->facesMeshName == NULL && config->elementsMeshName == NULL) {
+    printf("ERROR: You need to define either a face, nodes, or elements mesh. Check the adapter configuration file.\n");
     exit(EXIT_FAILURE);
   }
   if (config->nodesMeshName && config->facesMeshName) {
@@ -479,6 +479,8 @@ void PreciceInterface_Create(PreciceInterface *interface, SimulationData *sim, I
 
   // Initialize pointers as NULL
   interface->elementIDs            = NULL;
+  interface->elemIPID              = NULL;
+  interface->elemIPCoordinates     = NULL;
   interface->faceIDs               = NULL;
   interface->faceCenterCoordinates = NULL;
   interface->preciceFaceCenterIDs  = NULL;
@@ -551,6 +553,14 @@ void PreciceInterface_Create(PreciceInterface *interface, SimulationData *sim, I
     interface->couplingMeshName = interface->faceCentersMeshName;
   }
 
+  // Element mesh
+  interface->elementsMeshName = NULL;
+  if (config->elementsMeshName) {
+    interface->elementsMeshName = strdup(config->elementsMeshName);
+    PreciceInterface_ConfigureElementsMesh(interface, sim);
+    interface->couplingMeshName = interface->elementsMeshName;
+  }
+
   PreciceInterface_ConfigureCouplingData(interface, sim, config);
 }
 
@@ -573,6 +583,51 @@ static enum ElemType findSimulationMeshType(SimulationData *sim)
   return INVALID_ELEMENT;
 }
 
+void PreciceInterface_ConfigureElementsMesh(PreciceInterface *interface, SimulationData *sim)
+{
+  printf("WARNING: Elements-mesh support is experimental. Use with caution.\n");
+  fflush(stdout);
+
+  char *elementSetName    = interface->name;
+  interface->elementSetID = getSetID(elementSetName, sim->set, sim->nset);
+  interface->numElements  = getNumSetElements(interface->elementSetID, sim->istartset, sim->iendset);
+
+  interface->elementIDs = malloc(interface->numElements * sizeof(ITG));
+  getElementsIDs(interface->elementSetID, sim->ialset, sim->istartset, sim->iendset, interface->elementIDs);
+
+  interface->numIPTotal        = sim->mi[0] * interface->numElements; // Number of Gauss points per element * number of elements
+  interface->elemIPCoordinates = malloc(interface->numIPTotal * 3 * sizeof(double));
+
+  interface->elemIPID = malloc(interface->numIPTotal * sizeof(int));
+  for (int j = 0; j < interface->numIPTotal; j++) {
+    interface->elemIPID[j] = j;
+  }
+
+  int numElements = interface->numElements;
+
+  enum ElemType elemType = findSimulationMeshType(sim);
+
+  // Gauss point extraction is supported only for tetrahedra and hexahedra elements.
+  int nodesPerElement;
+  if (elemType == TETRAHEDRA) {
+    nodesPerElement = 4;
+  } else if (elemType == HEXAHEDRA) {
+    nodesPerElement = 8;
+  } else {
+    supportedElementError();
+  }
+
+  FORTRAN(getelementgausspointcoords, (&numElements,
+                                       interface->elementIDs,
+                                       &nodesPerElement,
+                                       sim->co,
+                                       sim->kon,
+                                       sim->ipkon,
+                                       interface->elemIPCoordinates));
+
+  precicec_setMeshVertices(interface->elementsMeshName, interface->numIPTotal, interface->elemIPCoordinates, interface->elemIPID);
+}
+
 void PreciceInterface_ConfigureFaceCentersMesh(PreciceInterface *interface, SimulationData *sim)
 {
   // printf("Entering ConfigureFaceCentersMesh \n");
@@ -811,7 +866,10 @@ void PreciceInterface_FreeData(PreciceInterface *preciceInterface)
   free(preciceInterface->readData);
   free(preciceInterface->writeData);
   free(preciceInterface->elementIDs);
+  free(preciceInterface->elemIPID);
+  free(preciceInterface->elemIPCoordinates);
   free(preciceInterface->faceIDs);
+  free(preciceInterface->nodeIDs);
   free(preciceInterface->preciceFaceCenterIDs);
   free(preciceInterface->faceCenterCoordinates);
   free(preciceInterface->nodeCoordinates);
@@ -833,6 +891,7 @@ void PreciceInterface_FreeData(PreciceInterface *preciceInterface)
   // Mesh names
   free(preciceInterface->faceCentersMeshName);
   free(preciceInterface->nodesMeshName);
+  free(preciceInterface->elementsMeshName);
 
   // Data names
   free(preciceInterface->displacementDeltas);

adapter/PreciceInterface.h

@@ -33,10 +33,15 @@ typedef struct PreciceInterface {
   int          nodeSetID;
   int *        preciceNodeIDs;
   char *       nodesMeshName;
+  char *       elementsMeshName;
 
-  // Interface face elements
   int     numElements;
   int *   elementIDs;
+  int *   elemIPID;
+  int     elementSetID;
+  double *elemIPCoordinates;
+  int     numIPTotal;
+
   int *   faceIDs;
   double *faceCenterCoordinates;
   int     faceSetID;
@@ -277,6 +282,13 @@ void sendFaceCentersVertices(PreciceInterface *interface);
  */
 void PreciceInterface_ConfigureNodesMesh(PreciceInterface *interface, SimulationData *sim);
 
+/**
+ * @brief Configures the elements mesh and calls setMeshVertices on preCICE
+ * @param interface
+ * @param sim: Structure with CalculiX data
+ */
+void PreciceInterface_ConfigureElementsMesh(PreciceInterface *interface, SimulationData *sim);
+
 /**
  * @brief Terminate execution if the nodes mesh ID is not valid
  * @param interface

docs/configure.md

@@ -27,11 +27,19 @@ precice-config-file: ../precice-config.xml
 The adapter allows us to use several participants in one simulation (e.g., several instances of Calculix if several solid objects are taken into account). The name of the participant `Calculix` must match the specification of the participant on the command line when running the executable of `CCX` with the adapter being used (this is described later). Also, the name must be the same as the one used in the preCICE configuration file `precice-config.xml`.  
 
 One participant may have several coupling interfaces. Note that each interface specification starts with a dash.
-Depending on the data you need to read and write, the interface should define either a `faces-mesh` (or `mesh` as a synonym) where the data points are centers of faces (computed by the adapter) or a mesh made of CalculiX vertices, with the keyword `nodes-mesh`. An interface made of faces should be defined in the CalculiX case using the `*SURFACE` command, whereas meshes with nodes should define these nodes using `*NSET`. Using the wrong family of mesh (e.g. reading forces on faces) throws an error. If you need both kinds of meshes, you should define more than one interface.
+Depending on the data you need to read and write, the interface should define a mesh of the following types
+
+* a `faces-mesh` (or `mesh` as a synonym) where the data points are centers of faces (computed by the adapter). An interface made of faces should be defined in the CalculiX case using the `*SURFACE` command.
+* a `nodes-mesh` where the data points are the nodal vertices. An interface made of nodes should define these nodes using `*NSET`.
+* a `elements-mesh` where the data points are the quadrature points of the elements of a mesh. The mesh should be defined by nodes using `*NEST`. **Note**: `elements-mesh` is still experimental.
+
+Using the wrong family of mesh (e.g. reading forces on faces) throws an error. If you need both kinds of meshes, you should define more than one interface.
 
 For FSI simulations the mesh type of an interface is always `nodes-mesh`, as forces and displacement are defined on nodes. The name of this mesh, `Calculix_Mesh`, must match the mesh name given in the preCICE configuration file. In CHT simulations, `faces-meshes` are usually chosen, as they are needed to apply heat fluxes or convective heat transfer.
 For defining which nodes of the CalculiX domain belong to the FSI interface, a node set needs to be defined in the CalculiX input files. The name of this node set must match the name of the patch (here: "interface").  
 
+For multiscale mechanics simulations, the mesh type is always `elements-mesh`. The stresses, strains, and the material stiffness are defined on the quadrature points.
+
 In the current FSI example, the adapter reads forces from preCICE and feeds displacement deltas (not absolute displacements, but the change of the displacements relative to the last time step) to preCICE. This is defined with the keywords `read-data` and `write-data`, respectively. The names (here: `Forces` and `DisplacementDeltas`) again need to match the specifications in the preCICE configuration file. In the current example, the coupled fluid solver expects displacement deltas instead of displacements. However, the adapter is capable of writing either type. Just use `write-data: [Displacements]` for absolute displacements rather than relative changes being transferred in each time step. Valid `readData` keywords in CalculiX are:
 
 On faces-mesh:
@@ -146,6 +154,8 @@ The preCICE CalculiX adapter should support most elements when using `nodes-mesh
 
 When using face meshes, only tetrahedra and hexahedra are supported.
 
+When using `elements-mesh`, linear tetrahedral (C3D4) and hexahedral (C3D8) elements are supported.
+
 ### Coupling to 2D simulations
 
 The adapter supports quasi 2D simulations when the z-direction is ignored. If you set the preCICE interface dimension to 2, the adapter will map data from the CalculiX 3D simulation to 2D space and vice-versa. The 3D simulation should be made of solid elements (or shells) of unit thickness.

docs/overview.md

@@ -32,7 +32,7 @@ Compatibility with preCICE:
 
 ## History
 
-The adapter was initially developed for conjugate heat transfer (CHT) simulations via preCICE by Lucia Cheung in the scope of her master’s thesis[^1], in cooperation with [SimScale](https://www.simscale.com/). For running the adapter for CHT simulations refer to this thesis. The adapter was extended to fluid-structure interaction by Alexander Rusch[^2].
+The adapter was initially developed for conjugate heat transfer (CHT) simulations via preCICE by Lucia Cheung in the scope of her master’s thesis[^1], in cooperation with [SimScale](https://www.simscale.com/). For running the adapter for CHT simulations refer to this thesis. The adapter was extended to fluid-structure interaction by Alexander Rusch[^2]. The adapter was further extended for volumetric coupling by Ibrahim Kaleel and Ishaan Desai.
 
 ## References
 

getelementgausspointcoords.f

@@ -0,0 +1,113 @@
+!
+!     CalculiX - A 3-dimensional finite element program
+!              Copyright (C) 1998-2015 Guido Dhondt
+!
+!     This program is free software; you can redistribute it and/or
+!     modify it under the terms of the GNU General Public License as
+!     published by the Free Software Foundation(version 2);
+!     
+!
+!     This program is distributed in the hope that it will be useful,
+!     but WITHOUT ANY WARRANTY; without even the implied warranty of 
+!     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
+!     GNU General Public License for more details.
+!
+!     You should have received a copy of the GNU General Public License
+!     along with this program; if not, write to the Free Software
+!     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+!
+!     This function is a copy of the function for calculation and printout of the lift and drag forces
+!
+!     Computes the physical coordinates of the Gauss/integration points
+!     of a set of elements. Supports either C3D4 (tetrahedra, 1 GP) or
+!     C3D8 (hexahedra, 8 GP) elements, selected via the "nope" argument
+!     (number of nodes per element: 4 or 8).
+!
+      subroutine getelementgausspointcoords(nelem, elem_ids, nope,
+     &    co, kon, ipkon, elem_gp_coord)
+
+         implicit none
+
+         !Input/Output variables
+         integer     :: nelem            ! Number of elements
+         integer     :: elem_ids(*)      ! Element IDs, need to be adjusted for Fortran
+         integer     :: nope             ! Nodes per element: 4 (C3D4) or 8 (C3D8)
+         real(8)     :: co(3,*)          ! Nodal coordinates of all nodes
+         integer     :: kon(*)
+         integer     :: ipkon(*)
+
+         real(8)     :: elem_gp_coord(*) ! GP coords
+
+         ! Internal variables
+         integer(4)     :: iel, el_id, indexe, i, j, k, l
+         integer(4)     :: iflag, idx, konl(8), gp_id, ngp
+         real(8)        :: xl(3,8), xi, et, ze, xsj, shp(4,20)
+
+         include "gauss.f"
+
+         data iflag /1/
+
+         ! Number of Gauss points per element: 1 for tetrahedra, 8 for hexahedra
+         if (nope .eq. 4) then
+            ngp = 1
+         else
+            ngp = 8
+         end if
+
+         ! Initialize gauss point coordinates to zero
+         do l = 1, nelem*ngp*3
+            elem_gp_coord(l) = 0.0
+         end do
+
+         do iel = 1, nelem
+            el_id = elem_ids(iel)
+
+            indexe=ipkon(el_id)
+
+            ! connectivity + local nodal coordinates
+            do i = 1, nope
+               konl(i)=kon(indexe+i)
+               do j = 1, 3
+                  xl(j,i)=co(j,konl(i))
+               end do
+            end do
+
+            ! Loop through gauss points of each element
+            do gp_id = 1, ngp
+
+               if (nope .eq. 4) then
+                  ! gauss3d4: tet, 1 integration point
+                  xi = gauss3d4(1,gp_id)
+                  et = gauss3d4(2,gp_id)
+                  ze = gauss3d4(3,gp_id)
+
+                  call shape4tet(xi,et,ze,xl,xsj,shp,iflag)
+               else
+                  ! gauss3d2: hex, 2-point integration (8 integration points)
+                  xi = gauss3d2(1,gp_id)
+                  et = gauss3d2(2,gp_id)
+                  ze = gauss3d2(3,gp_id)
+
+                  call shape8h(xi,et,ze,xl,xsj,shp,iflag)
+               end if
+
+               ! Calculate the Gauss point coordinates
+               ! Note: indexed by the loop counter (iel), not the element ID
+               ! (el_id), since elem_gp_coord is a compact buffer holding only
+               ! the "nelem" elements of this interface, in the order given by
+               ! elem_ids.
+               do k = 1, 3
+                  idx = (iel - 1)*ngp*3 + (gp_id - 1)*3 + k
+                  do l = 1, nope
+                     elem_gp_coord(idx)=elem_gp_coord(idx)
+     &                     +xl(k,l)*shp(4,l)
+                  end do
+               end do
+
+            end do
+
+         end do
+
+         return
+
+      end subroutine getelementgausspointcoords