# bitmask module

The central part of this module is the `bitmasks_module.f90` file. It contains the constants that will be used to define on which kind of integer the bitmasks will be defined.

In the program, to represent a determinant as a pair of bitstrings, the determinant should be defined as

    use bitmasks
    integer(bit_kind)  :: determinant(N_int,2)

`bitmasks_routines.irp.f` contains helper routines to manipulate bitmask, like transforming a bit string to a list of integers for example.

`bit_kind_shift`, `bit_kind_size` and `bit_kind` are supposed to be consistent:

    2**bit_kind_shift = bit_kind_size
    bit_kind = bit_kind_size / 8

For an example of how to use the bitmaks, see the file `example.irp.f`.

## Providers

`act_bitmask`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`cas_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: cas_bitmask  (N_int,2,N_cas_bitmask)

  Bitmasks for CAS reference determinants. (N_int, alpha/beta, CAS reference)

  Needs:

  `ezfio_filename` `full_ijkl_bitmask` `generators_bitmask_restart` | `hf_bitmask` `mpi_master` `n_cas_bitmask` | `n_generators_bitmask` `n_int`

  Needed by:

  `closed_shell_ref_bitmask` `psi_cas` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` | `reunion_of_core_inact_act_bitmask`

`closed_shell_ref_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: closed_shell_ref_bitmask     (N_int,2)

  Needs:

  `cas_bitmask` | `n_int` | `ref_bitmask`

`core_bitmask`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`core_inact_act_bitmask_4`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: core_inact_act_bitmask_4     (N_int,4)

  Needs:

  `n_int` | `reunion_of_core_inact_act_bitmask` |

  Needed by:

  `mo_two_e_integrals_in_map` |  |

`core_inact_virt_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: inact_virt_bitmask   (N_int,2)
      integer(bit_kind), allocatable  :: core_inact_virt_bitmask      (N_int,2)

  Reunion of the inactive and virtual bitmasks

  Needs:

  `list_inact` | `n_int` |

`del_bitmask`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`dim_list_act_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: dim_list_core_orb
      integer :: dim_list_inact_orb
      integer :: dim_list_virt_orb
      integer :: dim_list_act_orb
      integer :: dim_list_del_orb

  dimensions for the allocation of list_inact, list_virt, list_core and list_act it is at least 1

  Needs:

  `n_core_orb` |  |

  Needed by:

  `list_inact` |  |

`dim_list_core_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: dim_list_core_orb
      integer :: dim_list_inact_orb
      integer :: dim_list_virt_orb
      integer :: dim_list_act_orb
      integer :: dim_list_del_orb

  dimensions for the allocation of list_inact, list_virt, list_core and list_act it is at least 1

  Needs:

  `n_core_orb` |  |

  Needed by:

  `list_inact` |  |

`dim_list_del_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: dim_list_core_orb
      integer :: dim_list_inact_orb
      integer :: dim_list_virt_orb
      integer :: dim_list_act_orb
      integer :: dim_list_del_orb

  dimensions for the allocation of list_inact, list_virt, list_core and list_act it is at least 1

  Needs:

  `n_core_orb` |  |

  Needed by:

  `list_inact` |  |

`dim_list_inact_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: dim_list_core_orb
      integer :: dim_list_inact_orb
      integer :: dim_list_virt_orb
      integer :: dim_list_act_orb
      integer :: dim_list_del_orb

  dimensions for the allocation of list_inact, list_virt, list_core and list_act it is at least 1

  Needs:

  `n_core_orb` |  |

  Needed by:

  `list_inact` |  |

`dim_list_virt_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: dim_list_core_orb
      integer :: dim_list_inact_orb
      integer :: dim_list_virt_orb
      integer :: dim_list_act_orb
      integer :: dim_list_del_orb

  dimensions for the allocation of list_inact, list_virt, list_core and list_act it is at least 1

  Needs:

  `n_core_orb` |  |

  Needed by:

  `list_inact` |  |

`full_ijkl_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: full_ijkl_bitmask    (N_int)

  Bitmask to include all possible MOs

  Needs:

  `mo_class` | `mo_num` | `n_int`

  Needed by:

  `cas_bitmask` `fock_operator_closed_shell_ref_bitmask` | `fock_wee_closed_shell` `full_ijkl_bitmask_4` | `generators_bitmask` `generators_bitmask_restart`

