QCaml/CI/CI.ml

open Lacaml.D
open Util

module Ds = DeterminantSpace
module Sd = Spindeterminant

type t =
  {
    e_shift     : float ; (* Diagonal energy shift for increasing numerical precision *)
    det_space   : Ds.t ;
    m_H         : Matrix.t lazy_t ;
    m_S2        : Matrix.t lazy_t ;
    eigensystem : (Mat.t * Vec.t) lazy_t;
    n_states    : int;
  }

let det_space    t = t.det_space

let n_states     t = t.n_states

let m_H          t = Lazy.force t.m_H

let m_S2         t = Lazy.force t.m_S2

let eigensystem  t = Lazy.force t.eigensystem 

let mo_class     t = DeterminantSpace.mo_class t.det_space

let eigenvectors t = 
  let (x,_) = eigensystem t in x

let eigenvalues t = 
  let (_,x) = eigensystem t in x

let h_integrals mo_basis = 
  let one_e_ints  = MOBasis.one_e_ints mo_basis
  and two_e_ints  = MOBasis.two_e_ints mo_basis
  in
  ( (fun i j _ -> one_e_ints.{i,j}), 
    (fun i j k l s s' ->
       if s' = Spin.other s then
         ERI.get_phys two_e_ints i j k l
       else
         (ERI.get_phys two_e_ints i j k l) -. 
         (ERI.get_phys two_e_ints i j l k) 
    ) )



let h_ij mo_basis ki kj =
  let integrals =
    List.map (fun f -> f mo_basis)
      [ h_integrals ]
  in
  CIMatrixElement.make integrals ki kj 
  |> List.hd


let h_ij_non_zero mo_basis deg_a deg_b ki kj =
  let integrals =
    List.map (fun f -> f mo_basis)
      [ h_integrals ]
  in
  CIMatrixElement.non_zero integrals deg_a deg_b ki kj 
  |> List.hd


