Work : suppression contenu inutile

This commit is contained in:
Yann Damour 2020-05-18 14:27:44 +02:00
parent 17360e417f
commit 19ffb39db5

View File

@ -1308,100 +1308,6 @@
"let pi = 3.14159265358979323846264338;;\n" "let pi = 3.14159265358979323846264338;;\n"
] ]
}, },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Fonction de calcul de tous les alpha ER -> Matrice, dépend de m_a12, m_b12 qui dépendent de m_C *)\n",
"(*\n",
"let f_alpha m_C =\n",
"\n",
" let n_mo = Mat.dim2 m_C in\n",
" let t0 = Sys.time () in\n",
" \n",
" let m_b12 = Mat.init_cols n_mo n_mo (fun i j -> 0.) in\n",
" let m_a12 = Mat.init_cols n_mo n_mo (fun i j -> 0.) in\n",
" \n",
" (* Tableaux temporaires *)\n",
" let m_pqr =\n",
" Bigarray.(Array3.create Float64 fortran_layout n_ao n_ao n_ao)\n",
" in\n",
" let m_qr_i = Mat.create (n_ao*n_ao) n_mo in\n",
" let m_ri_j = Mat.create (n_ao*n_mo) n_mo in\n",
" let m_ij_k = Mat.create (n_mo*n_mo) n_mo in\n",
" \n",
" Array.iter (fun s ->\n",
" (* Grosse boucle externe sur s *)\n",
" Array.iter (fun r ->\n",
" Array.iter (fun q ->\n",
" Array.iter (fun p ->\n",
" m_pqr.{p,q,r} <- ERI.get_phys ee_ints p q r s\n",
" ) (Util.array_range 1 n_ao)\n",
" ) (Util.array_range 1 n_ao)\n",
" ) (Util.array_range 1 n_ao);\n",
" \n",
" (* Conversion d'un tableau a 3 indices en une matrice nao x nao^2 *)\n",
" let m_p_qr =\n",
" Bigarray.reshape (Bigarray.genarray_of_array3 m_pqr) [| n_ao ; n_ao*n_ao |]\n",
" |> Bigarray.array2_of_genarray\n",
" in\n",
" \n",
" let m_qr_i =\n",
" (* (qr,i) = <i r|q s> = \\sum_p <p r | q s> C_{pi} *)\n",
" gemm ~transa:`T ~c:m_qr_i m_p_qr m_C\n",
" in\n",
" \n",
" let m_q_ri =\n",
" (* Transformation de la matrice (qr,i) en (q,ri) *)\n",
" Bigarray.reshape_2 (Bigarray.genarray_of_array2 m_qr_i) n_ao (n_ao*n_mo)\n",
" in\n",
" \n",
" let m_ri_j =\n",
" (* (ri,j) = <i r | j s> = \\sum_q <i r | q s> C_{bj} *)\n",
" gemm ~transa:`T ~c:m_ri_j m_q_ri m_C\n",
" in\n",
" \n",
" let m_r_ij =\n",
" (* Transformation de la matrice (ri,j) en (r,ij) *)\n",
" Bigarray.reshape_2 (Bigarray.genarray_of_array2 m_ri_j) n_ao (n_mo*n_mo)\n",
" in\n",
" \n",
" let m_ij_k =\n",
" (* (ij,k) = <i k | j s> = \\sum_r <i r | j s> C_{rk} *)\n",
" gemm ~transa:`T ~c:m_ij_k m_r_ij m_C\n",
" in\n",
" \n",
" let m_ijk =\n",
" (* Transformation de la matrice (ei,j) en (e,ij) *)\n",
" Bigarray.reshape (Bigarray.genarray_of_array2 m_ij_k) [| n_mo ; n_mo ; n_mo |]\n",
" |> Bigarray.array3_of_genarray\n",
" in\n",
" \n",
" Array.iter (fun j ->\n",
" Array.iter (fun i ->\n",
" m_b12.{i,j} <- m_b12.{i,j} +. m_C.{s,j} *. (m_ijk.{i,i,i} -. m_ijk.{j,i,j});\n",
" m_a12.{i,j} <- m_a12.{i,j} +. m_ijk.{i,i,j} *. m_C.{s,j} -.\n",
" 0.25 *. ( (m_ijk.{i,i,i} -. m_ijk.{j,i,j}) *. m_C.{s,i} +.\n",
" (m_ijk.{j,j,j} -. m_ijk.{i,j,i}) *. m_C.{s,j})\n",
" ) (Util.array_range 1 n_mo)\n",
" ) (Util.array_range 1 n_mo)\n",
" ) (Util.array_range 1 n_ao);\n",
" \n",
" let t1 = Sys.time () in\n",
" Printf.printf \"t = %f s\\n%!\" (t1 -. t0);\n",
" Mat.init_cols n_mo n_mo ( fun i j ->\n",
" if i= j then 0.\n",
" else 0.25 *. (acos(-. m_a12.{i,j} /. sqrt((m_a12.{i,j}**2.) +. (m_b12.{i,j}**2. ))))\n",
" );;\n",
"\n",
"(*********************)\n",
"\n",
"f_alpha m_C;;\n",
"*)"
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
@ -1456,9 +1362,9 @@
" else 0.25 *. (acos(-. m_a12.{i,j} /. sqrt((m_a12.{i,j}**2.) +. (m_b12.{i,j}**2.)))));;\n", " else 0.25 *. (acos(-. m_a12.{i,j} /. sqrt((m_a12.{i,j}**2.) +. (m_b12.{i,j}**2.)))));;\n",
"\n", "\n",
"(*********************)\n", "(*********************)\n",
"\n", "(*\n",
"f_alpha m_C;; \n", "f_alpha m_C;; \n",
"\n" "*)\n"
] ]
}, },
{ {
@ -1552,89 +1458,9 @@
" ),Vec.sum v_d);;\n", " ),Vec.sum v_d);;\n",
"\n", "\n",
"(*********************)\n", "(*********************)\n",
"\n", "(*\n",
"f_alpha m_C;;\n", "f_alpha m_C;;\n",
"(*\n",
"let m_alpha , s_D = f_alpha m_C;;\n", "let m_alpha , s_D = f_alpha m_C;;\n",
"\n",
"*)\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(*\n",
"(* Fonction de calcul de tous les alpha ER -> Matrice, dépend de m_a12, m_b12 qui dépendent de m_C *)\n",
"let f_alpha m_C eps=\n",
" let n_mo = Mat.dim2 m_C\n",
" in\n",
" (* Fonction de calcul de toutes les intégrales B_12 -> Matrice, dépend de m_C *)\n",
" let m_b12 = Mat.init_cols n_mo n_mo (fun i j -> 0.) in\n",
" let m_a12 = Mat.init_cols n_mo n_mo (fun i j -> 0.) in\n",
" Array.iter (fun a ->\n",
" Array.iter (fun b ->\n",
" let mca = Vec.init n_mo (fun i -> m_C.{a,i} *. m_C.{b,i}) in\n",
" Array.iter (fun e ->\n",
" Array.iter (fun f ->\n",
" let integral = ERI.get_phys ee_ints f b e a in\n",
" if abs_float integral > eps then\n",
" Array.iter ( fun i -> \n",
" let mcei = m_C.{e,i} *. m_C.{f,i} in\n",
" Array.iter ( fun j -> \n",
" let x = m_C.{e,i} *. m_C.{f,j} *. integral in\n",
" let mcaij = ( mca.{i} -. mca.{j} ) in\n",
" m_b12.{i,j} <- m_b12.{i,j} +. mcaij *. x;\n",
" m_a12.{i,j} <- m_a12.{i,j} +. m_C.{a,i} *. m_C.{b,j} *. x\n",
" -. 0.25 *. ( mcei -. m_C.{e,j} *. m_C.{f,j} ) *. mcaij *. integral \n",
" ) (Util.array_range 1 n_mo)\n",
" ) (Util.array_range 1 n_mo)\n",
" ) (Util.array_range 1 n_ao)\n",
" ) (Util.array_range 1 n_ao)\n",
" ) (Util.array_range 1 n_ao)\n",
" ) (Util.array_range 1 n_ao);\n",
"\n",
" Mat.init_cols n_mo n_mo ( fun i j -> \n",
" if i= j then 0. \n",
" else 0.25 *. (acos(-. m_a12.{i,j} /. sqrt((m_a12.{i,j}**2.) +. (m_b12.{i,j}**2.)))));;\n",
"\n",
"(*********************)\n",
"\n",
"f_alpha m_C 1.e-5;; \n",
"*)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(*\n",
"(* Calcul de D -> critère à maximiser dans ER*)\n",
"let s_D m_C = \n",
" let v_D = \n",
" let n_mo = Mat.dim2 m_C\n",
" in\n",
" let m_D = Mat.init_cols n_mo n_mo (fun i j ->\n",
" integral_general (fun a b e f i j -> m_C.{a,i} *. m_C.{b,i} *. m_C.{e,i} *. m_C.{f,i} \n",
" ) i j\n",
" )\n",
" in Vec.init n_mo ( fun i -> m_D.{i,i} )\n",
" in Vec.sum v_D ;;\n",
"\n",
"(******************)\n",
"let m_D = Mat.init_cols n_mo n_mo (fun i j ->\n",
" integral_general (fun a b e f i j -> m_C.{a,i} *. m_C.{b,i} *. m_C.{e,i} *. m_C.{f,i} \n",
" ) i j\n",
" );;\n",
"let toto = s_D m_C;;\n",
"\n",
"*)" "*)"
] ]
}, },
@ -1681,8 +1507,9 @@
" Vec.sum(Vec.init n_mo ( fun i -> (phi_x_phi.{i,i})**2. +. (phi_y_phi.{i,i})**2. +. (phi_z_phi.{i,i})**2.)));;\n", " Vec.sum(Vec.init n_mo ( fun i -> (phi_x_phi.{i,i})**2. +. (phi_y_phi.{i,i})**2. +. (phi_z_phi.{i,i})**2.)));;\n",
"\n", "\n",
"(****************************)\n", "(****************************)\n",
"\n", "(*\n",
"f_alpha_boys m_C;;\n" "f_alpha_boys m_C;;\n",
"*)"
] ]
}, },
{ {
@ -1724,11 +1551,8 @@
"(*\n", "(*\n",
"m_alpha_d \"ER\" ;;\n", "m_alpha_d \"ER\" ;;\n",
"m_alpha_d \"Boys\" ;;\n", "m_alpha_d \"Boys\" ;;\n",
"\n",
"let methode = \"ER\";;\n", "let methode = \"ER\";;\n",
"\n",
"let alphad = m_alpha_d methode m_C;;\n", "let alphad = m_alpha_d methode m_C;;\n",
"\n",
"let m_alpha = alphad.m_alpha;;\n", "let m_alpha = alphad.m_alpha;;\n",
"let d = alphad.d;;\n", "let d = alphad.d;;\n",
"*)" "*)"
@ -1748,7 +1572,8 @@
" let vec2 = Vec.sqr vec_m\n", " let vec2 = Vec.sqr vec_m\n",
"in sqrt(Vec.sum vec2);;\n", "in sqrt(Vec.sum vec2);;\n",
" \n", " \n",
"(*\n", "(************************) \n",
" (*\n",
"norme_alpha m_alpha;;\n", "norme_alpha m_alpha;;\n",
"*)" "*)"
] ]
@ -1791,7 +1616,7 @@
" \n", " \n",
" (* indice i du alpha max *)\n", " (* indice i du alpha max *)\n",
" let indice_ii = \n", " let indice_ii = \n",
" let max = max_element3 alpha_m (* Fonction -> constante *)\n", " let max = max_element3 alpha_m \n",
" in\n", " in\n",
" \n", " \n",
" (*Printf.printf \"%i\\n%!\" max;*)\n", " (*Printf.printf \"%i\\n%!\" max;*)\n",
@ -1801,7 +1626,7 @@
" \n", " \n",
" (* indice j du alpha max *)\n", " (* indice j du alpha max *)\n",
" let indice_jj = \n", " let indice_jj = \n",
" let max = max_element3 alpha_m (* Fonction -> constante *)\n", " let max = max_element3 alpha_m \n",
" in\n", " in\n",
" (max - 1) / n_mo +1\n", " (max - 1) / n_mo +1\n",
" in\n", " in\n",
@ -1818,7 +1643,7 @@
" alpha_m.{i,j}\n", " alpha_m.{i,j}\n",
" \n", " \n",
" in\n", " in\n",
" let alpha_max = alpha alpha_m (* Fonction -> constante *)\n", " let alpha_max = alpha alpha_m \n",
" in\n", " in\n",
" \n", " \n",
" (*Printf.printf \"%f\\n%!\" alpha_max;*)\n", " (*Printf.printf \"%f\\n%!\" alpha_max;*)\n",
@ -1828,7 +1653,6 @@
" else new_m_alpha alpha_m m_C (n_rec_alpha-1);;\n", " else new_m_alpha alpha_m m_C (n_rec_alpha-1);;\n",
"\n", "\n",
"(*************************)\n", "(*************************)\n",
"\n",
"(*\n", "(*\n",
"let m_alpha,d = f_alpha m_C\n", "let m_alpha,d = f_alpha m_C\n",
"let alphaij = new_m_alpha m_alpha m_C 3;;\n", "let alphaij = new_m_alpha m_alpha m_C 3;;\n",
@ -1842,6 +1666,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"(* Fonction de pattern matching pour localiser ou délocaliser *)\n",
"let alpha_v loc_deloc alphaij = \n", "let alpha_v loc_deloc alphaij = \n",
" let alpha_loc = alphaij.alpha_max\n", " let alpha_loc = alphaij.alpha_max\n",
" in\n", " in\n",
@ -1854,7 +1679,6 @@
" | _ -> invalid_arg \"Unknown method, please enter loc or deloc\" \n", " | _ -> invalid_arg \"Unknown method, please enter loc or deloc\" \n",
"in choice loc_deloc ;;\n", "in choice loc_deloc ;;\n",
"\n", "\n",
"\n",
"(* Matrice de rotation 2 par 2 *)\n", "(* Matrice de rotation 2 par 2 *)\n",
"let f_R alpha =\n", "let f_R alpha =\n",
" Mat.init_cols 2 2 (fun i j -> \n", " Mat.init_cols 2 2 (fun i j -> \n",
@ -1865,7 +1689,6 @@
" else -. sin alpha )\n", " else -. sin alpha )\n",
";;\n", ";;\n",
"(*************************)\n", "(*************************)\n",
"\n",
"(*\n", "(*\n",
"let alpha = alphaij.alpha_max;; (* Fonction -> constante *) \n", "let alpha = alphaij.alpha_max;; (* Fonction -> constante *) \n",
"f_R alpha;;\n", "f_R alpha;;\n",
@ -1886,12 +1709,9 @@
"(*Uniquement pour pouvoir tester les fonctions après cette cellules*)\n", "(*Uniquement pour pouvoir tester les fonctions après cette cellules*)\n",
"(*\n", "(*\n",
"(* Indice i et j du alpha max après calcul *)\n", "(* Indice i et j du alpha max après calcul *)\n",
"let indice_i = alphaij.indice_ii;; (* Fonction -> constante *)\n", "let indice_i = alphaij.indice_ii;; \n",
" \n", "let indice_j = alphaij.indice_jj;; \n",
"let indice_j = alphaij.indice_jj;; (* Fonction -> constante *)\n", "let m_R = f_R alpha;; \n",
" \n",
" \n",
"let m_R = f_R alpha;; (* Fonction -> constante *) \n",
"*)" "*)"
] ]
}, },
@ -1909,10 +1729,9 @@
"Mat.init_cols n_ao 2 (fun i j -> if j=1 then m_C.{i,indice_i} else m_C.{i,indice_j} );;\n", "Mat.init_cols n_ao 2 (fun i j -> if j=1 then m_C.{i,indice_i} else m_C.{i,indice_j} );;\n",
"\n", "\n",
"(*************************)\n", "(*************************)\n",
"\n",
"(*\n", "(*\n",
"let m_Ksi = f_Ksi indice_i indice_j m_C;; (* Fonction -> constante *)\n", "let m_Ksi = f_Ksi indice_i indice_j m_C;; \n",
"*)\n" "*)"
] ]
}, },
{ {
@ -1926,10 +1745,9 @@
"let f_Ksi_tilde m_R m_Ksi m_C = gemm m_Ksi m_R;;\n", "let f_Ksi_tilde m_R m_Ksi m_C = gemm m_Ksi m_R;;\n",
"\n", "\n",
"(*************************)\n", "(*************************)\n",
"\n",
"(*\n", "(*\n",
"let m_Ksi_tilde = f_Ksi_tilde m_R m_Ksi;; (* Fonction -> constante *)\n", "let m_Ksi_tilde = f_Ksi_tilde m_R m_Ksi;; \n",
"*)\n" "*)"
] ]
}, },
{ {
@ -1974,6 +1792,7 @@
" else 0.)\n", " else 0.)\n",
";;\n", ";;\n",
"*)\n", "*)\n",
"\n",
"let f_k mat indice_i indice_j m_C = \n", "let f_k mat indice_i indice_j m_C = \n",
"let n_mo = Mat.dim2 m_C\n", "let n_mo = Mat.dim2 m_C\n",
" in\n", " in\n",
@ -1988,9 +1807,9 @@
"(*************************)\n", "(*************************)\n",
"\n", "\n",
"(*\n", "(*\n",
"let m_Psi = f_Psi m_Ksi indice_i indice_j;; (* Fonction -> constante *)\n", "let m_Psi = f_Psi m_Ksi indice_i indice_j;; \n",
"\n", "\n",
"let m_Psi_tilde = f_Psi_tilde m_Ksi_tilde indice_i indice_j;; (* Fonction -> constante *)\n", "let m_Psi_tilde = f_Psi_tilde m_Ksi_tilde indice_i indice_j;; \n",
"*)" "*)"
] ]
}, },
@ -2007,7 +1826,7 @@
"(*************************)\n", "(*************************)\n",
"\n", "\n",
"(*\n", "(*\n",
"let m_interm = f_interm m_C m_Psi;; (* Fonction -> constante *)\n", "let m_interm = f_interm m_C m_Psi;; \n",
"\n", "\n",
"let new_m_C m_C= Mat.add m_Psi_tilde m_interm;;\n", "let new_m_C m_C= Mat.add m_Psi_tilde m_interm;;\n",
"\n", "\n",
@ -2084,55 +1903,55 @@
" (* alphaij contient le alpha max ainsi que ses indices i et j *)\n", " (* alphaij contient le alpha max ainsi que ses indices i et j *)\n",
" let n_rec_alpha = 10 (* Nombre ditération max pour réduire les valeurs de alpha *)\n", " let n_rec_alpha = 10 (* Nombre ditération max pour réduire les valeurs de alpha *)\n",
" in\n", " in\n",
" let alphaij = new_m_alpha m_alpha m_C n_rec_alpha (* Fonction -> constante *)\n", " let alphaij = new_m_alpha m_alpha m_C n_rec_alpha \n",
" in\n", " in\n",
"\n", "\n",
" (* Valeur de alpha max après calcul *) (* Epsilon = Pas <1. , 1. -> normal, sinon Pas plus petit *)\n", " (* Valeur de alpha max après calcul *) (* Epsilon = Pas <1. , 1. -> normal, sinon Pas plus petit *)\n",
" let alpha = (alpha_v loc_deloc alphaij) *. epsilon (* Fonction -> constante *)\n", " let alpha = (alpha_v loc_deloc alphaij) *. epsilon \n",
" in\n", " in\n",
"\n", "\n",
" (*Printf.printf \"%f\\n%!\" alpha;*)\n", " (*Printf.printf \"%f\\n%!\" alpha;*)\n",
" \n", " \n",
" (* Indice i et j du alpha max après calcul *)\n", " (* Indice i et j du alpha max après calcul *)\n",
" let indice_i = alphaij.indice_ii (* Fonction -> constante *)\n", " let indice_i = alphaij.indice_ii \n",
" in\n", " in\n",
" let indice_j = alphaij.indice_jj (* Fonction -> constante *)\n", " let indice_j = alphaij.indice_jj \n",
" in\n", " in\n",
"\n", "\n",
" (*Printf.printf \"%i %i\\n%!\" indice_i indice_j;*)\n", " (*Printf.printf \"%i %i\\n%!\" indice_i indice_j;*)\n",
" \n", " \n",
" (* Matrice de rotation *)\n", " (* Matrice de rotation *)\n",
" let m_R = f_R alpha (* Fonction -> constante *)\n", " let m_R = f_R alpha \n",
" in\n", " in\n",
"\n", "\n",
" (*Util.debug_matrix \"m_R\" m_R;*)\n", " (*Util.debug_matrix \"m_R\" m_R;*)\n",
"\n", "\n",
" (* Matrice qui va subir la rotation *)\n", " (* Matrice qui va subir la rotation *)\n",
" let m_Ksi = f_Ksi indice_i indice_j m_C (* Fonction -> constante *)\n", " let m_Ksi = f_Ksi indice_i indice_j m_C \n",
" in\n", " in\n",
"\n", "\n",
" (*Util.debug_matrix \"m_Ksi\" m_Ksi;*)\n", " (*Util.debug_matrix \"m_Ksi\" m_Ksi;*)\n",
"\n", "\n",
" (* Matrice ayant subit la rotation *)\n", " (* Matrice ayant subit la rotation *)\n",
" let m_Ksi_tilde = f_Ksi_tilde m_R m_Ksi m_C (* Fonction -> constante *)\n", " let m_Ksi_tilde = f_Ksi_tilde m_R m_Ksi m_C \n",
" in\n", " in\n",
"\n", "\n",
" (*Util.debug_matrix \"m_Ksi_tilde\" m_Ksi_tilde;*)\n", " (*Util.debug_matrix \"m_Ksi_tilde\" m_Ksi_tilde;*)\n",
"\n", "\n",
" (* Matrice pour supprimerles coef des orbitales i et j dans la matrice des coef *)\n", " (* Matrice pour supprimerles coef des orbitales i et j dans la matrice des coef *)\n",
" let m_Psi = f_k m_Ksi indice_i indice_j m_C(* Fonction -> constante *)\n", " let m_Psi = f_k m_Ksi indice_i indice_j m_C\n",
" in\n", " in\n",
"\n", "\n",
" (*Util.debug_matrix \"m_Psi\" m_Psi;*)\n", " (*Util.debug_matrix \"m_Psi\" m_Psi;*)\n",
"\n", "\n",
" (* Matrice pour ajouter les coef des orbitales i~ et j~ dans la matrice des coef *)\n", " (* Matrice pour ajouter les coef des orbitales i~ et j~ dans la matrice des coef *)\n",
" let m_Psi_tilde = f_k m_Ksi_tilde indice_i indice_j m_C (* Fonction -> constante *)\n", " let m_Psi_tilde = f_k m_Ksi_tilde indice_i indice_j m_C \n",
" in\n", " in\n",
"\n", "\n",
" (*Util.debug_matrix \"m_Psi_tilde\" m_Psi_tilde;*)\n", " (*Util.debug_matrix \"m_Psi_tilde\" m_Psi_tilde;*)\n",
"\n", "\n",
" (* Matrice avec les coef des orbitales i et j remplacés par 0 *)\n", " (* Matrice avec les coef des orbitales i et j remplacés par 0 *)\n",
" let m_interm = f_interm m_C m_Psi (* Fonction -> constante *)\n", " let m_interm = f_interm m_C m_Psi \n",
" in\n", " in\n",
" \n", " \n",
" (*Util.debug_matrix \"m_interm\" m_interm;*)\n", " (*Util.debug_matrix \"m_interm\" m_interm;*)\n",
@ -2140,7 +1959,7 @@
" (* Matrice après rotation *)\n", " (* Matrice après rotation *)\n",
" ( Mat.add m_Psi_tilde m_interm, critere_D)\n", " ( Mat.add m_Psi_tilde m_interm, critere_D)\n",
" in\n", " in\n",
" let m_new_m_C , critere_D = new_m_C m_C methode loc_deloc (* Fonction -> constante *)\n", " let m_new_m_C , critere_D = new_m_C m_C methode loc_deloc \n",
" in\n", " in\n",
" let diff = prev_critere_D -. critere_D +. 1.\n", " let diff = prev_critere_D -. critere_D +. 1.\n",
" \n", " \n",