`full_ijkl_bitmask_4`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: full_ijkl_bitmask_4  (N_int,4)

  Needs:

  `full_ijkl_bitmask` | `n_int` |

  Needed by:

  `mo_two_e_integrals_erf_in_map` | `mo_two_e_integrals_in_map` |

`generators_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: generators_bitmask   (N_int,2,6,N_generators_bitmask)

  Bitmasks for generator determinants. (N_int, alpha/beta, hole/particle, generator).

  3rd index is :

  - 1 : hole for single exc
  - 2 : particle for single exc
  - 3 : hole for 1st exc of double
  - 4 : particle for 1st exc of double
  - 5 : hole for 2nd exc of double
  - 6 : particle for 2nd exc of double

  Needs:

  `ezfio_filename` `full_ijkl_bitmask` | `mpi_master` `n_generators_bitmask` | `n_int`

`generators_bitmask_restart`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: generators_bitmask_restart   (N_int,2,6,N_generators_bitmask_restart)

  Bitmasks for generator determinants. (N_int, alpha/beta, hole/particle, generator).

  3rd index is :

  - 1 : hole for single exc
  - 2 : particle for single exc
  - 3 : hole for 1st exc of double
  - 4 : particle for 1st exc of double
  - 5 : hole for 2nd exc of double
  - 6 : particle for 2nd exc of double

  Needs:

  `ezfio_filename` `full_ijkl_bitmask` | `mpi_master` `n_generators_bitmask` | `n_generators_bitmask_restart` `n_int`

  Needed by:

  `cas_bitmask` |  |

`hf_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: hf_bitmask   (N_int,2)

  Hartree Fock bit mask

  Needs:

  `elec_alpha_num` | `elec_beta_num` | `n_int`

  Needed by:

  `cas_bitmask` `degree_max_generators` `double_exc_bitmask` | `max_degree_exc` `psi_cas` `psi_det` | `ref_bitmask` `single_exc_bitmask` `unpaired_alpha_electrons`

`i_bitmask_gen`

  File : `bitmask/bitmasks.irp.f`

      integer :: i_bitmask_gen

  Current bitmask for the generators

`inact_bitmask`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`inact_virt_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: inact_virt_bitmask   (N_int,2)
      integer(bit_kind), allocatable  :: core_inact_virt_bitmask      (N_int,2)

  Reunion of the inactive and virtual bitmasks

  Needs:

  `list_inact` | `n_int` |

`index_holes_bitmask`

  File : `bitmask/modify_bitmasks.irp.f`

      integer, allocatable    :: index_holes_bitmask  (3)

  Index of the holes in the generators_bitmasks

`index_particl_bitmask`

  File : `bitmask/modify_bitmasks.irp.f`

      integer, allocatable    :: index_particl_bitmask        (3)

  Index of the holes in the generators_bitmasks

`list_act`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_act_reverse`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_core`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_core_inact_act`

  File : `bitmask/bitmasks.irp.f`

      integer, allocatable    :: list_core_inact_act  (n_core_inact_act_orb)
      integer, allocatable    :: list_core_inact_act_reverse  (mo_num)

  Needs:

  `list_inact` `mo_num` | `n_int` | `reunion_of_core_inact_act_bitmask`

`list_core_inact_act_reverse`

  File : `bitmask/bitmasks.irp.f`

      integer, allocatable    :: list_core_inact_act  (n_core_inact_act_orb)
      integer, allocatable    :: list_core_inact_act_reverse  (mo_num)

  Needs:

  `list_inact` `mo_num` | `n_int` | `reunion_of_core_inact_act_bitmask`

