Trouver le barycentre à partir des coordonnées de 4 points

C'est moins simple que certains le pensent.  Il ne s'agit pas du barycentre des 4 points, mais du barycentre du polygone délimité par les 4 points.

reste à savoir si les 4 points sont dans le plan ou pas ..

et ton barycentre:

bcx= xb0 + (Ltop ** 2 + L * (Ltop+ L/3) ) / (L + 2 * Ltop)

bcy = yb0 + H * ( Ltop + L / 3 ) / (L + 2 * Ltop)

merci beaucoup !

plus propre:

cr=[xb0+Ltop/2,yb0+H/2]
ct=[xb0+Ltop+L/3,yb0+H/3]
cb = [(cr[i]*2*Ltop+ct[i]*L)/ (L + 2 * Ltop) for i in range(len(cr))  ]

Comme je l'expliquais, dans le cas d'un polygone non convexe l'isobarycentre n'est en général pas le centre de gravité (notamment quand le polygone n'est pas convexe). Donc dans le cas général voir ce lien.

Le code python en #21 calcule le centre de gravité des 4 points, tandis qu'il cherche le centre de masse de la surface du polygone formé par ces 4 points.

J'ai bien compris yg_be, et c'est pour ça que j'ai donné dans le message #27 ce lien (qui renvoie sur ce paragraphe wikipedia), qui lui répond à la question du centre de gravité pour un polygone.

Je ne suis pas certain qu'une représentation en 2D a du sens pour un barrage.

Comment sélectionnes-tu ces 4 points?

Montre nous ton code et tes données.  Je me demande si le plus logique n'est pas de calculer la moyenne des nœuds de la maille.

# -*- coding: utf-8 -*-
"""
Created on Thu Dec  8 08:15:46 2022

@author: Pierre
"""

#importation des bibliothèque
# import numpy as np
# import matplotlib.pyplot as plt
# from mailleur import maillage

# -*- coding: utf-8 -*-
"""
Created on Thu Dec  8 08:12:05 2022

@author: Pierre
"""


import numpy as np
import matplotlib.pyplot as plt
from mailleur import maillage 


#propriété des matériaux
EBeton = 50e9
nuBeton = 0.25
rhoBeton = 2500
ESol = 100e6
nusol = 0.35
rhoSol = 1500
rhoW = 1000
g = 9.81


N = 80
#géométrie du projet
xmin, xmax = 0, 30
ymin, ymax = -10, 10
H, L, Ltop = 10, 6, 1

#position barrage
xb0 = 10
yb0 = 0

#définition des caractérisitiques du sol
Kx=1E-5 
Kz=1E-5 

#définition du nombre de noeuds
fact1 = 5
Nx=7*fact1 
Ny=5*fact1

N = 30
#taille des mailles
dX= xmax/ (Nx-1)
dY= ymax/ (Ny-1)

#Limites horizontales du barrage
i1 = round(xb0/dX)
i2 = round((xb0+L+Ltop)/dX)

#Limites horizontales du barrage
j1 = round(yb0/dY)

#frontières & maillage en éléments finis

x = np.array([xmin, xmin,xb0, xb0, xb0+Ltop, xb0+Ltop+L, xmax, xmax])
y = np.array([ymin, yb0, yb0, yb0+H, yb0+H,yb0,yb0, ymin])
xNode, yNode, connect, tri = maillage(x, y, N)


plt.figure(2)
plt.triplot(xNode, yNode, connect)

#tracé du contour du problème et des noeuds
xn1D=np.array(list(range(Nx)))*dX
yn1D=np.array(list(range(Ny)))*(-dY)
[Xnode, Ynode]=np.meshgrid(xn1D,yn1D)


plt.figure(num=1, figsize=(10, 6))
plt.clf()
plt.plot(x,y,'b--')
plt.xlabel('X (m)')
plt.ylabel('Z(m)')
plt.show()


#Remplissage de la matrice A et du vecteur B avec les bonnes expressions
#Initialisation de la matrice et du second membre à 0
A = np.zeros([Nx*Ny,Nx*Ny]) 
B = np.zeros([Nx*Ny,1]) 

H2 = ymin
Kx=1E-5 
Kz=1E-5 

#Balayage de l'ensemble des noeuds du maillage
for i in range(Nx):
    for j in range(Ny):
     #Calcul de l'indice k correspond au couple (i,j) courant
        k = (i) + Nx*(j) 
             # Série de tests permettant d'affecter à chaque noeud l'équation qui lui correspond dans la matrice et le 2nd membre
        if j==0 and i>=i2: # condition en charge à droite du barrage
            A[k,k] = 1
            B[k]   = 0
        elif j==j1 and i<=i1: # condition en charge en aval
            A[k,k] = 1
            B[k]   = H2
        elif i==0 and j>j1 and j<(Ny-1): # condition aux limites à gauche du domaine (symétrie)
            A[k,k]   =  -1
            A[k, k+1] = 1
            B[k]   =  0
        elif i==(Nx-1) and j>0 and j<(Ny-1):  # condition aux limites à droite du domaine (infini)
            A[k,k]   =  1
            A[k, k-1] = -1
            B[k] = 0            
        elif j==(Ny-1):   # condition aux limites en bas du domaine (substratum imperméable)
            A[k,k] = 1
            A[k, k-Nx] = -1
            B[k] = 0
        elif i>i1 and i<i2 and j==j1:  # condition sous le barrage
            A[k,k] = 1
            A[k, k+Nx] = -1
            B[k] = 0
        else:  # Points dans le domaine : on se sert des 4 voisins
            A[k,k] = -2*((Kz/dX**2)+(Kz/dY**2))
            A[k, k-1] = (Kx/(dX**2))
            A[k,k+1] = (Kx/(dX**2))
            A[k,k-Nx] = (Kz/(dY**2))
            A[k, k+Nx] = (Kz/(dY**2))
            B[k] = 0

#resolution proprement dite
#Resolution du Système Linéaire (méthode du pivot de Gauss inclue dans python)
H = np.linalg.inv(A) @ B


#Préparation de l'affichage des isocontours
#Matrice d'affichage
#Xplot = np.zeros([Nx,Nz])
#Zplot = np.zeros([Nx,Nz])
Hplot = np.zeros([Nx,Ny])
Vx = np.zeros([Nx,Ny])
Vz = np.zeros([Ny,Nx])
#Vf = np.zeros([Nx,Nz])

HplotT = Hplot.transpose()

for i in range(Nx):
    for j in range(Ny):
        k = i + Nx*(j) 
        Hplot[i,j] = H[k]

            
HplotT = Hplot.transpose() # on repasse l'espace physique dans le bon sens 

#trace type 1
nbcolo=30
levels = np.linspace(H2-0.5, 1, nbcolo+1)
fig = plt.contour(Xnode, Ynode, HplotT, levels=levels, cmap='Reds')
cbar1 = plt.colorbar()
cbar1.set_label('pression')
# fig = plt.contourf(HplotT, levels=levels, cmap='coolwarm')

# #trace type 2
plt.figure(num=1, figsize=(10, 6))
plt.pcolor(Xnode, Ynode, HplotT, cmap='coolwarm', vmin=H2, vmax=0)
cbar2 = plt.colorbar()
cbar2.set_label('Charge hydraulique (m)')
plt.title('Projet méthode numérique', fontsize = 20)
plt.show()

et je vous joins de plus la fonction mailleur:

from shapely.geometry import Point, Polygon
import numpy as np
from scipy.spatial import Delaunay

# import matplotlib.tri as tri

# import matplotlib.pyplot as plt
# from shapely.plotting import plot_polygon
# import matplotlib.tri as tri

   
def maillage(x,y,Nx):

    coords = np.zeros([len(x),2]) 
    
    for i in range(len(x)):
        coords[i,:] = np.array([x[i],y[i]])     
        
    poly = Polygon(coords)
    # plot_polygon(poly)
    # plt.show()
    
    # Generate random points
    xmin, xmax, ymin, ymax = min(x), max(x), min(y), max(y)
    dx = (xmax - xmin)/Nx
    Ny = (ymax - ymin) * Nx / (xmax - xmin)
    dy = (ymax-ymin)/Ny
    xdot = np.arange(xmin,xmax,dx)
    ydot = np.arange(ymin,ymax,dy)
    
    XX, YY = np.meshgrid(xdot, ydot)
    Z = len(xdot) * len(ydot)
    xNode=np.reshape(XX,Z)
    yNode=np.reshape(YY,Z)
    
    xN = []
    yN = []

    for i in range(Z):
        a = Point(xNode[i],yNode[i])
        b = poly.covers(a)
        if b:
            xN = np.append(xN, xNode[i])
            yN = np.append(yN, yNode[i])
    
    xyNode=np.zeros([len(xN),2])
    xyNode[:,0]=np.transpose(xN)
    xyNode[:,1]=np.transpose(yN)
    
    triang  = Delaunay(xyNode) 
    connect = triang.vertices
    
    #suppression des triangles en dehors du sol et du barrage
    xTri=np.mean(xN[connect],axis=1)
    yTri=np.mean(yN[connect],axis=1)
    
    con = []
    for i in range(len(connect)):
        ac = Point(xTri[i],yTri[i])
        bc = poly.covers(ac)
        if bc:
            con = np.append(con, i)
    
    con = np.array(con, dtype='int')
    connect = connect[con,:]        
    
    # #triangles au-dessus du sol et du barrage à supprimer
    # ibad=np.where(((xTri<0)&(yTri>0))|((xTri>((L+Ltop)-yTri*L/H))&(yTri>0)))
    
    # xybad=np.array([xTri[ibad],yTri[ibad]])
    # isupp=tri.find_simplex(xybad.T) #indices des trangles contenant les centres à supprimer
    # connect=np.delete(connect,isupp,0)
    # #maj des coordonnées du centre des elements
    # xTri=np.mean(xNode[connect],axis=1)
    # yTri=np.mean(yNode[connect],axis=1)
    
    # triang = tri.Triangulation(xyNode[:,0], xyNode[:,1])
    # connect = triang.get_masked_triangles()
    
    # # Mask off unwanted triangles.
    # min_aire = dx*dy
    
    # con = []
    # for i in range(len(connect)):
    #     [no1,no2,no3] = xyNode[connect[i],:]
    #     vec12 = np.array([no2[0]-no1[0],no2[1]-no1[1]])
    #     vec13 = np.array([no3[0]-no1[0],no3[1]-no1[1]])
    #     aire = (vec12[0] * vec13[1] - vec12[1] * vec13[0])/2 
    #     if aire <= min_aire:
    #         con = np.append(con, i)
    
    # con = np.array(con, dtype='int')
    # connect = connect[con,:]

    return xN, yN, connect, triang

J'obtiens sur une figure les écoulements sur le barrage et sur une autre le maillage du barrage + sol et avec ce maillage et j'aimerais trouver le barycentre du barrage.

Si le barrage a une hauteur constante, moi j'adapterais (ou je clonerais) la fonction maillage, et je calculerais la moyenne des coordonnées des points qui sont à l'intérieur du barrage.

Quand tu partages du code, tiens compte de ceci: https://codes-sources.commentcamarche.net/faq/11288-poster-un-extrait-de-code

Merci pour ton aide je vais essayer d'avancer !