Merge pull request #25 from precice/precice-v3-update

Make adapter compatible with preCICE v3.0.0

Author: MakisH

cht/adapter.comm

@@ -47,7 +47,8 @@ adapter = Adapter(preciceConfigFile,
 BCs = [{'CHARGE': bc} for bc in BC]
 LOADS = BCs + adapter.LOADS
 
-dt = adapter.initialize(INIT_T)
+adapter.initialize(INIT_T)
+dt = adapter.getMaxTimeStepSize()
 
 # ==========================================================================================
 # ==========================================================================================
@@ -127,7 +128,8 @@ while adapter.isCouplingOngoing():
         )
 
     adapter.writeCouplingData(T)
-    dt = adapter.advance()
+    adapter.advance()
+    dt = adapter.getMaxTimeStepSize()
     adapter.readCheckpoint()
 
     if adapter.isCouplingTimestepComplete():

cht/adapter.py

@@ -20,8 +20,7 @@ def __init__(self, preciceConfigFile, participantName, config, MESH, MODEL, MAT,
 		self.LOADS = []
 		self.isNonLinear = isNonLinear
 		self.participantName = participantName
-		self.preciceDt = -1
-		self.precice = precice.Interface(participantName, preciceConfigFile, 0, 1)
+		self.precice = precice.Participant(participantName, preciceConfigFile, 0, 1)
 		self.configure(config)
 
 	def configure(self, config):
@@ -40,48 +39,44 @@ def configure(self, config):
 			self.interfaces.append(interface)
 
 	def initialize(self, INIT_T):
-
-		self.preciceDt = self.precice.initialize()
-		if self.precice.is_action_required(precice.action_write_initial_data()):
+		if self.precice.requires_initial_data():
 			self.writeCouplingData(INIT_T)
-			self.precice.fulfilled_action(precice.action_write_initial_data())
-
-		self.precice.initialize_data()
-		return self.preciceDt
+		self.precice.initialize()
 
 	def isCouplingOngoing(self):
 		return self.precice.is_coupling_ongoing()
 
 	def writeCouplingData(self, TEMP):
-		if self.precice.is_write_data_required(self.preciceDt):
-			for interface in self.interfaces:
-				interface.writeBCs(TEMP)
+		for interface in self.interfaces:
+			interface.writeBCs(TEMP)
 
 	def readCouplingData(self):
-		if self.precice.is_read_data_available():
-			for interface in self.interfaces:
-				interface.readAndUpdateBCs()
+		for interface in self.interfaces:
+			interface.readAndUpdateBCs()
 
 	def writeCheckpoint(self):
-		if self.precice.is_action_required(precice.action_write_iteration_checkpoint()):
+		if self.precice.requires_writing_checkpoint():
 			# Do nothing
-			self.precice.fulfilled_action(precice.action_write_iteration_checkpoint())
+			pass
 
 	def readCheckpoint(self):
-		if self.precice.is_action_required(precice.action_read_iteration_checkpoint()):
+		if self.precice.requires_reading_checkpoint():
 			# Do nothing
-			self.precice.fulfilled_action(precice.action_read_iteration_checkpoint())
+			pass
 
 	def isCouplingTimestepComplete(self):
 		return self.precice.is_time_window_complete()
 
 	def advance(self):
-		self.preciceDt = self.precice.advance(self.preciceDt)
-		return self.preciceDt
+		dt = self.precice.get_max_time_step_size()
+		self.precice.advance(dt)
 
 	def finalize(self):
 		self.precice.finalize()
 
+	def getMaxTimeStepSize(self):
+		return self.precice.get_max_time_step_size()
+
 
 class Interface:
 	def __init__(self, precice, participantName, names, MESH, SHMESH, MODEL, MAT, isNonLinear = False):
@@ -108,16 +103,9 @@ def __init__(self, precice, participantName, names, MESH, SHMESH, MODEL, MAT, is
 		self.preciceNodeIndices = []
 		self.preciceFaceCenterIndices = []
 
-		self.preciceFaceCentersMeshID = 0
-		self.preciceNodesMeshID = 0
+		self.readData = dict()
 
-		self.readHCoeffDataID = 0
-		self.readTempDataID = 0
-		self.writeHCoeffDataID = 0
-		self.writeTempDataID = 0
-
-		self.writeTemp = []
-		self.writeHCoeff = []
+		self.writeDataNames = []
 
 		self.MESH = MESH
 		# Shifted mesh (contains only the interface, and is shifted by delta in the direction opposite to the normal)
@@ -142,7 +130,14 @@ def configure(self, names):
 
 		self.computeNormals()
 
-		dims = self.precice.get_dimensions()
+		nodes_mesh_dims = self.precice.get_mesh_dimensions(self.nodesMeshName)
+		face_centers_mesh_dims = self.precice.get_mesh_dimensions(self.faceCentersMeshName)
+
+		if nodes_mesh_dims != face_centers_mesh_dims:
+			raise ValueError("Dimensions of the read mesh and the write mesh do not match")
+		else:
+			# Set dimensions to nodes mesh dimensions
+			dims = nodes_mesh_dims
 
 		self.nodeCoordinates = np.array([p for p in self.SHMESH.sdj.COORDO.VALE.get()])
 		self.nodeCoordinates = np.resize(self.nodeCoordinates, (int(len(self.nodeCoordinates)/dims), dims))
@@ -153,7 +148,7 @@ def configure(self, names):
 		self.faceCenterCoordinates = np.array([np.array([self.mesh.cn[node] for node in elem]).mean(0) for elem in self.connectivity])
 		self.setVertices()
 
-		self.setDataIDs(names)
+		self.setDataNames(names)
 
 	def computeNormals(self):
 		# Get normals at the nodes
@@ -173,43 +168,35 @@ def computeNormals(self):
 		)
 		self.normals = N.EXTR_COMP().valeurs
 
-		dims = self.precice.get_dimensions()
+		dims = self.precice.get_mesh_dimensions(self.nodesMeshName)
 
 		self.normals = np.resize(np.array(self.normals), (int(len(self.normals)/dims), dims))
 		DETRUIRE(CONCEPT=({"NOM": N}, {"NOM": DUMMY}))
 
 	def setVertices(self):
 		# Nodes
-		self.preciceNodesMeshID = self.precice.get_mesh_id(self.nodesMeshName)
-		self.preciceNodeIndices = self.precice.set_mesh_vertices(self.preciceNodesMeshID,  self.nodeCoordinates)
+		self.preciceNodeIndices = self.precice.set_mesh_vertices(self.nodesMeshName,  self.nodeCoordinates)
 		# Face centers
-		self.preciceFaceCentersMeshID = self.precice.get_mesh_id(self.faceCentersMeshName)
-		self.preciceFaceCenterIndices = self.precice.set_mesh_vertices(self.preciceFaceCentersMeshID, self.faceCenterCoordinates)
+		self.preciceFaceCenterIndices = self.precice.set_mesh_vertices(self.faceCentersMeshName, self.faceCenterCoordinates)
 
-	def setDataIDs(self, names):
+	def setDataNames(self, names):
 		for writeDataName in names["write-data"]:
-			if writeDataName.find("Heat-Transfer-Coefficient-") >= 0:
-				self.writeHCoeffDataID = self.precice.get_data_id(writeDataName, self.preciceNodesMeshID)
-			elif writeDataName.find("Sink-Temperature-") >= 0:
-				self.writeTempDataID = self.precice.get_data_id(writeDataName, self.preciceNodesMeshID)
+			if writeDataName.find("Heat-Transfer-Coefficient-Solid") >= 0:
+				self.writeDataNames.append(writeDataName)
+			elif writeDataName.find("Sink-Temperature-Solid") >= 0:
+				self.writeDataNames.append(writeDataName)
 		for readDataName in names["read-data"]:
-			if readDataName.find("Heat-Transfer-Coefficient-") >= 0:
-				self.readHCoeffDataID = self.precice.get_data_id(readDataName, self.preciceFaceCentersMeshID)
-			elif readDataName.find("Sink-Temperature-") >= 0:
-				self.readTempDataID = self.precice.get_data_id(readDataName, self.preciceFaceCentersMeshID)
+			if readDataName.find("Heat-Transfer-Coefficient-Fluid") >= 0:
+				self.readData[readDataName] = None
+			elif readDataName.find("Sink-Temperature-Fluid") >= 0:
+				self.readData[readDataName] = None
 
 	def getPreciceNodeIndices(self):
 		return self.preciceNodeIndices
 
 	def getPreciceFaceCenterIndices(self):
 		return self.preciceFaceCenterIndices
 
-	def getPreciceNodesMeshID(self):
-		return self.preciceNodesMeshID
-
-	def getPreciceFaceCentersMeshID(self):
-		return self.preciceFaceCentersMeshID
-
 	def getNodeCoordinates(self):
 		return self.nodeCoordinates
 
@@ -245,14 +232,17 @@ def updateBCs(self, temp, hCoeff):
 					1)
 
 	def readAndUpdateBCs(self):