`list_core_reverse`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_del`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_del_reverse`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_inact`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_inact_reverse`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_virt`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`list_virt_reverse`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`mpi_bit_kind`

  File : `bitmask/mpi.irp.f`

      integer :: mpi_bit_kind

  MPI bit kind type

`n_act_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: n_core_orb
      integer :: n_inact_orb
      integer :: n_act_orb
      integer :: n_virt_orb
      integer :: n_del_orb

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `mo_class` | `mo_num` | `mpi_master`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `dim_list_core_orb` | `eigenvectors_fock_matrix_mo` `fock_matrix_mo` `list_inact` `mo_two_e_integrals_vv_from_ao` | `n_core_orb_allocate` `n_inact_orb_allocate` `n_virt_orb_allocate` `pt2_f`

`n_cas_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_cas_bitmask

  Number of bitmasks for CAS

  Needs:

  `ezfio_filename` | `mpi_master` | `n_int`

  Needed by:

  `cas_bitmask` | `psi_cas` |

`n_core_inact_act_orb`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: reunion_of_core_inact_act_bitmask    (N_int,2)
      integer :: n_core_inact_act_orb

  Reunion of the core, inactive and active bitmasks

  Needs:

  `cas_bitmask` | `n_int` | `reunion_of_core_inact_bitmask`

  Needed by:

  `core_inact_act_bitmask_4` | `list_core_inact_act` |

`n_core_inact_orb`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_core_inact_orb

  Needs:

  `n_int` | `reunion_of_core_inact_bitmask` |

`n_core_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: n_core_orb
      integer :: n_inact_orb
      integer :: n_act_orb
      integer :: n_virt_orb
      integer :: n_del_orb

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `mo_class` | `mo_num` | `mpi_master`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `dim_list_core_orb` | `eigenvectors_fock_matrix_mo` `fock_matrix_mo` `list_inact` `mo_two_e_integrals_vv_from_ao` | `n_core_orb_allocate` `n_inact_orb_allocate` `n_virt_orb_allocate` `pt2_f`

`n_core_orb_allocate`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_core_orb_allocate

  Needs:

  `n_core_orb` |  |

`n_del_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: n_core_orb
      integer :: n_inact_orb
      integer :: n_act_orb
      integer :: n_virt_orb
      integer :: n_del_orb

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `mo_class` | `mo_num` | `mpi_master`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `dim_list_core_orb` | `eigenvectors_fock_matrix_mo` `fock_matrix_mo` `list_inact` `mo_two_e_integrals_vv_from_ao` | `n_core_orb_allocate` `n_inact_orb_allocate` `n_virt_orb_allocate` `pt2_f`

`n_generators_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_generators_bitmask

  Number of bitmasks for generators

  Needs:

  `ezfio_filename` | `mpi_master` | `n_int`

  Needed by:

  `cas_bitmask` | `generators_bitmask` | `generators_bitmask_restart`

`n_generators_bitmask_restart`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_generators_bitmask_restart

  Number of bitmasks for generators

  Needs:

  `ezfio_filename` | `mpi_master` | `n_int`

  Needed by:

  `generators_bitmask_restart` |  |

