mlatom 2.0.1__py3.7.egg

MLatom/interfaces/sGDML/sgdml_dataset_from_extxyz.py

@@ -0,0 +1,199 @@
+#!/export/home/fcge/.linuxbrew/opt/python@3.8/bin/python3.8
+
+# MIT License
+#
+# Copyright (c) 2018-2019 Stefan Chmiela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import print_function
+
+import os
+import sys
+
+try:
+    from ase.io import read
+except ImportError:
+    raise ImportError('Optional ASE dependency not found! Please run \'pip install sgdml[ase]\' to install it.')
+
+import numpy as np
+
+from sgdml import __version__
+from sgdml.utils import io, ui
+
+if sys.version[0] == '3':
+    raw_input = input
+
+
+# Assumes that the atoms in each molecule are in the same order.
+def read_nonstd_ext_xyz(f):
+    n_atoms = None
+
+    R, z, E, F = [], [], [], []
+    for i, line in enumerate(f):
+        line = line.strip()
+        if not n_atoms:
+            n_atoms = int(line)
+            print('Number atoms per geometry: {:,}'.format(n_atoms))
+
+        file_i, line_i = divmod(i, n_atoms + 2)
+
+        if line_i == 1:
+            try:
+                e = float(line)
+            except ValueError:
+                pass
+            else:
+                E.append(e)
+
+        cols = line.split()
+        if line_i >= 2:
+            R.append(list(map(float, cols[1:4])))
+            if file_i == 0:  # first molecule
+                z.append(io._z_str_to_z_dict[cols[0]])
+            F.append(list(map(float, cols[4:7])))
+
+        if file_i % 1000 == 0:
+            sys.stdout.write('\rNumber geometries found so far: {:,}'.format(file_i))
+            sys.stdout.flush()
+    sys.stdout.write('\rNumber geometries found so far: {:,}'.format(file_i))
+    sys.stdout.flush()
+    print()
+
+    R = np.array(R).reshape(-1, n_atoms, 3)
+    z = np.array(z)
+    E = None if not E else np.array(E)
+    F = np.array(F).reshape(-1, n_atoms, 3)
+
+    if F.shape[0] != R.shape[0]:
+        sys.exit(
+            ui.color_str('[FAIL]', fore_color=ui.RED, bold=True)
+            + ' Force labels are missing from dataset or are incomplete!'
+        )
+
+    f.close()
+    return (R, z, E, F)
+
+def convert(dataset, overwrite=True):
+
+    name = os.path.splitext(os.path.basename(dataset))[0]
+    dataset_file_name = name + '.npz'
+
+    dataset_exists = os.path.isfile(dataset_file_name)
+    if dataset_exists and overwrite:
+        print(ui.color_str('[INFO]', bold=True) + ' Overwriting existing dataset file.')
+    if not dataset_exists or overwrite:
+        print('Writing dataset to \'{}\'...'.format(dataset_file_name))
+    else:
+        sys.exit(
+            ui.color_str('[FAIL]', fore_color=ui.RED, bold=True)
+            + ' Dataset \'{}\' already exists.'.format(dataset_file_name)
+        )
+
+    mols = read(dataset, index=':')
+
+    lattice, R, z, E, F = None, None, None, None, None
+
+    calc = mols[0].get_calculator()
+    is_extxyz = calc is not None
+    if is_extxyz:
+
+        print("\rNumber geometries found: {:,}\n".format(len(mols)))
+
+        if 'forces' not in calc.results:
+            sys.exit(
+                ui.color_str('[FAIL]', fore_color=ui.RED, bold=True)
+                + ' Forces are missing in the input file!'
+            )
+
+        lattice = np.array(mols[0].get_cell())
+        if not np.any(lattice):
+            print(
+                ui.color_str('[INFO]', bold=True)
+                + ' No lattice vectors specified in extended XYZ file.'
+            )
+
+        Z = np.array([mol.get_atomic_numbers() for mol in mols])
+        all_z_the_same = (Z == Z[0]).all()
+        if not all_z_the_same:
+            sys.exit(
+                ui.color_str('[FAIL]', fore_color=ui.RED, bold=True)
+                + ' Order of atoms changes accross dataset.'
+            )
+
+        lattice = np.array(mols[0].get_cell())
+        if not np.any(lattice): # all zeros
+            lattice = None
+
+        R = np.array([mol.get_positions() for mol in mols])
+        z = Z[0]
+
+        if 'Energy' in mols[0].info:
+            E = np.array([mol.info['Energy'] for mol in mols])
+        if 'energy' in mols[0].info:
+            E = np.array([mol.info['energy'] for mol in mols])
+        F = np.array([mol.get_forces() for mol in mols])
+
+    else:  # legacy non-standard XYZ format
+
+        with open(dataset) as f:
+            R, z, E, F = read_nonstd_ext_xyz(f)
+
+
+    # Base variables contained in every model file.
+    base_vars = {
+        'type': 'd',
+        'code_version': __version__,
+        'name': name,
+        'theory': 'unknown',
+        'R': R,
+        'z': z,
+        'F': F,
+    }
+
+    base_vars['F_min'], base_vars['F_max'] = np.min(F.ravel()), np.max(F.ravel())
+    base_vars['F_mean'], base_vars['F_var'] = np.mean(F.ravel()), np.var(F.ravel())
+
+    # print('Please provide a description of the length unit used in your input file, e.g. \'Ang\' or \'au\': ')
+    # print('Note: This string will be stored in the dataset file and passed on to models files for later reference.')
+    # r_unit = raw_input('> ').strip()
+    r_unit = 'Ang'
+    if r_unit != '':
+        base_vars['r_unit'] = r_unit
+
+    # print('Please provide a description of the energy unit used in your input file, e.g. \'kcal/mol\' or \'eV\': ')
+    # print('Note: This string will be stored in the dataset file and passed on to models files for later reference.')
+    # e_unit = raw_input('> ').strip()
+    e_unit = 'kcal/mol'
+    if e_unit != '':
+        base_vars['e_unit'] = e_unit
+
+    if E is not None:
+        base_vars['E'] = E
+        base_vars['E_min'], base_vars['E_max'] = np.min(E), np.max(E)
+        base_vars['E_mean'], base_vars['E_var'] = np.mean(E), np.var(E)
+    else:
+        print(ui.color_str('[INFO]', bold=True) + ' No energy labels found in dataset.')
+
+    if lattice is not None:
+        base_vars['lattice'] = lattice
+
+    base_vars['md5'] = io.dataset_md5(base_vars)
+    np.savez_compressed(dataset_file_name, **base_vars)
+    print(ui.color_str('[DONE]', fore_color=ui.GREEN, bold=True))

