Update CLI scripts to use logging_utils.

Author: NikoOinonen

ppafm/GUIWidgets.py

@@ -122,11 +122,10 @@ class FigImshow(FigCanvas):
 
     cbar = None
 
-    def __init__(self, parentWiget=None, parentApp=None, width=5, height=4, dpi=100, verbose=0):
+    def __init__(self, parentWiget=None, parentApp=None, width=5, height=4, dpi=100):
         super(self.__class__, self).__init__(parentWiget=parentWiget, parentApp=parentApp, width=width, height=height, dpi=dpi)
         self.fig.canvas.mpl_connect("button_press_event", self.onclick)
         self.fig.canvas.mpl_connect("scroll_event", self.onscroll)
-        self.verbose = verbose
         self.img = None
         self.cbar = None
 
@@ -509,9 +508,8 @@ def updateParent(self):
 
 
 class FFViewer(SlaveWindow):
-    def __init__(self, parent=None, title="View Forcefield", width=5, height=4, dpi=100, verbose=0):
+    def __init__(self, parent=None, title="View Forcefield", width=5, height=4, dpi=100):
         super().__init__(parent=parent, title=title)
-        self.verbose = verbose
 
         self.figCan = FigImshow(parent, width=width, height=height, dpi=dpi)
         self.centralLayout.addWidget(self.figCan)

ppafm/cli/conv_rho.py

@@ -1,9 +1,13 @@
 #!/usr/bin/python
 import gc
+import sys
 
 import numpy as np
 
 from .. import common, fieldFFT, io
+from ..logging_utils import get_logger
+
+logger = get_logger("conv_rho")
 
 
 def handle_aeccar(fname, lvec, rho):
@@ -35,21 +39,23 @@ def main(argv=None):
 
     args = parser.parse_args(argv)
 
-    print(">>> Loading sample from ", args.sample, " ... ")
+    logger.info(f"Loading sample from {args.sample}")
     rho_sample, lvec_sample, n_dim_sample, head_sample = io.loadXSF(args.sample)
-    print(">>> Loading tip from ", args.tip, " ... ")
+    logger.info(f"Loading tip from {args.tip}")
     rho_tip, lvec_tip, n_dim_tip, head_tip = io.loadXSF(args.tip)
 
     if np.any(n_dim_sample != n_dim_tip):
-        raise Exception("Tip and Sample grids have different dimensions! - sample: " + str(n_dim_sample) + " tip: " + str(n_dim_tip))
+        logger.error(f"Tip and Sample grids have different dimensions! - sample: {n_dim_sample} tip: {n_dim_tip}")
+        sys.exit(1)
     if np.any(lvec_sample != lvec_tip):
-        raise Exception("Tip and Sample grids have different shapes! - sample: " + str(lvec_sample) + " tip: " + str(lvec_tip))
+        logger.error(f"Tip and Sample grids have different shapes! - sample: {lvec_sample} tip: {lvec_tip}")
+        sys.exit(1)
 
     handle_aeccar(args.sample, lvec_sample, rho_sample)
     handle_aeccar(args.tip, lvec_tip, rho_tip)
 
     if args.Bpauli > 0.0:
-        print(">>> computing rho^B where B = ", args.Bpauli)
+        logger.info(f"Computing rho^B where B = {args.Bpauli}")
         # NOTE: due to round-off error the density from DFT code is often negative in some voxels which produce NaNs after exponentiation; we need to correct this
         if not args.no_negative_check:
             handle_negative_density(rho_sample)
@@ -61,15 +67,15 @@ def main(argv=None):
             io.save_scal_field("tip_density_pow_%03.3f.xsf" % args.Bpauli, rho_tip, lvec_tip, data_format=args.output_format, head=head_tip)
 
     if args.density_cutoff:
-        print(f">>> Applying a density cutoff of {args.density_cutoff} to sample and tip electron densities.")
+        logger.info(f"Applying a density cutoff of {args.density_cutoff} to sample and tip electron densities.")
         rho_sample[rho_sample > args.density_cutoff] = args.density_cutoff
         rho_tip[rho_tip > args.density_cutoff] = args.density_cutoff
 
-    print(">>> Evaluating convolution E(R) = A*Integral_r ( rho_tip^B(r-R) * rho_sample^B(r) ) using FFT ... ")
+    logger.info("Evaluating convolution E(R) = A*Integral_r ( rho_tip^B(r-R) * rho_sample^B(r) ) using FFT ... ")
     f_x, f_y, f_z, energy = fieldFFT.potential2forces_mem(rho_sample, lvec_sample, n_dim_sample, rho=rho_tip, doForce=True, doPot=True, deleteV=True)
 
     namestr = args.output
-    print(">>> Saving result of convolution to FF_", namestr, "_?.xsf ... ")
+    logger.info(f">>> Saving result of convolution to FF_{namestr}_?.xsf ... ")
 
     # Density Overlap Model
     if args.energy:

ppafm/cli/generateDFTD3.py

@@ -7,6 +7,9 @@
 
 from .. import common
 from ..HighLevel import computeDFTD3