`n_inact_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: n_core_orb
      integer :: n_inact_orb
      integer :: n_act_orb
      integer :: n_virt_orb
      integer :: n_del_orb

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `mo_class` | `mo_num` | `mpi_master`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `dim_list_core_orb` | `eigenvectors_fock_matrix_mo` `fock_matrix_mo` `list_inact` `mo_two_e_integrals_vv_from_ao` | `n_core_orb_allocate` `n_inact_orb_allocate` `n_virt_orb_allocate` `pt2_f`

`n_inact_orb_allocate`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_inact_orb_allocate

  Needs:

  `n_core_orb` |  |

`n_int`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_int

  Number of 64-bit integers needed to represent determinants as binary strings

  Needs:

  `mo_num` | `mpi_master` |

  Needed by:

  `cas_bitmask` `ci_electronic_energy` `closed_shell_ref_bitmask` `coef_hf_selector` `core_inact_act_bitmask_4` `degree_max_generators` `det_to_occ_pattern` `diagonal_h_matrix_on_psi_det` `double_exc_bitmask` `exc_degree_per_selectors` `fock_operator_closed_shell_ref_bitmask` `fock_wee_closed_shell` `full_ijkl_bitmask` `full_ijkl_bitmask_4` `generators_bitmask` `generators_bitmask_restart` `h_apply_buffer_allocated` `h_matrix_all_dets` `h_matrix_cas` `hf_bitmask` `inact_virt_bitmask` `list_core_inact_act` `list_inact` | `max_degree_exc` `mo_two_e_integrals_erf_in_map` `mo_two_e_integrals_in_map` `n_cas_bitmask` `n_core_inact_orb` `n_generators_bitmask` `n_generators_bitmask_restart` `one_e_dm_mo_alpha` `psi_bilinear_matrix_values` `psi_cas` `psi_cas_sorted_bit` `psi_det` `psi_det_alpha` `psi_det_alpha_unique` `psi_det_beta` `psi_det_beta_unique` `psi_det_generators` `psi_det_hii` `psi_det_sorted` `psi_det_sorted_bit` `psi_det_sorted_gen` `psi_energy` | `psi_energy_two_e` `psi_non_cas` `psi_non_cas_sorted_bit` `psi_occ_pattern` `psi_selectors` `psi_selectors_diag_h_mat` `ref_bitmask` `ref_bitmask_energy` `ref_closed_shell_bitmask` `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_act_bitmask` `reunion_of_core_inact_bitmask` `s2_matrix_all_dets` `s2_values` `single_exc_bitmask` `singles_alpha_csc` `singles_alpha_csc_idx` `singles_beta_csc` `singles_beta_csc_idx` `unpaired_alpha_electrons` `virt_bitmask_4`

`n_virt_orb`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer :: n_core_orb
      integer :: n_inact_orb
      integer :: n_act_orb
      integer :: n_virt_orb
      integer :: n_del_orb

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `mo_class` | `mo_num` | `mpi_master`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `dim_list_core_orb` | `eigenvectors_fock_matrix_mo` `fock_matrix_mo` `list_inact` `mo_two_e_integrals_vv_from_ao` | `n_core_orb_allocate` `n_inact_orb_allocate` `n_virt_orb_allocate` `pt2_f`

`n_virt_orb_allocate`

  File : `bitmask/bitmasks.irp.f`

      integer :: n_virt_orb_allocate

  Needs:

  `n_core_orb` |  |

`ref_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: ref_bitmask  (N_int,2)

  Reference bit mask, used in Slater rules, chosen as Hartree-Fock bitmask

  Needs:

  `hf_bitmask` | `n_int` |

  Needed by:

  `closed_shell_ref_bitmask` `coef_hf_selector` `diagonal_h_matrix_on_psi_det` | `exc_degree_per_selectors` `psi_det_hii` `psi_selectors_diag_h_mat` | `ref_bitmask_energy` `ref_closed_shell_bitmask`

`reunion_of_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: reunion_of_bitmask   (N_int,2)

  Reunion of the inactive, active and virtual bitmasks

  Needs:

  `cas_bitmask` | `list_inact` | `n_int`

`reunion_of_cas_inact_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: reunion_of_cas_inact_bitmask (N_int,2)

  Reunion of the inactive, active and virtual bitmasks

  Needs:

  `cas_bitmask` | `list_inact` | `n_int`

`reunion_of_core_inact_act_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: reunion_of_core_inact_act_bitmask    (N_int,2)
      integer :: n_core_inact_act_orb

  Reunion of the core, inactive and active bitmasks

  Needs:

  `cas_bitmask` | `n_int` | `reunion_of_core_inact_bitmask`

  Needed by:

  `core_inact_act_bitmask_4` | `list_core_inact_act` |

`reunion_of_core_inact_bitmask`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: reunion_of_core_inact_bitmask        (N_int,2)

  Reunion of the core and inactive and virtual bitmasks

  Needs:

  `list_inact` | `n_int` |

  Needed by:

  `n_core_inact_orb` | `reunion_of_core_inact_act_bitmask` |

`unpaired_alpha_electrons`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: unpaired_alpha_electrons     (N_int)

  Bitmask reprenting the unpaired alpha electrons in the HF_bitmask

  Needs:

  `hf_bitmask` | `n_int` |

`virt_bitmask`

  File : `bitmask/core_inact_act_virt.irp.f`

      integer, allocatable    :: list_inact   (dim_list_inact_orb)
      integer, allocatable    :: list_virt    (dim_list_virt_orb)
      integer, allocatable    :: list_inact_reverse   (mo_num)
      integer, allocatable    :: list_virt_reverse    (mo_num)
      integer, allocatable    :: list_del_reverse     (mo_num)
      integer, allocatable    :: list_del     (mo_num)
      integer, allocatable    :: list_core    (dim_list_core_orb)
      integer, allocatable    :: list_core_reverse    (mo_num)
      integer, allocatable    :: list_act     (dim_list_act_orb)
      integer, allocatable    :: list_act_reverse     (mo_num)
      integer(bit_kind), allocatable  :: core_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: inact_bitmask        (N_int,2)
      integer(bit_kind), allocatable  :: act_bitmask  (N_int,2)
      integer(bit_kind), allocatable  :: virt_bitmask (N_int,2)
      integer(bit_kind), allocatable  :: del_bitmask  (N_int,2)

  inact_bitmask : Bitmask of the inactive orbitals which are supposed to be doubly excited in post CAS methods n_inact_orb : Number of inactive orbitals virt_bitmask : Bitmaks of vritual orbitals which are supposed to be recieve electrons in post CAS methods n_virt_orb : Number of virtual orbitals list_inact : List of the inactive orbitals which are supposed to be doubly excited in post CAS methods list_virt : List of vritual orbitals which are supposed to be recieve electrons in post CAS methods list_inact_reverse : reverse list of inactive orbitals list_inact_reverse(i) = 0 ::> not an inactive list_inact_reverse(i) = k ::> IS the kth inactive list_virt_reverse : reverse list of virtual orbitals list_virt_reverse(i) = 0 ::> not an virtual list_virt_reverse(i) = k ::> IS the kth virtual list_act(i) = index of the ith active orbital

  list_act_reverse : reverse list of active orbitals list_act_reverse(i) = 0 ::> not an active list_act_reverse(i) = k ::> IS the kth active orbital

  Needs:

  `dim_list_core_orb` `mo_class` | `mo_num` `n_core_orb` | `n_int`

  Needed by:

  `core_energy` `core_energy_erf` `core_fock_operator` `core_fock_operator_erf` `eigenvectors_fock_matrix_mo` | `fock_matrix_mo` `inact_virt_bitmask` `list_core_inact_act` `mo_two_e_integrals_in_map` `mo_two_e_integrals_vv_from_ao` | `reunion_of_bitmask` `reunion_of_cas_inact_bitmask` `reunion_of_core_inact_bitmask` `virt_bitmask_4`

`virt_bitmask_4`

  File : `bitmask/bitmasks.irp.f`

      integer(bit_kind), allocatable  :: virt_bitmask_4       (N_int,4)

  Needs:

  `list_inact` | `n_int` |

## Subroutines / functions

`bitstring_to_hexa:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine bitstring_to_hexa( output, string, Nint )

  Transform a bit string to a string in hexadecimal format for printing

  Called by:

  `debug_det()` | `debug_spindet()` |

`bitstring_to_list:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine bitstring_to_list( string, list, n_elements, Nint)

  Gives the inidices(+1) of the bits set to 1 in the bit string

  Called by:

  `add_integrals_to_map()` `add_integrals_to_map_erf()` `add_integrals_to_map_no_exit_34()` | `add_integrals_to_map_three_indices()` `create_microlist()` `example_bitmask()` | `getmobiles()` `list_core_inact_act` `ref_bitmask_energy`

`bitstring_to_str:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine bitstring_to_str( output, string, Nint )

  Transform a bit string to a string for printing

  Called by:

  `add_integrals_to_map()` `add_integrals_to_map_erf()` | `add_integrals_to_map_three_indices()` `example_bitmask()` | `print_det()` `print_spindet()`