MLatom/ref.json

@@ -0,0 +1,23 @@
+{
+    "JCP2017_MLCH3Cl":        "P. O. Dral, A. Owens, S. N. Yurchenko, W. Thiel,\nJ. Chem. Phys. 2017, 146, 244108",
+    "JCTC2015_DeltaLearning": "R. Ramakrishnan, P. O. Dral, M. Rupp, O. A. von Lilienfeld,\nJ. Chem. Theory Comput. 2015, 11, 2087",
+    "CM":                     "M. Rupp, A. Tkatchenko, K.\u2010R. M\u00fcller, O. A. von Lilienfeld,\nPhys. Rev. Lett. 2012, 108, 058301\n\nK. Hansen, G. Montavon, F. Biegler, S. Fazli, M. Rupp,\nM. Scheffler, O. A. von Lilienfeld, A. Tkatchenko, K.\u2010R. M\u00fcller,\nJ. Chem. Theory Comput. 2013, 9, 3404",
+    "sGDMLprog":              "S. Chmiela, H. E. Sauceda, I. Poltavsky, K.-R. M\u00fcller, A. Tkatchenko,\nComput. Phys. Commun. 2019, 240, 38",
+    "sGDMLmodel":             "S. Chmiela, H. E. Sauceda, K.-R. M\u00fcller, A. Tkatchenko,\nNat. Commun. 2018, 9, 3887",
+    "GDMLmodel":              "S. Chmiela, A. Tkatchenko, H. E. Sauceda, I. Poltavsky, K. T. Sch\u00fctt,  K.-R. M\u00fcller,\nSci. Adv. 2017, 3, e1603015",
+    "hyperopt":               "J. Bergstra, D. Yamins, D. D. Cox, Making a Science of Model Search:\nHyperparameter Optimization in Hundreds of Dimensions for Vision\nArchitectures.\nProceedings of the 30th International Conference on Machine Learning\n(ICML 2013), Vol. 28, JMLR.org, Atlanta, GA, USA, 2013, pp. I-115",
+    "TPE":                    "J. Bergstra, R. Bardenet, Y. Bengio, B. Kegl,\nAlgorithms for Hyper-Parameter Optimization.\nIn Advances in Neural Information Processing Systems, Vol. 24.\nEds.: J. Shawe-Taylor, R. Zemel, P. Bartlett, F. Pereira, K. Q. Weinberger,\nCuran Associates, Inc., 2011",
+    "ML-NEA":                 "B.-X. Xue, M. Barbatti, P. O. Dral, J. Phys. Chem. A 2020, 124, 7199",
+    "NEA":                    "R. Crespo-Otero, M. Barbatti, Theor. Chem. Acc. 2012, 131, 1237",
+    "Wigner":                 "Schinke, R. Photodissociation Dynamics: Spectroscopy and Fragmentation of\nSmall Polyatomic Molecules; Cambridge University Press: Cambridge, U.K., 1995",
+    "NEWTON-X":              "M. Barbatti, G. Granucci, M. Ruckenbauer, F. Plasser,\nR. Crespo-Otero,\nJ. Pittner, M. Persico, H. Lischka,\nNEWTON-X:\na package for Newtonian dynamics close to the crossing seam,\nversion 2.2, www.newtonx.org, 2017\n\nM. Barbatti, M. Ruckenbauer, F. Plasser, J. Pittner, G. Granucci,\nM. Persico, H. Lischka, WIREs: Comp. Mol. Sci. 2014, 4, 26",
+    "PhysNet":               "O. T. Unke, M. Meuwly, J. Chem. Theory Comput. 2019, 15, 3678",
+    "TorchANI":              "X. Gao, F. Ramezanghorbani, O. Isayev, J. S. Smith, A. E. Roitberg,\nJ. Chem. Inf. Model. 2020, 60, 3408",
+    "ANI":                   "J. S. Smith, O. Isayev, A. E. Roitberg, Chem. Sci. 2017, 8, 3192",
+    "DeePMD-kit":            "H. Wang, L. Zhang, J. Han, W. E, Comput. Phys. Commun. 2018, 228, 178",
+    "DPMD":                  "L. Hang, J. Han, H. Wang, R. Car, W. E, Phys. Rev. Lett. 2018, 120, 143001",
+    "DeepPot-SE":            "L.F. Zhang, J.Q. Han, H. Wang, W.A. Saidi, R. Car, W.N. E,\nAdv. Neural. Inf. Process. Syst. 2018, 31, 4436",
+    "GAP":                   "A. P. Bartok, M. C. Payne, R. Konor, G. Csanyi,\nPhys. Rev. Lett. 2010, 104, 136403",
+    "SOAP":                  "A. P. Bartok,              R. Konor, G. Csanyi,\nPhys. Rev. B     2013,  87, 184115"
+}
+

