Initial commit

new 1.py

+from math import*
+import random as rd
+import matplotlib.pyplot as plt
+
+Lois=[] #list de [profondeur,c]
+
+c=340#m/s
+def formationDesVoies(hydrophones,thetaMax,N,n,d,Dtemps):#-->renvoie des doublets (faisceau,temps)
+    #hydrophones : tableau des valeurs transducteurs enfonction du temps
+    #N nombre de voies souhaitées
+    #n : nombre de transducteurs
+    #d : distance entre les transducteurs
+    #theta en degrés
+    retards=[]
+    a=len(hydrophones[0])
+    for k in range(N):      #on parcourt les N faisceaux
+        theta=-thetaMax+k*(thetaMax/2)
+        if abs(theta)<30:  #Détection par amplitude (Instant d'Amplitude Maximale)
+            dectectionAmplitude(theta,d,hydrophones,thetaMax,theta,a,Dtemps)
+        #else :
+        #interferometrie(theta,hydrophones,thetaMax,N,n,d,Dtemps,a)
+
+def dectectionAmplitude(theta,hydrophones,thetaMax,N,n,d,Dtemps,a):
+    amplitudeMax=0
+    instantAmplitudeMax=0
+    for j in range(floor(((n//2*d*sin(thetaMax)/c)+1)*(a/Dtemps)),floor((1-(n//2*d*sin(thetaMax)/c))*(a/Dtemps))): #on parcourt le temps
+            if Amax>sum(hydrophones[i][j+(n//2-j)*d*sin(theta)/c] for j in range(n)): #on somme les valeurs de tous les transducteeurs
+                amplitudeMax=sum(hydrophones[i][j+(n//2-j)*d*sin(theta)/c] for j in range(n))#sélection de l'instant d'amplitude max
+                instantAmplitudeMax=j*Dtemps/a
+            retards.append([k,instantAmplitudeMax])
+
+#def interferometrie(theta,hydrophones,thetaMax,N,n,d,Dtemps,a):
+# antenne1,antenne2=hydrophones[n//2+1:],hydrophones[:n//2+1]
+
+def ping(w,t,t0,tf):
+    if t0<=t<=tf:
+        return cos(w*t)
+    else :
+        return 0
+
+def amplitude(A,r):
+    return A/(pi*r)
+
+
+def générerPlancher(profondeur=3000,alpha=pi/4,l=20):
+    Lz,Lx=[],[]
+    L=0 #longueur du plancher
+    x0=-1-tan(alpha/2)*profondeur #position de départ du plancher
+    z=profondeur #variable pour contrôler la profondeur
+    while L<-x0+tan(alpha/2)*z:
+        beta=pi*rd.gauss(0,0.2)
+        L+=l*cos(beta)
+        z+=l*sin(beta)
+        Lz.append(z)
+        Lx.append(x0+L)
+    plt.plot(Lx,Lz);plt.show()
+    #return Lx,Ly
+
+def valeursAngulaires(Lx,Lz):#renvoie les valeurs angulaires des "sommets"  du plancher
+    valeursAngulaires=[]
+    l=len(Lx)
+    for k in range(l):
+        valeursAngulaires.append(atan2(Lx,L,y))#k pour conserver le rang du "sommet"
+    return valeursAngulaires
+
+def reflecteurs(Lx,Lz,R,alpha): #R la résolution voulue #renvoie les coordonnées des "réflecteurs"
+                                #renvoie les coordonnées des réflecteurs
+    angleSommets=valeursAngulaires(Lx,Lz)
+    anglesClassés=sorted(angleSommets,key=lambda angle: angle[0])
+    pas=alpha/(R-1) 
+    l=len(Lx)-1
+    reflecteurs=[]
+    for k in range(R):#on place chacun des réflecteurs
+        angle=k*pas #angle du réflecteur
+        arretes=[]
+        arrete=0
+        for i in range(l):#on extrait les arrêtes de plancher qui croisées par le faisceau
+            if (angleSommets[i]-angle)*(angleSommets[i+1]-angle)<0:
+                arretes.append([i,sqrt(Lx[i]**2+Lz[i]**2)+sqrt(Lx[i+1]**2+Lz[i+1]**2)])#arrête comprise entre les sommets i et i+1 et sa "distance"
+        if len(arretes)>1:
+            arretesClassees=[]
+            arretesClassees=sorted(arretes,key=lambda distance: distance[1])
+            arrete=arretesClassees[0][0]
+        else:
+            arrete=arretes[0]
+        points=[Lx[arrete],Lz[arrete],Lx[arrete+1],Lz[arrete+1]]
+        a,b=coefFonctionAffine(points)[0],coefFonctionAffine(points)[1]
+        def f(x):return a*x+b-(sin(angle)/cos(angle))*x
+        t=dichotomie(0,point[1],f,1E-5)
+        coordonnees=[t,f(t)]
+        reflecteurs.append(coordonnees)
+
+def ondeSonar(x,z,t,A,w,lois): #donne la forme de l'onde émise par le sonar
+	r=sqrt(x**2+z**2)
+	j=0
+	while z> lois[j][3]:
+	
+	
+		
+		
+	               
+		
+
+   
+
+def ondeReflecteur(xr,zr,t,pas):
+    rr=sqrt(xr**2+zr**2)
+    d=sqrt(xr**2+zr**2)-sqrt(x**2+z**2)
+    ampReflecteur=amplitude(A,rr+d)
+    ampReflecteur=pas*ampReflecteur
+    ti=t
+    while zr>lois[2*j]:
+        if j==0:
+            ti-=quad(temps(loisDeVitesse[0],loisDeVitesse[1]),0,lois[0])
+        else :
+            ti-=quad(temps(loisDeVitesse[2*j],loisDeVitesse[2*j+1]),lois[2*(j-1)],lois[2*j])
+        j+=1
+    ti-=quad(temps(loisDeVitesse[2*j],loisDeVitesse[2*j+1]),lois[2*(j-1)],zr)
+        
+    return ampReflecteur*ping(w,ti,t0,tf)
+
+def ondeRéflechie(coordonnees,x,z,t): #coordonnées du réflecteur
+    j=len(lois)//2
+    while z<lois[2*j]:
+        j=j-1
+        
+    
+    
+    
+    
+        
+
+def loisDeVitesse(lois):#liste  %2 elts :[profondeur, vitesse]
+                        #renvoie les coeff a et b des lois affines de vitesse
+    loisDeVitesse=coefFonctionAffine(lois)
+    return loisDeVitesse
+
+def coefFonctionAffine(L): #renvoie les coefficients a et b tels que y=ax+b
+    iterations=len(L)//2-1
+    coeff=[]
+    for k in range(iterations):
+        a=(L[k+1]-L[k+3])/(L[k+0]-L[k+2])
+        b=L[1]-a*L[0]
+        coeff.append(a);coeff.append(b)
+    
+    return coeff
+
+def temps(a,b,x):
+    f=lambda u:a*u+b
+    return f(x)
+        
+            
+            
+def dichotomie(a,b,f,eps):
+    while abs(b-a)>eps:
+        m=(b+a)/2
+        if f(m)*f(b)>0:
+            b=m
+        else :
+            a=m
+        return m