예제 #1
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self.pw = PWTask(filename)
     self.ph = PHTask(filename)
     self.dynmat = DynmatTask(filename)
     self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = self.pw.input.outDir())
     self.taskList = [self.pwph, self.dynmat]
예제 #2
0
    def __init__(self,
                 filename=None,
                 configString=None,
                 sectionList=None,
                 taskList=None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [['pw', PWTask], ['ph', PHTask], ['q2r', Q2RTask],
                          ['matdyn', MatdynTask]]
        # Merging map sets tasks to be merged. Last two columns identify name
        # of default task (its input and output objects will be directly
        #accessible) and last column is the name of merged task object (e.g.'pwph')

        #is not implemented yet !!!!
        self._mergingMap = [
            ['pw', 'ph', 'pw', 'pwph'],
        ]

        self._populateTasks(filename, configString, sectionList, taskList)

        self.pwph = PWPHMerger(self.pw, self.ph, cleanOutDir=True)
        self.taskList = [self.pwph, self.q2r, self.matdyn]

        self._dispersion = PHDispersion(self.pw.input.structure.lattice,
                                        self.matdyn)

        self.dos = PhononDOS(self.matdyn)
예제 #3
0
    def __init__(self, filename = None, configString = None, sectionList = None, taskList = None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [
                          ['pw', PWTask],
                          ['ph', PHTask],
                          ['q2r', Q2RTask],
                          ['matdyn', MatdynTask]
                         ]
        # Merging map sets tasks to be merged. Last two columns identify name
        # of default task (its input and output objects will be directly
        #accessible) and last column is the name of merged task object (e.g.'pwph')

        #is not implemented yet !!!!
        self._mergingMap = [ ['pw', 'ph', 'pw','pwph'],
                           ]

        self._populateTasks(filename, configString, sectionList, taskList)


        self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = True)
        self.taskList = [self.pwph, self.q2r, self.matdyn]

        self._dispersion = PHDispersion(self.pw.input.structure.lattice, self.matdyn)

        self.dos = PhononDOS(self.matdyn)
예제 #4
0
    def __init__(self,
                 filename=None,
                 configString=None,
                 sectionList=None,
                 taskList=None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [['pw', PWTask], ['ph', PHTask], ['d3', D3Task]]

        self._populateTasks(filename, configString, sectionList, taskList)
        #self.pw = PWTask(filename)
        #self.ph = PHTask(filename)
        #self.d3 = D3Task(filename)
        self.pwph = PWPHMerger(self.pw,
                               self.ph,
                               cleanOutDir=self.pw.input.outDir())
        self.taskList = [self.pwph, self.d3]

        #Hack: make sure d3 task is serial (d3 does not seem to work in parallel)
        for task in [self.pw, self.ph, self.d3]:
            #task.setting.useTorque = 'False'
            task.setSerial()
            task.setting.serialPrefix = ''
예제 #5
0
    def __init__(self, fname=None, taskName = 'total energy', tolerance = 1, nMaxSteps = 10):
        """taskName - currently can be 'total energy', 'single phonon',
           or 'geometry'
           tolerance -  task convergence criteria in percents
           nMaxSteps =  maximum number of optimization steps for
           the optimization routines"""

        # Default values, see explanations below:
#        convergerDic = {
#        'taskName': 'total energy',
#        'tolerance': '1',
#        'nMaxSteps': '10'
#        }
        QECalc.__init__(self,fname)
        # value to converge with respect to k-points or energy cutoffs
        # currently can be 'total energy', 'single phonon', or 'geometry':
#        self.taskName = self.config.get('Converger', 'taskName')

        # convergence criteria in percents:
#        self.tolerance = self.config.getfloat('Converger','tolerance')

        # maximum number of optimization steps:
#        self.nMaxSteps = self.config.getint('Converger','nMaxSteps')

        self.taskName = taskName
        self.tolerance = tolerance
        self.nMaxSteps = nMaxSteps
        
        self.lookupTable = {
        'total energy' : (self.pwscfLauncher, self.getTotalEnergy),
        'single phonon': (self.singlePhononLauncher, self.getSinglePhonon),
        'geometry'     : (self.pwscfLauncher, self.getLatticeParameters)
#        'multiple phonon': (self.multiPhononLauncher, self.getMultiPhonon)
        }
        assert self.lookupTable.has_key(self.taskName), "Convergence \
예제 #6
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self.pw = PWTask(filename)
     self.ph = PHTask(filename)
     self.dynmat = DynmatTask(filename)
     self.pwph = PWPHMerger(self.pw,
                            self.ph,
                            cleanOutDir=self.pw.input.outDir())
     self.taskList = [self.pwph, self.dynmat]
예제 #7
0
    def __init__(self, filename = None, configString = None, sectionList = None, taskList = None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [
                          ['pw', PWTask]
                         ]

        self._populateTasks(filename, configString, sectionList, taskList)
예제 #8
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self._freqs = None
     self._modes = None
     self._qpts = None
     self.pw = PWTask(filename)
     self.ph = PHTask(filename)
     self.q2r = Q2RTask(filename)
     self.matdyn = MatdynTask(filename)
     self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = self.pw.input.outDir())
     self.dispersion = PHDispersion(self.pw.input.structure, self.matdyn)
     self.taskList = [self.pwph, self.q2r, self.matdyn]
예제 #9
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self._freqs = None
     self._modes = None
     self._qpts = None
     self.pw = PWTask(filename)
     self.ph = PHTask(filename)
     self.q2r = Q2RTask(filename)
     self.matdyn = MatdynTask(filename)
     self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = self.pw.input.outDir())
     self.dispersion = PHDispersion(self.pw.input.structure.lattice, self.matdyn)
     self.dos = PhononDOS(self.matdyn)
     self.taskList = [self.pwph, self.q2r, self.matdyn]
예제 #10
0
    def __init__(self, filename):
        QECalc.__init__(self)
        self.pw = PWTask(filename)
        self.ph = PHTask(filename)
        self.d3 = D3Task(filename)
        self.pwph = PWPHMerger(self.pw,
                               self.ph,
                               cleanOutDir=self.pw.input.outDir())
        self.taskList = [self.pwph, self.d3]

        #Hack: make sure d3 task is serial (d3 does not seem to work in parallel)
        for task in [self.pw, self.ph, self.d3]:
            task.setting.useTorque = 'False'
            task.setting.paraPrefix = ''
            task.setting.paraPostfix = ''
예제 #11
0
    def __init__(self, filename = None , configString = None, sectionList = None, taskList = None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [
                          ['pw', PWTask],
                          ['ph', PHTask],
                          ['dynmat', DynmatTask]
                         ]

        self._populateTasks(filename, configString, sectionList, taskList)

        #self.pw = PWTask(filename)
        #self.ph = PHTask(filename)
        #self.dynmat = DynmatTask(filename)
        self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = True)
        self.taskList = [self.pwph, self.dynmat]
예제 #12
0
    def __init__(self,
                 filename=None,
                 configString=None,
                 sectionList=None,
                 taskList=None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [['pw', PWTask], ['ph', PHTask],
                          ['dynmat', DynmatTask]]

        self._populateTasks(filename, configString, sectionList, taskList)

        #self.pw = PWTask(filename)
        #self.ph = PHTask(filename)
        #self.dynmat = DynmatTask(filename)
        self.pwph = PWPHMerger(self.pw, self.ph, cleanOutDir=True)
        self.taskList = [self.pwph, self.dynmat]
예제 #13
0
    def __init__(self,
                 fname=None,
                 taskName='total energy',
                 tolerance=1,
                 nMaxSteps=10):
        """taskName - currently can be 'total energy', 'single phonon',
           or 'geometry'
           tolerance -  task convergence criteria in percents
           nMaxSteps =  maximum number of optimization steps for
           the optimization routines"""

        # Default values, see explanations below:
        #        convergerDic = {
        #        'taskName': 'total energy',
        #        'tolerance': '1',
        #        'nMaxSteps': '10'
        #        }
        QECalc.__init__(self, fname)
        # value to converge with respect to k-points or energy cutoffs
        # currently can be 'total energy', 'single phonon', or 'geometry':
        #        self.taskName = self.config.get('Converger', 'taskName')

        # convergence criteria in percents:
        #        self.tolerance = self.config.getfloat('Converger','tolerance')

        # maximum number of optimization steps:
        #        self.nMaxSteps = self.config.getint('Converger','nMaxSteps')

        self.taskName = taskName
        self.tolerance = tolerance
        self.nMaxSteps = nMaxSteps

        self.lookupTable = {
            'total energy': (self.pwscfLauncher, self.getTotalEnergy),
            'single phonon': (self.singlePhononLauncher, self.getSinglePhonon),
            'geometry': (self.pwscfLauncher, self.getLatticeParameters)
            #        'multiple phonon': (self.multiPhononLauncher, self.getMultiPhonon)
        }
        assert self.lookupTable.has_key(self.taskName), "Convergence \
예제 #14
0
    def __init__(self, filename = None, configString = None, sectionList = None, taskList = None):
        QECalc.__init__(self)

        # tasks definition:
        # specify taskName/taskConstructur pairs
        self._taskSpec = [
                          ['pw', PWTask],
                          ['ph', PHTask],
                          ['d3', D3Task]
                         ]

        self._populateTasks(filename, configString, sectionList, taskList)
        #self.pw = PWTask(filename)
        #self.ph = PHTask(filename)
        #self.d3 = D3Task(filename)
        self.pwph = PWPHMerger(self.pw,self.ph, cleanOutDir = True)
        self.taskList = [self.pwph, self.d3]

        #Hack: make sure d3 task is serial (d3 does not seem to work in parallel)
        for task in [self.pw, self.ph, self.d3]:
            #task.setting.useTorque = 'False'
            task.setSerial()
예제 #15
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self.pw = PWTask(filename)
     self.taskList = [self.pw]
예제 #16
0
 def __init__(self, filename):
     QECalc.__init__(self)
     self.pw = PWTask(filename)
     self.taskList = [self.pw]
예제 #17
0
 def __init__(self, fname):
     QECalc.__init__(self, fname)
예제 #18
0
 def __init__(self, fname):
     QECalc.__init__(self, fname)
     self.__freqs = None
     self.__modes = None
     self.__qpts = None
예제 #19
0
 def __init__(self, fname):
     QECalc.__init__(self,fname)
예제 #20
0
 def __init__(self, fname):
     QECalc.__init__(self, fname)
     self.__freqs = None
     self.__modes = None
     self.__qpts = None