prg_c_interface.F90

Go to the documentation of this file.

module prg_c_interface
 
  use iso_c_binding
 
  use prg_densitymatrix_mod
  use prg_charges_mod
  use prg_chebyshev_mod
  use prg_ewald_mod
  use prg_dos_mod
  use prg_genz_mod
  use prg_normalize_mod
  use prg_system_mod
  use prg_openfiles_mod
  use prg_progress_mod
  use prg_pulaycomponent_mod
  use prg_sp2_fermi_mod
  use prg_sp2_mod
  use prg_timer_mod
  use bml_types_m
 
  implicit none
 
  public :: prg_version_c
  public :: prg_progress_init_c
  public :: prg_progress_shutdown_c
 
  ! density matrix module
  public :: prg_build_density_t0_c
  public :: prg_check_idempotency_c, prg_get_eigenvalues_c
  public :: prg_get_flevel_c, prg_build_density_t_c, prg_build_atomic_density_c
  public :: prg_build_density_t_fermi_c, prg_get_flevel_nt_c, prg_build_density_t_fulldata_c
  public :: prg_build_density_t_ed_c, prg_toeigenspace_c, prg_tocanonicalspace_c
  public :: canon_dm_prt_c, prg_get_evalsdvalsevects_c, prg_build_density_fromevalsandevects_c
 
