Codigo para cálculo de términos espectroscópicos

Esta rutina genera todas las posibles combinaciones excluyendo términos que no cumplen con el principio de exclusión y combinaciones equivalentes. Una combinación equivalente serían por ejemplo los siguientes dos estados:

[(2,-0.5), (1,0.5)] y [(1,0.5), (2,-0.5)]

En este caso cada tupla () es un electrón con sus números l y s, y el estado es la combinación de ambos.


In [12]:
Slater_sets = []
Slater = []
for ml1 in (-2,-1,0,1,2):
    for ml2 in (-2,-1,0,1,2):
        for ms1 in (1/2,-1/2):
            for ms2 in (1/2,-1/2):
                if len({(ml1,ms1),(ml2,ms2)})>1:
                    if {(ml1,ms1),(ml2,ms2)} not in Slater_sets:
                        Slater_sets.append({(ml1,ms1),(ml2,ms2)})
                        Slater.append(list({(ml1,ms1),(ml2,ms2)}))

In [31]:
print("Hay %d posibles combinaciones:\n" %len(Slater)); Slater


Hay 45 posibles combinaciones:

Out[31]:
[[(-2, -0.5), (-2, 0.5)],
 [(-1, 0.5), (-2, 0.5)],
 [(-1, -0.5), (-2, 0.5)],
 [(-1, 0.5), (-2, -0.5)],
 [(-1, -0.5), (-2, -0.5)],
 [(0, 0.5), (-2, 0.5)],
 [(0, -0.5), (-2, 0.5)],
 [(0, 0.5), (-2, -0.5)],
 [(0, -0.5), (-2, -0.5)],
 [(1, 0.5), (-2, 0.5)],
 [(1, -0.5), (-2, 0.5)],
 [(1, 0.5), (-2, -0.5)],
 [(1, -0.5), (-2, -0.5)],
 [(2, 0.5), (-2, 0.5)],
 [(2, -0.5), (-2, 0.5)],
 [(2, 0.5), (-2, -0.5)],
 [(2, -0.5), (-2, -0.5)],
 [(-1, -0.5), (-1, 0.5)],
 [(0, 0.5), (-1, 0.5)],
 [(0, -0.5), (-1, 0.5)],
 [(0, 0.5), (-1, -0.5)],
 [(0, -0.5), (-1, -0.5)],
 [(1, 0.5), (-1, 0.5)],
 [(1, -0.5), (-1, 0.5)],
 [(1, 0.5), (-1, -0.5)],
 [(1, -0.5), (-1, -0.5)],
 [(2, 0.5), (-1, 0.5)],
 [(2, -0.5), (-1, 0.5)],
 [(2, 0.5), (-1, -0.5)],
 [(2, -0.5), (-1, -0.5)],
 [(0, -0.5), (0, 0.5)],
 [(1, 0.5), (0, 0.5)],
 [(1, -0.5), (0, 0.5)],
 [(1, 0.5), (0, -0.5)],
 [(1, -0.5), (0, -0.5)],
 [(2, 0.5), (0, 0.5)],
 [(2, -0.5), (0, 0.5)],
 [(2, 0.5), (0, -0.5)],
 [(2, -0.5), (0, -0.5)],
 [(1, -0.5), (1, 0.5)],
 [(2, 0.5), (1, 0.5)],
 [(2, -0.5), (1, 0.5)],
 [(2, 0.5), (1, -0.5)],
 [(2, -0.5), (1, -0.5)],
 [(2, -0.5), (2, 0.5)]]

Luego se crea un diccionario para clasificarlas. El diccionario nos ayudará a determinar a qué combinación de (L,S) pertenece cada estado.


In [33]:
D = dict()
for slater in Slater:
    key = (slater[0][0]+slater[1][0],slater[0][1]+slater[1][1])
    if key not in D:
        D[key] = [slater]
    else:
        D[key].append(slater)

In [34]:
print("Existen %d combinaciones de L y S" %len(D))


Existen 23 combinaciones de L y S

In [16]:
D.keys()


Out[16]:
dict_keys([(0, 0.0), (-2, 0.0), (-3, -1.0), (-2, -1.0), (-1, 1.0), (2, 1.0), (-3, 1.0), (3, -1.0), (2, -1.0), (-4, 0.0), (1, 0.0), (1, -1.0), (3, 0.0), (-1, 0.0), (0, 1.0), (-2, 1.0), (3, 1.0), (-3, 0.0), (2, 0.0), (-1, -1.0), (0, -1.0), (4, 0.0), (1, 1.0)])

