FablabSU

N,N),dtype=numpy.uint8) 'on crée une matrice de taille N*N pour placer les valeur des spins'

          self.nbits = 8                   '''taille du codage des bits et donc du nombre de réseau parallèle'''
          self.Nspin = self.Ns*self.nbits  '''nombre de spin totale'''
              
      def temperature(self,T):
          beta = 1.0/T                    
          p0 = math.exp(-8.0*beta)               '''probabilité du cas où il y a aucun spin de signe opposé autour '''
          p1 = (math.exp(-4.0*beta)-p0)/(1.0-p0) '''probabilité du cas où il y a un spin de signe opposé autour '''
          self.deuxp0 = p0*2.0                   '''on multiplie les probabilités par 2 puisque on a pris''' 
          self.deuxp1 = p1*2.0                   '''pour convention des spins de valeur +-1 et non +-1/2)'''

      def voisin(self,i,j):          '''fonction qui fixe les conventions au bord du réseau'''
          ii = i             
          if ii<0:                   '''si i (indice de ligne) est négatif on prend la dernière valeur de la ligne'''
              ii=self.N-1  
          elif ii>=self.N:           '''si i est supérieur à la dernière valeur de la ligne on prend la première'''
              ii=0                   '''si i est dans l'intervalle 0 N-1 on ne fait rien'''
          jj = j                     '''idem pour j (les colonnes)'''
          if jj<0: 
              jj=self.N-1
          elif jj>=self.N:
              jj=0
          return self.spin[jj][ii]
          
          
      def moment(self):                          '''fonction pour le moment'''
          m = 0.0
          for i in range(self.N):                '''on parcourt la matrice de spin'''
              for j in range(self.N):
                  s = self.spin[j][i]            '''on prend un spin'''
                  for b in range(self.nbits):    '''on parcourt les bits du spin s'''
                      m += 2*(s&1)-1             '''m prends la valeur du premier bit du codage du spin'''
                      s = s >> 1                 '''on switch vers la gauche les bits de la valeur s pour '''
          return -m*1.0/self.Nspin               '''que la ligne du dessus reste valide (parcourt des bits de s)'''
                                                 '''on renvois la moyenne pondérer par le nombre de spin totale 8*N*N'''

      def metropolis(self):                      '''algorithme de Métropolis'''
          i = random.randint(0,self.N-1)         '''on prend un spin aléatoirement dans le réseau,pour se faire'''
          j = random.randint(0,self.N-1)         '''on prend un nombre aléatoire entre 0 et N-1 pour i et j '''
          s = self.spin[j][i]                    '''une variable renvois à ce spin'''
          a1 = s^self.voisin(i-1,j)              '''création des variables correspondant au voisins'''
          a2 = s^self.voisin(i+1,j)
          a3 = s^self.voisin(i,j-1)
          a4 = s^self.voisin(i,j+1)
          R1 = a1|a2|a3|a4                      '''on défini la variable un voisin de spin opposé'''
          R2 = ((a1|a2)&(a3|a4))|((a1&a2)|(a3&a4)) '''on défini la variable deux voisins de spin opposé'''
          if random.random() < self.deuxp0:         '''on prend un nombre aléatoire pour le comparé à la probabilité '''
              r0 = random.getrandbits(self.nbits)   '''défini plus haut, dans le cas où ΔE=8 ou ΔE=4'''
          else:
              r0 = 0
          if random.random() < self.deuxp1:
              r1 = random.getrandbits(self.nbits)
          else:
              r1 = 0
          self.spin[j][i] ^= R2|(R1&r1)|r0          '''le spin prend sa nouvelle valeur'''
          
      def boucle(self,n):                     '''on défini notre boucle d'itération'''
          m = numpy.zeros(n)                  '''le moment est une matrice de taille 1*n remplis de zéros'''
          for k in range(n):                  '''la boucle for s'itère n fois '''
              m[k] = self.moment()            '''on change les valeurs de m avec la valeur calculé pour ce réseau '''
              for i in range(self.Ns):        '''grâce à la fonction moment puis on rechange les valeur du réseau'''
                   self.metropolis()          '''avec la fonction metropolis'''
          return (m,numpy.mean(m),numpy.std(m)) '''on retourne m (matrice moment),moyenne de m et l'écart type de m'''
      def couche(self):                          '''fonction qui affiche le réseau'''
          mask = numpy.ones((self.N,self.N),dtype=numpy.uint8) '''on crée un mask remplis de 1 de dimension du réseau'''
          return numpy.bitwise_and(self.spin,mask)             '''on remplis ce mask avec les valeurs d'un des huit 
          
      réseaux'''
      
      
      Tc = 2.0/(math.asinh(1.0))              
      N = 30                            '''on défini la taille du réseau'''
      def fox(k):                       '''fonction pour calculer le moment moyen pour différent T (température)'''
          M=np.ones(k-1)                '''on prends une matrice avec des 1 '''
          for i in range(0,k-1):        '''on lance la boucle for qui calcul le nombre de valeur voulus'''
              ising = ising2D.Ising2D(N)  '''on lance les fonctions utilent'''
              ising.temperature(1+(0.1*i))
              (mi,Mi,dM)=ising.boucle(1000)
              print(mi)                         '''on met un print pour controler qu'il n'y est pas d'ineptie au cours du calcul'''
              M[i]=Mi                           '''on rempli notre matrice en changeant les 1 par les moments'''
          return M                              '''on retourne notre matrice'''
          
       M1=fox(21)                                                                       
       M1=[ 0.99932111,0.99836861,  0.99701611,  0.99489139 , 0.99160444 , 0.98705167,
            0.97972222 , 0.97036139,  0.95754611 , 0.93823056 , 0.91144806 , 0.87130667,
            0.78990611 , 0.56608111,  0.22495639 , 0.10684556,  0.07126639 , 0.01653139,
            0.01311056 , 0.02070972]

       T1=[ 1.        ,  1.10526316  ,1.21052632 , 1.31578947,  1.42105263 , 1.52631579,
            1.63157895,  1.73684211 , 1.84210526 , 1.94736842 , 2.05263158 , 2.15789474,
            2.26315789 , 2.36842105 , 2.47368421 , 2.57894737 , 2.68421053 , 2.78947368,
            2.89473684,  3.        ]

        plot(T1,M1,'b')                 '''on affiche le graphe M(T)'''
        xlabel("T (temperature)")
        ylabel("M (moment magnetique)")
        title("M(t)")
        savefig("M(t)",format="png")

Voici les courbes qui montrent l'alignement du réseau de spin selon un champ extérieur, j'ai effectué la modélisation dans le cas où le champ vaut +/-“1”.(On rappel que les spins ici valent par défaut -1 et que M ici est une valeur pondérer par le nombre de spin (taille du réseau