let create_matrix_arbitrary f det_space =
  lazy (
    let ndet = Ds.size det_space in
    let data = 
      match Ds.determinants det_space with
      | Ds.Arbitrary a -> a
      | _ -> assert false
    in
    let det_alfa    = data.Ds.det_alfa
    and det_beta    = data.Ds.det_beta
    and det         = data.Ds.det
    and index_start = data.Ds.index_start
    in


    (** Array of (list of singles, list of doubles) in the beta spin *)
    let degree_bb = 
      Array.map (fun det_i ->
          let deg = Spindeterminant.degree det_i in
          let doubles =
            Array.mapi (fun i det_j -> 
                let d = deg det_j in
                if d < 3 then
                  Some (i,d,det_j)
                else
                  None
              ) det_beta
            |> Array.to_list
            |> Util.list_some
          in
          let singles = 
            List.filter (fun (i,d,det_j) -> d < 2) doubles
            |> List.map (fun (i,_,det_j) -> (i,det_j))
          in
          let doubles = 
            List.map (fun (i,_,det_j) -> (i,det_j)) doubles
          in
          (singles, doubles)
        ) det_beta
    in

    let task (i,i_dets) = 
      let shift = index_start.(i) in

      let result =
        Array.init (index_start.(i+1) - shift)
          (fun _ -> [])
      in

      (** Update function when ki and kj are connected *)
      let update i j deg_a deg_b ki kj =
        let x = f deg_a deg_b ki kj in
        if abs_float x > Constants.epsilon then
          result.(i - shift) <- (j, x) :: result.(i - shift) ;
      in

      let i_alfa = det_alfa.(i) in
      let deg_a = Spindeterminant.degree i_alfa in

      Array.iteri (fun j j_dets ->
          let j_alfa = det_alfa.(j) in
          let degree_a = deg_a j_alfa in

          begin
            match degree_a with
            | 2 -> 
              Array.iteri (fun i' i_b ->
                  try
                    Array.iteri (fun j' j_b ->
                        if j_b >= i_b then 
                          ( if j_b = i_b then
                              ( let i_beta = det_beta.(i_b) in
                                let ki = Determinant.of_spindeterminants i_alfa i_beta in
                                let kj = Determinant.of_spindeterminants j_alfa i_beta in
                                update (index_start.(i) + i')
                                  (index_start.(j) + j' + 1) 2 0 ki kj);
                            raise Exit)
                      ) j_dets
                  with Exit -> ()
                ) i_dets 
            | 1 -> 
              Array.iteri (fun i' i_b ->
                  let i_beta = det_beta.(i_b) in
                  let ki = Determinant.of_spindeterminants i_alfa i_beta in
                  let singles, _ = degree_bb.(i_b) in 
                  let rec aux singles j' =
                    match singles with
                    | [] -> ()
                    | (js, j_beta)::r_singles ->
                      begin
                        match compare js j_dets.(j') with
                        | -1 -> aux r_singles j'
                        |  0 ->
                          let kj =
                            Determinant.of_spindeterminants j_alfa j_beta
                          in (update
                                (index_start.(i) + i') (index_start.(j) + j' + 1)
                                1 (Determinant.degree_beta ki kj) ki kj;
                              aux r_singles (j'+1);)
                        |  1 -> if (j' < Array.length j_dets) then aux singles (j'+1)
                        |  _ -> assert false
                      end
                  in aux singles 0 
                ) i_dets 
            | 0 -> 
              Array.iteri (fun i' i_b ->
                  let i_beta = det_beta.(i_b) in
                  let ki = Determinant.of_spindeterminants i_alfa i_beta in
                  let _, doubles = degree_bb.(i_b) in 
                  let rec aux doubles j' =
                    match doubles with
                    | [] -> ()
                    | (js, j_beta)::r_doubles ->
                      begin
                        match compare js j_dets.(j') with
                        | -1 -> aux r_doubles j'
                        |  0 ->
                          let kj =
                            Determinant.of_spindeterminants j_alfa j_beta
                          in (update
                                (index_start.(i) + i') (index_start.(j) + j' + 1)
                                0 (Determinant.degree_beta ki kj) ki kj;
                              aux r_doubles (j'+1);)
                        |  1 -> if (j' < Array.length j_dets) then aux doubles (j'+1)
                        |  _ -> assert false
                      end
                  in aux doubles 0 
                ) i_dets 
            | _ -> ();
          end
        ) det;
      let r =
        Array.map (fun l -> 
            List.rev l
            |> Vector.sparse_of_assoc_list ndet
          ) result
      in (i,r)
    in


    let result =
      if Parallel.master then
        Array.init ndet (fun _ -> Vector.sparse_of_assoc_list ndet [])
      else
        Array.init ndet (fun _ -> Vector.sparse_of_assoc_list ndet [])
    in

    let n_det_alfa = 
      Array.length det_alfa
    in
    Array.mapi (fun i i_dets -> i, i_dets) det
    |> Array.to_list
    |> Stream.of_list
    |> Farm.run ~ordered:false ~f:task
    |> Stream.iter (fun (k, r) ->
        let shift = index_start.(k) in
        let det_k = det.(k) in
        Array.iteri (fun j r_j -> result.(shift+det_k.(j)) <- r_j) r;
        Printf.eprintf "%8d / %8d\r%!" (k+1) n_det_alfa;
      ) ;
    Matrix.sparse_of_vector_array result
  )


(* Create a matrix using the fact that the determinant space is made of
   the outer product of spindeterminants.  *)
let create_matrix_spin f det_space = 
  lazy (
    let ndet = Ds.size det_space in
    let a, b = 
      match Ds.determinants det_space with
      | Ds.Spin (a,b) -> (a,b)
      | _ -> assert false
    in
    let n_beta = Array.length b in


    (** Array of (list of singles, list of doubles) in the beta spin *)
    let degree_bb = 
      Array.map (fun det_i ->
          let deg = Spindeterminant.degree det_i in
          let doubles =
            Array.mapi (fun i det_j -> 
                let d = deg det_j in
                if d < 3 then
                  Some (i,d,det_j)
                else
                  None
              ) b
            |> Array.to_list
            |> Util.list_some
          in
          let singles = 
            List.filter (fun (i,d,det_j) -> d < 2) doubles
            |> List.map (fun (i,_,det_j) -> (i,det_j))
          in
          let doubles = 
            List.map (fun (i,_,det_j) -> (i,det_j)) doubles
          in
          (singles, doubles)
        ) b
    in
    let a = Array.to_list a
    and b = Array.to_list b
    in

    let task (i,i_alfa) = 
      let result =
        Array.init n_beta (fun _ -> [])
      in

      (** Update function when ki and kj are connected *)
      let update i j deg_a deg_b ki kj =
        let x = f deg_a deg_b ki kj in
        if abs_float x > Constants.epsilon then
          result.(i) <- (j, x) :: result.(i) ;
      in

      let j = ref 1 in
      let deg_a = Spindeterminant.degree i_alfa in
      List.iter (fun j_alfa ->
          let degree_a = deg_a j_alfa in
          begin
            match degree_a with
            | 2 ->
              let i' = ref 0 in
              List.iteri (fun ib i_beta ->
                  let ki = Determinant.of_spindeterminants i_alfa i_beta in
                  let kj = Determinant.of_spindeterminants j_alfa i_beta in
                  update !i' (ib + !j) 2 0 ki kj;
                  incr i';
                ) b;
            | 1 -> 
              let i' = ref 0 in
              List.iteri (fun ib i_beta ->
                  let ki = Determinant.of_spindeterminants i_alfa i_beta in
                  let singles, _ = degree_bb.(ib) in
                  List.iter (fun (j', j_beta) ->
                      let kj = Determinant.of_spindeterminants j_alfa j_beta in
                      update !i' (j' + !j) 1 (Determinant.degree_beta ki kj) ki kj
                    ) singles;
                  incr i';
                ) b;
            | 0 ->
              let i' = ref 0 in
              List.iteri (fun ib i_beta ->
                  let ki = Determinant.of_spindeterminants i_alfa i_beta in
                  let _singles, doubles = degree_bb.(ib) in
                  List.iter (fun (j', j_beta) ->
                      let kj = Determinant.of_spindeterminants j_alfa j_beta in
                      update !i' (j' + !j) 0 (Determinant.degree_beta ki kj) ki kj
                    ) doubles;
                  incr i';
                ) b;
            | _ -> ();
          end;
          j := !j + n_beta
        ) a;
      let r = 
        Array.map (fun l ->
            List.rev l
            |> Vector.sparse_of_assoc_list ndet
          ) result 
      in (i,r)
    in

    let result =
      Array.init ndet (fun _ -> Vector.sparse_of_assoc_list ndet [])
    in

    List.mapi (fun i i_alfa -> i*n_beta, i_alfa) a
    |> Stream.of_list
    |> Farm.run ~ordered:false ~f:task
    |> Stream.iter (fun (k, r) ->
        Array.iteri (fun j r_j -> result.(k+j) <- r_j) r;
        Printf.eprintf "%8d / %8d\r%!" (k+Array.length r) ndet;
      ) ;
    Matrix.sparse_of_vector_array result
  )



(* Create a matrix using the fact that the determinant space is made of
   the outer product of spindeterminants.  *)
let create_matrix_spin_computed f det_space = 
  lazy (
    let ndet = Ds.size det_space in
    let a, b = 
      match Ds.determinants det_space with
      | Ds.Spin (a,b) -> (a,b)
      | _ -> assert false
    in
    let n_beta = Array.length b in

    let h i_alfa j_alfa =
        let deg_a = Spindeterminant.degree a.(i_alfa) a.(j_alfa) in
        match deg_a with
        | 2 ->
          let ai, aj = a.(i_alfa), a.(j_alfa) in
          (fun i_beta j_beta ->
              if i_beta <> j_beta then 0. else
                let deg_b = 0 in
                let ki = Determinant.of_spindeterminants ai b.(i_beta) in
                let kj = Determinant.of_spindeterminants aj b.(j_beta) in
                f deg_a deg_b ki kj
          )
        | 1 ->
          let ai, aj = a.(i_alfa), a.(j_alfa) in
          (fun i_beta j_beta ->
              let deg_b = Spindeterminant.degree b.(i_beta) b.(j_beta) in
              match deg_b with
              | 0 | 1 ->
                let ki = Determinant.of_spindeterminants ai b.(i_beta) in
                let kj = Determinant.of_spindeterminants aj b.(j_beta) in
                  f deg_a deg_b ki kj
              | _ -> 0.
          )
        | 0 ->
          let ai, aj = a.(i_alfa), a.(j_alfa) in
          (fun i_beta j_beta ->
              let deg_b = Spindeterminant.degree b.(i_beta) b.(j_beta) in
              match deg_b with
              | 0 | 1 | 2 ->
                let deg_b = Spindeterminant.degree b.(i_beta) b.(j_beta) in
                let ki = Determinant.of_spindeterminants ai b.(i_beta) in
                let kj = Determinant.of_spindeterminants aj b.(j_beta) in
                f deg_a deg_b ki kj
              | _ -> 0.
          )
        | _ -> (fun _ _ -> 0.)
    in

    let i_prev = ref (-10)
    and result = ref (fun _ -> 0.)
    in
    let h123 = ref (fun _ -> 0.)  in

    let g i =
      (*
        i      : index of the i-th determinant. 1 <= i <= ndet
        i_prev : index of the i-th determinant in the previous function call.
                  1 <= i_prev <= ndet
        i_a    : index of the i_a-th alpha determinant. 0 <= i_a < n_alfa
        i_b    : index of the i_b-th beta determinant. 0 <= i_b < n_beta
        j0     : index - 1 of the first determinant with the same alfa component
                  0 <= j0 < n_beta*(n_alfa-1)
        j1     : index - 1 of the next determinant with the 1st beta determinant
                  n_beta <= j1 <= ndet
        j_a    : index of the j_a-th alpha determinant. 0 <= j_a < n_alfa
        j_b    : index of the j_b-th beta determinant. 0 <= j_b < n_beta
      *)
      if i <> !i_prev then
        begin
          i_prev := i;
          let i_a = (i-1)/n_beta in
          let h1 = h i_a in
          let i_b = i - i_a*n_beta - 1  in
          let j0 = ref (2*ndet) in
          let j1 = ref (2*ndet) in
          let j_a = ref 0 in
          result := fun j ->
              if  (!j0 < j) && (j <= !j1) then 
                  ()
              else
                begin
                  if (!j1 < j) && (j <= !j1 + n_beta) then 
                    begin
                      incr j_a;
                      j0 := !j1;
                    end
                  else
                    begin
                      j_a := (j-1)/n_beta;
                      j0 := !j_a * n_beta;
                    end;
                  j1 := !j0 + n_beta;
                  h123 := h1 !j_a i_b;
                end;
                let j_b = j - !j0 - 1 in
                !h123 j_b
        end;
      !result
    in

    Matrix.of_fun ndet ndet g
  )



let make ?(n_states=1) ?(algo=`Direct) det_space = 

  let mo_basis = Ds.mo_basis det_space in

  let e_shift = 
    let d0 = 
      Ds.determinant_stream det_space
      |> Stream.next
    in
    h_ij_non_zero mo_basis 0 0 d0 d0
  in

  let m_H = 

    (* While in a sequential region, initiate the parallel
       4-idx transformation to avoid nested parallel jobs
    *)
    ignore @@ MOBasis.two_e_ints mo_basis;

    let f = 
      match Ds.determinants det_space with
      | Ds.Arbitrary _ -> create_matrix_arbitrary
      | Ds.Spin      _ -> 
        if algo = `Direct then
          create_matrix_spin_computed
        else 
          create_matrix_spin
    in
    f (fun deg_a deg_b ki kj ->
         if deg_a + deg_b > 0 then
            h_ij_non_zero mo_basis deg_a deg_b ki kj
         else
            h_ij_non_zero mo_basis 0 0 ki ki -. e_shift
      ) det_space 
  in

  let m_S2 =
    let f = 
      match Ds.determinants det_space with
      | Ds.Arbitrary _ -> create_matrix_arbitrary
      | Ds.Spin      _ -> create_matrix_spin
    in
    f (fun _deg_a _deg_b ki kj -> CIMatrixElement.make_s2 ki kj) det_space 
    (*TODO*)
  in

  let eigensystem = lazy (

    let eigensystem_incore () = 
      let m_H =
        Lazy.force m_H
      in
      let diagonal =
        Parallel.broadcast (lazy (
          Vec.init (Matrix.dim1 m_H) (fun i -> Matrix.get m_H i i)
        ))
      in
      let matrix_prod psi = 
        let result = 
          Matrix.mm ~transa:`T m_H psi 
        in
        Parallel.broadcast (lazy result)
      in
      let eigenvectors, eigenvalues = 
        let result = 
          Davidson.make ~threshold:1.e-6  ~n_states diagonal matrix_prod
        in
        Parallel.broadcast (lazy result)
      in
      let eigenvalues = Vec.map (fun x -> x +. e_shift) eigenvalues in
      eigenvectors, eigenvalues
    in

    let eigensystem_direct () = 
      let m_H =
        Lazy.force m_H
      in
      let diagonal =
        Parallel.broadcast (lazy (
          Vec.init (Matrix.dim1 m_H) (fun i -> Matrix.get m_H i i)
        ))
      in
      let matrix_prod psi = 
        let result = 
          Matrix.parallel_mm ~transa:`T ~transb:`N psi m_H
          |> Matrix.transpose
        in
        Parallel.broadcast (lazy result)
      in
      let eigenvectors, eigenvalues = 
        let result = 
          Davidson.make ~threshold:1.e-6  ~n_states diagonal matrix_prod
        in
        Parallel.broadcast (lazy result)
      in
      let eigenvalues = Vec.map (fun x -> x +. e_shift) eigenvalues in
      eigenvectors, eigenvalues
    in

    match algo with
    | `Direct -> eigensystem_direct ()
    | `InCore -> eigensystem_incore ()
  )
  in
  { det_space ; e_shift ; m_H ; m_S2 ; eigensystem ; n_states }




let second_order_sum { det_space ; m_H ; m_S2 ; eigensystem ; n_states }
    list_holes  list_particles ?(unique=true) is_internal
    i_o1_alfa  alfa_o2_i  w_alfa  psi0 =

  let list_holes     = Array.of_list list_holes in
  let list_particles = Array.of_list list_particles in

  let psi0 =
    let stream = 
      Ds.determinant_stream det_space
    in
    Array.init (Ds.size det_space) (fun i ->
        (Stream.next stream), (Mat.copy_row psi0 (i+1)) )
  in



  let symmetric = i_o1_alfa == alfa_o2_i in


  let det_contribution i =

    let already_generated =
      if unique then
        (fun alfa ->
          if is_internal alfa then
            true
          else
            let rec aux = function
              | -1 -> false
              | j  -> Determinant.degree (fst psi0.(j)) alfa <= 2
                      || aux (j-1)
            in
            aux (i-1)
        )
      else
        is_internal
    in

    let psi_filtered_idx =
      let rec aux accu =  function
        | j when j < i -> List.rev accu
        | j ->
          if Determinant.degree (fst psi0.(i)) (fst psi0.(j)) < 4
          then
            aux (j::accu) (j-1)
          else
            aux accu (j-1)
      in aux [] (Array.length psi0 - 1)
    in

    let psi_filtered = 
      List.map (fun i -> psi0.(i)) psi_filtered_idx
    in

    let psi_h_alfa alfa =
      List.fold_left (fun accu (det, coef) ->
(* Single state here *)
          accu +. coef.{1} *. (i_o1_alfa det alfa)) 0. psi_filtered
    in

    let alfa_h_psi alfa =
      List.fold_left (fun accu (det, coef) ->
(* Single state here *)
              accu +. coef.{1} *. (alfa_o2_i alfa det)) 0. psi_filtered
    in

    let psi_h_alfa_alfa_h_psi alfa =
      if symmetric then
        let x = psi_h_alfa alfa in x *. x
      else
        (psi_h_alfa alfa) *. (alfa_h_psi alfa)
    in

    let det_i = fst psi0.(i) in
    let w_alfa = w_alfa det_i in

    let same_spin = 
      List.fold_left (fun accu spin ->
          accu +.
          Array.fold_left (fun accu particle ->
              accu +.
              Array.fold_left (fun accu hole ->
                  if hole = particle then accu else
                    let alfa =
                      Determinant.single_excitation spin hole particle det_i
                    in
                    if Determinant.is_none alfa then accu else

                      let single = 
                        if already_generated alfa then 0. else
                          w_alfa alfa *. psi_h_alfa_alfa_h_psi alfa 
                      in

                      let double =
                        Array.fold_left (fun accu particle' ->
                            if particle' >= particle || particle' = hole then
                              accu
                            else
                              accu +.
                              Array.fold_left (fun accu hole' ->
                                  if hole' = particle' || hole' = particle || hole' <= hole then
                                    accu
                                  else
                                      let alfa = 
                                        Determinant.single_excitation
                                          spin  hole' particle' alfa
                                      in
                                      if Determinant.is_none alfa ||
                                         already_generated alfa then
                                        accu
                                      else
                                        accu +. w_alfa alfa *. psi_h_alfa_alfa_h_psi alfa 
                                ) 0. list_holes
                          ) 0. list_particles
                      in
                      accu +. single +. double
                ) 0. list_holes
            ) 0. list_particles
        ) 0. [ Spin.Alfa ; Spin.Beta ]
    in

    let opposite_spin =
      Array.fold_left (fun accu particle ->
          accu +.
          Array.fold_left (fun accu hole ->
              if hole = particle then accu else
                let alfa =
                  Determinant.single_excitation Spin.Alfa hole particle det_i
                in
                if Determinant.is_none alfa then accu else

                  let double_ab =
                    Array.fold_left (fun accu particle' ->
                          accu +.
                          Array.fold_left (fun accu hole' ->
                              if hole' = particle' then accu else
                                let alfa = 
                                  Determinant.double_excitation
                                    Spin.Alfa hole  particle
                                    Spin.Beta hole' particle' det_i
                                in
                                if Determinant.is_none alfa ||
                                  already_generated alfa then
                                  accu
                                else
                                  accu +. w_alfa alfa *. psi_h_alfa_alfa_h_psi alfa 
                          ) 0. list_holes
                      ) 0. list_particles
                  in

                  accu +. double_ab 
            ) 0. list_holes
        ) 0. list_particles
    in
    same_spin +. opposite_spin
  in

  Util.stream_range 0 (Array.length psi0 - 1)
  |> Farm.run ~ordered:true ~f:det_contribution
  |> Util.stream_to_list



let second_order_sum2 { det_space ; m_H ; m_S2 ; eigensystem ; n_states }
    list_holes  list_particles i_o1_alfa e0 psi0 =

  let psi0 =
    let stream = 
      Ds.determinant_stream det_space
    in
    Array.init (Ds.size det_space) (fun i ->
        (Stream.next stream), (Mat.copy_row psi0 (i+1)) )
  in

  let determinants =

    Ds.determinants_array det_space
    |> Array.to_list
    |> List.map (fun det_i ->
        [ Spin.Alfa ; Spin.Beta ] 
        |>  List.map (fun spin ->
            List.map (fun particle ->
              List.map (fun hole ->
                  [ [ Determinant.single_excitation spin hole particle det_i ] ;
                    List.map (fun particle' ->
                        List.map (fun hole' ->
                          Determinant.double_excitation
                            spin  hole particle 
                            spin  hole' particle' det_i
                        ) list_holes
                    ) list_particles
                    |> List.concat
                    ;
                    List.map (fun particle' ->
                        List.map (fun hole' ->
                          Determinant.double_excitation
                            spin  hole particle 
                            (Spin.other spin)  hole' particle' det_i
                        ) list_holes
                    ) list_particles
                    |> List.concat
                  ]
                  |> List.concat
                ) list_holes
            ) list_particles
            |> List.concat
          )
          |> List.concat
        )  
        |> List.concat
        |> List.concat
    |> List.filter (fun alfa -> not (Determinant.is_none alfa))
    |> List.sort_uniq compare
  in

  List.fold_left (fun accu alfa ->
    let alfa_o2 = i_o1_alfa alfa in
    let a_h_psi = 
      Array.fold_left (fun accu (det,ci) -> ci.{1} *. (alfa_o2 det)) 0. psi0
    in
    accu +. (a_h_psi *. a_h_psi) /. (e0 -. (alfa_o2 alfa))
    ) 0. determinants




let is_internal det_space =
    let mo_class      = DeterminantSpace.mo_class det_space in
    let numbits = Array.length @@ MOClass.mo_class_array mo_class in
    let m l =
      List.fold_left (fun accu i ->
          let j = i-1 in
          Bitstring.logor accu (Bitstring.shift_left_one numbits j)
        ) (Bitstring.zero numbits) l
    in
    let active_mask   = m (MOClass.active_mos   mo_class) in
    let occ_mask      = m (MOClass.core_mos     mo_class) in
    let inactive_mask = m (MOClass.inactive_mos mo_class) in
    let occ_mask = Bitstring.logor occ_mask inactive_mask in
    let neg_active_mask = Bitstring.lognot active_mask in
    fun a ->
      let alfa =
        Determinant.alfa a
        |> Spindeterminant.bitstring
      in
      if Bitstring.logand neg_active_mask alfa <> occ_mask then
        false
      else
        let beta =
          Determinant.beta a
          |> Spindeterminant.bitstring
        in
        Bitstring.logand neg_active_mask beta = occ_mask


let _pt2_en ci =

  let mo_basis  = Ds.mo_basis ci.det_space in
  let psi0, e0 = Parallel.broadcast ci.eigensystem in

  let i_o1_alfa = h_ij mo_basis in

  let w_alfa det_i =
    let one_e, two_e = h_integrals mo_basis in
    let fock_diag_alfa, fock_diag_beta = 
      Ds.fock_diag ci.det_space det_i
    in
    let h_aa alfa =
      match Excitation.of_det det_i alfa with
      | Excitation.Double (_,
            {hole = h ; particle = p ; spin = s }, 
            {hole = h'; particle = p'; spin = s'}) -> 
              let fock_diag1 =
                if s = Spin.Alfa then
                  fock_diag_alfa
                else
                  fock_diag_beta
              in
              let fock_diag2 =
                if s' = Spin.Alfa then
                  fock_diag_alfa
                else
                  fock_diag_beta
              in
              fock_diag1.(0) -. fock_diag1.(h)
              +. (fock_diag1.(p ) -. two_e h p h p s s)
              -. (fock_diag2.(h') -. two_e h h' h h' s s' +. two_e p h' p h' s s')
              +. (fock_diag2.(p') -. two_e h p' h p' s s'
                  +. two_e p p' p p' s s' -. two_e h' p' h' p' s' s')
      | Excitation.Single (_,
            {hole = h ; particle = p ; spin = s }) -> 
              let fock_diag =
                if s = Spin.Alfa then
                  fock_diag_alfa
                else
                  fock_diag_beta
              in
              fock_diag.(0) -. fock_diag.(h)
              +. (fock_diag.(p) -. two_e h p h p s s)
              |> ignore;
              h_ij mo_basis alfa alfa
      | _ -> e0.{1} -. 1.0
    in
    let e0 = e0.{1} in 
    fun alfa ->
      1. /. (e0 -. h_aa alfa)
  in

  let mo_class = mo_class ci in
  let list_holes = List.concat
    [ MOClass.inactive_mos mo_class ; MOClass.active_mos mo_class ]
  and list_particles = List.concat 
    [ MOClass.active_mos mo_class ; MOClass.virtual_mos mo_class ]
  in

  second_order_sum  ci  list_holes  list_particles  
    (is_internal ci.det_space) i_o1_alfa  i_o1_alfa  w_alfa  psi0
  |> List.fold_left (+.) 0.


let pt2_en ci =

  let mo_basis  = Ds.mo_basis ci.det_space in
  let psi0, e0 = Parallel.broadcast ci.eigensystem in

  let i_o1_alfa = h_ij mo_basis in

  let mo_class = mo_class ci in
  let list_holes = List.concat
    [ MOClass.inactive_mos mo_class ; MOClass.active_mos mo_class ]
  and list_particles = List.concat 
    [ MOClass.active_mos mo_class ; MOClass.virtual_mos mo_class ]
  in
  second_order_sum2 ci list_holes  list_particles i_o1_alfa e0.{1} psi0 



let pt2_mp ci =

  let mo_basis  = Ds.mo_basis ci.det_space in

  let i_o1_alfa = h_ij mo_basis in

  let eps = MOBasis.mo_energies mo_basis in
  let w_alfa det_i alfa=
    match Excitation.of_det  det_i  alfa with
    | Excitation.Single (_, { hole ; particle ; spin })->
        1./.(eps.{hole} -. eps.{particle})
    | Excitation.Double (_, { hole=h ; particle=p ; spin=s },
                            { hole=h'; particle=p'; spin=s'})->
        1./.(eps.{h} +. eps.{h'} -. eps.{p} -. eps.{p'})
    | _ -> assert false
  in

  let mo_class = mo_class ci in
  let list_holes = List.concat
    [ MOClass.inactive_mos mo_class ; MOClass.active_mos mo_class ]
  and list_particles = List.concat 
    [ MOClass.active_mos mo_class ; MOClass.virtual_mos mo_class ]
  in

  let psi0, _ = Parallel.broadcast ci.eigensystem in
  second_order_sum  ci  list_holes  list_particles  
    (is_internal ci.det_space) i_o1_alfa  i_o1_alfa  w_alfa  psi0
  |> List.fold_left (+.) 0.


let variance ci =

  let mo_basis  = Ds.mo_basis ci.det_space in
  let psi0, _ = Parallel.broadcast ci.eigensystem in

  let i_o1_alfa = h_ij mo_basis in

  let w_alfa _ _ = 1. in

  let mo_class = mo_class ci in
  let list_holes = List.concat
    [ MOClass.inactive_mos mo_class ; MOClass.active_mos mo_class ]
  and list_particles = List.concat 
    [ MOClass.active_mos mo_class ; MOClass.virtual_mos mo_class ]
  in

  second_order_sum  ci  list_holes  list_particles  
    (is_internal ci.det_space) i_o1_alfa  i_o1_alfa  w_alfa  psi0
  |> List.fold_left (+.) 0.




let pt2_en_reference ci =

  let mo_basis  = Ds.mo_basis ci.det_space in
  let psi0, e0 = Parallel.broadcast ci.eigensystem in

  let aux_basis = mo_basis in
  let ds =
    DeterminantSpace.fci_of_mo_basis ~frozen_core:false aux_basis
  in
  let out_dets =
    ds
    |> DeterminantSpace.determinants_array                                                    
    |> Array.to_list
    |> List.filter (fun i -> not (is_internal ci.det_space i))
    |> Array.of_list
  in
      
  let in_dets =
    DeterminantSpace.determinants_array ci.det_space
  in
    
  let m_H_aux =
    let h_aa =
      Array.map (fun ki -> h_ij aux_basis ki ki) out_dets
    in
    Array.map (fun ki ->
      Array.mapi (fun j kj ->
        (h_ij aux_basis ki kj) /. (e0.{1} -. h_aa.(j)) 
      ) out_dets
    ) in_dets
    |> Mat.of_array
  in
    
  let m_F_aux =
    Array.map (fun ki ->
      Array.map (fun kj ->
        h_ij aux_basis ki kj
      ) out_dets 
    ) in_dets
    |> Mat.of_array
  in 
    
  let m_HF =
    gemm m_H_aux m_F_aux ~transb:`T
  in
  (gemm ~transa:`T psi0 @@ gemm m_HF psi0).{1,1}