+from ..logging_utils import get_logger
+
+logger = get_logger("generateDFTD3")
 
 
 def main(argv=None):
@@ -45,7 +48,7 @@ def main(argv=None):
         df_params = {"s6": p[0], "s8": p[1], "a1": p[2], "a2": p[3]}
     else:
         if args.df_name not in d3.DF_DEFAULT_PARAMS:
-            print(f"Unknown functional name `{args.df_name}`!")
+            logger.error(f"Unknown functional name `{args.df_name}`!")
             sys.exit(1)
         df_params = args.df_name
 

ppafm/cli/generateElFF.py

@@ -12,6 +12,9 @@
     loadValenceElectronDict,
     subtractCoreDensities,
 )
+from ..logging_utils import get_logger
+
+logger = get_logger("generateElFF")
 
 
 def main(argv=None):
@@ -43,7 +46,8 @@ def main(argv=None):
     subtract_core_densities = (args.doDensity) and (args.Rcore > 0.0) and (args.tip_dens is not None)
     if subtract_core_densities:  # We do it here, in case it crash we don't want to wait for all the huge density files to load
         if args.tip_dens is None:
-            raise Exception("Rcore>0 but no tip density provided!")
+            logger.error("Rcore>0 but no tip density provided!")
+            sys.exit(1)
         valence_electrons_dictionary = loadValenceElectronDict()
         rs_tip, elems_tip = getAtomsWhichTouchPBCcell(args.tip_dens, Rcut=args.Rcore, parameters=parameters)
 
@@ -66,43 +70,42 @@ def main(argv=None):
 
     if args.tip_dens is not None:
         #  No need to renormalize: fieldFFT already works with density
-        print(">>> Loading tip density from ", args.tip_dens, "...")
+        logger.info(f">>> Loading tip density from {args.tip_dens}")
         if args.tip_dens.lower().endswith("xsf"):
             rho_tip, lvec_tip, _, head_tip = io.loadXSF(args.tip_dens)
         else:
-            print(f'ERROR!!! Unknown or unsupported format of the tip density file "{args.tip_dens}"\n', file=sys.stderr)
+            logger.error(f'Unknown or unsupported format of the tip density file "{args.tip_dens}"\n')
             sys.exit(1)
         if subtract_core_densities:
-            print(">>> subtracting core densities from rho_tip ... ")
+            logger.info(">>> subtracting core densities from rho_tip ... ")
             subtractCoreDensities(rho_tip, lvec_tip, elems=elems_tip, Rs=rs_tip, valElDict=valence_electrons_dictionary, Rcore=args.Rcore, head=head_tip)
 
         parameters.tip = -rho_tip  # Negative sign, because the electron density needs to be negative but the input density is positive
 
     if args.KPFM_sample is not None:
         sigma = parameters.sigma
-        print(parameters.sigma)
+        logger.debug(f"{parameters.sigma}")
         if input_format == "xsf" and args.KPFM_sample.lower().endswith(".xsf"):
             v_ref_s = args.Vref
-            print(">>> Loading Hartree potential under bias from ", args.KPFM_sample, "...")
-            print("Use loadXSF")
+            logger.info(f">>> Loading Hartree potential under bias from {args.KPFM_sample}")
+            logger.debug("Use loadXSF")
             v_kpfm, lvec, n_dim, head = io.loadXSF(args.KPFM_sample)
 
         elif input_format == "cube" and args.KPFM_sample.lower().endswith(".cube"):
             v_ref_s = args.Vref
-            print(">>> Loading Hartree potential under bias from ", args.KPFM_sample, "...")
-            print("Use loadCUBE")
+            logger.info(f">>> Loading Hartree potential under bias from {args.KPFM_sample}")
+            logger.debug("Use loadCUBE")
             v_kpfm, lvec, n_dim, head = io.loadCUBE(args.KPFM_sample)
 
         else:
