Problème Boucle dans Boucle

Bonjour à vous,

J'ai besoin de votre aide pour une imbrication de boucles.

J'ai donc deux boucles imbriquées l'une dans l'autre de la façon suivante :

Boucle Géométrie
Boucle Stabilisation

Fin de boucle Stabilisation
Fin de boucle Géométrie

Pour vous expliquer le fonctionnement du programme : J'ai deux câbles qui ont une influence l'un sur l'autre. La position du câble du bas doit respecter une position objectif tandis que celle du haut dépend des efforts ponctuels nécessaires à l'atteinte de la position objectif du câble du bas.

Les câbles sont découpés en éléments et en noeuds, et il y a des forces ponctuelles tous les n noeuds.

Mon problème est dans la boucle géométrie. Car en effet, la boucle Stabilisation fonctionne quand je n'utilise qu'elle. Et quand je lui rajoute la boucle géométrie (Qui est une boucle qui recherche la solution pas à pas par ajout/retrait de Delta force à la valeur des forces ponctuelles pour obtenir une convergence et qui fonctionne dans le cas simple de recherche de solution à des équations basiques) le programme se bloque.

La blocage intervient de la manière suivante :

Le calcul de la première stabilisation se fait entièrement (30 calculs). Le programme passe donc à la vérification (Je suppose) de la réalisation ou non de l'objectif géométrie et ensuite, il effectue le premier calcul de la boucle stabilisation à plusieurs reprises.

Je vous donne en dessous les boucles en questions :

def boucle_Newton_Raphson(etat,poi,pen):

    geometrie = False
    forme_objectif = 1.4
    compteur = 0
        
    while not(geometrie):
        
        compteur+=1
        fini = False
        compt = 0
        
        while not(fini):
            compt += 1
            
            ### calcul de K et des efforts internes
            (KK_glob,ff_glob) = calcule_K_f(etat,liste_elems)
            
            ### calcul des efforts externes
            # cas simple 100 N par noeud vers le bas
            f_ext = matrix(zeros((2*nb_noeuds,1)))
            
            for i in range(nb_noeuds):
                f_ext[2*i+1,0] = - carac_ml*dx
                    
            ### Pendules
            force_actuelle=[0]             
            f_pendule = matrix(zeros((2*nb_noeuds,1)))    
            for i in range (nb_pendules):
                f_pendule[i*2*npen+1,0]= poi * carac_ml*ltot / nb_pendules - pen       
                force_actuelle.append(f_pendule[i*2*npen+1,0])
                
            #f_pendule = matrix(zeros((2*nb_noeuds,1)))
            #for i in range(nb_pendules):
                #f_pendule[i*2*npen+1,0] = - f_ext[2*i+1,0] * npen * poi - pen
                
            # for n in range(nb_pendules):
             #   f_pendule[2*((1+n)*int(nb_noeuds/(nb_pendules+1)))+1,0] = - f_ext[2*((1+n)*int(nb_noeuds/(nb_pendules+1)))+1,0] * nb_noeuds/(nb_pendules+1) * poi/2 - pen
           
                                
            ### reduction du systeme
            (K_red,f_red) = systeme_reduit(KK_glob,ff_glob+f_ext+f_pendule)#+f_inverse)#f_surcharge)
            
            ### resolution
            u_compl = deplacement_complet(K_red,f_red)
        
            ### affichage
            print("Calcul "+str(compt)+" -- min(etat)="+str(min(etat)[0,0]))
                                
            ### test de convergence
            if max(abs(u_compl))<1e-10:
                fini = True
                
            # limitation des deplacements si necessaire
            tol = 0.5
            if max(abs(u_compl)) > tol:
                u_compl *= tol/max(abs(u_compl))[0,0]
            
            #trace graphe
            #trace_graphe('b')
            #draw()
            
            ### mise a jour etat
            etat = etat + u_compl
            for i in range(nb_pendules):
                print(etat[i*2*npen+1,0])
                
    ##premiere boucle            
    for i in range(nb_pendules):
        if etat[i*2*npen+1,0] > (forme_objectif-0.1) and etat(i*2*npen+1,0) < (forme_objectif+0.1):
            geometrie = True
    
        else :
            geometrie = False
            fini = False
            for i in range (nb_pendules):
                print (i)
                if etat[i*2*npen+1,0] > forme_objectif:  
                    if etat[i*2*npen+1,0]-forme_objectif > 1:
                        force_actuelle[i]-=0.1
                    else:
                        if etat[i*2*npen+1,0]-forme_objectif > .3 :
                            force_actuelle[i]-=0.05
                        else:
                            force_actuelle[i]-=0.0001                
                else:
                    if etat[i*2*npen+1,0]-forme_objectif < 1:
                        force_actuelle[i]+=0.1
                    else:
                        if etat[i*2*npen+1,0]-forme_objectif < .3 :
                            force_actuelle[i]+=0.05
                        else:
                            force_actuelle[i]+=0.0001 
                    
                print("1",compt, force_actuelle[i], etat[i*2*npen+1,0],0) 
        
    return etat

De plus, je voudrais que pour un câble, le calcul tienne compte des deux boucles car il y a une géométrie objectif pour lui et que pour le second câble on ne tienne compte que des forces ponctuelles obtenues pour le premier câble et qu'il n'y ait donc qu'un passage dans la boucle stabilisation et pas la boucle géométrie car il n'y a pas d'objectif de ce côté là.

Merci pour vos lumières,

Sniffle