mlatom 2.0.4__tar.gz → 2.1.0__tar.gz

{MLatom-2.0.4 → MLatom-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MLatom
-Version: 2.0.4
+Version: 2.1.0
 Summary: A Package for Atomistic Simulations with Machine Learning
 Home-page: http://mlatom.com
 Author: Pavlo O. Dral
@@ -122,7 +122,7 @@ MLatom also provides interfaces to some third-party software where extra ML mode
 
 # About Program
 MLatom: a Package for Atomistic Simulations with Machine Learning    
-Version 2.0.3
+Version 2.1.0
 http://mlatom.com/                             
                                                                            
 Copyright (c) 2013-2021 Pavlo O. Dral                   
@@ -136,7 +136,7 @@ Cite as:
 
 1. Pavlo O. Dral, J. Comput. Chem. 2019, 40, 2339-2347             
 2. Pavlo O. Dral, Fuchun Ge, Bao-Xin Xue, Yi-Fan Hou, Max Pinheiro Jr, Jianxing Huang, Mario Barbatti, Top. Curr. Chem. 2021, 379, 27              
-3. Pavlo O. Dral, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou, Max Pinheiro Jr, MLatom: A Package for Atomistic Simulations with Machine Learning, version 2.0.3, Xiamen University, Xiamen, China, 2013-2021.               
+3. Pavlo O. Dral, Peikun Zheng, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou, Max Pinheiro Jr, MLatom: A Package for Atomistic Simulations with Machine Learning, version 2.1.0, Xiamen University, Xiamen, China, 2013-2021.               
 
 
 # License

{MLatom-2.0.4 → MLatom-2.1.0}/README.md

@@ -104,7 +104,7 @@ MLatom also provides interfaces to some third-party software where extra ML mode
 
 # About Program
 MLatom: a Package for Atomistic Simulations with Machine Learning    
-Version 2.0.3
+Version 2.1.0
 http://mlatom.com/                             
                                                                            
 Copyright (c) 2013-2021 Pavlo O. Dral                   
@@ -118,7 +118,7 @@ Cite as:
 
 1. Pavlo O. Dral, J. Comput. Chem. 2019, 40, 2339-2347             
 2. Pavlo O. Dral, Fuchun Ge, Bao-Xin Xue, Yi-Fan Hou, Max Pinheiro Jr, Jianxing Huang, Mario Barbatti, Top. Curr. Chem. 2021, 379, 27              
-3. Pavlo O. Dral, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou, Max Pinheiro Jr, MLatom: A Package for Atomistic Simulations with Machine Learning, version 2.0.3, Xiamen University, Xiamen, China, 2013-2021.               
+3. Pavlo O. Dral, Peikun Zheng, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou, Max Pinheiro Jr, MLatom: A Package for Atomistic Simulations with Machine Learning, version 2.1.0, Xiamen University, Xiamen, China, 2013-2021.               
 
 
 # License

{MLatom-2.0.4 → MLatom-2.1.0}/setup.py

@@ -43,7 +43,7 @@ with open(os.path.join(here, 'README.md')) as f:
 
 setup(
     name = pkg_name,
-    version = "2.0.4",
+    version = "2.1.0",
     author = "Pavlo O. Dral",
     author_email = "admin@mlatom.com",
     license = 'CC BY-NC-ND 4.0',  # https://creativecommons.org/licenses/by-nc-nd/4.0/

MLatom-2.1.0/src/MLatom/AIQM1.py

@@ -0,0 +1,463 @@
+#!/usr/bin/env python3
+'''
+  !---------------------------------------------------------------------------! 
+  ! AIQM1: Artificial intelligence quantum-mechanical method 1                ! 
+  ! Implementations by: Peikung Zheng                                         ! 
+  !---------------------------------------------------------------------------! 
+'''
+import numpy as np
+import os
+import sys
+from collections import Counter
+import stopper
+import json
+import struct
+import re
+#import time
+import warnings
+warnings.filterwarnings("ignore")
+
+mlatomdir=os.path.dirname(__file__)
+bohr2a = 0.52917721067
+
+class AIQM1Cls(object):
+    def __init__(self, argsAIQM1 = sys.argv[1:]):
+        
+        args.parse(argsAIQM1)
+        self.mndobin = args.mndobin
+        self.dftd4bin = args.dftd4bin
+
+        self.xyzfile = args.xyzfile
+        self.device = args.device
+        self.level = args.level
+        self.d4 = args.d4
+        self.model_index = args.model_index
+        self.mndokw = args.mndokw
+        self.yestfile = args.yestfile
+        self.ygradestfile = args.ygradxyzestfile
+        self.hessianestfile = args.hessianestfile
+        self.hesscalc = args.hesscalc
+        self.species_order =  [1, 6, 7, 8]
+        self.dftsae = [-4.27888067e-02, -3.34869833e+01, -4.69896148e+01, -6.30294433e+01]
+        self.ccsae = [-4.29365862e-02, -3.34329586e+01, -4.69301173e+01, -6.29634763e+01]
+    
+    def define_aev(self):
+        Rcr = 5.2000e+00
+        Rca = 4.0000e+00
+        EtaR = torch.tensor([1.6000000e+01], device=self.device)
+        ShfR = torch.tensor([9.0000000e-01, 1.1687500e+00, 1.4375000e+00, 1.7062500e+00, 1.9750000e+00, 2.2437500e+00, 2.5125000e+00, 2.7812500e+00, 3.0500000e+00, 3.3187500e+00, 3.5875000e+00, 3.8562500e+00, 4.1250000e+00, 4.3937500e+00, 4.6625000e+00, 4.9312500e+00], device=self.device)
+        Zeta = torch.tensor([3.2000000e+01], device=self.device)
+        ShfZ = torch.tensor([1.9634954e-01, 5.8904862e-01, 9.8174770e-01, 1.3744468e+00, 1.7671459e+00, 2.1598449e+00, 2.5525440e+00, 2.9452431e+00], device=self.device)
+        EtaA = torch.tensor([8.0000000e+00], device=self.device)
+        ShfA = torch.tensor([9.0000000e-01, 1.6750000e+00,  2.4499998e+00, 3.2250000e+00], device=self.device)
+        num_species = len(self.species_order)
+        aev_computer = torchani.AEVComputer(Rcr, Rca, EtaR, ShfR, EtaA, Zeta, ShfA, ShfZ, num_species)
+        self.aev_computer = aev_computer
+
+    def define_nn(self):
+        aev_dim = self.aev_computer.aev_length
+        H_network = torch.nn.Sequential(
+            torch.nn.Linear(aev_dim, 160),
+            torch.nn.GELU(),
+            torch.nn.Linear(160, 128),
+            torch.nn.GELU(),
+            torch.nn.Linear(128, 96),
+            torch.nn.GELU(),
+            torch.nn.Linear(96, 1)
+        )
+        
+        C_network = torch.nn.Sequential(
+            torch.nn.Linear(aev_dim, 144),
+            torch.nn.GELU(),
+            torch.nn.Linear(144, 112),
+            torch.nn.GELU(),
+            torch.nn.Linear(112, 96),
+            torch.nn.GELU(),
+            torch.nn.Linear(96, 1)
+        )
+        
+        N_network = torch.nn.Sequential(
+            torch.nn.Linear(aev_dim, 128),
+            torch.nn.GELU(),
+            torch.nn.Linear(128, 112),
+            torch.nn.GELU(),
+            torch.nn.Linear(112, 96),
+            torch.nn.GELU(),
+            torch.nn.Linear(96, 1)
+        )
+        
+        O_network = torch.nn.Sequential(
+            torch.nn.Linear(aev_dim, 128),
+            torch.nn.GELU(),
+            torch.nn.Linear(128, 112),
+            torch.nn.GELU(),
+            torch.nn.Linear(112, 96),
+            torch.nn.GELU(),
+            torch.nn.Linear(96, 1)
+        )
+        
+        nn = torchani.ANIModel([H_network, C_network, N_network, O_network])
+        #print(nn)
+        self.nn = nn
+
+    def load_models(self):
+        dirname = os.path.join(mlatomdir, 'aiqm1_model')
+        method = 'aiqm1_' + self.level
+        models = list()
+        if self.model_index is None:
+            for i in range(8):
+                self.define_nn()
+                checkpoint = torch.load(os.path.join(dirname, f'{method}_cv{i}.pt'), map_location=self.device)
+                self.nn.load_state_dict(checkpoint['nn'])
+                model = torchani.nn.Sequential(self.aev_computer, self.nn).to(self.device).double()
+                models.append(model)
+        else:
+            self.define_nn()
+            checkpoint = torch.load(os.path.join(dirname, f'{method}_cv{self.model_index}.pt'), map_location=self.device)
+            self.nn.load_state_dict(checkpoint['nn'])
+            model = torchani.nn.Sequential(self.aev_computer, self.nn).to(self.device).double()
+            models.append(model)
+        self.models = models
+
+    def predict(self, device, d4, sae, optmol):
+        
+        numbers, coordinates = get_xyz(self.xyzfile)
+        charges, mults, odm2_energies, odm2_grads, odm2_hesses = run_odm2_calculation(self.mndobin, numbers, coordinates, self.hesscalc, self.mndokw, optmol)
+        shifts = cal_shifts(numbers, sae)
+        if d4:
+            d4_energies, d4_grads, d4_hesses = run_d4_calculation(self.dftd4bin, self.xyzfile, numbers, coordinates, charges, self.hesscalc)
+        species_to_tensor = ChemicalSymbolsToInts(self.species_order)
+        
+        fenergy = open(args.yestfile, 'w')
+        fgrad = open(args.ygradxyzestfile, 'w')
+        if self.hesscalc:
+            fhess = open(args.hessianestfile, 'w')
+
+        for i in range(len(numbers)):
+            nat = len(numbers[i])
+            coordinate =  torch.tensor(coordinates[i]).to(device).requires_grad_(True)
+            shift = torch.tensor(shifts[i]).to(device)
+            odm2_energy = torch.tensor(odm2_energies[i]).to(device)
+            odm2_grad = torch.tensor(odm2_grads[i]).to(device)
+            coordinate = coordinate.unsqueeze(0)
+            species = species_to_tensor(numbers[i]).to(device).unsqueeze(0)
+            delta_energies = []; delta_grads = []; delta_hesses = []
+            for mod in self.models:
+                delta_energy = mod((species, coordinate)).energies
+                delta_grad = torch.autograd.grad(delta_energy.sum(), coordinate, create_graph=True, retain_graph=True)[0]
+                delta_energies.append(delta_energy)
+                delta_grads.append(delta_grad)
+                if self.hesscalc:
+                    delta_hess = torchani.utils.hessian(coordinate, energies=delta_energy)
+                    delta_hesses.append(delta_hess)
+                    
+            delta_energy = torch.stack([e for e in delta_energies], dim=0).mean(0)
+            delta_grad = torch.stack([g for g in delta_grads], dim=0).mean(0)
+            energy = delta_energy[0] + odm2_energy + shift
+            grad = delta_grad[0] + odm2_grad
+            if self.hesscalc:
+                odm2_hess = torch.tensor(odm2_hesses[i]).to(device)
+                delta_hess = torch.stack([h for h in delta_hesses], dim=0).mean(0)
+                hess = delta_hess + odm2_hess
+            if d4:
+                d4_energy = torch.tensor(d4_energies[i]).to(device)
+                d4_grad = torch.tensor(d4_grads[i]).to(device)
+                energy = energy + d4_energy
+                grad = grad + d4_grad
+                if self.hesscalc:
+                    d4_hess = torch.tensor(d4_hesses[i]).to(device)
+                    hess = hess + d4_hess
+            fenergy.write('%20.12f\n' % energy)
+            fgrad.write('%d\n\n' % nat)
+            for j in range(nat):
+                fgrad.write('%20.12f %20.12f %20.12f\n' % (grad[j][0], grad[j][1], grad[j][2]))
+            if self.hesscalc:
+                hess = hess.flatten()
+                fhess.write('%d\n\n' % nat)
+                for j in range(len(hess)):
+                    fhess.write('%20.12f\n' % hess[j])
+        fenergy.close()
+        fgrad.close()
+        if self.hesscalc:
+            fhess.close()
+        return charges, mults
+
+    def forward(self, optmol=None):
+        # optmol is used for geomopt
+        if self.level == 'dft':
+            sae = self.dftsae
+        elif self.level == 'cc':
+            sae = self.ccsae
+        self.define_aev()
+        self.load_models()
+        charges, mults = self.predict(self.device, self.d4, sae, optmol)
+        return charges, mults
+
+class args(object):
+
+    @classmethod
+    def check_prog(cls):
+        # MNDO
+        status = os.popen('echo $mndobin').read().strip()
+        if len(status) != 0:
+            mndobin = status
+        else:
+            stopper.stopMLatom('Can not find MNDO software, please set the environment variable: export mndobin=...')
+        # dftd4
+        dftd4bin = None
+        if cls.d4:
+            status = os.popen('echo $dftd4bin').read().strip()
+            if len(status) != 0:
+                dftd4bin = status
+            else:
+                stopper.stopMLatom('Can not find dftd4 software, please set the environment variable: export dftd4bin=...')
+        # TorchANI
+        try: 
+            import torch
+            import torchani
+            from torchani.utils import ChemicalSymbolsToInts
+        except: 
+            stopper.stopMLatom('Please install all Python module required for TorchANI')
+        globals()['torch'] = torch
+        globals()['torchani'] = torchani
+        globals()['ChemicalSymbolsToInts'] = ChemicalSymbolsToInts
+        
+        cls.mndobin  = mndobin
+        cls.dftd4bin = dftd4bin
+
+    @classmethod
+    def parse(cls, argsraw):
+        # Default values:
+        cls.xyzfile = None
+        cls.level = 'cc'
+        cls.d4 = False
+        cls.model_index = None
+        cls.mndokw = None
+        cls.yestfile = 'enest.dat'
+        cls.ygradxyzestfile = 'gradest.dat'
+        cls.hessianestfile = None
+        cls.hesscalc = False
+        
+        argslower = [arg.lower() for arg in argsraw]
+        if 'xyzfile' not in ''.join(argslower):
+            printHelp()
+            stopper.stopMLatom('At least xyzfile should be provided')
+        for arg in argsraw:
+            if  (arg.lower() == 'help'
+              or arg.lower() == '-help'
+              or arg.lower() == '-h'
+              or arg.lower() == '--help'):
+                printHelp()
+                stopper.stopMLatom('')
+            elif arg.lower()[0:len('aiqm1dftstar')]      == 'aiqm1dftstar':  
+                cls.level = 'dft'
+            elif arg.lower()[0:len('aiqm1dft')]          == 'aiqm1dft':
+                cls.level = 'dft'
+                cls.d4 = True
+            elif arg.lower()[0:len('aiqm1')]             == 'aiqm1':
+                cls.level = 'cc'
+                cls.d4 = True
+            elif arg.lower()[0:len('xyzfile=')]          == 'xyzfile=':  
+                cls.xyzfile = arg[len('xyzfile='):]
+            #elif arg.lower()[0:len('gpu=')]              == 'gpu=':
+            #    os.environ["CUDA_VISIBLE_DEVICES"] = arg[len('gpu='):]
+            #    cls.device = torch.device('cuda')
+            elif arg.lower()[0:len('model_index=')]      == 'model_index=':
+                cls.model_index = int(arg[len('model_index='):])
+            elif arg.lower()[0:len('mndokeywords=')]     == 'mndokeywords=':
+                cls.mndokw = arg[len('mndokeywords='):]
+            elif arg.lower()[0:len('yestfile=')]         == 'yestfile=':
+                cls.yestfile = arg[len('yestfile='):]
+            elif arg.lower()[0:len('ygradxyzestfile=')]  == 'ygradxyzestfile=':
+                cls.ygradxyzestfile = arg[len('ygradxyzestfile='):]
+            elif arg.lower()[0:len('hessianestfile=')]   == 'hessianestfile=':
+                cls.hessianestfile = arg[len('hessianestfile='):]
+                cls.hesscalc = True
+            #else:
+            #    printHelp()
+            #    stopper.stopMLatom('Option "%s" is not recognized' % arg)
+        cls.check_prog()
+        cls.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def get_xyz(xyzfile):
+    element2number = {'H':1, 'C':6, 'N':7, 'O':8}
+    coordinates = []; numbers = []
+    with open(xyzfile, 'r') as f:
+        lines = f.readlines()
+        for i in range(len(lines)):
+            if lines[i].strip().isdigit():
+                element = []; coordinate = []
+                nat = int(lines[i])
+                for j in range(i+2, i+2+nat):
+                    element.append(lines[j].strip().split()[0])
+                    coordinate.append(lines[j].strip().split()[1:])
+                if element[0].isdigit():
+                    number = element
+                else:    
+                    number = np.array([element2number[i.upper()] for i in element])
+                number = np.array(number).astype('int')
+                coordinate = np.array(coordinate).astype('float')
+                numbers.append(number)
+                coordinates.append(coordinate)
+    return numbers, coordinates
+
+def run_odm2_calculation(mndobin, numbers, coordinates, hesscalc, mndokw, optmol):
+    charges = np.full(len(numbers), 0)
+    mults = np.full(len(numbers), 1)
+    energies = []; grads = []; hesses = []
+    if mndokw: 
+        mndokeywords, charges, mults = read_mndokw(mndokw, optmol)
+        if len(mndokeywords) != len(numbers):
+            stopper.stopMLatom('Inconsistency of the nubmer of keywords and molecules')
+    for i in range(len(numbers)):
+        with open('mndo.inp', 'w') as f:
+            if mndokw:
+                f.write(mndokeywords[i] + '\n\n\n')
+            else:
+                if hesscalc:
+                    f.write('jop=2 +\n')
+                else:
+                    f.write('jop=-2 +\n')
+                f.write('iop=-22 igeom=1 iform=1 immdp=-1 nsav15=3 +\n')
+                f.write('icuts=-1 icutg=-1 kitscf=9999 iscf=9 iplscf=9 +\n')
+                f.write('iprint=-1 kprint=-5 lprint=-2 mprint=0 jprint=-1 +\n')
+                f.write('kharge=0 imult=0 nprint=-1\n\n\n')
+            number = numbers[i]
+            coordinate = coordinates[i]
+            for j in range(len(number)):
+                f.write('%2s' % (number[j]) + ' '*5)
+                f.write('%12.8f %3d' % (coordinate[j][0], 1))
+                f.write(' '*5)
+                f.write('%12.8f %3d' % (coordinate[j][1], 1))
+                f.write(' '*5)
+                f.write('%12.8f %3d' % (coordinate[j][2], 1))
+                f.write('\n')
+            f.write('\n')
+        os.system(mndobin + " < mndo.inp > mndo.out")
+        energy, grad, hess = get_odm2_result(hesscalc)
+        energies.append(energy)
+        grads.append(grad)
+        hesses.append(hess)
+    return charges, mults, energies, grads, hesses
+
+def read_mndokw(mndokw, optmol):
+    with open(mndokw, 'r') as f:
+        mndokeywords = f.read().strip('\n')
+    mndokeywords = mndokeywords.split('\n\n')
+    charges = np.full(len(mndokeywords), 0)
+    mults = np.full(len(mndokeywords), 1)
+    for i in range(len(mndokeywords)):
+        status = re.search('kharge=\d+', mndokeywords[i])
+        if status:
+            charges[i] = int(status.group().split('=')[1])
+        status = re.search('imult=\d+', mndokeywords[i])
+        if status:
+            imult = int(status.group().split('=')[1])
+            if imult == 0:
+                mults[i] = 1
+            else:
+                mults[i] = imult
+    if optmol is not None:
+        mndokeywords = [mndokeywords[optmol]]
+        charges = [charges[optmol]]
+        mults = [mults[optmol]]
+
+    return mndokeywords, charges, mults
+
+def get_odm2_result(hesscalc):
+    hess = None
+    with open('fort.15', 'r') as f:
+        lines = f.readlines()
+        for i in range(len(lines)):
+            if 'NUMAT' in lines[i]:
+                nat = int(lines[i].strip().split()[-1])
+            if 'ENERGY' in lines[i]:
+                energy = lines[i+1].strip().split()[0]
+                energy = float(energy) / (27.21 * 23.061)
+            if 'CARTESIAN GRADIENT' in lines[i]:
+                grad = []
+                for j in range(nat):
+                    grad.append(lines[i+j+1].strip().split()[-3:])
+                grad = np.array(grad).astype('float') / (27.21 * 23.061)
+            if hesscalc:
+                lhess = nat * nat * 9
+                fhess = open('fort.4', 'rb')
+                data = fhess.read()
+                dt = f'id{lhess}d'
+                dat_size = struct.calcsize(dt)
+                temp = struct.unpack(dt, data[:dat_size])
+                hess = np.array(temp[2:]).reshape(-1, nat*3) / (0.529167 * 0.529167)
+
+    return energy, grad, hess
+
+def cal_shifts(numbers, sae):
+    shifts = []
+    for i in range(len(numbers)):
+        count = Counter(numbers[i])
+        ncount = [count[1], count[6], count[7], count[8]]
+        shift = np.dot(ncount, sae)
+        shifts.append(shift)
+    return shifts
+
+def run_d4_calculation(dftd4bin, xyzfile, numbers, coordinates, charges, hesscalc):
+    number2element = {1:'H', 6:'C', 7:'N', 8:'O'}
+    shifts = []
+    d4_energies = []; d4_grads = []; d4_hesses = []
+    for i in range(len(numbers)):
+        number = numbers[i]
+        coordinate = coordinates[i]
+        charge = charges[i]
+        nat = len(numbers[i])
+        with open('coordinate', 'w') as f:
+            f.write(str(nat) + '\n\n')
+            for j in range(nat):
+                f.write('%s %15.12f %15.12f %15.12f\n' 
+                    % (number2element[number[j]], coordinate[j][0], coordinate[j][1], coordinate[j][2]))
+        if hesscalc:
+            os.system(dftd4bin + " coordinate -s --grad --hess --orca --json -f wb97x -c " + str(charge) + " > /dev/null 2>&1")
+        else:
+            os.system(dftd4bin + " coordinate -s --grad --orca --json -f wb97x -c " + str(charge) + " > /dev/null 2>&1")
+        with open('dftd4.json', 'r') as f:
+            d4_results = json.load(f)
+        #try:
+        #    with open('dftd4.json', 'r') as f:
+        #        d4_results = json.load(f)
+        #except:
+        #    time.sleep(0.5)
+        #    with open('dftd4.json', 'r') as f:
+        #        d4_results = json.load(f)
+        d4_energy = np.array(d4_results['energy'])
+        d4_grad = np.array(d4_results['gradient']) / bohr2a
+        d4_grad = d4_grad.reshape(-1, 3)
+        d4_energies.append(d4_energy)
+        d4_grads.append(d4_grad)
+        if hesscalc:
+            d4_hess = np.array(d4_results['hessian']).reshape(-1, nat*3) / (bohr2a * bohr2a)
+            d4_hesses.append(d4_hess)
+        #os.system('rm -f coordinate dftd4.json')
+    os.system('rm -f coordinate dftd4.json')
+    return d4_energies, d4_grads, d4_hesses
+
+def printHelp():
+    helpText = '''
+  !---------------------------------------------------------------------------! 
+  !                          AIQM1 usage and options                          ! 
+  !---------------------------------------------------------------------------!
+  
+  Usage:
+    MLatom.py AIQM1@DFT* xyzfile=... [options]
+    MLatom.py AIQM1@DFT xyzfile=... [options]
+    MLatom.py AIQM1 xyzfile=... [options]
+    
+  Options:
+      xyzfile=S                file S with xyz coordinates
+      model_index=N            0-7 (by default the ensemble of 8 models are used)
+      YestFile=S               file S with estimated Y values
+      YgradXYZestFile=S        file S with estimated XYZ gradients
+      HessianestFile=S         file S with estimated Hessians
+      mndokeywords=S           read MNDO keyword from file S, separating by a blank line for each molecules
+      (it is required to set iop=-22, jop=-2 or 2, igeom=1, nsav15=3, immdp=-1)
+'''
+    print(helpText)
+
+    

{MLatom-2.0.4 → MLatom-2.1.0}/src/MLatom/ML_NEA.py

@@ -824,19 +824,9 @@ class NewtonXCalc(LinuxInterface):
                  ' nis = 1\n nfs = 2\n kvert = 1\n de = 100\n prog = 6.5\n iseed = 1234\n lvprt = 1\n/\n'
         with open(inp_name, 'w') as f:
             f.write(nx_inp)
-        # err_code, out = self.exec(f'$NX/initcond.pl > NX-MD.log 2>&1')
-        try:
-            err_code, out = self.exec('$NX/mk_qvector < initqp_input ; ' \
-                                      '$NX/weight < initqp_input &> weight.log ; ' \
-                                      '$NX/initqp < initqp_input &> initqp.log ')
-            if err_code != 0 or out != '':
-                err_print(f'Newton-X calculation failed!!!\nstatus code: {err_code} (0 stands for normal exit, none 0 stands for error)\noutput: {out}')
-        except:
-            os.system('$NX/mk_qvector < initqp_input ; ' \
-                      '$NX/weight < initqp_input &> weight.log ; ' \
-                      '$NX/initqp < initqp_input &> initqp.log ')
-            import time
-            time.sleep(0.01)
+        os.system('$NX/mk_qvector < initqp_input')
+        os.system('$NX/weight     < initqp_input > weight.log')
+        os.system('$NX/initqp     < initqp_input > initqp.log')
     
     def restore_multi_xyz(self, atom_num: int):
         with open('ini_qv') as f:
@@ -2356,11 +2346,12 @@ class RecurPaperProcedure(ArgParser, LinuxInterface):
         self.delta_QC = 0.01
         self.delta_SPC = 0.3
         
-    def opt_freq_calc(self):
+    def opt_freq_calc(self, force_calc: bool=False):
         self.cd(self.work_path)
-        if self.exist_path(self.eq_init_xyz_name) and self.exist_path(self.nx_nea_geom_name):
-            self.opt_molecule.read_xyz(self.eq_init_xyz_name) 
-            return
+        if not force_calc:
+            if self.exist_path(self.eq_init_xyz_name) and self.exist_path(self.nx_nea_geom_name):
+                self.opt_molecule.read_xyz(self.eq_init_xyz_name) 
+                return
         if not EnvCheck.check_NX():
             exit()
         self.cd(self.work_path)
@@ -2372,28 +2363,37 @@ class RecurPaperProcedure(ArgParser, LinuxInterface):
             else:  # not exists opt-freq.com, raise error
                 err_print(f'not exists {self.gauss_opt_inp_name} or {self.gauss_opt_log_name}, exit')
                 exit()
+        else:
+            self.cp(self.gauss_opt_log_name, os.path.join(self.gauss.gauss_path, self.gauss_opt_log_name))
         # now exists opt-freq.log, extract opt.xyz & freq
-        self.opt_molecule = self.gauss.extract_xyz(
-            os.path.join(self.gauss.gauss_path, self.gauss_opt_log_name))
-        # self.opt_molecule.print_xyz(self.eq_xyz_name)  # no needed, don't pollute the working directory
+        if not force_calc:
+            self.opt_molecule = self.gauss.extract_xyz(
+                os.path.join(self.gauss.gauss_path, self.gauss_opt_log_name))
+            # self.opt_molecule.print_xyz(self.eq_xyz_name)  # no needed, don't pollute the working directory
 
     def NX_multi_xyz_calc(self):
-        self.cd(self.work_path)
-        if not self.exist_path(self.nx_nea_geom_name): # not exist multiple xyz.dat, need to calc it with NX
+        def NX_gen_ensemble():
+            if not EnvCheck.check_NX():
+                exit()
             self.cd(self.nx.NX_path)
             self.opt_molecule.print_xyz('opt.xyz')
             self.cp(os.path.join(self.gauss.gauss_path, self.gauss_opt_log_name),
                     os.path.join(self.nx.NX_path, 'opt.log'))
-            if not EnvCheck.check_NX():
-                exit()
             self.nx.invoke_NX('opt.xyz', 'opt.log', self.opt_molecule.atom_num, self.ML_point)
             self.multi_xyz = self.nx.multi_xyz
-        else:
-            # now exists xyz file, process this file and store it to self.multi_xyz_geom
+        
+        self.cd(self.work_path)
+        if self.exist_path(self.nx_nea_geom_name): # exists nea geom path
             self.multi_xyz = Molecule.read_multi_xyz(self.nx_nea_geom_name)
-            # self.ML_point = len(self.multi_xyz) - 1   # keep the MLpoint the same with ML-NEA (except the equibrium geom)
-            if len(self.multi_xyz) - 1 >= self.ML_point:
+            if len(self.multi_xyz) - 1 > self.ML_point:
                 self.multi_xyz = self.multi_xyz[:self.ML_point + 1]
+            elif len(self.multi_xyz) - 1 < self.ML_point:
+                orig_xyz = self.multi_xyz
+                self.opt_freq_calc(force_calc=True)
+                NX_gen_ensemble()
+                self.multi_xyz = orig_xyz + self.multi_xyz[len(orig_xyz): ]
+        else:  # not exists multiple nea geom data, need to calc it with NX
+            NX_gen_ensemble()
 
     def ML_NEA_calc_all(self):
         self.cd(self.cs_ML.ML_path)
@@ -2403,7 +2403,7 @@ class RecurPaperProcedure(ArgParser, LinuxInterface):
         # self.gauss.process_gaussian_log(self.gauss.all_log_path, self.max_state, pattern='', regex=False)
         ctl_adapter = CtlPartAdapter(self, CtlPartAdapter.paper_adapter)
         self.cs_ML.define_data_set(this=ctl_adapter, TD_point=self.TD_point, xyz_file=self.nx_nea_geom_name,
-                                   max_state=self.max_state, delta=0.01)
+                                   max_state=self.max_state, delta=self.delta_ML)
         self.cs_ML.ML_train_all()
         
     def ML_NEA_calc_iter(self):

{MLatom-2.0.4 → MLatom-2.1.0}/src/MLatom/MLatom.py

@@ -31,9 +31,10 @@
   ! Pavlo O. Dral, Fuchun Ge, Bao-Xin Xue, Yi-Fan Hou, Max Pinheiro Jr,       !
   ! Jianxing Huang, Mario Barbatti, Top. Curr. Chem. 2021, 379, 27            !
   !                                                                           !
-  ! Pavlo O. Dral, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou, Max Pinheiro Jr,       !
+  ! Pavlo O. Dral, Peikun Zheng, Bao-Xin Xue, Fuchun Ge, Yi-Fan Hou,          !
+  ! Max Pinheiro Jr,                                                          !
   ! MLatom: A Package for Atomistic Simulations with Machine Learning         !
-  ! version 2.0, Xiamen University, Xiamen, China, 2013-2021                  !
+  ! version 2.1, Xiamen University, Xiamen, China, 2013-2021                  !
   !                                                                           !  
   !---------------------------------------------------------------------------!
 
@@ -88,6 +89,8 @@ class MLatomMainCls(object):
             sliceData.sliceDataCls(argsSD = args.args2pass)
         elif (args.useMLmodel    or args.createMLmodel or
               args.estAccMLmodel or args.learningCurve or
+              args.AIQM1DFTstar or args.AIQM1DFT or args.AIQM1 or 
+              args.geomopt or args.freq or
               args.MLNEA):
             MLtasks.MLtasksCls(argsMLtasks = args.args2pass)
         
@@ -105,11 +108,14 @@ class Args(ArgsBase):
         self.task_list = [
             'XYZ2X', 'analyze', 'sample', 'sampleFromSlices', 'mergeSlices','slice',
             'useMLmodel', 'createMLmodel', 'estAccMLmodel', 'learningCurve', 
-            'crossSection'
+            'crossSection', # Interfaces
+            'callNXinterface', 'AIQM1DFTstar', 'AIQM1DFT', 'AIQM1', # DEVELOPMENT VERSION
+            'geomopt', 'freq'
         ]
         self.add_default_dict_args(self.task_list, bool)
         self.add_default_dict_args([
-            'useMLmodel', 'createMLmodel', 'estAccMLmodel', 'learningCurve','deltaLearn','selfCorrect','MLmodelType'
+            'useMLmodel', 'createMLmodel', 'estAccMLmodel', 'learningCurve','deltaLearn','selfCorrect','MLmodelType',
+            'geomopt', 'freq'
             ],
             bool
         )
@@ -119,13 +125,20 @@ class Args(ArgsBase):
             ''
         )
         self.add_default_dict_args([
-            'Yb', 'Yt', 'YestT', 'YestFile','XYZfile', 'XfileIn', 'Yfile', 'YgradXYZfile', 'absXfileIn', 'absXYZfile', 'absYfile', 'absYgradXYZfile', 'YgradXYZestFile', 'Ntrain', 'Nsubtrain', 'Nvalidate', 'Ntest', 'iTrainIn', 'iTestIn', 'iSubtrainIn', 'iValidateIn', 'sampling', 'MLmodelIn', 'MLmodelOut',
+            'XYZfile', 'XfileIn',
+            'Yfile', 'YestFile', 'Yb', 'Yt', 'YestT',
+            'YgradFile', 'YgradEstFile', 'YgradB', 'YgradT', 'YgradEstT',
+            'YgradXYZfile', 'YgradXYZestFile', 'YgradXYZb', 'YgradXYZt', 'YgradXYZestT',
+            'absXfileIn', 'absXYZfile', 'absYfile', 'absYgradXYZfile',
+            'Nuse', 'Ntrain', 'Nsubtrain', 'Nvalidate', 'Ntest', 'iTrainIn', 'iTestIn', 'iSubtrainIn', 'iValidateIn', 'sampling', 'MLmodelIn', 'MLmodelOut',
             'molDescriptor', 'kernel'
             ],
             ''
         )
         self.add_dict_args({'MLmodelType': '', 'nthreads': None})
         self.set_keyword_alias('crossSection', ['ML-NEA', 'ML_NEA', 'crossSection', 'cross-section', 'cross_section','MLNEA'])
+        self.set_keyword_alias('AIQM1DFTstar', ['AIQM1@DFT*'])
+        self.set_keyword_alias('AIQM1DFT', ['AIQM1@DFT'])
         self.args2pass = []
 
     def parse(self, argsraw):