-            print(
-                f'ERROR!!! Format of the "{args.KPFM_sample}" file with Hartree potential under bias is unknown or incompatible with the main input format, which is "{input_format}".\n',
-                file=sys.stderr,
+            logger.error(
+                f'Format of the "{args.KPFM_sample}" file with Hartree potential under bias is unknown or incompatible with the main input format, which is "{input_format}".\n'
             )
             sys.exit(1)
         v_kpfm *= -1  # Unit conversion, energy to potential (eV -> V)
         dv_kpfm = v_kpfm - electrostatic_potential
 
-        print(">>> Loading tip density under bias from ", args.KPFM_tip, "...")
+        logger.info(f">>> Loading tip density under bias from {args.KPFM_tip}")
         if input_format == "xsf" and args.KPFM_tip.lower().endswith(".xsf"):
             v_ref_t = args.Vref
             rho_tip_kpfm, lvec_tip, _, head_tip = io.loadXSF(args.KPFM_tip)
@@ -118,28 +121,23 @@ def main(argv=None):
             if parameters.probeType == "8":
                 drho_kpfm = {"pz": 0.045}
                 sigma = 0.48
-                print(" Select CO-tip polarization ")
+                logger.debug("Select CO-tip polarization ")
             if parameters.probeType == "47":
                 drho_kpfm = {"pz": 0.21875}
                 sigma = 0.7
-                print(" Select Ag polarization with decay sigma", sigma)
+                logger.debug(f"Select Ag polarization with decay sigma {sigma}")
             if parameters.probeType == "54":
                 drho_kpfm = {"pz": 0.250}
                 sigma = 0.67
-                print(" Select Xe-tip polarization")
+                logger.debug("Select Xe-tip polarization")
         else:
-            raise ValueError(
-                'ERROR!!! Neither is "'
-                + args.KPFM_sample
-                + '" a density file with an appropriate ("'
-                + input_format
-                + '") format\nnor is it a valid name of a tip polarizability model.\n'
-            )
+            logger.error(f'Neither is "{args.KPFM_sample}" a density file with an appropriate ("{input_format}") format nor is it a valid name of a tip polarizability model.')
+            sys.exit(1)
 
         ff_kpfm_t0sv, _ = computeElFF(dv_kpfm, lvec, n_dim, parameters.tip, computeVpot=args.energy, tilt=args.tilt, parameters=parameters)
         ff_kpfm_tvs0, _ = computeElFF(electrostatic_potential, lvec, n_dim, drho_kpfm, computeVpot=args.energy, tilt=args.tilt, sigma=sigma, deleteV=False, parameters=parameters)
 
-        print("Linear E to V")
+        logger.debug("Linear E to V")
         zpos = np.linspace(lvec[0, 2] - args.z0, lvec[0, 2] + lvec[3, 2] - args.z0, n_dim[0])
         for i in range(n_dim[0]):
             # z position of the KPFM tip with respect to the sample must not be zero or negative
@@ -149,14 +147,14 @@ def main(argv=None):
             ff_kpfm_t0sv[i, :, :] = ff_kpfm_t0sv[i, :, :] / ((v_ref_s) * (zpos[i] + 0.1))
             ff_kpfm_tvs0[i, :, :] = ff_kpfm_tvs0[i, :, :] / ((v_ref_t) * (zpos[i] + 0.1))
 
-        print(">>> Saving electrostatic forcefield ... ")
+        logger.info(">>> Saving electrostatic forcefield")
         io.save_vec_field("FFkpfm_t0sV", ff_kpfm_t0sv, lvec_samp, data_format=args.output_format, head=head_samp)
         io.save_vec_field("FFkpfm_tVs0", ff_kpfm_tvs0, lvec_samp, data_format=args.output_format, head=head_samp)
 
-    print(">>> Calculating electrostatic forcefield with FFT convolution as Eel(R) = Integral( rho_tip(r-R) V_sample(r) ) ... ")
+    logger.info(">>> Calculating electrostatic forcefield with FFT convolution as Eel(R) = Integral( rho_tip(r-R) V_sample(r) )")
     ff_electrostatic, e_electrostatic = computeElFF(electrostatic_potential, lvec, n_dim, parameters.tip, computeVpot=args.energy, tilt=args.tilt, parameters=parameters)
 
-    print(">>> Saving electrostatic forcefield ... ")
+    logger.info(">>> Saving electrostatic forcefield")
 
     io.save_vec_field("FFel", ff_electrostatic, lvec_samp, data_format=args.output_format, head=head_samp, atomic_info=(atoms_samp[:4], lvec_samp))
     if args.energy:

ppafm/cli/generateTraining_PVE.py

@@ -10,13 +10,16 @@
 
 from .. import common, core
 from ..HighLevel import prepareArrays, relaxedScan3D
+from ..logging_utils import get_logger
+
+logger = get_logger("generateTraining_PVE")
 
 file_format = "xsf"
 
 parameters = common.PpafmParameters.from_file("params.ini")
 
 if os.path.isfile("atomtypes.ini"):
-    print(">> LOADING LOCAL atomtypes.ini")
+    logger.info(">> LOADING LOCAL atomtypes.ini")
     ff_params = common.loadSpecies("atomtypes.ini")
 else:
     ff_params = common.loadSpecies(cpp_utils.PACKAGE_PATH / "defaults" / "atomtypes.ini")
@@ -32,11 +35,11 @@
 parameters.gridA = lvec_t[1]
 parameters.gridB = lvec_t[2]
 parameters.gridC = lvec_t[3]  # must be before parseAtoms
-print(parameters.gridN, parameters.gridA, parameters.gridB, parameters.gridC)
+logger.debug(parameters.gridN, parameters.gridA, parameters.gridB, parameters.gridC)
 
 force_field, _ = prepareArrays(None, False)
 
-print("FFLJ.shape", force_field.shape)
+logger.debug("FFLJ.shape", force_field.shape)
 core.setFF_shape(np.shape(force_field), lvec_t, parameters=parameters)
 
 base_dir = os.getcwd()
@@ -54,7 +57,6 @@
 
     force_field[:, :, :, :] = 0
     lj_coefficients = common.getAtomsLJ(pp_indexes, izs, ff_params)
-    # print "cLJs",cLJs; np.savetxt("cLJs_3D.dat", cLJs);  exit()
     core.getVdWFF(rs, lj_coefficients)  # THE MAIN STUFF HERE
 
     # Generate Pauli force field.