docs: def get_sample(self, res, resMode='abs', DL=None, method='sum', ind=None,
                    compact=False):
          """ Return a linear sampling of the LOS
  
          The LOS is sampled into a series a points and segments lengths
          The resolution (segments length) is <= res
          The sampling can be done according to different methods
          It is possible to sample only a subset of the LOS
  
          Parameters
          ----------
          res:     float
              Desired resolution
          resMode: str
              Flag indicating res should be understood as:
                  - 'abs':    an absolute distance in meters
                  - 'rel':    a relative distance (fraction of the LOS length)
          DL:     None / iterable
              The fraction [L1;L2] of the LOS that should be sampled, where
              L1 and L2 are distances from the starting point of the LOS (LOS.D)
          method: str
              Flag indicating which to use for sampling:
                  - 'sum':    the LOS is sampled into N segments of equal length,
                              where N is the smallest int such that:
                                  * segment length <= resolution(res,resMode)
                              The points returned are the center of each segment
                  - 'simps':  the LOS is sampled into N segments of equal length,
                              where N is the smallest int such that:
                                  * segment length <= resolution(res,resMode)
                                  * N is even
                              The points returned are the egdes of each segment
                  - 'romb':   the LOS is sampled into N segments of equal length,
                              where N is the smallest int such that:
                                  * segment length <= resolution(res,resMode)
                                  * N = 2^k + 1
                              The points returned are the egdes of each segment
  
          Returns
          -------
          pts:    np.ndarray
              A (3,NP) array of NP points along the LOS in (X,Y,Z) coordinates
          k:      np.ndarray
              A (NP,) array of the points distances from the LOS starting point
          reseff: float
              The effective resolution (<= res input), as an absolute distance
  
          """
          ind = self._check_indch(ind)
          # preload k
          kIn = self.kIn
          kOut = self.kOut
  
          # Preformat DL
          if DL is None:
              DL = np.array([kIn[ind], kOut[ind]])
          elif np.asarray(DL).size==2:
              DL = np.tile(np.asarray(DL).ravel(),(len(ind),1)).T
          DL = np.ascontiguousarray(DL).astype(float)
          assert type(DL) is np.ndarray and DL.ndim==2
          assert DL.shape==(2,len(ind)), "Arg DL has wrong shape !"
  
          # Check consistency of limits
          ii = DL[0,:] < kIn[ind]
          DL[0,ii] = kIn[ind][ii]
          ii[:] = DL[0,:] >= kOut[ind]
          DL[0,ii] = kOut[ind][ii]
          ii[:] = DL[1,:] > kOut[ind]
          DL[1,ii] = kOut[ind][ii]
          ii[:] = DL[1,:] <= kIn[ind]
          DL[1,ii] = kIn[ind][ii]
  
          # Preformat Ds, us
          Ds, us = self.D[:,ind], self.u[:,ind]
          if len(ind)==1:
              Ds, us = Ds.reshape((3,1)), us.reshape((3,1))
          Ds, us = np.ascontiguousarray(Ds), np.ascontiguousarray(us)
  
          # Launch    # NB : find a way to exclude cases with DL[0,:]>=DL[1,:] !!
          # Todo : reverse in _GG : make compact default for faster computation !
          lpts, k, reseff = _GG.LOS_get_sample(Ds, us, res, DL,
                                               dLMode=resMode, method=method)
          if compact:
              pts = np.concatenate(lpts, axis=1)
              ind = np.array([pt.shape[1] for pt in lpts], dtype=int)
              ind = np.cumsum(ind)[:-1]
              return pts, k, reseff, ind
          else:
              return lpts, k, reseff