code: def _build_mesh(self, mesh_method, **kwargs):
          
  
          # if we don't provide instantaneous masses or smas, then assume they are
          # not time dependent - in which case they were already stored in the init
          sma = kwargs.get('sma', self.sma)  # Rsol (same units as coordinates)
  
          mesh_args = self.instantaneous_mesh_args
  
          if mesh_method == 'marching':
              ntriangles = kwargs.get('ntriangles', self.ntriangles)
  
              av = libphoebe.sphere_area_volume(*mesh_args,
                                                larea=True,
                                                lvolume=True)
  
              delta = _estimate_delta(ntriangles, av['larea'])
  
              new_mesh = libphoebe.sphere_marching_mesh(*mesh_args,
                                                        delta=delta,
                                                        full=True,
                                                        max_triangles=ntriangles*2,
                                                        vertices=True,
                                                        triangles=True,
                                                        centers=True,
                                                        vnormals=True,
                                                        tnormals=True,
                                                        cnormals=False,
                                                        vnormgrads=True,
                                                        cnormgrads=False,
                                                        areas=True,
                                                        volume=True,
                                                        init_phi=self.mesh_init_phi)
  
              # In addition to the values exposed by the mesh itself, let's report
              # the volume and surface area of the lobe.  The lobe area is used
              # if mesh_offseting is required, and the volume is optionally exposed
              # to the user.
              new_mesh['volume'] = av['lvolume']
              new_mesh['area'] = av['larea']
  
              scale = sma
  
          else:
              raise NotImplementedError("mesh_method '{}' is not supported".format(mesh_method))
  
          return new_mesh, scale
docs: this function takes mesh_method and kwargs that came from the generic Body.intialize_mesh and returns
          the grid... intialize mesh then takes care of filling columns and rescaling to the correct units, etc