-		readHCoeff = self.precice.read_block_scalar_data(self.readHCoeffDataID,  self.preciceFaceCenterIndices)
-		readTemp = self.precice.read_block_scalar_data(self.readTempDataID,  self.preciceFaceCenterIndices)
-		self.updateBCs(readTemp, readHCoeff)
+		dt = self.precice.get_max_time_step_size()
+		for name in self.readData.keys():
+			self.readData[name] = self.precice.read_data(self.faceCentersMeshName, name, self.preciceFaceCenterIndices, dt)
+
+		self.updateBCs(self.readData["Sink-Temperature-Fluid"], self.readData["Heat-Transfer-Coefficient-Fluid"])
 
 	def writeBCs(self, TEMP):
 		writeTemp, writeHCoeff = self.getBoundaryValues(TEMP)
-		self.precice.write_block_scalar_data(self.writeHCoeffDataID, self.preciceNodeIndices, writeHCoeff)
-		self.precice.write_block_scalar_data(self.writeTempDataID,  self.preciceNodeIndices, writeTemp)
+
+		self.precice.write_data(self.nodesMeshName, self.writeDataNames[0], self.preciceNodeIndices, writeHCoeff)
+		self.precice.write_data(self.nodesMeshName, self.writeDataNames[1],  self.preciceNodeIndices, writeTemp)
 
 	def getBoundaryValues(self, T):
 
@@ -271,7 +261,7 @@ def setLoad(self, LOAD):
 		self.LOAD = LOAD
 
 	def shiftMesh(self):
-		dims = self.precice.get_dimensions()
+		dims = self.precice.get_mesh_dimensions(self.nodesMeshName)
 		coords = [p for p in self.SHMESH.sdj.COORDO.VALE.get()]
 		for i in range(len(self.normals)):
 			for c in range(dims):