code: def adjoint(self):
          
          if self.variant == 'point_eval':
              variant = 'dirac'
          elif self.variant == 'integrate':
              variant = 'char_fun'
          else:
              raise RuntimeError('bad variant {!r}'.format(self.variant))
  
          return WeightedSumSamplingOperator(self.domain, self.sampling_points,
                                             variant)
docs: Adjoint of the sampling operator, a `WeightedSumSamplingOperator`.
  
          If each sampling point occurs only once, the adjoint consists
          in inserting the given values into the output at the sampling
          points. Duplicate sampling points are weighted with their
          multiplicity.
  
          Examples
          --------
          >>> space = odl.uniform_discr([-1, -1], [1, 1], shape=(2, 3))
          >>> sampling_points = [[0, 1, 1, 0],
          ...                    [0, 1, 2, 0]]
          >>> op = odl.SamplingOperator(space, sampling_points)
          >>> x = space.element([[1, 2, 3],
          ...                    [4, 5, 6]])
          >>> abs(op.adjoint(op(x)).inner(x) - op(x).inner(op(x))) < 1e-10
          True
  
          The ``'integrate'`` variant adjoint puts ones at the indices in
          ``sampling_points``, multiplied by their multiplicity:
  
          >>> op = odl.SamplingOperator(space, sampling_points,
          ...                           variant='integrate')
          >>> op.adjoint(op.range.one())  # (0, 0) occurs twice
          uniform_discr([-1., -1.], [ 1.,  1.], (2, 3)).element(
              [[ 2.,  0.,  0.],
               [ 0.,  1.,  1.]]
          )
          >>> abs(op.adjoint(op(x)).inner(x) - op(x).inner(op(x))) < 1e-10
          True