Python - Anzahl der Elemente im Array über einer gekrümmten Funktion zurückgegeben

Question

Ich versuche, die Anzahl der Werte über den gestrichelten, gepunkteten, gestrichelten und gepunkteten Kurven in meinem Diagramm zu extrahieren.

Ich kann immer die Anzahl der Punkte Augapfel, die das Ausmaß dieser Kurven überschreiten, aber ich will keine Fehler in diesem Verfahren riskieren.

Zunächst werden diese Kurven durch eine Massenvariable und eine Abstandsvariable I in meinem Code Escape_Velocity definiert. Es ist Teil eines Klassenprofils, das ich gemacht habe.

import numpy as np 
import NFW_Profile as NFW 

h0 = 0.704 
NFWc12 = NFW.Profile(c=12.5, z=0.0, h=h0) 
nfwEsc = NFWc12.Escape_Velocity(Mass, Radius) 

Auf meinem Grundstück sind die Kurven auf dieser Funktion basiert, in dem ich einen beliebigen Mass Wert auswählen und Radius einen np.linspace Wert zugeführt.

Die Werte auf meinem Grundstück sind aus meiner Analyse von Datensätzen, in denen wir RadVel sein, um die y-Achse Werte „Radial Velocity“ und Dist der x-Achse Werte „galaktozentrischen Distance“ sein nennen kann.

Der Schlüssel ist, dass beide Arrays von Elementen die gleiche Dimension haben und dass sie miteinander indiziert werden können. Zum Beispiel entspricht der 20. indizierte Wert RadVel dem 20. indizierten Wert von Dist.

---

Also mein Plan aus zu

1. Wählen Sie ein willkürlicher Wert von Mass
2. ein Element Nehmen von Dist
3. -Feed, die Escape_Velocity
4. zu schätzen Wenn der RadVel Wert, entsprechend zu dem Element, das Escape_Velocity zugeführt wird, ist größer als der Escape_Velocity Wert, es coat ts.

5. Wenn der Wert Escape_Velocity größer ist als der entsprechende Wert RadVel, wird dieser Wert nicht berücksichtigt.

   import numpy as np 
   import NFW_Profile as NFW 
   
   h0 = 0.704 
   NFWc12 = NFW.Profile(c=12.5, z=0.0, h=h0) 
   
   
   def UnboundSubhalos(mass, Dist): 
       Vesc = NFWc12.Escape_Velocity(mass, Dist) 
   
       PosValues = [i for i in RadVel if i => Vesc.all()] 
       NegValues = [i for i in RadVel if i <= -Vesc.all()] 
   
       return len(PosValues) + len(NegValues) 
   

Answer 1

Soweit ich das bekam, die Anzahl der roten Punkte finden möchten, die außerhalb der Region sind durch eine nicht-lineare Funktion definiert Sie Escape_Velocity und die roten Punkte haben x-Positionen aufrufen und Y-Positionen, die in den Arrays Dist bzw. RedVal gespeichert sind, werden so geordnet, dass ein roter Punkt eine Position (x, y) = (Dist[n], RedVel[n]) hat. Es sieht auch so aus (und Ihre Definition von UnboundSubhalos schlägt es vor), die durch Escape_Velocity definierten gepunkteten Linien sind symmetrisch um RedVel = 0, d. H. Sie möchten tatsächlich die Anzahl der roten Punkte mit einem absoluten Wert von RedVel größer als Escape_Velocity finden.

In diesem Fall können Sie einfach folgendes tun: Escape_Velocity Unter der Annahme ist eine Funktion ein Array übergeben können, können Sie das Escape_Velocity für jedes Element des Array Dist und speichern sie in dem Array esc_vel = Escape_Velocity(Mass, Dist) finden. Andernfalls müssen Sie diese Werte mit einer Schleife über die Elemente Dist berechnen.Aus Ihrem Code kann ich annehmen, dass Escape_Velocity einen positiven Wert ergibt, d. H. Die gestrichelte Linie bei positiven RedVal Werten. Dann enthält das Array outside_dots = np.abs(RedVel) >= esc_velTrue für jeden Punkt außerhalb des Bereichs, der durch die gepunkteten Kurven eingeschlossen ist, und False für jeden Punkt im Inneren. Dann gibt np.sum(outside_dots) Ihnen die gewünschte Anzahl von Punkten außerhalb.

Der folgende Code funktioniert wie beschrieben:

import numpy as np 
import matplotlib.pyplot as plt 

number_dots = 100 
x = np.random.random(number_dots) # random numbers in the range [0, 1] 
y = (np.random.random(number_dots) - 0.5) * 2 # random numbers in the range [-1, 1] 

curved_function = lambda z: 1 - np.sqrt(z)/3 

plt.plot(x, y, 'ro') 
plt.xlabel('x') 
plt.ylabel('y') 

def count_dots_outside(x, y): 
     outside_dots = np.abs(y) > curved_function(x) 
     return np.sum(outside_dots) 

plt.title('Number of dots outside the curved function: '+str(count_dots_outside(x,y))) 
xx = np.linspace(0,1,100) 
plt.plot(xx, curved_function(xx), 'black', linestyle='dashed') 
plt.plot(xx, -curved_function(xx), 'black', linestyle='dashed') 
plt.show()