Tracer les valeurs y d'un arc

Question

J'essaie de tracer le segment d'un cercle (2D) comme un arc dans matplotlib. J'ai écrit une classe qui fournira les mathématiques pour le segment, comme la longueur de la corde, la hauteur de l'arc, etc. Je souhaite tracer les valeurs x y entre (0,0) et (0, longueur de corde).

Je représente actuellement les valeurs X sous forme de tableau numpy linspace (0, chordLength, 200). Je suis un peu perplexe quant à la manière de représenter les valeurs y sous la forme d'un tableau linspace similaire afin de pouvoir tracer ces points à l'aide de matplotlib. L'idée derrière tout cela est d'afficher la courbure de la terre entre deux points d'une longueur d'arc connue (distance du grand cercle). J'ai lu des articles sur le sinus et le cosinus, mais en dehors de l'utilisation de formules à l'emporte-pièce pour mes calculs géométriques, je suis quelque peu perdu quant à la manière de les appliquer pour obtenir mes valeurs en ordonnées.

Tout d'abord, la classe de cercle

import numpy as np

class Circle:

    def __init__(self,radiusOfCircle,lengthOfArc):
        self.radius = radiusOfCircle
        self.circumference = 2 * np.pi * self.radius
        self.diameter = self.radius * 2
        self.arcLength = lengthOfArc
        self.degrees = self.calcDegrees()
        self.radians = self.calcRadians()
        self.chordLength = self.calcChordLength()
        self.sagitta = self.calcSagitta()
        self.segmentArea = self.calcSegmentArea()
        self.arcHeight = self.calcArcHeight()

    #Setters and getters for the Circle class (TODO: setters)
    def getRadius(self):
        return self.radius

    def getCircumference(self):
        return self.circumference

    def getDiameter(self):
        return self.diameter

    def getArcLength(self):
        return self.arcLength

    def getRadians(self):
        return self.radians

    def getDegrees(self):
        return self.degrees

    def getChordLength(self):
        return self.chordLength

    def getSagitta(self):
        return self.sagitta

    def getSegmentArea(self):
        return self.segmentArea

    def getArcHeight(self):
        return self.arcHeight

    #Define Circle class methods

    #Calculate the central angle, in degrees, by using the arcLength
    def calcDegrees(self):
        self.degrees = (self.arcLength / (np.pi * self.diameter)) * 360 #Gives angle in degrees at centre of the circle between the two points (beginning and end points of arcLength)
        return self.degrees

    #Calculate the central angle in radians, between two points on the circle
    def calcRadians(self):#Where theta is the angle between both points at the centre of the circle
        self.radians = np.radians(self.degrees) # Convert degrees to radians to work with ChordLength formula
        return self.radians

    #Returns the chord lengths of the arc, taking theta (angle in radians) as it's argument
    #The chord is the horizontal line which separates the arc segment from the rest of the circle
    def calcChordLength(self):
        self.chordLength = 2*self.radius*np.sin(self.radians/2) #formula works for theta (radians) only, not degrees #confirmed using http://www.ambrsoft.com/TrigoCalc/Sphere/Arc_.htm
        return self.chordLength

    #Calculates the length of arc, taking theta (angle in radians) as its argument.
    def calcArcLength(self):
        self.arcLength = (self.degrees/360)*self.diameter*np.pi #confirmed using http://www.ambrsoft.com/TrigoCalc/Sphere/Arc_.htm
        return self.arcLength

    #Calculates the sagitta of the arc segment.  The sagitta is the horizontal line which extends from the bottom
    #of the circle to the chord of the segment
    def calcSagitta(self):
        self.sagitta = self.radius - (np.sqrt((self.radius**2)-((self.chordLength/2)**2))) #Confirmed correct against online calculator https://www.liutaiomottola.com/formulae/sag.htm
        return self.sagitta

    #Calculates the area of the circular segment/arc).
    def calcSegmentArea(self):
        self.segmentArea = (self.radians - np.sin(self.radians) / 2) * self.radius**2
        return self.segmentArea

    #Calculate the height of the arc
    #Radius - sagitta of the segment
    def calcArcHeight(self):
        self.arcHeight = self.radius - self.sagitta
        return self.arcHeight

Je n'ai pas beaucoup progressé avec le programme principal car l'une des premières tâches que je cherche à faire est de créer les valeurs y. Je ne sais pas si je peux le faire. Voici ce que j'ai jusqu'à présent

from circle import Circle
import numpy as np
import matplotlib.pyplot as plt

def main():
    #define centre point

    #Circle(radius,arc length)
    c1 = Circle(3440.065,35) #Nautical miles radius with 35Nm arc length
    chordLength = c1.getChordLength()
    arcHeight = c1.getArcHeight()

    centerX = chordLength/2
    centerY = 0

if __name__ == "__main__":
    main()

Dans le contexte, je souhaite utiliser cet "arc" pour y ajouter des données d'élévation, un peu comme dans le cas de l'installation d'un système d'alarme. https://link.ui.com/# . J'espère simuler une augmentation de la courbure sur la distance, que je peux utiliser pour une analyse approximative de la ligne de visée.

Cependant, la première étape consiste à obtenir les valeurs y.