`broadcast_chunks_bit_kind:`()

  File : `bitmask/mpi.irp.f`

      subroutine broadcast_chunks_bit_kind(A, LDA)

  Broadcast with chunks of ~2GB

`clear_bit_to_integer:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine clear_bit_to_integer(i_physical,key,Nint)

  set to 0 the bit number i_physical in the bitstring key

  Called by:

  `example_bitmask()` | `ref_closed_shell_bitmask` |

`debug_det:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine debug_det(string,Nint)

  Subroutine to print the content of a determinant in ‘+-‘ notation and hexadecimal representation.

  Called by:

  `build_fock_tmp()` `example_determinants()` | `get_excitation_degree_vector_mono_or_exchange_verbose()` `number_of_holes_verbose()` | `number_of_particles_verbose()` `routine_example_psi_det()`

  Calls:

  `bitstring_to_hexa()` | `print_det()` |

`debug_spindet:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine debug_spindet(string,Nint)

  Subroutine to print the content of a determinant in ‘+-‘ notation and hexadecimal representation.

  Calls:

  `bitstring_to_hexa()` | `print_spindet()` |

`example_bitmask:`()

  File : `bitmask/example.irp.f`

      subroutine example_bitmask

  subroutine that illustrates the main features available in bitmask

  Needs:

  `n_core_orb` `list_inact` | `n_int` | `mo_num`

  Calls:

  `bitstring_to_list()` `bitstring_to_str()` | `clear_bit_to_integer()` | `set_bit_to_integer()`

`initialize_bitmask_to_restart_ones:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine initialize_bitmask_to_restart_ones

  Initialization of the generators_bitmask to the restart bitmask

  Needs:

  `generators_bitmask_restart` `n_generators_bitmask` | `generators_bitmask` | `n_int`

`is_a_1h:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_1h(key_in)

  Needs:

  `n_int` |  |

`is_a_1h1p:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_1h1p(key_in)

  Needs:

  `n_int` |  |

`is_a_1h2p:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_1h2p(key_in)

  Needs:

  `n_int` |  |

`is_a_1p:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_1p(key_in)

  Needs:

  `n_int` |  |

`is_a_2h:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_2h(key_in)

  Needs:

  `n_int` |  |

`is_a_2h1p:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_2h1p(key_in)

  Needs:

  `n_int` |  |

`is_a_2p:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_2p(key_in)

  Needs:

  `n_int` |  |

`is_a_two_holes_two_particles:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_a_two_holes_two_particles(key_in)

  logical function that returns True if the determinant ‘key_in’ belongs to the 2h-2p excitation class of the DDCI space this is calculated using the CAS_bitmask that defines the active orbital space, the inact_bitmasl that defines the inactive oribital space and the virt_bitmask that defines the virtual orbital space

  Needs:

  `cas_bitmask` `reunion_of_core_inact_bitmask` | `list_inact` | `n_int`

`is_i_in_virtual:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      logical function is_i_in_virtual(i)

  Needs:

  `list_inact` | `n_int` |

`is_the_hole_in_det:`()

  File : `bitmask/find_hole.irp.f`

      logical function is_the_hole_in_det(key_in,ispin,i_hole)

  Needs:

  `n_int` |  |

`is_the_particl_in_det:`()

  File : `bitmask/find_hole.irp.f`

      logical function is_the_particl_in_det(key_in,ispin,i_particl)

  Needs:

  `n_int` |  |

`list_to_bitstring:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine list_to_bitstring( string, list, n_elements, Nint)

  Returns the physical string “string(N_int,2)” from the array of occupations “list(N_int*bit_kind_size,2)

  Called by:

  `hf_bitmask` | `list_inact` |

`modify_bitmasks_for_hole:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine modify_bitmasks_for_hole(i_hole)

  modify the generators_bitmask in order that one can only excite the electrons occupying i_hole

  Needs:

  `n_generators_bitmask` `generators_bitmask` | `n_int` | `index_holes_bitmask`

`modify_bitmasks_for_hole_in_out:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine modify_bitmasks_for_hole_in_out(i_hole)

  modify the generators_bitmask in order that one can only excite the electrons occupying i_hole

  Needs:

  `n_generators_bitmask` | `generators_bitmask` | `index_holes_bitmask`

