Plotting y values of an arc - python-3.x

Question

I am trying to plot the segment of a circle (2D) as an arc in matplotlib. I have written a class which will provide the maths for the segment such as chord length, height of arc etc. I wish to plot the x y values between (0,0) and (0, chord length).
I am currently representing the X values as numpy linspace array (0, chordLength, 200). I am a bit stumped as to how to plot the y values as a similar linspace array so that I can plot these points using matplotlib. The idea behind this is to display the curvature of the earth between two points of a known arc length (great circle distance). I have been reading around sine cosine etc however outside of using cookie cutter formulas for my geometry calculations, I am somewhat lost as to how to apply it to gain my y values.
First, the circle class
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
I have not progressed very far with the main program as one of the first tasks im aiming to do is create the y values. This is what I have so far -
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()
For context, I wish to use this 'arc' to add elevation data to, akin to - https://link.ui.com/#. I hope to simulate increased curvature over distance which I can use for rough line of sight analysis.
However, first step is getting the y values.

Answer 1

Here is the final solution, I'm not 100% about the maths and how it all works but if anyone is struggling with the same problem - I hope this helps.
The circle class can be found in the original question, located below. Find attached the final code which provides me with what I was after - simulating the curvature of the earth on a graph based upon the arc length (great circle distance).
Big thank you to all who took the time to answer me and help me along my way.
from circle import Circle
import numpy as np
import matplotlib.pyplot as plt
def calcStartAngle(startY,centreY,startX,centreX):
startAngle = np.arctan2(startY-centreY, startX-centreX)
return startAngle
def calcEndAngle(endY,centreY,endX,centreX):
endAngle = np.arctan2(endY-centreY, endX-centreX)
return endAngle
def main():
distance = 200
radius = 3440.065
#create circle object
c1 = Circle(radius,distance)
angle = c1.getDegrees()
xc = c1.getXc()
yc = c1.getYc()
#set start and end points
x1,y1 = 0,0
x2,y2 = distance,0
#get start and end angles
startAngle = calcStartAngle(y1,yc,x1,xc)
endAngle = calcEndAngle(y2,yc,x2,xc)
angleList = np.linspace(startAngle,endAngle,distance)
x_values = np.linspace(x1,x2,distance)
y_valuesList = []
for i in range(len(x_values)):
y = radius*np.sin(angleList[i]) - c1.getArcHeight()
y_valuesList.append(y)
#Create numpy array to hold y values
y_values = np.array(y_valuesList)
plt.ylim(0,50)
plt.plot(x_values,y_values)
plt.show()
if __name__ == "__main__":
main()
Here is an example of the finished product -