docs: def get_fault_patch_vertices(cls, rupture_top_edge,
                                   upper_seismogenic_depth,
                                   lower_seismogenic_depth, dip, index_patch=1):
          """
          Get surface main vertices.
          Parameters are the same as for :meth:`from_fault_data`, excluding
          fault_trace, and mesh spacing.
  
          :param rupture_top_edge:
              A instances of :class:`openquake.hazardlib.geo.line.Line`
              representing the rupture surface's top edge.
          :param index_patch:
              Indicate the patch of the fault in order to output the vertices.
              The fault patch numbering follows the same logic of the right-hand
              rule i.e. patch with index 1 is the first patch along the trace.
          :returns:
              Four :class:~openquake.hazardlib.geo.point.Point objects
              representing the four vertices of the target patch.
          """
          # Similar to :meth:`from_fault_data`, we just don't resample edges
          dip_tan = math.tan(math.radians(dip))
          hdist_bottom = (
              lower_seismogenic_depth - upper_seismogenic_depth) / dip_tan
          strike = rupture_top_edge[0].azimuth(rupture_top_edge[-1])
          azimuth = (strike + 90.0) % 360
          # Collect coordinates of vertices on the top and bottom edge
          lons = []
          lats = []
          deps = []
  
          t_lon = []
          t_lat = []
          t_dep = []
          for point in rupture_top_edge.points:
              top_edge_point = point
              bottom_edge_point = point.point_at(hdist_bottom, 0, azimuth)
              lons.append(top_edge_point.longitude)
              lats.append(top_edge_point.latitude)
              deps.append(upper_seismogenic_depth)
              t_lon.append(bottom_edge_point.longitude)
              t_lat.append(bottom_edge_point.latitude)
              t_dep.append(lower_seismogenic_depth)
  
              all_lons = numpy.array(lons + list(reversed(t_lon)), float)
              all_lats = numpy.array(lats + list(reversed(t_lat)), float)
              all_deps = numpy.array(deps + list(reversed(t_dep)), float)
          index1 = int(index_patch - 1)
          index2 = int(index_patch)
          index3 = int(2 * len(rupture_top_edge) - (index_patch + 1))
          index4 = int(2 * len(rupture_top_edge) - index_patch)
          p0 = Point(all_lons[index1], all_lats[index1], all_deps[index1])
          p1 = Point(all_lons[index2], all_lats[index2], all_deps[index2])
          p2 = Point(all_lons[index3], all_lats[index3], all_deps[index3])
          p3 = Point(all_lons[index4], all_lats[index4], all_deps[index4])
          return p0, p1, p2, p3