anchor.diff:  
       deallocate(atomic_distance)
       deallocate(selfl21)
  -    deallocate(selfl22)
       deallocate(sin1)
  -    deallocate(sin2)
  -
  -end subroutine fget_kernels_arad
  -
  -
  -subroutine fget_symmetric_kernels_arad(q1, z1, n1, sigmas, nm1, nsigmas, &
  +
  +end subroutine fget_symmetric_kernels_arad
  +
  +subroutine fget_atomic_kernels_arad(q1, q2, z1, z2, n1, n2, sigmas, na1, na2, nsigmas, &
           & width, cut_distance, r_width, c_width, kernels)
   
       use arad, only: atomic_distl2
   
       implicit none
   
  -    ! ARAD descriptors for the training set, format (i,j_1,5,m_1)
  -    double precision, dimension(:,:,:,:), intent(in) :: q1
  -
  -    ! ARAD atom-types for each atom in each molecule, format (i, j_1, 2)
  -    double precision, dimension(:,:,:), intent(in) :: z1
  +    ! ARAD descriptors for each atom in the training set, format (i,5,m_1)
  +    double precision, dimension(:,:,:), intent(in) :: q1
  +    double precision, dimension(:,:,:), intent(in) :: q2
  +
  +    ! ARAD atom-types for each atom, format (i, 2)
  +    double precision, dimension(:,:), intent(in) :: z1
  +    double precision, dimension(:,:), intent(in) :: z2
  +
  +    ! Sigma in the Gaussian kernel
  +    double precision, dimension(:), intent(in) :: sigmas
   
       ! List of numbers of atoms in each molecule
       integer, dimension(:), intent(in) :: n1
  -
  -    ! Sigma in the Gaussian kernel
  -    double precision, dimension(:), intent(in) :: sigmas
  -
  -    ! Number of molecules
  -    integer, intent(in) :: nm1
  +    integer, dimension(:), intent(in) :: n2
  +
  +    ! Number of atom
  +    integer, intent(in) :: na1
  +    integer, intent(in) :: na2
   
       ! Number of sigmas
       integer, intent(in) :: nsigmas
  
positive.code:     enddo
      !$OMP END PARALLEL DO
  
      !$OMP PARALLEL DO PRIVATE(ni)
      do i = 1, nm2
          ni = n2(i)
          do i_1 = 1, ni
              selfl22(i,i_1) = atomic_distl2(q2(i,i_1,:,:), q2(i,i_1,:,:), n2(i), n2(i), &
                  & sin2(i,i_1,:), sin2(i,i_1,:), width, cut_distance, r_width, c_width)
          enddo
      enddo
      !$OMP END PARALLEL DO
  
  
      allocate(atomic_distance(maxval(n1), maxval(n2)))
  
      kernels(:,:,:) = 0.0d0
      atomic_distance(:,:) = 0.0d0
  
      !$OMP PARALLEL DO PRIVATE(l2dist,atomic_distance,ni,nj)
      do j = 1, nm2
          nj = n2(j)
          do i = 1, nm1
              ni = n1(i)
  
              atomic_distance(:,:) = 0.0d0
  
negative.code:     ! Number of atom
      integer, intent(in) :: na1
      integer, intent(in) :: na2
  
      ! ARAD parameters
      double precision, intent(in) :: width
  