read_op_sparse Subroutine

    subroutine read_op_sparse(this, indices, entries)
        use IntegralsData, only: nFrozen
        class(sparse_lMat_t), intent(inout) :: this
        ! We allow deallocation of indices/entries
        integer(int64), allocatable, intent(inout) :: indices(:, :), entries(:, :)

        integer(int64) :: block_size, i
        integer(int64), allocatable :: combined_inds(:)
        integer(int64) :: dummy
        HElement_t(dp) :: rVal
        routine_name("read_op_sparse")

        block_size = size(indices, dim=2)
        allocate(combined_inds(block_size))
        ! Transfer the 6 orbitals to one contiguous index
        do i = 1, block_size
            if(nFrozen > 0) then
                ! Take care of freezing orbitals here
                call map_indices(indices(:,i))
                ! Only freeze once, when filling in the values (this read_op can be called
                ! multiple times for the same block)
                if(this%htable%known_conflicts()) then
#ifdef CMPLX_
                    call stop_all(this_routine, "not implemented for complex")
#else
                    rVal = transfer(entries(1, i), rVal)
                    call add_core_en(rVal,indices(:,i))
                    entries(1,i) = transfer(rVal,entries(1,i))
#endif
                end if
            end if

            combined_inds(i) = this%indexFunc(indices(1, i), indices(2, i), indices(3, i), &
                indices(4, i), indices(5, i), indices(6, i))

            ! If the entry is frozen, do not count it
            if(t_freeze(indices)) combined_inds(i) = 0
        end do
        ! We might need this memory - all these operations can be memory critical
        deallocate(indices)

        if (this%htable%known_conflicts()) then
            call this%read_data(combined_inds, entries(1, :))
        else
            call this%count_conflicts(combined_inds)
        end if

        deallocate(combined_inds)
    end subroutine read_op_sparse