36#if defined(HAVE_ETSF_IO)
52 use,
intrinsic :: iso_fortran_env
114 subroutine output_init(outp, namespace, space, st, gr, nst, ks)
115 type(output_t),
intent(out) :: outp
116 type(namespace_t),
intent(in) :: namespace
117 class(space_t),
intent(in) :: space
118 type(states_elec_t),
intent(in) :: st
119 type(grid_t),
intent(in) :: gr
120 integer,
intent(in) :: nst
121 type(v_ks_t),
intent(inout) :: ks
125 character(len=80) :: nst_string, default
132 if (outp%what(option__output__wfs_fourier))
then
134 message(1) =
"Wave functions in Fourier space not supported on GPUs."
141 if (outp%what(option__output__elf) .or. outp%what(option__output__elf_basins))
then
142 if (space%dim /= 2 .and. space%dim /= 3)
then
143 outp%what(option__output__elf) = .false.
144 outp%what(option__output__elf_basins) = .false.
145 write(
message(1),
'(a)')
'Cannot calculate ELF except in 2D and 3D.'
151 if (outp%what(option__output__mmb_wfs))
then
155 if (outp%what(option__output__xc_torque))
then
156 if (st%d%ispin /=
spinors)
then
157 write(
message(1),
'(a)')
'The output xc_torque can only be computed for spinors.'
160 if (space%dim /= 3)
then
161 write(
message(1),
'(a)')
'The output xc_torque can only be computed in the 3D case.'
165 if (outp%what(option__output__mmb_den))
then
174 if (outp%what(option__output__energy_density))
call messages_experimental(
"'Output = energy_density'", namespace=namespace)
175 if (outp%what(option__output__heat_current))
call messages_experimental(
"'Output = heat_current'", namespace=namespace)
177 if (outp%what(option__output__wfs) .or. outp%what(option__output__wfs_sqmod))
then
189 write(nst_string,
'(i6)') nst
190 write(default,
'(a,a)')
"1-", trim(adjustl(nst_string))
191 call parse_variable(namespace,
'OutputWfsNumber', default, outp%wfs_list)
194 if (
parse_block(namespace,
'CurrentThroughPlane', blk) == 0)
then
195 if (.not. outp%what(option__output__j_flow))
then
196 outp%what(option__output__j_flow) = .
true.
197 call parse_variable(namespace,
'OutputInterval', 50, outp%output_interval(option__output__j_flow))
248 select case (space%dim)
266 norm = norm2(outp%plane%u(1:3))
268 write(
message(1),
'(a)')
'u-vector for CurrentThroughPlane cannot have norm zero.'
271 outp%plane%u(1:3) = outp%plane%u(1:3) / norm
273 norm = norm2(outp%plane%v(1:3))
275 write(
message(1),
'(a)')
'v-vector for CurrentThroughPlane cannot have norm zero.'
278 outp%plane%v(1:3) = outp%plane%v(1:3) / norm
280 outp%plane%n(1) = outp%plane%u(2)*outp%plane%v(3) - outp%plane%u(3)*outp%plane%v(2)
281 outp%plane%n(2) = outp%plane%u(3)*outp%plane%v(1) - outp%plane%u(1)*outp%plane%v(3)
282 outp%plane%n(3) = outp%plane%u(1)*outp%plane%v(2) - outp%plane%u(2)*outp%plane%v(1)
294 norm = norm2(outp%line%u(1:2))
296 write(
message(1),
'(a)')
'u-vector for CurrentThroughPlane cannot have norm zero.'
299 outp%line%u(1:2) = outp%line%u(1:2) / norm
301 outp%line%n(1) = -outp%line%u(2)
302 outp%line%n(2) = outp%line%u(1)
316 if (outp%what(option__output__matrix_elements))
then
319 outp%me%what = .false.
322 if (outp%what(option__output__berkeleygw))
then
324 message(1) =
"BerkeleyGW is not compatible with GPUs."
331 if (outp%what(option__output__potential_gradient) .and. .not. outp%what(option__output__potential))
then
332 outp%what(option__output__potential) = .
true.
333 outp%output_interval(option__output__potential) = outp%output_interval(option__output__potential_gradient)
345 call parse_variable(namespace,
'OutputDuringSCF', .false., outp%duringscf)
358 call parse_variable(namespace,
'RestartWriteInterval', 50, outp%restart_write_interval)
359 if (outp%restart_write_interval <= 0)
then
360 message(1) =
"RestartWriteInterval must be > 0."
375 call parse_variable(namespace,
'OutputIterDir',
"output_iter", outp%iter_dir)
376 if (any(outp%what) .and. any(outp%output_interval > 0))
then
377 call io_mkdir(outp%iter_dir, namespace)
390 if (outp%what(option__output__current_dia))
then
391 message(1) =
"The diamagnetic current will be calculated only if CalculateDiamagneticCurrent = yes."
399 subroutine output_all(outp, namespace, space, dir, gr, ions, iter, st, hm, ks)
402 class(
space_t),
intent(in) :: space
403 character(len=*),
intent(in) :: dir
404 type(
grid_t),
intent(in) :: gr
405 type(
ions_t),
intent(in) :: ions
406 integer,
intent(in) :: iter
409 type(
v_ks_t),
intent(inout) :: ks
411 integer :: idir, ierr, iout, iunit
412 character(len=MAX_PATH_LEN) :: fname
417 if (any(outp%what))
then
418 message(1) =
"Info: Writing output to " // trim(dir)
423 if (outp%what_now(option__output__mesh_r, iter))
then
424 do idir = 1, space%dim
425 write(fname,
'(a,a)')
'mesh_r-',
index2axis(idir)
427 gr, gr%x(:,idir),
units_out%length, ierr, pos=ions%pos, atoms=ions%atom)
431 call output_states(outp, namespace, space, dir, st, gr, ions, hm, iter)
432 call output_hamiltonian(outp, namespace, space, dir, hm, st, gr%der, ions, gr, iter, st%st_kpt_mpi_grp)
435 if (outp%what_now(option__output__el_pressure, iter))
then
439 if (st%d%spin_channels > 1)
then
446 if (outp%what_now(option__output__j_flow, iter))
then
450 if (outp%what_now(option__output__geometry, iter))
then
451 if (
bitand(outp%how(option__output__geometry), option__outputformat__xcrysden) /= 0)
then
454 if (
bitand(outp%how(option__output__geometry), option__outputformat__xyz) /= 0)
then
455 call ions%write_xyz(trim(dir)//
'/geometry')
456 if (ions%space%is_periodic())
then
457 call ions%write_crystal(dir)
460 if (
bitand(outp%how(option__output__geometry), option__outputformat__vtk) /= 0)
then
461 call ions%write_vtk_geometry(trim(dir)//
'/geometry')
465 if (outp%what_now(option__output__forces, iter))
then
466 if (
bitand(outp%how(option__output__forces), option__outputformat__bild) /= 0)
then
467 call ions%write_bild_forces_file(dir,
"forces")
470 gr, namespace, total_forces = ions%tot_force)
474 if (outp%what_now(option__output__matrix_elements, iter))
then
475 call output_me(outp%me, namespace, space, dir, st, gr, ions, hm)
478 do iout = lbound(outp%how, 1), ubound(outp%how, 1)
479 if (
bitand(outp%how(iout), option__outputformat__etsf) /= 0)
then
480 call output_etsf(outp, namespace, space, dir, st, gr, hm%kpoints, ions, iter)
485 if (outp%what_now(option__output__berkeleygw, iter))
then
489 if (outp%what_now(option__output__energy_density, iter))
then
493 if (outp%what_now(option__output__stress, iter))
then
495 iunit =
io_open(trim(dir)//
'/stress', namespace, action=
'write')
496 call output_stress(iunit, space%periodic_dim, st%stress_tensors)
501 if (outp%what_now(option__output__occ_matrices, iter))&
504 if (outp%what_now(option__output__effectiveu, iter))&
507 if (outp%what_now(option__output__magnetization, iter))&
510 if (outp%what_now(option__output__local_orbitals, iter))&
511 call output_dftu_orbitals(outp, dir, namespace, space, hm%lda_u, st, gr, ions, hm%phase%is_allocated())
513 if (outp%what_now(option__output__kanamoriu, iter))&
517 if (outp%what_now(option__output__photon_correlator, iter))
then
518 write(fname,
'(a)')
'photon_correlator'
519 call dio_function_output(outp%how(option__output__photon_correlator), dir, trim(fname), namespace, space, &
520 gr, ks%oep_photon%pt%correlator(:,1),
units_out%length, ierr, pos=ions%pos, atoms=ions%atom)
526 if (outp%what_now(option__output__xc_torque, iter))
then
528 write(
message(1),
'(a)')
'The output xc_torque can only be computed when there is a xc potential.'
544 class(
space_t),
intent(in) :: space
545 character(len=*),
intent(in) :: dir
548 type(
grid_t),
intent(in) :: gr
549 type(
ions_t),
intent(in) :: ions
550 integer,
intent(in) :: iter
552 real(real64),
allocatable :: f_loc(:,:)
553 character(len=MAX_PATH_LEN) :: fname
554 integer :: is, ierr, imax
559 mpi_grp = st%dom_st_kpt_mpi_grp
565 safe_allocate(f_loc(1:gr%np, 1:imax))
568 if (outp%what_now(option__output__elf, iter) .or. outp%what_now(option__output__elf_basins, iter))
then
569 assert(space%dim /= 1)
571 call elf_calc(space, st, gr, hm%kpoints, f_loc)
574 if (outp%what_now(option__output__elf, iter))
then
575 write(fname,
'(a)')
'elf_rs'
576 call dio_function_output(outp%how(option__output__elf), dir, trim(fname), namespace, space, gr, &
577 f_loc(:,imax),
unit_one, ierr, pos=ions%pos, atoms=ions%atom, grp = mpi_grp)
582 write(fname,
'(a,i1)')
'elf_rs-sp', is
583 call dio_function_output(outp%how(option__output__elf), dir, trim(fname), namespace, space, gr, &
584 f_loc(:, is),
unit_one, ierr, pos=ions%pos, atoms=ions%atom, grp = mpi_grp)
590 if (outp%what_now(option__output__elf_basins, iter))
then
591 call out_basins(f_loc(:,1),
"elf_rs_basins", outp%how(option__output__elf_basins))
596 if (outp%what_now(option__output__bader, iter))
then
597 do is = 1, st%d%nspin
602 call dio_function_output(outp%how(option__output__bader), dir, trim(fname), namespace, space, gr, &
603 f_loc(:,is),
units_out%length**(-2 - space%dim), ierr, &
604 pos=ions%pos, atoms=ions%atom, grp = mpi_grp)
607 call out_basins(f_loc(:,1), fname, outp%how(option__output__bader))
612 if (outp%what_now(option__output__el_pressure, iter))
then
614 call dio_function_output(outp%how(option__output__el_pressure), dir,
"el_pressure", namespace, space, gr, &
615 f_loc(:,1),
unit_one, ierr, pos=ions%pos, atoms=ions%atom, grp = mpi_grp)
619 safe_deallocate_a(f_loc)
625 subroutine out_basins(ff, filename, output_how)
626 real(real64),
intent(in) :: ff(:)
627 character(len=*),
intent(in) :: filename
628 integer(int64),
intent(in) :: output_how
630 character(len=MAX_PATH_LEN) :: fname
637 call basins_analyze(basins, namespace, gr, ff(:), st%rho, 0.01_real64)
640 real(basins%map, real64) , unit_one, ierr, pos=ions%pos, atoms=ions%atom, grp = mpi_grp)
643 write(fname,
'(4a)') trim(dir),
'/', trim(filename),
'.info'
644 iunit =
io_open(trim(fname), namespace, action =
'write')
660 type(
grid_t),
intent(in) :: gr
661 real(real64),
intent(out) :: pressure(:)
663 real(real64),
allocatable :: rho(:,:), lrho(:), tau(:,:)
664 real(real64) :: p_tf, dens
669 safe_allocate( rho(1:gr%np_part, 1:st%d%nspin))
670 safe_allocate(lrho(1:gr%np))
671 safe_allocate( tau(1:gr%np, 1:st%d%nspin))
678 do is = 1, st%d%spin_channels
682 pressure(:) = pressure(:) + &
687 dens = sum(rho(ii,1:st%d%spin_channels))
694 pressure(ii) = pressure(ii) + (dens*hm%ks_pot%vxc(ii,1) - hm%energy%exchange - hm%energy%correlation)
696 pressure(ii) = pressure(ii)/p_tf
708 class(
space_t),
intent(in) :: space
709 character(len=*),
intent(in) :: dir
711 type(
v_ks_t),
intent(inout) :: ks
713 type(
ions_t),
intent(in) :: ions
714 type(
grid_t),
intent(in) :: gr
716 integer :: is, ierr, ip
717 character(len=MAX_PATH_LEN) :: fname
719 real(real64),
allocatable :: energy_density(:, :)
720 real(real64),
allocatable :: ex_density(:)
721 real(real64),
allocatable :: ec_density(:)
726 safe_allocate(energy_density(1:gr%np, 1:st%d%nspin))
732 do is = 1, st%d%nspin
734 energy_density(ip, is) = energy_density(ip, is) + st%rho(ip, is)*hm%ep%vpsl(ip)
739 do is = 1, st%d%nspin
741 energy_density(ip, is) = energy_density(ip, is) +
m_half*st%rho(ip, is)*hm%ks_pot%vhartree(ip)
746 safe_allocate(ex_density(1:gr%np))
747 safe_allocate(ec_density(1:gr%np))
749 call xc_get_vxc(gr, ks%xc, st, hm%kpoints, hm%psolver, namespace, space, st%rho, st%d%ispin, &
750 hm%ions%latt%rcell_volume, ex_density = ex_density, ec_density = ec_density)
751 do is = 1, st%d%nspin
753 energy_density(ip, is) = energy_density(ip, is) + ex_density(ip) + ec_density(ip)
757 safe_deallocate_a(ex_density)
758 safe_deallocate_a(ec_density)
760 do is = 1, st%d%spin_channels
762 call dio_function_output(outp%how(option__output__energy_density), dir, trim(fname), namespace, space, gr, &
763 energy_density(:, is),
unit_one, ierr, pos=ions%pos, atoms=ions%atom, grp = st%dom_st_kpt_mpi_grp)
765 safe_deallocate_a(energy_density)
775 need_exx =(outp%what(option__output__berkeleygw) &
776 .or. outp%me%what(option__outputmatrixelements__two_body) &
777 .or. outp%me%what(option__outputmatrixelements__two_body_exc_k))
784 character(len=*),
intent(in) :: dir
786 class(
space_t),
intent(in) :: space
787 type(
lda_u_t),
intent(in) :: this
789 class(
mesh_t),
intent(in) :: mesh
790 type(
ions_t),
intent(in) :: ions
791 logical,
intent(in) :: has_phase
793 integer :: ios, im, ik, idim, ierr
794 complex(real64),
allocatable :: tmp(:)
795 real(real64),
allocatable :: dtmp(:)
798 character(len=MAX_PATH_LEN) :: fname
804 if (this%basis%use_submesh)
then
806 safe_allocate(dtmp(1:mesh%np))
808 safe_allocate(tmp(1:mesh%np))
812 do ios = 1, this%norbsets
813 os => this%orbsets(ios)
814 do ik = st%d%kpt%start, st%d%kpt%end
815 do im = 1, this%orbsets(ios)%norbs
816 do idim = 1, min(os%ndim, st%d%dim)
818 if (min(os%ndim, st%d%dim) > 1)
then
819 write(fname,
'(a,i1,a,i3.3,a,i8.8,a,i1)')
'orb', im,
'-os', ios,
'-k', ik,
'-sp', idim
821 write(fname,
'(a,i1,a,i3.3,a,i8.8)')
'orb', im,
'-os', ios,
'-k', ik
824 if (min(os%ndim, st%d%dim) > 1)
then
825 write(fname,
'(a,i1,a,i3.3,a,i1)')
'orb', im,
'-os', ios,
'-sp', idim
827 write(fname,
'(a,i1,a,i3.3)')
'orb', im,
'-os', ios
831 if (.not. this%basis%use_submesh)
then
832 call zio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, &
833 mesh, os%eorb_mesh(1:mesh%np,im,idim,ik), fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
837 call zio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, &
838 mesh, tmp, fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
841 if (.not. this%basis%use_submesh)
then
843 call dio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, mesh, &
844 os%dorb(1:mesh%np,idim,im), fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
846 call zio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, mesh, &
847 os%zorb(1:mesh%np,idim,im), fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
853 call dio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, &
854 mesh, dtmp, fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
858 call zio_function_output(outp%how(option__output__local_orbitals), dir, fname, namespace, space, &
859 mesh, tmp, fn_unit, ierr, pos=ions%pos, atoms=ions%atom)
868 safe_deallocate_a(tmp)
869 safe_deallocate_a(dtmp)
877 logical,
intent(in) :: states_are_real
881 if (outp%what(option__output__current) &
882 .or. outp%what(option__output__current_dia) &
883 .or. outp%what(option__output__heat_current) &
884 .or. outp%what(option__output__current_kpt))
then
885 if (.not. states_are_real)
then
888 message(1) =
'No current density output for real states since it is identically zero.'
896#include "output_etsf_inc.F90"
898#include "output_states_inc.F90"
900#include "output_h_inc.F90"
903#include "complex.F90"
904#include "output_linear_response_inc.F90"
908#include "output_linear_response_inc.F90"
pure logical function, public accel_is_enabled()
subroutine, public basins_write(this, mesh, iunit)
subroutine, public basins_init(this, namespace, mesh)
subroutine, public basins_analyze(this, namespace, mesh, f, rho, threshold)
subroutine, public basins_end(this)
This module implements a calculator for the density and defines related functions.
subroutine, public density_calc(st, gr, density, istin)
Computes the density from the orbitals in st.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public dderivatives_lapl(der, ff, op_ff, ghost_update, set_bc, factor)
apply the Laplacian to a mesh function
Module that handles computing and output of various density of states.
integer, parameter, public unpolarized
Parameters...
integer, parameter, public spinors
integer, parameter, public spin_polarized
subroutine, public elf_calc(space, st, gr, kpoints, elf, de)
(time-dependent) electron localization function, (TD)ELF.
Fast Fourier Transform module. This module provides a single interface that works with different FFT ...
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_four
real(real64), parameter, public m_pi
some mathematical constants
complex(real64), parameter, public m_z0
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_half
real(real64), parameter, public m_one
real(real64), parameter, public m_three
real(real64), parameter, public m_five
This module implements the underlying real-space grid.
This module defines classes and functions for interaction partners.
subroutine, public zio_function_output(how, dir, fname, namespace, space, mesh, ff, unit, ierr, pos, atoms, grp, root)
Top-level IO routine for functions defined on the mesh.
subroutine, public io_function_read_what_how_when(namespace, space, what, how, output_interval, what_tag_in, how_tag_in, output_interval_tag_in, ignore_error)
subroutine, public dio_function_output(how, dir, fname, namespace, space, mesh, ff, unit, ierr, pos, atoms, grp, root)
Top-level IO routine for functions defined on the mesh.
subroutine, public write_xsf_geometry_file(dir, fname, space, latt, pos, atoms, mesh, namespace, total_forces)
subroutine, public io_close(iunit, grp)
subroutine, public io_mkdir(fname, namespace, parents)
integer function, public io_open(file, namespace, action, status, form, position, die, recl, grp)
A module to handle KS potential, without the external potential.
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public kohn_sham_dft
subroutine, public lda_u_write_occupation_matrices(dir, this, st, namespace)
Prints the occupation matrices at the end of the scf calculation.
subroutine, public lda_u_write_kanamoriu(dir, st, this, namespace)
subroutine, public lda_u_write_magnetization(dir, this, ions, mesh, st, namespace)
subroutine, public lda_u_write_effectiveu(dir, this, namespace)
integer, parameter, public dft_u_none
This module is intended to contain "only mathematical" functions and procedures.
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
subroutine, public messages_not_implemented(feature, namespace)
subroutine, public messages_warning(no_lines, all_nodes, namespace)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
subroutine, public messages_experimental(name, namespace)
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
subroutine, public output_berkeleygw(bgw, namespace, space, dir, st, gr, ks, hm, ions)
subroutine, public output_berkeleygw_init(nst, namespace, bgw, periodic_dim)
this module contains the low-level part of the output system
character(len=max_path_len) function, public get_filename_with_spin(output, nspin, spin_index)
Returns the filame as output, or output-spX is spin polarized.
subroutine, public output_me_init(this, namespace, space, st, gr, nst)
subroutine, public output_me(this, namespace, space, dir, st, gr, ions, hm)
this module contains the output system
subroutine calc_electronic_pressure(st, hm, gr, pressure)
subroutine, public output_states(outp, namespace, space, dir, st, gr, ions, hm, iter)
logical function, public output_needs_current(outp, states_are_real)
subroutine, public output_hamiltonian(outp, namespace, space, dir, hm, st, der, ions, gr, iter, grp)
subroutine, public output_all(outp, namespace, space, dir, gr, ions, iter, st, hm, ks)
logical function, public output_need_exchange(outp)
subroutine, public output_init(outp, namespace, space, st, gr, nst, ks)
subroutine output_xc_torque(outp, namespace, dir, mesh, hm, st, ions, space)
subroutine, public output_current_flow(outp, namespace, space, dir, gr, st, kpoints)
subroutine, public zoutput_lr(outp, namespace, space, dir, st, mesh, lr, idir, isigma, ions, pert_unit)
subroutine, public doutput_lr(outp, namespace, space, dir, st, mesh, lr, idir, isigma, ions, pert_unit)
subroutine, public output_scalar_pot(outp, namespace, space, dir, mesh, ions, ext_partners, time)
subroutine output_energy_density(outp, namespace, space, dir, hm, ks, st, ions, gr)
subroutine output_dftu_orbitals(outp, dir, namespace, space, this, st, mesh, ions, has_phase)
subroutine output_localization_funct(outp, namespace, space, dir, st, hm, gr, ions, iter)
subroutine output_etsf(outp, namespace, space, dir, st, gr, kpoints, ions, iter)
To create an etsf file one has to do the following:
integer function, public parse_block(namespace, name, blk, check_varinfo_)
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
pure logical function, public states_are_real(st)
This module defines routines to write information about states.
subroutine, public states_elec_calc_quantities(gr, st, kpoints, nlcc, kinetic_energy_density, paramagnetic_current, density_gradient, density_laplacian, gi_kinetic_energy_density, st_end)
calculated selected quantities
This module implements the calculation of the stress tensor.
subroutine, public output_stress(iunit, space_dim, stress_tensors, all_terms)
subroutine, public add_last_slash(str)
Adds a '/' in the end of the string, only if it missing. Useful for directories.
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
This module defines the unit system, used for input and output.
type(unit_system_t), public units_out
type(unit_system_t), public units_inp
the units systems for reading and writing
type(unit_t), public unit_one
some special units required for particular quantities
This module is intended to contain simple general-purpose utility functions and procedures.
character pure function, public index2axis(idir)
subroutine, public v_ks_calculate_current(this, calc_cur)
integer, parameter, public oep_level_full
subroutine out_basins(ff, filename, output_how)
Description of the grid, containing information on derivatives, stencil, and symmetries.
Class to describe DFT+U parameters.
Describes mesh distribution to nodes.
This is defined even when running serial.
Output information for BerkeleyGW.
The states_elec_t class contains all electronic wave functions.