import pylab
import numpy
import random

class Lattice:
    def __init__(self,model,dim=20,value=None):
        self.dim     = dim
        self.lattice = []
        self.model   = model.name()
        ## fill the self.lattice now.
        ## fix this.
    
    def __call__(self,lx,ly):
        ## fix this ##
        return 1.

    def distance(lx1,ly1,lx2,ly2):
        deltax = abs(lx2-lx1)
        if abs(lx1+self.dim-lx2)<deltax:
            deltax = abs(lx1+self.dim-lx2)
        if abs(lx2+self.dim-lx1)<deltax:
            deltax = abs(lx2+self.dim-lx1)
        deltay = abs(ly2-ly1)
        if abs(ly1+self.dim-ly2)<deltay:
            deltay = abs(ly1+self.dim-ly2)
        if abs(ly2+self.dim-ly1)<deltay:
            deltay = abs(ly2+self.dim-ly1)
        return deltax+deltay

    def randomPosition(self):
        ## fix this
        return 0,0

    def setSpin(self,lx,ly,spin):
        ## fix this
        pass

    def output(self,lx=None,ly=None):
        if self.model=='+-':
            border = "  "
            for row in self.lattice:
                border += "--"
            print border
            y = 0
            for row in self.lattice:
                printrow = "  "
                x = 0
                for cell in row:
                    if lx is not None and ly is not None \
                               and lx==x and ly==y:
                        if cell==1:
                            printrow += " ^"
                        else:
                            printrow += " v"
                    else:
                        if cell==1:
                            printrow += " +"
                        else:
                            printrow += " -"
                    x += 1
                print printrow
                y += 1
            print border


class Ising:
    def __init__(self,H=0):
        self.H = H

    def name(self):
        return 'Ising Model'

    def randomSpin(self):
        ## fix this
        pass

    def modifySpin(self,spin):
        ## fix this
        pass

    def calculateEnergy(self,lx,ly,lattice):
        ## fix this
        return 1.


class Metropolis:
    def __init__(self,lattice,model):
        self.lattice = lattice
        self.model   = model
        self.dim     = self.lattice.dim
        self.dim2    = self.dim*self.dim

    def sweep(self,T):
        for count in xrange(self.dim2):
            self.modifySpin(T)

    def modifySpin(self,T):
        # This method picks a random position inside the lattice
        # and potentially changes the spin there.  To see whether
        # the spin changes, the energies related to it before and 
        # its possible alteration are calculated.  If the energy
        # after the spin alteration is smaller than before, the spin 
        # changes.  If not, the spin still changes with a
        # probability given by exp(-Delta E/T).  

        ## Fix this.
        pass



class Observables:
    def __init__(self,model):
        self.model      = model
        self.lattice    = Lattice(model)
        self.metropolis = Metropolis(self.lattice,self.model)
        self.Mmax       = float(self.lattice.dim*self.lattice.dim)

    def scanTemperatures(self,T=0.1,T1=4.0,deltaT=0.5,steps=10000):
        Ts = []
        Ms = []
        print 'Calculate observables in temperature range: [',T,',',T1,']'
        print '   in temperature steps of ',deltaT,' and with ',steps,' MC steps.'
        while T<T1:
            for i in xrange(steps/10):
                self.metropolis.sweep(T)
            M   = 0.
            for i in xrange(steps):
                self.metropolis.sweep(T)
                M += self.calculateMnorm()
            M /= float(steps)
            Ts.append(T)
            Ms.append(M)
            print T,M
            T += deltaT
        return Ts,Ms

    def calculateMnorm(self):
        ## fix this
        return 1.



if __name__ == "__main__":
    model  = Ising()
    #model  = Heisenberg()
    obs    = Observables(model)
    Ts, Ms = obs.scanTemperatures(0.,4.0,0.05,2000)

    import pylab

    # plot results
    pylab.subplot(111)
    MvsT      = pylab.plot(Ts,Ms,'gD',linewidth=1.0)
    titlename = 'M vs T in '+model.name()
    pylab.title(titlename)
    pylab.xlabel('$T$')
    pylab.ylabel('$M/M_{max}$')
    pylab.setp(pylab.gca(), 'xticklabels', [])
    # pylab.legend((MvsT),('Metropolis'))
    pylab.grid(True)
    pylab.show()