Construcción de la tabla de determinantes de Slater

Ahora ordenamos las cominaciones agrupandolas en filas y columnas de tal manera que


In [35]:
import pandas
rows = []
for i in range(9):
    rows.append([])
L = 4
j = 0
i =0
for L in range(4,-5,-1):
    for S in [1,0,-1]:
        if (L,S) in D.keys():
            rows[j].append(range(len(D[(L,S)])))
            #rows[j].append(D[(L,S)])
        else:
            rows[j].append(None)
    j+=1

In [53]:
df2 = pandas.DataFrame(rows,pandas.MultiIndex.from_tuples([('Ml',4),('Ml',3),('Ml',2),('Ml',1),('Ml',0),('Ml',-1),('Ml',-2),('Ml',-3),('Ml',-4)])\
       ,pandas.MultiIndex.from_tuples([('Ms',1),('Ms',0),('Ms',-1)]))

Configuración $nd^2$


In [58]:
df2


Out[58]:
Ms
1 0 -1
Ml 4 None (0) None
3 (0) (0, 1) (0)
2 (0) (0, 1, 2) (0)
1 (0, 1) (0, 1, 2, 3) (0, 1)
0 (0, 1) (0, 1, 2, 3, 4) (0, 1)
-1 (0, 1) (0, 1, 2, 3) (0, 1)
-2 (0) (0, 1, 2) (0)
-3 (0) (0, 1) (0)
-4 None (0) None

En detalle los estados serían:


In [63]:
rows = []
for i in range(9):
    rows.append([])
L = 4
j = 0
i =0
for L in range(4,-5,-1):
    for S in [1,0,-1]:
        if (L,S) in D.keys():
            #rows[j].append(range(len(D[(L,S)])))
            rows[j].append(D[(L,S)])
        else:
            rows[j].append(None)
    j+=1
df3 = pandas.DataFrame(rows,pandas.MultiIndex.from_tuples([('Ml',4),('Ml',3),('Ml',2),('Ml',1),('Ml',0),('Ml',-1),('Ml',-2),('Ml',-3),('Ml',-4)])\
       ,pandas.MultiIndex.from_tuples([('Ms',1),('Ms',0),('Ms',-1)]))

In [64]:
df3


Out[64]:
Ms
1 0 -1
Ml 4 None [[(2, -0.5), (2, 0.5)]] None
3 [[(2, 0.5), (1, 0.5)]] [[(2, -0.5), (1, 0.5)], [(2, 0.5), (1, -0.5)]] [[(2, -0.5), (1, -0.5)]]
2 [[(2, 0.5), (0, 0.5)]] [[(2, -0.5), (0, 0.5)], [(2, 0.5), (0, -0.5)],... [[(2, -0.5), (0, -0.5)]]
1 [[(2, 0.5), (-1, 0.5)], [(1, 0.5), (0, 0.5)]] [[(2, -0.5), (-1, 0.5)], [(2, 0.5), (-1, -0.5)... [[(2, -0.5), (-1, -0.5)], [(1, -0.5), (0, -0.5)]]
0 [[(2, 0.5), (-2, 0.5)], [(1, 0.5), (-1, 0.5)]] [[(2, -0.5), (-2, 0.5)], [(2, 0.5), (-2, -0.5)... [[(2, -0.5), (-2, -0.5)], [(1, -0.5), (-1, -0....
-1 [[(1, 0.5), (-2, 0.5)], [(0, 0.5), (-1, 0.5)]] [[(1, -0.5), (-2, 0.5)], [(1, 0.5), (-2, -0.5)... [[(1, -0.5), (-2, -0.5)], [(0, -0.5), (-1, -0....
-2 [[(0, 0.5), (-2, 0.5)]] [[(0, -0.5), (-2, 0.5)], [(0, 0.5), (-2, -0.5)... [[(0, -0.5), (-2, -0.5)]]
-3 [[(-1, 0.5), (-2, 0.5)]] [[(-1, -0.5), (-2, 0.5)], [(-1, 0.5), (-2, -0.... [[(-1, -0.5), (-2, -0.5)]]
-4 None [[(-2, -0.5), (-2, 0.5)]] None

In [ ]: