示例#1
0
 def argumentHandler(self,argv):
         #no argument: start GUI
         if len(argv) == 1:
                 self.gui = MainWindow(self)
         else:
                 self.gui = MainWindow(self)
                 for i in range(1,len(argv)):
                         #load a single configuration, start GUI
                         if argv[i] == '-pwi':
                                 self.readFile('PWScf Input',argv[i+1])
                                 self.gui.centralWidget().loadView()
                         if argv[i] == '-pwo':
                                 self.readFile('PWScf Output',argv[i+1])
                                 self.gui.centralWidget().loadView()
                         elif argv[i] == '-xyz':
                                 self.readFile('xyz',argv[i+1])
                                 self.gui.centralWidget().loadView()
示例#2
0
class TBController(QApplication):

        def __init__(self,argv):
                super(TBController,self).__init__(argv)
                self.mol = []
                self.pwdata = []
                self.indict = OrderedDict([('xyz',self.parseXyz),
                               ('PWScf Input',self.parsePwi),
                               ('PWScf Output' , self.parsePwo)])
                self.outdict= OrderedDict([('PWScf Input',self.writePwi),
                               ('xyz',self.writeXyz)])
                self.argumentHandler(argv)


#####################################################################
# Handle command line arguments:
#####################################################################
        def argumentHandler(self,argv):
                #no argument: start GUI
                if len(argv) == 1:
                        self.gui = MainWindow(self)
                else:
                        self.gui = MainWindow(self)
                        for i in range(1,len(argv)):
                                #load a single configuration, start GUI
                                if argv[i] == '-pwi':
                                        self.readFile('PWScf Input',argv[i+1])
                                        self.gui.centralWidget().loadView()
                                if argv[i] == '-pwo':
                                        self.readFile('PWScf Output',argv[i+1])
                                        self.gui.centralWidget().loadView()
                                elif argv[i] == '-xyz':
                                        self.readFile('xyz',argv[i+1])
                                        self.gui.centralWidget().loadView()


#####################################################################
# GET FUNCTIONS
#####################################################################

        def get_mol(self,index,step):
                return self.mol[index][step]

        def get_lmol(self,index):
                return len(self.mol[index])

        def get_nmol(self):
                return len(self.mol)

        def get_pw(self,index):
                return self.pwdata[index]

        def get_npw(self):
                return len(self.pwdata)


#####################################################################
# READ FUNCTIONS
#####################################################################

        def readFile(self,fmt,filename):
                data = open(filename,'r').readlines()
                self.indict[fmt](data)
                #return data

        def parseXyz(self,data):
                # create list of mol, trajectory support
                tlist = []
                # if first line does not contain nat exit
                if not data[0].strip().isdigit():
                        print 'not a xyz file'
                        return
                i=0
                while i < len(data):
                        # handle empty lines at eof or between molecules
                        if not data[i].strip().isdigit(): i+=1
                        # create new molecule
                        tmol = Molecule()
                        #fixed format nat and comment
                        nat = int(data[i])
                        tmol.comment = data[i+1]
                        #read coordinates and types
                        for j in range(i+2,i+nat+2):
                                line = data[j].split()
                                tmol.create_atom(line[0],float(line[1]),float(line[2]),float(line[3]))
                        i+=nat+2
                        tlist.append(tmol)
                #append to list of molecules
                self.mol.append(tlist)

        def parsePwi(self,data):
                # no need for list, only one molecule per file
                tmol = Molecule()
                tparam = PWParam()
                tcoord = []
                #parse data and create tparam
                while data:
                        header = data.pop(0).strip().split()
                        # ignore empty lines
                        if not header:
                                pass
                                #debug output. case not really needed.
                        # parse namelists
                        elif header[0][0] == '&':
                                tnl = {}
                                # parse entries
                                line = data.pop(0).strip().split(',')
                                while line[0] != '/':
                                        for j in range(len(line)):
                                                tnl[line[j].split('=')[0].strip()]=line[j].split('=')[1].strip()
                                        line = data.pop(0).strip().split(',')
                                tparam[header[0]]=tnl
                                #debug output
                        # parse card
                        elif header[0][0].isupper():
                                # 7 types of cards, need hardcoding
                                # 4 supported for now

                                #ATOMIC_SPECIES:
                                #Name   Weight  PP-file
                                if header[0] == 'ATOMIC_SPECIES':
                                        for i in range(int(tparam['&system']['ntyp'])):
                                                line = data.pop(0).strip().split()
                                                tparam['pse'][line[0]][1] = float(line[1])
                                                tparam['pse'][line[0]].append(line[2])

                                #ATOMIC_POSITIONS fmt
                                #Name   x   y   z
                                #Saved in temp list for parsing
                                elif header[0] == 'ATOMIC_POSITIONS':
                                        fmt = header[1]
                                        for i in range(int(tparam['&system']['nat'])):
                                                #support empty lines
                                                temp = data.pop(0).strip().split()
                                                while not temp:
                                                        temp = data.pop(0).strip().split()
                                                tcoord.append(temp)

                                #K_POINTS fmt
                                elif header[0] == 'K_POINTS':
                                        #Gamma point only
                                        if header[1] == 'gamma':
                                                tparam['K_POINTS']=['gamma']
                                        #MPGrid:
                                        #x y z offset
                                        #passed as whole string for now
                                        elif header[1] == 'automatic':
                                                #line = data.pop(0).strip().split()
                                                line = data.pop(0)
                                                #tparam['K_POINTS']=['automatic',[line[0:3],line[3:7]]]
                                                tparam['K_POINTS']=['automatic',line]
                                        #else:
                                        #number of kpoints
                                        #x y z weight
                                        #passed as whole string for now
                                        else:
                                                nk = data.pop(0).strip().split()
                                                kpoints = []
                                                for i in range(nk):
                                                        #kpoints.append(data.pop(0).strip().split())
                                                        kpoints.append(data.pop(0))
                                                taparam['K_POINTS']=[header[1],nk,kpoints]

                                #TODO: care for different formats
                                elif header[0] == 'CELL_PARAMETERS':
                                        vec=[[0,0,0],[0,0,0],[0,0,0]]
                                        for i in range(3):
                                                line = data.pop(0).strip().split()
                                                vec[i]=[float(x)for x in line]
                                        tmol.set_vec(vec)
                                else:
                                        pass

                #Create Molecule after getting the cell parameters
                #set celldm from input
                tmol.set_celldm(tparam['&system']['celldm(1)'])
                #create atoms:
                for i in range(len(tcoord)):
                        tmol.create_atom(tcoord[i][0],float(tcoord[i][1]),float(tcoord[i][2]),float(tcoord[i][3]),fmt)
                #delete nat and ntype before returning to controller
                del tparam['&system']['nat']
                del tparam['&system']['ntyp']

                #Append to controller
                self.mol.append([tmol])
                self.pwdata.append(tparam)

        #TODO: 2nd routine that only reads final config?
        def parsePwo(self,data):
                #Multiple configs supported
                tlist = []
                #no parameters for now
                #tparam=PWParam()
                #read list of molecules:
                i=0
                vec=[[0,0,0],[0,0,0],[0,0,0]]
                while i<len(data):
                        line = data[i].split()
                        #ignore empty lines
                        if not line:
                                pass
                        #read number of atoms
                        elif line[0:3] == ['number', 'of', 'atoms/cell']:
                                nat = int(line[4])
                        #TODO: tweak to recognize celldm(n), save if !0 in param
                        #read cell dimension
                        elif line[0] == 'celldm(1)=':
                                celldm = float(line[1])
                        #TODO: care for different formats
                        #read initial cell vectors
                        elif line[0:2] == ['crystal','axes:']:
                                for j in range(3):
                                        temp = data[i+1+j].split()
                                        vec[j]=[float(x) for x in temp[3:6]]
                        # read initial positions:
                        elif line[0] == 'site':
                                tmol = Molecule()
                                tmol.set_celldm(celldm)
                                tmol.set_vec(vec)
                                for j in range(i+1,i+nat+1):
                                        atom = data[j].split()
                                        tmol.create_atom(atom[1],float(atom[6]),float(atom[7]),float(atom[8]),'alat')
                                i+=nat
                                tlist.append(tmol)
                        #read step-vectors if cell is variable
                        elif line[0] == 'CELL_PARAMETERS':
                                for j in range(3):
                                        temp = data[i+1+j].split()
                                        vec[j]=[float(x) for x in temp[0:3]]
                        #read step-coordinates
                        elif line[0] == 'ATOMIC_POSITIONS':
                                tmol = Molecule()
                                tmol.set_celldm(celldm)
                                tmol.set_vec(vec)
                                for j in range(i+1,i+nat+1):
                                        atom = data[j].split()
                                        tmol.create_atom(atom[0],float(atom[1]),float(atom[2]),float(atom[3]),line[1].strip(')').strip('('))
                                i+=nat
                                tlist.append(tmol)
                        #break on reaching final coordinates (duplicate)
                        elif line[0] == 'Begin':
                                break
                        #ignore everything else
                        else:
                                pass
                        i+=1
                self.mol.append(tlist)


#############################################################################
# WRITE FUNCTIONS
#############################################################################

        def writeFile(self,ftype,mol,filename,param="",coordfmt=""):
                self.outdict[ftype](mol,filename,param,coordfmt)

        def writeXyz(self,mol,filename,param,coordfmt):
                if filename == "":
                        f=sys.stdout
                else:
                        f=open(filename,'w')
                # fixed format nat and comment
                f.write(str(mol.get_nat())+'\n')
                f.write(mol.get_comment()+'\n')
                # write coordinates
                for cntat in range(0,mol.get_nat()):
                        atom=mol.get_atom(cntat,'angstrom')
                        f.write('{:4s} {:15.10f} {:15.10f} {:15.10f}'.format(
                                     atom[0],atom[1][0],atom[1][1],atom[1][2])+'\n')
                f.close()

        def writePwi(self,mol,filename,param,coordfmt):
                if filename == "":
                        f=sys.stdout
                else:
                        f=open(filename,'w')

                #&control, &system and &electron namelists are mandatory
                for i in ['&control','&system','&electrons']:
                        f.write(i+'\n')
                        #write all parameters
                        if i == '&system':
                                f.write(' nat='+str(mol.get_nat())+'\n')
                                f.write(' ntyp='+str(mol.get_ntyp())+'\n')
                        for j in range(len(param[i])):
                                f.write(' '+param[i].keys()[j]+'='+param[i].values()[j]+'\n')
                        f.write('/\n\n')
                #&ions only when needed
                if param['&control']['calculation'] in ["'relax'","'vc-relax'","'md'","'vc-md'"]:
                        f.write('&ions'+'\n')
                        for j in range(len(param['&ions'])):
                                f.write(' '+param['&ions'].keys()[j]+'='+param['&ions'].values()[j]+'\n')
                        f.write('/\n\n')
                #&cell only when needed
                if param['&control']['calculation'] in ["'vc-relax'","'vc-md'"]:
                        f.write('&cell'+'\n')
                        for j in range(len(param['&cell'])):
                                f.write(' '+param['&cell'].keys()[j]+'='+param['&cell'].values()[j]+'\n')
                        f.write('/\n\n')

                #ATOMIC_SPECIES card:
                f.write('ATOMIC_SPECIES'+'\n')
                types = list(mol.get_types())
                for i in range(len(mol.get_types())):
                        atom = types[i]
                        f.write(atom+'    '+str(param['pse'][atom][1])+'   '+str(param['pse'][atom][2])+'\n')
                f.write('\n')

                #ATOMIC_POSITIONS
                f.write('ATOMIC_POSITIONS'+' '+coordfmt+'\n')
                for i in range(mol.get_nat()):
                        atom=mol.get_atom(i)
                        f.write('{:4s} {:15.10f} {:15.10f} {:15.10f}'.format(
                            atom[0],atom[1][0],atom[1][1],atom[1][2])+'\n')
                f.write('\n')

                #K_POINTS
                f.write('K_POINTS'+' '+param['K_POINTS'][0]+'\n')
                #Gamma point only
                if param['K_POINTS'][0] == 'gamma':
                        pass
                #MPGrid:
                #x y z offset
                #passed as whole string for now
                elif param['K_POINTS'][0] == 'automatic':
                        #f.write('{:4i}{:4i}{:4i}{:4i}{:4i}{:4i}'.format(
                        #        param['K_POINTS'][1][0][0],
                        #        param['K_POINTS'][1][0][1],
                        #        param['K_POINTS'][1][0][2],
                        #        param['K_POINTS'][1][0][0],
                        #        param['K_POINTS'][1][1][1],
                        #        param['K_POINTS'][1][1][2]
                        #        )+'\n\n')
                        f.write(param['K_POINTS'][1])
                #number of kpoints
                #x y z weight
                #passed as whole string for now
                #UNTESTED, beware!
                else:
                        f.write(param['K_POINTS'][1])
                        for i in range(param['K_POINTS'][1]):
                                f.write(param['K_POINTS'][2][i])
                f.write('\n')

                #Cell parameters
                f.write('CELL_PARAMETERS'+'\n')
                vec = mol.get_vec()
                fmt='{0[0][0]:15.10f} {0[0][1]:15.10f} {0[0][2]:15.10f}\n' + \
                    '{0[1][0]:15.10f} {0[1][1]:15.10f} {0[1][2]:15.10f}\n' + \
                    '{0[2][0]:15.10f} {0[2][1]:15.10f} {0[2][2]:15.10f}\n'
                f.write(fmt.format(mol.get_vec()))

                #Close file
                f.close()