MLatom/sliceData.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+'''
+  !---------------------------------------------------------------------------! 
+  ! sliceData: Scripts for working with sliced data                           ! 
+  ! Implementations by: Pavlo O. Dral                                         ! 
+  !---------------------------------------------------------------------------! 
+'''
+
+import sys, os, time, operator, re, copy, subprocess
+import stopper
+import interface_MLatomF
+
+class sliceDataCls(object):
+    eqX  = [] # Equilibrium input vector
+    xx   = [] # List of molecular descriptors
+    nall = 0  # Number of molecular descriptors
+    Ds   = {} # Dictionary {index i: distance to eqX}
+    sorted_indices = [] # Indices of input vectors sorted by their distance to the equilibrium structure
+    
+    def __init__(self, argsSD = sys.argv[1:]):
+        starttime = time.time()
+        
+        print(' %s ' % ('='*78))
+        print(time.strftime(" sliceData started on %d.%m.%Y at %H:%M:%S", time.localtime()))
+        for arg in argsSD:
+            flagmatch = re.search('nthreads', arg.lower(), flags=re.UNICODE | re.MULTILINE | re.DOTALL | re.IGNORECASE)
+            if flagmatch:
+                argsSD.remove(arg)
+        args.parse(argsSD)
+        print('        with the following options:')
+        argsstr = '        '
+        for arg in argsSD:
+            argsstr += arg + ' '
+        print(argsstr.rstrip())
+        print(' %s ' % ('='*78))
+        sys.stdout.flush()
+        
+        # Perform requested task
+        if args.slicedata:
+            self.getEqX(args.eqXfileIn)
+            self.getX(args.XfileIn)
+            self.sortByDistance()
+            self.slicedata()
+        if args.sampleFromSlices:
+            self.sampleFromSlices()
+        if args.mergeSlices:
+            self.mergeSlices()
+        
+        endtime = time.time()
+        wallclock = endtime - starttime
+        print(' %s ' % ('='*78))
+        print(' Wall-clock time: %.2f s (%.2f min, %.2f hours)\n' % (wallclock, wallclock / 60.0, wallclock / 3600.0))
+        print(time.strftime(" sliceData terminated on %d.%m.%Y at %H:%M:%S", time.localtime()))
+        print(' %s ' % ('='*78))
+        sys.stdout.flush()
+      
+    def getEqX(self, xfilename):
+        self.eqX = []
+        with open(xfilename, 'r') as xf:
+            for line in xf:
+                self.eqX = [float(x) for x in line.split()]
+                break
+      
+    def getX(self, xfilename):
+        self.xx = []
+        with open(xfilename, 'r') as xf:
+            for line in xf:
+                self.xx.append([float(x) for x in line.split()])
+        self.nall = len(self.xx)
+        
+    def sortByDistance(self):
+        for ii in range(1, self.nall+1):
+            self.Ds[ii] = self.distance(self.eqX, self.xx[ii-1])
+        self.sorted_indices = [ind for (ind, distance) in sorted(list(self.Ds.items()), key=operator.itemgetter(1))]
+        
+    @classmethod
+    def distance(cls, xi, xj):
+        # Returns distance between xi and xj descriptors (they must be of the same length)
+        dd = 0.0
+        for ii in range(len(xi)):
+            dd += (xi[ii] - xj[ii]) ** 2
+        dd = dd ** 0.5
+        return dd
+
+    def slicedata(self):
+        self.print_ordered_set( nstart = 1, nend = self.nall,
+                                xfilename = args.XfileIn,
+                                xorderedname = 'xordered.dat',
+                                indorderedname = 'indices_ordered.dat',
+                                distordname = 'distances_ordered.dat')
+        
+        for ii in range(1, args.nslices + 1):
+            ninslice = self.nall // args.nslices
+            nstart = ninslice * (ii - 1) + 1
+            nend = ninslice * ii
+            if ii == args.nslices:
+                nend = self.nall # The last slice takes the rest
+            os.system('mkdir slice%d' % ii)
+            self.print_ordered_set( nstart = nstart, nend = nend,
+                                xfilename = args.XfileIn,
+                                xorderedname = 'slice%d/x.dat' % ii,
+                                indorderedname = 'slice%d/slice_indices.dat' % ii,
+                                distordname = 'slice%d/slice_distances.dat' % ii)
+    
+    def print_ordered_set(self, nstart = 1, nend = 'all',
+                                xfilename = 'x.dat',
+                                xorderedname = 'xordered.dat',
+                                indorderedname = 'indices_ordered.dat',
+                                distordname = 'distances_ordered.dat'):
+        xlines = open(xfilename, 'r').readlines()
+        if nend == 'all':
+            nend = self.nall
+        
+        with open(xorderedname, 'w') as xof, open(indorderedname, 'w') as indof:
+            for nn in range(nstart, nend + 1):
+                ii = self.sorted_indices[nn - 1]
+                indof.writelines('%d\n' % ii)
+                xof.writelines(xlines[ii-1])
+        del xlines    
+        
+        with open(distordname, 'w') as dof:
+            for nn in range(nstart, nend + 1):
+                ii = self.sorted_indices[nn - 1]
+                dof.writelines('%20.12f\n' % self.Ds[ii])
+                
+    def sampleFromSlices(self):
+        for ii in range(1, args.nslices + 1):
+            ninslice = args.Ntrain // args.nslices
+            nstart = ninslice * (ii - 1) + 1
+            nend = ninslice * ii
+            if ii == args.nslices:
+                ninslice += args.Ntrain - nend
+                nend = args.Ntrain # The last slice takes the rest
+            argsloc = ['sample'] + args.argsSD + ['XfileIn=x.dat'] + ['Ntrain=%d' % ninslice] + ['iTrainOut=itrain.dat']
+            if True: # Local calculations
+                interface_MLatomF.ifMLatomCls.run(argsloc, cwdpath='slice%d' % ii)
+            else: # Submission to queue
+                with open('slice%d/sample.inp' % ii, 'w') as finp:
+                    for arg in argsloc:
+                        finp.writelines('%s\n' % arg)
+                #cd os.system('cd slice%d ; bsub < ../mlatom.bsub' % ii) # To submit the job with bsub
+                
+    def mergeSlices(self):
+        Ntrain = args.Ntrain
+        
+        sampled_slices = []
+        unsampled_slices = []
+        for islice in range(1,args.nslices+1):
+            sampled_slice = []
+            unsampled_slice = []
+            ordindices = [] # This indices refer to the lines in the original files x.dat and y.dat corresponding to the lines in the sorted files x.dat and y.dat before slicing
+            with open('slice%d/slice_indices.dat' % islice, 'r') as ff:
+                    for line in ff:
+                        ordindices.append(int(line))
+            trindices = [] # This indices refer to the lines in the sorted files x.dat and y.dat corresponding to the lines in the files x.dat and y.dat used for prediction
+            with open('slice%d/itrain.dat' % islice, 'r') as ff:
+                for line in ff:
+                    trindices.append(int(line))
+            for jj in trindices:
+                sampled_slice.append(ordindices[jj - 1])
+            for jj in ordindices:
+                if not jj in sampled_slice:
+                    unsampled_slice.append(jj)
+            sampled_slices.append(sampled_slice)
+            unsampled_slices.append(unsampled_slice)
+                
+        slicesSizes = [len(ss) for ss in sampled_slices]
+        Nsmpl = sum(slicesSizes)
+        if Nsmpl < Ntrain:
+            stopper.stopMLatom('Sampled less points than requested for training set')
+        unslicesSizes = [len(ss) for ss in unsampled_slices]
+        Nunsmpl = sum(unslicesSizes)
+        
+        # Sample data points into subsets
+        with open('itrain.dat', 'w') as fitrain, open('itest.dat', 'w') as fitest, open('isubtrain.dat', 'w') as fisubtrain, open('ivalidate.dat', 'w') as fivalidate:
+            Nsubtrain = int(Ntrain * 0.80)
+            counter = 0
+            exitWhileLoop = False
+            islc = [-1 for ss in range(args.nslices)]
+            while counter < Nsmpl:
+                for islice in range(args.nslices):
+                    islc[islice] += 1
+                    if islc[islice] < slicesSizes[islice]:
+                        counter += 1
+                        if counter <= Ntrain:
+                            fitrain.writelines('%d\n' % sampled_slices[islice][islc[islice]])
+                            if counter <= Nsubtrain:
+                                fisubtrain.writelines('%d\n' % sampled_slices[islice][islc[islice]])
+                            else:
+                                fivalidate.writelines('%d\n' % sampled_slices[islice][islc[islice]])
+                        elif counter <= Nsmpl:
+                            fitest.writelines('%d\n' % sampled_slices[islice][islc[islice]])
+                        else:
+                            print('breaking the loop')
+                            exitWhileLoop = True
+                            break
+                if exitWhileLoop:
+                    break
+            counter = 0
+            exitWhileLoop = False
+            islc = [-1 for ss in range(args.nslices)]
+            while counter < Nunsmpl:
+                for islice in range(args.nslices):
+                    islc[islice] += 1
+                    if islc[islice] < unslicesSizes[islice]:
+                        counter += 1
+                        if counter <= Nunsmpl:
+                            fitest.writelines('%d\n' % unsampled_slices[islice][islc[islice]])
+                        else:
+                            print('breaking the loop')
+                            exitWhileLoop = True
+                            break
+                if exitWhileLoop:
+                    break
+    
+class args(object):
+    # Default values:
+    slicedata = False
+    sampleFromSlices = False
+    mergeSlices = False
+    nslices   = 3
+    XfileIn   = None
+    eqXfileIn = None
+    Ntrain    = None
+    # Only this Python program options
+    argspy          = ['slice',
+                       'sampleFromSlices',
+                       'mergeSlices',
+                       'nslices=*',
+                       'eqXfileIn=*',
+                       'Ntrain=*']
+    # Only options of other programs
+    argsSD = []
+    
+    @classmethod
+    def parse(cls, argsraw):
+        if len(argsraw) == 0:
+            printHelp()
+            stopper.stopMLatom('At least one option should be provided')
+        argslower = [arg.lower() for arg in argsraw]
+        if ('help' in argslower
+        or '-help' in argslower
+        or '-h' in argslower
+        or '--help' in argslower):
+            printHelp()
+            stopper.stopMLatom('')
+
+        cls.argsSD = copy.deepcopy(argsraw)
+        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()                      == 'slice'.lower():
+                cls.slicedata                      = True
+            elif arg.lower()                      == 'sampleFromSlices'.lower():
+                cls.sampleFromSlices               = True
+            elif arg.lower()                      == 'mergeSlices'.lower():
+                cls.mergeSlices                    = True
+            elif arg.lower()[0:len('nslices=')]   == 'nslices='.lower():
+                cls.nslices                        = int(arg[len('nslices='):])
+            elif arg.lower()[0:len('XfileIn=')]   == 'XfileIn='.lower():
+                cls.XfileIn                        = arg[len('XfileIn='):]
+            elif arg.lower()[0:len('Ntrain=')]    == 'Ntrain='.lower():
+                cls.Ntrain                         = int(arg[len('Ntrain='):])
+            elif arg.lower()[0:len('eqXfileIn=')] == 'eqXfileIn='.lower():
+                cls.eqXfileIn                      = arg[len('eqXfileIn='):]
+            #else: # Other options are usually passed over to the interfaced programs
+            #    printHelp()
+            #    stopper.stopMLatom('Option "%s" is not recognized' % arg)
+            for argpy in cls.argspy:
+                flagmatch = re.search(argpy, arg.lower(), flags=re.UNICODE | re.MULTILINE | re.DOTALL | re.IGNORECASE)
+                if flagmatch:
+                    cls.argsSD.remove(arg)
+                    break
+        cls.checkArgs()
+            
+    @classmethod
+    def checkArgs(cls):
+        Ntasks = (cls.slicedata + cls.sampleFromSlices + cls.mergeSlices)
+        if Ntasks == 0:
+            printHelp()
+            stopper.stopMLatom('At least one task should be requested')
+        if cls.slicedata:
+            if cls.XfileIn == None:
+                printHelp()
+                stopper.stopMLatom('Provide correct file name with XfileIn option')
+            if cls.eqXfileIn == None:
+                printHelp()
+                stopper.stopMLatom('Provide correct file name with eqXfileIn option')
+        if cls.sampleFromSlices:
+            if cls.Ntrain == None:
+                printHelp()
+                stopper.stopMLatom('Provide the number of training points with Ntrain option')
+        if cls.mergeSlices:
+            if cls.Ntrain == None:
+                printHelp()
+                stopper.stopMLatom('Provide the number of training points with Ntrain option')
+                
+def printHelp():
+    if __name__ == '__main__':
+        print('''
+  !---------------------------------------------------------------------------! 
+  !                                                                           ! 
+  !              sliceData: Scripts for working with sliced data              ! 
+  !                                                                           ! 
+  !---------------------------------------------------------------------------!
+  
+  Usage:
+    sliceData.py [options]
+    
+  Options:
+      help            print this help and exit
+    
+    Tasks for sliceData.py. At least one task should be requested.
+''')
+    helpText = '''      slice           slice data set
+        nslices=N     number of slices [default = 3]
+        XfileIn=S     file S with input vectors X
+        eqXfileIn=S   file S with input vector for the equilibrium geometry
+      sampleFromSlices   sample from each slice
+        nslices=N     number N of slices [default = 3]
+        Ntrain=N      total integer number N of training points from all slices
+      mergeSlices     merges indices from slices [see sliceData help]
+        nslices=N     number N of slices [default = 3]
+        Ntrain=N      total integer number N of training points from all slices
+'''
+    print(helpText)
+
+if __name__ == '__main__':
+    print(__doc__)
+    sliceDataCls()

MLatom/stopper.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+'''
+  !---------------------------------------------------------------------------! 
+  ! stopper: Stopping MLatom and writing an error message                     ! 
+  ! Implementations by: Pavlo O. Dral                                         ! 
+  !---------------------------------------------------------------------------! 
+'''
+
+import sys
+
+def stopMLatom(errorMsg):
+    if errorMsg != '':
+        print(' <!> %s <!>' % errorMsg)
+    sys.exit()
+
+if __name__ == '__main__':
+    stopMLatom('Call the main program!')