`modify_bitmasks_for_particl:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine modify_bitmasks_for_particl(i_part)

  modify the generators_bitmask in order that one can only excite the electrons to the orbital i_part

  Needs:

  `index_particl_bitmask` `n_generators_bitmask` | `generators_bitmask` | `n_int`

`number_of_holes:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      integer function number_of_holes(key_in)

  Function that returns the number of holes in the inact space

  Needs:

  `cas_bitmask` | `reunion_of_core_inact_bitmask` | `n_int`

`number_of_holes_verbose:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      integer function number_of_holes_verbose(key_in)

  function that returns the number of holes in the inact space

  Needs:

  `cas_bitmask` | `reunion_of_core_inact_bitmask` | `n_int`

  Calls:

  `debug_det()` |  |

`number_of_particles:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      integer function number_of_particles(key_in)

  function that returns the number of particles in the virtual space

  Needs:

  `cas_bitmask` | `list_inact` | `n_int`

`number_of_particles_verbose:`()

  File : `bitmask/bitmask_cas_routines.irp.f`

      integer function number_of_particles_verbose(key_in)

  function that returns the number of particles in the inact space

  Needs:

  `cas_bitmask` | `list_inact` | `n_int`

  Calls:

  `debug_det()` |  |

`print_det:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine print_det(string,Nint)

  Subroutine to print the content of a determinant using the ‘+-‘ notation

  Called by:

  `debug_det()` `example_determinants()` | `print_generators_bitmasks_holes()` `print_generators_bitmasks_holes_for_one_generator()` | `print_generators_bitmasks_particles()` `print_generators_bitmasks_particles_for_one_generator()`

  Calls:

  `bitstring_to_str()` |  |

`print_generators_bitmasks_holes:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine print_generators_bitmasks_holes

  Needs:

  `generators_bitmask` | `n_int` | `index_holes_bitmask`

  Calls:

  `print_det()` |  |

`print_generators_bitmasks_holes_for_one_generator:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine print_generators_bitmasks_holes_for_one_generator(i_gen)

  Needs:

  `generators_bitmask` | `n_int` | `index_holes_bitmask`

  Calls:

  `print_det()` |  |

`print_generators_bitmasks_particles:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine print_generators_bitmasks_particles

  Needs:

  `index_particl_bitmask` | `generators_bitmask` | `n_int`

  Calls:

  `print_det()` |  |

`print_generators_bitmasks_particles_for_one_generator:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine print_generators_bitmasks_particles_for_one_generator(i_gen)

  Needs:

  `index_particl_bitmask` | `generators_bitmask` | `n_int`

  Calls:

  `print_det()` |  |

`print_spindet:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine print_spindet(string,Nint)

  Subroutine to print the content of a determinant using the ‘+-‘ notation

  Called by:

  `debug_spindet()` |  |

  Calls:

  `bitstring_to_str()` |  |

`set_bit_to_integer:`()

  File : `bitmask/bitmasks_routines.irp.f`

      subroutine set_bit_to_integer(i_physical,key,Nint)

  set to 1 the bit number i_physical in the bitstring key

  Called by:

  `example_bitmask()` |  |

`set_bitmask_hole_as_input:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine set_bitmask_hole_as_input(input_bimask)

  set the generators_bitmask for the holes as the input_bimask

  Needs:

  `n_generators_bitmask` `generators_bitmask` | `n_int` | `index_holes_bitmask`

  Touches:

  `generators_bitmask` |  |

`set_bitmask_particl_as_input:`()

  File : `bitmask/modify_bitmasks.irp.f`

      subroutine set_bitmask_particl_as_input(input_bimask)

  set the generators_bitmask for the particles as the input_bimask

  Needs:

  `index_particl_bitmask` `n_generators_bitmask` | `generators_bitmask` | `n_int`

  Touches:

  `generators_bitmask` |  |