contains
 
  ! C wrapper subroutine
  subroutine prg_version_c() bind(C, name="prg_version")
    call prg_version()
  end subroutine prg_version_c
 
  subroutine prg_progress_init_c() bind(C, name="prg_progress_init")
    call prg_progress_init()
  end subroutine prg_progress_init_c
 
  subroutine prg_progress_shutdown_c() bind(C, name="prg_progress_shutdown")
    call prg_progress_shutdown()
  end subroutine prg_progress_shutdown_c
 
 
  !------------------------------------------------
  !  Beginning of prg_densitymatrix_mod
  !------------------------------------------------
 
  subroutine prg_build_density_t0_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil,&
       eigenvalues_out) bind(C, name="prg_build_density_T0")
    integer(c_int), value :: norbs
    real(c_double), intent(in), value :: threshold, bndfil
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_build_density_t0(ham_bml, rho_bml, threshold, bndfil, eigenvalues)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
 
  end subroutine prg_build_density_t0_c
 
  subroutine prg_build_density_t_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil, kbt,&
       ef, eigenvalues_out) bind(C, name="prg_build_density_T")
    integer(c_int), value :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_t(ham_bml, rho_bml, threshold, bndfil, kbt, ef, eigenvalues)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
  end subroutine prg_build_density_t_c
 
  subroutine prg_build_density_t_fulldata_c(norbs, ham_bml_c, rho_bml_c, threshold, bndfil, kbt, &
       ef, eigenvalues_out, evects_bml_c, fvals_out) bind(C, name="prg_build_density_T_fulldata")
    integer(c_int), value :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: eigenvalues_out(norbs)
    real(c_double) :: fvals_out(norbs)
 
    real(c_double), allocatable :: fvals(:)
    real(c_double), allocatable :: eigenvalues(:)
 
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    type(bml_matrix_t) :: evects_bml
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    evects_bml%ptr = evects_bml_c
    call prg_build_density_t_fulldata(ham_bml, rho_bml, threshold, bndfil, kbt, ef,&
         eigenvalues, evects_bml, fvals)
    fvals_out = fvals
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
    deallocate(fvals)
 
  end subroutine prg_build_density_t_fulldata_c
 
  subroutine prg_build_density_t_ed_c(norbs, ham_bml_c, rho_bml_c, evects_bml_c, threshold,&
       bndfil, kbt, ef, evals_out, dvals_out, hindex_out, llsize, verbose)&
       bind(C, name="prg_build_density_T_ed")
    integer(c_int), value :: norbs
    integer(c_int), value :: llsize
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: evals_out(norbs)
    real(c_double) :: dvals_out(norbs)
    integer(c_int) :: hindex_out(norbs, norbs)
 
    integer(c_int), allocatable  :: hindex(:,:)
    real(c_double), allocatable  :: evals(:)
    real(c_double), allocatable  :: dvals(:)
 
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    evects_bml%ptr = evects_bml_c
 
    call prg_build_density_t_ed(ham_bml, rho_bml, evects_bml, threshold, bndfil, kbt, ef, evals,&
         dvals, hindex, llsize, verbose)
 
    evals_out = evals
    dvals_out = dvals
    hindex_out = hindex
    deallocate(evals)
    deallocate(dvals)
    deallocate(hindex)
 
  end subroutine prg_build_density_t_ed_c
 
  subroutine prg_get_evalsdvalsevects_c(norbs, ham_bml_c, threshold, hindex_in, llsize, evals_out,&
       dvals_out, evects_bml_c, verbose) bind(C, name="prg_get_evalsDvalsEvects")
    integer(c_int), value :: norbs, llsize, verbose
    real(c_double), value :: threshold
    integer(c_int)  :: hindex_in(norbs,norbs)
    real(c_double)  :: evals_out(norbs)
    real(c_double)  :: dvals_out(norbs)
    integer(c_int), allocatable  :: hindex(:,:)
    real(c_double), allocatable  :: evals(:)
    real(c_double), allocatable  :: dvals(:)
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: evects_bml_c
 
    ham_bml%ptr = ham_bml_c
    evects_bml%ptr = evects_bml_c
    allocate(hindex(2, llsize))
    hindex = hindex_in
    call prg_get_evalsdvalsevects(ham_bml, threshold, hindex, llsize, evals, dvals, evects_bml,&
         verbose)
    evals_out = evals
    dvals_out = dvals
    deallocate(hindex, evals, dvals)
 
  end subroutine prg_get_evalsdvalsevects_c
 
  subroutine prg_build_density_fromevalsandevects_c(norbs,evects_bml_c, evals,rho_bml_c,threshold,&
       bndfil, kbt, ef, verbose) bind(C, name="prg_build_density_fromEvalsAndEvects")
    integer(c_int), value :: norbs, verbose
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: kbt
    real(c_double), value :: ef
    real(c_double) :: evals(norbs)
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
 
    evects_bml%ptr = evects_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_fromevalsandevects(evects_bml, evals, rho_bml, threshold, bndfil, kbt,&
         ef, verbose)
 
  end subroutine prg_build_density_fromevalsandevects_c
 
  subroutine prg_build_density_t_fermi_c(ham_bml_c, rho_bml_c, threshold, kbt, ef, verbose, drho)&
       bind(C, name="prg_build_density_T_fermi")
    integer(c_int), value  :: verbose
    real(c_double), value :: threshold
    real(c_double), value :: kbt
    real(c_double), value :: ef
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    real(c_double), intent(inout) :: drho
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_t_fermi(ham_bml, rho_bml, threshold, kbt, ef, verbose, drho)
  end subroutine prg_build_density_t_fermi_c
 
  subroutine prg_build_atomic_density_c(rhoat_bml_c, numel, hindex, spindex, norb, bml_type)&
       bind(C, name="prg_build_atomic_density")
    character(c_char), value :: bml_type
    integer(c_int), target :: hindex(norb, norb)
    integer(c_int), value :: norb
    integer(c_int), target :: spindex(norb)
    real(c_double), target :: numel(norb)
    type(c_ptr), value :: rhoat_bml_c
    type(bml_matrix_t) :: rhoat_bml
    rhoat_bml%ptr = rhoat_bml_c
    call prg_build_atomic_density(rhoat_bml, numel, hindex, spindex, norb, bml_type)
  end subroutine prg_build_atomic_density_c
 
  subroutine prg_get_flevel_c(norbs, eigenvalues, kbt, bndfil, tol, Ef)&
       bind(C, name="prg_get_flevel")
    integer(c_int) :: norbs
    real(c_double), value :: tol
    real(c_double), value :: bndfil
    real(c_double), target :: eigenvalues(norbs)
    real(c_double), value :: kbt
    real(c_double), value :: ef
    logical :: err
    call prg_get_flevel(eigenvalues, kbt, bndfil, tol, ef, err)
  end subroutine prg_get_flevel_c
 
  subroutine prg_get_flevel_nt_c(norbs, eigenvalues, kbt, bndfil, tol, ef, verbose)&
       bind(C, name="prg_get_flevel_nt")
    integer(c_int) :: norbs
    real(c_double), value :: bndfil
    real(c_double), value :: kbt
    real(c_double), value :: tol
    real(c_double), target :: eigenvalues(norbs)
    real(c_double), value :: ef
    integer(c_int), optional  :: verbose
    logical :: err
    call prg_get_flevel_nt(eigenvalues, kbt, bndfil, tol, ef, err, verbose)
  end subroutine prg_get_flevel_nt_c
 
  subroutine prg_get_eigenvalues_c(norbs, ham_bml_c, eigenvalues_out, verbose)&
       bind(C, name="prg_get_eigenvalues")
    integer(c_int) :: norbs
    integer(c_int), value :: verbose
    real(c_double)     :: eigenvalues_out(norbs)
    real(c_double), allocatable :: eigenvalues(:)
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    ham_bml%ptr = ham_bml_c
    call prg_get_eigenvalues(ham_bml, eigenvalues, verbose)
    eigenvalues_out = eigenvalues
    deallocate(eigenvalues)
  end subroutine prg_get_eigenvalues_c
 
  subroutine prg_check_idempotency_c(mat_bml_c, threshold, idempotency)&
       bind(C, name="prg_check_idempotency")
    real(c_double), value :: threshold
    real(c_double), value :: idempotency
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    mat_bml%ptr = mat_bml_c
 
    call prg_check_idempotency(mat_bml, threshold, idempotency)
 
  end subroutine prg_check_idempotency_c
 
  subroutine prg_toeigenspace_c(mat_bml_c, matEig_bml_c, evects_bml_c, threshold, verbose)&
       bind(C, name="prg_toEigenspace")
    integer(c_int), optional  :: verbose
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: mateig_bml_c
    type(bml_matrix_t) :: mateig_bml
    real(c_double), value :: threshold
    mat_bml%ptr = mat_bml_c
    evects_bml%ptr = evects_bml_c
    mateig_bml%ptr = mateig_bml_c
    call prg_toeigenspace(mat_bml, mateig_bml, evects_bml, threshold, verbose)
  end subroutine prg_toeigenspace_c
 
  subroutine prg_tocanonicalspace_c(mat_bml_c, matCan_bml_c, evects_bml_c, threshold, verbose)&
       bind(C, name="prg_toCanonicalspace")
    integer(c_int), optional  :: verbose
    type(c_ptr), value :: mat_bml_c
    type(bml_matrix_t) :: mat_bml
    type(c_ptr), value :: evects_bml_c
    type(bml_matrix_t) :: evects_bml
    type(c_ptr), value :: matcan_bml_c
    type(bml_matrix_t) :: matcan_bml
    real(c_double), value :: threshold
    mat_bml%ptr = mat_bml_c
    evects_bml%ptr = evects_bml_c
    matcan_bml%ptr = matcan_bml_c
    call prg_tocanonicalspace(mat_bml, matcan_bml, evects_bml, threshold, verbose)
  end subroutine prg_tocanonicalspace_c
 
  subroutine canon_dm_prt_c(P1, H1, Nocc, T, Q, e, mu0, m, HDIM) bind(C, name="Canon_DM_PRT")
    integer(c_int), value :: hdim
    integer(c_int), value :: m
    real(c_double), intent(in) :: h1(hdim, hdim), q(hdim, hdim), e(hdim)
    real(c_double), intent(out) :: p1(hdim, hdim)
    real(c_double), value :: t, mu0, nocc
 
    call canon_dm_prt(p1, h1, nocc, t, q, e, mu0, m, hdim)
  end subroutine canon_dm_prt_c
 
 
  !------------------------------------------------
  !  end of prg_densitymatrix_mod
  !------------------------------------------------
 
 
  !------------------------------------------------
  !  Beginning of prg_charges_mod
  !------------------------------------------------
  subroutine prg_get_charges_c(nats, norbs, rho_bml_c, over_bml_c, hindex, charges, numel,&
       spindex, mdimin, threshold) bind(C, name="prg_get_charges")
    integer(c_int), value :: nats, norbs
    integer(c_int), value :: mdimin
    integer(c_int) :: hindex(nats,nats)
    integer(c_int) :: spindex(nats)
    real(c_double) :: charges_out(nats)
    real(c_double) :: numel_in(norbs)
    real(c_double), value :: threshold
 
    real(c_double), allocatable :: charges(:)
    real(c_double), allocatable :: numel(:)
 
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    over_bml%ptr = over_bml_c
    rho_bml%ptr = rho_bml_c
    allocate(numel(norbs))
    numel = numel_in
    call prg_get_charges(rho_bml, over_bml, hindex, charges, numel, spindex, mdimin, threshold)
    charges_out = charges
    deallocate(charges, numel)
 
  end subroutine prg_get_charges_c
 
  subroutine prg_get_hscf_c(nats, ham0_bml_c, over_bml_c, ham_bml_c, spindex, hindex, hubbardu,&
       charges, coulomb_pot_r, coulomb_pot_k, mdimin, threshold) bind(C, name="prg_get_hscf")
    integer(c_int), value :: nats
    integer(c_int), target :: hindex(nats, nats)
    integer(c_int), value :: mdimin
    integer(c_int), target :: spindex(nats)
    real(c_double), target :: charges(nats)
    real(c_double), target :: coulomb_pot_r(nats)
    real(c_double), target :: coulomb_pot_k(nats)
    real(c_double), target :: hubbardu(nats)
    real(c_double), value :: threshold
    type(c_ptr), value :: ham0_bml_c
    type(bml_matrix_t) :: ham0_bml
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    ham0_bml%ptr = ham0_bml_c
    over_bml%ptr = over_bml_c
    ham_bml%ptr = ham_bml_c
    call prg_get_hscf(ham0_bml, over_bml, ham_bml, spindex, hindex, hubbardu, charges,&
         coulomb_pot_r, coulomb_pot_k, mdimin, threshold)
  end subroutine prg_get_hscf_c
 
  subroutine prg_get_hscf_v2_c(nats, ham0_bml_c, over_bml_c, ham_bml_c, spindex, hindex, hubbardu,&
       charges, coulomb_pot_r, coulomb_pot_k, mdimin, threshold) bind(C, name="prg_get_hscf_v2")
    integer(c_int), value :: nats
    integer(c_int) :: hindex(nats, nats)
    integer(c_int), value :: mdimin
    real(c_double), value :: threshold
    integer(c_int) :: spindex(nats)
    real(c_double) :: charges(nats)
    real(c_double) :: coulomb_pot_r(nats)
    real(c_double) :: coulomb_pot_k(nats)
    real(c_double) :: hubbardu(nats)
    type(c_ptr), value :: ham0_bml_c
    type(bml_matrix_t) :: ham0_bml
    type(c_ptr), value :: over_bml_c
    type(bml_matrix_t) :: over_bml
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
 
    ham0_bml%ptr = ham0_bml_c
    over_bml%ptr = over_bml_c
    ham_bml%ptr = ham_bml_c
    call prg_get_hscf_v2(ham0_bml, over_bml, ham_bml, spindex, hindex, hubbardu, charges,&
         coulomb_pot_r, coulomb_pot_k, mdimin, threshold)
  end subroutine prg_get_hscf_v2_c
 
  !------------------------------------------------
  !  End of prg_charges_mod
  !------------------------------------------------
 
  !------------------------------------------------
  ! prg_chebyshev_mod
  !------------------------------------------------
 
  subroutine prg_build_density_cheb_c(ham_bml_c, rho_bml_c, athr, threshold, ncoeffs, kbt, ef,&
       bndfil, jon, verbose) bind(C, name="prg_build_density_cheb")
    integer(c_int), value :: ncoeffs
    integer(c_int), value :: verbose
    real(c_double), value :: athr
    real(c_double), value :: kbt
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: ef
    type(c_ptr), value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int), value :: jon
    logical :: jon_l = .false.
    if (jon==1) jon_l = .true.
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_build_density_cheb(ham_bml, rho_bml, athr, threshold, ncoeffs, kbt, ef, bndfil,&
         jon_l, verbose)
  end subroutine prg_build_density_cheb_c
 
  subroutine prg_build_density_cheb_fermi_c(ham_bml_c, rho_bml_c, athr, threshold, ncoeffs, kbt,&
       ef, bndfil, getef, fermitol, jon, npts, trkfunc, verbose)&
       bind(C, name="prg_build_density_cheb_fermi")
    type(c_ptr), value :: ham_bml_c
    type(c_ptr), value :: rho_bml_c
    integer(c_int), value :: npts
    integer(c_int), value :: ncoeffs
    integer(c_int), value :: verbose
    real(c_double), value :: fermitol
    real(c_double), value :: athr
    real(c_double), value :: kbt
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: ef
    type(bml_matrix_t) :: ham_bml
    type(bml_matrix_t) :: rho_bml
    integer(c_int), value :: getef
    integer(c_int), value :: jon
    integer(c_int), value :: trkfunc
    logical :: getef_l = .false., jon_l = .false., trkfunc_l = .false.
 
    if (jon == 1) jon_l = .true.
    if (getef == 1) getef_l = .true.
    if (trkfunc == 1) trkfunc_l = .true.
 
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_build_density_cheb_fermi(ham_bml, rho_bml, athr, threshold, ncoeffs, kbt, ef, bndfil,&
         getef_l, fermitol, jon_l, npts, trkfunc_l, verbose)
 
  end subroutine prg_build_density_cheb_fermi_c
 
  !------------------------------------------------
  ! prg_dos_mod
  !------------------------------------------------
 
  subroutine prg_write_tdos_c(nstates, eigenvals, gamma, npts, emin, emax, filename)&
       bind(C, name="prg_write_tdos")
    integer(c_int), value :: nstates, npts
    real(c_double), target :: eigenvals(nstates)
    real(c_double), value :: emax
    real(c_double), value :: emin
    real(c_double), value :: gamma
    character(c_char), value :: filename
 
    call prg_write_tdos(eigenvals, gamma, npts, emin, emax, filename)
  end subroutine prg_write_tdos_c
 
  !------------------------------------------------
  ! prg_ewald_mod
  !------------------------------------------------
 
  subroutine ewald_real_space_single_latte_c(COULOMBV, I, RXYZ, Box, Nr_elem, DELTAQ, J, U,&
       Element_Pointer, Nr_atoms, COULACC, HDIM, Max_Nr_Neigh) bind(C, name="Ewald_Real_Space_Single_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: Nr_elem
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: J
    integer(c_int),    target :: Element_Pointer(Nr_atoms)
    real(c_double), value :: COULACC
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: U(Nr_elem)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_single_latte(coulombv, i, rxyz, box, nr_elem, deltaq, j, u, element_pointer,&
         nr_atoms, coulacc, hdim, max_nr_neigh)
  end subroutine ewald_real_space_single_latte_c
 
  subroutine ewald_real_space_single_c(COULOMBV, FCOUL, I, RX, RY, RZ, LBox, DELTAQ, J, U,&
       Element_Type, Nr_atoms, COULACC, TIMERATIO, HDIM, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space_Single")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: J
    real(c_double), value :: COULACC
    real(c_double), value :: TIMERATIO
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    real(c_double), intent(out) :: COULOMBV
    real(c_double), intent(out) :: FCOUL(3)
    call ewald_real_space_single(coulombv, fcoul, i, rx, ry, rz, lbox, deltaq, j, u, element_type,&
         nr_atoms, coulacc, timeratio, hdim, max_nr_neigh)
  end subroutine ewald_real_space_single_c
 
  subroutine ewald_real_space_matrix_latte_c(E, RXYZ, Box, U, Element_Pointer, Nr_atoms, COULACC,&
       nebcoul, totnebcoul, HDIM, Max_Nr_Neigh, Nr_Elem)&
       bind(C, name="Ewald_Real_Space_Matrix_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: Nr_Elem
    real(c_double), value :: COULACC
    real(c_double), intent(out) :: E(Nr_atoms,Nr_atoms)
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: U(Nr_elem)
    integer(c_int), target :: Element_Pointer(Nr_atoms)
    integer(c_int),    target :: totnebcoul(Nr_atoms)
    integer(c_int),    target :: nebcoul(4,Max_Nr_Neigh,Nr_atoms)
    call ewald_real_space_matrix_latte(e, rxyz, box, u, element_pointer, nr_atoms, coulacc, nebcoul,&
         totnebcoul, hdim, max_nr_neigh, nr_elem)
  end subroutine ewald_real_space_matrix_latte_c
 
  subroutine ewald_real_space_latte_c(COULOMBV, I, RXYZ, Box, DELTAQ, U, Element_Pointer, Nr_atoms,&
       COULACC, nebcoul, totnebcoul, HDIM, Max_Nr_Neigh, Nr_Elem)&
       bind(C, name="Ewald_Real_Space_latte")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    integer(c_int),    value :: Nr_Elem
    real(c_double), value :: COULACC
    real(c_double), target :: RXYZ(3,Nr_atoms)
    real(c_double), target :: Box(3,3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_elem)
    integer(c_int), target :: Element_Pointer(Nr_atoms)
    integer(c_int),    target :: totnebcoul(Nr_atoms)
    integer(c_int),    target :: nebcoul(4,Max_Nr_Neigh,Nr_atoms)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_latte(coulombv, i, rxyz, box, deltaq, u, element_pointer, nr_atoms, coulacc, &
         nebcoul, totnebcoul, hdim, max_nr_neigh, nr_elem)
  end subroutine ewald_real_space_latte_c
 
  subroutine ewald_real_space_test_c(COULOMBV, I, RX, RY, RZ, LBox, DELTAQ, U, Element_Type,&
       Nr_atoms, COULACC, nnRx, nnRy, nnRz, nrnnlist, nnType, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space_Test")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    real(c_double), value :: COULACC
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    integer(c_int),    target :: nrnnlist(Nr_atoms)
    integer(c_int),    target :: nnType(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRx(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRy(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRz(Nr_atoms,Max_Nr_Neigh)
    real(c_double), intent(out) :: COULOMBV
    call ewald_real_space_test(coulombv, i, rx, ry, rz, lbox, deltaq, u, element_type, nr_atoms,&
         coulacc, nnrx, nnry, nnrz, nrnnlist, nntype, max_nr_neigh)
  end subroutine ewald_real_space_test_c
 
  subroutine ewald_real_space_c(COULOMBV, FCOUL, I, RX, RY, RZ, LBox, DELTAQ, U, Element_Type,&
       Nr_atoms, COULACC, TIMERATIO, nnRx, nnRy, nnRz, nrnnlist, nnType, HDIM, Max_Nr_Neigh)&
       bind(C, name="Ewald_Real_Space")
    integer(c_int),    value :: Nr_atoms
    integer(c_int),    value :: HDIM
    integer(c_int),    value :: Max_Nr_Neigh
    integer(c_int),    value :: I
    real(c_double), value :: COULACC
    real(c_double), value :: TIMERATIO
    real(c_double), target :: RX(Nr_atoms)
    real(c_double), target :: RY(Nr_atoms)
    real(c_double), target :: RZ(Nr_atoms)
    real(c_double), target :: LBox(3)
    real(c_double), target :: DELTAQ(Nr_atoms)
    real(c_double), target :: U(Nr_atoms)
    character(c_char), target :: Element_Type(Nr_atoms)
    integer(c_int),    target :: nrnnlist(Nr_atoms)
    integer(c_int),    target :: nnType(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRx(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRy(Nr_atoms,Max_Nr_Neigh)
    real(c_double), target :: nnRz(Nr_atoms,Max_Nr_Neigh)
    real(c_double), intent(out) :: COULOMBV
    real(c_double), intent(out) :: FCOUL(3)
    call ewald_real_space(coulombv, fcoul, i, rx, ry, rz, lbox, deltaq, u, element_type, nr_atoms,&
         coulacc, timeratio, nnrx, nnry, nnrz, nrnnlist, nntype, hdim, max_nr_neigh)
  end subroutine ewald_real_space_c
 
  !------------------------------------------------
  ! prg_normalize_mod
  !------------------------------------------------
 
  subroutine prg_normalize_c(h_bml_c) bind(C, name="prg_normalize")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    h_bml%ptr = h_bml_c
    call prg_normalize(h_bml)
  end subroutine prg_normalize_c
 
  subroutine prg_normalize_fermi_c(h_bml_c, h1, hN, mu) bind(C, name="prg_normalize_fermi")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: h1
    real(c_double), value :: hN
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    call prg_normalize_fermi(h_bml, h1, hn, mu)
  end subroutine prg_normalize_fermi_c
 
  subroutine prg_normalize_implicit_fermi_c(h_bml_c, cnst, mu)&
       bind(C, name="prg_normalize_implicit_fermi")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: cnst
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    call prg_normalize_implicit_fermi(h_bml, cnst, mu)
  end subroutine prg_normalize_implicit_fermi_c
 
  subroutine prg_normalize_cheb_c(h_bml_c, mu, emin, emax, alpha, scaledmu)&
       bind(C, name="prg_normalize_cheb")
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    real(c_double), value :: mu
    real(c_double), value :: emin
    real(c_double), value :: emax
    real(c_double), value :: scaledmu
    real(c_double), value :: alpha
    h_bml%ptr = h_bml_c
    call prg_normalize_cheb(h_bml, mu, emin, emax, alpha, scaledmu)
  end subroutine prg_normalize_cheb_c
 
  !------------------------------------------------
  ! prg_sp2_mod
  !------------------------------------------------
 
  subroutine prg_sp2_fermi_init_c(h_bml_c, nsteps, nocc, tscale, threshold, occErrLimit, traceLimit, &
       x_bml_c, mu, beta, h1, hN, sgnlist) bind(C, name="prg_sp2_fermi_init")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: x_bml
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double), value :: nocc
    real(c_double), value :: tscale
    real(c_double), value :: threshold
    real(c_double), value :: occErrLimit
    real(c_double), value :: traceLimit
    real(c_double), value :: mu
    real(c_double), value :: beta
    real(c_double), value :: h1
    real(c_double), value :: hN
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi_init(h_bml, nsteps, nocc, tscale, threshold, occerrlimit, tracelimit,&
         x_bml, mu, beta, h1, hn, sgnlist)
  end subroutine prg_sp2_fermi_init_c
 
  subroutine prg_sp2_fermi_init_norecs_c(h_bml_c, nsteps, nocc, tscale, threshold, occErrLimit,&
       traceLimit, x_bml_c, mu, beta, h1, hN, sgnlist, verbose)&
       bind(C, name="prg_sp2_fermi_init_norecs")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: x_bml
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double), value :: nocc
    real(c_double), value :: tscale
    real(c_double), value :: threshold
    real(c_double), value :: occErrLimit
    real(c_double), value :: traceLimit
    real(c_double), value :: mu
    real(c_double), value :: beta
    real(c_double), value :: h1
    real(c_double), value :: hN
    integer(c_int), optional :: verbose
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi_init_norecs(h_bml, nsteps, nocc, tscale, threshold, occerrlimit,&
         tracelimit, x_bml, mu, beta, h1, hn, sgnlist, verbose)
  end subroutine prg_sp2_fermi_init_norecs_c
 
  subroutine prg_sp2_fermi_c(h_bml_c, osteps, nsteps, nocc, mu, beta, h1, hN, sgnlist,&
       threshold, eps, traceLimit, x_bml_c) bind(C, name="prg_sp2_fermi")
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr), value :: x_bml_c
    type(bml_matrix_t) :: x_bml
    integer(c_int), value :: osteps
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double), value :: nocc
    real(c_double), value :: threshold
    real(c_double), value :: eps
    real(c_double), value :: traceLimit
    real(c_double), value :: beta
    real(c_double), value :: h1
    real(c_double), value :: hN
    real(c_double), value :: mu
    h_bml%ptr = h_bml_c
    x_bml%ptr = x_bml_c
    call prg_sp2_fermi(h_bml, osteps, nsteps, nocc, mu, beta, h1, hn, sgnlist, threshold,&
         eps, tracelimit, x_bml)
  end subroutine prg_sp2_fermi_c
 
  subroutine prg_sp2_entropy_function_c(mu, h1, hN, nsteps, sgnlist, GG, ee)&
       bind(C, name="prg_sp2_entropy_function")
    real(c_double), value :: mu
    real(c_double), value :: h1
    real(c_double), value :: hN
    integer(c_int), value :: nsteps
    integer(c_int), target :: sgnlist(nsteps)
    real(c_double) :: GG(1001)
    real(c_double) :: ee(1001)
    real(c_double), allocatable :: GG_tmp(:), ee_tmp(:)
    call prg_sp2_entropy_function(mu, h1, hn, nsteps, sgnlist, gg_tmp, ee_tmp)
    gg = gg_tmp
    ee = ee_tmp
    deallocate(gg_tmp, ee_tmp)
  end subroutine prg_sp2_entropy_function_c
 
  !------------------------------------------------
  ! prg_sp2_mod
  !------------------------------------------------
 
  subroutine prg_sp2_basic_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, verbose) bind(C, name="prg_sp2_basic")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    rho_bml%ptr = rho_bml_c
    h_bml%ptr = h_bml_c
    call prg_sp2_basic(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol, verbose)
  end subroutine prg_sp2_basic_c
 
  subroutine prg_sp2_basic_tcore_c(h_bml_c, rho_bml_c, rhofull_bml_c, threshold, bndfil, minsp2iter,&
       maxsp2iter, sp2conv, idemtol, verbose) bind(C, name="prg_sp2_basic_tcore")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: bndfil
    real(c_double), value :: threshold
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr), value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    type(c_ptr), value :: rhofull_bml_c
    type(bml_matrix_t) :: rhofull_bml
    type(c_ptr), value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    rho_bml%ptr = rho_bml_c
    rhofull_bml%ptr = rhofull_bml_c
    h_bml%ptr = h_bml_c
    call prg_sp2_basic_tcore(h_bml, rho_bml, rhofull_bml, threshold, bndfil, minsp2iter, maxsp2iter,&
         sp2conv, idemtol, verbose)
  end subroutine prg_sp2_basic_tcore_c
 
  subroutine prg_sp2_alg2_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, verbose) bind(C, name="prg_sp2_alg2")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    integer(c_int), value  :: verbose
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol, verbose)
  end subroutine prg_sp2_alg2_c
 
  subroutine prg_sp2_alg2_genseq_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
       idemtol, pp, icount, vv, verbose) bind(C, name="prg_sp2_alg2_genseq")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    real(c_double), target :: vv(:)
    character(c_char), value :: sp2conv
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int)  :: verbose
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2_genseq(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv, idemtol,&
         pp, icount, vv, verbose)
  end subroutine prg_sp2_alg2_genseq_c
 
  subroutine prg_sp2_alg2_seq_c(h_bml_c, rho_bml_c, threshold, pp, icount, vv, verbose)&
       bind(C, name="prg_sp2_alg2_seq")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int)  :: verbose
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg2_seq(h_bml, rho_bml, threshold, pp, icount, vv, verbose)
  end subroutine prg_sp2_alg2_seq_c
 
  subroutine prg_prg_sp2_alg2_seq_inplace_c(rho_bml_c, threshold, pp, icount, vv, mineval, maxeval,&
       verbose) bind(C, name="prg_prg_sp2_alg2_seq_inplace")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double)  :: mineval
    real(c_double)  :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    integer(c_int)  :: verbose
    rho_bml%ptr = rho_bml_c
    call prg_prg_sp2_alg2_seq_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval,verbose)
  end subroutine prg_prg_sp2_alg2_seq_inplace_c
 
  subroutine prg_sp2_alg1_c(h_bml_c, rho_bml_c, threshold, bndfil, minsp2iter, maxsp2iter,&
       sp2conv, idemtol, verbose) bind(C, name="prg_sp2_alg1")
    integer(c_int), value :: minsp2iter
    integer(c_int), value :: maxsp2iter
    integer(c_int), value :: verbose
    real(c_double), value :: threshold
    real(c_double), value :: bndfil
    real(c_double), value :: idemtol
    character(c_char), value :: sp2conv
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
 
    call prg_sp2_alg1(h_bml, rho_bml, threshold, bndfil, minsp2iter, maxsp2iter, sp2conv,&
         idemtol, verbose)
  end subroutine prg_sp2_alg1_c
 
  subroutine prg_sp2_alg1_seq_c(h_bml_c, rho_bml_c, threshold, pp, icount, vv)&
       bind(C, name="prg_sp2_alg1_seq")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    type(c_ptr),value :: h_bml_c
    type(bml_matrix_t) :: h_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    h_bml%ptr = h_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_alg1_seq(h_bml, rho_bml, threshold, pp, icount, vv)
  end subroutine prg_sp2_alg1_seq_c
 
  subroutine prg_prg_sp2_alg1_seq_inplace_c(rho_bml_c, threshold, pp, icount, vv, mineval, maxeval)&
       bind(C, name="prg_prg_sp2_alg1_seq_inplace")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    rho_bml%ptr = rho_bml_c
    call prg_prg_sp2_alg1_seq_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval)
  end subroutine prg_prg_sp2_alg1_seq_inplace_c
 
  subroutine prg_sp2_submatrix_c(ham_bml_c, rho_bml_c, threshold, pp, icount, vv, mineval, maxeval,&
       core_size) bind(C, name="prg_sp2_submatrix")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    integer(c_int), value :: core_size
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: ham_bml_c
    type(bml_matrix_t) :: ham_bml
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    ham_bml%ptr = ham_bml_c
    rho_bml%ptr = rho_bml_c
    call prg_sp2_submatrix(ham_bml, rho_bml, threshold, pp, icount, vv, mineval, maxeval, core_size)
  end subroutine prg_sp2_submatrix_c
 
  subroutine prg_sp2_submatrix_inplace_c(rho_bml_c, threshold, pp, icount, vv, mineval, maxeval,&
       core_size) bind(C, name="prg_sp2_submatrix_inplace")
    integer(c_int), value :: icount
    integer(c_int), target :: pp(:)
    integer(c_int), value :: core_size
    real(c_double), value :: threshold
    real(c_double), target :: vv(:)
    real(c_double), value :: mineval
    real(c_double), value :: maxeval
    type(c_ptr),value :: rho_bml_c
    type(bml_matrix_t) :: rho_bml
    rho_bml%ptr = rho_bml_c
    call prg_sp2_submatrix_inplace(rho_bml, threshold, pp, icount, vv, mineval, maxeval, core_size)
  end subroutine prg_sp2_submatrix_inplace_c
 
  !------------------------------------------------
  ! prg_timer_mod
  !------------------------------------------------
 
  subroutine timer_prg_init_c() bind(C, name="timer_prg_init")
    call timer_prg_init()
  end subroutine timer_prg_init_c
 
  subroutine prg_timer_shutdown_c() bind(C, name="prg_timer_shutdown")
    call prg_timer_shutdown()
  end subroutine prg_timer_shutdown_c
 
  subroutine prg_timer_start_c(itimer, tag) bind(C, name="prg_timer_start")
    integer(c_int) :: itimer
    character(c_char), value :: tag
    call prg_timer_start(itimer, tag)
  end subroutine prg_timer_start_c
 
  subroutine prg_timer_stop_c(itimer, verbose) bind(C, name="prg_timer_stop")
    integer(c_int) :: itimer, verbose
    call prg_timer_stop(itimer, verbose)
  end subroutine prg_timer_stop_c
 
  subroutine prg_timer_collect_c() bind(C, name="prg_timer_collect")
    call prg_timer_collect()
  end subroutine prg_timer_collect_c
 
  subroutine prg_timer_results_c() bind(C, name="prg_timer_results")
    call prg_timer_results()
  end subroutine prg_timer_results_c
 
  subroutine prg_print_date_and_time_c(tag) bind(C, name="prg_print_date_and_time")
    character(c_char), value :: tag
    call prg_print_date_and_time(tag)
  end subroutine prg_print_date_and_time_c
 
 
 
  !------------------------------------------------
  ! prg_openfiles_mod
  !------------------------------------------------
 
  subroutine prg_open_file_c(io, name) bind(C, name="prg_open_file")
    character(c_char), value :: name
    integer(c_int), value :: io
    call prg_open_file(io, name)
  end subroutine prg_open_file_c
 
  subroutine prg_open_file_to_read_c(io, name) bind(C, name="prg_open_file_to_read")
    character(c_char), value :: name
    integer(c_int), value :: io
    call prg_open_file_to_read(io, name)
  end subroutine prg_open_file_to_read_c
 
 
end module prg_c_interface