diff --git a/.gitignore b/.gitignore index 5310c640..d8b5c41e 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,10 @@ dev_tests/ /doc/.LaTeX/Manual.pdf* /doc/.LaTeX/**/*.synctex* /README.html + +# Python cache +__pycache__/ +*.pyc +.ipynb_checkpoints/ +outputs/ +.DS_Store diff --git a/ChangeLog b/ChangeLog index d9d9e1f8..6819c58d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -2,6 +2,13 @@ -Date -Name -changes +-------------- +November 07, 2025 +Name: Qihao Cheng +Changes: utils/pdos/, utils/atom/ +1. Add projected density of states (PDOS) post-processing module, including configuration file, example scripts, and sample outputs. +2. Add atomic utilities and related submodules (mesh, pseudo, scf, xc, etc.) for standalone atomic DFT calculations. + -------------- October 03, 2025 Name: Sayan Bhowmik diff --git a/src/initialization.c b/src/initialization.c index 513bbb7b..82d860d5 100644 --- a/src/initialization.c +++ b/src/initialization.c @@ -3722,7 +3722,7 @@ void write_output_init(SPARC_OBJ *pSPARC) { } fprintf(output_fp,"***************************************************************************\n"); - fprintf(output_fp,"* SPARC (version October 03, 2025) *\n"); + fprintf(output_fp,"* SPARC (version November 07, 2025) *\n"); fprintf(output_fp,"* Copyright (c) 2020 Material Physics & Mechanics Group, Georgia Tech *\n"); fprintf(output_fp,"* Distributed under GNU General Public License 3 (GPL) *\n"); fprintf(output_fp,"* Start time: %s *\n",c_time_str); diff --git a/utils/atom/__init__.py b/utils/atom/__init__.py new file mode 100644 index 00000000..477bb0bb --- /dev/null +++ b/utils/atom/__init__.py @@ -0,0 +1,22 @@ +""" +Atomic DFT Solver Package + +This package provides a comprehensive implementation of Atomic Density Functional Theory +solver using finite element method. + +Main class: + AtomicDFTSolver: Main solver class for atomic DFT calculations + +Example: + >>> from delta.atomic_dft import AtomicDFTSolver + >>> solver = AtomicDFTSolver(atomic_number=13, xc_functional="GGA_PBE") + >>> results = solver.solve() +""" + +__version__ = "0.1.0" + +# Main solver class +from .solver import AtomicDFTSolver + +# Make AtomicDFTSolver easily accessible +__all__ = ["AtomicDFTSolver"] diff --git a/utils/atom/delta/__init__.py b/utils/atom/delta/__init__.py new file mode 100644 index 00000000..ecb6827b --- /dev/null +++ b/utils/atom/delta/__init__.py @@ -0,0 +1 @@ +from .pipeline import DeltaLearningPipeline # noqa: F401 diff --git a/utils/atom/delta/dataset.py b/utils/atom/delta/dataset.py new file mode 100644 index 00000000..54d7a355 --- /dev/null +++ b/utils/atom/delta/dataset.py @@ -0,0 +1,13 @@ +from __future__ import annotations +import numpy as np +from typing import Dict, Any + +def save_delta_npz(path: str, snapshot, ref_v: Dict[str, np.ndarray], other_v: Dict[str, np.ndarray]) -> None: + """Persist Δ-learning data to NPZ.""" + np.savez_compressed( + path, + r=snapshot.r_quad, rho=snapshot.rho, + vx_ref=ref_v.get("vx"), vc_ref=ref_v.get("vc"), + vx_other=other_v.get("vx"), vc_other=other_v.get("vc"), + meta=snapshot.meta + ) diff --git a/utils/atom/delta/pipeline.py b/utils/atom/delta/pipeline.py new file mode 100644 index 00000000..f453bc96 --- /dev/null +++ b/utils/atom/delta/pipeline.py @@ -0,0 +1,12 @@ +from __future__ import annotations +from typing import Tuple, Dict, Any + +class DeltaLearningPipeline: + """High-level Δ-learning pipeline at fixed density snapshots. Placeholder.""" + def __init__(self, solver, xc_evaluator): + self.solver = solver + self.xc_eval = xc_evaluator + + def run_once(self, xc_ref: str, xc_other: str, include_tau: bool = False) -> Tuple[Any, Dict[str, Any], Dict[str, Any], Dict[str, Any]]: + """Return (snapshot, ref_v, other_v, delta).""" + raise NotImplementedError diff --git a/utils/atom/mesh/__init__.py b/utils/atom/mesh/__init__.py new file mode 100644 index 00000000..9f02188f --- /dev/null +++ b/utils/atom/mesh/__init__.py @@ -0,0 +1,2 @@ +from .builder import Quadrature1D, Mesh1D, LagrangeShapeFunctions # noqa: F401 +from .operators import RadialOperatorsBuilder # noqa: F401 diff --git a/utils/atom/mesh/builder.py b/utils/atom/mesh/builder.py new file mode 100644 index 00000000..b7519298 --- /dev/null +++ b/utils/atom/mesh/builder.py @@ -0,0 +1,1024 @@ +from __future__ import annotations +import numpy as np +from typing import Tuple + +# error messages for class Quadrature1D +QUADRATURE_POINT_NUMBER_NOT_INTEGER_ERROR = \ + "quadrature_point_number must be an integer, get {} instead" +QUADRATURE_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR = \ + "quadrature_point_number must be greater than 0, get {} instead" + +# error messages for class Mesh1D +DOMAIN_RADIUS_NOT_FLOAT_ERROR = \ + "domain_radius must be a float, get {} instead" +DOMAIN_RADIUS_NOT_GREATER_THAN_0_ERROR = \ + "domain_radius must be greater than 0, get {} instead" +NUMBER_OF_FINITE_ELEMENTS_NOT_INTEGER_ERROR = \ + "number_of_finite_elements must be an integer, get {} instead" +NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR = \ + "number_of_finite_elements must be greater than 0, get {} instead" +MESH_TYPE_NOT_STRING_ERROR = \ + "mesh_type must be a string, get {} instead" +MESH_TYPE_NOT_IN_VALID_LIST_ERROR = \ + "mesh_type must be in {}, get {} instead" +CLUSTERING_PARAMETER_NOT_FLOAT_ERROR = \ + "clustering_parameter must be a float, get {} instead" +CLUSTERING_PARAMETER_NOT_GREATER_THAN_0_ERROR = \ + "clustering_parameter must be greater than 0, get {} instead" +CLUSTERING_PARAMETER_NOT_NONE_FOR_UNIFORM_MESH_TYPE_WARNING = \ + "Warning: clustering_parameter must be None for uniform mesh type" +EXP_SHIFT_NOT_FLOAT_ERROR = \ + "exp_shift must be a float, get {} instead" +EXP_SHIFT_NEGATIVE_ERROR = \ + "exp_shift must be greater than or equal to 0, get {} instead" +EXP_SHIFT_NOT_NONE_FOR_UNIFORM_AND_POLYNOMIAL_MESH_TYPE_WARNING = \ + "Warning: exp_shift must be None for uniform and polynomial mesh type" + +MESH_NODES_NOT_EQUAL_TO_NUMBER_OF_FINITE_ELEMENTS_PLUS_1_ERROR = \ + "Number of nodes should be equal to number of finite elements + 1, get {} instead" +MESH_WIDTH_NOT_EQUAL_TO_NUMBER_OF_FINITE_ELEMENTS_ERROR = \ + "Number of widths should be equal to number of finite elements, get {} instead" + +BOUNDARIES_NODES_NOT_NUMPY_ARRAY_ERROR = \ + "boundaries_nodes must be a numpy array" +INTERP_NODES_NOT_NUMPY_ARRAY_ERROR = \ + "interp_nodes must be a numpy array" + + +BASE_NODES_NOT_NUMPY_ARRAY_ERROR = \ + "base_nodes must be a numpy array" +BASE_NODES_NOT_1D_ARRAY_ERROR = \ + "base_nodes must be a 1D numpy array" +BASE_NODES_NOT_MONOTONICALLY_INCREASING_OR_DECREASING_ERROR = \ + "base_nodes must be monotonically increasing or decreasing" + +BOUNDARIES_NODES_NOT_MONOTONICALLY_INCREASING_ERROR = \ + "boundaries_nodes must be monotonically increasing" +INTERP_NODES_NOT_MONOTONICALLY_INCREASING_ERROR = \ + "interp_nodes must be monotonically increasing" +INTERP_WEIGHTS_NOT_NUMPY_ARRAY_ERROR = \ + "interp_weights must be a numpy array" + +BOUNDARIES_NODES_NOT_AT_LEAST_2_ERROR = \ + "boundaries_nodes must have length >= 2" +INTERP_NODES_AND_WEIGHTS_NOT_THE_SAME_LENGTH_ERROR = \ + "interp_nodes and interp_weights must have the same length" +INTERP_NODES_NOT_AT_LEAST_1_ERROR = \ + "interp_nodes must have length >= 1" +BOUNDARIES_NODES_NOT_NONDECREASING_ERROR = \ + "boundaries_nodes must be nondecreasing" +INTERP_NODES_NOT_INCLUDE_MINUS_1_AT_LEFT_BOUNDARY_ERROR = \ + "interp_nodes must include -1 at the left boundary" +INTERP_NODES_NOT_INCLUDE_1_AT_RIGHT_BOUNDARY_ERROR = \ + "interp_nodes must include 1 at the right boundary" +GLOBAL_NODES_NOT_EQUAL_TO_EXPECTED_LENGTH_ERROR = \ + "Expected {} nodes, got {} instead" + +FLAT_NOT_NUMPY_ARRAY_ERROR = \ + "flat must be a numpy array, get {} instead" +FLAT_NOT_1D_ARRAY_ERROR = \ + "flat must be a 1D numpy array, get {} instead" +N_ELEM_NOT_INT_ERROR = \ + "n_elem must be an integer, get {} instead" +ENDPOINTS_SHARED_NOT_BOOL_ERROR = \ + "endpoints_shared must be a boolean, get {} instead" +POINTS_PER_ELEM_NOT_INT_ERROR = \ + "points_per_elem must be an integer, get {} instead" +FLAT_NOT_EXPECTED_LENGTH_ENDPOINTS_SHARED_TRUE_ERROR = \ + "flat must have length = n_elem * (m - 1) + m if endpoints_shared = True, get length={}, n_elem={} instead" +FLAT_NOT_EXPECTED_LENGTH_ENDPOINTS_SHARED_FALSE_ERROR = \ + "flat must have length = n_elem * m if endpoints_shared = False, get length={}, n_elem={} instead" + +# error messages for class LagrangeShapeFunctions +X_NODE_NOT_NUMPY_ARRAY_ERROR = \ + "x_node must be a numpy array, get {} instead" +X_NODE_NOT_AT_LEAST_2_ERROR = \ + "x_node must have length >= 2, get {} instead" +X_NODE_NOT_1D_OR_2D_ARRAY_ERROR = \ + "x_node must be a 1D or 2D numpy array, get dimension {} instead" +X_EVAL_NOT_NUMPY_ARRAY_ERROR = \ + "x_eval must be a numpy array, get {} instead" +X_EVAL_NOT_1D_OR_2D_ARRAY_ERROR = \ + "x_eval must be a 1D or 2D numpy array, get dimension {} instead" +X_EVAL_NOT_AT_LEAST_1_ERROR = \ + "x_eval must have length >= 1, get {} instead" +X_NODE_AND_X_EVAL_NOT_THE_SAME_SHAPE_ERROR = \ + "x_node and x_eval must have the same shape, get dimension {} and {} instead" + + + + +class Quadrature1D: + """Factory for Gauss-Legendre / Lobatto nodes and weights on [-1, 1].""" + + @staticmethod + def gauss_legendre(n: int) -> Tuple[np.ndarray, np.ndarray]: + r""" + Gauss-Legendre quadrature with Golub-Welsch algorithm + \int_{-1}^1 f(x) dx ≈ \sum_{i=1}^n w_i f(x_i) + Return nodes (x_i) and weights (w_i) for Gauss-Legendre on [-1,1]. + + Ref: + - https://en.wikipedia.org/wiki/Gauss-Legendre_quadrature + - https://en.wikipedia.org/wiki/Gaussian_quadrature#The_Golub-Welsch_algorithm + + Note: + - Exact for polynomials up to degree 2n-1 + - Does not include the boundaries + """ + assert isinstance(n, int), \ + QUADRATURE_POINT_NUMBER_NOT_INTEGER_ERROR.format(type(n)) + assert n > 0, \ + QUADRATURE_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR.format(n) + + beta = 0.5/np.sqrt(1 - 1 / (2*(np.arange(1,n)))**(2)) + T = np.diag(beta,k=1) + np.diag(beta,k=-1) + nodes, eigvecs = np.linalg.eigh(T,UPLO='L') + index = np.arange(nodes.size) + legendre_weights = 2*(eigvecs[0,index])**2 + return nodes, legendre_weights + + + @staticmethod + def lobatto(n: int, tol: float = 1e-14) -> Tuple[np.ndarray, np.ndarray]: + r""" + Legendre-Gauss-lobatto points with Chebyshev-Lobatto initial guess + \int_{-1}^1 f(x) dx ≈ \sum_{i=1}^n w_i f(x_i) + Return nodes (x_i) and weights (w_i) for Legendre-Gauss-Lobatto on [-1,1]. + + Ref: + - Greg von Winckel (2024). Legende-Gauss-Lobatto nodes and weights + - https://www.mathworks.com/matlabcentral/fileexchange/4775-legende-gauss-lobatto-nodes-and-weights + + Note: + - Exact for polynomials up to degree 2n-3 + - Includes the boundaries + """ + + assert isinstance(n, int), \ + QUADRATURE_POINT_NUMBER_NOT_INTEGER_ERROR.format(type(n)) + assert n > 0, \ + QUADRATURE_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR.format(n) + + # initial guess: Chebyshev–Lobatto + nodes = np.cos(np.pi * np.arange(n+1) / n) + nodes_old = 2*np.ones_like(nodes) + Pvals = np.zeros((n+1, n+1)) + while np.max(np.abs(nodes - nodes_old)) > tol: + nodes_old = nodes + Pvals[0, :] = 1.0 + Pvals[1, :] = nodes + for k in range(2, n+1): + Pvals[k, :] = ((2*k-1)*nodes*Pvals[k-1,:] - (k-1)*Pvals[k-2,:]) / k + nodes = nodes_old - (nodes*Pvals[n,:] - Pvals[n-1,:]) / ((n+1)*Pvals[n,:]) + legendre_weights = 2.0 / (n*(n+1) * (Pvals[n,:]**2)) + return nodes, legendre_weights + + + +class Mesh1D: + """1D radial mesh on [0, 2R] with uniform / polynomial / exponential spacing.""" + + def __init__( + self, + domain_radius : float, # extent of radial domain, in Bohr + finite_elements_num : int, # number of finite elements + mesh_type : str, # 'uniform', 'polynomial', 'exponential' + clustering_param : float | None, # concentration parameter for node distribution + exp_shift : float | None, # shift parameter for exponential distribution + ): + + self.R = float(domain_radius) + self.n_elem = finite_elements_num + self.mesh_type = mesh_type + self.concentration = clustering_param + self.exp_shift = exp_shift + + self.check_initial_parameters() + + + def check_initial_parameters(self): + # domain radius + assert isinstance(self.R, float), \ + DOMAIN_RADIUS_NOT_FLOAT_ERROR.format(type(self.R)) + assert self.R > 0., \ + DOMAIN_RADIUS_NOT_GREATER_THAN_0_ERROR.format(self.R) + + # number of finite elements + assert isinstance(self.n_elem, int), \ + NUMBER_OF_FINITE_ELEMENTS_NOT_INTEGER_ERROR.format(type(self.n_elem)) + assert self.n_elem > 0, \ + NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR.format(self.n_elem) + + # mesh type + assert isinstance(self.mesh_type, str), \ + MESH_TYPE_NOT_STRING_ERROR.format(type(self.mesh_type)) + assert self.mesh_type in ['uniform', 'polynomial', 'exponential'], \ + MESH_TYPE_NOT_IN_VALID_LIST_ERROR.format(['uniform', 'polynomial', 'exponential'], self.mesh_type) + + # clustering parameter + if self.mesh_type in ['polynomial', 'exponential']: + assert isinstance(self.concentration, float), \ + CLUSTERING_PARAMETER_NOT_FLOAT_ERROR.format(type(self.concentration)) + assert self.concentration > 0., \ + CLUSTERING_PARAMETER_NOT_GREATER_THAN_0_ERROR.format(self.concentration) + if self.mesh_type == 'exponential' and self.concentration == 1.0: + raise NotImplementedError("Exponential mesh with concentration 1.0 is not implemented yet, should degrade to uniform mesh") + elif self.mesh_type == 'uniform': + if self.concentration is not None: + print(CLUSTERING_PARAMETER_NOT_NONE_FOR_UNIFORM_MESH_TYPE_WARNING) + else: + raise ValueError("This error should never be raised") + + # exp_shift parameter + if self.mesh_type == 'exponential': + if self.exp_shift is None: + self.exp_shift = 0.0 # default value + assert isinstance(self.exp_shift, float), \ + EXP_SHIFT_NOT_FLOAT_ERROR.format(type(self.exp_shift)) + assert self.exp_shift >= 0., \ + EXP_SHIFT_NEGATIVE_ERROR.format(self.exp_shift) + elif self.mesh_type in ['uniform', 'polynomial']: + if self.exp_shift is not None: + print(EXP_SHIFT_NOT_NONE_FOR_UNIFORM_AND_POLYNOMIAL_MESH_TYPE_WARNING) + else: + raise ValueError("This error should never be raised") + + + def generate_mesh_nodes_and_width(self) -> Tuple[np.ndarray, np.ndarray]: + """ + Generate mesh nodes in [0, 2R] for uniform, polynomial, and exponential distributions. + For polynomial and exponential distributions, the nodes are distributed according to the clustering parameter (s or a) and exp_shift (c). + + Mesh types: + - Uniform + r_i = i * (2R) / n_elem + - Polynomial: + r_i = 2R * (i**s) / (n_elem ** s) + - Exponential: + r_i = c + (2R-c) * (a**(i/(n_elem-1)) - 1) / (a**(n_elem/(n_elem-1)) - 1) + + Returns: + mesh_nodes: array of mesh nodes r in [0, 2R] + mesh_width: array of mesh widths + """ + if self.mesh_type == "uniform": + mesh_nodes = np.linspace(0.0, 2.0 * self.R, self.n_elem + 1) + elif self.mesh_type == "polynomial": + s = float(self.concentration) + mesh_nodes = 2.0 * self.R * (np.arange(self.n_elem+1)**s) / (self.n_elem ** s) + elif self.mesh_type == "exponential": + a = float(self.concentration) + c = float(self.exp_shift) + beta = np.log(a) / (self.n_elem - 1) + alpha = (2.0 * self.R - c) / (np.exp(beta*self.n_elem) - 1.0) + mesh_nodes = c + alpha * (np.exp(beta*np.arange(self.n_elem+1)) - 1.0) + mesh_nodes[0] = 0.0 + mesh_nodes[-1] = 2.0 * self.R + else: + raise ValueError(f"Unknown mesh_type={self.mesh_type}") + + mesh_width = mesh_nodes[1:] - mesh_nodes[:-1] + + assert len(mesh_nodes) == self.n_elem + 1, \ + MESH_NODES_NOT_EQUAL_TO_NUMBER_OF_FINITE_ELEMENTS_PLUS_1_ERROR.format(len(mesh_nodes)) + assert len(mesh_width) == self.n_elem, \ + MESH_WIDTH_NOT_EQUAL_TO_NUMBER_OF_FINITE_ELEMENTS_ERROR.format(len(mesh_width)) + return mesh_nodes, mesh_width + + + @staticmethod + def generate_fe_nodes(boundaries_nodes: np.ndarray, + interp_nodes: np.ndarray) -> np.ndarray: + """ + Map reference nodes from [-1,1] to each physical element [r_i, r_{i+1}], + remove duplicate interface nodes, and return the global FE nodes. + + Parameters + ---------- + boundaries_nodes : np.ndarray, shape (num_elements+1,) + Coordinates of boundaries of finite elements (monotonically increasing or decreasing). + interp_nodes : np.ndarray, shape (poly_order+1,) + Interpolation nodes in [-1,1], e.g. Lobatto nodes. + + Returns + ------- + global_nodes : np.ndarray, shape (num_elements * poly_order + 1,) + Concatenated FE nodes over [0,2R] without duplicate interface nodes. + """ + assert isinstance(boundaries_nodes, np.ndarray), \ + BOUNDARIES_NODES_NOT_NUMPY_ARRAY_ERROR + assert isinstance(interp_nodes, np.ndarray), \ + INTERP_NODES_NOT_NUMPY_ARRAY_ERROR + + # reverse the nodes if the nodes are decreasing + if np.all(np.diff(boundaries_nodes) < 0.0): + boundaries_nodes = boundaries_nodes[::-1] + if np.all(np.diff(interp_nodes) < 0.0): + interp_nodes = interp_nodes[::-1] + + # check if the nodes are monotonically increasing + assert np.all(np.diff(boundaries_nodes) > 0.0), \ + BOUNDARIES_NODES_NOT_MONOTONICALLY_INCREASING_ERROR + assert np.all(np.diff(interp_nodes) > 0.0), \ + INTERP_NODES_NOT_MONOTONICALLY_INCREASING_ERROR + + + # check if interp_nodes includes -1 and 1 at both boundaries + assert np.isclose(interp_nodes[0], -1.0), \ + INTERP_NODES_NOT_INCLUDE_MINUS_1_AT_LEFT_BOUNDARY_ERROR + assert np.isclose(interp_nodes[-1], 1.0), \ + INTERP_NODES_NOT_INCLUDE_1_AT_RIGHT_BOUNDARY_ERROR + + num_elements = boundaries_nodes.size - 1 + poly_order = interp_nodes.size - 1 + + left = boundaries_nodes[:-1] + right = boundaries_nodes[1:] + + # affine map + mapped = 0.5*(right - left)[:, None] * interp_nodes[None, :] \ + + 0.5*(right + left)[:, None] + + global_nodes = mapped.ravel() + + # remove duplicates: last node of each element except the last + remove_idx = np.arange(poly_order, + (poly_order+1)*(num_elements-1)+poly_order, + poly_order+1) + global_nodes = np.delete(global_nodes, remove_idx) + + # sanity check + expected_len = num_elements * poly_order + 1 + assert global_nodes.size == expected_len, \ + GLOBAL_NODES_NOT_EQUAL_TO_EXPECTED_LENGTH_ERROR.format(expected_len, global_nodes.size) + + return global_nodes + + + @staticmethod + def refine_interpolation_nodes(base_nodes: np.ndarray) -> np.ndarray: + """ + Refine interpolation nodes by inserting midpoints between existing nodes + and adding extra midpoints near the two boundaries. + + Parameters + ---------- + base_nodes : np.ndarray + Original interpolation nodes (e.g., Lobatto nodes on [-1,1]). + + Returns + ------- + refined_nodes : np.ndarray + Refined nodes, containing original nodes, all midpoints, + and extra midpoints near the left and right boundaries. + The output is returned in descending order (consistent with some FE codes). + """ + assert isinstance(base_nodes, np.ndarray), \ + BASE_NODES_NOT_NUMPY_ARRAY_ERROR + assert base_nodes.ndim == 1, \ + BASE_NODES_NOT_1D_ARRAY_ERROR + + # reverse the nodes if the nodes are decreasing + monotonically_increasing_flag = True + if np.all(np.diff(base_nodes) < 0.0): + base_nodes = base_nodes[::-1] + monotonically_increasing_flag = False + assert np.all(np.diff(base_nodes) > 0.0), \ + BASE_NODES_NOT_MONOTONICALLY_INCREASING_OR_DECREASING_ERROR + + + # insert midpoints between consecutive nodes + midpoints = base_nodes[:-1] + 0.5*np.diff(base_nodes) + refined_nodes = np.sort(np.concatenate((base_nodes, midpoints))) + + # extra midpoint near left boundary + refined_nodes = np.insert(refined_nodes, 1, 0.5*(refined_nodes[0] + refined_nodes[1])) + + # extra midpoint near right boundary + refined_nodes = np.insert(refined_nodes, len(refined_nodes)-1, 0.5*(refined_nodes[-1] + refined_nodes[-2])) + + # flip to descending order (optional, to match legacy FE codes) + if monotonically_increasing_flag: + refined_nodes = np.flip(refined_nodes) + + return refined_nodes + + + @staticmethod + def map_quadrature_to_physical_elements( + boundaries_nodes : np.ndarray, + interp_nodes : np.ndarray, + interp_weights : np.ndarray, + flatten : bool = True, + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Affine-map Gauss-Legendre (or any reference) quadrature nodes/weights from [-1,1] + to each physical element [x_i, x_{i+1}] and return global points/weights. + + Parameters + ---------- + boundaries_nodes : (N_e+1,) array_like + Monotonically nondecreasing element boundaries [x_0, ..., x_{N_e}]. + interp_nodes : (q,) array_like + Quadrature nodes in [-1,1] on the reference interval. + interp_weights : (q,) array_like + Corresponding quadrature weights on [-1,1]. + flatten : bool, default True + If True, return 1D arrays of length N_e*q (global concatenation). + If False, return 2D arrays of shape (N_e, q) per element. + + Returns + ------- + quad_x : ndarray + Mapped quadrature nodes. Shape (N_e*q,) if flatten else (N_e, q). + quad_w : ndarray + Mapped quadrature weights. Shape (N_e*q,) if flatten else (N_e, q). + + Notes + ----- + Mapping formula for each element [xL, xR]: + x = 0.5*(xR - xL)*xi + 0.5*(xR + xL) + w = 0.5*(xR - xL)*w_ref + """ + assert isinstance(boundaries_nodes, np.ndarray), \ + BOUNDARIES_NODES_NOT_NUMPY_ARRAY_ERROR + assert isinstance(interp_nodes, np.ndarray), \ + INTERP_NODES_NOT_NUMPY_ARRAY_ERROR + assert isinstance(interp_weights, np.ndarray), \ + INTERP_WEIGHTS_NOT_NUMPY_ARRAY_ERROR + + xb = np.asarray(boundaries_nodes, dtype=float).reshape(-1) + xi = np.asarray(interp_nodes, dtype=float).reshape(-1) + wi = np.asarray(interp_weights, dtype=float).reshape(-1) + + # basic checks + assert xb.size >= 2, \ + BOUNDARIES_NODES_NOT_AT_LEAST_2_ERROR + assert xi.size == wi.size, \ + INTERP_NODES_AND_WEIGHTS_NOT_THE_SAME_LENGTH_ERROR + assert xi.size >= 1, \ + INTERP_NODES_NOT_AT_LEAST_1_ERROR + assert np.all(np.diff(xb) >= 0.0), \ + BOUNDARIES_NODES_NOT_NONDECREASING_ERROR + + + Ne = xb.size - 1 + q = xi.size + + xL = xb[:-1] # (Ne,) + xR = xb[1:] # (Ne,) + h = (xR - xL)[:, None] # (Ne,1) + + # map nodes & weights: (Ne,q) + quad_x = 0.5 * h * xi[None, :] + 0.5 * (xR + xL)[:, None] + quad_w = 0.5 * h * wi[None, :] + + if flatten: + return quad_x.reshape(-1), quad_w.reshape(-1) + return quad_x, quad_w + + + @staticmethod + def fe_flat_to_block2d( + flat: np.ndarray, + n_elem: int, + endpoints_shared: bool, + ) -> np.ndarray: + + r""" + Convert a 1D concatenated FE grid into a 2D array of shape (n_elem, m), + where m is the number of points per element. + + Two supported layouts for 'flat': + 1) endpoints_shared=True: + Global array stores unique boundary nodes, so consecutive elements share 1 node. + Expected length: len(flat) = n_elem * (m - 1) + m. + 2) endpoints_shared=False: + Elements are simply stacked; no overlapping boundary nodes. + Expected length: len(flat) = n_elem * m. + + Parameters + ---------- + flat : (L,) 1D ndarray + Concatenated points on the reference line. + n_elem : int + Number of finite elements. + points_per_elem : Optional[int] + Points per element (m). If None, it will be inferred from len(flat), n_elem, + and endpoints_shared (if provided) or by trying both layouts. + endpoints_shared : Optional[bool] + If True/False, use the specified layout. If None, auto-detect by matching lengths. + + Returns + ------- + blocks : (n_elem, m) ndarray + The 2D array where each row corresponds to one element's local grid. + + Examples + -------- + # Example 1: endpoints shared (unique global nodes) + + Suppose each element has m=4 nodes and n_elem=3: + element 0: [0, 1, 2, 3] + element 1: [3, 4, 5, 6] + element 2: [6, 7, 8, 9] + flat1: + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (length = 3*4 - 2 = 10) + blocks1: + [[0, 1, 2, 3], + [3, 4, 5, 6], + [6, 7, 8, 9]] + + # Example 2: endpoints NOT shared (stacked) + Suppose each element has m=4 nodes and n_elem=3: + element 0: [0, 1, 2, 3] + element 1: [4, 5, 6, 7] + element 2: [8, 9,10,11] + flat2: + [0,1,2,3, 4,5,6,7, 8,9,10,11] (length = 3*4 = 12) + blocks2: + [[0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9,10,11]] + """ + + assert isinstance(flat, np.ndarray), \ + FLAT_NOT_NUMPY_ARRAY_ERROR + assert flat.ndim == 1, \ + FLAT_NOT_1D_ARRAY_ERROR + assert isinstance(n_elem, int), \ + N_ELEM_NOT_INT_ERROR + assert isinstance(endpoints_shared, bool), \ + ENDPOINTS_SHARED_NOT_BOOL_ERROR + + + # ---- Construct the (n_elem, m) view/array ---- + if endpoints_shared: + assert (flat.size - 1) % n_elem == 0, \ + FLAT_NOT_EXPECTED_LENGTH_ENDPOINTS_SHARED_TRUE_ERROR.format(flat.size, n_elem) + # Overlapping windows with stride (m-1) + m = (flat.size - 1) // n_elem + 1 + out = np.empty((n_elem, m), dtype=flat.dtype) + for i_elem in range(n_elem): + start = i_elem * (m - 1) + out[i_elem, :] = flat[start : start + m] + return out + + else: + assert flat.size % n_elem == 0, \ + FLAT_NOT_EXPECTED_LENGTH_ENDPOINTS_SHARED_FALSE_ERROR.format(flat.size, n_elem) + # Simple reshape when elements are stacked without overlap + return flat.reshape(n_elem, -1) + + + +class LagrangeShapeFunctions: + """ + Lagrange shape functions (and their derivatives) built from a given set of nodes. + This class replaces the ad-hoc broadcasting logic in + - lagrange_polynomial(...) + - lagrange_polynomial_t_obtain_quantities_uniform_grid(...) + + It supports: + 1) Reference-element evaluation: given reference nodes xj in [-1,1], evaluate Phi,dPhi at xi. + 2) Physical-element evaluation: given element-wise physical nodes rj (Ne,p+1) and eval points re (Ne,n_eval), + evaluate Phi(re), dPhi(re) w.r.t. the physical coordinate r (chain rule handled). + 3) Interpolation to a global uniform grid with per-element selection (returns lag_poly and raw_indexes). + """ + + + + # @classmethod + # def lagrange_basis_and_derivatives(cls, x_node: np.ndarray, x_eval: np.ndarray, atol: float = 1e-12) -> Tuple[np.ndarray, np.ndarray]: + # return cls.lagrange_basis_and_derivatives_old(x_node, x_eval, atol) + + + @staticmethod + def lagrange_basis_and_derivatives(x_node: np.ndarray, x_eval: np.ndarray, atol: float = 1e-12) -> Tuple[np.ndarray, np.ndarray]: + r""" + Compute Lagrange basis values and their first derivatives on each FE element, + fully vectorized over elements, evaluation points, and basis indices. + + Parameters + ---------- + x_node : ndarray, shape (n_elem, n_node) + Element-local nodal coordinates x_j for each element (one row per element). + For an element with polynomial degree p, m = p+1. + x_eval : ndarray, shape (n_elem, n_eval) + Evaluation points on each element (one row per element). + These can be quadrature points or the nodes themselves. + atol : float + Absolute tolerance to decide if an evaluation point exactly coincides + with a node (used to avoid 0/0 and to apply the exact nodal limits). + + + Returns + ------- + L : ndarray, shape (n_elem, n_eval, n_node) + Lagrange basis values. L[i, j, k] = L_k(x_eval_ij) on element i. + dLdx : ndarray, shape (n_elem, n_eval, n_node) + First derivatives of the Lagrange basis. dLdx[i, j, k] = d/dx L_k at x_eval_ij. + + + Mathematics (per element) + ------------------------- + Let nodes be {x_k}_{k=0}^{m-1}, m = n_node. + Barycentric weights: + ω_k = 1 / prod_{t≠k} (x_k - x_t) + + For a non-nodal evaluation point x: + L_k(x) = (ω_k / (x - x_k)) / ( sum_t(ω_t / (x - x_t)) ) + + Derivative at a non-nodal x: + L'_k(x) = L_k(x) * ( sum_t(1/(x - x_t)) - 1/(x - x_k) ) + + For nodal x = x_a, the derivative row equals the a-th row of the + nodal differentiation matrix D, with off-diagonal entries + D[a,b] = (c_a / c_b) / (x_a - x_b), a ≠ b, + where c_k = prod_{t≠k} (x_k - x_t), and diagonal fixed by + D[a,a] = - sum_{b≠a}( D[a,b] ). + + + Notes + ----- + * Uses absolute matching tolerance `atol` with rtol=0 to detect x exactly at nodes. + * Avoids forming large/small products at evaluation points (stable vs. "full-product then divide"). + """ + + # basic checks + assert isinstance(x_node, np.ndarray), \ + X_NODE_NOT_NUMPY_ARRAY_ERROR.format(type(x_node)) + assert isinstance(x_eval, np.ndarray), \ + X_EVAL_NOT_NUMPY_ARRAY_ERROR.format(type(x_eval)) + if x_node.ndim == 1: + x_node = x_node[None, :] + if x_eval.ndim == 1: + x_eval = x_eval[None, :] + assert x_node.ndim == 2, \ + X_NODE_NOT_1D_OR_2D_ARRAY_ERROR.format(x_node.ndim) + assert x_eval.ndim == 2, \ + X_EVAL_NOT_1D_OR_2D_ARRAY_ERROR.format(x_eval.ndim) + assert x_node.shape[0] == x_eval.shape[0], \ + X_NODE_AND_X_EVAL_NOT_THE_SAME_SHAPE_ERROR.format(x_node.shape[0], x_eval.shape[0]) + assert x_node.shape[1] >= 2, \ + X_NODE_NOT_AT_LEAST_2_ERROR.format(x_node.shape[1]) + assert x_eval.shape[1] >= 1, \ + X_EVAL_NOT_AT_LEAST_1_ERROR.format(x_eval.shape[1]) + + # shapes + n_elem, n_node = x_node.shape + n_elem, n_eval = x_eval.shape + + # 1) Precompute barycentric weights: omega = 1 / c, where + # c_k = prod_{t≠k} (x_k - x_t), done per element. + + # diffs_nodes[i, k, t] = x_k - x_t (on element i) + diffs_nodes = x_node[:, :, None] - x_node[:, None, :] # (n_elem, n_node, n_node) + mask_offdiag = ~np.eye(n_node, dtype=bool) # (n_node, n_node) True for a≠b + + # c[i, k] = prod_{t≠k} (x_k - x_t): set diagonal to 1 so the product ignores it + c = np.where(mask_offdiag[None, :, :], diffs_nodes, 1.0).prod(axis=2) # (n_elem, n_node) + omega = 1.0 / c # (n_elem, n_node) + + # 2) Distances from evaluation points to nodes: dx = x - x_k + dx = x_eval[:, :, None] - x_node[:, None, :] # (n_elem, n_eval, n_node) + + # 3) Identify nodal evaluations (x == x_k) using absolute tolerance + is_nodal = np.isclose(x_eval[:, :, None], x_node[:, None, :], atol=atol) # (n_elem, n_eval, n_node) + has_nodal_row = is_nodal.any(axis=2) # (n_elem, n_eval) + + # 4) Basis values at non-nodal points via barycentric formula + # L_k(x) = (omega_k /(x - x_k)) / sum_t (omega_t /(x - x_t)) + with np.errstate(divide='ignore', invalid='ignore'): + inv_dx = 1.0 / dx # (n_elem, n_point, n_node) + numer = omega[:, None, :] * inv_dx # (n_elem, n_point, n_node) + denom = np.sum(numer, axis=2, keepdims=True) # (n_elem, n_point, 1) + L = numer / denom # (n_elem, n_point, n_node) + + # Enforce nodal rows to be exact one-hot (interpolation property) + # First zero out rows that contain nodal matches; then set matching entries to 1. + L = np.where(np.isfinite(L), L, 0.0) + L = np.where(has_nodal_row[:, :, None], 0.0, L) + L = np.where(is_nodal, 1.0, L) + + # 5) Derivatives at non-nodal points: + # L'_k(x) = L_k(x) * ( sum_t 1/(x - x_t) - 1/(x - x_k) ) + with np.errstate(divide='ignore', invalid='ignore'): + harmonic_sum = np.sum(inv_dx, axis=2, keepdims=True) # (n_elem, n_point, 1) + dLdx = L * (harmonic_sum - inv_dx) # (n_elem, n_point, n_node) + + # 6) Nodal differentiation matrix D on the nodes {x_k} (per element) + # Off-diagonal: D[a,b] = (c_a / c_b) / (x_a - x_b) + # Diagonal: D[a,a] = -sum_{b≠a} D[a,b] + with np.errstate(divide='ignore', invalid='ignore'): + D = (c[:, :, None] / c[:, None, :]) / diffs_nodes # (n_elem, n_node, n_node) + D = np.where(mask_offdiag[None, :, :], D, 0.0) + D[..., np.arange(n_node), np.arange(n_node)] = -np.sum(D, axis=2) + + # Overwrite derivative rows where x coincides with a node: + # For each (i, j) with a nodal match, find which node index k* and set dLdx[i, j, :] = D[i, k*, :] + if has_nodal_row.any(): + nodal_index = np.argmax(is_nodal, axis=2) # (n_elem, n_point), argmax is safe since rows with no nodal are masked by has_nodal_row + i_idx, j_idx = np.nonzero(has_nodal_row) # indices of rows to overwrite + k_idx = nodal_index[i_idx, j_idx] + dLdx[i_idx, j_idx, :] = D[i_idx, k_idx, :] + + # 7) Cleanup any residual non-finite entries (should be rare) + L = np.where(np.isfinite(L), L, 0.0) + dLdx = np.where(np.isfinite(dLdx), dLdx, 0.0) + + return L, dLdx + + + + @staticmethod + def lagrange_basis_and_derivatives_old( + x_node: np.ndarray, + x_eval: np.ndarray, + atol: float = 1e-12 + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Old-style algorithm that mirrors the legacy implementation's math: + - build (x - x_k) slabs and take products + - make denominator by (x_k - x_t) with diagonal shifted to 1 + - handle nodal points by replacing invalid numerators with denominators + - assemble derivative via "leave-one-factor-out" product sums + Returns L, dLdx with the same shapes/semantics as the optimized version. + """ + + raise NotImplementedError("This function is now deprecated and will be removed in the future.") + + # --- shape normalization (match new API) --- + # basic checks + assert isinstance(x_node, np.ndarray), \ + X_NODE_NOT_NUMPY_ARRAY_ERROR.format(type(x_node)) + assert isinstance(x_eval, np.ndarray), \ + X_EVAL_NOT_NUMPY_ARRAY_ERROR.format(type(x_eval)) + if x_node.ndim == 1: + x_node = x_node[None, :] + if x_eval.ndim == 1: + x_eval = x_eval[None, :] + assert x_node.ndim == 2, \ + X_NODE_NOT_1D_OR_2D_ARRAY_ERROR.format(x_node.ndim) + assert x_eval.ndim == 2, \ + X_EVAL_NOT_1D_OR_2D_ARRAY_ERROR.format(x_eval.ndim) + assert x_node.shape[0] == x_eval.shape[0], \ + X_NODE_AND_X_EVAL_NOT_THE_SAME_SHAPE_ERROR.format(x_node.shape[0], x_eval.shape[0]) + assert x_node.shape[1] >= 2, \ + X_NODE_NOT_AT_LEAST_2_ERROR.format(x_node.shape[1]) + assert x_eval.shape[1] >= 1, \ + X_EVAL_NOT_AT_LEAST_1_ERROR.format(x_eval.shape[1]) + + # Normalize shapes + if x_node.ndim == 1: + x_node = x_node[None, :] + if x_eval.ndim == 1: + x_eval = x_eval[None, :] + n_elem, n_node = x_node.shape + _, n_eval = x_eval.shape + assert n_node >= 2 and n_eval >= 1, "Need at least 2 nodes and 1 evaluation point." + + # Legacy variable names + init_FE = x_node[:, None, :] # (n_elem, 1, n_node) + int_points = x_eval[:, :, None] # (n_elem, n_eval, 1) + + # (x - x_k) + lp = lambda r, x: r - x + lagr = lp(int_points, init_FE) # (n_elem, n_eval, n_node) + + # Numerator: ∏_t (x - x_t) / (x - x_k) + prod_lagr = np.prod(lagr, axis=2) # (n_elem, n_eval) + one_by_lagr = 1.0 / lagr # (n_elem, n_eval, n_node) + lag_poly_num = prod_lagr[:, :, None] * one_by_lagr # (n_elem, n_eval, n_node) + + # Denominator: ∏_{t≠k} (x_k - x_t), with diagonal set to 1 + diffs_nodes = (np.transpose(init_FE, (0, 2, 1)) - init_FE) # (n_elem, n_node, n_node) + eye = np.eye(n_node)[None, :, :] + lag_poly_d_w_z = diffs_nodes + eye # diagonal -> 1 + lag_poly_d = np.prod(lag_poly_d_w_z, axis=2) # (n_elem, n_node) + lag_poly_den = lag_poly_d[:, None, :] # (n_elem, 1, n_node) + + # Nodal coincidence detection: x ≈ x_k + is_nodal = np.isclose(x_eval[:, :, None], x_node[:, None, :], atol=atol, rtol=0.0) + + # Replace non-finite numerator with denominator (nodal limit => 1) + bad = ~np.isfinite(lag_poly_num) + if np.any(bad): + ii, jj, kk = np.where(bad) + lag_poly_num[ii, jj, kk] = lag_poly_den[ii, 0, kk] + + # Basis values + L = lag_poly_num / lag_poly_den + if np.any(is_nodal): + L = np.where(is_nodal.any(axis=2, keepdims=True), 0.0, L) + L = np.where(is_nodal, 1.0, L) + L = np.where(np.isfinite(L), L, 0.0) + + # ===== Derivative via "leave-one-factor-out" ===== + # lagr_k_t[e, j, k, t] = (x_eval - x_t), replicated along k + lagr_k_t = np.broadcast_to(lagr[:, :, None, :], (n_elem, n_eval, n_node, n_node)) + + # Build per-row indices t ≠ k in a vectorized way + # off_idx[k] = [0,1,...,k-1,k+1,...,n_node-1] + all_idx = np.tile(np.arange(n_node), (n_node, 1)) # (n_node, n_node) + mask = ~np.eye(n_node, dtype=bool) # (n_node, n_node) + off_idx = all_idx[mask].reshape(n_node, n_node - 1) # (n_node, n_node-1) + + # Gather (x - x_t) for all t ≠ k -> shape (n_elem, n_eval, n_node, n_node-1) + lagr_broad_d = np.take_along_axis(lagr_k_t, off_idx[None, None, :, :], axis=3) + + # Replicate numerator along the excluded-factor axis + diff_lag = np.broadcast_to(lag_poly_num[:, :, :, None], + (n_elem, n_eval, n_node, n_node - 1)) + + # Divide and handle nodal-limit fixes + diff_lag_poly_num = diff_lag / lagr_broad_d + + bad_d = ~np.isfinite(diff_lag_poly_num) + if np.any(bad_d): + ii, jj, kk, mm = np.where(bad_d) + tmp = lagr_broad_d.copy() + # Temporarily set the problematic factor to NaN, then multiply the rest + tmp[ii, jj, kk, mm] = np.nan + fill = np.nancumprod(tmp[ii, jj, kk, :], axis=1)[:, -1] # product of remaining factors + # Restore the slot and write back the limit + tmp[ii, jj, kk, mm] = 0.0 + diff_lag_poly_num[ii, jj, kk, mm] = fill + + # Sum over exclusions and divide by denominator + diff_lag_poly_num_sum = np.sum(diff_lag_poly_num, axis=3) # (n_elem, n_eval, n_node) + dLdx = diff_lag_poly_num_sum / lag_poly_den + + # Overwrite nodal rows with the exact nodal differentiation matrix + if np.any(is_nodal): + c = np.prod(np.where(eye.astype(bool), 1.0, diffs_nodes), axis=2) # (n_elem, n_node) + with np.errstate(divide='ignore', invalid='ignore'): + D = (c[:, :, None] / c[:, None, :]) / diffs_nodes + D = np.where(~np.eye(n_node, dtype=bool)[None, :, :], D, 0.0) + D[..., np.arange(n_node), np.arange(n_node)] = -np.sum(D, axis=2) + + nodal_rows = is_nodal.any(axis=2) # (n_elem, n_eval) + if np.any(nodal_rows): + nodal_index = np.argmax(is_nodal, axis=2) + ie, je = np.nonzero(nodal_rows) + ke = nodal_index[ie, je] + dLdx[ie, je, :] = D[ie, ke, :] + + dLdx = np.where(np.isfinite(dLdx), dLdx, 0.0) + + return L, dLdx + + + + @staticmethod + def _barycentric_weights(xj: np.ndarray) -> np.ndarray: + """Compute barycentric weights w_j = 1 / ∏_{m≠j} (x_j - x_m).""" + xj = np.asarray(xj, dtype=float) + n = xj.size + w = np.ones(n, dtype=float) + for j in range(n): + diff = xj[j] - xj + diff[j] = 1.0 # avoid zero + w[j] = 1.0 / np.prod(diff) + return w + + + + + @staticmethod + def _derivative_matrix_at_nodes(xj: np.ndarray, w: np.ndarray) -> np.ndarray: + """ + Derivatives of Lagrange basis evaluated at the nodes: + D[k,j] = φ_j'(x_k) + with φ_j the cardinal basis through xj. Closed form: + for j≠k: D[k,j] = w[j] / ( w[k] * (x_k - x_j) ) + for j=k: D[k,k] = -∑_{m≠k} D[k,m] + """ + xj = np.asarray(xj, dtype=float) + n = xj.size + D = np.empty((n, n), dtype=float) + for k in range(n): + for j in range(n): + if j == k: + continue + D[k, j] = w[j] / (w[k] * (xj[k] - xj[j])) + D[k, k] = -np.sum(D[k, :]) + D[k, k] if np.isfinite(D[k, k]) else -np.sum(D[k, :]) + return D + + + +class RPAFrequencyGrid: + """ + Frequency integration grid for RPA correlation energy calculations. + + Transforms Gauss-Legendre quadrature from [-1,1] to [0, \infty) for imaginary + frequency integration required in RPA: + E_c^RPA = \int_0^\infty f(ω) dω + + Reference: https://journals.aps.org/prl/supplemental/10.1103/PhysRevLett.134.016402/scrpa4_SM.pdf + """ + + def __init__( + self, + n_frequency_points: int, + frequency_scale: float = 2.5 + ): + """ + Initialize RPA frequency grid generator. + + Parameters + ---------- + n_frequency_points : int + Number of frequency integration points (q_omega) + frequency_scale : float + Transformation scale parameter (default 2.5) + """ + self.n_frequency_points = n_frequency_points + self.frequency_scale = frequency_scale + + # Generate main frequency grid + self.omega_points, self.omega_weights = self._generate_main_grid() + + + def _generate_main_grid(self) -> Tuple[np.ndarray, np.ndarray]: + """ + Generate main frequency grid [0, ∞). + + Transformation: ω = scale * (1+ξ)/(1-ξ), ξ ∈ [-1,1] + Jacobian: dω/dξ = 2*scale/(1-ξ)² + """ + # Get Gauss-Legendre nodes on reference interval [-1, 1] + reference_nodes, reference_weights = Quadrature1D.gauss_legendre(self.n_frequency_points) + + # Transform to semi-infinite interval [0, ∞) + omega_points = self.frequency_scale * (1 + reference_nodes) / (1 - reference_nodes) + + # Apply Jacobian transformation to weights + jacobian = 2 * self.frequency_scale / (1 - reference_nodes)**2 + omega_weights = reference_weights * jacobian + + return omega_points, omega_weights + + + def generate_smoothing_grid(self, + n_smoothing_points: int, + smoothing_cutoff: float + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Generate low-frequency smoothing grid [0, cutoff]. + + Parameters + ---------- + n_smoothing_points : int + Number of smoothing points (q_smoothening) + smoothing_cutoff : float + Cutoff frequency (f_c_smoothening) + + Returns + ------- + r_quad_smoothening : np.ndarray + Smoothing frequency points + w_smoothening : np.ndarray + Smoothing frequency weights + """ + # Get Gauss-Legendre nodes on reference interval [-1, 1] + reference_nodes, reference_weights = Quadrature1D.gauss_legendre(n_smoothing_points) + + # Linear transformation: [-1,1] → [0, cutoff] + # f = cutoff * (ξ + 1) / 2 + smoothing_frequency_points = smoothing_cutoff * (reference_nodes + 1) / 2 + + # Scale weights by interval length + smoothing_frequency_weights = reference_weights * (smoothing_cutoff / 2) + + return smoothing_frequency_points, smoothing_frequency_weights + + + def get_frequency_grid(self) -> Tuple[np.ndarray, np.ndarray]: + """ + Get main frequency integration grid. + + Returns + ------- + r_quad_omega : np.ndarray + Frequency points + w_omega : np.ndarray + Frequency weights + """ + return self.omega_points, self.omega_weights + + + +if __name__ == "__main__": + # nodes, legendre_weights = Quadrature1D.gauss_legendre(95) + # print("legendre_weights: \n", legendre_weights) + # print("nodes: \n", nodes) + + + + print(Mesh1D.map_quadrature_to_physical_elements( + boundaries_nodes=np.array([0.0, 1.0, 2.0, 3.0]), + interp_nodes=np.array([-1.0, 0.0, 1.0]), + interp_weights=np.array([1.0, 1.0, 1.0]))) + pass \ No newline at end of file diff --git a/utils/atom/mesh/grid_distribution.png b/utils/atom/mesh/grid_distribution.png new file mode 100644 index 00000000..e970c7c4 Binary files /dev/null and b/utils/atom/mesh/grid_distribution.png differ diff --git a/utils/atom/mesh/operators.py b/utils/atom/mesh/operators.py new file mode 100644 index 00000000..aa66a1ae --- /dev/null +++ b/utils/atom/mesh/operators.py @@ -0,0 +1,1118 @@ +from __future__ import annotations +import numpy as np +from typing import Dict, Any, Optional, Tuple +from .builder import LagrangeShapeFunctions, Mesh1D +from dataclasses import dataclass + + + +# Error messages +NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR = \ + "parameter number_of_finite_elements must be greater than 0, get {} instead" +PHYSICAL_NODES_NOT_1D_ARRAY_ERROR = \ + "parameter physical_nodes must be a 1D array" +QUADRATURE_NODES_NOT_1D_ARRAY_ERROR = \ + "parameter quadrature_nodes must be a 1D array" +QUADRATURE_WEIGHTS_NOT_1D_ARRAY_ERROR = \ + "parameter quadrature_weights must be a 1D array" +QUADRATURE_NODES_AND_WEIGHTS_NOT_THE_SAME_LENGTH_ERROR = \ + "parameter quadrature_nodes and quadrature_weights must have the same length" +Z_NUCLEAR_NOT_FLOAT_ERROR = \ + "parameter z_nuclear must be a float, get {} instead" +ALL_ELECTRON_FLAG_NOT_PROVIDED_ERROR = \ + "parameter all_electron_flag must be provided" +V_LOCAL_COMPONENT_PSP_NOT_NP_NDARRAY_ERROR = \ + "parameter v_local_component_psp must be a numpy array, get {} instead" +V_LOCAL_COMPONENT_PSP_NOT_THE_SAME_SIZE_AS_QUADRATURE_NODES_ERROR = \ + "parameter v_local_component_psp must have the same size as quadrature_nodes, get {} and {} instead" +POTENTIAL_VALUES_DO_NOT_MATCH_QUADRATURE_NODES_ERROR = \ + "parameter potential_values shape {} does not match quadrature_nodes shape {}" +POTENTIAL_VALUES_DO_NOT_MATCH_NUMBER_OF_FINITE_ELEMENTS_ERROR = \ + "parameter potential_values shape {} does not match number_of_finite_elements shape {}" +POTENTIAL_VALUES_DO_NOT_MATCH_QUADRATURE_NODE_NUMBER_ERROR = \ + "parameter potential_values shape {} does not match quadrature_node_number shape {}" +POTENTIAL_VALUES_NDIM_ERROR = \ + "parameter potential_values must be a 1D or 2D array, get dimension {} instead" + +RHO_TYPE_ERROR_MESSAGE = \ + "parameter rho must be a numpy array, get type {} instead" +RHO_NDIM_ERROR_MESSAGE = \ + "parameter rho must be a 1D array, get dimension {} instead" +RHO_SHAPE_ERROR_MESSAGE = \ + "parameter rho shape {} does not match quadrature_node_number shape {}" + +DE_XC_DTAU_SHAPE_ERROR_MESSAGE = \ + "parameter de_xc_dtau shape {} does not match quadrature_node_number shape {}" +DE_XC_DTAU_NDIM_ERROR = \ + "parameter de_xc_dtau must be 1D or 2D array, got {}D instead" + +GIVEN_GRID_NOT_MONOTONICALLY_INCREASING_ERROR = \ + "The given grid must be monotonically increasing" +GIVEN_GRID_NOT_WITHIN_PHYSICAL_NODES_ERROR = \ + "The given grid must be within the physical nodes" +ORBITAL_NDIM_ERROR_MESSAGE = \ + "parameter orbital must be a 1D array, get dimension {} instead" +ORBITAL_SHAPE_ERROR_MESSAGE = \ + "parameter orbital shape {} does not match number_of_finite_elements * physical_node_number shape {}" + + +# Warning messages +V_LOCAL_COMPONENT_PSP_NOT_USED_IN_ALL_ELECTRON_CALCULATIONS_WARNING = \ + "WARNING: v_local_component_psp is not used in all-electron calculations" +Z_NUCLEAR_NOT_USED_IN_NON_ALL_ELECTRON_CALCULATIONS_WARNING = \ + "WARNING: z_nuclear is not used in non-all-electron calculations" +NUMBER_OF_FINITE_ELEMENTS_NOT_USED_WHEN_USING_GRID_DATA_WARNING = \ + "WARNING: number_of_finite_elements is not used when using GridData" +PHYSICAL_NODES_NOT_USED_WHEN_USING_GRID_DATA_WARNING = \ + "WARNING: physical_nodes is not used when using GridData" +QUADRATURE_NODES_NOT_USED_WHEN_USING_GRID_DATA_WARNING = \ + "WARNING: quadrature_nodes is not used when using GridData" +QUADRATURE_WEIGHTS_NOT_USED_WHEN_USING_GRID_DATA_WARNING = \ + "WARNING: quadrature_weights is not used when using GridData" + + + +@dataclass(frozen=True) +class GridData: + """ + Immutable grid information needed for XC calculations. + + Attributes + ---------- + r_quad : np.ndarray + Radial quadrature points + w_quad : np.ndarray + Quadrature weights + derivative_matrix : np.ndarray + Matrix for computing derivatives at quadrature points + Shape: (n_elem, n_quad, n_quad) + n_elem : int + Number of finite elements + n_quad_per_elem : int + Number of quadrature points per element + """ + number_of_finite_elements: int + physical_nodes : np.ndarray + quadrature_nodes : np.ndarray + quadrature_weights : np.ndarray + + + def __post_init__(self): + # check if the input parameters are valid + assert self.number_of_finite_elements > 0, \ + NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR.format(self.number_of_finite_elements) + assert self.physical_nodes.ndim == 1, \ + PHYSICAL_NODES_NOT_1D_ARRAY_ERROR + assert self.quadrature_nodes.ndim == 1, \ + QUADRATURE_NODES_NOT_1D_ARRAY_ERROR + assert self.quadrature_weights.ndim == 1, \ + QUADRATURE_WEIGHTS_NOT_1D_ARRAY_ERROR + assert self.quadrature_nodes.shape[0] == self.quadrature_weights.shape[0], \ + QUADRATURE_NODES_AND_WEIGHTS_NOT_THE_SAME_LENGTH_ERROR + + + + +class RadialOperatorsBuilder: + """ + Assemble radial FE operators and interpolation matrices. + + Can be initialized either from individual parameters or from GridData. + """ + + def __init__(self, + number_of_finite_elements : Optional[int] = None, + physical_nodes : Optional[np.ndarray] = None, + quadrature_nodes : Optional[np.ndarray] = None, + quadrature_weights : Optional[np.ndarray] = None, + grid_data : Optional[GridData] = None, + verbose : bool = False, + ): + """ + Initialize radial operators builder. + + Two initialization modes: + + Mode 1 - From individual parameters: + number_of_finite_elements, physical_nodes, quadrature_nodes, quadrature_weights + + Mode 2 - From GridData (preferred): + grid_data (contains all the above) + + Parameters + ---------- + grid_data : GridData, optional + Grid data object (preferred way) + number_of_finite_elements : int, optional + Number of finite elements (legacy way) + physical_nodes : np.ndarray, optional + Physical FE nodes (legacy way) + quadrature_nodes : np.ndarray, optional + Quadrature points (legacy way) + quadrature_weights : np.ndarray, optional + Quadrature weights (legacy way) + """ + # Extract parameters from GridData or use individual parameters + if grid_data is not None: + # Mode 2: Use GridData (preferred) + self.number_of_finite_elements = grid_data.number_of_finite_elements + self.physical_nodes = grid_data.physical_nodes + self.quadrature_nodes = grid_data.quadrature_nodes + self.quadrature_weights = grid_data.quadrature_weights + + # if other parameters are provided, they will be ignored, and a warning will be printed + if number_of_finite_elements is not None: + print(NUMBER_OF_FINITE_ELEMENTS_NOT_USED_WHEN_USING_GRID_DATA_WARNING) + if physical_nodes is not None: + print(PHYSICAL_NODES_NOT_USED_WHEN_USING_GRID_DATA_WARNING) + if quadrature_nodes is not None: + print(QUADRATURE_NODES_NOT_USED_WHEN_USING_GRID_DATA_WARNING) + if quadrature_weights is not None: + print(QUADRATURE_WEIGHTS_NOT_USED_WHEN_USING_GRID_DATA_WARNING) + else: + # Mode 1: Use individual parameters (legacy) + assert number_of_finite_elements is not None, \ + "number_of_finite_elements required" + assert physical_nodes is not None, \ + "physical_nodes required" + assert quadrature_nodes is not None, \ + "quadrature_nodes required" + assert quadrature_weights is not None, \ + "quadrature_weights required" + + # Validation + assert physical_nodes.ndim == 1, \ + PHYSICAL_NODES_NOT_1D_ARRAY_ERROR + assert quadrature_nodes.ndim == 1, \ + QUADRATURE_NODES_NOT_1D_ARRAY_ERROR + assert quadrature_weights.ndim == 1, \ + QUADRATURE_WEIGHTS_NOT_1D_ARRAY_ERROR + assert quadrature_nodes.shape[0] == quadrature_weights.shape[0], \ + QUADRATURE_NODES_AND_WEIGHTS_NOT_THE_SAME_LENGTH_ERROR + + self.number_of_finite_elements = number_of_finite_elements + self.physical_nodes = physical_nodes + self.quadrature_nodes = quadrature_nodes + self.quadrature_weights = quadrature_weights + + + + # Store verbose flag + self.verbose = verbose + + # Reshape to element-wise structure + self._reshape_grid_data() + + # Compute Lagrange basis functions + self._compute_basis_functions() + + # Print summary if verbose + if self.verbose: + self._print_initialization_summary() + + + def _reshape_grid_data(self): + """Reshape 1D arrays to (n_elem, n_points) structure.""" + self.physical_nodes_reshaped = Mesh1D.fe_flat_to_block2d( + self.physical_nodes, + self.number_of_finite_elements, + endpoints_shared=True + ) + self.quadrature_nodes_reshaped = Mesh1D.fe_flat_to_block2d( + self.quadrature_nodes, + self.number_of_finite_elements, + endpoints_shared=False + ) + self.quadrature_weights_reshaped = Mesh1D.fe_flat_to_block2d( + self.quadrature_weights, + self.number_of_finite_elements, + endpoints_shared=False + ) + + self.physical_node_number = self.physical_nodes_reshaped.shape[1] + self.quadrature_node_number = self.quadrature_nodes_reshaped.shape[1] + + + def _compute_basis_functions(self): + """Compute Lagrange basis functions and derivatives.""" + self.lagrange_basis, self.lagrange_basis_derivatives = \ + LagrangeShapeFunctions.lagrange_basis_and_derivatives( + x_node=self.physical_nodes_reshaped, + x_eval=self.quadrature_nodes_reshaped + ) + # Shape: (n_elem, n_quad, n_basis) + + + def _print_initialization_summary(self): + """Print initialization summary.""" + print("=" * 60) + print("\t\t RadialOperatorsBuilder") + print("=" * 60) + print(f"\t Number of elements : {self.number_of_finite_elements}") + print(f"\t Physical nodes per element : {self.physical_nodes_reshaped.shape[1]}") + print(f"\t Quadrature points per element : {self.quadrature_node_number}") + print(f"\t Total DOFs : {self.number_of_finite_elements * self.physical_node_number + 1}") + print(f"\t Total quadrature points : {len(self.quadrature_nodes)}") + print(f"\t Lagrange basis shape : {self.lagrange_basis.shape}") + print(f"\t Lagrange derivatives shape : {self.lagrange_basis_derivatives.shape}") + print() + + + @classmethod + def from_grid_data(cls, grid_data: GridData, verbose: bool = False) -> 'RadialOperatorsBuilder': + """ + Create RadialOperatorsBuilder from GridData. + + Convenience factory method for cleaner code. + + Parameters + ---------- + grid_data : GridData + Grid data object + verbose : bool, optional + If True, print initialization summary + Default: False + + Returns + ------- + RadialOperatorsBuilder + Initialized operators builder + + Example + ------- + >>> grid_data = GridData(...) + >>> ops = RadialOperatorsBuilder.from_grid_data(grid_data, verbose=True) + """ + return cls(grid_data=grid_data, verbose=verbose) + + + def get_H_kinetic(self) -> np.ndarray: + """ + Kinetic energy matrix + """ + # check if the kinetic energy matrix has been computed + if hasattr(self, "_H_kinetic"): + return self._H_kinetic + + # compute the kinetic energy matrix + H_kinetic = - 0.5 * self.get_laplacian() + + # store the kinetic energy matrix + self._H_kinetic = H_kinetic + + return H_kinetic + + + def get_laplacian(self) -> np.ndarray: + """ + Laplacian matrix + """ + # check if the Laplacian matrix has been computed + if hasattr(self, "_laplacian"): + return self._laplacian + + # compute the Laplacian matrix + laplacian_local = - np.einsum("emi,emk,em->eik", + self.lagrange_basis_derivatives, + self.lagrange_basis_derivatives, + self.quadrature_weights_reshaped, + optimize=True) + + # Assemble local matrices into global matrix + laplacian = self._assemble_local_to_global_matrix(laplacian_local) + + # store the Laplacian matrix + self._laplacian = laplacian + + return laplacian + + + def build_potential_matrix(self, potential_values: np.ndarray) -> np.ndarray: + """ + Construct Hamiltonian matrix from potential energy values at quadrature points. + + This is a general-purpose matrix builder that can be used for any potential: + - Nuclear Coulomb potential: V(r) = -Z/r + - Local pseudopotential: V_loc(r) + - Hartree potential: V_H(r) + - Exchange-correlation potential: V_xc(r) + + Theory + ------ + Given potential V(r) sampled at quadrature points, compute: + H_V[i,j] = ∫ φ_i(r) V(r) φ_j(r) dr + + Using finite element basis φ and Gauss quadrature. + + Parameters + ---------- + potential_values : np.ndarray + Potential energy values at quadrature points. + Can be 1D (flat, length = n_elem * n_quad) or + 2D (reshaped, shape = (n_elem, n_quad)) + + Returns + ------- + H_potential : np.ndarray + Assembled global Hamiltonian matrix contribution from this potential. + Shape: (n_global_dofs, n_global_dofs) + + Examples + -------- + >>> # Nuclear Coulomb potential + >>> V_nuc = -Z / ops.quadrature_nodes + >>> H_nuc = ops.build_potential_matrix(V_nuc) + + >>> # XC potential + >>> V_xc = compute_xc_potential(rho) + >>> H_xc = ops.build_potential_matrix(V_xc) + """ + # Reshape potential if needed + if potential_values.ndim == 1: + assert potential_values.size == self.quadrature_nodes_reshaped.size, \ + POTENTIAL_VALUES_DO_NOT_MATCH_QUADRATURE_NODES_ERROR.format(potential_values.size, self.quadrature_nodes_reshaped.size) + potential_reshaped = potential_values.reshape(self.quadrature_nodes_reshaped.shape) + elif potential_values.ndim == 2: + assert potential_values.shape[0] == self.number_of_finite_elements, \ + POTENTIAL_VALUES_DO_NOT_MATCH_NUMBER_OF_FINITE_ELEMENTS_ERROR.format(potential_values.shape[0], self.number_of_finite_elements) + assert potential_values.shape[1] == self.quadrature_node_number, \ + POTENTIAL_VALUES_DO_NOT_MATCH_QUADRATURE_NODE_NUMBER_ERROR.format(potential_values.shape[1], self.quadrature_node_number) + potential_reshaped = potential_values + else: + raise ValueError(POTENTIAL_VALUES_NDIM_ERROR.format(potential_values.ndim)) + + # Compute local element matrices: H^e[i,k] = ∫ φ_i V φ_k dr + H_local = np.einsum("emi,emk,em,em->eik", + self.lagrange_basis, # φ_i at quadrature points + self.lagrange_basis, # φ_k at quadrature points + self.quadrature_weights_reshaped, # quadrature weights + potential_reshaped, # V(r) at quadrature points + optimize=True) + + # Assemble local matrices into global matrix + H_potential = self._assemble_local_to_global_matrix(H_local) + + return H_potential + + + def build_metagga_kinetic_density_matrix(self, de_xc_dtau: np.ndarray) -> np.ndarray: + """ + Construct Hamiltonian matrix from meta-GGA kinetic density term at quadrature points. + + This implements the meta-GGA contribution to the Hamiltonian: + H_metagga[i,j] = ∫ φ'_i * (0.5 * de_xc_dtau) * φ'_j dr + + ∫ φ_i * (0.5 * w/r * d(de_xc_dtau)/dr) * φ_j dr + + Theory + ------ + For meta-GGA functionals, the kinetic energy density τ contributes additional + terms to the Hamiltonian. The implementation follows: + V3 = de_xc_dtau + V3grad = d(V3)/dr (computed via derivative matrix) + + Term 1: ∫ φ'_i * (0.5 * V3 * w) * φ'_j dr + Term 2: ∫ φ_i * (0.5 * w/r * V3grad) * φ_j dr + + Parameters + ---------- + de_xc_dtau : np.ndarray + Derivative of XC energy density w.r.t. kinetic energy density τ. + Can be 1D (flat, length = n_elem * n_quad) or + 2D (reshaped, shape = (n_elem, n_quad)) + + Returns + ------- + H_metagga : np.ndarray + Assembled global Hamiltonian matrix contribution from meta-GGA kinetic density term. + Shape: (n_global_dofs, n_global_dofs) + """ + # Reshape de_xc_dtau if needed + if de_xc_dtau.ndim == 1: + assert de_xc_dtau.size == self.quadrature_nodes_reshaped.size, \ + DE_XC_DTAU_SHAPE_ERROR_MESSAGE.format(de_xc_dtau.size, self.quadrature_nodes_reshaped.size) + de_xc_dtau_reshaped = de_xc_dtau.reshape(self.quadrature_nodes_reshaped.shape) + elif de_xc_dtau.ndim == 2: + assert de_xc_dtau.shape[0] == self.number_of_finite_elements, \ + DE_XC_DTAU_SHAPE_ERROR_MESSAGE.format(de_xc_dtau.shape[0], self.number_of_finite_elements) + assert de_xc_dtau.shape[1] == self.quadrature_node_number, \ + DE_XC_DTAU_SHAPE_ERROR_MESSAGE.format(de_xc_dtau.shape[1], self.quadrature_node_number) + de_xc_dtau_reshaped = de_xc_dtau + else: + raise ValueError(DE_XC_DTAU_NDIM_ERROR.format(de_xc_dtau.ndim)) + + # Get derivative matrix for computing d(de_xc_dtau)/dr + D = self.get_derivative_matrix() # Shape: (n_elem, n_quad, n_quad) + + # Compute gradient: v3grad = D @ de_xc_dtau (element-wise) + # For each element: v3grad[e, i] = sum_k D[e, i, k] * de_xc_dtau[e, k] + de_xc_dtau_grad = np.einsum("eik,ek->ei", D, de_xc_dtau_reshaped) + + # Term 1: ∫ φ'_i * (0.5 * de_xc_dtau * w) * φ'_j dr + # Using derivative basis functions + H_term1_local = np.einsum("emi,emk,em,em->eik", + self.lagrange_basis_derivatives, # φ'_i + self.lagrange_basis_derivatives, # φ'_j + self.quadrature_weights_reshaped, # w + 0.5 * de_xc_dtau_reshaped, # 0.5 * de_xc_dtau + optimize=True) + + # Term 2: ∫ φ_i * (0.5 * w/r * d(de_xc_dtau)/dr) * φ_j dr + # Using regular basis functions + # Note: 0.5 * w / r * v3grad + weight_over_r = 0.5 * self.quadrature_weights_reshaped / self.quadrature_nodes_reshaped + H_term2_local = np.einsum("emi,emk,em,em->eik", + self.lagrange_basis, # φ_i + self.lagrange_basis, # φ_j + weight_over_r, # 0.5 * w / r + de_xc_dtau_grad, # d(de_xc_dtau)/dr + optimize=True) + + # Combine both terms + H_metagga_local = H_term1_local + H_term2_local + + # Assemble local matrices into global matrix + H_metagga = self._assemble_local_to_global_matrix(H_metagga_local) + + return H_metagga + + + + + def get_nuclear_coulomb_potential(self, z_nuclear: float) -> np.ndarray: + """ + Compute nuclear Coulomb potential: V_nuc(r) = -Z/r + + Parameters + ---------- + z_nuclear : float + Nuclear charge (atomic number for all-electron, or effective charge) + + Returns + ------- + V_nuclear : np.ndarray + Nuclear Coulomb potential at quadrature points. + Shape: (n_elem * n_quad,) flat array + + Notes + ----- + For all-electron calculations, z_nuclear is the atomic number Z. + The negative sign accounts for attractive electron-nucleus interaction. + """ + try: + z_nuclear = float(z_nuclear) + except: + raise ValueError(Z_NUCLEAR_NOT_FLOAT_ERROR.format(type(z_nuclear))) + + # V_nuc(r) = -Z/r at all quadrature points + V_nuclear = -z_nuclear / self.quadrature_nodes + + return V_nuclear + + + def get_H_r_inv_sq(self) -> np.ndarray: + """ + Inverse square of the radial distance matrix + """ + # check if the inverse square of the radial distance matrix has been computed + if hasattr(self, "_H_r_inv_sq"): + return self._H_r_inv_sq + + # compute the inverse square of the radial distance matrix + H_r_inv_sq_local = np.einsum("emi,emk,em,em->eik", + self.lagrange_basis, + self.lagrange_basis, + self.quadrature_weights_reshaped, + 1.0 / self.quadrature_nodes_reshaped**2, + optimize=True) + + # Assemble local matrices into global matrix + H_r_inv_sq = self._assemble_local_to_global_matrix(H_r_inv_sq_local) + + # store the inverse square of the radial distance matrix + self._H_r_inv_sq = H_r_inv_sq + + return H_r_inv_sq + + + def get_S(self) -> np.ndarray: + """ + Overlap matrix S + """ + # check if the overlap matrix has been computed + if hasattr(self, "_S"): + return self._S + + # compute the overlap matrix + S_local = np.einsum("emi,emk,em->eik", + self.lagrange_basis, + self.lagrange_basis, + self.quadrature_weights_reshaped, + optimize=True) + + # Assemble local matrices into global matrix + S = self._assemble_local_to_global_matrix(S_local) + + # store the overlap matrix + self._S = S + + return S + + + def get_S_inv_sqrt(self) -> np.ndarray: + """ + Inverse square root of the overlap matrix: S^(-1/2) + Computed via eigendecomposition: S^(-1/2) = V * Λ^(-1/2) * V^T + """ + if hasattr(self, "_S_inv_sqrt"): + return self._S_inv_sqrt + + S = self.get_S() + eigvals, eigvecs = np.linalg.eigh(S, UPLO='L') + S_inv_sqrt = eigvecs @ np.diag(1.0 / np.sqrt(eigvals)) @ eigvecs.T + S_inv_sqrt = 0.5 * (S_inv_sqrt + S_inv_sqrt.T) # Symmetrize + + self._S_inv_sqrt = S_inv_sqrt + return S_inv_sqrt + + + def get_derivative_matrix(self) -> np.ndarray: + """ + Differentiation matrix for computing derivatives at quadrature points. + + This matrix D enables direct computation of derivatives from function values: + f'(x_quad) = D @ f(x_quad) + + Theory: + ------- + For a function f(x) = sum_j c_j φ_j(x) in the FE space, + we have f' = (dL/dx) @ L⁺ @ f, where: + - L[i,j] = φ_j(x_quad_i) : basis functions at quadrature points + - L⁺ : pseudoinverse of L (maps function values -> coefficients) + - dL/dx[i,j] = φ'_j(x_quad_i) : basis derivatives at quadrature points + + Returns + ------- + np.ndarray + Shape: (n_elements, n_quad_points, n_quad_points) + D[e, i, k] maps f(x_k) → f'(x_i) within element e + """ + if hasattr(self, "_derivative_matrix"): + return self._derivative_matrix + + # Compute pseudoinverse of Lagrange basis: L⁺ maps values → coefficients + # Shape: (n_elem, n_basis, n_quad) where n_basis = physical_node_number + n_elem = self.number_of_finite_elements + n_basis = self.physical_node_number + n_quad = self.quadrature_node_number + + basis_pseudoinverse = np.zeros((n_elem, n_basis, n_quad)) + for elem_idx in range(n_elem): + # self.lagrange_basis[elem_idx] has shape (n_quad, n_basis) + basis_pseudoinverse[elem_idx] = np.linalg.pinv(self.lagrange_basis[elem_idx]) + + # Differentiation matrix: D = (dL/dx) @ L⁺ + # Maps function values at quadrature points to derivative values + derivative_matrix = np.matmul(self.lagrange_basis_derivatives, basis_pseudoinverse) + + self._derivative_matrix = derivative_matrix + return derivative_matrix + + + def get_global_interpolation_matrix(self) -> np.ndarray: + """ + Global interpolation matrix for evaluating functions at quadrature points. + + This matrix maps global nodal coefficients to function values at all quadrature points: + f(x_quad) = interpolation_matrix @ f_nodal + + Theory + ------ + For a function f(x) represented by nodal values on the global FE grid, + this matrix evaluates f at all quadrature points across all elements. + + Unlike _assemble_local_to_global_matrix (which accumulates contributions), + this constructs a rectangular interpolation matrix by: + 1. Placing local Lagrange basis matrices in block-diagonal form + 2. Merging columns corresponding to shared boundary nodes + 3. Removing duplicate columns + + Returns + ------- + np.ndarray + Shape: (n_elements * n_quad_points, n_global_nodes) + where n_global_nodes = n_elements * polynomial_order + 1 + + Example: n_elem=17, p=31, n_quad=95 → shape (1615, 528) + + Usage + ----- + Essential for Hartree-Fock exchange (HF, PBE0) where orbital overlaps + must be computed at quadrature points: + psi_i(x_quad) = interp_matrix @ psi_i_nodal + + Not needed for LDA, GGA, or meta-GGA functionals. + """ + if hasattr(self, "_global_interpolation_matrix"): + return self._global_interpolation_matrix + + n_elem = self.number_of_finite_elements + n_quad = self.quadrature_node_number + n_local = self.physical_node_number + n_global = n_elem * (self.physical_node_number - 1) + 1 + + # Method: Build block-diagonal then remove duplicate columns + # Alternative could use fancy indexing, but this is clearer + + # Reshape lagrange_basis from (n_elem, n_quad, n_local) to 2D blocks + # Result shape: (n_elem * n_quad, n_elem * n_local) + interp_matrix = np.zeros((n_elem * n_quad, n_elem * n_local)) + + for elem_idx in range(n_elem): + row_slice = slice(elem_idx * n_quad, (elem_idx + 1) * n_quad) + col_slice = slice(elem_idx * n_local, (elem_idx + 1) * n_local) + interp_matrix[row_slice, col_slice] = self.lagrange_basis[elem_idx] + + # Shared boundary nodes: right edge of each element (except last) + # These correspond to duplicate columns that must be merged + shared_cols = np.array([n_local * (i + 1) - 1 for i in range(n_elem - 1)]) + + # Merge: add right neighbor column to left neighbor column + interp_matrix[:, shared_cols] += interp_matrix[:, shared_cols + 1] + + # Remove duplicate columns + interp_matrix = np.delete(interp_matrix, shared_cols + 1, axis=1) + + assert interp_matrix.shape == (n_elem * n_quad, n_global), \ + f"Shape mismatch: expected {(n_elem * n_quad, n_global)}, got {interp_matrix.shape}" + + self._global_interpolation_matrix = interp_matrix + return interp_matrix + + + def assemble_poisson_rhs_vector(self, rho: np.ndarray, z_nuclear: float) -> np.ndarray: + """ + Assemble the right-hand side vector for the Poisson equation. + + Computes the RHS vector for solving d²u/dr² = -4πrρ(r) where u = rV. + The weak form involves integrating -4πrρ(r) against test functions. + + Parameters + ---------- + rho : np.ndarray + Electron density at quadrature points + Shape: (n_elements * n_quad_points,) + z_nuclear : float + Nuclear charge (used for boundary condition) + + Returns + ------- + rhs_vector : np.ndarray + Assembled global RHS vector + Shape: (n_global_dofs,) + Note: Caller must set boundary values: + rhs_vector[0] = left_bc + rhs_vector[-1] = right_bc + + Notes + ----- + - The local RHS contribution for each element is: + RHS_local[i] = ∫ φ_i(r) * (-4πrρ(r)) dr + These are assembled into a global vector, with contributions from + adjacent elements added at shared boundary nodes. + """ + # Type and shape validation + assert isinstance(rho, np.ndarray), \ + RHO_TYPE_ERROR_MESSAGE.format(type(rho)) + assert rho.ndim == 1, \ + RHO_NDIM_ERROR_MESSAGE.format(rho.ndim) + assert rho.shape[0] == self.number_of_finite_elements * self.quadrature_node_number, \ + RHO_SHAPE_ERROR_MESSAGE.format(rho.shape[0], self.number_of_finite_elements * self.quadrature_node_number) + assert isinstance(z_nuclear, float), \ + Z_NUCLEAR_NOT_FLOAT_ERROR.format(type(z_nuclear)) + + # Reshape density to element-wise structure + rho_reshaped = rho.reshape(self.number_of_finite_elements, self.quadrature_node_number) + + # Compute source term at quadrature points: -4πrρ + r_rho = self.quadrature_nodes_reshaped * rho_reshaped + source = - 4.0 * np.pi * r_rho + + + # Compute local RHS: ∫ φ_i(r) * source(r) dr + rhs_vector_local = np.einsum( + "emi,em,em->ei", + self.lagrange_basis, # φ_i at quadrature points + self.quadrature_weights_reshaped, # quadrature weights + source, # -4πrρ at quadrature points + optimize=True + ) # Shape: (n_elem, n_physical_nodes) + + # Assemble local vectors into global vector + # Shared boundary nodes will have contributions from adjacent elements added + rhs_vector = self._assemble_local_to_global_vector(rhs_vector_local) + + return rhs_vector + + + def _assemble_local_to_global_vector(self, local_vector: np.ndarray) -> np.ndarray: + """ + Assemble local element vectors into a global vector. + + This method takes local element-wise vectors (shape: [n_elements, n_dofs_per_elem]) + and assembles them into a single global vector by adding overlapping contributions + at shared nodes. + + Parameters + ---------- + local_vector : np.ndarray + Local element vectors with shape (n_elements, n_local_dofs) + where n_local_dofs = polynomial_order + 1 = physical_node_number + + Returns + ------- + np.ndarray + Assembled global vector with shape (n_global_dofs,) + where n_global_dofs = n_elements * polynomial_order + 1 + + Notes + ----- + The assembly process accounts for shared endpoints between adjacent elements, + accumulating contributions from all elements that share a degree of freedom. + + For example, with 3 elements and polynomial order 2: + Element 0: [a0, a1, a2] → global indices [0, 1, 2] + Element 1: [b0, b1, b2] → global indices [2, 3, 4] (b0 adds to global[2]) + Element 2: [c0, c1, c2] → global indices [4, 5, 6] (c0 adds to global[4]) + + Global vector: [a0, a1, a2+b0, b1, b2+c0, c1, c2] + """ + # Initialize global vector + global_size = self.number_of_finite_elements * (self.physical_node_number - 1) + 1 + global_vector = np.zeros(global_size) + + # Get assembly indices (mapping from local to global DOFs) + indices_global = self._build_assembly_indices_vector() + + # Assemble: add local contributions to global vector + # np.add.at handles accumulation at repeated indices automatically + np.add.at(global_vector, indices_global, local_vector.reshape(-1)) + + return global_vector + + + def _assemble_local_to_global_matrix(self, local_matrix: np.ndarray) -> np.ndarray: + """ + Assemble local element matrices into a global matrix. + + This method takes local element-wise matrices (shape: [n_elements, n_dofs_per_elem, n_dofs_per_elem]) + and assembles them into a single global matrix by adding overlapping contributions at shared nodes. + + Parameters + ---------- + local_matrix : np.ndarray + Local element matrices with shape (n_elements, n_local_dofs, n_local_dofs) + where n_local_dofs = polynomial_order + 1 + + Returns + ------- + np.ndarray + Assembled global matrix with shape (n_global_dofs, n_global_dofs) + where n_global_dofs = n_elements * polynomial_order + 1 + + Notes + ----- + The assembly process accounts for shared endpoints between adjacent elements, + accumulating contributions from all elements that share a degree of freedom. + """ + # Initialize global matrix + global_size = self.number_of_finite_elements * (self.physical_node_number - 1) + 1 + global_matrix = np.zeros((global_size, global_size)) + + # Get assembly indices (mapping from local to global DOFs) + rows_global, cols_global = self._build_assembly_indices() + + # Assemble: add local contributions to global matrix + np.add.at(global_matrix, (rows_global, cols_global), local_matrix.reshape(-1)) + + return global_matrix + + + def _build_assembly_indices_vector(self): + """ + Return local→global indices for assembling element vectors into + a global vector (with shared endpoints). + + This is similar to _build_assembly_indices but for vectors (1D). + + Primary FE space: + local dofs per element : N_grid = physical_node_number + global stride (overlap by 1) : stride = N_grid - 1 + global dofs : N_elem * stride + 1 + + Returns + ------- + indices_global : np.ndarray + 1D array of global indices, shape (n_elements * n_local_dofs,) + Maps local_vector.reshape(-1) to positions in global_vector + + Example + ------- + For 3 elements with 3 nodes each (polynomial order 2): + Element 0: local indices [0, 1, 2] → global indices [0, 1, 2] + Element 1: local indices [0, 1, 2] → global indices [2, 3, 4] + Element 2: local indices [0, 1, 2] → global indices [4, 5, 6] + + Returns: [0, 1, 2, 2, 3, 4, 4, 5, 6] + ^^^^^^^ ^^^^^^^ ^^^^^^^ + elem 0 elem 1 elem 2 + + Note the repeated indices (2, 2) and (4, 4) at element boundaries. + """ + N_elem = self.number_of_finite_elements # e for element + N_grid = self.physical_node_number # g for grid + + # compute the assembly indices + stride = N_grid - 1 + elem_array = np.arange(N_elem) # [0, 1, 2, ...] + grid_array = np.arange(N_grid) # [0, 1, 2, ..., N_grid-1] + + # Global index for each (element, local_node) pair + # I_eg[elem, local_idx] = global_idx + I_eg = elem_array[:, None] * stride + grid_array[None, :] # (N_elem, N_grid) + + # Flatten to 1D array + indices_global = I_eg.reshape(-1) + + return indices_global + + + def _build_assembly_indices(self): + """ + Return clean local→global row/col indices for assembling element blocks into + a global matrix (with shared endpoints). + + Primary FE space: + local dofs per element : N_g = physical_node_number - 1 + global stride (overlap by 1) : stride = N_g - 1 + global dofs : N_e * stride + 1 + """ + # ----- primary FE space ----- + N_elem = self.number_of_finite_elements # e for element + N_grid = self.physical_node_number # g for grid + + # compute the assembly indices + stride = N_grid - 1 + elem_array = np.arange(N_elem) + grid_array = np.arange(N_grid) + I_eg = elem_array[:, None]*stride + grid_array[None, :] # (N_elem, N_grid) + + rows_primary = np.repeat(I_eg[:, :, None], N_grid, axis=2).reshape(-1) + cols_primary = np.repeat(I_eg[:, None, :], N_grid, axis=1).reshape(-1) + + return rows_primary, cols_primary + + + + @property + def H_kinetic(self) -> np.ndarray: + return self.get_H_kinetic() + + @property + def H_r_inv_sq(self) -> np.ndarray: + return self.get_H_r_inv_sq() + + @property + def S(self) -> np.ndarray: + return self.get_S() + + @property + def S_inv_sqrt(self) -> np.ndarray: + return self.get_S_inv_sqrt() + + @property + def laplacian(self) -> np.ndarray: + return self.get_laplacian() + + @property + def derivative_matrix(self) -> np.ndarray: + return self.get_derivative_matrix() + + @property + def global_interpolation_matrix(self) -> np.ndarray: + """ + Property accessor for global interpolation matrix. + Used for HF/PBE0 calculations. + """ + return self.get_global_interpolation_matrix() + + + def evaluate_single_orbital_on_given_grid( + self, + given_grid: np.ndarray, + orbital : np.ndarray, + ) -> np.ndarray: + """ + Evaluate a single orbital on a given grid using Lagrange interpolation. + + This function takes an orbital represented by its values at quadrature + points and evaluates it at arbitrary grid points using finite element + Lagrange basis functions. For each grid point, the function: + 1. Identifies which finite element contains the point + 2. Converts quadrature point values to nodal coefficients (using pseudoinverse) + 3. Evaluates the Lagrange basis functions at that point + 4. Computes the orbital value as a linear combination of basis functions + + Parameters + ---------- + given_grid : np.ndarray, shape (n_points,) + Grid points where the orbital should be evaluated. + Must be monotonically increasing and within the physical domain. + orbital : np.ndarray, shape (n_elem * n_quad,) + Orbital values at quadrature points (global quadrature points). + The orbital is stored as: ψ[r_quad] where r_quad are quadrature nodes. + + Returns + ------- + orbital_values : np.ndarray, shape (n_points,) + Orbital values evaluated at the given grid points. + orbital_values[i] = ψ(given_grid[i]) + + Implementation Logic + -------------------- + 1. **Input validation**: + - Grid must be monotonically increasing + - Grid must be within physical domain bounds + - Orbital must be 1D array with shape (n_elem * n_quad,) + + 2. **Reshape orbital to element structure**: + - Global orbital: (n_elem * n_quad,) → Element-wise: (n_elem, n_quad) + - Each row contains the orbital values at quadrature points for one element + + 3. **For each element, compute pseudoinverse of Lagrange basis**: + - lagrange_basis[elem_idx] has shape (n_quad, n_basis) + - basis_pseudoinverse[elem_idx] maps quadrature values → nodal coefficients + + 4. **For each grid point**: + a. Find which element contains the point (using element boundaries) + b. Convert quadrature values to nodal coefficients: c_nodal = L⁺ @ ψ_quad + c. Evaluate Lagrange basis functions at that point + d. Compute orbital value: ψ(x) = Σᵢ c_nodal_i * Lᵢ(x) + + 5. **Handle boundary nodes**: + - Boundary nodes are shared between adjacent elements + - Use the element that naturally contains the point + - For the last element, include the right boundary point + + Notes + ----- + - The orbital input is at quadrature points, not physical nodes. + - The interpolation uses Lagrange basis functions defined at physical nodes. + - The conversion from quadrature points to nodal coefficients uses the + pseudoinverse of the Lagrange basis matrix. + - Points outside the domain are not allowed (will raise assertion error). + + Example + ------- + >>> # Given orbital values at quadrature points + >>> orbital = np.array([...]) # shape: (n_elem * n_quad,) + >>> # Evaluate on a uniform grid + >>> uniform_grid = np.linspace(0, domain_size, 1000) + >>> orbital_values = ops_builder.evaluate_single_orbital_on_given_grid( + ... given_grid=uniform_grid, + ... orbital=orbital + ... ) + >>> # orbital_values.shape = (1000,) + """ + # Validate input: grid must be monotonically increasing + assert np.all(np.diff(given_grid) > 0.0), \ + GIVEN_GRID_NOT_MONOTONICALLY_INCREASING_ERROR + + # Validate input: grid must be within physical domain + assert np.all(given_grid >= self.physical_nodes[0]) and \ + np.all(given_grid <= self.physical_nodes[-1]), \ + GIVEN_GRID_NOT_WITHIN_PHYSICAL_NODES_ERROR + + # Validate input: orbital must be 1D array with correct shape + assert orbital.ndim == 1, \ + ORBITAL_NDIM_ERROR_MESSAGE.format(orbital.ndim) + assert orbital.shape[0] == self.number_of_finite_elements * self.quadrature_node_number, \ + ORBITAL_SHAPE_ERROR_MESSAGE.format( + orbital.shape[0], + self.number_of_finite_elements * self.quadrature_node_number + ) + + n_elem = self.number_of_finite_elements + n_quad = self.quadrature_node_number + n_basis = self.physical_node_number + n_points = len(given_grid) + + # Reshape orbital from global quadrature points to element-wise structure + # Shape: (n_elem * n_quad,) -> (n_elem, n_quad) + # Each row contains the orbital values at quadrature points for one element + orbital_reshaped = orbital.reshape(n_elem, n_quad) + + # Compute pseudoinverse of Lagrange basis for each element + # This maps quadrature point values to nodal coefficients + # basis_pseudoinverse[elem_idx] has shape (n_basis, n_quad) + basis_pseudoinverse = np.zeros((n_elem, n_basis, n_quad)) + for elem_idx in range(n_elem): + # self.lagrange_basis[elem_idx] has shape (n_quad, n_basis) + # Pseudoinverse maps: ψ_quad → c_nodal + basis_pseudoinverse[elem_idx] = np.linalg.pinv(self.lagrange_basis[elem_idx]) + + # Get element boundaries from physical nodes + boundaries = np.zeros(n_elem + 1) + boundaries[0] = self.physical_nodes_reshaped[0, 0] + for elem_idx in range(n_elem): + boundaries[elem_idx + 1] = self.physical_nodes_reshaped[elem_idx, -1] + + # Initialize output array + orbital_values = np.zeros(n_points) + + # For each grid point, find its element and evaluate the orbital + for point_idx, x_point in enumerate(given_grid): + # Find which element contains this point + # For the last element, include the right boundary + elem_idx = None + for e_idx in range(n_elem): + left = boundaries[e_idx] + right = boundaries[e_idx + 1] + if e_idx == n_elem - 1: + # Last element: include right boundary + if left <= x_point <= right: + elem_idx = e_idx + break + else: + # Other elements: exclude right boundary (handled by next element) + if left <= x_point < right: + elem_idx = e_idx + break + + if elem_idx is None: + # This should not happen if assertions passed, but handle gracefully + raise ValueError(f"Point {x_point} not found in any element") + + # Get orbital values at quadrature points for this element + orbital_quad_elem = orbital_reshaped[elem_idx, :] # Shape: (n_quad,) + + # Convert quadrature point values to nodal coefficients + # c_nodal = L⁺ @ ψ_quad, where L⁺ is the pseudoinverse + orbital_coef_nodal = basis_pseudoinverse[elem_idx] @ orbital_quad_elem # Shape: (n_basis,) + + # Get physical nodes for this element (as row vector for LagrangeShapeFunctions) + nodes_elem = self.physical_nodes_reshaped[elem_idx:elem_idx+1, :] # Shape: (1, n_basis) + + # Evaluate Lagrange basis functions at this point + # x_eval should be (1, 1) for single point + basis_elem, _ = LagrangeShapeFunctions.lagrange_basis_and_derivatives( + x_node=nodes_elem, # (1, n_basis) + x_eval=np.array([[x_point]]) # (1, 1) + ) + # basis_elem shape: (1, 1, n_basis) -> (n_basis,) + basis_values = basis_elem[0, 0, :] + + # Compute orbital value: ψ(x) = Σᵢ c_nodal_i * Lᵢ(x) + orbital_values[point_idx] = np.dot(orbital_coef_nodal, basis_values) + + return orbital_values + diff --git a/utils/atom/post/__init__.py b/utils/atom/post/__init__.py new file mode 100644 index 00000000..eb52aed1 --- /dev/null +++ b/utils/atom/post/__init__.py @@ -0,0 +1,3 @@ +from .snapshot import DensitySnapshot # noqa: F401 +from .builder import SnapshotBuilder # noqa: F401 +from .postproc import PostProcessor # noqa: F401 diff --git a/utils/atom/post/builder.py b/utils/atom/post/builder.py new file mode 100644 index 00000000..69b42ff7 --- /dev/null +++ b/utils/atom/post/builder.py @@ -0,0 +1,25 @@ +from __future__ import annotations +import numpy as np +from typing import Dict, Any, Optional +from .snapshot import DensitySnapshot + +class SnapshotBuilder: + """Build DensitySnapshot from SCF state. Placeholder.""" + def __init__(self, ops_dict: Dict[str, Any]): + self.ops = ops_dict + + def build(self, Z: int, rho: np.ndarray, eigvals: Optional[np.ndarray] = None, + eigvecs: Optional[np.ndarray] = None, meta: Optional[Dict[str, Any]] = None, + include_tau: bool = False) -> DensitySnapshot: + r = self.ops.get("r_quad"); w = self.ops.get("w_quad") + D = self.ops.get("D") + if r is None or w is None or D is None: + raise RuntimeError("Operators dict missing r_quad/w_quad/D.") + # Minimal grad_rho (exact formula depends on your D operator) + grad_rho = None + tau = None + V_H = None + return DensitySnapshot( + Z=Z, r_quad=r, w_quad=w, rho=rho, grad_rho=grad_rho, tau=tau, + V_H=V_H, D_handle=D, meta=meta or {}, eigvals=eigvals, eigvecs=eigvecs + ) diff --git a/utils/atom/post/postproc.py b/utils/atom/post/postproc.py new file mode 100644 index 00000000..93ef4c83 --- /dev/null +++ b/utils/atom/post/postproc.py @@ -0,0 +1,13 @@ +from __future__ import annotations +import numpy as np +from typing import Tuple, Dict, Any + +class PostProcessor: + """Produce uniform r-grid orbitals and info dict. Placeholder.""" + def __init__(self, mesh_spacing: float = 0.1): + self.mesh_spacing = float(mesh_spacing) + + def make_outputs(self, R: float, eigvecs_FE: np.ndarray, occ_nl: np.ndarray, info: Dict[str, Any]) -> Tuple[np.ndarray, np.ndarray, np.ndarray, Dict[str, Any]]: + """Return (r_array, orbitals, n_l_orbitals, info_dict).""" + # TODO: interpolate from FE grid to uniform grid + raise NotImplementedError diff --git a/utils/atom/post/snapshot.py b/utils/atom/post/snapshot.py new file mode 100644 index 00000000..e524c0ea --- /dev/null +++ b/utils/atom/post/snapshot.py @@ -0,0 +1,26 @@ +from __future__ import annotations +from dataclasses import dataclass +import numpy as np +from typing import Optional, Any, Dict + +@dataclass(frozen=True) +class DensitySnapshot: + """Immutable description of fixed electron density and needed context.""" + Z: int + r_quad: np.ndarray + w_quad: np.ndarray + rho: np.ndarray + grad_rho: Optional[np.ndarray] + tau: Optional[np.ndarray] + V_H: Optional[np.ndarray] + D_handle: Any + meta: Dict[str, Any] + eigvals: Optional[np.ndarray] = None + eigvecs: Optional[np.ndarray] = None + + def to_npz(self, path: str) -> None: + np.savez_compressed( + path, Z=self.Z, r=self.r_quad, w=self.w_quad, rho=self.rho, + grad_rho=self.grad_rho, tau=self.tau, V_H=self.V_H, meta=self.meta, + eigvals=self.eigvals, eigvecs=self.eigvecs + ) diff --git a/utils/atom/pseudo/__init__.py b/utils/atom/pseudo/__init__.py new file mode 100644 index 00000000..43b98821 --- /dev/null +++ b/utils/atom/pseudo/__init__.py @@ -0,0 +1,3 @@ +from .local import LocalPseudopotential # noqa: F401 +from .non_local import NonLocalPseudopotential # noqa: F401 +# from .nlcc import NLCC # noqa: F401 \ No newline at end of file diff --git a/utils/atom/pseudo/local.py b/utils/atom/pseudo/local.py new file mode 100644 index 00000000..12c7a6ad --- /dev/null +++ b/utils/atom/pseudo/local.py @@ -0,0 +1,417 @@ +from __future__ import annotations +import numpy as np +import os +from typing import Dict, Any, Optional + +from scipy.interpolate import interp1d, make_interp_spline +from .read_pseudopotential import read_pseudopotential_file + +__all__ = ["LocalPseudopotential"] + +PSEUDOPOTENTIAL_PATH_NOT_PROVIDED_ERROR = \ + "Pseudopotential path must be provided" +PSEUDOPOTENTIAL_FILENAME_NOT_PROVIDED_ERROR = \ + "Pseudopotential filename must be provided" +PSEUDOPOTENTIAL_PATH_DOES_NOT_EXIST_ERROR = \ + "Pseudopotential path {} does not exist" +PSEUDOPOTENTIAL_FILENAME_DOES_NOT_EXIST_ERROR = \ + "Pseudopotential filename {} does not exist" +R_NODES_MUST_BE_MONOTONICALLY_INCREASING_AND_NON_NEGATIVE_ERROR = \ + "r_nodes must be monotonically increasing and non-negative" + +class LocalPseudopotential: + """ + Local pseudopotential reader and interpolator. + + This class handles loading and interpolation of local pseudopotential data + from psp8 format files. It provides methods to evaluate the local potential + on arbitrary radial grids. + """ + + def __init__(self, + atomic_number: int, + path: Optional[str] = None, + filename: Optional[str] = None): + """ + Initialize local pseudopotential. + + Parameters + ---------- + atomic_number : int + Atomic number of the element + path : str, optional + Path to pseudopotential files directory + filename : str, optional + Pseudopotential filename (e.g., 'H.psp8') + """ + + # Initialize attributes + if path is not None and filename is not None: + self.all_electron = False + self.load(path, filename) + self.u_local = 1.0 + self.u_non_local = 1.0 + self.load_psp = True + else: + self.all_electron = True + self.z_valence = atomic_number + self.z_nuclear = atomic_number + self.u_local = 0.0 + self.u_non_local = 0.0 + self.load_psp = False + + + @staticmethod + def thomas_fermi_density_guess(z_valence: float, r_nodes: np.ndarray) -> np.ndarray: + """ + Thomas-Fermi approximation for all-electron density guess + Based on screening model with empirical fitting parameters + """ + # Compute scaled radial coordinate for Thomas-Fermi model + # x = r * k_TF where k_TF is the Thomas-Fermi wave vector + thomas_fermi_prefactor = (128 * z_valence / (9 * np.pi**2))**(1/3) + r_scaled = r_nodes * thomas_fermi_prefactor + + # Empirical fitting parameters for effective charge screening + # From quantum Monte Carlo or DFT fitting + screening_alpha = 0.7280642371 # Primary screening parameter + screening_beta = -0.5430794693 # Secondary screening parameter + screening_gamma = 0.3612163121 # Decay parameter + + # Compute effective nuclear charge with screening corrections + # Z_eff accounts for electron-electron screening effects + sqrt_r_scaled = np.sqrt(r_scaled) + screening_correction = ( + 1 + screening_alpha * sqrt_r_scaled + + screening_beta * r_scaled * np.exp(-screening_gamma * sqrt_r_scaled) + ) + z_effective = z_valence * screening_correction**2 * np.exp(-2 * screening_alpha * sqrt_r_scaled) + + # Compute initial potential: V(r) = -Z_eff / r + v_coulomb_screened = -z_effective / r_nodes + + # Thomas-Fermi density: rho(r) = (1/(3π²)) * [2|V(r)|]^(3/2) + # This comes from the semiclassical approximation + thomas_fermi_constant = 1 / (3 * np.pi**2) + rho_thomas_fermi = thomas_fermi_constant * ((-2 * v_coulomb_screened)**(3/2)) + + return rho_thomas_fermi + + + def get_rho_guess(self, r_nodes: np.ndarray) -> np.ndarray: + """ + Get the initial density guess for the SCF. + + Parameters + ---------- + r_nodes : np.ndarray + Radial nodes where to evaluate the density + + Returns + ------- + np.ndarray + Density guess at the nodes + """ + # check if r_nodes is monotonically increasing and non-negative + if not np.all(np.diff(r_nodes) > 0.0) or not np.all(r_nodes > 0.0): + raise ValueError(R_NODES_MUST_BE_MONOTONICALLY_INCREASING_AND_NON_NEGATIVE_ERROR) + + if self.all_electron: + return self.thomas_fermi_density_guess(self.z_valence, r_nodes) + else: + # Interpolate the density guess from pseudopotential data + # For r < r_cutoff: use cubic spline interpolation + # For r >= r_cutoff: use exponential extrapolation based on tail behavior + rho_grid_cutoff = np.max(self.r_grid_density) + + # Get values at last two grid points for exponential extrapolation + rho_last = self.density_initial_guess[-1] + rho_second_last = self.density_initial_guess[-2] + r_last = self.r_grid_density[-1] + r_second_last = self.r_grid_density[-2] + + # Fit exponential tail: rho(r) = prefactor * exp(decay_rate * r) + # Using last two points to determine decay rate and prefactor + decay_rate = np.log(rho_last / rho_second_last) / (r_last - r_second_last) + prefactor = rho_last / np.exp(decay_rate * r_last) + + # Split nodes into inner and outer regions + indices_below_cutoff = np.where(r_nodes < rho_grid_cutoff) + indices_above_cutoff = np.where(r_nodes >= rho_grid_cutoff) + r_below_cutoff = r_nodes[indices_below_cutoff[0]] + + # Inner region: cubic spline interpolation + rho_interpolator = make_interp_spline(self.r_grid_density, self.density_initial_guess, k=3) + rho_interpolated = np.zeros_like(r_nodes) + rho_interpolated[indices_below_cutoff[0]] = rho_interpolator(r_below_cutoff) + + # Outer region: exponential extrapolation + rho_extrapolated = np.zeros_like(r_nodes) + rho_extrapolated[indices_above_cutoff[0]] = prefactor * np.exp(decay_rate * r_nodes[indices_above_cutoff[0]]) + + # Combine interpolated and extrapolated regions + rho_guess = rho_interpolated + rho_extrapolated + return rho_guess + + + def get_rho_core_correction(self, r_nodes: np.ndarray) -> np.ndarray: + """ + Get the nonlinear core correction (NLCC) density for the SCF, evaluated on the r_nodes. + """ + # check if r_nodes is monotonically increasing and non-negative + if not np.all(np.diff(r_nodes) > 0.0) or not np.all(r_nodes > 0.0): + raise ValueError(R_NODES_MUST_BE_MONOTONICALLY_INCREASING_AND_NON_NEGATIVE_ERROR) + + if self.all_electron: + # NLCC is not used in all-electron calculations + return np.zeros_like(r_nodes) + else: + # Interpolate the nonlinear core correction (NLCC) density + # For r < r_cutoff: use cubic spline interpolation + # For r >= r_cutoff: density is zero (core correction vanishes) + + nlcc_grid_cutoff = np.max(self.r_grid_nlcc) + + # Find nodes within the NLCC grid range + indices_below_cutoff = np.where(r_nodes < nlcc_grid_cutoff) + r_below_cutoff = r_nodes[indices_below_cutoff[0]] + + # Initialize NLCC density array (zero outside cutoff) + rho_nlcc = np.zeros_like(r_nodes) + + # Interpolate NLCC density using cubic spline + rho_nlcc_interpolator = make_interp_spline( + self.r_grid_nlcc, + self.density_nlcc, + k=3 + ) + rho_nlcc[indices_below_cutoff[0]] = rho_nlcc_interpolator(r_below_cutoff) + + return rho_nlcc + + + + + def get_v_local_component_psp(self, r_nodes: np.ndarray) -> np.ndarray: + """ + Get the local potential component of the pseudopotential, evaluated on the r_nodes. + + For r < r_cutoff: interpolates from the pseudopotential data + For r >= r_cutoff: uses the Coulomb tail -Z/r + + Parameters + ---------- + r_nodes : np.ndarray + Radial grid points where to evaluate the local potential + + Returns + ------- + np.ndarray + Local potential values at the given radial nodes + """ + # Validate input: r_nodes must be monotonically increasing and non-negative + if not np.all(np.diff(r_nodes) > 0.0) or not np.all(r_nodes > 0.0): + raise ValueError(R_NODES_MUST_BE_MONOTONICALLY_INCREASING_AND_NON_NEGATIVE_ERROR) + + if self.all_electron: + # Local potential component of the pseudopotential is not used in all-electron calculations + return np.zeros_like(r_nodes) + else: + # Interpolate the local potential component of the pseudopotential + r_cutoff = self.r_grid_local[-1] + + # Split nodes into inner region (r < r_cutoff) and outer region (r >= r_cutoff) + indices_below_cutoff = np.where(r_nodes < r_cutoff) + indices_above_cutoff = np.where(r_nodes >= r_cutoff) + r_below_cutoff = r_nodes[indices_below_cutoff[0]] + + # Initialize local potential array + v_local = np.zeros_like(r_nodes) + + # Outer region: use Coulomb tail -Z/r + v_local[indices_above_cutoff[0]] = -self.z_valence + + # Inner region: interpolate from pseudopotential grid + # Multiply by r to get r*V(r) for interpolation + r_times_v_local = self.r_grid_local * self.v_local_values + v_local_interpolator = interp1d( + self.r_grid_local, + r_times_v_local, + kind='cubic', + bounds_error=False, + fill_value='extrapolate' + ) + v_local[indices_below_cutoff[0]] = v_local_interpolator(r_below_cutoff) + + # Divide by r to get V(r) = (r*V(r))/r + return v_local / r_nodes + + + def load(self, path: str, filename: str) -> Dict[str, Any]: + """ + Load pseudopotential data from file. + + Returns + ------- + Dict[str, Any] + Dictionary containing loaded pseudopotential information + """ + assert path is not None, \ + PSEUDOPOTENTIAL_PATH_NOT_PROVIDED_ERROR + assert filename is not None, \ + PSEUDOPOTENTIAL_FILENAME_NOT_PROVIDED_ERROR + assert os.path.exists(path), \ + PSEUDOPOTENTIAL_PATH_DOES_NOT_EXIST_ERROR.format(path) + assert os.path.exists(os.path.join(path, filename)), \ + PSEUDOPOTENTIAL_FILENAME_DOES_NOT_EXIST_ERROR.format(filename) + + # Read pseudopotential file + psp_data = read_pseudopotential_file( + psp_dir_path = path, + psp_file_name = filename, + print_debug = False + ) + + # Unpack pseudopotential data (keep original variable names for reference) + (Z, Zatom, XC, Vloc, r_grid_vloc, rc, Pot, lmax, lloc, nproj, + r_grid_rho, rho_isolated_guess, rho_tilde, r_grid_rho_tilde, + pspsoc, Potso, rc_max_list) = psp_data + + # Store atomic charge information + self.z_valence = Z # Z: Valence charge (for pseudopotential Coulomb tail) + self.z_nuclear = Zatom # Zatom: True nuclear charge of the atom + self.xc_functional = XC # XC: Exchange-correlation functional identifier + + # Store local pseudopotential data + self.v_local_values = Vloc # Vloc: Local pseudopotential values on radial grid + self.r_grid_local = r_grid_vloc # r_grid_vloc: Radial grid points for local potential + self.r_core_cutoff = rc # rc: Core radius cutoff for pseudopotential + + # Store non-local pseudopotential data + self.nonlocal_projectors = Pot # Pot: Non-local projector functions for each angular momentum l + self.n_projectors_per_l = nproj # nproj: Number of projectors for each l channel + + # Store density-related data + self.r_grid_density = r_grid_rho # r_grid_rho: Radial grid for density guess + self.density_initial_guess = rho_isolated_guess # rho_isolated_guess: Initial atomic density for SCF guess + + # Store nonlinear core correction (NLCC) data + self.density_nlcc = rho_tilde # rho_tilde: Core electron density for NLCC + self.r_grid_nlcc = r_grid_rho_tilde # r_grid_rho_tilde: Radial grid for NLCC density + + # Store spin-orbit coupling data + self.has_spin_orbit = pspsoc # pspsoc: Spin-orbit coupling flag (0=no, 1=yes) + self.spin_orbit_projectors = Potso # Potso: Spin-orbit coupling projector functions + + # Store cutoff radii information + self.r_cutoff_max_per_l = rc_max_list # rc_max_list: Maximum cutoff radius for each l channel + + + def print_info(self): + """ + Print pseudopotential information summary. + """ + print("=" * 60) + print("\t\t PSEUDOPOTENTIAL INFORMATION") + print("=" * 60) + + + + # Basic atomic information + print(f"Valence Charge (z_valence) : {self.z_valence}") + print(f"Nuclear Charge (z_nuclear) : {self.z_nuclear}") + print() + + if self.load_psp: + # Local potential information + print("LOCAL POTENTIAL:") + print(f" Core Cutoff Radius (r_core_cutoff) : {self.r_core_cutoff:.6f} Bohr") + print(f" Grid Points (r_grid_local) : {len(self.r_grid_local)}") + print(f" Grid Range (r_grid_local) : [{self.r_grid_local[0]:.6f}, {self.r_grid_local[-1]:.6f}] Bohr") + print(f" Potential Range (v_local_values) : [{np.min(self.v_local_values):.6f}, {np.max(self.v_local_values):.6f}] Hartree") + print() + + # Non-local potential information + if hasattr(self, 'nonlocal_projectors') and len(self.nonlocal_projectors) > 0: + print("NON-LOCAL POTENTIAL:") + print(f" Maximum Angular Momentum (l_max) : {len(self.nonlocal_projectors) - 1}") + print(f" Projectors per l (n_projectors_per_l) : {self.n_projectors_per_l}") + print(f" Spin-Orbit Coupling (has_spin_orbit) : {'Yes' if self.has_spin_orbit else 'No'}") + print() + + # Projector information for each l + for l in range(len(self.nonlocal_projectors)): + if l < len(self.n_projectors_per_l): + n_proj_l = self.n_projectors_per_l[l] + print(f" l = {l}: {n_proj_l} projector(s)") + if l < len(self.r_cutoff_max_per_l): + print(f" Max cutoff radius: {self.r_cutoff_max_per_l[l]:.6f} Bohr") + print() + + # Density information + if hasattr(self, 'r_grid_density') and len(self.r_grid_density) > 0: + print("DENSITY INFORMATION:") + print(f" Density Grid Points (r_grid_density) : {len(self.r_grid_density)}") + print(f" Density Grid Range (r_grid_density) : [{self.r_grid_density[0]:.6f}, {self.r_grid_density[-1]:.6f}] Bohr") + if hasattr(self, 'density_initial_guess') and len(self.density_initial_guess) > 0: + print(f" Initial Density Range (density_initial_guess) : [{np.min(self.density_initial_guess):.6f}, {np.max(self.density_initial_guess):.6f}]") + if hasattr(self, 'density_nlcc') and len(self.density_nlcc) > 0: + print(f" NLCC Density Range (density_nlcc) : [{np.min(self.density_nlcc):.6f}, {np.max(self.density_nlcc):.6f}]") + + print() + + + def evaluate_on(self, r_quad: np.ndarray) -> np.ndarray: + """ + Evaluate local potential on quadrature grid. + + Parameters + ---------- + r_quad : np.ndarray + Radial quadrature points where to evaluate the potential + + Returns + ------- + np.ndarray + Local potential values at quadrature points + """ + raise NotImplementedError("check again") + + if len(self.v_local_values) == 0: + raise ValueError("Pseudopotential data not loaded. Call load() first.") + + # Handle edge cases + if len(r_quad) == 0: + return np.array([]) + + # Ensure r_quad is within the pseudopotential grid range + r_min = np.min(self.r_grid_local) + r_max = np.max(self.r_grid_local) + + # Clamp r_quad to valid range + r_quad_clamped = np.clip(r_quad, r_min, r_max) + + # Interpolate local potential + try: + # Use cubic spline interpolation for smooth results + interp_func = interp1d( + self.r_grid_local, + self.v_local_values, + kind='cubic', + bounds_error=False, + fill_value='extrapolate' + ) + V_local_interp = interp_func(r_quad_clamped) + + except ValueError: + # Fallback to linear interpolation if cubic fails + interp_func = interp1d( + self.r_grid_local, + self.v_local_values, + kind='linear', + bounds_error=False, + fill_value='extrapolate' + ) + V_local_interp = interp_func(r_quad_clamped) + + return V_local_interp diff --git a/utils/atom/pseudo/non_local.py b/utils/atom/pseudo/non_local.py new file mode 100644 index 00000000..fefabbcd --- /dev/null +++ b/utils/atom/pseudo/non_local.py @@ -0,0 +1,348 @@ +from __future__ import annotations +import numpy as np +from typing import Dict, Any +from scipy.interpolate import make_interp_spline + + +class NonLocalPseudopotential: + """ + Non-local pseudopotential components using Kleinman-Bylander projectors. + + The non-local pseudopotential is represented as: + V_nl = Σ_{ljm} |χ_{lj}⟩ γ_{lj} ⟨χ_{lj}| + + where: + χ_{lj}(r) - Projector functions (from pseudopotential file) + γ_{lj} - Energy coefficients (from pseudopotential file) + l, j, m - Angular momentum quantum numbers + """ + + def __init__( + self, + pseudo, # LocalPseudopotential instance + ops_builder # RadialOperatorsBuilder instance + ): + """ + Initialize non-local pseudopotential calculator. + + Parameters + ---------- + pseudo : LocalPseudopotential + Pseudopotential data (contains nonlocal_projectors, etc.) + ops_builder : RadialOperatorsBuilder + Finite element operators for matrix assembly + """ + self.pseudo = pseudo + self.ops = ops_builder + + # Extract data from pseudopotential + self.nonlocal_projectors = pseudo.nonlocal_projectors + self.n_projectors_per_l = pseudo.n_projectors_per_l + self.r_cutoff_max_per_l = pseudo.r_cutoff_max_per_l + self.r_grid_local = pseudo.r_grid_local + + # Extract grid data from operators + self.r_quad = ops_builder.quadrature_nodes + self.w_quad = ops_builder.quadrature_weights + self.lagrange_basis = ops_builder.lagrange_basis + self.n_elem = ops_builder.number_of_finite_elements + self.n_quad = ops_builder.quadrature_node_number + self.n_global_dofs = self.n_elem * (ops_builder.physical_node_number - 1) + 1 + + + def compute_nonlocal_matrix(self, l_channel: int) -> np.ndarray: + """ + Compute non-local pseudopotential matrix for angular momentum l. + + This implements the Kleinman-Bylander form: + H_nl = Σⱼ |χⱼ⟩ γⱼ ⟨χⱼ| + + Parameters + ---------- + l_channel : int + Angular momentum quantum number + + Returns + ------- + np.ndarray + Non-local potential matrix, shape (n_global_dofs, n_global_dofs) + + Notes + ----- + The matrix is assembled from projector overlaps: + V_nl[i,j] = Σₖ γₖ ∫ φᵢ(r) χₖ(r) r dr ∫ χₖ(r') φⱼ(r') r' dr' + """ + if l_channel >= len(self.nonlocal_projectors): + # No projectors for this l + return np.zeros((self.n_global_dofs, self.n_global_dofs)) + + # Get projector data for this l channel + nl_data = self.nonlocal_projectors[l_channel] + gamma_coefficients = nl_data['gamma_Jl'] # Energy coefficients + projector_functions = nl_data['proj'] # Projector radial functions + r_cutoff = self.r_cutoff_max_per_l[l_channel] + n_projectors = self.n_projectors_per_l[l_channel] + + # Initialize non-local matrix + V_nonlocal = np.zeros((self.n_global_dofs, self.n_global_dofs)) + + # Loop over projectors for this l + for proj_idx in range(n_projectors): + # Step 1: Interpolate projector to quadrature grid + chi_at_quad = self._interpolate_projector( + projector_functions[:, proj_idx], + r_cutoff + ) + + # Step 2: Compute projection integrals ⟨χ|φᵢ⟩ for all basis functions + chi_r = chi_at_quad * self.r_quad # r*χ(r) + projection_integrals = self._compute_projection_integrals(chi_r) + + # Step 3: Assemble matrix: V += γ |⟨χ|φᵢ⟩⟨χ|φⱼ⟩| + gamma = gamma_coefficients[proj_idx] + V_nonlocal += gamma * np.outer(projection_integrals, projection_integrals) + + return V_nonlocal + + + def _interpolate_projector( + self, + projector_values: np.ndarray, + r_cutoff: float + ) -> np.ndarray: + """ + Interpolate projector function to quadrature grid. + + Parameters + ---------- + projector_values : np.ndarray + Projector values on pseudopotential grid + r_cutoff : float + Cutoff radius for this projector + + Returns + ------- + np.ndarray + Projector values at quadrature points (zero beyond r_cutoff) + """ + # Find quadrature points within cutoff + mask_within_cutoff = self.r_quad <= r_cutoff + r_within_cutoff = self.r_quad[mask_within_cutoff] + + # Interpolate projector using cubic spline + chi_interpolator = make_interp_spline( + self.r_grid_local, + projector_values, + k=3 + ) + + # Evaluate at quadrature points + chi_at_quad = np.zeros_like(self.r_quad) + chi_at_quad[mask_within_cutoff] = chi_interpolator(r_within_cutoff) + + return chi_at_quad + + + def _compute_projection_integrals( + self, + chi_r: np.ndarray + ) -> np.ndarray: + """ + Compute projection integrals ⟨χ|φᵢ⟩ = ∫ χ(r) φᵢ(r) r dr. + + Parameters + ---------- + chi_r : np.ndarray + r * χ(r) at quadrature points, shape (n_quad_total,) + + Returns + ------- + np.ndarray + Projection integrals for all global basis functions + Shape: (n_global_dofs,) + """ + # Reshape chi_r to element structure + from atom.mesh.builder import Mesh1D + + chi_r_reshaped = Mesh1D.fe_flat_to_block2d( + chi_r, + self.n_elem, + endpoints_shared=False + ) # Shape: (n_elem, n_quad) + + # Compute local integrals: ∫ χ(r) φᵢ(r) r w dr + # lagrange_basis: (n_elem, n_quad, n_basis) + # chi_r_reshaped: (n_elem, n_quad) + # w_quad_reshaped: (n_elem, n_quad) + + w_quad_reshaped = Mesh1D.fe_flat_to_block2d( + self.w_quad, + self.n_elem, + endpoints_shared=False + ) + + # Local integrals for each element + # Shape: (n_elem, n_basis) + local_integrals = np.einsum( + 'emk,em,em->ek', + self.lagrange_basis, # (n_elem, n_quad, n_basis) + chi_r_reshaped, # (n_elem, n_quad) + w_quad_reshaped, # (n_elem, n_quad) + optimize=True + ) + + # Assemble to global DOFs (handle shared nodes) + global_integrals = self._assemble_local_to_global_vector(local_integrals) + + return global_integrals + + + def _assemble_local_to_global_vector( + self, + local_vector: np.ndarray + ) -> np.ndarray: + """ + Assemble local element vectors to global vector. + + Parameters + ---------- + local_vector : np.ndarray + Shape: (n_elem, n_local_dofs) + + Returns + ------- + np.ndarray + Global vector, shape: (n_global_dofs,) + """ + n_elem = local_vector.shape[0] + n_local = local_vector.shape[1] + stride = n_local - 1 + + # Initialize global vector + global_vector = np.zeros(self.n_global_dofs) + + # Assemble: add contributions from each element + for elem_idx in range(n_elem): + global_start = elem_idx * stride + global_end = global_start + n_local + global_vector[global_start:global_end] += local_vector[elem_idx] + + return global_vector + + + def compute_all_nonlocal_matrices( + self, + l_channels: np.ndarray + ) -> Dict[int, np.ndarray]: + """ + Compute non-local matrices for all required l channels. + + Parameters + ---------- + l_channels : np.ndarray + Array of unique l values to compute + + Returns + ------- + dict + Dictionary mapping l → V_nl matrix + Each matrix has shape (n_global_dofs, n_global_dofs) + """ + nonlocal_matrices = {} + + for l in l_channels: + # Remove boundary DOFs (keep only interior points) + V_nl_full = self.compute_nonlocal_matrix(l) + # V_nl_interior = V_nl_full[1:-1, 1:-1] + nonlocal_matrices[l] = V_nl_full + + return nonlocal_matrices + + + def compute_nonlocal_energy( + self, + orbitals : np.ndarray, + occupations : np.ndarray, + l_values : np.ndarray, + unique_l_values : np.ndarray + ) -> float: + """ + Compute non-local pseudopotential energy contribution. + + This implements the Kleinman-Bylander form: + E_nl = Σ_l Σ_j γ_{lj} ⟨φ|χ_{lj}⟩⟨χ_{lj}|φ⟩ + + where: + γ_{lj} = energy coefficients + χ_{lj} = projector functions + φ = occupied orbitals + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) + Shape: (n_grid, n_orbitals) + occupations : np.ndarray + Occupation numbers for each orbital + Shape: (n_orbitals,) + l_values : np.ndarray + Angular momentum quantum numbers for each orbital + Shape: (n_orbitals,) + unique_l_values : np.ndarray + Unique angular momentum values to loop over + + Returns + ------- + float + Total non-local pseudopotential energy contribution + """ + E_nonlocal_total = 0.0 + + # Loop over unique l channels + for l in unique_l_values: + # Skip if no projectors for this l + if l >= len(self.nonlocal_projectors) or self.n_projectors_per_l[l] == 0: + continue + + # Get projector data for this l channel + nl_data = self.nonlocal_projectors[l] + gamma_coefficients = nl_data['gamma_Jl'] # Energy coefficients + projector_functions = nl_data['proj'] # Projector functions + r_cutoff = self.r_cutoff_max_per_l[l] + n_projectors = self.n_projectors_per_l[l] + + # Get orbitals for this l channel + mask_l = (l_values == l) + orbitals_l = orbitals[:, mask_l] # Shape: (n_grid, n_orbitals_l) + occupations_l = occupations[mask_l] # Shape: (n_orbitals_l,) + + # Loop over projectors for this l channel + for proj_idx in range(n_projectors): + # Interpolate projector to quadrature grid + chi_at_quad = self._interpolate_projector( + projector_functions[:, proj_idx], + r_cutoff + ) + + # Compute r * chi(r) + r_chi_l = chi_at_quad * self.r_quad + + # Compute energy contribution using einsum + # Following reference code: gamma_Jl[i]*np.einsum('ij,jk,ik->', Occ*orb*w, r_chi*r_chi, orb*w) + # The einsum computes: Σ_i,j occ_i * orb_i(j) * w(j) * r_chi(j) * r_chi(j) * orb_i(j) * w(j) + # = Σ_i occ_i * ⟨φ_i|χ⟩⟨χ|φ_i⟩ + gamma = gamma_coefficients[proj_idx] + + # einsum('ij,jk,ik->', Occ*orb*w, r_chi*r_chi, orb*w) + # i = orbital index, j,k = grid indices + energy_contribution = gamma * np.einsum( + 'ij,jk,ik->', + occupations_l[:, np.newaxis] * orbitals_l.T * self.w_quad[np.newaxis, :], + r_chi_l[:, np.newaxis] * r_chi_l[np.newaxis, :], + orbitals_l.T * self.w_quad[np.newaxis, :], + optimize=True + ) + + E_nonlocal_total += energy_contribution + + return E_nonlocal_total diff --git a/utils/atom/pseudo/read_pseudopotential.py b/utils/atom/pseudo/read_pseudopotential.py new file mode 100644 index 00000000..381fb738 --- /dev/null +++ b/utils/atom/pseudo/read_pseudopotential.py @@ -0,0 +1,179 @@ +import sys +import numpy as np +import math +import os +import re + +np.set_printoptions(threshold=sys.maxsize) + +''' +@brief READPSEUDOPOT reads the pseudopotential file (psp8 format). + +@param ityp Element type index. +@param psdfname The pseudopotential filename, with suffix. +@param element Element type. + +@authors Qimen Xu + Abhiraj Sharma + Phanish Suryanarayana + +@copyright (c) 2019 Material Physics & Mechanics Group, Georgia Tech +''' + + + +def read_pseudopotential_file( + psp_dir_path : str, + psp_file_name: str, + print_debug : bool = False): + + pseudopotential_filename = os.path.join(psp_dir_path, psp_file_name) + + with open(pseudopotential_filename,"r") as psp: + # Read all lines from the file + lines = psp.readlines() + + # Process each line: split by the separator pattern (,\s+)+(\+\S) + # This pattern matches: comma followed by whitespace, then a plus sign with something + separator_pattern = r'(,\s+)+(\+\S)' + l1_list = [] + for line in lines: + # Split by the separator pattern + parts = re.split(separator_pattern, line) + # Keep only the first part (before the separator) and filter out empty strings + if parts: + l1_list.append([parts[0].strip()]) + + # Now split each string by comma or whitespace + pattern = r',|\s+' + l1_split = [re.split(pattern, string[0]) for string in l1_list] + # Filter out empty strings from each split result + l1_split = [[item for item in split_list if item] for split_list in l1_split] + + Zatom = float(l1_split[1][0]) + Z = float(l1_split[1][1]) + + pspxc = float(l1_split[2][1]) + + lmax = int(l1_split[2][2]) + lloc = float(l1_split[2][3]) + mmax = int(l1_split[2][4]) + + fchrg = float(l1_split[3][1]) + + nproj = [int(l1_split[4][i]) for i in range(int(lmax+1))] + + extension_switch = float(l1_split[5][0]) + pspsoc = 0 # indicating if the psp file including spin-orbit coupling + + if extension_switch == 2 or extension_switch == 3: + if print_debug: + print("This psp8 includes spin-orbit coupling.\n") + pspsoc = 1 + nprojso = [float(l1_split[6][i]) for i in range(int(lmax))] + + + Pot = [dict({'gamma_Jl' : np.zeros((int(nproj[i]),1)), 'proj' : (int(nproj[i]),mmax) }) for i in range(lmax+1)] + Potso = [dict({'gamma_Jl' : np.zeros((int(nproj[i]),1)), 'proj' : (int(nproj[i]),mmax) }) for i in range(lmax+1)] + + l_read = float(l1_split[6][0]) + + l_count = 0 + lc_count = 6 + for l in range(int(lmax+1)): + if l != lloc: + Pot[l]['gamma_Jl'] = [float(l1_split[6 + l*mmax+l][i]) for i in range(1,nproj[l]+1)] + sz1 = (mmax,2+nproj[l]) + A1 = [float(l1_split[j+l*mmax][k]) if l==0 else float(l1_split[j+l*mmax + l][k]) for j in range(7 ,mmax+7) for k in range(2+nproj[l])] + y1 = np.reshape(np.array(A1), sz1) + r = y1[:,1] + Pot[l]['proj'] = y1[:,2:] + Pot[l]['proj'][1:,:] = Pot[l]['proj'][1:,:]/np.reshape(r[1:],(-1,1)) + Pot[l]['proj'][0,:] = Pot[l]['proj'][1,:] + else: + A2 = [float(l1_split[j+l*mmax][k]) if l==0 else float(l1_split[j+l*mmax + l][k]) for j in range(7 ,mmax+7) for k in range(3)] + y2 = np.reshape(np.array(A2), (mmax, 3)) + r = y2[:,1] + Vloc = y2[:,2] + + l_read = float(l1_split[6 + (l+1)*mmax+l+1][0]) + + l_count = l_count+1 + if l ==0: + lc_count = mmax+lc_count + else: + lc_count = mmax+lc_count+1 + + + if lloc > lmax or l_read ==4: + A3 = [float(l1_split[j+(l_count)*mmax+l_count][k]) for j in range(7 ,mmax+7) for k in range(3)] + y3 = np.reshape(np.array(A3), (mmax, 3)) + r = y3[:,1] + Vloc = y3[:,2] + l_count = l_count+1 + lc_count = mmax+lc_count+1 + + '''read spin-orbit projectors''' + if pspsoc == 1: + for l in range(1,lmax+1): + Potso[l]['gamma_Jl'] = [float(l1_split[6 + (l_count)*mmax][i]) for i in range(1,nproj[l]+1)] + sz = (mmax,2+nprojso[l]) + A4 = [float(l1_split[j+(l_count)*mmax+l_count][k]) for j in range(7 ,mmax+7) for k in range(2+nprojso[l])] + y4 = np.reshape(np.array(A4), sz) + r = y4[:,1] + Potso[l]['proj'] = y4[:,2:] + Potso[l]['proj'][1:,:] = Potso[l]['proj'][1:,:]/np.reshape(r[1:],(-1,1)) + Potso[l]['proj'][0,:] = Potso[l]['proj'][1,:] + lc_count = mmax + lc_count + + '''read core density''' + if fchrg > 0: + Atilde = [float(l1_split[lc_count+1+j][k]) for j in range(mmax) for k in range(7)] + y4 = np.reshape(np.array(Atilde), (mmax, 7)) + uu = y4[:,2]/(4*math.pi) + rho_tilde = uu + rTilde = y4[:,1] + lc_count = mmax + lc_count + + else: + rTilde = r + rho_tilde= np.zeros((np.size(r),1)) + + uu = np.zeros((mmax)) + A5 = [float(l1_split[lc_count+1+j][k]) for j in range(mmax) for k in range(5)] + y5 = np.reshape(np.array(A5), (mmax,5)) + uu[:] = y5[:,2]/(4*math.pi) + rho_isolated_guess = uu + + rc = 0 + + rc_max_list = np.zeros((lmax+1)) + for l in range(lmax+1): + r_core_read = float(l1_split[0][l+3]) + rc_max = r_core_read + if l != lloc: + ''' % check if r_core is large enough s.t. |proj| < 1E-8''' + r_indx_all = np.where(r < r_core_read) + r_indx = r_indx_all[0][-1] + for i in range(np.shape(Pot[l]['proj'])[1]): + try: + rc_temp = r[r_indx +np.where(np.absolute(Pot[l]['proj'][r_indx+1:,i])<(1e-8))[0][0] - 1] + except: + rc_temp = r[-1] + if rc_temp>rc_max: + rc_max = rc_temp + + rc_max_list[l] = rc_max + if print_debug: + print("atom type {first}, l = {second}, r_core_read {third}, change to rmax where |UdV| < (1e-8), {fourth} \n".format(first = 1, second = l, third = r_core_read, fourth = rc_max)) + if rc_max > rc: + rc = rc_max + + r_grid_vloc = r + r_grid_rho = r + + XC = pspxc + r_grid_rho_Tilde = rTilde + + return [Z, Zatom, XC, Vloc, r_grid_vloc, rc, Pot, lmax, lloc, nproj, r_grid_rho, rho_isolated_guess, rho_tilde, r_grid_rho_Tilde, pspsoc, Potso, rc_max_list] + diff --git a/utils/atom/scf/__init__.py b/utils/atom/scf/__init__.py new file mode 100644 index 00000000..1a5870ff --- /dev/null +++ b/utils/atom/scf/__init__.py @@ -0,0 +1,8 @@ +from .driver import SCFDriver, SCFSettings, SCFResult # noqa: F401 +from .eigensolver import EigenSolver # noqa: F401 +from .mixer import Mixer # noqa: F401 +from .hamiltonian import HamiltonianBuilder # noqa: F401 +from .density import DensityCalculator, DensityData # noqa: F401 +from .poisson import PoissonSolver # noqa: F401 +from .convergence import ConvergenceChecker, ConvergenceHistory # noqa: F401 +from .energy import EnergyCalculator, EnergyComponents # noqa: F401 \ No newline at end of file diff --git a/utils/atom/scf/convergence.py b/utils/atom/scf/convergence.py new file mode 100644 index 00000000..68e80dc1 --- /dev/null +++ b/utils/atom/scf/convergence.py @@ -0,0 +1,177 @@ +""" +Convergence criteria and checkers for SCF iterations +""" + +from __future__ import annotations +import numpy as np +from typing import Optional +from dataclasses import dataclass + +# Convergence Checker Error Messages +LOOP_TYPE_ERROR_MESSAGE = \ + "parameter loop_type must be 'Inner' or 'Outer', get {} instead" + +@dataclass +class ConvergenceHistory: + """Track convergence history""" + iterations: list[int] + residuals: list[float] + converged: bool = False + + def add(self, iteration: int, residual: float): + """Add convergence data point""" + self.iterations.append(iteration) + self.residuals.append(residual) + + +class ConvergenceChecker: + """ + Check SCF convergence based on density residual + + Convergence criterion: + ||ρ_out - ρ_in|| / ||ρ_out|| < tolerance + + Requires consecutive satisfaction to avoid false convergence + """ + + def __init__( + self, + tolerance: float = 1e-6, + n_consecutive: int = 1, + norm_type: int = 2, + loop_type: str = "Inner" + ): + """ + Parameters + ---------- + tolerance : float + Convergence threshold + n_consecutive : int + Number of consecutive iterations that must satisfy criterion + norm_type : int + Norm type for residual calculation (1, 2, or np.inf) + loop_type : str + Type of loop for display purposes ("Inner" or "Outer") + """ + assert loop_type in ["Inner", "Outer"], \ + LOOP_TYPE_ERROR_MESSAGE.format(loop_type) + + self.tolerance = tolerance + self.n_consecutive = n_consecutive + self.norm_type = norm_type + self.loop_type = loop_type + + self._consecutive_count = 0 + self._history = ConvergenceHistory(iterations=[], residuals=[]) + + + def check( + self, + rho_in: np.ndarray, + rho_out: np.ndarray, + iteration: int, + print_status: bool = False, + prefix: str = "" + ) -> tuple[bool, float]: + """ + Check if SCF has converged + + Parameters + ---------- + rho_in : np.ndarray + Input density for this iteration + rho_out : np.ndarray + Output density from this iteration + iteration : int + Current iteration number + print_status : bool, optional + If True, print convergence status for this iteration + Default: False + prefix : str, optional + Prefix for printed output (e.g., " " for indentation) + Default: "" + + Returns + ------- + converged : bool + Whether SCF has converged + residual : float + Convergence residual for this iteration + """ + # Compute relative residual + residual = self._compute_residual(rho_in, rho_out) + + # Update history + self._history.add(iteration, residual) + + # Check if residual is below tolerance + if residual < self.tolerance: + self._consecutive_count += 1 + else: + self._consecutive_count = 0 + + # Converged if satisfied for n_consecutive iterations + converged = (self._consecutive_count >= self.n_consecutive) + + if converged: + self._history.converged = True + + # Print status if requested + if print_status: + self.print_status(iteration, residual, prefix) + + return converged, residual + + + def _compute_residual(self, rho_in: np.ndarray, rho_out: np.ndarray) -> float: + """ + Compute relative residual: ||ρ_out - ρ_in|| / ||ρ_out|| + """ + diff = rho_out - rho_in + norm_diff = np.linalg.norm(diff, ord=self.norm_type) + norm_out = np.linalg.norm(rho_out, ord=self.norm_type) + + if norm_out < 1e-14: + return np.inf + + return norm_diff / norm_out + + + def reset(self): + """Reset convergence state""" + self._consecutive_count = 0 + self._history = ConvergenceHistory(iterations=[], residuals=[]) + + + @property + def history(self) -> ConvergenceHistory: + """Get convergence history""" + return self._history + + + def print_header(self, prefix: str = ""): + """Print table header for convergence status""" + print(f"{prefix}\t {'Iter':^4} {'Residual':^14} {'Target':^14} {'Converged':^8}") + print(f"{prefix}{'-'*60}") + + + def print_status(self, iteration: int, residual: float, prefix: str = ""): + """Print convergence status in table format""" + status = "Yes" if residual < self.tolerance else "No" + if self.loop_type == "Outer": + print(f"{prefix}\t Density residual of outer iteration: {residual:.6e}") + print() + else: + # print(f"[Inner] Iter {iteration:3d}: residual = {residual:.8e} {status}") + print(f"{prefix}\t {iteration:^4d} {residual:^14.6e} {self.tolerance:^14.6e} {status:^8}") + + + def print_footer(self, converged: bool, n_iterations: int, prefix: str = ""): + """Print table footer with final status""" + status_msg = "converged" if converged else "not converged" + if self.loop_type == "Outer": + print(f"[Outer] Converged after {n_iterations} iteration(s)") + else: + print(f"{prefix}\t SCF Iteration {status_msg} after {n_iterations} iteration(s)") + print() + diff --git a/utils/atom/scf/density.py b/utils/atom/scf/density.py new file mode 100644 index 00000000..4e19d4ce --- /dev/null +++ b/utils/atom/scf/density.py @@ -0,0 +1,679 @@ +""" +Density calculator for Kohn-Sham DFT +Computes electron density from orbitals and occupation numbers +""" + +from __future__ import annotations +import numpy as np +from typing import Optional +from dataclasses import dataclass + +from ..mesh.operators import GridData +from ..utils.occupation_states import OccupationInfo + +# Constant values +DEFAULT_DENSITY_VALUE = 1e-12 + +# Warning messages +RHO_INTEGRAL_TOO_SMALL_WARNING = \ + "Warning: Density integral almost zero, using default values {}" + +# Error messages +GRID_DATA_TYPE_ERROR_MESSAGE = \ + "parameter grid_data must be an instance of GridData, get type {} instead" +DERIVATIVE_MATRIX_TYPE_ERROR_MESSAGE = \ + "parameter derivative_matrix must be an instance of np.ndarray, get type {} instead" +DERIVATIVE_MATRIX_SHAPE_ERROR_MESSAGE = \ + "parameter derivative_matrix's shape {shape} must match grid_data shape ({n_elem}, {n_quad}, {n_quad})" +DERIVATIVE_MATRIX_NDIM_ERROR_MESSAGE = \ + "parameter derivative_matrix must be a 3D array, get dimension {} instead" +OCCUPATION_INFO_TYPE_ERROR_MESSAGE = \ + "parameter occupation_info must be an instance of OccupationInfo, get type {} instead" +VERBOSE_TYPE_ERROR_MESSAGE = \ + "parameter verbose must be an instance of bool, get type {} instead" + +RHO_NLCC_SHAPE_ERROR_MESSAGE = \ + "parameter rho_nlcc must have the same number of quadrature points as orbitals, get shape {} instead" + + +@dataclass +class DensityData: + """Container for density and related quantities""" + rho : np.ndarray # electron density ρ(r) + grad_rho : Optional[np.ndarray] = None # |∇ρ(r)| for GGA + tau : Optional[np.ndarray] = None # kinetic energy density for meta-GGA + + def __post_init__(self): + """Validate shapes""" + n_points = self.rho.shape[0] + if self.grad_rho is not None: + assert self.grad_rho.shape[0] == n_points + if self.tau is not None: + assert self.tau.shape[0] == n_points + + +class DensityCalculator: + """ + Computes electron density from Kohn-Sham orbitals + + For spherically symmetric atoms, the density is: + ρ(r) = (1/4π) Σ_i f_i |ψ_i(r)/r|² + + where f_i is the occupation number and ψ_i(r) is the radial wavefunction. + """ + + def __init__( + self, + grid_data : GridData, + occupation_info : OccupationInfo, + derivative_matrix : np.ndarray, + verbose: bool = False): + """ + Parameters + ---------- + grid_data : GridData + Grid information (quadrature points, weights) + occupation_info : OccupationInfo + Occupation numbers and quantum numbers + derivative_matrix : np.ndarray + Differentiation matrix + verbose : bool + If True, print normalization information during density calculation + """ + + self.quadrature_nodes = grid_data.quadrature_nodes + self.quadrature_weights = grid_data.quadrature_weights + self.occupation_info = occupation_info + self.derivative_matrix = derivative_matrix + self.verbose = verbose + self.n_electrons = np.sum(occupation_info.occupations) + + assert isinstance(grid_data, GridData), \ + GRID_DATA_TYPE_ERROR_MESSAGE.format(type(grid_data)) + assert isinstance(self.occupation_info, OccupationInfo), \ + OCCUPATION_INFO_TYPE_ERROR_MESSAGE.format(type(self.occupation_info)) + assert isinstance(self.derivative_matrix, np.ndarray), \ + DERIVATIVE_MATRIX_TYPE_ERROR_MESSAGE.format(type(self.derivative_matrix)) + assert isinstance(self.verbose, bool), \ + VERBOSE_TYPE_ERROR_MESSAGE.format(type(self.verbose)) + assert self._check_derivative_matrix_shape(self.derivative_matrix, grid_data) + + + @staticmethod + def _check_derivative_matrix_shape(derivative_matrix: np.ndarray, grid_data: GridData) -> bool: + assert derivative_matrix.ndim == 3, \ + DERIVATIVE_MATRIX_NDIM_ERROR_MESSAGE.format(derivative_matrix.ndim) + _n_elem = grid_data.number_of_finite_elements + _n_quad = grid_data.quadrature_nodes.shape[0] // grid_data.number_of_finite_elements + assert derivative_matrix.shape == (_n_elem, _n_quad, _n_quad), \ + DERIVATIVE_MATRIX_SHAPE_ERROR_MESSAGE.format( + shape = derivative_matrix.shape, + n_elem = _n_elem, + n_quad = _n_quad) + return True + + + + def compute_density( + self, + orbitals: np.ndarray, + normalize: bool = True + ) -> np.ndarray: + """ + Compute electron density from orbitals + + Parameters + ---------- + orbitals : np.ndarray + Radial wavefunctions, shape (n_states, n_quad_points) + These are R_nl(r), not R_nl(r)/r + normalize : bool + If True, normalize density to correct number of electrons + + Returns + ------- + rho : np.ndarray + Electron density at quadrature points, shape (n_quad_points,) + """ + + # Convert radial wavefunction R(r) to true wavefunction ψ(r) = R(r)/r + wavefunction = orbitals / self.quadrature_nodes[:, np.newaxis] + + + # Density: ρ(r) = (1/4π) Σ f_i |ψ_i|² + occupations = self.occupation_info.occupations[np.newaxis, :] + + + rho = (1.0 / (4 * np.pi)) * np.sum( + occupations * wavefunction**2, + axis=1 + ) + + # Normalize to correct electron count + if normalize: + rho = self.normalize_density(rho) + + return rho + + + def compute_density_gradient(self, rho: np.ndarray) -> np.ndarray: + """ + Compute density gradient magnitude for GGA functionals in spherical coordinates. + + For spherical systems with radial symmetry: ∇ρ = dρ/dr · r̂ + So |∇ρ| = |dρ/dr| + + The radial derivative is computed using the chain rule: + d(ρ·r)/dr = ρ + r·dρ/dr + Rearranging: + dρ/dr = [d(ρ·r)/dr - ρ] / r + + Parameters + ---------- + rho : np.ndarray + Electron density at quadrature points, shape (N_quad,) + + Returns + ------- + grad_rho : np.ndarray + |∇ρ(r)| = |dρ/dr| at quadrature points, shape (N_quad,) + + Notes + ----- + Matches reference implementation: + grad_rho = (D @ ((ρ·r).reshape(N_e, q, 1)) - ρ) / r + + This is used by GGA functionals (PBE, etc.) to compute σ = |∇ρ|². + """ + # Get dimensions + n_elem = self.derivative_matrix.shape[0] # number of elements + n_quad = self.derivative_matrix.shape[1] # quadrature points per element + + # Compute ρ·r and reshape for element-wise differentiation + rho_times_r = rho * self.quadrature_nodes + rho_times_r_reshaped = rho_times_r.reshape(n_elem, n_quad, 1) + + # Apply derivative matrix: D @ (ρ·r) + d_rho_r_dr = np.matmul(self.derivative_matrix, rho_times_r_reshaped).reshape(-1) + + # Compute dρ/dr = [d(ρ·r)/dr - ρ] / r + grad_rho = (d_rho_r_dr - rho) / self.quadrature_nodes + + return grad_rho + + + def compute_kinetic_energy_density(self, orbitals: np.ndarray) -> np.ndarray: + """ + Compute kinetic energy density τ for meta-GGA functionals. + + τ(r) = (1/2) Σ_i f_i [|∂(ψ_i)/∂r|² + l(l+1)|ψ_i/r|²] / (4π) + + Parameters + ---------- + orbitals : np.ndarray + Radial wavefunctions R_nl(r), shape (n_grid, n_states) + + Returns + ------- + tau : np.ndarray + Kinetic energy density at quadrature points, shape (n_grid,) + """ + # Get dimensions + n_grid, n_states = orbitals.shape # orbitals: (n_quad_points, n_states) + n_elem = self.derivative_matrix.shape[0] # Number of finite elements + n_quad = self.derivative_matrix.shape[1] # Quadrature points per element + + # Convert R(r) to ψ(r) = R(r)/r + orbitals_by_r = orbitals / self.quadrature_nodes[:, np.newaxis] + + # Compute ∂R/∂r using finite element derivative matrix + orbitals_reshaped = orbitals.reshape(n_elem, n_quad, n_states) + diff_orbitals = np.matmul(self.derivative_matrix, orbitals_reshaped).reshape(n_grid, n_states) + + # Compute ∂(ψ)/∂r = [∂R/∂r - R/r] / r + diff_orbitals_by_r = (diff_orbitals - orbitals_by_r) / self.quadrature_nodes[:, np.newaxis] + + # Get occupation numbers and angular momentum quantum numbers + occupations = self.occupation_info.occupations # Shape: (n_states,) + l_values = self.occupation_info.l_values # Shape: (n_states,) + + # Term 1: Radial derivative contribution |∂(ψ)/∂r|² + term1 = 0.5 * occupations[np.newaxis, :] * diff_orbitals_by_r**2 + + # Term 2: Angular momentum contribution l(l+1)|ψ/r|² + l_times_l_plus_1 = l_values * (l_values + 1) + term2 = 0.5 * occupations[np.newaxis, :] * l_times_l_plus_1[np.newaxis, :] * \ + (orbitals_by_r / self.quadrature_nodes[:, np.newaxis])**2 + + # Sum over orbitals and divide by 4π + tau = np.sum(term1 + term2, axis=-1) / (4 * np.pi) + + return tau + + + def create_density_data_from_rho( + self, + rho: np.ndarray, + compute_gradient: bool = False + ) -> DensityData: + """ + Create DensityData from electron density ρ + + This method constructs DensityData from an existing density array. + Note: tau (kinetic energy density) cannot be computed from ρ alone, + so it is always set to None when using this method. + + Parameters + ---------- + rho : np.ndarray + Electron density, shape (n_quad_points,) + compute_gradient : bool, optional + If True, compute |∇ρ| for GGA functionals + If False, grad_rho is set to None + Default: False + + Returns + ------- + density_data : DensityData + Container with ρ, optionally |∇ρ|, and tau=None + + Examples + -------- + >>> # LDA: only need density + >>> density_data = calc.create_density_data_from_rho(rho, compute_gradient=False) + >>> + >>> # GGA: need density and gradient + >>> density_data = calc.create_density_data_from_rho(rho, compute_gradient=True) + """ + # Compute gradient if requested + grad_rho = None + if compute_gradient: + grad_rho = self.compute_density_gradient(rho) + + # tau cannot be computed from rho alone, always None + tau = None + + return DensityData( + rho = rho, + grad_rho = grad_rho, + tau = tau + ) + + + def create_density_data_from_mixed( + self, + rho_mixed : np.ndarray, + orbitals : Optional[np.ndarray] = None, + compute_gradient : bool = False, + compute_tau : bool = False, + rho_nlcc : Optional[np.ndarray] = None + ) -> DensityData: + """ + Create DensityData from mixed density and orbitals. + + This method is specifically designed for SCF iterations where: + - rho is taken from input rho_mixed (NOT recomputed from orbitals) + - grad_rho is computed from the input rho_mixed + rho_nlcc + - tau is computed from input orbitals (only if compute_tau=True) + + Key difference from create_density_data_from_orbitals: + The density rho is NOT recomputed from orbitals, but taken directly + from the input rho_mixed. This is because in SCF mixing, the mixed + density may not correspond exactly to any orbital-based density. + + Use this method AFTER mixing in SCF loops. + + Parameters + ---------- + rho_mixed : np.ndarray + Mixed valence density from mixer.mix(), shape (n_quad_points,) + This is the density to be used in the next iteration + orbitals : np.ndarray, optional + Current orbitals, shape (n_states, n_quad_points) + Only required if compute_tau=True + Default: None + compute_gradient : bool, optional + If True, compute |∇ρ| for GGA functionals + Default: False + compute_tau : bool, optional + If True, compute kinetic energy density τ for meta-GGA functionals + Requires orbitals to be provided + Default: False + rho_nlcc : np.ndarray, optional + Non-linear core correction density from pseudopotential + If provided, will be added to rho_mixed: ρ_total = ρ_mixed + ρ_nlcc + Default: None (no core correction) + + Returns + ------- + density_data : DensityData + Container with ρ, optionally |∇ρ| and τ + Note: rho = rho_mixed + rho_nlcc (not recomputed from orbitals) + + Raises + ------ + ValueError + If compute_tau=True but orbitals is None + + Examples + -------- + >>> # LDA/GGA: no tau needed + >>> rho_mixed = mixer.mix(rho, rho_new) + >>> density_data = calc.create_density_data_from_mixed( + ... rho_mixed=rho_mixed, + ... compute_gradient=True, + ... compute_tau=False + ... # orbitals not needed + ... ) + >>> + >>> # meta-GGA: tau needed + >>> density_data = calc.create_density_data_from_mixed( + ... rho_mixed=rho_mixed, + ... orbitals=orbitals, # Required for tau + ... compute_gradient=True, + ... compute_tau=True, + ... rho_nlcc=rho_nlcc + ... ) + + Notes + ----- + Key difference from create_density_data_from_orbitals: + - rho is taken from input rho_mixed (NOT recomputed from orbitals) + - rho comes from mixing: rho_mixed = mixer.mix(rho_in, rho_out) + - grad_rho is computed from the mixed density (rho_mixed + rho_nlcc) + - tau is computed from input orbitals (only if requested) + + Why "mixed"? Because the density rho is not computed from orbitals + but taken directly from the input rho_mixed. In SCF mixing, the + mixed density may not correspond exactly to any orbital-based density. + """ + # Validate: if tau is requested, orbitals must be provided + if compute_tau and orbitals is None: + raise ValueError( + "orbitals must be provided when compute_tau=True. " + "Cannot compute kinetic energy density without orbitals." + ) + + # Total density for XC (mixed + NLCC) + rho_total = rho_mixed + rho_nlcc if rho_nlcc is not None else rho_mixed + + # Compute gradient from mixed total density + grad_rho = None + if compute_gradient: + grad_rho = self.compute_density_gradient(rho_total) + + # Compute tau from orbitals (only if requested) + tau = None + if compute_tau: + tau = self.compute_kinetic_energy_density(orbitals) + + return DensityData( + rho = rho_total, + grad_rho = grad_rho, + tau = tau + ) + + + def create_density_data_from_orbitals( + self, + orbitals : np.ndarray, + compute_gradient : bool = False, + compute_tau : bool = False, + normalize : bool = True, + rho_nlcc : Optional[np.ndarray] = None + ) -> DensityData: + """ + Create DensityData from Kohn-Sham orbitals + + This method computes density from orbitals and optionally computes + gradient and kinetic energy density for advanced functionals. + + For pseudopotential calculations, the NLCC (non-linear core correction) + density can be added to the valence density for XC functional evaluation. + + Parameters + ---------- + orbitals : np.ndarray + Radial wavefunctions, shape (n_states, n_quad_points) + compute_gradient : bool, optional + If True, compute |∇ρ| for GGA functionals + If False, grad_rho is set to None + Default: False + compute_tau : bool, optional + If True, compute kinetic energy density τ for meta-GGA functionals + If False, tau is set to None + Default: False + normalize : bool, optional + If True, normalize density to match total electron count + Default: True + rho_nlcc : np.ndarray, optional + Non-linear core correction density from pseudopotential + If provided, will be added to valence density: ρ_total = ρ_valence + ρ_nlcc + This is used for XC functional evaluation in pseudopotential calculations + Default: None (no core correction) + + Returns + ------- + density_data : DensityData + Container with ρ, optionally |∇ρ| and τ + Note: If rho_nlcc is provided, ρ includes the core correction + + Examples + -------- + >>> # LDA: only need density + >>> density_data = calc.create_density_data_from_orbitals( + ... orbitals, + ... compute_gradient=False, + ... compute_tau=False + ... ) + >>> + >>> # GGA: need density and gradient + >>> density_data = calc.create_density_data_from_orbitals( + ... orbitals, + ... compute_gradient=True, + ... compute_tau=False + ... ) + >>> + >>> # meta-GGA: need density, gradient, and tau + >>> density_data = calc.create_density_data_from_orbitals( + ... orbitals, + ... compute_gradient=True, + ... compute_tau=True + ... ) + >>> + >>> # Pseudopotential with NLCC + >>> density_data = calc.create_density_data_from_orbitals( + ... orbitals, + ... compute_gradient=True, + ... rho_nlcc=pseudo.get_rho_core_correction(r_nodes) + ... ) + + Notes + ----- + For pseudopotential calculations: + - Valence density ρ_v is computed from orbitals + - NLCC density ρ_nlcc represents frozen core electrons + - Total density ρ_total = ρ_v + ρ_nlcc is used for XC evaluation + - This improves XC energy accuracy compared to valence-only + """ + + if rho_nlcc is not None: + assert rho_nlcc.shape[0] == orbitals.shape[0], \ + RHO_NLCC_SHAPE_ERROR_MESSAGE.format(rho_nlcc.shape) + + # Compute valence density from orbitals + rho_valence = self.compute_density(orbitals, normalize=normalize) + + # Add NLCC if provided (for pseudopotential calculations) + if rho_nlcc is not None: + rho = rho_valence + rho_nlcc + else: + rho = rho_valence + + # Compute gradient if requested (uses total density including NLCC) + grad_rho = None + if compute_gradient: + grad_rho = self.compute_density_gradient(rho) + + # Compute tau if requested (only from valence orbitals) + tau = None + if compute_tau: + tau = self.compute_kinetic_energy_density(orbitals) + + return DensityData( + rho = rho, + grad_rho = grad_rho, + tau = tau + ) + + + + def normalize_density(self, rho: np.ndarray) -> np.ndarray: + """ + Normalize density to integrate to correct number of electrons + + Ensures that ∫ 4π r² ρ(r) dr = N_electrons by rescaling the density. + + Parameters + ---------- + density : np.ndarray + Unnormalized electron density at quadrature points + + Returns + ------- + normalized_density : np.ndarray + Density rescaled to integrate to the correct electron count + """ + # Compute the integrated electron count from current density + # ∫ 4π r² ρ(r) dr using quadrature: Σ 4π r² ρ(r) w + integrated_electron_count = np.sum( + 4 * np.pi * self.quadrature_nodes**2 * rho * self.quadrature_weights + ) + + # Handle edge case: if density is almost zero + if integrated_electron_count < DEFAULT_DENSITY_VALUE: + print(RHO_INTEGRAL_TOO_SMALL_WARNING.format(DEFAULT_DENSITY_VALUE)) + return np.ones_like(rho) * DEFAULT_DENSITY_VALUE + + # Rescale density to match target electron count + scaling_factor = self.n_electrons / integrated_electron_count + normalized_rho = rho * scaling_factor + + return normalized_rho + + + def check_normalization(self, rho: np.ndarray) -> float: + """ + Check how many electrons the density integrates to + + Returns the integrated electron count + """ + return np.sum(4 * np.pi * self.quadrature_nodes**2 * rho * self.quadrature_weights) + + @staticmethod + def add_nlcc_to_density_data( + density_data_valence: 'DensityData', + rho_nlcc: Optional[np.ndarray], + quadrature_nodes: Optional[np.ndarray] = None, + derivative_matrix: Optional[np.ndarray] = None + ) -> 'DensityData': + """ + Add NLCC (non-linear core correction) to valence density data. + + This method properly handles the NLCC correction for pseudopotential calculations. + When rho_nlcc is added to valence density: + - rho_total = rho_valence + rho_nlcc + - grad_rho must be recomputed from rho_total (not reused from valence) + - tau remains unchanged (only depends on valence orbitals) + + Parameters + ---------- + density_data_valence : DensityData + Valence electron density data (from KS orbitals) + rho_nlcc : np.ndarray, optional + Non-linear core correction density + If None, returns the input density_data_valence unchanged + quadrature_nodes : np.ndarray, optional + Quadrature node positions, shape (n_quad_points,) + Required if density_data_valence.grad_rho is not None + derivative_matrix : np.ndarray, optional + Derivative matrix for computing grad_rho + Required if density_data_valence.grad_rho is not None + Shape: (n_elem, n_quad, n_quad) + + Returns + ------- + density_data_total : DensityData + Total density data including NLCC correction + - rho = rho_valence + rho_nlcc + - grad_rho = recomputed from total density (if grad_rho was provided) + - tau = same as input (unchanged) + + Raises + ------ + ValueError + If rho_nlcc is provided and grad_rho is not None, but quadrature_nodes + or derivative_matrix are missing + + Notes + ----- + This static method follows the same logic as DensityCalculator.compute_density_gradient + for consistency with the rest of the codebase. + + Examples + -------- + >>> # LDA: no gradient needed + >>> density_total = DensityCalculator.add_nlcc_to_density_data( + ... density_data_valence, + ... rho_nlcc=rho_nlcc + ... ) + >>> + >>> # GGA: gradient needs to be recomputed + >>> density_total = DensityCalculator.add_nlcc_to_density_data( + ... density_data_valence, + ... rho_nlcc=rho_nlcc, + ... quadrature_nodes=r_nodes, + ... derivative_matrix=D + ... ) + """ + # If no NLCC provided, return input unchanged + if rho_nlcc is None: + return density_data_valence + + # Add NLCC to valence density + rho_total = density_data_valence.rho + rho_nlcc + + # Handle gradient: if it was provided, it needs to be recomputed + grad_rho = None + if density_data_valence.grad_rho is not None: + # Need quadrature_nodes and derivative_matrix to recompute gradient + if quadrature_nodes is None or derivative_matrix is None: + raise ValueError( + "quadrature_nodes and derivative_matrix must be provided " + "when density_data_valence.grad_rho is not None, " + "since grad_rho needs to be recomputed from the total density." + ) + + # Recompute gradient using same logic as compute_density_gradient + N_e = derivative_matrix.shape[0] # number of elements + q = derivative_matrix.shape[1] # quadrature points per element + + # Compute ρ·r and reshape for element-wise differentiation + rho_times_r = rho_total * quadrature_nodes + rho_times_r_reshaped = rho_times_r.reshape(N_e, q, 1) + + # Apply derivative matrix: D @ (ρ·r) + d_rho_r_dr = np.matmul(derivative_matrix, rho_times_r_reshaped).reshape(-1) + + # Compute dρ/dr = [d(ρ·r)/dr - ρ] / r + grad_rho = (d_rho_r_dr - rho_total) / quadrature_nodes + + # tau remains unchanged (only depends on valence orbitals) + tau = density_data_valence.tau + + return DensityData( + rho=rho_total, + grad_rho=grad_rho, + tau=tau + ) + diff --git a/utils/atom/scf/driver.py b/utils/atom/scf/driver.py new file mode 100644 index 00000000..4891bbe3 --- /dev/null +++ b/utils/atom/scf/driver.py @@ -0,0 +1,1025 @@ +from __future__ import annotations +import numpy as np +from typing import Dict, Any, Optional, Union, List +from dataclasses import dataclass, field + +from .hamiltonian import HamiltonianBuilder, SwitchesFlags +from .density import DensityCalculator, DensityData +from .poisson import PoissonSolver +from .convergence import ConvergenceChecker +from .eigensolver import EigenSolver +from .mixer import Mixer +from ..utils.occupation_states import OccupationInfo +from ..xc.evaluator import XCEvaluator, create_xc_evaluator, XCPotentialData +from ..xc.functional_requirements import get_functional_requirements, FunctionalRequirements +from ..xc.hybrid import HartreeFockExchange + + +# SCF Settings Error Messages +INNER_MAX_ITER_TYPE_ERROR_MESSAGE = \ + "parameter inner_max_iter must be an integer, get type {} instead" +RHO_TOL_TYPE_ERROR_MESSAGE = \ + "parameter rho_tol must be a float, get type {} instead" +N_CONSECUTIVE_TYPE_ERROR_MESSAGE = \ + "parameter n_consecutive must be an integer, get type {} instead" +OUTER_MAX_ITER_TYPE_ERROR_MESSAGE = \ + "parameter outer_max_iter must be an integer, get type {} instead" +OUTER_RHO_TOL_TYPE_ERROR_MESSAGE = \ + "parameter outer_rho_tol must be a float, get type {} instead" +PRINT_DEBUG_TYPE_ERROR_MESSAGE = \ + "parameter print_debug must be a boolean, get type {} instead" + +# SCF Result Error Messages +EIGENVALUES_TYPE_ERROR_MESSAGE = \ + "parameter eigenvalues must be a numpy array, get type {} instead" +EIGENVECTORS_TYPE_ERROR_MESSAGE = \ + "parameter eigenvectors must be a numpy array, get type {} instead" +RHO_TYPE_ERROR_MESSAGE = \ + "parameter rho must be a numpy array, get type {} instead" +CONVERGED_TYPE_ERROR_MESSAGE = \ + "parameter converged must be a boolean, get type {} instead" +ITERATIONS_TYPE_ERROR_MESSAGE = \ + "parameter iterations must be an integer, get type {} instead" +RESIDUAL_TYPE_ERROR_MESSAGE = \ + "parameter residual must be a float, get type {} instead" +TOTAL_ENERGY_TYPE_ERROR_MESSAGE = \ + "parameter total_energy must be a float, get type {} instead" +ENERGY_COMPONENTS_TYPE_ERROR_MESSAGE = \ + "parameter energy_components must be a dictionary, get type {} instead" +OUTER_ITERATIONS_TYPE_ERROR_MESSAGE = \ + "parameter outer_iterations must be an integer, get type {} instead" +OUTER_CONVERGED_TYPE_ERROR_MESSAGE = \ + "parameter outer_converged must be a boolean, get type {} instead" + + +# SCF Driver Error Messages +HAMILTONIAN_BUILDER_TYPE_ERROR_MESSAGE = \ + "parameter hamiltonian_builder must be a HamiltonianBuilder, get type {} instead" +DENSITY_CALCULATOR_TYPE_ERROR_MESSAGE = \ + "parameter density_calculator must be a DensityCalculator, get type {} instead" +POISSON_SOLVER_TYPE_ERROR_MESSAGE = \ + "parameter poisson_solver must be a PoissonSolver, get type {} instead" +EIGENSOLVER_TYPE_ERROR_MESSAGE = \ + "parameter eigensolver must be a EigenSolver, get type {} instead" +MIXER_TYPE_ERROR_MESSAGE = \ + "parameter mixer must be a Mixer, get type {} instead" +OCCUPATION_INFO_TYPE_ERROR_MESSAGE = \ + "parameter occupation_info must be a OccupationInfo, get type {} instead" + + +RHO_INITIAL_TYPE_ERROR_MESSAGE = \ + "parameter rho_initial must be a numpy array, get type {} instead" +SETTINGS_TYPE_ERROR_MESSAGE = \ + "parameter settings must be a SCFSettings or a dictionary, get type {} instead" +H_HF_EXCHANGE_DICT_BY_L_TYPE_ERROR_MESSAGE = \ + "provided parameter H_hf_exchange_dict_by_l must be a dictionary, get type {} instead" +ORBITALS_INITIAL_TYPE_ERROR_MESSAGE = \ + "parameter orbitals_initial must be a numpy array, get type {} instead" + +# SCF Driver Warning Messages +INNER_SCF_DID_NOT_CONVERGE_WARNING = \ + "WARNING: Inner SCF did not converge after {max_iter} iterations" +HF_CALCULATOR_NOT_AVAILABLE_WARNING = \ + "WARNING: Hartree-Fock calculator is not available, please initialize the HF calculator first" + + +@dataclass +class SCFSettings: + """ + Configuration settings for SCF calculation + + Attributes + ---------- + inner_max_iter : int + Maximum number of inner SCF iterations + rho_tol : float + Convergence tolerance for density residual + n_consecutive : int + Number of consecutive converged iterations required + outer_max_iter : int + Maximum number of outer SCF iterations (for HF/OEP/RPA) + outer_rho_tol : float + Convergence tolerance for outer loop density residual + print_debug : bool + Whether to print debug information during SCF + """ + + # Inner loop settings + inner_max_iter: int = 200 + rho_tol: float = 1e-6 + n_consecutive: int = 1 + + # Outer loop settings + outer_max_iter: int = 1 + outer_rho_tol: float = 1e-5 + + # Output settings + print_debug: bool = False + + + def __post_init__(self): + # type check (allow int, float and numpy types) + assert isinstance(self.inner_max_iter, (int, np.integer)), \ + INNER_MAX_ITER_TYPE_ERROR_MESSAGE.format(type(self.inner_max_iter)) + assert isinstance(self.rho_tol, (int, float, np.floating)), \ + RHO_TOL_TYPE_ERROR_MESSAGE.format(type(self.rho_tol)) + assert isinstance(self.n_consecutive, (int, np.integer)), \ + N_CONSECUTIVE_TYPE_ERROR_MESSAGE.format(type(self.n_consecutive)) + assert isinstance(self.outer_max_iter, (int, np.integer)), \ + OUTER_MAX_ITER_TYPE_ERROR_MESSAGE.format(type(self.outer_max_iter)) + assert isinstance(self.outer_rho_tol, (int, float, np.floating)), \ + OUTER_RHO_TOL_TYPE_ERROR_MESSAGE.format(type(self.outer_rho_tol)) + assert isinstance(self.print_debug, (bool, np.bool_)), \ + PRINT_DEBUG_TYPE_ERROR_MESSAGE.format(type(self.print_debug)) + + + @classmethod + def from_dict(cls, settings_dict: dict) -> SCFSettings: + """ + Create SCFSettings from dictionary + + Parameters + ---------- + settings_dict : dict + Dictionary containing settings + + Returns + ------- + SCFSettings + Settings object + """ + return cls( + inner_max_iter=settings_dict.get('inner_max_iter', 200), + rho_tol=settings_dict.get('rho_tol', 1e-6), + n_consecutive=settings_dict.get('n_consecutive', 1), + outer_max_iter=settings_dict.get('outer_max_iter', 1), + outer_rho_tol=settings_dict.get('outer_rho_tol', 1e-5), + print_debug=settings_dict.get('print_debug', False) + ) + + + def to_dict(self) -> dict: + """ + Convert to dictionary format + + Returns + ------- + dict + Dictionary representation of settings + """ + return { + 'inner_max_iter': self.inner_max_iter, + 'rho_tol': self.rho_tol, + 'n_consecutive': self.n_consecutive, + 'outer_max_iter': self.outer_max_iter, + 'outer_rho_tol': self.outer_rho_tol, + 'print_debug': self.print_debug + } + + +@dataclass +class SCFResult: + """ + Results from SCF calculation + + Attributes + ---------- + eigen_energies : np.ndarray + Kohn-Sham eigenvalues (orbital energies) for all states, shape (n_states,) + orbitals : np.ndarray + Converged Kohn-Sham orbitals (radial wavefunctions R_nl(r)) + Shape: (n_states, n_quad_points) + density_data : DensityData + Converged electron density and related quantities (rho, grad_rho, tau) + converged : bool + Whether inner SCF loop converged + iterations : int + Number of inner SCF iterations performed + rho_residual : float + Final density residual of inner loop (L2 norm) + outer_iterations : int, optional + Number of outer SCF iterations (for HF/OEP/RPA methods) + outer_converged : bool, optional + Whether outer SCF loop converged + total_energy : float, optional + Total energy of the system + energy_components : dict, optional + Breakdown of energy components (kinetic, Hartree, XC, etc.) + """ + + # Core results + eigen_energies: np.ndarray + orbitals: np.ndarray + density_data: DensityData + + # Inner loop convergence info + converged: bool + iterations: int + rho_residual: float + + # Outer loop info (optional) + outer_iterations : Optional[int] = None + outer_converged : Optional[bool] = None + + # Energy info (optional) + total_energy : Optional[float] = None + energy_components : Optional[dict] = field(default=None) + + def __post_init__(self): + # type check for required fields + assert isinstance(self.eigen_energies, np.ndarray), \ + "eigen_energies must be a numpy array, got {}".format(type(self.eigen_energies)) + assert isinstance(self.orbitals, np.ndarray), \ + "orbitals must be a numpy array, got {}".format(type(self.orbitals)) + assert isinstance(self.density_data, DensityData), \ + "density_data must be a DensityData instance, got {}".format(type(self.density_data)) + assert isinstance(self.converged, bool), \ + CONVERGED_TYPE_ERROR_MESSAGE.format(type(self.converged)) + assert isinstance(self.iterations, int), \ + ITERATIONS_TYPE_ERROR_MESSAGE.format(type(self.iterations)) + assert isinstance(self.rho_residual, (float, np.floating)), \ + "rho_residual must be a float, got {}".format(type(self.rho_residual)) + + # type check for optional fields (only if not None) + if self.outer_iterations is not None: + assert isinstance(self.outer_iterations, int), \ + OUTER_ITERATIONS_TYPE_ERROR_MESSAGE.format(type(self.outer_iterations)) + if self.outer_converged is not None: + assert isinstance(self.outer_converged, bool), \ + OUTER_CONVERGED_TYPE_ERROR_MESSAGE.format(type(self.outer_converged)) + if self.total_energy is not None: + assert isinstance(self.total_energy, (float, np.floating)), \ + TOTAL_ENERGY_TYPE_ERROR_MESSAGE.format(type(self.total_energy)) + if self.energy_components is not None: + assert isinstance(self.energy_components, dict), \ + ENERGY_COMPONENTS_TYPE_ERROR_MESSAGE.format(type(self.energy_components)) + + + @classmethod + def from_dict(cls, result_dict: dict) -> SCFResult: + """ + Create SCFResult from dictionary + + Parameters + ---------- + result_dict : dict + Dictionary containing results + + Returns + ------- + SCFResult + Result object + """ + return cls( + eigenvalues=result_dict['eigenvalues'], + eigenvectors=result_dict['eigenvectors'], + rho=result_dict['rho'], + converged=result_dict['converged'], + iterations=result_dict['iterations'], + residual=result_dict['residual'], + outer_iterations=result_dict.get('outer_iterations'), + outer_converged=result_dict.get('outer_converged'), + total_energy=result_dict.get('total_energy'), + energy_components=result_dict.get('energy_components') + ) + + def to_dict(self) -> dict: + """ + Convert to dictionary format + + Returns + ------- + dict + Dictionary representation of results + """ + result = { + 'eigenvalues': self.eigenvalues, + 'eigenvectors': self.eigenvectors, + 'rho': self.rho, + 'converged': self.converged, + 'iterations': self.iterations, + 'residual': self.residual + } + + # Add optional fields if present + if self.outer_iterations is not None: + result['outer_iterations'] = self.outer_iterations + if self.outer_converged is not None: + result['outer_converged'] = self.outer_converged + if self.total_energy is not None: + result['total_energy'] = self.total_energy + if self.energy_components is not None: + result['energy_components'] = self.energy_components + + return result + + def summary(self) -> str: + """ + Get a summary string of the SCF results + + Returns + ------- + str + Summary of results + """ + lines = [ + "=" * 60, + "SCF Results Summary", + "=" * 60, + f"Inner SCF converged: {self.converged}", + f"Inner iterations: {self.iterations}", + f"Final residual: {self.residual:.6e}", + ] + + if self.outer_iterations is not None: + lines.extend([ + f"Outer SCF converged: {self.outer_converged}", + f"Outer iterations: {self.outer_iterations}", + ]) + + if self.total_energy is not None: + lines.append(f"Total energy: {self.total_energy:.10f} Ha") + + if self.energy_components is not None: + lines.append("\nEnergy components:") + for key, value in self.energy_components.items(): + lines.append(f" {key}: {value:.10f} Ha") + + lines.extend([ + f"Number of states: {len(self.eigenvalues)}", + f"Lowest eigenvalue: {self.eigenvalues[0]:.6f} Ha", + "=" * 60 + ]) + + return "\n".join(lines) + + + +class SCFDriver: + """ + Self-consistent field driver for Kohn-Sham DFT + + Manages both inner and outer SCF loops: + - Inner loop: standard KS self-consistency (rho → V → H → solve → rho') + - Outer loop: for methods requiring orbital-dependent potentials (HF, OEP, RPA) + """ + + def __init__( + self, + hamiltonian_builder : HamiltonianBuilder, + density_calculator : DensityCalculator, + poisson_solver : PoissonSolver, + eigensolver : EigenSolver, + mixer : Mixer, + occupation_info : OccupationInfo, + xc_functional : str, + hybrid_mixing_parameter : Optional[float] = None + ): + """ + Parameters + ---------- + hamiltonian_builder : HamiltonianBuilder + Constructs Hamiltonian matrices for each angular momentum channel + density_calculator : DensityCalculator + Computes electron density from Kohn-Sham orbitals + poisson_solver : PoissonSolver + Solves Poisson equation for Hartree potential + eigensolver : EigenSolver + Solves eigenvalue problems (H ψ = ε S ψ) + mixer : Mixer + Density mixing strategy for SCF convergence (linear, Pulay, etc.) + occupation_info : OccupationInfo + Occupation numbers and quantum numbers for atomic states + xc_functional : str + Name of XC functional (e.g., 'LDA_PZ', 'GGA_PBE', 'SCAN') + Used to determine what density-related quantities to compute + Also used to initialize the XC calculator internally + hybrid_mixing_parameter : float, optional + Mixing parameter for hybrid functionals (HF exchange fraction) + Required only for hybrid functionals (PBE0, HF) + - For PBE0: typically 0.25 + - For HF: 1.0 + For non-hybrid functionals, this parameter is ignored + This parameter is designed to be autodiff-compatible for delta learning + """ + self.hamiltonian_builder = hamiltonian_builder + self.density_calculator = density_calculator + self.poisson_solver = poisson_solver + self.eigensolver = eigensolver + self.mixer = mixer + self.occupation_info = occupation_info + self.xc_functional = xc_functional + self.hybrid_mixing_parameter = hybrid_mixing_parameter + + # Create SwitchesFlags instance (handles validation internally) + self.switches = SwitchesFlags(xc_functional, hybrid_mixing_parameter) + + # Get functional requirements (what to compute for this functional) + self.xc_requirements : FunctionalRequirements = get_functional_requirements(xc_functional) + + # Initialize XC calculator internally based on functional + self.xc_calculator : Optional[XCEvaluator] = self._initialize_xc_calculator( + derivative_matrix=density_calculator.derivative_matrix, + r_quad=density_calculator.quadrature_nodes + ) + + # Initialize HF exchange calculator for hybrid functionals + self.hf_calculator : Optional[HartreeFockExchange] = self._initialize_hf_calculator() + + # Extract NLCC density from pseudopotential (if using pseudopotential) + self.rho_nlcc : np.ndarray = self._initialize_nlcc_density() + + # Initialize convergence checkers (will be configured in run method) + self.inner_convergence_checker : Optional[ConvergenceChecker] = None + self.outer_convergence_checker : Optional[ConvergenceChecker] = None + + # type check for required parameters + assert isinstance(self.hamiltonian_builder, HamiltonianBuilder), \ + HAMILTONIAN_BUILDER_TYPE_ERROR_MESSAGE.format(type(self.hamiltonian_builder)) + assert isinstance(self.density_calculator, DensityCalculator), \ + DENSITY_CALCULATOR_TYPE_ERROR_MESSAGE.format(type(self.density_calculator)) + assert isinstance(self.poisson_solver, PoissonSolver), \ + POISSON_SOLVER_TYPE_ERROR_MESSAGE.format(type(self.poisson_solver)) + assert isinstance(self.eigensolver, EigenSolver), \ + EIGENSOLVER_TYPE_ERROR_MESSAGE.format(type(self.eigensolver)) + assert isinstance(self.mixer, Mixer), \ + MIXER_TYPE_ERROR_MESSAGE.format(type(self.mixer)) + assert isinstance(self.occupation_info, OccupationInfo), \ + OCCUPATION_INFO_TYPE_ERROR_MESSAGE.format(type(self.occupation_info)) + + + def _initialize_xc_calculator( + self, + derivative_matrix: np.ndarray, + r_quad: np.ndarray + ) -> Optional[XCEvaluator]: + """ + Initialize XC calculator based on the functional name. + + For functional 'None' (pure kinetic energy), no XC calculator is needed. + For all other functionals, create the appropriate evaluator instance. + + Parameters + ---------- + derivative_matrix : np.ndarray + Finite element derivative matrix (from DensityCalculator) + Required for GGA and meta-GGA to transform gradients to spherical form + r_quad : np.ndarray + Radial quadrature nodes (coordinates) + Required for spherical coordinate transformations + + Returns + ------- + xc_calculator : XCEvaluator or None + Specific XC functional evaluator (e.g., LDA_PZ, GGA_PBE). + Returns None if xc_functional is 'None'. + + Raises + ------ + ValueError + If the specified functional is not implemented + """ + if self.xc_functional in ['None', 'HF']: + return None + else: + return create_xc_evaluator( + functional_name=self.xc_functional, + derivative_matrix=derivative_matrix, + r_quad=r_quad + ) + + + def _initialize_hf_calculator(self) -> Optional[HartreeFockExchange]: + """ + Initialize Hartree-Fock exchange calculator for hybrid functionals. + + Returns + ------- + Optional[HartreeFockExchange] + HF exchange calculator if functional requires it, None otherwise + """ + # Only create HF calculator for hybrid functionals + if not self.switches.use_hf_exchange: + return None + + # Create HF exchange calculator with ops_builder and occupation_info + hf_calculator = HartreeFockExchange( + ops_builder=self.hamiltonian_builder.ops_builder, + occupation_info=self.occupation_info + ) + + return hf_calculator + + + def _initialize_nlcc_density(self) -> np.ndarray: + """ + Initialize non-linear core correction (NLCC) density from pseudopotential. + + NLCC is used to improve the accuracy of exchange-correlation energy + in pseudopotential calculations by including core electron effects. + + Returns + ------- + rho_nlcc : np.ndarray + Core correction density at quadrature points. + Returns zeros for all-electron calculations. + """ + # Get quadrature nodes from hamiltonian builder + quadrature_nodes = self.hamiltonian_builder.ops_builder.quadrature_nodes + + # Check if using pseudopotential or all-electron + if self.hamiltonian_builder.all_electron: + # No NLCC for all-electron calculations + return np.zeros_like(quadrature_nodes) + else: + # Extract NLCC density from pseudopotential + pseudo = self.hamiltonian_builder.pseudo + rho_nlcc = pseudo.get_rho_core_correction(quadrature_nodes) + return rho_nlcc + + + def get_total_density_for_xc(self, rho_valence: np.ndarray) -> np.ndarray: + """ + Get total density for exchange-correlation calculations. + + For pseudopotential calculations, XC functionals should use: + rho_total = rho_valence + rho_nlcc + + For all-electron calculations: + rho_total = rho_valence + + Parameters + ---------- + rho_valence : np.ndarray + Valence electron density from KS orbitals + + Returns + ------- + rho_total : np.ndarray + Total density including NLCC correction + """ + return rho_valence + self.rho_nlcc + + + def _get_zero_hf_exchange_matrices_dict(self) -> Dict[int, np.ndarray]: + """ + Create zero HF exchange matrices dictionary for all l channels. + + Returns + ------- + Dict[int, np.ndarray] + Dictionary mapping l values to zero matrices + Keys are unique l values from occupation_info + Values are zero matrices of shape (n_physical_nodes, n_physical_nodes) + """ + zero_matrices_dict = {} + + # Get matrix size from kinetic energy matrix + H_kinetic = self.hamiltonian_builder.H_kinetic + matrix_size = H_kinetic.shape[0] + + # Create zero matrices for all unique l values + for l in self.occupation_info.unique_l_values: + zero_matrices_dict[l] = np.zeros((matrix_size, matrix_size)) + + return zero_matrices_dict + + + def _compute_hf_exchange_matrices_dict(self, orbitals: np.ndarray) -> Dict[int, np.ndarray]: + """ + Compute Hartree-Fock exchange matrices for all l channels. + + This method delegates the calculation to the hf_calculator. + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) at quadrature points + Shape: (n_grid, n_orbitals) + + Returns + ------- + Dict[int, np.ndarray] + Dictionary mapping l values to HF exchange matrices + """ + if self.hf_calculator is None: + # Return zero matrices for all l channels + print(HF_CALCULATOR_NOT_AVAILABLE_WARNING) + return self._get_zero_hf_exchange_matrices_dict() + + # Delegate to hf_calculator + return self.hf_calculator.compute_exchange_matrices_dict(orbitals) + + + + def run( + self, + rho_initial : np.ndarray, + settings : Union[SCFSettings, Dict[str, Any]], + orbitals_initial : Optional[np.ndarray] = None + ) -> SCFResult: + """ + Run SCF calculation + + Parameters + ---------- + rho_initial : np.ndarray + Initial density guess + settings : SCFSettings or dict + SCF settings (max iterations, tolerances, etc.) + Can be a SCFSettings object or a dictionary + + Returns + ------- + result : SCFResult + SCF solution including eigenvalues, eigenvectors, density, energy + """ + assert isinstance(rho_initial, np.ndarray), \ + RHO_INITIAL_TYPE_ERROR_MESSAGE.format(type(rho_initial)) + + # Convert dict to SCFSettings if needed + if isinstance(settings, dict): + settings = SCFSettings.from_dict(settings) + elif not isinstance(settings, SCFSettings): + raise TypeError(SETTINGS_TYPE_ERROR_MESSAGE.format(type(settings))) + + # Determine if outer loop is needed + needs_outer_loop = (settings.outer_max_iter > 1) + + # Configure convergence checkers + self.inner_convergence_checker = ConvergenceChecker( + tolerance = settings.rho_tol, + n_consecutive = settings.n_consecutive, + loop_type = "Inner" + ) + + # Initialize outer convergence checker if outer loop is needed + if needs_outer_loop: + self.outer_convergence_checker = ConvergenceChecker( + tolerance = settings.outer_rho_tol, + n_consecutive = settings.n_consecutive, # Outer loop typically converges in 1 iteration + loop_type = "Outer" + ) + + if hasattr(settings, 'print_debug') and settings.print_debug: + print("="*60) + print("\t\t Self-Consistent Field") + print("="*60) + + if needs_outer_loop: + return self._outer_loop(rho_initial, settings, orbitals_initial) + else: + return self._inner_loop(rho_initial, settings, orbitals_initial) + + + def _reorder_eigenstates_by_occupation( + self, + eigenvalues_all : List[np.ndarray], + eigenvectors_all: List[np.ndarray] + ) -> tuple[np.ndarray, np.ndarray]: + """ + Reorder eigenvalues and eigenvectors from l-channel lists to match occupation order. + + When solving each l-channel separately, results are grouped by l: + [all l=0 states] [all l=1 states] [all l=2 states] ... + + But occupation list may have interleaved l values: + [1s(l=0), 2s(l=0), 2p(l=1), 3s(l=0), 3p(l=1)] + + This function reorders the results to match the occupation list order. + + Parameters + ---------- + eigenvalues_all : List[np.ndarray] + List of eigenvalue arrays, one per unique l value + eigenvalues_all[i] has shape (n_states_for_l[i],) + eigenvectors_all : List[np.ndarray] + List of eigenvector arrays, one per unique l value + eigenvectors_all[i] has shape (n_grid_points, n_states_for_l[i]) + + Returns + ------- + eigenvalues : np.ndarray + Reordered eigenvalues in occupation list order, shape (n_total_states,) + eigenvectors : np.ndarray + Reordered eigenvectors in occupation list order, shape (n_grid_points, n_total_states) + + Examples + -------- + For Al (Z=13): occupation = [1s(l=0), 2s(l=0), 2p(l=1), 3s(l=0), 3p(l=1)] + - Input: eigenvalues_all = [eigvals_l0, eigvals_l1] with l0=[1s,2s,3s], l1=[2p,3p] + - Output: eigenvalues = [1s, 2s, 2p, 3s, 3p] (correctly interleaved) + """ + # Preallocate output arrays + n_total_states = len(self.occupation_info.occupations) + n_grid_points = eigenvectors_all[0].shape[0] + eigenvalues = np.zeros(n_total_states) + eigenvectors = np.zeros((n_grid_points, n_total_states)) + + # Fill arrays according to occupation list order + for i_l, l in enumerate(self.occupation_info.unique_l_values): + # Find all indices in occupation list where l matches + sort_index = np.where(self.occupation_info.l_values == l)[0] + n_states = len(sort_index) + + # Place eigenstates at correct positions + eigenvalues[sort_index] = eigenvalues_all[i_l][:n_states] + eigenvectors[:, sort_index] = eigenvectors_all[i_l][:, :n_states] + + return eigenvalues, eigenvectors + + + + + def _inner_loop( + self, + rho_initial : np.ndarray, + settings : SCFSettings, + orbitals_initial : Optional[np.ndarray] = None, + H_hf_exchange_dict_by_l : Optional[Dict[int, np.ndarray]] = None, + ) -> SCFResult: + """ + Inner SCF loop: standard Kohn-Sham self-consistency + + Fixed: external potential, HF exchange (if any) + Iterate: rho → V_H, V_xc → H → solve → orbitals → rho' + + Parameters + ---------- + rho_initial : np.ndarray + Initial density guess + settings : SCFSettings + SCF settings + orbitals_initial : np.ndarray, optional + Initial orbitals guess for debugging + Shape: (n_grid, n_orbitals) + If provided, will be used as initial orbitals instead of solving eigenvalue problem + H_hf_exchange_dict_by_l : dict, optional + Hartree-Fock exchange matrices dictionary (from outer loop) + + Returns + ------- + result : SCFResult + Converged SCF state + """ + + # type check for required fields + assert isinstance(rho_initial, np.ndarray), \ + RHO_INITIAL_TYPE_ERROR_MESSAGE.format(type(rho_initial)) + assert isinstance(settings, SCFSettings), \ + SETTINGS_TYPE_ERROR_MESSAGE.format(type(settings)) + if orbitals_initial is not None: + assert isinstance(orbitals_initial, np.ndarray), \ + ORBITALS_INITIAL_TYPE_ERROR_MESSAGE.format(type(orbitals_initial)) + if H_hf_exchange_dict_by_l is not None: + assert isinstance(H_hf_exchange_dict_by_l, dict), \ + H_HF_EXCHANGE_DICT_BY_L_TYPE_ERROR_MESSAGE.format(type(H_hf_exchange_dict_by_l)) + + # initialize variables + max_iter = settings.inner_max_iter + print_debug = settings.print_debug + + # rho = rho_initial.copy() + + rho = self.density_calculator.normalize_density(rho_initial.copy()) + + density_data = self.density_calculator.create_density_data_from_mixed( + rho_mixed = rho, + orbitals = orbitals_initial, + compute_gradient = self.xc_requirements.needs_gradient, + compute_tau = self.xc_requirements.needs_tau and (orbitals_initial is not None), + rho_nlcc = self.rho_nlcc + ) + + # Reset mixer and convergence checker + self.mixer.reset() + self.inner_convergence_checker.reset() + + # Set HF exchange if provided + if H_hf_exchange_dict_by_l is not None: + self.hamiltonian_builder.set_hf_exchange_matrices(H_hf_exchange_dict_by_l) + + # Print convergence table header + if print_debug: + self.inner_convergence_checker.print_header(prefix="") + + # Main inner SCF loop + for iteration in range(max_iter): + + # ===== Step 1: Compute potentials ===== + # Hartree potential + v_hartree = self.poisson_solver.solve_hartree(rho) + + # XC potential + # For pseudopotentials: use rho_total = rho_valence + rho_nlcc + # For all-electron: rho_nlcc is zero, so rho_total = rho_valence + v_x = np.zeros_like(rho) # Default: no exchange potential + v_c = np.zeros_like(rho) # Default: no correlation potential + + if self.xc_calculator is not None: + # Compute XC using new interface: DensityData → XCPotentialData + xc_potential_data = self.xc_calculator.compute_xc(density_data) + v_x = xc_potential_data.v_x + v_c = xc_potential_data.v_c + de_xc_dtau = xc_potential_data.de_xc_dtau + + # ===== Step 2: Build and solve for each l channel ===== + eigenvalues_all = [] + eigenvectors_all = [] + + for l in self.occupation_info.unique_l_values: + # Build Hamiltonian for this l + H_l = self.hamiltonian_builder.build_for_l_channel( + l = l, + v_hartree = v_hartree, + v_x = v_x, + v_c = v_c, + switches = self.switches, + de_xc_dtau = de_xc_dtau, + symmetrize = False + ) + + S_inv_sqrt = self.hamiltonian_builder.ops_builder.get_S_inv_sqrt() + H_l = S_inv_sqrt[1:-1,1:-1] @ H_l[1:-1,1:-1] @ S_inv_sqrt[1:-1,1:-1] + H_l = 0.5 * (H_l + H_l.T) + + # Number of states to solve for this l + n_states = self.occupation_info.n_states_for_l(l) + + # Solve eigenvalue problem + # eigvals, eigvecs = self.eigensolver.solve_lowest(H_l[1:-1,1:-1], n_states) + eigvals, eigvecs = self.eigensolver.solve_lowest(H_l, n_states) + + eigenvalues_all.append(eigvals) + eigenvectors_all.append(eigvecs) + + # Reorder eigenstates to match occupation list order + eigenvalues, eigenvectors = self._reorder_eigenstates_by_occupation( + eigenvalues_all, eigenvectors_all + ) + + # Interpolate eigenvectors to quadrature points, also symmetrize the eigenvectors + orbitals = self.hamiltonian_builder.interpolate_eigenvectors_to_quadrature( + eigenvectors = eigenvectors, + symmetrize = True, + pad_width = 1, + ) + + # ===== Step 3: Compute new density ===== + # Compute new density from orbitals + rho_new = self.density_calculator.compute_density(orbitals, normalize=True) + + # ===== Step 4: Check convergence ===== + converged, residual = self.inner_convergence_checker.check( + rho, rho_new, iteration + 1, + print_status=print_debug, + prefix="" + ) + + if converged: + break + + # ===== Step 5: Mix densities and update density_data ===== + rho = self.mixer.mix(rho, rho_new) + + # Update density_data for next iteration using mixed density + density_data = self.density_calculator.create_density_data_from_mixed( + rho_mixed = rho, + orbitals = orbitals, + compute_gradient = self.xc_requirements.needs_gradient, + compute_tau = self.xc_requirements.needs_tau, + rho_nlcc = self.rho_nlcc + ) + + # Print convergence footer + if print_debug: + self.inner_convergence_checker.print_footer(converged, iteration + 1, prefix="") + + if not converged: + print(INNER_SCF_DID_NOT_CONVERGE_WARNING.format(max_iter=max_iter)) + + + # Create final density_data from converged orbitals, do not include NLCC + final_density_data : DensityData = self.density_calculator.create_density_data_from_orbitals( + orbitals = orbitals, + compute_gradient = self.xc_requirements.needs_gradient, + compute_tau = self.xc_requirements.needs_tau, + rho_nlcc = None + ) + + # Return final state + return SCFResult( + eigen_energies = eigenvalues, + orbitals = orbitals, + density_data = final_density_data, + converged = converged, + iterations = iteration + 1, + rho_residual = residual + ) + + + def _outer_loop( + self, + rho_initial : np.ndarray, + settings : SCFSettings, + orbitals_initial : Optional[np.ndarray] = None + ) -> SCFResult: + """ + Outer SCF loop: for orbital-dependent functionals + + Used for: + - Hartree-Fock exchange (requires orbitals) + - OEP methods (requires full spectrum) + - RPA correlation (requires response functions) + + Parameters + ---------- + rho_initial : np.ndarray + Initial density + settings : SCFSettings + SCF settings + orbitals_initial : np.ndarray, optional + Initial orbitals guess for debugging + Shape: (n_grid, n_orbitals) + If provided, will be used as initial orbitals instead of solving eigenvalue problem + Returns + ------- + result : SCFResult + Converged SCF state from outer loop + """ + # type check for required fields + assert isinstance(rho_initial, np.ndarray), \ + RHO_INITIAL_TYPE_ERROR_MESSAGE.format(type(rho_initial)) + assert isinstance(settings, SCFSettings), \ + SETTINGS_TYPE_ERROR_MESSAGE.format(type(settings)) + if orbitals_initial is not None: + assert isinstance(orbitals_initial, np.ndarray), \ + ORBITALS_INITIAL_TYPE_ERROR_MESSAGE.format(type(orbitals_initial)) + + # initialize variables + max_outer_iter = settings.outer_max_iter + print_debug = settings.print_debug + + rho = rho_initial.copy() + orbitals = orbitals_initial + + # Compute HF exchange matrices from initial orbitals if provided + if orbitals_initial is not None: + H_hf_exchange_dict_by_l = self._compute_hf_exchange_matrices_dict(orbitals_initial) + else: + H_hf_exchange_dict_by_l = self._get_zero_hf_exchange_matrices_dict() + + + # Reset outer convergence checker + self.outer_convergence_checker.reset() + + for outer_iter in range(max_outer_iter): + + if print_debug: + print(f"Outer iteration {outer_iter + 1}") + + # Run inner SCF with fixed HF exchange + inner_result : SCFResult = self._inner_loop( + rho_initial = rho, + settings = settings, + H_hf_exchange_dict_by_l = H_hf_exchange_dict_by_l + ) + + # update rho and orbitals + rho_new = inner_result.density_data.rho + orbitals = inner_result.orbitals + + # update HF exchange dictionary + H_hf_exchange_dict_by_l = self._compute_hf_exchange_matrices_dict(orbitals) + + + # Check outer loop convergence + outer_converged, outer_residual = self.outer_convergence_checker.check( + rho, rho_new, outer_iter + 1, + print_status=print_debug + ) + + if outer_converged: + break + + # Update for next outer iteration + rho = rho_new + + + # Update outer loop info in result + outer_iterations = outer_iter + 1 + outer_converged = (outer_iter < max_outer_iter - 1) + + # Print outer loop footer if debug enabled + if print_debug: + self.outer_convergence_checker.print_footer(outer_converged, outer_iterations) + + return SCFResult( + eigen_energies = inner_result.eigen_energies, + orbitals = inner_result.orbitals, + density_data = inner_result.density_data, + converged = outer_converged, + iterations = outer_iterations, + rho_residual = outer_residual, + ) + diff --git a/utils/atom/scf/eigensolver.py b/utils/atom/scf/eigensolver.py new file mode 100644 index 00000000..daed5991 --- /dev/null +++ b/utils/atom/scf/eigensolver.py @@ -0,0 +1,69 @@ +from __future__ import annotations +import numpy as np +from scipy.sparse.linalg import eigsh, LinearOperator +from scipy.linalg import eigh +from typing import Optional + + +class EigenSolver: + """ + Simplified eigenvalue solver matching reference implementation. + + For SCAN/RSCAN/R2SCAN: uses LinearOperator + eigsh + For others: uses eigh with subset_by_index + """ + + def __init__(self, xc_functional: Optional[str] = None): + """ + Initialize eigenvalue solver. + + Parameters + ---------- + xc_functional : str, optional + XC functional name (e.g., 'SCAN', 'RSCAN', 'R2SCAN', 'GGA_PBE') + """ + self.xc_functional = xc_functional + + def solve_lowest(self, H: np.ndarray, k: int) -> tuple[np.ndarray, np.ndarray]: + """ + Solve for k lowest eigenvalues and eigenvectors. + + Parameters + ---------- + H : np.ndarray + Hamiltonian matrix (symmetric/Hermitian) + k : int + Number of lowest eigenvalues to compute + + Returns + ------- + eigenvalues : np.ndarray + k lowest eigenvalues (sorted in ascending order) + eigenvectors : np.ndarray + Corresponding eigenvectors, shape (n, k) + """ + n = H.shape[0] + + # Use LinearOperator + eigsh for SCAN/R2SCAN + if self.xc_functional in ['SCAN', 'R2SCAN']: + def matvec(x): + return H @ x + + H_op = LinearOperator((n, n), matvec=matvec, dtype=np.float64) + k_solve = n - 1 + + eigvals, eigvecs = eigsh(H_op, k=k_solve, which='SA', tol=1e-14) + + # Sort and return only k eigenvalues + sort_idx = np.argsort(eigvals) + return eigvals[sort_idx][:k], eigvecs[:, sort_idx][:, :k] + + # Use eigh with subset_by_index for others (reference: subset_by_index=[0, k-1]) + else: + eigvals, eigvecs = eigh( + H, + subset_by_index=[0, k-1], + check_finite=False, + driver='evr' + ) + return eigvals, eigvecs diff --git a/utils/atom/scf/energy.py b/utils/atom/scf/energy.py new file mode 100644 index 00000000..8667592b --- /dev/null +++ b/utils/atom/scf/energy.py @@ -0,0 +1,507 @@ +""" +Energy calculator for Kohn-Sham DFT +Computes total energy and all components from converged SCF solution +""" + +from __future__ import annotations +import numpy as np +from typing import Optional, TYPE_CHECKING +from dataclasses import dataclass + +from ..mesh.operators import GridData +from ..utils.occupation_states import OccupationInfo +from ..scf.poisson import PoissonSolver +from ..xc.evaluator import XCEvaluator, XCPotentialData +from ..xc.hybrid import HartreeFockExchange +from ..mesh.operators import RadialOperatorsBuilder +from ..pseudo.local import LocalPseudopotential +from ..pseudo.non_local import NonLocalPseudopotential +from .density import DensityCalculator + + +if TYPE_CHECKING: + from .density import DensityData + + +# Error messages +DERIVATIVE_MATRIX_SHAPE_ERROR_MESSAGE = \ + "parameter derivative_matrix's shape {shape} must match grid_data shape ({n_elem}, {n_quad}, {n_quad})" +Z_NUCLEAR_NOT_PROVIDED_ERROR_MESSAGE = \ + "parameter z_nuclear must be provided, get {z_nuclear} instead" +V_LOCAL_PSP_NOT_PROVIDED_ERROR_MESSAGE = \ + "parameter v_local_psp must be provided, get {v_local_psp} instead" +INTEGRAND_NDIM_ERROR_MESSAGE = \ + "Integrand should be one-dimensional, but got {ndim} dimensions" +MIXING_PARAMETER_NOT_A_FLOAT_ERROR = \ + "parameter mixing_parameter must be a float, get type {} instead" +MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR = \ + "parameter mixing_parameter must be in [0, 1], got {} instead" + + +@dataclass +class EnergyComponents: + """Container for all energy components""" + # Kinetic energy + kinetic_radial : float # T_radial = (1/2) ∫ |dR/dr|² dr + kinetic_angular : float # T_angular = (1/2) Σ l(l+1) ∫ |R/r|² dr + + # Potential energies + external : float # E_ext = ∫ ρ V_ext dr (nuclear or local pseudopotential) + hartree : float # E_H = (1/2) ∫ ρ V_H dr + exchange : float # E_x (from XC functional) + correlation : float # E_c (from XC functional) + + # Optional: advanced functionals and corrections + nonlocal_psp : float = 0.0 # E_nl (non-local pseudopotential) + hf_exchange : float = 0.0 # E_HF (Hartree-Fock exchange) + rpa_correlation : float = 0.0 # E_RPA (RPA correlation) + + @property + def total_kinetic(self) -> float: + """Total kinetic energy""" + return self.kinetic_radial + self.kinetic_angular + + @property + def total_potential(self) -> float: + """Total potential energy""" + return (self.external + self.nonlocal_psp + self.hartree + + self.exchange + self.correlation + + self.hf_exchange + self.rpa_correlation) + + @property + def total(self) -> float: + """Total energy""" + return self.total_kinetic + self.total_potential + + def print_info(self, title: str = "Energy Components"): + """Print formatted energy information""" + # Title + print(f"{'='*60}") + print(f"\t\t {title}") + print(f"{'='*60}") + + # Kinetic energy + print(f"\t Kinetic (radial) : {self.kinetic_radial:16.8f} Ha") + print(f"\t Kinetic (angular) : {self.kinetic_angular:16.8f} Ha") + print(f"\t Total Kinetic : {self.total_kinetic:16.8f} Ha") + print(f"\t {'-'*42}") + + # External potential energy + print(f"\t External potential : {self.external:16.8f} Ha") + + print(f"\t Hartree : {self.hartree:16.8f} Ha") + print(f"\t Exchange : {self.exchange:16.8f} Ha") + print(f"\t Correlation : {self.correlation:16.8f} Ha") + if abs(self.nonlocal_psp) > 1e-12: + print(f"\t Nonlocal PSP : {self.nonlocal_psp:16.8f} Ha") + if abs(self.hf_exchange) > 1e-12: + print(f"\t HF Exchange : {self.hf_exchange:16.8f} Ha") + if abs(self.rpa_correlation) > 1e-12: + print(f"\t RPA Correlation : {self.rpa_correlation:16.8f} Ha") + print(f"\t Total Potential : {self.total_potential:16.8f} Ha") + print(f"\t {'-'*42}") + + # Total energy + print(f"\t TOTAL ENERGY : {self.total:16.8f} Ha") + print() + + +class EnergyCalculator: + """ + Computes total energy from converged Kohn-Sham solution + + Total energy: + E = T_s + E_ext + E_H + E_xc + E_HF + E_RPA + + where: + T_s = kinetic energy of non-interacting electrons + E_ext = external potential energy (nuclear or pseudopotential) + E_H = Hartree energy (classical electron-electron repulsion) + E_xc = exchange-correlation energy + E_HF = Hartree-Fock exchange (optional) + E_RPA = RPA correlation (optional) + """ + + def __init__( + self, + grid_data : GridData, + occupation_info : OccupationInfo, + ops_builder : RadialOperatorsBuilder, + poisson_solver : PoissonSolver, + pseudo : LocalPseudopotential, + xc_calculator : Optional[XCEvaluator] = None, + hf_calculator : Optional[HartreeFockExchange] = None, + derivative_matrix : Optional[np.ndarray] = None, + ): + """ + Parameters + ---------- + grid_data : GridData + Grid information (quadrature points, weights) from standard grid + occupation_info : OccupationInfo + Occupation numbers and quantum numbers + ops_builder : RadialOperatorsBuilder + Operator builder from standard grid + Note: ops_builder should be from standard grid for general use + poisson_solver : PoissonSolver + Solver for Hartree potential + pseudo : LocalPseudopotential + Pseudopotential object containing all-electron or pseudopotential information + xc_calculator : XCEvaluator or None + XC functional evaluator for energy densities + hf_calculator : HartreeFockExchange, optional + HF exchange calculator for hybrid functionals + Should be the same instance as used in SCFDriver + derivative_matrix : np.ndarray, optional + Derivative matrix for kinetic energy computation + Note: If None, uses ops_builder.derivative_matrix. + If provided, should be from dense grid for more accurate results. + """ + self.quadrature_nodes = grid_data.quadrature_nodes + self.quadrature_weights = grid_data.quadrature_weights + self.occupation_info = occupation_info + self.ops_builder = ops_builder + self.poisson_solver = poisson_solver + self.pseudo = pseudo + self.xc_calculator = xc_calculator + self.hf_calculator = hf_calculator + + # Use provided derivative_matrix or fall back to ops_builder's matrix + if derivative_matrix is not None: + self.derivative_matrix = derivative_matrix + else: + self.derivative_matrix = ops_builder.derivative_matrix + + # External potential - determined by pseudo.all_electron + self.all_electron = pseudo.all_electron + if self.all_electron: + self.v_ext = -pseudo.z_nuclear / self.quadrature_nodes + else: + self.v_ext = pseudo.get_v_local_component_psp(self.quadrature_nodes) + + # NLCC (Non-linear Core Correction) density + if self.all_electron: + # For all-electron calculations, rho_nlcc = 0 + self.rho_nlcc = np.zeros_like(self.quadrature_nodes) + else: + # For pseudopotential calculations, XC functionals should use: rho_total = rho_valence + rho_nlcc + self.rho_nlcc = pseudo.get_rho_core_correction(self.quadrature_nodes) + + # Non-local pseudopotential calculator + if not self.all_electron: + self.nonlocal_calculator = NonLocalPseudopotential( + pseudo=self.pseudo, + ops_builder=self.ops_builder + ) + else: + self.nonlocal_calculator = None + + + def compute_energy( + self, + orbitals: np.ndarray, + density_data: 'DensityData', + mixing_parameter: Optional[float] = None, + ) -> EnergyComponents: + """ + Compute total energy from converged SCF solution + + Parameters + ---------- + orbitals : np.ndarray + Converged Kohn-Sham orbitals (radial wavefunctions R_nl(r)) + Shape: (n_states, n_quad_points) + density_data : DensityData + Electron density and related quantities (rho, grad_rho, tau) + This density data should not include NLCC + + Returns + ------- + energy : EnergyComponents + All energy components + + Notes + ----- + This is a simplified interface that handles all internal details. + Matches reference code energy formula: + E = E_Ts1 + E_Ts2 + E_ext + E_nonlocal + E_H + E_HF + E_RPA + E_x + E_c + """ + if mixing_parameter is not None: + assert isinstance(mixing_parameter, float), \ + "mixing_parameter must be a float, get type {} instead".format(type(mixing_parameter)) + assert 0.0 <= mixing_parameter <= 1.0, \ + "mixing_parameter must be in [0, 1], got {}".format(mixing_parameter) + + # 1. Kinetic energy + T_radial, T_angular = self._compute_kinetic_energy(orbitals, self.derivative_matrix) + + # 2. External potential energy (local part) + E_ext = self._compute_external_energy(density_data.rho) + + # 3. Hartree energy (solve internally) + v_hartree = self.poisson_solver.solve_hartree(density_data.rho) + E_hartree = self._compute_hartree_energy(density_data.rho, v_hartree) + + # 4. XC energy (compute internally using density data with NLCC correction) + E_x, E_c = self._compute_xc_energy(density_data) + + # 5. Non-local pseudopotential energy + E_nonlocal_psp = self._compute_nonlocal_psp_energy(orbitals) + + # 6. Hartree-Fock exchange energy (if HF calculator is available) + E_hf_exchange = self._compute_hf_exchange_energy(orbitals) + + # 7. Advanced energy terms (placeholders for future implementation) + E_rpa_correlation = 0.0 + + if mixing_parameter is not None: + E_x *= (1.0 - mixing_parameter) + E_hf_exchange *= mixing_parameter + + return EnergyComponents( + kinetic_radial=T_radial, + kinetic_angular=T_angular, + external=E_ext, + hartree=E_hartree, + exchange=E_x, + correlation=E_c, + nonlocal_psp=E_nonlocal_psp, + hf_exchange=E_hf_exchange, + rpa_correlation=E_rpa_correlation + ) + + + def _compute_kinetic_energy( + self, + orbitals: np.ndarray, + derivative_matrix: np.ndarray + ) -> tuple[float, float]: + """ + Compute kinetic energy: T = T_radial + T_angular + + Given orbitals are R_nl(r), the radial wavefunction. + Orbitals are stored as column vectors: shape = (n_grid, n_orbitals) + + T_radial = (1/2) Σ_i f_i ∫ |dR_i/dr|² dr + T_angular = (1/2) Σ_i f_i l_i(l_i+1) ∫ |R_i/r|² dr + + Returns + ------- + T_radial, T_angular : float, float + """ + occupations = self.occupation_info.occupations + l_values = self.occupation_info.l_values + + # Save the shape information + n_grid_tol, n_orbitals = orbitals.shape + n_elem = derivative_matrix.shape[0] # Number of finite elements + n_quad = derivative_matrix.shape[1] # Quadrature points per element + assert n_grid_tol == n_elem * n_quad, \ + DERIVATIVE_MATRIX_SHAPE_ERROR_MESSAGE.format(shape = derivative_matrix.shape, n_elem = n_elem, n_quad = n_quad) + + # Reshape the orbitals to (n_elem, n_quad, n_orbitals) + orbitals_reshaped = orbitals.reshape(n_elem, n_quad, n_orbitals) + + # Radial kinetic energy : T_radial + # Formula: T_radial = 0.5 * sum(occ * (dR/dr)^2 * w) + dR_dr = np.einsum('ejk,ekn->ejn', derivative_matrix, orbitals_reshaped).reshape(n_grid_tol, n_orbitals) + T_radial = 0.5 * np.sum(occupations[np.newaxis, :] * (dR_dr ** 2) * self.quadrature_weights[:, np.newaxis]) + + # Angular kinetic energy: T_angular + # Formula: T_angular = sum(occ * l(l+1)/2 * (R/r)^2 * w) + orb_div_r = orbitals / self.quadrature_nodes[:, np.newaxis] + l_factor = l_values * (l_values + 1) / 2.0 + T_angular = np.sum(occupations[np.newaxis, :] * l_factor[np.newaxis, :] * (orb_div_r**2) * self.quadrature_weights[:, np.newaxis]) + + return T_radial, T_angular + + + def _compute_external_energy(self, rho: np.ndarray) -> float: + """ + External potential energy: E_ext = ∫ ρ(r) v_ext(r) d³r + """ + integrand = rho * self.v_ext + return self._integrate(integrand) + + + def _compute_hartree_energy(self, rho: np.ndarray, v_hartree: np.ndarray) -> float: + """ + Hartree energy: E_H = (1/2) ∫ ρ(r) V_H(r) d³r + + The factor 1/2 avoids double-counting + """ + integrand = rho * v_hartree + return 0.5 * self._integrate(integrand) + + + def _compute_xc_energy(self, density_data: 'DensityData') -> tuple[float, float]: + """ + Compute exchange-correlation energy with NLCC correction. + + This method handles the proper inclusion of NLCC density for pseudopotential + calculations. The valence density is updated to include core correction before + computing XC energy. + + Parameters + ---------- + density_data : DensityData + Valence electron density data (does not include NLCC) + + Returns + ------- + E_x, E_c : float, float + Exchange and correlation energy components + """ + if self.xc_calculator is None: + return 0.0, 0.0 + + # Get total density including NLCC for pseudopotential calculations + density_data_total = self.get_total_density_data_for_xc(density_data) + + # Compute XC potential using total density + xc_potential_data = self.xc_calculator.compute_xc(density_data_total) + + # Integrate energy densities + E_x = self._integrate(density_data_total.rho * xc_potential_data.e_x) + E_c = self._integrate(density_data_total.rho * xc_potential_data.e_c) + + return E_x, E_c + + + def _integrate(self, integrand: np.ndarray) -> float: + """ + Integrate in spherical coordinates: ∫ f(r) 4π r² dr, the integrand should be one-dimensional + """ + assert integrand.ndim == 1, \ + INTEGRAND_NDIM_ERROR_MESSAGE.format(ndim = integrand.ndim) + return np.sum(4 * np.pi * self.quadrature_nodes**2 * integrand * self.quadrature_weights) + + + def get_total_density_data_for_xc(self, density_data: 'DensityData') -> 'DensityData': + """ + Get total density data for exchange-correlation calculations. + + For pseudopotential calculations, XC functionals should use: + rho_total = rho_valence + rho_nlcc + + For all-electron calculations: + rho_total = rho_valence + + Note: grad_rho will be recomputed from the total density if it was provided, + since grad_rho must be consistent with the total density. + + Parameters + ---------- + density_data : DensityData + Valence electron density data from KS orbitals + + Returns + ------- + density_data_total : DensityData + Total density data including NLCC correction + """ + # Use static method to add NLCC correction + # This properly handles recomputing grad_rho if needed + density_data_total = DensityCalculator.add_nlcc_to_density_data( + density_data_valence=density_data, + rho_nlcc=self.rho_nlcc if not self.all_electron else None, + quadrature_nodes=self.quadrature_nodes, + derivative_matrix=self.derivative_matrix + ) + + return density_data_total + + + def compute_xc_potential(self, density_data: 'DensityData'): + """ + Compute exchange-correlation potential for given density data. + + This method handles NLCC correction for pseudopotential calculations. + The input density_data contains valence density only, and NLCC is added + for XC calculations. + + Parameters + ---------- + density_data : DensityData + Valence electron density data (does not include NLCC) + + Returns + ------- + xc_potential_data : XCPotentialData + Exchange-correlation potential and energy density data + """ + if self.xc_calculator is None: + # Return zero XC potential data when no XC calculator is available + n_grid = len(self.quadrature_nodes) + return XCPotentialData( + v_x=np.zeros(n_grid), + v_c=np.zeros(n_grid), + e_x=np.zeros(n_grid), + e_c=np.zeros(n_grid) + ) + + # Get total density data (including NLCC for pseudopotential calculations) + density_data_total = self.get_total_density_data_for_xc(density_data) + + # Compute XC potential using total density + xc_potential_data = self.xc_calculator.compute_xc(density_data_total) + + return xc_potential_data + + + def _compute_nonlocal_psp_energy(self, orbitals: np.ndarray) -> float: + """ + Compute non-local pseudopotential energy contribution. + + This implements the Kleinman-Bylander form: + E_nl = Σ_l Σ_j γ_{lj} ⟨φ|χ_{lj}⟩⟨χ_{lj}|φ⟩ + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) + Shape: (n_grid, n_orbitals) + + Returns + ------- + float + Non-local pseudopotential energy contribution + """ + # Return 0.0 for all-electron calculations (no pseudopotential) + if self.all_electron or self.nonlocal_calculator is None: + return 0.0 + + # Delegate computation to nonlocal calculator + return self.nonlocal_calculator.compute_nonlocal_energy( + orbitals=orbitals, + occupations=self.occupation_info.occupations, + l_values=self.occupation_info.l_values, + unique_l_values=self.occupation_info.unique_l_values + ) + + + def _compute_hf_exchange_energy( + self, + orbitals: np.ndarray + ) -> float: + """ + Compute Hartree-Fock exchange energy. + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) at quadrature points + Shape: (n_grid, n_orbitals) + + Returns + ------- + float + HF exchange energy (0.0 if no HF calculator available) + """ + if self.hf_calculator is None: + return 0.0 + + # Delegate computation to HF calculator + return self.hf_calculator.compute_exchange_energy(orbitals) + + diff --git a/utils/atom/scf/hamiltonian.py b/utils/atom/scf/hamiltonian.py new file mode 100644 index 00000000..57700f32 --- /dev/null +++ b/utils/atom/scf/hamiltonian.py @@ -0,0 +1,461 @@ +""" +Hamiltonian builder for Kohn-Sham DFT +Responsible for constructing the total Hamiltonian matrix from various potential components +""" + +from __future__ import annotations +import numpy as np +from typing import Dict, Optional, Any +from dataclasses import dataclass + +from ..mesh.operators import RadialOperatorsBuilder +from ..pseudo.local import LocalPseudopotential +from ..utils.occupation_states import OccupationInfo + + +# Error messages +OPS_BUILDER_MUST_BE_A_RADIAL_OPERATORS_BUILDER_ERROR = \ + "parameter ops_builder must be a RadialOperatorsBuilder, get type {} instead" +LOCAL_PSEUDOPOTENTIAL_MUST_BE_A_LOCAL_PSEUDOPOTENTIAL_ERROR = \ + "parameter pseudo must be a LocalPseudopotential, get type {} instead" +OCCUPATION_INFO_MUST_BE_AN_OCCUPATION_INFO_ERROR = \ + "parameter occupation_info must be an OccupationInfo, get type {} instead" +ALL_ELECTRON_MUST_BE_A_BOOLEAN_ERROR = \ + "parameter all_electron must be a boolean, get type {} instead" + +EIGENVECTORS_MUST_BE_A_NUMPY_ARRAY_ERROR = \ + "parameter eigenvectors must be a numpy array, get type {} instead" +EIGENVECTORS_MUST_BE_A_2D_ARRAY_ERROR = \ + "parameter eigenvectors must be a 2D array, get dimension {} instead" +HARTREE_FOCK_EXCHANGE_MATRIX_FOR_L_CHANNEL_NOT_AVAILABLE_ERROR = \ + "Hartree-Fock exchange matrix for l={l} is not available, please set the HF exchange matrices first" + +MIXING_PARAMETER_NOT_A_FLOAT_ERROR = \ + "parameter mixing_parameter must be a float, get type {} instead" +MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR = \ + "parameter mixing_parameter must be in [0, 1], got {} instead" + +DE_XC_DTAU_NOT_AVAILABLE_ERROR = \ + "parameter de_xc_dtau is not available for l={l}, please set the de_xc_dtau first" + + +# Warning messages +HARTREE_FOCK_EXCHANGE_MATRIX_FOR_L_CHANNEL_NOT_AVAILABLE_WARNING = \ + "WARNING: Hartree-Fock exchange matrix for l={l} is not available, please set the HF exchange matrices first" +HF_EXCHANGE_MATRIX_NOT_AVAILABLE_WARNING = \ + "WARNING: Hartree-Fock exchange matrix is not available, please set the HF exchange matrices first" + + + + +class SwitchesFlags: + """ + Internal helper class for HamiltonianBuilder to manage functional switches. + Determines which Hamiltonian components to include based on the XC functional. + + Attributes: + use_hf_exchange (bool): Whether to use Hartree-Fock exchange + use_oep_exchange (bool): Whether to use Optimized Effective Potential (OEP) exchange + use_oep_correlation (bool): Whether to use OEP correlation + use_rpa_correlation (bool): Whether to use Random Phase Approximation (RPA) correlation + use_metagga (bool): Whether to use meta-GGA functional (requires de_xc_dtau in Hamiltonian) + OEP (bool): Whether to use OEP methods + inside_OEP (bool): Whether currently inside OEP iteration + uscrpa (bool): Whether to use RPA (Random Phase Approximation) - "use RPA" flag + """ + def __init__(self, xc_functional: str, hybrid_mixing_parameter: Optional[float] = None): + """ + Initialize switches based on XC functional and hybrid mixing parameter. + + Parameters + ---------- + xc_functional : str + Name of XC functional + hybrid_mixing_parameter : float, optional + Mixing parameter for hybrid functionals (0-1). Required only for hybrid functionals. + - For PBE0: should be 0.25 + - For HF: should be 1.0 + """ + # Type checking + assert isinstance(xc_functional, str), \ + "parameter xc_functional must be a string, get type {} instead".format(type(xc_functional)) + if hybrid_mixing_parameter is not None: + assert isinstance(hybrid_mixing_parameter, (float, int)), \ + "parameter hybrid_mixing_parameter must be a float, get type {} instead".format(type(hybrid_mixing_parameter)) + hybrid_mixing_parameter = float(hybrid_mixing_parameter) + + self.xc_functional = xc_functional + self.hybrid_mixing_parameter = hybrid_mixing_parameter + + # Initialize all flags to False + self.OEP = False + self.inside_OEP = False + self.uscrpa = False + self.use_hf_exchange = False + self.use_oep_exchange = False + self.use_oep_correlation = False + self.use_rpa_correlation = False + self.use_metagga = False + + # Set flags based on functional + if xc_functional == 'RPA': + self.OEP = True + self.uscrpa = True + self.use_oep_exchange = True + self.use_oep_correlation = True + self.use_rpa_correlation = True + elif xc_functional == 'OEPx': + self.OEP = True + self.uscrpa = True + self.use_oep_exchange = True + self.use_oep_correlation = True + elif xc_functional == 'HF': + self.use_hf_exchange = True + # Check if hybrid_mixing_parameter is provided for hybrid functionals + if hybrid_mixing_parameter is None: + print("WARNING: hybrid_mixing_parameter not provided for HF functional, using default value 1.0") + self.hybrid_mixing_parameter = 1.0 + elif not np.isclose(hybrid_mixing_parameter, 1.0): + print("WARNING: hybrid_mixing_parameter for HF should be 1.0, got {}".format(hybrid_mixing_parameter)) + elif xc_functional == 'PBE0': + self.use_hf_exchange = True + # Check if hybrid_mixing_parameter is provided for hybrid functionals + if hybrid_mixing_parameter is None: + print("WARNING: hybrid_mixing_parameter not provided for PBE0 functional, using default value 0.25") + self.hybrid_mixing_parameter = 0.25 + elif not np.isclose(hybrid_mixing_parameter, 0.25): + print("WARNING: hybrid_mixing_parameter for PBE0 should be 0.25, got {}".format(hybrid_mixing_parameter)) + + # Set meta-GGA flag for functionals that require de_xc_dtau + if xc_functional in ['SCAN', 'RSCAN', 'R2SCAN']: + self.use_metagga = True + + # LDA/GGA functionals: no special flags (default False) + + def print_info(self): + """ + Print functional switch information summary. + """ + print("=" * 60) + print("\t\t FUNCTIONAL SWITCHES") + print("=" * 60) + print(f"\t XC Functional : {self.xc_functional}") + if self.hybrid_mixing_parameter is not None: + print(f"\t Hybrid Mixing Parameter : {self.hybrid_mixing_parameter}") + else: + print(f"\t Hybrid Mixing Parameter : None (not applicable)") + print() + print("\t FUNCTIONAL FLAGS:") + print(f"\t use_hf_exchange : {self.use_hf_exchange}") + print(f"\t use_oep_exchange : {self.use_oep_exchange}") + print(f"\t use_oep_correlation : {self.use_oep_correlation}") + print(f"\t use_rpa_correlation : {self.use_rpa_correlation}") + print(f"\t use_metagga : {self.use_metagga}") + print(f"\t OEP : {self.OEP}") + print(f"\t inside_OEP : {self.inside_OEP}") + print(f"\t use_RPA (uscrpa) : {self.uscrpa}") + print() + + +class HamiltonianBuilder: + """ + Constructs Kohn-Sham Hamiltonian matrices for each angular momentum channel + + H_l = T + V_ext + V_H + V_xc + l(l+1)/(2r²) + V_nl(l) + V_HF(l) + + where: + - T: kinetic energy (radial derivative) + - V_ext: external potential (nuclear or pseudopotential) + - V_H: Hartree potential (electron-electron repulsion) + - V_xc: exchange-correlation potential + - l(l+1)/(2r²): angular momentum centrifugal term + - V_nl(l): non-local pseudopotential (l-dependent) + - V_HF(l): Hartree-Fock exchange (l-dependent, optional) + + This class is self-contained: it computes all fixed matrices internally + from the operators builder and pseudopotential information. + """ + + def __init__( + self, + ops_builder : RadialOperatorsBuilder, + pseudo : LocalPseudopotential, + occupation_info : OccupationInfo, + all_electron : bool = True + ): + """ + Parameters + ---------- + ops_builder : RadialOperatorsBuilder + Operator builder for constructing matrices + pseudo : LocalPseudopotential + Pseudopotential information (z_nuclear, z_valence, projectors, etc.) + occupation_info : OccupationInfo + Occupation information (needed for l channels in non-local PSP) + all_electron : bool + If True, use nuclear Coulomb potential; if False, use pseudopotential + """ + self.ops_builder = ops_builder + self.pseudo = pseudo + self.occupation_info = occupation_info + self.all_electron = all_electron + + assert isinstance(ops_builder, RadialOperatorsBuilder), \ + OPS_BUILDER_MUST_BE_A_RADIAL_OPERATORS_BUILDER_ERROR.format(type(ops_builder)) + assert isinstance(pseudo, LocalPseudopotential), \ + LOCAL_PSEUDOPOTENTIAL_MUST_BE_A_LOCAL_PSEUDOPOTENTIAL_ERROR.format(type(pseudo)) + assert isinstance(occupation_info, OccupationInfo), \ + OCCUPATION_INFO_MUST_BE_AN_OCCUPATION_INFO_ERROR.format(type(occupation_info)) + assert isinstance(all_electron, bool), \ + ALL_ELECTRON_MUST_BE_A_BOOLEAN_ERROR.format(type(all_electron)) + + # Pre-compute fixed matrices + self._compute_fixed_matrices() + + # Optional: Hartree-Fock exchange matrices (set by outer loop) + self.H_hf_exchange_dict: Dict[int, np.ndarray] = {} + + + def _compute_fixed_matrices(self): + """ + Pre-compute all fixed Hamiltonian matrix components + + These matrices are computed once and reused in all SCF iterations: + - H_kinetic: kinetic energy operator + - H_ext: external potential (nuclear or local pseudopotential) + - H_r_inv_sq: 1/r² operator for angular momentum term + - H_nonlocal: non-local pseudopotential matrices (if applicable) + """ + # 1. Kinetic energy matrix + self.H_kinetic = self.ops_builder.get_H_kinetic() + + # 2. External potential matrix + if self.all_electron: + # All-electron: nuclear Coulomb potential V = -Z/r + V_external = self.ops_builder.get_nuclear_coulomb_potential( + self.pseudo.z_nuclear + ) + else: + # Pseudopotential: local component + V_external = self.pseudo.get_v_local_component_psp( + self.ops_builder.quadrature_nodes + ) + + self.H_ext = self.ops_builder.build_potential_matrix(V_external) + + # 3. Angular momentum operator: 1/r² + self.H_r_inv_sq = self.ops_builder.get_H_r_inv_sq() + + # 4. Non-local pseudopotential matrices (if using pseudopotential) + if not self.all_electron: + from ..pseudo.non_local import NonLocalPseudopotential + + nonlocal_calculator = NonLocalPseudopotential( + pseudo=self.pseudo, + ops_builder=self.ops_builder + ) + + self.H_nonlocal = nonlocal_calculator.compute_all_nonlocal_matrices( + l_channels=self.occupation_info.unique_l_values + ) + else: + self.H_nonlocal = {} + + + def build_for_l_channel( + self, + l: int, + v_hartree: np.ndarray, + v_x: np.ndarray, + v_c: np.ndarray, + switches: SwitchesFlags, + v_x_oep: Optional[np.ndarray] = None, + v_c_oep: Optional[np.ndarray] = None, + de_xc_dtau: Optional[np.ndarray] = None, + symmetrize: bool = False + ) -> np.ndarray: + """ + Build total Hamiltonian for angular momentum channel l + + Parameters + ---------- + l : int + Angular momentum quantum number + v_hartree : np.ndarray + Hartree potential V_H(r) at quadrature points + v_x : np.ndarray + Exchange potential V_x(r) at quadrature points + v_c : np.ndarray + Correlation potential V_c(r) at quadrature points + switches : SwitchesFlags + Functional switches determining which components to include + v_x_oep : np.ndarray, optional + OEP exchange potential (if used) + v_c_oep : np.ndarray, optional + OEP correlation potential (if used) + de_xc_dtau : np.ndarray, optional + Derivative ∂ε_xc/∂τ of XC energy density w.r.t. kinetic energy density (for meta-GGA) + symmetrize : bool, optional + Whether to apply symmetrization using S^(-1/2) (default: False) + Transforms: H → S^(-1/2) @ H @ S^(-1/2), then H → (H+H^T)/2 + + Returns + ------- + H_total : np.ndarray + Total Hamiltonian matrix for this l channel + + Notes + ----- + Symmetrization uses the overlap matrix S to transform the generalized + eigenvalue problem (H·ψ = ε·S·ψ) into a standard eigenvalue problem. + For meta-GGA functionals, de_xc_dtau is used to add additional terms to the Hamiltonian. + """ + # Determine whether to include HF exchange based on switches + include_hf_exchange = switches.use_hf_exchange + if include_hf_exchange and len(self.H_hf_exchange_dict) == 0: + print(HF_EXCHANGE_MATRIX_NOT_AVAILABLE_WARNING) + include_hf_exchange = False + + # Determine whether to mix the exchange functionals of HF and GGA_PBE + hybrid_mixing_parameter = 0.0 + if switches.use_hf_exchange: + assert isinstance(switches.hybrid_mixing_parameter, float), \ + MIXING_PARAMETER_NOT_A_FLOAT_ERROR.format(type(switches.hybrid_mixing_parameter)) + assert 0.0 <= switches.hybrid_mixing_parameter <= 1.0, \ + MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR.format(switches.hybrid_mixing_parameter) + hybrid_mixing_parameter = switches.hybrid_mixing_parameter + + # Determine whether to include de_xc_dtau based on switches + if switches.use_metagga: + assert de_xc_dtau is not None, \ + DE_XC_DTAU_NOT_AVAILABLE_ERROR.format(l) + + if switches.use_oep_exchange: + v_x_oep = v_x_oep if v_x_oep is not None else np.zeros_like(v_x) + + if switches.use_oep_correlation: + v_c_oep = v_c_oep if v_c_oep is not None else np.zeros_like(v_c) + + # Start with fixed terms + H = self.H_kinetic + self.H_ext + + # Add Hartree potential + H_hartree = self.ops_builder.build_potential_matrix(v_hartree) + H += H_hartree + + # Add XC potential (may include OEP contributions) + v_xc_total = (1.0 - hybrid_mixing_parameter) * v_x + v_xc_total += v_c + if v_x_oep is not None: + v_xc_total += v_x_oep + if v_c_oep is not None: + v_xc_total += v_c_oep + + H_xc = self.ops_builder.build_potential_matrix(v_xc_total) + H += H_xc + + + # np.savetxt("H_part.txt", self.H_kinetic + self.H_ext) + # np.savetxt("H_hartree.txt", H_hartree) + # np.savetxt("H_xc.txt", H_xc) + # np.savetxt("v_hartree.txt", v_hartree) + # np.savetxt("v_x.txt", v_x) + # np.savetxt("v_c.txt", v_c) + # raise RuntimeError("Stop here") + + # Add meta-GGA kinetic density term (radial component) + if switches.use_metagga: + H_metagga_tau = self.ops_builder.build_metagga_kinetic_density_matrix(de_xc_dtau) + H += H_metagga_tau + + # Add angular momentum term: l(l+1)/(2r²) + if l > 0: + angular_term = self.H_r_inv_sq + if switches.use_metagga: + # Meta-GGA angular term: ∫ φ_i * (w * de_xc_dtau / r²) * φ_j dr + potential_angular = de_xc_dtau / self.ops_builder.quadrature_nodes**2 + angular_term += self.ops_builder.build_potential_matrix(potential_angular) + + H += (l * (l + 1) / 2) * angular_term + + # Add non-local pseudopotential (if present for this l) + if l in self.H_nonlocal: + H += self.H_nonlocal[l] + + # Add Hartree-Fock exchange (if requested and available) + if include_hf_exchange: + assert l in self.H_hf_exchange_dict, \ + HARTREE_FOCK_EXCHANGE_MATRIX_FOR_L_CHANNEL_NOT_AVAILABLE_ERROR.format(l) + H += self.H_hf_exchange_dict[l] * hybrid_mixing_parameter + + # Apply symmetrization transformation (if requested) + if symmetrize: + # Get S^(-1/2) from ops_builder + S_inv_sqrt = self.ops_builder.get_S_inv_sqrt() + + # Transform: H → S^(-1/2) @ H @ S^(-1/2) + H = S_inv_sqrt @ H @ S_inv_sqrt + + # Enforce symmetry: H → (H + H^T) / 2 + H = 0.5 * (H + H.T) + + return H + + + def set_hf_exchange_matrices(self, H_hf_by_l: Dict[int, np.ndarray]): + """ + Set Hartree-Fock exchange matrices for each l channel + + Called by outer SCF loop after computing HF exchange from orbitals + """ + self.H_hf_exchange_dict = H_hf_by_l + + + def interpolate_eigenvectors_to_quadrature( + self, + eigenvectors: np.ndarray, + symmetrize: bool = False, + pad_width: int = 0, + ) -> np.ndarray: + """ + Interpolate eigenvectors to quadrature points using the global interpolation matrix + + Parameters + ---------- + eigenvectors : np.ndarray + Eigenvectors at physical grid points (shape: (n_physical_nodes, n_states)) + symmetrize : bool, optional + Whether to apply symmetrization using S^(-1/2) (default: False) + Transforms: H → S^(-1/2) @ H @ S^(-1/2), then H → (H+H^T)/2 + pad_width : int, optional + Number of points to pad on each side of the eigenvectors (default: 1) + """ + + assert isinstance(eigenvectors, np.ndarray), \ + EIGENVECTORS_MUST_BE_A_NUMPY_ARRAY_ERROR.format(type(eigenvectors)) + assert eigenvectors.ndim == 2, \ + EIGENVECTORS_MUST_BE_A_2D_ARRAY_ERROR.format(eigenvectors.ndim) + + if symmetrize: + S_inv_sqrt = self.ops_builder.get_S_inv_sqrt() + if pad_width > 0: + S_inv_sqrt = S_inv_sqrt[pad_width:-pad_width,pad_width:-pad_width] + eigenvectors = S_inv_sqrt @ eigenvectors + + # print("eigenvectors.shape:", eigenvectors.shape) + # np.savetxt("eigenvectors.txt", eigenvectors) + # raise RuntimeError("Stop here") + + if pad_width > 0: + eigenvectors = np.pad(eigenvectors,((pad_width,pad_width),(0,0))) + + global_interpolation_matrix = self.ops_builder.get_global_interpolation_matrix() + eigenvectors_quadrature = global_interpolation_matrix @ eigenvectors + + return eigenvectors_quadrature + + + + + + diff --git a/utils/atom/scf/mixer.py b/utils/atom/scf/mixer.py new file mode 100644 index 00000000..45a49ad8 --- /dev/null +++ b/utils/atom/scf/mixer.py @@ -0,0 +1,270 @@ +from __future__ import annotations +import numpy as np +from typing import Optional + +class Mixer: + """ + Density mixing for SCF convergence. + + Supports: + - Simple linear mixing: rho_new = rho_out (pulay_mixing=0) + - Pulay mixing: DIIS-like method using history of residuals + - Alternating linear mixing: odd/even steps with different coefficients + + Parameters + ---------- + tol : float + Convergence tolerance (not used in mixing itself) + alpha_lin : tuple of float + Linear mixing parameters (alpha21, alpha22) for odd/even steps + alpha_pulay : float + Pulay mixing parameter (alpha11 in original code) + history : int + Number of previous iterations to keep for Pulay mixing + frequency : int + Apply Pulay mixing every 'frequency' iterations + pulay_mixing : int + 0: simple linear (rho_in = rho_out) + 1: use Pulay + alternating linear mixing + un_zero_rho : float + Minimum density value to avoid negative densities + """ + + def __init__( + self, + tol: float, + alpha_lin=(0.5, 0.5), + alpha_pulay=0.55, + history=7, + frequency=2, + pulay_mixing=1, + un_zero_rho=1e-12 + ): + self.tol = float(tol) + self.alpha21 = float(alpha_lin[0]) # Odd step mixing + self.alpha22 = float(alpha_lin[1]) # Even step mixing + self.alpha11 = float(alpha_pulay) # Pulay mixing parameter + self.history = int(history) + self.frequency = int(frequency) + self.pulay_mixing = int(pulay_mixing) + self.un_zero_rho = float(un_zero_rho) + + # History storage: (N_q, history+1) + self.rho_in_store: Optional[np.ndarray] = None + self.rho_out_store: Optional[np.ndarray] = None + self.iteration_count = 0 + self.n_points = None + + + def reset(self) -> None: + """ + Reset the mixer state. + + Clears all history buffers and resets iteration counter. + Called at the start of each SCF calculation. + """ + self.rho_in_store = None + self.rho_out_store = None + self.iteration_count = 0 + self.n_points = None + + + def mix(self, rho_in: np.ndarray, rho_out: np.ndarray) -> np.ndarray: + """ + Mix input and output densities to produce next input density. + + Implements the exact logic from the original code, including: + - History management with rolling window + - Pulay mixing every 'frequency' iterations + - Alternating linear mixing (odd/even steps) + - Negative density correction + + Parameters + ---------- + rho_in : np.ndarray + Input density for current iteration, shape (n_points,) + rho_out : np.ndarray + Output density from KS solve, shape (n_points,) + + Returns + ------- + rho_next : np.ndarray + Mixed density for next iteration + + Notes + ----- + This method stores rho_out internally and returns the next rho_in. + The caller should update the SCF loop accordingly. + """ + # Initialize history storage on first call + if self.rho_in_store is None: + self.n_points = rho_in.shape[0] + self.rho_in_store = np.zeros((self.n_points, self.history + 1)) + self.rho_out_store = np.zeros((self.n_points, self.history + 1)) + self.rho_in_store[:, 0] = rho_in + self.iteration_count = 0 + + runs = self.iteration_count + + # Store rho_out in appropriate column + if runs < self.history: + self.rho_out_store[:, runs] = rho_out + else: + self.rho_out_store[:, -1] = rho_out + + # Decide on next rho_in based on mixing strategy + if self.pulay_mixing == 0: + # Simple mixing: rho_in = rho_out + if runs < self.history: + rho_next = self.rho_out_store[:, runs].copy() + else: + rho_next = self.rho_out_store[:, -1].copy() + + else: + # Pulay + alternating linear mixing + rho_next = self._hybrid_mix(runs) + + # Store next rho_in for next iteration + if runs + 1 < self.history: + self.rho_in_store[:, runs + 1] = rho_next + else: + # Roll history and store in last column + if runs + 1 > self.history: + self.rho_in_store = np.roll(self.rho_in_store, -1, axis=1) + self.rho_out_store = np.roll(self.rho_out_store, -1, axis=1) + self.rho_in_store[:, -1] = rho_next + + self.iteration_count += 1 + return rho_next + + + def _hybrid_mix(self, runs: int) -> np.ndarray: + """ + Hybrid mixing: Pulay every 'frequency' iterations, linear otherwise. + + Parameters + ---------- + runs : int + Current iteration number (before increment in reference code) + + Returns + ------- + rho_next : np.ndarray + Mixed density + + Notes + ----- + Reference code increments 'runs' before mixing, so we add 1 to match: + - runs=0 (here) -> runs=1 (ref): linear (1%2=1) + - runs=1 (here) -> runs=2 (ref): Pulay (2%2=0) + - runs=2 (here) -> runs=3 (ref): linear (3%2=1) + - runs=3 (here) -> runs=4 (ref): Pulay (4%2=0) + """ + use_pulay = ((runs + 1) % self.frequency == 0) and (runs > 0) + + if runs < self.history: + # Early phase: direct indexing + if use_pulay: + rho_next = self._pulay_mix_early(runs) + else: + rho_next = self._linear_mix_early(runs) + else: + # Stable phase: use rolling window (last column) + if use_pulay: + rho_next = self._pulay_mix_stable() + else: + rho_next = self._linear_mix_stable() + + # Correct negative densities + negative_mask = rho_next <= 0 + rho_next[negative_mask] = self.un_zero_rho + + return rho_next + + + def _linear_mix_early(self, runs: int) -> np.ndarray: + """Linear mixing for early phase (runs < history)""" + # Alternating coefficients for odd/even steps + # Reference code increments before mixing, so: + # runs=0 (here) -> runs=1 (ref, odd) -> use alpha21 + # runs=1 (here) -> runs=2 (ref, even) -> use alpha22 + if (runs + 1) % 2 != 0: # equivalent to: runs % 2 == 0 + alpha = self.alpha21 + else: + alpha = self.alpha22 + + rho_in_prev = self.rho_in_store[:, runs] + rho_out_prev = self.rho_out_store[:, runs] + + return rho_in_prev + alpha * (rho_out_prev - rho_in_prev) + + + def _linear_mix_stable(self) -> np.ndarray: + """Linear mixing for stable phase (runs >= history)""" + runs = self.iteration_count + + # Alternating coefficients (matching reference after increment) + if (runs + 1) % 2 != 0: # equivalent to: runs % 2 == 0 + alpha = self.alpha21 + else: + alpha = self.alpha22 + + rho_in_prev = self.rho_in_store[:, -2] + rho_out_prev = self.rho_out_store[:, -2] + + return rho_in_prev + alpha * (rho_out_prev - rho_in_prev) + + + def _pulay_mix_early(self, runs: int) -> np.ndarray: + """Pulay mixing for early phase (runs < history)""" + # Compute residuals using differences + rho_in_residual = np.diff(self.rho_in_store[:, :runs+1], axis=1) + rho_out_residual = np.diff(self.rho_out_store[:, :runs+1], axis=1) + rho_out_minus_in_residual = rho_out_residual - rho_in_residual + + # Pulay projection matrix formula + # P = alpha11*I - (Δρ_in + alpha11*ΔF) @ (ΔF^T @ ΔF)^(-1) @ ΔF^T + N_q = self.n_points + alpha11 = self.alpha11 + + # ΔF^T @ ΔF + A = rho_out_minus_in_residual.T @ rho_out_minus_in_residual + A_inv = np.linalg.inv(A) + + # Projection matrix + term1 = rho_in_residual + alpha11 * rho_out_minus_in_residual + term2 = term1 @ A_inv @ rho_out_minus_in_residual.T + P = alpha11 * np.eye(N_q) - term2 + + # Apply to residual + rho_in_prev = self.rho_in_store[:, runs] + rho_out_prev = self.rho_out_store[:, runs] + residual = rho_out_prev - rho_in_prev + + return rho_in_prev + P @ residual + + + def _pulay_mix_stable(self) -> np.ndarray: + """Pulay mixing for stable phase (runs >= history)""" + # Compute residuals using differences (all history columns) + rho_in_residual = np.diff(self.rho_in_store, axis=1) + rho_out_residual = np.diff(self.rho_out_store, axis=1) + rho_out_minus_in_residual = rho_out_residual - rho_in_residual + + # Pulay projection + N_q = self.n_points + alpha11 = self.alpha11 + + A = rho_out_minus_in_residual.T @ rho_out_minus_in_residual + A_inv = np.linalg.inv(A) + + term1 = rho_in_residual + alpha11 * rho_out_minus_in_residual + term2 = term1 @ A_inv @ rho_out_minus_in_residual.T + P = alpha11 * np.eye(N_q) - term2 + + # Apply to residual + rho_in_prev = self.rho_in_store[:, -2] + rho_out_prev = self.rho_out_store[:, -2] + residual = rho_out_prev - rho_in_prev + + return rho_in_prev + P @ residual diff --git a/utils/atom/scf/poisson.py b/utils/atom/scf/poisson.py new file mode 100644 index 00000000..3a1530b7 --- /dev/null +++ b/utils/atom/scf/poisson.py @@ -0,0 +1,223 @@ +""" +Poisson solver for 1D and spherically symmetric 3D problems + +Mathematical transformation for spherical symmetry: + 3D: ∇²V = -4πρ → Let u = rV → 1D: d²u/dr² = -4πrρ +""" + +from __future__ import annotations +import scipy +import numpy as np +from typing import Optional +from ..mesh.operators import RadialOperatorsBuilder +from ..mesh.builder import Mesh1D + + + +OPS_BUILDER_TYPE_ERROR_MESSAGE = \ + "ops_builder must be an instance of RadialOperatorsBuilder, but got {} instead" +Z_VALENCE_TYPE_ERROR_MESSAGE = \ + "parameter z_valence must be a float, get type {} instead" +RHS_VECTOR_TYPE_ERROR_MESSAGE = \ + "parameter rhs_vector must be a numpy array, get type {} instead" +RHS_VECTOR_NDIM_ERROR_MESSAGE = \ + "parameter rhs_vector must be a 1D array, get type {} instead" +RHS_VECTOR_SHAPE_ERROR_MESSAGE = \ + "parameter rhs_vector shape {} must match Laplacian matrix size {}" + +RHO_TYPE_ERROR_MESSAGE = \ + "parameter rho must be a numpy array, get type {} instead" +RHO_NDIM_ERROR_MESSAGE = \ + "parameter rho must be a 1D array, get type {} instead" +RHO_SHAPE_ERROR_MESSAGE = \ + "parameter rho shape {} must match quadrature nodes size {}" + + + +class PoissonSolver: + """ + Poisson equation solver supporting: + 1. Generic 1D equation: d²u/dx² = f(x) + 2. Spherically symmetric 3D: ∇²V = -4πρ(r) + + Parameters + ---------- + ops_builder : RadialOperatorsBuilder + Provides Laplacian matrix and grid information + """ + + def __init__( + self, + ops_builder: RadialOperatorsBuilder, + z_valence: float, + ): + # type check for required parameters + assert isinstance(ops_builder, RadialOperatorsBuilder), \ + OPS_BUILDER_TYPE_ERROR_MESSAGE.format(type(ops_builder)) + try: + z_valence = float(z_valence) + except: + raise ValueError(Z_VALENCE_TYPE_ERROR_MESSAGE.format(type(z_valence))) + + self.ops_builder = ops_builder + self.z_valence = z_valence + + + # laplacian matrix and set boundary conditions + _laplacian = ops_builder.laplacian + _laplacian[0,:] = 0 + _laplacian[-1,:] = 0 + _laplacian[:,0] = 0 + _laplacian[0,0] = -1 + _laplacian[-1,-1] = -1 + self.laplacian_with_boundary_conditions = _laplacian + + # store some other useful information + self.number_of_finite_elements : int = ops_builder.number_of_finite_elements + self.quadrature_nodes : np.ndarray = ops_builder.quadrature_nodes + self.quadrature_weights : np.ndarray = ops_builder.quadrature_weights + + + + + + def solve_1d(self, rhs_vector: np.ndarray) -> np.ndarray: + """ + Solve 1D Poisson equation: d²u/dx² = f(x) + + This method solves the linear system L @ u = rhs_vector using the + pre-configured Laplacian matrix with Dirichlet boundary conditions. + + The Laplacian matrix L has been modified during initialization: + - L[0, :] = [1, 0, 0, ...] → First equation: u[0] = rhs[0] + - L[-1, :] = [0, 0, ..., 0, 1] → Last equation: u[-1] = rhs[-1] + - Interior rows maintain original finite element discretization + + Therefore, the caller must set boundary values at the endpoints of rhs_vector: + rhs_vector[0] = left boundary value + rhs_vector[-1] = right boundary value + + Parameters + ---------- + rhs_vector : np.ndarray + Right-hand side vector of the linear system, containing: + - rhs[0]: Left boundary condition value (enforced as u[0]) + - rhs[1:-1]: Interior source terms f(x_i) + - rhs[-1]: Right boundary condition value (enforced as u[-1]) + Shape: (n_nodes,) must match Laplacian matrix dimension + + Returns + ------- + solution : np.ndarray + Solution vector u satisfying the boundary conditions + Shape: (n_nodes,) + + Notes + ----- + This method directly solves the linear system without coordinate + transformations or interpolation. Boundary condition enforcement + is handled through matrix modification (done in __init__). + """ + # Type and shape validation + assert isinstance(rhs_vector, np.ndarray), \ + RHS_VECTOR_TYPE_ERROR_MESSAGE.format(type(rhs_vector)) + assert rhs_vector.ndim == 1, \ + RHS_VECTOR_NDIM_ERROR_MESSAGE.format(rhs_vector.ndim) + assert rhs_vector.shape[0] == self.laplacian_with_boundary_conditions.shape[0], \ + RHS_VECTOR_SHAPE_ERROR_MESSAGE.format(rhs_vector.shape[0], self.laplacian.shape[0]) + + # Solve linear system: L @ u = rhs + solution = scipy.linalg.solve(self.laplacian_with_boundary_conditions, rhs_vector[:, np.newaxis])[:, 0] + + # np.savetxt("solution.txt", solution.reshape(-1)) + # np.savetxt("rhs_vector.txt", rhs_vector.reshape(-1)) + # np.savetxt("laplacian_with_boundary_conditions.txt", self.laplacian_with_boundary_conditions.reshape(-1)) + # raise RuntimeError("Stop here") + + return solution + + + def solve_hartree(self, rho: np.ndarray) -> np.ndarray: + """ + Solve 3D spherically symmetric Poisson equation for Hartree potential + + Equation: ∇²V = -4πρ(r) + + Transform: u = rV, then d²u/dr² = -4πrρ(r) + + Boundary conditions: + - u(0) = 0 (V finite at origin) + - u(∞) = Q (Q = total charge for V → Q/r at infinity) + + Parameters + ---------- + rho : np.ndarray + Electron density at quadrature nodes + Shape: (N_quad,) + Z : float, optional + Nuclear charge (for computing total charge Q) + If provided: Q = Z - ∫ρd³r + If None: Q = ∫ρd³r (for testing/special cases) + + Returns + ------- + v_hartree : np.ndarray + Hartree potential at quadrature nodes + Shape: (N_quad,) + """ + assert isinstance(rho, np.ndarray), \ + RHO_TYPE_ERROR_MESSAGE.format(type(rho)) + assert rho.ndim == 1, \ + RHO_NDIM_ERROR_MESSAGE.format(rho.ndim) + assert rho.shape[0] == self.quadrature_nodes.shape[0], \ + RHO_SHAPE_ERROR_MESSAGE.format(rho.shape[0], self.quadrature_nodes.shape[0]) + + + # prepare the rhs_vector for the 1D Poisson equation + rhs_vector = self.ops_builder.assemble_poisson_rhs_vector(rho, self.z_valence) + + # Set the boundary values + rhs_vector[0] = 0.0 + rhs_vector[-1] = - self.z_valence + + # solve the 1D Poisson equation at dense physical nodes + r_times_v_hartree_at_dense_physical_nodes = self.solve_1d(rhs_vector) # r * v_hartree + + # Convert to quadrature nodes + r_times_v_hartree_at_dense_physical_nodes_reshaped = Mesh1D.fe_flat_to_block2d( + flat = r_times_v_hartree_at_dense_physical_nodes, + n_elem = self.number_of_finite_elements, + endpoints_shared = True + ) + + r_times_v_hartree_at_quadrature_nodes = np.einsum( + "emi,ei->em", + self.ops_builder.lagrange_basis, # (n_elem, n_quad, n_phys) + r_times_v_hartree_at_dense_physical_nodes_reshaped, # (n_elem, n_phys) + optimize=True + ).reshape(-1,) + + v_hartree = r_times_v_hartree_at_quadrature_nodes / self.quadrature_nodes + + return v_hartree + + + def compute_hartree_energy(self, rho: np.ndarray, V_H: np.ndarray) -> float: + """ + Compute Hartree energy: E_H = (1/2) ∫ ρ(r) V_H(r) 4πr² dr + + Parameters + ---------- + rho : np.ndarray + Electron density + V_H : np.ndarray + Hartree potential + + Returns + ------- + E_H : float + Hartree energy + """ + integrand = rho * V_H * 4.0 * np.pi * self.r_quad**2 + E_H = 0.5 * np.sum(integrand * self.w_quad) + raise NotImplementedError("This function is not tested") diff --git a/utils/atom/solver.py b/utils/atom/solver.py new file mode 100644 index 00000000..b0fe83c9 --- /dev/null +++ b/utils/atom/solver.py @@ -0,0 +1,1253 @@ +""" +Atomic Density Functional Theory (DFT) Solver + + This module provides a comprehensive implementation of Atomic DFT solver using + finite element method for solving the Kohn-Sham equations for atomic systems. + + The solver supports: + - Multiple exchange-correlation functionals (LDA, GGA, Meta-GGA, Hybrid, etc.) + - Both all-electron and pseudopotential calculations + - Self-consistent field (SCF) iterations with convergence control + - High-order finite element discretization with Legendre-Gauss-Lobatto nodes + - Various mesh types (exponential, polynomial, uniform) + + @file solver.py + @brief Atomic DFT Solver using finite element method + @authors Shubhang Trivedi + Qihao Cheng + Phanish Suryanarayana + + Copyright (c) 2025 Material Physics & Mechanics Group, Georgia Tech. +""" + + +from __future__ import annotations + +import os +import sys +from pathlib import Path + +# Fix the relative import issue when running as a script +try: + __package__ +except NameError: + __package__ = None + +if __package__ is None: + # Set the package name, so the relative import can work + __package__ = 'atom' + parent_dir = Path(__file__).resolve().parent.parent + if str(parent_dir) not in sys.path: + sys.path.insert(0, str(parent_dir)) + +import numpy as np +from typing import Optional, Dict, Any, Tuple + +# Mesh & operators +from .mesh.builder import Quadrature1D, Mesh1D, RPAFrequencyGrid +from .mesh.operators import GridData, RadialOperatorsBuilder + +# Typing imports +from .pseudo.local import LocalPseudopotential +from .pseudo.non_local import NonLocalPseudopotential +from .utils.occupation_states import OccupationInfo +from .scf.energy import EnergyComponents +from .scf.driver import SCFResult +from .xc.evaluator import XCPotentialData +from .xc.functional_requirements import get_functional_requirements + +# SCF stack +from .scf import ( + HamiltonianBuilder, + DensityCalculator, + PoissonSolver, + SCFDriver, + EnergyCalculator, + EigenSolver, + Mixer, + ConvergenceChecker +) + +# XC and snapshot +from .xc.evaluator import XCEvaluator +from .post.builder import SnapshotBuilder + + + +# Valid XC Functional +VALID_XC_FUNCTIONAL_LIST = ['GGA_PBE', 'RPA', 'OEPx', 'LDA_PZ', 'LDA_PW', 'SCAN', 'RSCAN', 'R2SCAN', 'PBE0', 'HF'] + +# Valid Mesh Type +VALID_MESH_TYPE_LIST = ['exponential', 'polynomial', 'uniform'] + + + +# Type Check Error Messages +ATOMIC_NUMBER_NOT_INTEGER_ERROR = \ + "parameter atomic_number must be an integer, get {} instead" +DOMAIN_SIZE_NOT_FLOAT_ERROR = \ + "parameter domain_size must be a float, get {} instead" +NUMBER_OF_FINITE_ELEMENTS_NOT_INTEGER_ERROR = \ + "parameter number_of_finite_elements must be an integer, get {} instead" +POLYNOMIAL_ORDER_NOT_INTEGER_ERROR = \ + "parameter polynomial_order must be an integer, get {} instead" +QUADRATURE_POINT_NUMBER_NOT_INTEGER_ERROR = \ + "parameter quadrature_point_number must be an integer, get {} instead" +XC_FUNCTIONAL_NOT_STRING_ERROR = \ + "parameter xc_functional must be a string, get {} instead" +MESH_TYPE_NOT_STRING_ERROR = \ + "parameter mesh_type must be a string, get {} instead" +MESH_CONCENTRATION_NOT_FLOAT_ERROR = \ + "parameter mesh_concentration must be a float, get {} instead" +SCF_TOLERANCE_NOT_FLOAT_ERROR = \ + "parameter scf_tolerance must be a float, get {} instead" +ALL_ELECTRON_FLAG_NOT_BOOL_ERROR = \ + "parameter all_electron_flag must be a boolean, get {} instead" +ENABLE_DOMAIN_SIZE_TEST_NOT_BOOL_ERROR = \ + "parameter enable_domain_size_test must be a boolean, get {} instead" +PSP_DIR_PATH_NOT_STRING_ERROR = \ + "parameter psp_dir_path must be a string, get {} instead" +PSP_FILE_NAME_NOT_STRING_ERROR = \ + "parameter psp_file_name must be a string, get {} instead" +FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_INTEGER_ERROR = \ + "parameter frequency_integration_point_number must be an integer, get {} instead" +EIGENTOLERANCE_X_NOT_FLOAT_ERROR = \ + "parameter eigentolerance_x must be a float, get {} instead" +EIGENTOLERANCE_C_NOT_FLOAT_ERROR = \ + "parameter eigentolerance_c must be a float, get {} instead" +L_MAX_QUANTUM_NUMBER_NOT_INTEGER_ERROR = \ + "parameter l_max_quantum_number must be an integer, get {} instead" +SMOOTHENING_CUTOFF_FREQUENCY_NOT_FLOAT_ERROR = \ + "parameter smoothening_cutoff_frequency must be a float, get {} instead" +DOUBLE_HYBRID_FLAG_NOT_BOOL_ERROR = \ + "parameter double_hybrid_flag must be a boolean, get {} instead" +HYBRID_MIXING_PARAMETER_NOT_FLOAT_ERROR = \ + "parameter hybrid_mixing_parameter must be a float, get {} instead" +MESH_SPACING_NOT_FLOAT_ERROR = \ + "parameter mesh_spacing must be a float, get {} instead" +PRINT_DEBUG_NOT_BOOL_ERROR = \ + "parameter print_debug must be a boolean, get {} instead" + +# Value Check Error Messages +ATOMIC_NUMBER_NOT_GREATER_THAN_0_ERROR = \ + "parameter atomic_number must be greater than 0, get {} instead" +ATOMIC_NUMBER_LARGER_THAN_119_ERROR = \ + "parameter atomic_number must be smaller than 119, get {} instead" +DOMAIN_SIZE_NOT_GREATER_THAN_0_ERROR = \ + "parameter domain_size must be greater than 0, get {} instead" +NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR = \ + "parameter number_of_finite_elements must be greater than 0, get {} instead" +POLYNOMIAL_ORDER_NOT_GREATER_THAN_0_ERROR = \ + "parameter polynomial_order must be greater than 0, get {} instead" + +QUADRATURE_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR = \ + "parameter quadrature_point_number must be greater than 0, get {} instead" +FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR = \ + "parameter frequency_integration_point_number must be greater than 0, get {} instead" +L_MAX_QUANTUM_NUMBER_NEGATIVE_ERROR = \ + "parameter l_max_quantum_number must be non-negative, get {} instead" +XC_FUNCTIONAL_TYPE_ERROR_MESSAGE = \ + "parameter xc_functional must be a string, get type {} instead" +XC_FUNCTIONAL_NOT_IN_VALID_LIST_ERROR = \ + "parameter xc_functional must be in {}, get {} instead" +MESH_TYPE_NOT_IN_VALID_LIST_ERROR = \ + "parameter mesh_type must be in {}, get {} instead" +MESH_CONCENTRATION_NOT_GREATER_THAN_0_ERROR = \ + "parameter mesh_concentration must be greater than 0, get {} instead" +SCF_TOLERANCE_NOT_GREATER_THAN_0_ERROR = \ + "parameter scf_tolerance must be greater than 0, get {} instead" +PSP_DIR_PATH_NOT_EXISTS_ERROR = \ + "parameter default psp directory path {} does not exist, please provide a valid psp directory path" +PSP_FILE_NAME_NOT_EXISTS_ERROR = \ + "parameter psp file name `{}` does not exist in the psp file path `{}`, please provide a valid psp file name" +EIGENTOLERANCE_X_NOT_GREATER_THAN_0_ERROR = \ + "parameter eigentolerance_x must be greater than 0, get {} instead" +EIGENTOLERANCE_C_NOT_GREATER_THAN_0_ERROR = \ + "parameter eigentolerance_c must be greater than 0, get {} instead" +SMOOTHENING_CUTOFF_FREQUENCY_NEGATIVE_ERROR = \ + "parameter smoothening_cutoff_frequency must be non-negative, get {} instead" +HYBRID_MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR = \ + "parameter hybrid_mixing_parameter must be in [0, 1], get {} instead" +HYBRID_MIXING_PARAMETER_NOT_ONE_FOR_NON_HYBRID_FUNCTIONAL_ERROR = \ + "parameter hybrid_mixing_parameter must be 1.0 for non-hybrid functional, get {} instead" +DENSITY_MIXING_PARAMETER_NOT_FLOAT_ERROR = \ + "parameter density_mixing_parameter must be a float, get {} instead" +DENSITY_MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR = \ + "parameter density_mixing_parameter must be in [0, 1], get {} instead" +MESH_SPACING_NOT_GREATER_THAN_0_ERROR = \ + "parameter mesh_spacing must be greater than 0, get {} instead" + +# WARNING Messages +MESH_CONCENTRATION_NOT_NONE_FOR_UNIFORM_MESH_TYPE_WARNING = \ + "WARNING: parameter mesh_concentration is not None for uniform mesh type, so it will be ignored" +PSP_DIR_PATH_NOT_NONE_FOR_ALL_ELECTRON_CALCULATION_WARNING = \ + "WARNING: parameter psp_dir_path is not None for all-electron calculation, so it will be ignored" +PSP_FILE_NAME_NOT_NONE_FOR_ALL_ELECTRON_CALCULATION_WARNING = \ + "WARNING: parameter psp_file_name is not None for all-electron calculation, so it will be ignored" +FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_NONE_FOR_OEPX_AND_NONE_XC_FUNCTIONAL_WARNING = \ + "WARNING: parameter frequency_integration_point_number is not None for XC functional `{}`, so it will be ignored" +EIGENTOLERANCE_X_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING = \ + "WARNING: parameter eigentolerance_x is not None for XC functional `{}`, so it will be ignored" +EIGENTOLERANCE_C_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING = \ + "WARNING: parameter eigentolerance_c is not None for XC functional `{}`, so it will be ignored" +SMOOTHENING_CUTOFF_FREQUENCY_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING = \ + "WARNING: parameter smoothening_cutoff_frequency is not None for XC functional `{}`, so it will be ignored" +NO_HYBRID_MIXING_PARAMETER_PROVIDED_FOR_HYBRID_FUNCTIONAL_WARNING = \ + "WARNING: hybrid_mixing_parameter not provided for {} functional, using default value {}" +HYBRID_MIXING_PARAMETER_NOT_IN_ZERO_ONE_WARNING = \ + "WARNING: hybrid_mixing_parameter for {} should be in [0, 1], got {}" +HYBRID_MIXING_PARAMETER_NOT_ONE_FOR_NON_HYBRID_FUNCTIONAL_WARNING = \ + "WARNING: hybrid_mixing_parameter for {} must be 1.0 for non-hybrid functional, got {}" +HYBRID_MIXING_PARAMETER_NOT_FLOAT_WARNING = \ + "WARNING: hybrid_mixing_parameter for {} must be a float, got {}" +HYBRID_MIXING_PARAMETER_NOT_IN_ZERO_ONE_WARNING = \ + "WARNING: hybrid_mixing_parameter for {} must be in [0, 1], got {}" +HYBRID_MIXING_PARAMETER_NOT_ONE_FOR_HF_ERROR = \ + "WARNING: hybrid_mixing_parameter for {} must be 1.0 for HF functional, got {}" +WARM_START_NOT_CONVERGED_WARNING = \ + "WARNING: warm start calculation for {} did not converge, using intermediate result" + +class AtomicDFTSolver: + """ + Atomic Density Functional Theory (DFT) Solver using finite element method. + + This class provides a comprehensive interface for solving the Kohn-Sham equations + for atomic systems using various exchange-correlation functionals and computational + parameters. It supports both all-electron and pseudopotential calculations. + """ + + # Basic physical parameters + atomic_number : int # Atomic number of the element to calculate (e.g., 13 for Aluminum) + domain_size : float # Radial computational domain size in atomic units (typically 10-30) + number_of_finite_elements : int # Number of finite elements in the computational domain + polynomial_order : int # Polynomial order of basis functions within each finite element + quadrature_point_number : int # Number of quadrature points for numerical integration (recommended: 3-4x polynomial_order) + + # Exchange-correlation functional parameters + xc_functional : str # XC functional type: 'GGA_PBE', 'RPA', 'OEPx', 'LDA_PZ', 'LDA_PW', 'SCAN', 'RSCAN', 'R2SCAN' + mesh_type : str # Mesh distribution type: 'exponential' (higher density near nucleus), 'polynomial', or 'uniform' + mesh_concentration : float # Mesh concentration parameter (controls point density distribution) + + # Self-consistent field (SCF) convergence parameters + scf_tolerance : float # SCF convergence tolerance (typically 1e-8) + all_electron_flag : bool # True for all-electron calculation, False for pseudopotential calculation + enable_domain_size_test : bool # Flag for domain size convergence testing + + # Pseudopotential parameters + psp_dir_path : str # Path to pseudopotential files directory (required when all_electron_flag=False) + psp_file_name : str # Name of the pseudopotential file (required when all_electron_flag=False) + + # Advanced functional parameters (for OEPx, RPA, etc.) + frequency_integration_point_number : int # Number of frequency integration points for RPA calculations + eigentolerance_x : float # Eigenvalue convergence tolerance for exchange term + eigentolerance_c : float # Eigenvalue convergence tolerance for correlation term + l_max_quantum_number : int # Maximum angular momentum quantum number to include + smoothening_cutoff_frequency : float # Smoothing cutoff frequency for numerical stability + double_hybrid_flag : bool # Flag for double-hybrid functional methods + hybrid_mixing_parameter : float # Mixing parameter for hybrid/double-hybrid functionals (e.g., 0.25 for PBE0) + + # Grid and computational parameters + mesh_spacing : float # Minimum mesh spacing (should match output file spacing) + density_mixing_parameter : float # Density mixing parameter for SCF convergence (alpha in linear mixing) + print_debug : bool # Flag for printing debug information during calculation + + + + def __init__(self, + atomic_number : int, # Only atomic_number is required, all other parameters have default values + domain_size : Optional[float] = None, # 20.0 by default + number_of_finite_elements : Optional[int] = None, # 17 by default + polynomial_order : Optional[int] = None, # 31 by default + quadrature_point_number : Optional[int] = None, # 95 by default + xc_functional : Optional[str] = None, # 'GGA_PBE' by default + mesh_type : Optional[str] = None, # 'exponential' by default + mesh_concentration : Optional[float] = None, # 61.0 by default + scf_tolerance : Optional[float] = None, # 1e-8 by default + all_electron_flag : Optional[bool] = None, # False by default + enable_domain_size_test : Optional[bool] = None, # False by default + psp_dir_path : Optional[str] = None, # ../psps by default + psp_file_name : Optional[str] = None, # {atomic_number}.psp8 by default + frequency_integration_point_number : Optional[int] = None, # if xc_functional is 'RPA', 1200 by default + eigentolerance_x : Optional[float] = None, # for RPA, 1e-9 by default; for OEPx, 1e-11 by default, otherwise not needed + eigentolerance_c : Optional[float] = None, # for RPA, 1e-9 by default; for OEPx, 1e-09 by default, otherwise not needed + l_max_quantum_number : Optional[int] = None, # for RPA, 4 by default; for OEPx, 8 by default, otherwise 0 by default + smoothening_cutoff_frequency : Optional[float] = None, # for xc other than RPA, not needed; otherwise 0.0 for most atoms + double_hybrid_flag : Optional[bool] = None, # False by default + hybrid_mixing_parameter : Optional[float] = None, # 1.0 by default (0.25 for PBE0, variable for RPA) + mesh_spacing : Optional[float] = None, # 0.1 by default + density_mixing_parameter : Optional[float] = None, # 0.5 by default (alpha in linear mixing) + print_debug : Optional[bool] = None, # False by default + ): + + """ + Initialize the AtomicDFTSolver with computational parameters. + + Args: + atomic_number (int) : Atomic number of the element (e.g., 13 for Aluminum) + domain_size (float): Radial domain size in atomic units (typically 10-30) + number_of_finite_elements (int) : Number of finite elements in the domain + polynomial_order (int) : Polynomial order of basis functions (typically 20-40) + quadrature_point_number (int) : Quadrature points for integration (3-4x polynomial_order) + xc_functional (str) : Exchange-correlation functional ('GGA_PBE', 'RPA', 'OEPx', etc.) + mesh_type (str) : Mesh type ('exponential', 'polynomial', 'uniform') + mesh_concentration (float): Mesh concentration parameter (controls point density) + scf_tolerance (float): SCF convergence tolerance (typically 1e-8) + all_electron_flag (bool) : True for all-electron, False for pseudopotential + enable_domain_size_test (bool) : Enable domain size convergence testing + psp_dir_path (str) : Path to pseudopotential directory (required if all_electron_flag=False) + psp_file_name (str) : Name of pseudopotential file (required if all_electron_flag=False) + frequency_integration_point_number (int) : Frequency points for RPA calculations + eigentolerance_x (float): Exchange eigenvalue convergence tolerance + eigentolerance_c (float): Correlation eigenvalue convergence tolerance + l_max_quantum_number (int) : Maximum angular momentum quantum number + smoothening_cutoff_frequency (float): Smoothing cutoff for numerical stability + double_hybrid_flag (bool) : Enable double-hybrid functional methods + hybrid_mixing_parameter (float): Mixing parameter for hybrid functionals (e.g., 0.25 for PBE0) + mesh_spacing (float): Minimum mesh spacing (should match output file) + density_mixing_parameter (float): Density mixing parameter for SCF (alpha in linear mixing) + print_debug (bool) : Enable debug output + + Raises: + ValueError: If any parameter has incorrect type + + Note: + The solver uses finite element method with Legendre-Gauss-Lobatto nodes + for high-order accuracy in solving the Kohn-Sham equations. + """ + + # Initialize the class attributes + self.atomic_number = atomic_number + self.domain_size = domain_size + self.number_of_finite_elements = number_of_finite_elements + self.polynomial_order = polynomial_order + self.quadrature_point_number = quadrature_point_number + self.xc_functional = xc_functional + self.mesh_type = mesh_type + self.mesh_concentration = mesh_concentration + self.scf_tolerance = scf_tolerance + self.all_electron_flag = all_electron_flag + self.enable_domain_size_test = enable_domain_size_test + self.psp_dir_path = psp_dir_path + self.psp_file_name = psp_file_name + self.frequency_integration_point_number = frequency_integration_point_number + self.eigentolerance_x = eigentolerance_x + self.eigentolerance_c = eigentolerance_c + self.l_max_quantum_number = l_max_quantum_number + self.smoothening_cutoff_frequency = smoothening_cutoff_frequency + self.double_hybrid_flag = double_hybrid_flag + self.hybrid_mixing_parameter = hybrid_mixing_parameter + self.mesh_spacing = mesh_spacing + self.density_mixing_parameter = density_mixing_parameter + self.print_debug = print_debug + + + # set the default parameters, if not provided + self.set_and_check_initial_parameters() + + # initialize the psuedopotential data + self.pseudo = LocalPseudopotential( + atomic_number = self.atomic_number, + path = self.psp_dir_path, + filename = self.psp_file_name) + + # initialize the occupation information + self.occupation_info = OccupationInfo( + z_nuclear = int(self.pseudo.z_nuclear), + z_valence = int(self.pseudo.z_valence), + all_electron_flag = self.all_electron_flag) + + + # XC evaluator for delta-learning usage (to be initialized when needed) + self.xc_evaluator = None # TODO: Initialize when delta-learning is implemented + + # Grid data and operators (initialized in __init__) + self.grid_data_standard : Optional[GridData] = None + self.grid_data_dense : Optional[GridData] = None + self.ops_builder_standard : Optional[RadialOperatorsBuilder] = None + self.ops_builder_dense : Optional[RadialOperatorsBuilder] = None + + # SCF components (initialized in __init__) + self.hamiltonian_builder : Optional[HamiltonianBuilder] = None + self.density_calculator : Optional[DensityCalculator] = None + self.poisson_solver : Optional[PoissonSolver] = None + self.energy_calculator : Optional[EnergyCalculator] = None + self.scf_driver : Optional[SCFDriver] = None + + # Initialize grids and operators + self.grid_data_standard, self.grid_data_dense = self._initialize_grids() + self.ops_builder_standard = RadialOperatorsBuilder.from_grid_data( + self.grid_data_standard, verbose=self.print_debug + ) + self.ops_builder_dense = RadialOperatorsBuilder.from_grid_data( + self.grid_data_dense, verbose=self.print_debug + ) + + # Initialize SCF components + self._initialize_scf_components( + ops_builder_standard = self.ops_builder_standard, + grid_data_standard = self.grid_data_standard, + ops_builder_dense = self.ops_builder_dense, + ) + + if self.print_debug: + self.print_input_parameters() + self.pseudo.print_info() + self.occupation_info.print_info() + + + def set_and_check_initial_parameters(self): + """ + set and check the default parameters, if not provided + """ + # atomic number + assert isinstance(self.atomic_number, int), \ + ATOMIC_NUMBER_NOT_INTEGER_ERROR.format(type(self.atomic_number)) + assert self.atomic_number > 0, \ + ATOMIC_NUMBER_NOT_GREATER_THAN_0_ERROR.format(self.atomic_number) + assert self.atomic_number < 119, \ + ATOMIC_NUMBER_LARGER_THAN_119_ERROR.format(self.atomic_number) + + # domain size + if self.domain_size is None: + self.domain_size = 20.0 + try: + self.domain_size = float(self.domain_size) + except: + raise ValueError(DOMAIN_SIZE_NOT_FLOAT_ERROR.format(type(self.domain_size))) + assert isinstance(self.domain_size, float), \ + DOMAIN_SIZE_NOT_FLOAT_ERROR.format(type(self.domain_size)) + assert self.domain_size > 0, \ + DOMAIN_SIZE_NOT_GREATER_THAN_0_ERROR.format(self.domain_size) + + # number of finite elements + if self.number_of_finite_elements is None: + self.number_of_finite_elements = 17 + assert isinstance(self.number_of_finite_elements, int), \ + NUMBER_OF_FINITE_ELEMENTS_NOT_INTEGER_ERROR.format(type(self.number_of_finite_elements)) + assert self.number_of_finite_elements > 0, \ + NUMBER_OF_FINITE_ELEMENTS_NOT_GREATER_THAN_0_ERROR.format(self.number_of_finite_elements) + + # polynomial order + if self.polynomial_order is None: + self.polynomial_order = 31 + assert isinstance(self.polynomial_order, int), \ + POLYNOMIAL_ORDER_NOT_INTEGER_ERROR.format(type(self.polynomial_order)) + assert self.polynomial_order > 0, \ + POLYNOMIAL_ORDER_NOT_GREATER_THAN_0_ERROR.format(self.polynomial_order) + + # grid points integration quadrature + if self.quadrature_point_number is None: + self.quadrature_point_number = 95 + assert isinstance(self.quadrature_point_number, int), \ + QUADRATURE_POINT_NUMBER_NOT_INTEGER_ERROR.format(type(self.quadrature_point_number)) + assert self.quadrature_point_number > 0, \ + QUADRATURE_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR.format(self.quadrature_point_number) + + # xc functional + if self.xc_functional is None: + self.xc_functional = 'GGA_PBE' + assert isinstance(self.xc_functional, str), \ + XC_FUNCTIONAL_NOT_STRING_ERROR.format(type(self.xc_functional)) + assert self.xc_functional in VALID_XC_FUNCTIONAL_LIST, \ + XC_FUNCTIONAL_NOT_IN_VALID_LIST_ERROR.format(VALID_XC_FUNCTIONAL_LIST, self.xc_functional) + + # mesh type + if self.mesh_type is None: + self.mesh_type = 'exponential' + assert isinstance(self.mesh_type, str), \ + MESH_TYPE_NOT_STRING_ERROR.format(type(self.mesh_type)) + assert self.mesh_type in ['exponential', 'polynomial', 'uniform'], \ + MESH_TYPE_NOT_IN_VALID_LIST_ERROR.format(VALID_MESH_TYPE_LIST, self.mesh_type) + + # mesh concentration + if self.mesh_concentration is None: # default value + if self.mesh_type == 'exponential': + self.mesh_concentration = 61.0 + elif self.mesh_type == 'polynomial': + self.mesh_concentration = 3.0 + elif self.mesh_type == 'uniform': + self.mesh_concentration = None + if self.mesh_type in ['exponential', 'polynomial']: # type check + try: + self.mesh_concentration = float(self.mesh_concentration) + except: + raise ValueError(MESH_CONCENTRATION_NOT_FLOAT_ERROR.format(type(self.mesh_concentration))) + assert isinstance(self.mesh_concentration, float), \ + MESH_CONCENTRATION_NOT_FLOAT_ERROR.format(type(self.mesh_concentration)) + assert self.mesh_concentration > 0., \ + MESH_CONCENTRATION_NOT_GREATER_THAN_0_ERROR.format(self.mesh_concentration) + elif self.mesh_type == 'uniform': + if self.mesh_concentration is not None: + print(MESH_CONCENTRATION_NOT_NONE_FOR_UNIFORM_MESH_TYPE_WARNING) + self.mesh_concentration = None + else: + raise ValueError("This error should never be raised") + + # scf tolerance + if self.scf_tolerance is None: + # For most functionals, the default tolerance is 1e-8 + self.scf_tolerance = 1e-8 + if self.xc_functional in ['SCAN']: + # SCAN functional suffers from convergence issues, so we use a higher tolerance + self.scf_tolerance = 1e-4 + try: + self.scf_tolerance = float(self.scf_tolerance) + except: + raise ValueError(SCF_TOLERANCE_NOT_FLOAT_ERROR.format(type(self.scf_tolerance))) + assert isinstance(self.scf_tolerance, float), \ + SCF_TOLERANCE_NOT_FLOAT_ERROR.format(type(self.scf_tolerance)) + assert self.scf_tolerance > 0., \ + SCF_TOLERANCE_NOT_GREATER_THAN_0_ERROR.format(self.scf_tolerance) + + # all electron flag + if self.all_electron_flag is None: + self.all_electron_flag = False + if self.all_electron_flag in [0, 1]: + self.all_electron_flag = False if self.all_electron_flag == 0 else True + assert isinstance(self.all_electron_flag, bool), \ + ALL_ELECTRON_FLAG_NOT_BOOL_ERROR.format(type(self.all_electron_flag)) + + # enable domain size test + if self.enable_domain_size_test is None: + self.enable_domain_size_test = False + if self.enable_domain_size_test in [0, 1]: + self.enable_domain_size_test = False if self.enable_domain_size_test == 0 else True + assert isinstance(self.enable_domain_size_test, bool), \ + ENABLE_DOMAIN_SIZE_TEST_NOT_BOOL_ERROR.format(type(self.enable_domain_size_test)) + + # psp directory path + if self.all_electron_flag == False: + if self.psp_dir_path is None: + self.psp_dir_path = os.path.join(os.path.dirname(__file__), "..", "psps") + if not os.path.exists(self.psp_dir_path): + # if the psp directory path is not absolute path, make it absolute path + self.psp_dir_path = os.path.join(os.path.dirname(__file__), "..", self.psp_dir_path) + assert isinstance(self.psp_dir_path, str), \ + PSP_DIR_PATH_NOT_STRING_ERROR.format(type(self.psp_dir_path)) + assert os.path.exists(self.psp_dir_path), \ + PSP_DIR_PATH_NOT_EXISTS_ERROR.format(self.psp_dir_path) + + elif self.all_electron_flag == True: + if self.psp_dir_path is not None: + print(PSP_DIR_PATH_NOT_NONE_FOR_ALL_ELECTRON_CALCULATION_WARNING) + self.psp_dir_path = None + else: + raise ValueError("This error should never be raised") + + # psp file name + if self.all_electron_flag == False: + if self.psp_file_name is None: + # default value + if self.atomic_number < 10: + self.psp_file_name = "0" + str(self.atomic_number) + ".psp8" + else: + self.psp_file_name = str(self.atomic_number) + ".psp8" + assert isinstance(self.psp_file_name, str), \ + PSP_FILE_NAME_NOT_STRING_ERROR.format(type(self.psp_file_name)) + assert os.path.exists(os.path.join(self.psp_dir_path, self.psp_file_name)), \ + PSP_FILE_NAME_NOT_EXISTS_ERROR.format(self.psp_file_name, self.psp_dir_path) + elif self.all_electron_flag == True: + if self.psp_file_name is not None: + print(PSP_FILE_NAME_NOT_NONE_FOR_ALL_ELECTRON_CALCULATION_WARNING) + self.psp_file_name = None + else: + raise ValueError("This error should never be raised") + + # frequency integration point number + if self.xc_functional in ['RPA', ]: + if self.frequency_integration_point_number is None: + self.frequency_integration_point_number = 1200 + assert isinstance(self.frequency_integration_point_number, int), \ + FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_INTEGER_ERROR.format(type(self.frequency_integration_point_number)) + assert self.frequency_integration_point_number > 0, \ + FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_GREATER_THAN_0_ERROR.format(self.frequency_integration_point_number) + else: + if self.frequency_integration_point_number is not None: + print(FREQUENCY_INTEGRATION_POINT_NUMBER_NOT_NONE_FOR_OEPX_AND_NONE_XC_FUNCTIONAL_WARNING.format(self.xc_functional)) + self.frequency_integration_point_number = None + + # eigentolerance x + if self.xc_functional in ['OEPx', 'RPA']: # Default value: 1e-11 for OEPx, 1e-9 for RPA + if self.eigentolerance_x is None: + self.eigentolerance_x = 1e-11 if self.xc_functional == 'OEPx' else 1e-9 + assert isinstance(self.eigentolerance_x, float), \ + EIGENTOLERANCE_X_NOT_FLOAT_ERROR.format(type(self.eigentolerance_x)) + assert self.eigentolerance_x > 0., \ + EIGENTOLERANCE_X_NOT_GREATER_THAN_0_ERROR.format(self.eigentolerance_x) + else: + if self.eigentolerance_x is not None: + print(EIGENTOLERANCE_X_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING.format(self.xc_functional)) + self.eigentolerance_x = None + + # eigentolerance c + if self.xc_functional in ['OEPx', 'RPA']: # Default value: 1e-9 for OEPx, 1e-9 for RPA + if self.eigentolerance_c is None: + self.eigentolerance_c = 1e-9 + assert isinstance(self.eigentolerance_c, float), \ + EIGENTOLERANCE_C_NOT_FLOAT_ERROR.format(type(self.eigentolerance_c)) + assert self.eigentolerance_c > 0., \ + EIGENTOLERANCE_C_NOT_GREATER_THAN_0_ERROR.format(self.eigentolerance_c) + else: + if self.eigentolerance_c is not None: + print(EIGENTOLERANCE_C_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING.format(self.xc_functional)) + self.eigentolerance_c = None + + # l_max_quantum_number + if self.l_max_quantum_number is None: + if self.xc_functional == 'OEPx': + self.l_max_quantum_number = 8 + elif self.xc_functional == 'RPA': + self.l_max_quantum_number = 4 + else: + self.l_max_quantum_number = 0 + assert isinstance(self.l_max_quantum_number, int), \ + L_MAX_QUANTUM_NUMBER_NOT_INTEGER_ERROR.format(type(self.l_max_quantum_number)) + assert self.l_max_quantum_number >= 0., \ + L_MAX_QUANTUM_NUMBER_NEGATIVE_ERROR.format(self.l_max_quantum_number) + + # smoothening cutoff frequency + if self.xc_functional in ['RPA', ]: + if self.smoothening_cutoff_frequency is None: + self.smoothening_cutoff_frequency = 60.0 + if self.atomic_number == 2: + self.smoothening_cutoff_frequency = 60.0 + elif self.atomic_number == 4: + self.smoothening_cutoff_frequency = 60.0 + elif self.atomic_number == 10: + self.smoothening_cutoff_frequency = 60.0 + elif self.atomic_number == 12: + self.smoothening_cutoff_frequency = 60.0 + elif self.atomic_number == 18: + self.smoothening_cutoff_frequency = 100.0 + assert isinstance(self.smoothening_cutoff_frequency, float), \ + SMOOTHENING_CUTOFF_FREQUENCY_NOT_FLOAT_ERROR.format(type(self.smoothening_cutoff_frequency)) + assert self.smoothening_cutoff_frequency >= 0., \ + SMOOTHENING_CUTOFF_FREQUENCY_NEGATIVE_ERROR.format(self.smoothening_cutoff_frequency) + else: + if self.smoothening_cutoff_frequency is not None: + print(SMOOTHENING_CUTOFF_FREQUENCY_NOT_NONE_FOR_XC_FUNCTIONAL_OTHER_THAN_RPA_WARNING.format(self.xc_functional)) + self.smoothening_cutoff_frequency = None + + # double hybrid flag + if self.double_hybrid_flag is None: + self.double_hybrid_flag = False + if self.double_hybrid_flag in [0, 1]: + self.double_hybrid_flag = False if self.double_hybrid_flag == 0 else True + assert isinstance(self.double_hybrid_flag, bool), \ + DOUBLE_HYBRID_FLAG_NOT_BOOL_ERROR.format(type(self.double_hybrid_flag)) + + # hybrid mixing parameter + # Only validate for hybrid functionals (PBE0, HF) + if self.xc_functional in ['PBE0', 'HF']: + if self.hybrid_mixing_parameter is None: + # Use default values based on functional + if self.xc_functional == 'PBE0': + self.hybrid_mixing_parameter = 0.25 + # print(NO_HYBRID_MIXING_PARAMETER_PROVIDED_FOR_HYBRID_FUNCTIONAL_WARNING.format(self.xc_functional, 0.25)) + elif self.xc_functional == 'HF': + self.hybrid_mixing_parameter = 1.0 + + # If the hybrid mixing parameter is provided, check the type and value + assert isinstance(self.hybrid_mixing_parameter, (float, int)), \ + HYBRID_MIXING_PARAMETER_NOT_FLOAT_ERROR.format(type(self.hybrid_mixing_parameter)) + assert 0.0 <= self.hybrid_mixing_parameter <= 1.0, \ + HYBRID_MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR.format(self.hybrid_mixing_parameter) + if self.xc_functional == "HF": + assert self.hybrid_mixing_parameter == 1.0, \ + HYBRID_MIXING_PARAMETER_NOT_ONE_FOR_HF_ERROR.format(self.hybrid_mixing_parameter) + else: + # For non-hybrid functionals, hybrid_mixing_parameter is not used + # Set it to None to avoid confusion + self.hybrid_mixing_parameter = None + + # density mixing parameter + if self.density_mixing_parameter is None: + self.density_mixing_parameter = 0.5 + try: + self.density_mixing_parameter = float(self.density_mixing_parameter) + except: + raise ValueError(DENSITY_MIXING_PARAMETER_NOT_FLOAT_ERROR.format(type(self.density_mixing_parameter))) + assert 0.0 < self.density_mixing_parameter <= 1.0, \ + DENSITY_MIXING_PARAMETER_NOT_IN_ZERO_ONE_ERROR.format(self.density_mixing_parameter) + + # mesh spacing + if self.mesh_spacing is None: + self.mesh_spacing = 0.1 + assert isinstance(self.mesh_spacing, float), \ + MESH_SPACING_NOT_FLOAT_ERROR.format(type(self.mesh_spacing)) + assert self.mesh_spacing > 0., \ + MESH_SPACING_NOT_GREATER_THAN_0_ERROR.format(self.mesh_spacing) + + + # print debug + if self.print_debug is None: + self.print_debug = False + if self.print_debug in [0, 1]: + self.print_debug = False if self.print_debug == 0 else True + assert isinstance(self.print_debug, bool), \ + PRINT_DEBUG_NOT_BOOL_ERROR.format(type(self.print_debug)) + + + def print_input_parameters(self): + + # Display relative path for psp_dir_path + if self.psp_dir_path is not None: + try: + # Try to get relative path from current working directory + psp_path_display = os.path.relpath(self.psp_dir_path) + except ValueError: + # If relative path fails (e.g., different drives on Windows), use absolute path + psp_path_display = self.psp_dir_path + else: + psp_path_display = self.psp_dir_path + + # print the input parameters + print("=" * 60) + print("\t\t INPUT PARAMETERS") + print("=" * 60) + + print("\t atomic_number : {}".format(self.atomic_number)) + print("\t domain_size : {}".format(self.domain_size)) + print("\t number_of_finite_elements : {}".format(self.number_of_finite_elements)) + print("\t polynomial_order : {}".format(self.polynomial_order)) + print("\t quadrature_point_number : {}".format(self.quadrature_point_number)) + print("\t xc_functional : {}".format(self.xc_functional)) + print("\t mesh_type : {}".format(self.mesh_type)) + print("\t mesh_concentration : {}".format(self.mesh_concentration)) + print("\t scf_tolerance : {}".format(self.scf_tolerance)) + print("\t all_electron_flag : {}".format(self.all_electron_flag)) + print("\t enable_domain_size_test : {}".format(self.enable_domain_size_test)) + print("\t psp_dir_path : {}".format(psp_path_display)) + print("\t psp_file_name : {}".format(self.psp_file_name)) + print("\t frequency_integration_point_number : {}".format(self.frequency_integration_point_number)) + print("\t eigentolerance_x : {}".format(self.eigentolerance_x)) + print("\t eigentolerance_c : {}".format(self.eigentolerance_c)) + print("\t l_max_quantum_number : {}".format(self.l_max_quantum_number)) + print("\t smoothening_cutoff_frequency : {}".format(self.smoothening_cutoff_frequency)) + print("\t double_hybrid_flag : {}".format(self.double_hybrid_flag)) + print("\t hybrid_mixing_parameter : {}".format(self.hybrid_mixing_parameter)) + print("\t mesh_spacing : {}".format(self.mesh_spacing)) + print("\t density_mixing_parameter : {}".format(self.density_mixing_parameter)) + print() + + + def _initialize_grids(self) -> Tuple[GridData, GridData]: + """ + Initialize finite element grids and quadrature. + + Generates two grid configurations: + - Standard grid: for most operators and wavefunctions + - Dense grid: refined mesh for Hartree potential solver (double density) + + Returns + ------- + grid_data_standard : GridData + Standard grid data for operators and wavefunctions + grid_data_dense : GridData + Dense grid data for Hartree solver + """ + # Generate Lobatto interpolation nodes on reference interval [-1, 1] + interp_nodes_ref, _ = Quadrature1D.lobatto(self.polynomial_order) + + # Generate mesh boundaries + mesh1d = Mesh1D( + domain_radius = self.domain_size / 2.0, + finite_elements_num = self.number_of_finite_elements, + mesh_type = self.mesh_type, + clustering_param = self.mesh_concentration, + exp_shift = getattr(self, 'exp_shift', None) + ) + boundaries_nodes, _ = mesh1d.generate_mesh_nodes_and_width() + + # Generate standard FE nodes + global_nodes = Mesh1D.generate_fe_nodes( + boundaries_nodes = boundaries_nodes, + interp_nodes = interp_nodes_ref + ) + + # Generate refined FE nodes (for Hartree potential solver) + refined_interp_nodes_ref = Mesh1D.refine_interpolation_nodes(interp_nodes_ref) + refined_global_nodes = Mesh1D.generate_fe_nodes( + boundaries_nodes = boundaries_nodes, + interp_nodes = refined_interp_nodes_ref + ) + + # Generate Gauss-Legendre quadrature nodes and weights + quadrature_nodes_ref, quadrature_weights_ref = Quadrature1D.gauss_legendre( + self.quadrature_point_number + ) + + # Map quadrature to physical elements + quadrature_nodes, quadrature_weights = Mesh1D.map_quadrature_to_physical_elements( + boundaries_nodes = boundaries_nodes, + interp_nodes = quadrature_nodes_ref, + interp_weights = quadrature_weights_ref, + flatten = True + ) + + # Create grid data objects + grid_data_standard = GridData( + number_of_finite_elements = self.number_of_finite_elements, + physical_nodes = global_nodes, + quadrature_nodes = quadrature_nodes, + quadrature_weights = quadrature_weights + ) + + grid_data_dense = GridData( + number_of_finite_elements = self.number_of_finite_elements, + physical_nodes = refined_global_nodes, + quadrature_nodes = quadrature_nodes, + quadrature_weights = quadrature_weights + ) + + return grid_data_standard, grid_data_dense + + + def _initialize_scf_components( + self, + ops_builder_standard: RadialOperatorsBuilder, + grid_data_standard: GridData, + ops_builder_dense: RadialOperatorsBuilder, + ) -> None: + """ + Initialize all SCF components. + + This method creates and configures all the modular SCF components: + - HamiltonianBuilder : constructs Hamiltonian matrices (uses standard grid) + - DensityCalculator : computes density from orbitals (uses standard grid) + - PoissonSolver : solves for Hartree potential (uses dense grid) + - EnergyCalculator : computes total energy (uses standard grid) + - SCFDriver : manages SCF iterations + + Note: Only PoissonSolver uses the dense grid for accurate Hartree potential. + All other components use the standard grid. + """ + + # Hamiltonian builder (uses standard grid) + self.hamiltonian_builder = HamiltonianBuilder( + ops_builder = ops_builder_standard, + pseudo = self.pseudo, + occupation_info = self.occupation_info, + all_electron = self.all_electron_flag + ) + + # Density calculator (uses standard grid, but the derivative matrix is from the dense grid) + self.density_calculator = DensityCalculator( + grid_data = grid_data_standard, + occupation_info = self.occupation_info, + derivative_matrix = ops_builder_dense.derivative_matrix + ) + + # Poisson solver for Hartree potential (uses dense grid for accuracy) + self.poisson_solver = PoissonSolver( + ops_builder = ops_builder_dense, + z_valence = float(self.occupation_info.z_valence) + ) + + # SCF Driver (create first to get xc_calculator) + eigensolver = EigenSolver(xc_functional=self.xc_functional) + mixer = Mixer( + tol = self.scf_tolerance, + alpha_lin = (self.density_mixing_parameter, self.density_mixing_parameter), + alpha_pulay = 0.55, + history = 7, + frequency = 2 + ) + + self.scf_driver = SCFDriver( + hamiltonian_builder = self.hamiltonian_builder, + density_calculator = self.density_calculator, + poisson_solver = self.poisson_solver, + eigensolver = eigensolver, + mixer = mixer, + occupation_info = self.occupation_info, + xc_functional = self.xc_functional, + hybrid_mixing_parameter = self.hybrid_mixing_parameter + ) + + # Get XC calculator and HF calculator from scf_driver + xc_calculator = self.scf_driver.xc_calculator if hasattr(self.scf_driver, 'xc_calculator') else None + hf_calculator = self.scf_driver.hf_calculator if hasattr(self.scf_driver, 'hf_calculator') else None + + # Energy calculator (uses standard grid data and ops_builder, but dense derivative matrix) + self.energy_calculator = EnergyCalculator( + grid_data = grid_data_standard, + occupation_info = self.occupation_info, + ops_builder = ops_builder_standard, + poisson_solver = self.poisson_solver, + pseudo = self.pseudo, + xc_calculator = xc_calculator, + hf_calculator = hf_calculator, # Pass HF calculator from SCFDriver + derivative_matrix = ops_builder_dense.derivative_matrix # Use dense grid derivative for accuracy + ) + + + def _get_scf_settings(self, xc_functional: str) -> Dict[str, Any]: + assert isinstance(xc_functional, str), \ + XC_FUNCTIONAL_TYPE_ERROR_MESSAGE.format(type(xc_functional)) + assert xc_functional in VALID_XC_FUNCTIONAL_LIST, \ + XC_FUNCTIONAL_NOT_IN_VALID_LIST_ERROR.format(VALID_XC_FUNCTIONAL_LIST, xc_functional) + + """Get SCF settings based on XC functional.""" + settings = { + 'inner_max_iter' : 500, + 'outer_max_iter' : 1, # Default: no outer loop for LDA/GGA + 'rho_tol' : self.scf_tolerance, + 'outer_rho_tol' : self.scf_tolerance, + 'n_consecutive' : 1, + 'print_debug' : self.print_debug + } + + # For functionals requiring outer loop (HF, OEP, RPA) + if xc_functional in ['HF', 'PBE0', 'OEPx', 'RPA']: + settings['outer_max_iter'] = 50 + + return settings + + + def _evaluate_basis_on_uniform_grid( + self, + ops_builder_standard: RadialOperatorsBuilder, + orbitals: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Evaluate all orbitals on a uniform evaluation grid. + + This function generates a uniform grid spanning the domain and evaluates + each orbital state on that grid using Lagrange interpolation. The result + is useful for: + - Visualization and analysis (uniform spacing for plotting) + - Output formatting (matching reference data formats) + - Further post-processing (interpolation to different grids) + + Parameters + ---------- + ops_builder_standard : RadialOperatorsBuilder + Operators builder containing mesh information and interpolation methods. + Used to evaluate orbitals on the given grid using finite element basis functions. + orbitals : np.ndarray + Orbital coefficients at physical nodes, shape (n_physical_nodes, n_states). + Each column represents one orbital state (eigenvector). + + Returns + ------- + orbitals_on_given_grid : np.ndarray + Orbital values evaluated on the uniform grid, shape (n_grid_points, n_states). + Each column contains the values of one orbital state on the uniform grid. + + Notes + ----- + - The uniform grid is generated with spacing `self.mesh_spacing` over `[0, domain_size]`. + - Each orbital is evaluated independently using `evaluate_single_orbital_on_given_grid`. + - The evaluation uses Lagrange polynomial interpolation within each finite element. + + Example + ------- + >>> uniform_grid_values = solver._evaluate_basis_on_uniform_grid( + ... ops_builder_standard=ops_builder, + ... orbitals=eigenvectors # shape: (n_nodes, n_states) + ... ) + >>> # uniform_grid_values.shape = (n_grid_points, n_states) + """ + # Generate uniform evaluation grid with specified spacing + uniform_eval_grid = np.linspace( + start=0.0, + stop=self.domain_size, + num=int(self.domain_size / self.mesh_spacing) + 1, + endpoint=True + ) + + # Evaluate each orbital state on the uniform grid + n_states = orbitals.shape[1] + n_grid_given = len(uniform_eval_grid) + orbitals_on_given_grid = np.zeros((n_grid_given, n_states)) + + for state_index in range(n_states): + # Evaluate single orbital on the uniform grid using Lagrange interpolation + orbitals_on_given_grid[:, state_index] = ops_builder_standard.evaluate_single_orbital_on_given_grid( + given_grid = uniform_eval_grid, + orbital = orbitals[:, state_index] + ) + return uniform_eval_grid, orbitals_on_given_grid + + + def _get_initial_density_and_orbitals_with_warm_start( + self, + xc_functional : str, + rho_initial : np.ndarray, + orbitals_initial : Optional[np.ndarray] = None, + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Warm start calculation using specified XC functional to obtain initial density and orbitals. + + This function is used for initializing meta-GGA functionals (e.g., SCAN) by running + a simpler functional (e.g., GGA_PBE) first to obtain better initial guesses, which + improves convergence. + + Parameters + ---------- + xc_functional : str + XC functional name for warm start (e.g., "GGA_PBE" or "RSCAN") + rho_initial : np.ndarray + Initial density guess to start the warm calculation + orbitals_initial : np.ndarray, optional + Initial orbitals guess (if available), None otherwise + + Returns + ------- + rho_initial : np.ndarray + Initial density from warm start calculation + orbitals_initial : np.ndarray + Initial orbitals from warm start calculation + + Notes + ----- + - Creates a temporary SCFDriver based on existing components + - Uses relaxed convergence criteria to accelerate warm start + - Warm start calculation does not require full convergence, only a reasonable initial guess + """ + # Create temporary eigensolver with specified functional type + eigensolver_warm = EigenSolver(xc_functional=xc_functional) + + + # Create temporary SCFDriver with specified xc_functional + # Reuse existing hamiltonian_builder, density_calculator, poisson_solver in the main SCFDriver + scf_driver_warm = SCFDriver( + hamiltonian_builder = self.scf_driver.hamiltonian_builder, + density_calculator = self.scf_driver.density_calculator, + poisson_solver = self.scf_driver.poisson_solver, + eigensolver = eigensolver_warm, + mixer = self.scf_driver.mixer, + occupation_info = self.scf_driver.occupation_info, + xc_functional = xc_functional, # Use specified functional + hybrid_mixing_parameter = self.scf_driver.hybrid_mixing_parameter + ) + + + # Run warm start SCF calculation + if self.print_debug: + print(f"[Warm Start] Running {xc_functional} pre-calculation for initial guess") + + scf_result_warm = scf_driver_warm.run( + rho_initial = rho_initial, + settings = self._get_scf_settings(xc_functional), + orbitals_initial = orbitals_initial + ) + + if self.print_debug: + if not scf_result_warm.converged: + print(WARM_START_NOT_CONVERGED_WARNING.format(xc_functional)) + + # Extract results: density and orbitals + rho_final = scf_result_warm.density_data.rho + orbitals_final = scf_result_warm.orbitals + + return rho_final, orbitals_final + + + def forward(self, orbitals) -> Dict[str, Any]: + """ + Forward pass of the atomic DFT solver. + + This method performs a single forward pass without SCF iteration: + - Takes rho and orbitals as input + - Computes XC potential and energy + - Returns results in the same format as solve() + + Parameters + ---------- + rho : np.ndarray + Electron density, shape (n_quad_points,) + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions R_nl(r)) + Shape: (n_states, n_quad_points) + + Returns + ------- + final_result : Dict[str, Any] + Dictionary containing: + - eigen_energies: None (not computed in forward pass) + - orbitals: input orbitals + - rho: valence density computed from orbitals + - density_data: DensityData computed from orbitals (without NLCC) + - rho_nlcc: non-linear core correction density + - energy: total energy + - energy_components: EnergyComponents object + - grid_data: GridData for standard grid + - occupation_info: OccupationInfo + - xc_potential: XCPotentialData + """ + # Phase 1: Get XC functional requirements + # Note: Grids and SCF components are already initialized in __init__ + xc_requirements = get_functional_requirements(self.xc_functional) + + # Phase 2: Calculate rho_nlcc (non-linear core correction for pseudopotentials) + rho_nlcc = self.pseudo.get_rho_core_correction(self.grid_data_standard.quadrature_nodes) + + # Phase 3: Create density_data from orbitals (with NLCC for XC potential calculation) + # Note: For XC potential calculation, we need density_data with NLCC + # For energy calculation, we use density_data without NLCC + density_data_with_nlcc = self.density_calculator.create_density_data_from_orbitals( + orbitals = orbitals, + compute_gradient = xc_requirements.needs_gradient, + compute_tau = xc_requirements.needs_tau, + normalize = True, + rho_nlcc = rho_nlcc + ) + + # Phase 4: Compute XC potential data (using density_data with NLCC) + xc_potential : XCPotentialData = self.energy_calculator.compute_xc_potential(density_data_with_nlcc) + + # Phase 5: Create density_data without NLCC for energy calculation + # Energy calculation uses valence density only (without NLCC) + density_data_valence = self.density_calculator.create_density_data_from_orbitals( + orbitals = orbitals, + compute_gradient = xc_requirements.needs_gradient, + compute_tau = xc_requirements.needs_tau, + normalize = True, + rho_nlcc = None # No NLCC for energy calculation + ) + + # Phase 6: Compute final energy (using valence density only) + energy_components : EnergyComponents = self.energy_calculator.compute_energy( + orbitals = orbitals, + density_data = density_data_valence, + mixing_parameter = self.hybrid_mixing_parameter + ) + + # Phase 7: Evaluate basis functions on uniform grid (optional, for future use) + # TODO: Implement this when needed + # Note: _evaluate_basis_on_uniform_grid expects SCFResult, which we don't have in forward pass + # For now, we'll skip this step as it's not essential for the forward pass + # If needed in the future, we can create a minimal SCFResult-like object or modify the method + uniform_grid, orbitals_on_uniform_grid = self._evaluate_basis_on_uniform_grid( + ops_builder_standard = self.ops_builder_standard, + orbitals = orbitals + ) + + # Phase 10: Pack and return results + final_result = { + 'eigen_energies' : None, # Not computed in forward pass + 'orbitals' : orbitals, + 'rho' : density_data_valence.rho, # Valence density + 'density_data' : density_data_valence, # Density data without NLCC + 'rho_nlcc' : rho_nlcc, + 'energy' : energy_components.total, + 'energy_components' : energy_components, + 'converged' : True, # Forward pass doesn't iterate, so always "converged" + 'iterations' : 0, # No iterations in forward pass + 'rho_residual' : 0.0, # No residual in forward pass + 'grid_data' : self.grid_data_standard, + 'occupation_info' : self.occupation_info, + 'xc_potential' : xc_potential, + } + + return final_result + + + def solve(self) -> Dict[str, Any]: + """ + Solve the Kohn-Sham equations using modular SCF architecture. + + Clean workflow: + 1. Initialize grids and operators + 2. Initialize SCF components + 3. Get initial density guess + 4. Run SCF iteration + 5. Compute final energy + 6. Return results + + """ + # Phase 1: Initial density guess + # Note: Grids and SCF components are already initialized in __init__ + rho_initial = self.pseudo.get_rho_guess(self.grid_data_standard.quadrature_nodes) + rho_nlcc = self.pseudo.get_rho_core_correction(self.grid_data_standard.quadrature_nodes) + orbitals_initial = None + + # Warm start calculation for relatively expensive meta-GGA functionals + if self.xc_functional in ['SCAN', 'RSCAN', 'R2SCAN']: + rho_initial, orbitals_initial = self._get_initial_density_and_orbitals_with_warm_start( + xc_functional = "GGA_PBE", + rho_initial = rho_initial, + orbitals_initial = orbitals_initial) + + # Phase 2: Run SCF + scf_result : SCFResult = self.scf_driver.run( + rho_initial = rho_initial, + settings = self._get_scf_settings(self.xc_functional), + orbitals_initial = orbitals_initial + ) + + # Phase 3: Compute final xc potential data + xc_potential : XCPotentialData = self.energy_calculator.compute_xc_potential(scf_result.density_data) + + # Phase 4: Compute final energy + energy_components : EnergyComponents = self.energy_calculator.compute_energy( + orbitals = scf_result.orbitals, + density_data = scf_result.density_data, + mixing_parameter = self.hybrid_mixing_parameter + ) + + # Phase 5: Evaluate basis functions on uniform grid + uniform_grid, orbitals_on_uniform_grid = self._evaluate_basis_on_uniform_grid( + ops_builder_standard = self.ops_builder_standard, + orbitals = scf_result.orbitals + ) + + + # Phase 6: Pack and return results + final_result = { + 'eigen_energies' : scf_result.eigen_energies, + 'orbitals' : scf_result.orbitals, + 'rho' : scf_result.density_data.rho, # Interpolate over psi and calculate rho at that site + 'density_data' : scf_result.density_data, # + 'rho_nlcc' : rho_nlcc, + 'energy' : energy_components.total, + 'energy_components' : energy_components, + 'converged' : scf_result.converged, + 'iterations' : scf_result.iterations, + 'rho_residual' : scf_result.rho_residual, + 'grid_data' : self.grid_data_standard, + 'occupation_info' : self.occupation_info, + 'xc_potential' : xc_potential, + 'uniform_grid' : uniform_grid, + 'orbitals_on_uniform_grid' : orbitals_on_uniform_grid, + } + + + # source : rho, grad_rho, lap_rho, v_hartree... + # target : vx, vc + + # Make a note. + # 1. Generalize to partial occupation + # 2. Net charge + # 3. inverse density -> Vp problem + + # Gauge for energy density (double integral -> different gauges) + # Non-locality + + + if self.print_debug: + energy_components.print_info(title = f"Total Energy ({self.xc_functional})") + print("="*60) + print("\t\t Calculation Complete") + print("="*60) + print() + + return final_result + + + +if __name__ == "__main__": + atomic_dft_solver = AtomicDFTSolver( + atomic_number = 13, + print_debug = True, + xc_functional = "GGA_PBE", + all_electron_flag = True, + ) + + results = atomic_dft_solver.solve() + rho = results['rho'] + orbitals = results['orbitals'] + print(rho.shape) + print(orbitals.shape) diff --git a/utils/atom/testcase/__init__.py b/utils/atom/testcase/__init__.py new file mode 100644 index 00000000..a5ff0c84 --- /dev/null +++ b/utils/atom/testcase/__init__.py @@ -0,0 +1 @@ +# Test case module for atomic_dft \ No newline at end of file diff --git a/utils/atom/testcase/mesh_builder_testcase.py b/utils/atom/testcase/mesh_builder_testcase.py new file mode 100644 index 00000000..59e5c500 --- /dev/null +++ b/utils/atom/testcase/mesh_builder_testcase.py @@ -0,0 +1,241 @@ + + +import os +import sys +import numpy as np +import matplotlib.pyplot as plt + + +sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) +from atom.mesh.builder import Quadrature1D, Mesh1D, LagrangeShapeFunctions + + + + +def test_function(x): + return 1 / (1 + x ** 2) + + +def print_test_passed(test_name : str): + print("\t {:<30} : test passed".format(test_name)) + + +def test_quadrature1d(n = 95, pnt=False): + # Test Function: Quadrature1D.gauss_legendre + # Test Purpose : Test the Gauss-Legendre quadrature nodes and weights + nodes, legendre_weights = Quadrature1D.gauss_legendre(n) + + integral = np.sum(test_function(nodes) * legendre_weights) + integral_ref = np.pi / 2 + assert np.isclose(integral, integral_ref, atol=1e-6) + print_test_passed("Quadrature1D.gauss_legendre") + + if pnt: + with open("outputs/mesh_builder_testcase/gauss_legendre_quadrature.txt", "w") as f: + f.write("legendre_weights: \n") + f.write(str(legendre_weights)) + f.write("\n") + f.write("nodes: \n") + f.write(str(nodes)) + f.write("\n") + + +def test_lobatto1d(n = 31, pnt=False): + # Test Function: Quadrature1D.lobatto + # Test Purpose : Test the Lobatto quadrature nodes and weights + + nodes, lobatto_weights = Quadrature1D.lobatto(n) + + integral = np.sum(test_function(nodes) * lobatto_weights) + integral_ref = np.pi / 2 + assert np.isclose(integral, integral_ref, atol=1e-6) + print_test_passed("Quadrature1D.lobatto") + + if pnt: + with open("outputs/mesh_builder_testcase/lobatto_quadrature.txt", "w") as f: + f.write("lobatto_weights: \n") + f.write(str(lobatto_weights)) + f.write("\n") + f.write("nodes: \n") + f.write(str(nodes)) + f.write("\n") + + +def test_mesh1d_grid(n = 17): + mesh = Mesh1D( + domain_radius = 10.0, + finite_elements_num = n, + mesh_type = "exponential", + clustering_param = 61.0, + exp_shift = 0.0) + mesh_nodes, mesh_width = mesh.generate_mesh_nodes_and_width() + with open("outputs/mesh_builder_testcase/mesh1d_grid.txt", "w") as f: + f.write("mesh_nodes: \n") + f.write(str(mesh_nodes)) + f.write("\n") + f.write("mesh_width: \n") + f.write(str(mesh_width)) + f.write("\n") + + +def test_mesh1d_fe_nodes(n = 17): + mesh = Mesh1D( + domain_radius = 10.0, + finite_elements_num = n, + mesh_type = "exponential", + clustering_param = 61.0, + exp_shift = 0.0) + mesh_nodes, _ = mesh.generate_mesh_nodes_and_width() + interp_nodes, _ = Quadrature1D.lobatto(31) + fe_nodes = Mesh1D.generate_fe_nodes(mesh_nodes, interp_nodes) + with open("outputs/mesh_builder_testcase/mesh1d_fe_nodes.txt", "w") as f: + f.write("len(fe_nodes): {}".format(len(fe_nodes))) + f.write("\n") + f.write("fe_nodes: \n") + f.write(str(fe_nodes)) + f.write("\n") + + +def test_fe_flat_to_block2d(): + """ + Test Function : fe_flat_to_block2d + Test Purpose : Verify reshaping 1D FE grids into (n_elem, m) blocks under + (1) shared-endpoint layout and (2) stacked layout; + also verify that invalid lengths raise AssertionError. + """ + + def print_pass(name): + print(f"\t {name} : passed") + + # ---------------------------- + # Case 1: endpoints_shared=True + # 3 elements, 4 points per element -> len(flat) = 3*(4-1)+1 = 10 + # rows should be windows with stride (m-1)=3 + # ---------------------------- + flat1 = np.arange(10, dtype=float) + n_elem1 = 3 + out1 = Mesh1D.fe_flat_to_block2d(flat1, n_elem1, endpoints_shared=True) + expected1 = np.array([ + [0, 1, 2, 3], + [3, 4, 5, 6], + [6, 7, 8, 9], + ], dtype=float) + + assert out1.shape == (3, 4) + np.testing.assert_array_equal(out1, expected1) + print_pass("fe_flat_to_block2d (endpoints_shared=True)") + + + # ---------------------------- + # Case 2: endpoints_shared=False + # 3 elements, 4 points per element -> len(flat) = 3*4 = 12 + # direct reshape into (3,4) + # ---------------------------- + flat2 = np.arange(12, dtype=float) + n_elem2 = 3 + out2 = Mesh1D.fe_flat_to_block2d(flat2, n_elem2, endpoints_shared=False) + expected2 = np.array([ + [0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9, 10, 11], + ], dtype=float) + + assert out2.shape == (3, 4) + np.testing.assert_array_equal(out2, expected2) + print_pass("fe_flat_to_block2d (endpoints_shared=False)") + + + # ---------------------------- + # Case 3: invalid lengths should raise AssertionError + # For shared=True, length must be n_elem*(m-1)+1; here we break it + # For shared=False, length must be n_elem*m; here we break it + # ---------------------------- + bad_flat = np.arange(9) # length 9 doesn't fit either (3,4) rules above + try: + _ = Mesh1D.fe_flat_to_block2d(bad_flat, 3, endpoints_shared=True) + raise AssertionError("Expected AssertionError for shared=True did not occur") + except AssertionError: + pass + try: + _ = Mesh1D.fe_flat_to_block2d(bad_flat, 3, endpoints_shared=False) + raise AssertionError("Expected AssertionError for shared=False did not occur") + except AssertionError: + pass + print_pass("fe_flat_to_block2d (invalid lengths raise)") + + print("\t All fe_flat_to_block2d tests passed!") + + + +def test_lagrange_shape_functions_lagrange_basis_and_derivatives(n=17): + """ + Unit test for LagrangeShapeFunctions.lagrange_basis_and_derivatives. + + This function checks: + 1. Shape correctness of returned arrays. + 2. Partition of unity: sum_k L_k(x) == 1. + 3. Derivative consistency: sum_k dLdx_k(x) == 0. + 4. Interpolation property: L_k(x_j) = δ_kj at nodal points. + 5. Smoothness: dLdx finite and behaves as expected. + """ + + # --- Setup: simple node layout and evaluation points --- + nodes = np.array([0.0, 1.0, 2.0, 3.0]) # 4 equally spaced nodes + x_eval = np.linspace(0.0, 3.0, 31) # evaluation points in [0,3] + + # Wrap into element-batch form (1 element) + nodes = nodes[None, :] + x_eval = x_eval[None, :] + + # --- Call the function to test --- + L, dLdx = LagrangeShapeFunctions.lagrange_basis_and_derivatives(nodes, x_eval) + + # --- Check 1: shape correctness --- + assert L.shape == (1, x_eval.shape[1], nodes.shape[1]) + assert dLdx.shape == (1, x_eval.shape[1], nodes.shape[1]) + print("\t 1. Shape check passed:", L.shape, dLdx.shape) + + # --- Check 2: partition of unity --- + unity_error = np.max(np.abs(np.sum(L[0, :, :], axis=1) - 1.0)) + assert unity_error < 1e-12 + print("\t 2. Partition of unity check passed (max error = %.2e)" % unity_error) + + # --- Check 3: derivative consistency (sum of dLdx == 0) --- + deriv_sum_error = np.max(np.abs(np.sum(dLdx[0, :, :], axis=1))) + assert deriv_sum_error < 1e-10 + print("\t 3. Derivative consistency check passed (max error = %.2e)" % deriv_sum_error) + + # --- Check 4: interpolation property (nodal identity) --- + # Evaluate basis at nodal points + L_nodes, dLdx_nodes = LagrangeShapeFunctions.lagrange_basis_and_derivatives(nodes, nodes) + identity_error = np.max(np.abs(L_nodes[0, :, :] - np.eye(nodes.shape[1]))) + assert identity_error < 1e-12 + print("\t 4. Interpolation property check passed (max error = %.2e)" % identity_error) + + # --- Check 5: finite values --- + assert np.all(np.isfinite(L)) + assert np.all(np.isfinite(dLdx)) + print("\t 5. Finite value check passed") + + print("\t All Lagrange basis tests passed!") + + + + + + +if __name__ == "__main__": + if not os.path.exists("outputs/mesh_builder_testcase"): + os.makedirs("outputs/mesh_builder_testcase") + + print("Running tests...") + # test_quadrature1d(n = 95) + # test_lobatto1d(n = 31) + # test_mesh1d_grid(n = 17) + # test_mesh1d_fe_nodes(n = 17) + test_fe_flat_to_block2d() + # test_lagrange_shape_functions_lagrange_basis_and_derivatives(n = 17) + print("All tests passed") + + # Terminal command: + # python atomic_dft/testcase/mesh_builder_testcase.py \ No newline at end of file diff --git a/utils/atom/utils/__init__.py b/utils/atom/utils/__init__.py new file mode 100644 index 00000000..121970c9 --- /dev/null +++ b/utils/atom/utils/__init__.py @@ -0,0 +1,2 @@ +# Utils module initialization +# This module contains utility classes and functions for atomic DFT calculations diff --git a/utils/atom/utils/occupation_states.py b/utils/atom/utils/occupation_states.py new file mode 100644 index 00000000..e2c85655 --- /dev/null +++ b/utils/atom/utils/occupation_states.py @@ -0,0 +1,618 @@ + + + +import sys +import numpy as np + + +''' +Input: Atomic Number Z +Output: Occ matrix containing "n" quantum number list in first row, "l" +quantum number in the second row, the corresponding spin-up occupation +in the third row and spin-down occupation in the fourth row. +''' + +def Occ_states(Z): + + if Z == 1: + n_quantum = np.array([1]) + l_quantum = np.array([0]) + s_quantum_up = np.array([1]) + s_quantum_down = np.array([0]) + elif Z == 2: + n_quantum = np.array([1]) + l_quantum = np.array([0]) + s_quantum_up = np.array([1]) + s_quantum_down = np.array([1]) + elif Z == 3: + n_quantum = np.array([1,2]) + l_quantum = np.array([0,0]) + s_quantum_up = np.array([1,1]) + s_quantum_down = np.array([1,0]) + elif Z == 4: + n_quantum = np.array([1,2]) + l_quantum = np.array([0,0]) + s_quantum_up = np.array([1,1]) + s_quantum_down = np.array([1,1]) + elif Z == 5: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,1]) + s_quantum_down = np.array([1,1,0]) + elif Z == 6: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,2]) + s_quantum_down = np.array([1,1,0]) + elif Z == 7: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,3]) + s_quantum_down = np.array([1,1,0]) + elif Z == 8: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,3]) + s_quantum_down = np.array([1,1,1]) + elif Z == 9: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,3]) + s_quantum_down = np.array([1,1,2]) + elif Z == 10: + n_quantum = np.array([1,2,2]) + l_quantum = np.array([0,0,1]) + s_quantum_up = np.array([1,1,3]) + s_quantum_down = np.array([1,1,3]) + elif Z == 11: + n_quantum = np.array([1,2,2,3]) + l_quantum = np.array([0,0,1,0]) + s_quantum_up = np.array([1,1,3,1]) + s_quantum_down = np.array([1,1,3,0]) + elif Z == 12: + n_quantum = np.array([1,2,2,3]) + l_quantum = np.array([0,0,1,0]) + s_quantum_up = np.array([1,1,3,1]) + s_quantum_down = np.array([1,1,3,1]) + elif Z == 13: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,1]) + s_quantum_down = np.array([1,1,3,1,0]) + elif Z == 14: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,2]) + s_quantum_down = np.array([1,1,3,1,0]) + elif Z == 15: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,3]) + s_quantum_down = np.array([1,1,3,1,0]) + elif Z == 16: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,3]) + s_quantum_down = np.array([1,1,3,1,1]) + elif Z == 17: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,3]) + s_quantum_down = np.array([1,1,3,1,2]) + elif Z == 18: + n_quantum = np.array([1,2,2,3,3]) + l_quantum = np.array([0,0,1,0,1]) + s_quantum_up = np.array([1,1,3,1,3]) + s_quantum_down = np.array([1,1,3,1,3]) + elif Z == 19: + n_quantum = np.array([1,2,2,3,3,4]) + l_quantum = np.array([0,0,1,0,1,0]) + s_quantum_up = np.array([1,1,3,1,3,1]) + s_quantum_down = np.array([1,1,3,1,3,0]) + elif Z == 20: + n_quantum = np.array([1,2,2,3,3,4]) + l_quantum = np.array([0,0,1,0,1,0]) + s_quantum_up = np.array([1,1,3,1,3,1]) + s_quantum_down = np.array([1,1,3,1,3,1]) + elif Z == 21: + n_quantum = np.array([1, 2, 2, 3, 3, 3, 4]) + l_quantum = np.array([0, 0, 1, 0, 1, 2, 0]) + s_quantum_up = np.array([1, 1, 3, 1, 3, 1, 1]) + s_quantum_down = np.array([1, 1, 3, 1, 3, 0, 1]) + elif Z == 22: + n_quantum = np.array([1, 2, 2, 3, 3, 3, 4]) + l_quantum = np.array([0, 0, 1, 0, 1, 2, 0]) + s_quantum_up = np.array([1, 1, 3, 1, 3, 2, 1]) + s_quantum_down = np.array([1, 1, 3, 1, 3, 0, 1]) + elif Z == 23: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 0, 1 ]) + elif Z == 24: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 0, 0 ]) + elif Z == 25: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 0, 1 ]) + elif Z == 26: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 1, 1 ]) + elif Z == 27: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 2, 1 ]) + elif Z == 28: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 3, 1 ]) + elif Z == 29: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 0 ]) + elif Z == 30: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1 ]) + elif Z == 31: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 0 ]) + elif Z == 32: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 2 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 0 ]) + elif Z == 33: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 0 ]) + elif Z == 34: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 1 ]) + elif Z == 35: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 2 ]) + elif Z == 36: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3 ]) + elif Z == 37: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0 ]) + elif Z == 38: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 1 ]) + elif Z == 39: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 40: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 2, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 41: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 4, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0, 0 ]) + elif Z == 42: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0, 0 ]) + elif Z == 43: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 44: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 2, 0 ]) + elif Z == 45: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 3, 0 ]) + elif Z == 46: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5 ]) + elif Z == 47: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0 ]) + elif Z == 48: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1 ]) + elif Z == 49: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 0 ]) + elif Z == 50: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 2 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 0 ]) + elif Z == 51: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 0 ]) + elif Z == 52: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 1 ]) + elif Z == 53: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 2 ]) + elif Z == 54: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3 ]) + elif Z == 55: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 0 ]) + elif Z == 56: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 1 ]) + elif Z == 57: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 58: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 1, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 0, 1 ]) + elif Z == 59: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 3, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 1 ]) + elif Z == 60: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 4, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 1 ]) + elif Z == 61: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 1 ]) + elif Z == 62: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 6, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 1 ]) + elif Z == 63: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 1 ]) + elif Z == 64: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 0, 1, 3, 0, 1 ]) + elif Z == 65: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 2, 1, 3, 1 ]) + elif Z == 66: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 3, 1, 3, 1 ]) + elif Z == 67: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 4, 1, 3, 1 ]) + elif Z == 68: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 5, 1, 3, 1 ]) + elif Z == 69: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 6, 1, 3, 1 ]) + elif Z == 70: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1 ]) + elif Z == 71: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 0, 1 ]) + elif Z == 72: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 2, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 0, 1 ]) + elif Z == 73: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 0, 1 ]) + elif Z == 74: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 4, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 0, 1 ]) + elif Z == 75: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 0, 1 ]) + elif Z == 76: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 1, 1 ]) + elif Z == 77: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 2, 1 ]) + elif Z == 78: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 4, 0 ]) + elif Z == 79: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 0 ]) + elif Z == 80: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1 ]) + elif Z == 81: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 0 ]) + elif Z == 82: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 2 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 0 ]) + elif Z == 83: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 0 ]) + elif Z == 84: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 1 ]) + elif Z == 85: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 2 ]) + elif Z == 86: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3 ]) + elif Z == 87: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 0 ]) + elif Z == 88: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 1 ]) + elif Z == 89: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 90: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 2, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 1, 3, 0, 1 ]) + elif Z == 91: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 2, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 0, 1, 3, 0, 1 ]) + elif Z == 92: + n_quantum = np.array([ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7 ]) + l_quantum = np.array([ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 0 ]) + s_quantum_up = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 3, 1, 3, 1, 1 ]) + s_quantum_down = np.array([ 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3, 5, 0, 1, 3, 0, 1 ]) + else: + raise ValueError("ERROR: Z should be between 1 and 92, but got {} instead".format(Z)) + + return n_quantum, l_quantum, s_quantum_up, s_quantum_down + + + +class OccupationInfo: + """ + Occupation information for atomic states. + """ + z_valence : int # Valence charge (for pseudopotential) + z_nuclear : int # True nuclear charge of the atom + all_electron_flag : bool # Whether to use all-electron or pseudopotential + occ_n : np.ndarray # Principal quantum number n for each orbital + occ_l : np.ndarray # Angular momentum quantum number l for each orbital + occ_spin_up : np.ndarray # Spin-up occupation for each orbital + occ_spin_down : np.ndarray # Spin-down occupation for each orbital + occ_spin_up_plus_spin_down : np.ndarray # Total occupation (spin-up + spin-down) + + + def __init__(self, + z_nuclear : int, # True nuclear charge (atomic number) + z_valence : int, # Valence charge (for pseudopotential Coulomb tail) + all_electron_flag : bool, # Whether to use all-electron or pseudopotential + ): + """ + Initialize occupation information. + + Parameters + ---------- + z_nuclear : int + True nuclear charge of the atom (atomic number) + z_valence : int + Valence charge for pseudopotential calculations + all_electron_flag : bool + True for all-electron, False for pseudopotential + """ + assert isinstance(z_nuclear, int), "z_nuclear must be an integer" + assert isinstance(z_valence, int), "z_valence must be an integer" + assert isinstance(all_electron_flag, bool), "all_electron_flag must be a boolean" + assert 0 < z_nuclear <= 92, "z_nuclear must be between 1 and 92" + + self.z_nuclear = z_nuclear + self.z_valence = z_valence + self.all_electron_flag = all_electron_flag + + n_quantum, l_quantum, s_quantum_up, s_quantum_down = Occ_states(z_nuclear) + + if all_electron_flag: + self.occ_n = n_quantum + self.occ_l = l_quantum + self.occ_spin_up = s_quantum_up + self.occ_spin_down = s_quantum_down + else: + # For pseudopotential: only valence electrons + n_core_electrons = z_nuclear - z_valence + orbital_occupation_numbers = s_quantum_up + s_quantum_down + cumulative_occupation = np.cumsum(orbital_occupation_numbers) + valence_orbitals_indices = np.where(cumulative_occupation > n_core_electrons)[0] + self.occ_n = n_quantum[valence_orbitals_indices] + self.occ_l = l_quantum[valence_orbitals_indices] + self.occ_spin_up = s_quantum_up[valence_orbitals_indices] + self.occ_spin_down = s_quantum_down[valence_orbitals_indices] + + self.occ_spin_up_plus_spin_down = self.occ_spin_up + self.occ_spin_down + + @property + def occupations(self) -> np.ndarray: + """ + Total occupation numbers (spin-up + spin-down) for each orbital. + Alias for occ_spin_up_plus_spin_down for cleaner API. + """ + return self.occ_spin_up_plus_spin_down + + @property + def l_values(self) -> np.ndarray: + """ + Angular momentum quantum numbers for each orbital. + Alias for occ_l for cleaner API. + """ + return self.occ_l + + @property + def n_values(self) -> np.ndarray: + """ + Principal quantum numbers for each orbital. + Alias for occ_n for cleaner API. + """ + return self.occ_n + + @property + def unique_l_values(self) -> np.ndarray: + """Get unique angular momentum quantum numbers present in occupied states.""" + return np.unique(self.occ_l) + + + @property + def n_states(self) -> int: + """Get total number of occupied states.""" + return len(self.occ_n) + + + def n_states_for_l(self, l: int) -> int: + """ + Get number of occupied states for a given angular momentum quantum number. + + Parameters + ---------- + l : int + Angular momentum quantum number + + Returns + ------- + n_states : int + Number of states with this l value + """ + return np.sum(self.occ_l == l) + + + + + + def print_info(self): + print("=" * 60) + print("\t\t OCCUPATION INFORMATION") + print("=" * 60) + print(f"\t z_valence (valence charge) : {self.z_valence}") + print(f"\t z_nuclear (nuclear charge) : {self.z_nuclear}") + print(f"\t all_electron_flag : {self.all_electron_flag}") + print(f"\t occ_n : {self.occ_n}") + print(f"\t occ_l : {self.occ_l}") + print(f"\t occ_spin_up : {self.occ_spin_up}") + print(f"\t occ_spin_down : {self.occ_spin_down}") + print(f"\t occ_spin_up_plus_spin_down : {self.occ_spin_up_plus_spin_down}") + print() + + + +if __name__ == "__main__": + Zatom = 13 + occupation_info = OccupationInfo(Zatom) \ No newline at end of file diff --git a/utils/atom/utils/periodic.py b/utils/atom/utils/periodic.py new file mode 100644 index 00000000..47f2c153 --- /dev/null +++ b/utils/atom/utils/periodic.py @@ -0,0 +1,195 @@ +def atomic_number_to_name(atomic_number): + if atomic_number == 1: return "H" + elif atomic_number == 2: return "He" + elif atomic_number == 3: return "Li" + elif atomic_number == 4: return "Be" + elif atomic_number == 5: return "B" + elif atomic_number == 6: return "C" + elif atomic_number == 7: return "N" + elif atomic_number == 8: return "O" + elif atomic_number == 9: return "F" + elif atomic_number == 10: return "Ne" + elif atomic_number == 11: return "Na" + elif atomic_number == 12: return "Mg" + elif atomic_number == 13: return "Al" + elif atomic_number == 14: return "Si" + elif atomic_number == 15: return "P" + elif atomic_number == 16: return "S" + elif atomic_number == 17: return "Cl" + elif atomic_number == 18: return "Ar" + elif atomic_number == 19: return "K" + elif atomic_number == 20: return "Ca" + elif atomic_number == 21: return "Sc" + elif atomic_number == 22: return "Ti" + elif atomic_number == 23: return "V" + elif atomic_number == 24: return "Cr" + elif atomic_number == 25: return "Mn" + elif atomic_number == 26: return "Fe" + elif atomic_number == 27: return "Co" + elif atomic_number == 28: return "Ni" + elif atomic_number == 29: return "Cu" + elif atomic_number == 30: return "Zn" + elif atomic_number == 31: return "Ga" + elif atomic_number == 32: return "Ge" + elif atomic_number == 33: return "As" + elif atomic_number == 34: return "Se" + elif atomic_number == 35: return "Br" + elif atomic_number == 36: return "Kr" + elif atomic_number == 37: return "Rb" + elif atomic_number == 38: return "Sr" + elif atomic_number == 39: return "Y" + elif atomic_number == 40: return "Zr" + elif atomic_number == 41: return "Nb" + elif atomic_number == 42: return "Mo" + elif atomic_number == 43: return "Tc" + elif atomic_number == 44: return "Ru" + elif atomic_number == 45: return "Rh" + elif atomic_number == 46: return "Pd" + elif atomic_number == 47: return "Ag" + elif atomic_number == 48: return "Cd" + elif atomic_number == 49: return "In" + elif atomic_number == 50: return "Sn" + elif atomic_number == 51: return "Sb" + elif atomic_number == 52: return "Te" + elif atomic_number == 53: return "I" + elif atomic_number == 54: return "Xe" + elif atomic_number == 55: return "Cs" + elif atomic_number == 56: return "Ba" + elif atomic_number == 57: return "La" + elif atomic_number == 58: return "Ce" + elif atomic_number == 59: return "Pr" + elif atomic_number == 60: return "Nd" + elif atomic_number == 61: return "Pm" + elif atomic_number == 62: return "Sm" + elif atomic_number == 63: return "Eu" + elif atomic_number == 64: return "Gd" + elif atomic_number == 65: return "Tb" + elif atomic_number == 66: return "Dy" + elif atomic_number == 67: return "Ho" + elif atomic_number == 68: return "Er" + elif atomic_number == 69: return "Tm" + elif atomic_number == 70: return "Yb" + elif atomic_number == 71: return "Lu" + elif atomic_number == 72: return "Hf" + elif atomic_number == 73: return "Ta" + elif atomic_number == 74: return "W" + elif atomic_number == 75: return "Re" + elif atomic_number == 76: return "Os" + elif atomic_number == 77: return "Ir" + elif atomic_number == 78: return "Pt" + elif atomic_number == 79: return "Au" + elif atomic_number == 80: return "Hg" + elif atomic_number == 81: return "Tl" + elif atomic_number == 82: return "Pb" + elif atomic_number == 83: return "Bi" + elif atomic_number == 84: return "Po" + elif atomic_number == 85: return "At" + elif atomic_number == 86: return "Rn" + elif atomic_number == 87: return "Fr" + elif atomic_number == 88: return "Ra" + elif atomic_number == 89: return "Ac" + elif atomic_number == 90: return "Th" + elif atomic_number == 91: return "Pa" + elif atomic_number == 92: return "U" + elif atomic_number == 93: return "Np" + else: + raise ValueError(f"Atomic number {atomic_number} is not supported") + + +def name_to_atomic_number(name: str) -> int: + if name == "H": return "01" + elif name == "He": return "02" + elif name == "Li": return "03" + elif name == "Be": return "04" + elif name == "B": return "05" + elif name == "C": return "06" + elif name == "N": return "07" + elif name == "O": return "08" + elif name == "F": return "09" + elif name == "Ne": return "10" + elif name == "Na": return "11" + elif name == "Mg": return "12" + elif name == "Al": return "13" + elif name == "Si": return "14" + elif name == "P": return "15" + elif name == "S": return "16" + elif name == "Cl": return "17" + elif name == "Ar": return "18" + elif name == "K": return "19" + elif name == "Ca": return "20" + elif name == "Sc": return "21" + elif name == "Ti": return "22" + elif name == "V": return "23" + elif name == "Cr": return "24" + elif name == "Mn": return "25" + elif name == "Fe": return "26" + elif name == "Co": return "27" + elif name == "Ni": return "28" + elif name == "Cu": return "29" + elif name == "Zn": return "30" + elif name == "Ga": return "31" + elif name == "Ge": return "32" + elif name == "As": return "33" + elif name == "Se": return "34" + elif name == "Br": return "35" + elif name == "Kr": return "36" + elif name == "Rb": return "37" + elif name == "Sr": return "38" + elif name == "Y": return "39" + elif name == "Zr": return "40" + elif name == "Nb": return "41" + elif name == "Mo": return "42" + elif name == "Tc": return "43" + elif name == "Ru": return "44" + elif name == "Rh": return "45" + elif name == "Pd": return "46" + elif name == "Ag": return "47" + elif name == "Cd": return "48" + elif name == "In": return "49" + elif name == "Sn": return "50" + elif name == "Sb": return "51" + elif name == "Te": return "52" + elif name == "I": return "53" + elif name == "Xe": return "54" + elif name == "Cs": return "55" + elif name == "Ba": return "56" + elif name == "La": return "57" + elif name == "Ce": return "58" + elif name == "Pr": return "59" + elif name == "Nd": return "60" + elif name == "Pm": return "61" + elif name == "Sm": return "62" + elif name == "Eu": return "63" + elif name == "Gd": return "64" + elif name == "Tb": return "65" + elif name == "Dy": return "66" + elif name == "Ho": return "67" + elif name == "Er": return "68" + elif name == "Tm": return "69" + elif name == "Yb": return "70" + elif name == "Lu": return "71" + elif name == "Hf": return "72" + elif name == "Ta": return "73" + elif name == "W": return "74" + elif name == "Re": return "75" + elif name == "Os": return "76" + elif name == "Ir": return "77" + elif name == "Pt": return "78" + elif name == "Au": return "79" + elif name == "Hg": return "80" + elif name == "Tl": return "81" + elif name == "Pb": return "82" + elif name == "Bi": return "83" + elif name == "Po": return "84" + elif name == "At": return "85" + elif name == "Rn": return "86" + elif name == "Fr": return "87" + elif name == "Ra": return "88" + elif name == "Ac": return "89" + elif name == "Th": return "90" + elif name == "Pa": return "91" + elif name == "U": return "92" + elif name == "Np": return "93" + else: + raise ValueError(f"Atomic number {name} is not supported") + diff --git a/utils/atom/xc/__init__.py b/utils/atom/xc/__init__.py new file mode 100644 index 00000000..cf8a66b0 --- /dev/null +++ b/utils/atom/xc/__init__.py @@ -0,0 +1,12 @@ +from .evaluator import XCEvaluator, XCPotentialData, create_xc_evaluator +from .functional_requirements import ( + get_functional_requirements, + register_functional, + list_available_functionals, + get_functionals_by_type, + FunctionalRequirements +) +from .lda import LDA_SVWN, LDA_SPW +from .gga_pbe import GGA_PBE +from .meta_scan import SCAN, rSCAN, r2SCAN +from .hybrid import HartreeFockExchange \ No newline at end of file diff --git a/utils/atom/xc/evaluator.py b/utils/atom/xc/evaluator.py new file mode 100644 index 00000000..bae7574f --- /dev/null +++ b/utils/atom/xc/evaluator.py @@ -0,0 +1,755 @@ +""" +Exchange-Correlation Evaluator Base Class + +This module provides the abstract base class for all XC functional implementations. + +Design Philosophy: +================== +All XC functionals are implemented in TWO stages: + +Stage 1: Generic Form (compute_exchange_generic / compute_correlation_generic) + - Implements the XC functional in its original form + - Usually defined in 3D Cartesian coordinates + - Returns generic potentials and energy densities + +Stage 2: Spherical Transform (transform_to_spherical) + - Transforms generic form to spherical coordinates + - Applies rotational symmetry simplifications + - Handles gradient transformations: ∇ρ in Cartesian → ∂ρ/∂r in spherical + - Returns final spherical potentials ready for radial Schrödinger equation + +This separation ensures: + - Clear distinction between functional definition and coordinate system + - Reusable generic implementations + - Proper handling of spherical symmetry in atomic calculations +""" + +from __future__ import annotations +from typing import Optional, Tuple, Dict, Any +from dataclasses import dataclass, field +from abc import ABC, abstractmethod +import numpy as np + +# Import DensityData from scf module +from ..scf.density import DensityData + + +@dataclass +class XCParameters: + """ + Base class for XC functional parameters. + + This is a simple container for functional parameters. + Each functional should subclass this to define its specific parameters. + + Attributes + ---------- + functional_name : str + Name of the functional (e.g., 'LDA_PZ', 'GGA_PBE', 'SCAN') + + Examples + -------- + >>> # Subclass for specific functional + >>> @dataclass + >>> class LDAParameters(XCParameters): + ... C_x: float = -(3/4) * (3/np.pi)**(1/3) # Slater constant + >>> + >>> params = LDAParameters(functional_name='LDA_PZ') + >>> print(params.C_x) + + Notes + ----- + For JAX compatibility, subclasses can be registered as pytrees. + All numeric fields will be differentiable. + """ + functional_name: str + + def __repr__(self) -> str: + """String representation""" + params_str = ', '.join( + f'{k}={v:.6f}' if isinstance(v, float) else f'{k}={v}' + for k, v in self.__dict__.items() + if k != 'functional_name' + ) + return f"{self.__class__.__name__}({params_str})" + + +@dataclass(frozen=True) +class GenericXCResult: + """ + Container for exchange or correlation results in GENERIC form (Stage 1). + + This contains the raw outputs from the XC functional evaluation before + spherical coordinate transformation. + + Attributes + ---------- + v_generic : np.ndarray + Potential in generic form: ∂ε/∂ρ + e_generic : np.ndarray + Energy density in generic form: ε + de_dsigma : np.ndarray, optional + Derivative ∂ε/∂σ where σ = |∇ρ|² (for GGA and meta-GGA) + de_dtau : np.ndarray, optional + Derivative ∂ε/∂τ (for meta-GGA) + """ + v_generic: np.ndarray # ∂ε/∂ρ + e_generic: np.ndarray # ε + de_dsigma: Optional[np.ndarray] = None # ∂ε/∂σ (GGA, meta-GGA) + de_dtau : Optional[np.ndarray] = None # ∂ε/∂τ (meta-GGA) + + +@dataclass(frozen=True) +class XCPotentialData: + """ + Container for exchange-correlation potentials and energy densities. + + This dataclass is immutable (frozen=True) to prevent accidental modification. + All XC functional evaluations must return this type. + + These are the FINAL potentials in spherical coordinates, ready to be used + in the radial Kohn-Sham equation. + + Attributes + ---------- + v_x : np.ndarray + Exchange potential V_x(r) at quadrature points (spherical form) + v_c : np.ndarray + Correlation potential V_c(r) at quadrature points (spherical form) + e_x : np.ndarray + Exchange energy density ε_x(r) at quadrature points (spherical form) + e_c : np.ndarray + Correlation energy density ε_c(r) at quadrature points (spherical form) + de_x_dtau : np.ndarray, optional + Derivative ∂ε_x/∂τ of exchange energy density w.r.t. kinetic energy density (for meta-GGA) + de_c_dtau : np.ndarray, optional + Derivative ∂ε_c/∂τ of correlation energy density w.r.t. kinetic energy density (for meta-GGA) + + Examples + -------- + >>> pot_data = XCPotentialData( + ... v_x=np.array([...]), + ... v_c=np.array([...]), + ... e_x=np.array([...]), + ... e_c=np.array([...]) + ... ) + >>> v_total = pot_data.v_xc # V_x + V_c + """ + v_x: np.ndarray # Exchange potential (spherical) + v_c: np.ndarray # Correlation potential (spherical) + e_x: np.ndarray # Exchange energy density (spherical) + e_c: np.ndarray # Correlation energy density (spherical) + de_x_dtau: Optional[np.ndarray] = None # ∂ε_x/∂τ (meta-GGA) + de_c_dtau: Optional[np.ndarray] = None # ∂ε_c/∂τ (meta-GGA) + + def __post_init__(self): + """Validate shapes - all arrays must have the same length""" + n_points = self.v_x.shape[0] + assert self.v_c.shape[0] == n_points, "v_c shape mismatch" + assert self.e_x.shape[0] == n_points, "e_x shape mismatch" + assert self.e_c.shape[0] == n_points, "e_c shape mismatch" + if self.de_x_dtau is not None: + assert self.de_x_dtau.shape[0] == n_points, "de_x_dtau shape mismatch" + if self.de_c_dtau is not None: + assert self.de_c_dtau.shape[0] == n_points, "de_c_dtau shape mismatch" + + @property + def v_xc(self) -> np.ndarray: + """Total XC potential: V_xc = V_x + V_c""" + return self.v_x + self.v_c + + @property + def e_xc(self) -> np.ndarray: + """Total XC energy density: ε_xc = ε_x + ε_c""" + return self.e_x + self.e_c + + @property + def de_xc_dtau(self) -> np.ndarray: + """Total XC energy density derivative ∂ε_xc/∂τ""" + if self.de_x_dtau is None or self.de_c_dtau is None: + assert (self.de_x_dtau is None and self.de_c_dtau is None), \ + "de_x_dtau and de_c_dtau must both be None or both be not None" + return None + return self.de_x_dtau + self.de_c_dtau + + +class XCEvaluator(ABC): + """ + Abstract base class for exchange-correlation functional evaluators. + + All XC functionals must inherit from this class and implement: + + Required Abstract Methods: + ------------------------- + 1. compute_exchange_generic(rho, grad_rho, tau, ...) → (v_x_generic, e_x_generic) + - Implements exchange in its original/generic form + - Static method: pure function, no side effects + + 2. compute_correlation_generic(rho, grad_rho, tau, ...) → (v_c_generic, e_c_generic) + - Implements correlation in its original/generic form + - Static method: pure function, no side effects + + Provided Methods: + ---------------- + - compute_xc(density_data, derivative_matrix) → PotentialData + Orchestrates the two-stage calculation: + Stage 1: compute generic form + Stage 2: transform to spherical coordinates + + - transform_to_spherical(...) → transformed potentials + Default implementation for spherical coordinate transformation + Can be overridden for functionals with special requirements + + Design Philosophy: + ----------------- + Stage 1 (Generic): Functional definition (universal) + Input: ρ, ∇ρ, τ in generic form + Output: V_x, V_c, ε_x, ε_c in generic form + + Stage 2 (Spherical): Coordinate transformation (atom-specific) + Input: Generic potentials + derivative matrix + Output: Spherical potentials for radial equation + Transformation: ∇ρ(x,y,z) → ∂ρ/∂r (radial derivative) + + Examples + -------- + >>> # Define parameter class for your functional + >>> @dataclass + >>> class MyLDAParameters(XCParameters): + ... C_x: float = -(3/4) * (3/np.pi)**(1/3) # Slater constant + >>> + >>> class MyLDA(XCEvaluator): + ... def _default_params(self): + ... return MyLDAParameters(functional_name='MyLDA') + ... + ... def compute_exchange_generic(self, density_data): + ... rho = density_data.rho + ... C_x = self.params.C_x # Direct access + ... + ... # LDA exchange + ... e_x = C_x * rho**(4/3) + ... v_x = (4/3) * C_x * rho**(1/3) + ... + ... return GenericXCResult( + ... v_generic=v_x, + ... e_generic=e_x, + ... de_dsigma=None, + ... de_dtau=None + ... ) + ... + ... def compute_correlation_generic(self, density_data): + ... # Similar structure + ... pass + >>> + >>> # GGA example + >>> @dataclass + >>> class MyGGAParameters(XCParameters): + ... mu: float = 0.2195 + ... kappa: float = 0.804 + >>> + >>> class MyGGA(XCEvaluator): + ... def _default_params(self): + ... return MyGGAParameters(functional_name='MyGGA') + ... + ... def compute_exchange_generic(self, density_data): + ... rho = density_data.rho + ... grad_rho = density_data.grad_rho + ... mu = self.params.mu # Direct access + ... + ... # GGA exchange + ... e_x = ... + ... v_x = ... + ... de_x_dsigma = ... + ... + ... return GenericXCResult( + ... v_generic=v_x, + ... e_generic=e_x, + ... de_dsigma=de_x_dsigma, + ... de_dtau=None + ... ) + """ + + def __init__( + self, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None, + params: Optional[XCParameters] = None + ): + """ + Initialize XC evaluator. + + Parameters + ---------- + derivative_matrix : np.ndarray, optional + Finite element derivative matrix for gradient transformations. + Required for GGA and meta-GGA functionals. + Shape: (n_elements, n_quad_per_element, n_quad_per_element) + r_quad : np.ndarray, optional + Radial quadrature nodes (coordinates). + Required for spherical coordinate transformations in GGA and meta-GGA. + Shape: (n_quad_points,) + params : XCParameters, optional + Functional parameters (for delta learning). + If None, uses default parameters. + """ + self.derivative_matrix = derivative_matrix + self.r_quad = r_quad + self.params = params if params is not None else self._default_params() + + def _default_params(self) -> XCParameters: + """ + Return default parameters for this functional. + + Subclasses should override this to provide functional-specific parameters. + + Returns + ------- + params : XCParameters (or subclass) + Default parameters for this functional + + Examples + -------- + >>> def _default_params(self): + ... return LDAParameters(functional_name='LDA_PZ', C_x=-0.738559) + """ + return XCParameters(functional_name=self.__class__.__name__) + + + @abstractmethod + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute exchange in GENERIC form (Stage 1). + + This method implements the XC functional in its original/published form, + typically in 3D Cartesian coordinates or coordinate-independent form. + + Parameters + ---------- + density_data : DensityData + Container with: + - rho: electron density ρ(r) + - grad_rho: density gradient magnitude |∇ρ| (for GGA and meta-GGA) + - tau: kinetic energy density τ (for meta-GGA) + + Returns + ------- + result : GenericXCResult + Container with: + - v_generic: ∂εₓ/∂ρ (exchange potential in generic form) + - e_generic: εₓ (exchange energy density) + - de_dsigma: ∂εₓ/∂σ (for GGA, meta-GGA), where σ = |∇ρ|² + - de_dtau: ∂εₓ/∂τ (for meta-GGA) + + Notes + ----- + For LDA: only v_generic and e_generic are needed + For GGA: v_generic, e_generic, and de_dsigma are needed + For meta-GGA: all four components are needed + + The derivatives de_dsigma and de_dtau are essential for computing + the correct potential in spherical coordinates: + V = ∂ε/∂ρ - (2/r²)·d/dr[r²·∂ε/∂σ·dρ/dr] - ∇·(∂ε/∂τ·∇τ) + + Examples + -------- + >>> density_data = DensityData(rho=rho, grad_rho=grad_rho) + >>> result = evaluator.compute_exchange_generic(density_data) + >>> v_x = result.v_generic + """ + pass + + + @abstractmethod + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute correlation in GENERIC form (Stage 1). + + This method implements the XC functional in its original/published form, + typically in 3D Cartesian coordinates or coordinate-independent form. + + Parameters + ---------- + density_data : DensityData + Container with: + - rho: electron density ρ(r) + - grad_rho: density gradient magnitude |∇ρ| (for GGA and meta-GGA) + - tau: kinetic energy density τ (for meta-GGA) + + Returns + ------- + result : GenericXCResult + Container with: + - v_generic: ∂εc/∂ρ (correlation potential in generic form) + - e_generic: εc (correlation energy density) + - de_dsigma: ∂εc/∂σ (for GGA, meta-GGA), where σ = |∇ρ|² + - de_dtau: ∂εc/∂τ (for meta-GGA) + + Notes + ----- + For LDA: only v_generic and e_generic are needed + For GGA: v_generic, e_generic, and de_dsigma are needed + For meta-GGA: all four components are needed + + The derivatives de_dsigma and de_dtau are essential for computing + the correct potential in spherical coordinates: + V = ∂ε/∂ρ - (2/r²)·d/dr[r²·∂ε/∂σ·dρ/dr] - ∇·(∂ε/∂τ·∇τ) + + Examples + -------- + >>> density_data = DensityData(rho=rho, grad_rho=grad_rho) + >>> result = evaluator.compute_correlation_generic(density_data) + >>> v_c = result.v_generic + """ + pass + + + @staticmethod + def _transform_potential_to_spherical( + v_generic : np.ndarray, + de_dsigma : Optional[np.ndarray], + density_data : DensityData, + derivative_matrix : Optional[np.ndarray], + r_quad : Optional[np.ndarray] + ) -> np.ndarray: + """ + Transform a SINGLE XC potential (exchange or correlation) to spherical form. + + This is a static utility method that transforms one potential component at a time. + It ensures that v_x and v_c are processed using the SAME transformation logic. + + IMPORTANT: Only the potential V needs transformation, NOT the energy density ε. + Energy density ε is a scalar field and is invariant under coordinate transformations. + + For spherically symmetric atomic systems, the potential transformation is: + + LDA: + V = V1 = ∂ε/∂ρ (no transformation needed) + + GGA: + V = V1 - D@(V2·dρ/dr) - 2·V2·(dρ/dr)/r + where V1 = ∂ε/∂ρ, V2 = ∂ε/∂σ + + meta-GGA: + V = V1 - D@(V2·dρ/dr) - 2·V2·(dρ/dr)/r + (terms involving ∂ε/∂τ) + + Parameters + ---------- + v_generic : np.ndarray + Generic potential V1 = ∂ε/∂ρ (coordinate-independent part) + de_dsigma : np.ndarray, optional + Derivative V2 = ∂ε/∂σ where σ = |∇ρ|² (None for LDA) + density_data : DensityData + Density information (must contain grad_rho for GGA/meta-GGA) + derivative_matrix : np.ndarray, optional + FEM derivative matrix (required for GGA and meta-GGA) + r_quad : np.ndarray, optional + Radial quadrature nodes (required for spherical transformation) + + Returns + ------- + v_spherical : np.ndarray + Potential in spherical coordinates, ready for radial Kohn-Sham equation + + Notes + ----- + Reference implementation: + V = V1 - D@(V2·grad_rho) - 2·V2·grad_rho/r + + This base class method handles LDA, GGA, and meta-GGA automatically + by checking if de_dsigma is provided. + """ + # LDA case: no gradient correction + if de_dsigma is None: + return v_generic + + # GGA/meta-GGA case: add gradient correction + # V = V1 - D@(V2·dρ/dr) - 2·V2·(dρ/dr)/r + grad_rho = density_data.grad_rho + + if grad_rho is None: + raise ValueError("grad_rho required for GGA/meta-GGA transformation") + if r_quad is None: + raise ValueError("r_quad required for spherical transformation") + if derivative_matrix is None: + raise ValueError("derivative_matrix required for GGA/meta-GGA transformation") + + # Get problem dimensions + n_elem = derivative_matrix.shape[0] # number of elements + n_quad = derivative_matrix.shape[1] # quadrature points per element + + # Compute f = V2 · dρ/dr + f = de_dsigma * grad_rho + + # Apply derivative operator: D @ f + f_reshaped = f.reshape(n_elem, n_quad, 1) + df_dr = np.matmul(derivative_matrix, f_reshaped).reshape(-1) + + # Final potential in spherical coordinates + v_spherical = v_generic - (df_dr + 2.0 * f / r_quad) + + return v_spherical + + + def transform_to_spherical( + self, + xc_result: GenericXCResult, + density_data: DensityData + ) -> np.ndarray: + """ + Transform a generic XC potential to spherical coordinates (Stage 2). + + This is a convenience wrapper that calls _transform_potential_to_spherical. + Subclasses typically override _transform_potential_to_spherical instead. + + NOTE: Only the potential V is transformed. The energy density ε is a scalar + and remains unchanged (it's coordinate-independent). + + Parameters + ---------- + xc_result : GenericXCResult + Generic XC calculation result (contains v, e, and derivatives) + density_data : DensityData + Density information (needed for gradient transformations) + + Returns + ------- + v_spherical : np.ndarray + Potential in spherical coordinates, ready for radial Kohn-Sham equation + """ + return self._transform_potential_to_spherical( + v_generic = xc_result.v_generic, + de_dsigma = xc_result.de_dsigma, + density_data = density_data, + derivative_matrix = self.derivative_matrix, + r_quad = self.r_quad + ) + + + def compute_xc(self, density_data: DensityData) -> XCPotentialData: + """ + Compute exchange-correlation potentials and energy densities (TWO STAGES). + + This is the main interface that orchestrates the two-stage calculation: + + Stage 1: Generic Form + --------------------- + Call compute_exchange_generic() and compute_correlation_generic() + to get potentials in their original functional form, along with + necessary derivatives (∂ε/∂σ, ∂ε/∂τ) for GGA and meta-GGA. + + Stage 2: Spherical Transform (Potentials ONLY) + ---------------------------------------------- + Call transform_to_spherical() separately for exchange and correlation + to convert generic potentials to spherical coordinates suitable for + radial atomic calculations. v_x and v_c use the SAME transformation logic. + + IMPORTANT: Only potentials V are transformed. Energy densities ε are scalars + and remain unchanged (coordinate-independent). + + Parameters + ---------- + density_data : DensityData + Container with electron density ρ(r) and optionally: + - grad_rho: |∇ρ(r)| for GGA functionals + - tau: kinetic energy density for meta-GGA functionals + + Returns + ------- + potential_data : XCPotentialData + Container with: + - V_x, V_c: potentials in SPHERICAL coordinates + - ε_x, ε_c: energy densities (coordinate-independent scalars) + This is an immutable (frozen) dataclass + + Raises + ------ + ValueError + If required density quantities are missing + (e.g., GGA needs grad_rho but it's None) + + Examples + -------- + >>> density_data = DensityData(rho=rho, grad_rho=grad_rho) + >>> evaluator = GGA_PBE(derivative_matrix=D) + >>> pot_data = evaluator.compute_xc(density_data) + >>> v_xc_spherical = pot_data.v_xc # Ready for radial equation + """ + # ===== Stage 1: Compute generic form ===== + # Returns GenericXCResult with v, e, and derivatives (de_dsigma, de_dtau) + x_result = self.compute_exchange_generic(density_data) + c_result = self.compute_correlation_generic(density_data) + + + # ===== Stage 2: Transform potentials to spherical ===== + # Process exchange and correlation separately using the SAME transformation + # Energy densities are scalars and don't need transformation + v_x = self.transform_to_spherical(x_result, density_data) + v_c = self.transform_to_spherical(c_result, density_data) + + # Energy densities are coordinate-independent (scalars) + e_x = x_result.e_generic + e_c = c_result.e_generic + + # Derivatives of energy densities + de_x_dtau = x_result.de_dtau + de_c_dtau = c_result.de_dtau + + return XCPotentialData(v_x=v_x, v_c=v_c, e_x=e_x, e_c=e_c, de_x_dtau=de_x_dtau, de_c_dtau=de_c_dtau) + + + def __repr__(self) -> str: + """String representation of the evaluator""" + return f"{self.__class__.__name__}()" + + +def create_xc_evaluator( + functional_name: str, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None + ) -> XCEvaluator: + """ + Factory function to create the appropriate XC evaluator. + + This is a simple factory that maps functional names to their implementations. + + Parameters + ---------- + functional_name : str + Name of the XC functional (e.g., 'LDA_PZ', 'GGA_PBE', 'SCAN') + derivative_matrix : np.ndarray, optional + Finite element derivative matrix for gradient-dependent functionals. + Required for GGA and meta-GGA. + r_quad : np.ndarray, optional + Radial quadrature nodes (coordinates). + Required for spherical coordinate transformations in GGA and meta-GGA. + + Returns + ------- + evaluator : XCEvaluator + Instance of the appropriate XC evaluator subclass + + Raises + ------ + ValueError + If functional_name is not recognized + + Examples + -------- + >>> # LDA: no derivative matrix or r_quad needed + >>> evaluator = create_xc_evaluator('LDA_PZ') + >>> + >>> # GGA: needs derivative matrix and r_quad for transformation + >>> evaluator = create_xc_evaluator('GGA_PBE', derivative_matrix=D, r_quad=r) + >>> + >>> density_data = DensityData(rho=rho, grad_rho=grad_rho) + >>> pot_data = evaluator.compute_xc(density_data) + """ + # Import functional implementations + from .lda import LDA_SVWN, LDA_SPW + from .gga_pbe import GGA_PBE + from .meta_scan import SCAN, rSCAN, r2SCAN + + # Simple mapping: functional name → class + FUNCTIONAL_MAP = { + # LDA functionals + 'LDA_PZ': LDA_SVWN, # Note: LDA_PZ uses VWN correlation in current implementation + 'LDA_PW': LDA_SPW, + + # GGA functionals + 'GGA_PBE': GGA_PBE, + + # meta-GGA functionals + 'SCAN': SCAN, + 'RSCAN': rSCAN, + 'R2SCAN': r2SCAN, + + # hybrid functionals + 'PBE0': GGA_PBE, + # 'HF': HF, + + # TODO: Add OEP and RPA + # 'OEPx': OEPx, + # 'RPA': RPA, + } + + if functional_name not in FUNCTIONAL_MAP: + available = ', '.join(FUNCTIONAL_MAP.keys()) + raise ValueError( + f"Unknown XC functional: '{functional_name}'\n" + f"Available functionals: {available}" + ) + + # Create and return instance with derivative matrix and r_quad + functional_class = FUNCTIONAL_MAP[functional_name] + return functional_class(derivative_matrix=derivative_matrix, r_quad=r_quad) + + +# ============================================================================= +# JAX Compatibility (Optional) +# ============================================================================= +# The dataclasses GenericXCResult and PotentialData are automatically +# compatible with JAX autodiff if registered as pytrees. +# This registration is optional and only activated if JAX is installed. + +try: + import jax + from jax import tree_util + + # Note: XCParameters subclasses can be registered individually + # Each functional can register its specific parameter class as needed + # Example: + # tree_util.register_pytree_node( + # LDAParameters, + # lambda p: ((p.C_x,), {'functional_name': p.functional_name}), + # lambda aux, ch: LDAParameters(functional_name=aux['functional_name'], C_x=ch[0]) + # ) + + # Register GenericXCResult as JAX pytree + def _generic_xc_result_flatten(result): + """Flatten GenericXCResult for JAX transformations""" + children = (result.v_generic, result.e_generic, + result.de_dsigma, result.de_dtau) + aux_data = None + return children, aux_data + + def _generic_xc_result_unflatten(aux_data, children): + """Reconstruct GenericXCResult from flattened form""" + return GenericXCResult(*children) + + tree_util.register_pytree_node( + GenericXCResult, + _generic_xc_result_flatten, + _generic_xc_result_unflatten + ) + + # Register XCPotentialData as JAX pytree + def _xc_potential_data_flatten(potential): + """Flatten XCPotentialData for JAX transformations""" + children = (potential.v_x, potential.v_c, + potential.e_x, potential.e_c) + aux_data = None + return children, aux_data + + def _xc_potential_data_unflatten(aux_data, children): + """Reconstruct XCPotentialData from flattened form""" + return XCPotentialData(*children) + + tree_util.register_pytree_node( + XCPotentialData, + _xc_potential_data_flatten, + _xc_potential_data_unflatten + ) + + # Note: DensityData should also be registered (done in scf/density.py) + + _JAX_AVAILABLE = True + +except ImportError: + # JAX not installed - this is fine, NumPy operations work as usual + _JAX_AVAILABLE = False diff --git a/utils/atom/xc/functional_requirements.py b/utils/atom/xc/functional_requirements.py new file mode 100644 index 00000000..c30aa375 --- /dev/null +++ b/utils/atom/xc/functional_requirements.py @@ -0,0 +1,273 @@ +""" +Functional requirements for XC functionals + +This module defines computational requirements for different XC functionals: +- LDA: only needs density ρ +- GGA: needs density ρ and gradient |∇ρ| +- meta-GGA: needs density ρ, gradient |∇ρ|, and kinetic energy density τ +""" + +from typing import Dict, Literal +from dataclasses import dataclass + + +# Functional type definitions +FunctionalType = Literal['LDA', 'GGA', 'meta-GGA', 'hybrid-GGA', 'hybrid-meta-GGA', 'OEP', 'RPA', 'None'] + + +@dataclass +class FunctionalRequirements: + """ + Computational requirements for an XC functional + + Attributes + ---------- + needs_gradient : bool + Whether the functional requires density gradient |∇ρ| + needs_tau : bool + Whether the functional requires kinetic energy density τ + functional_type : str + Type of functional (LDA, GGA, meta-GGA, etc.) + needs_orbitals : bool + Whether the functional needs explicit orbital information (HF, OEP, RPA) + """ + needs_gradient : bool + needs_tau : bool + functional_type : FunctionalType + needs_orbitals : bool = False + + @property + def is_lda(self) -> bool: + """Check if functional is LDA type""" + return self.functional_type == 'LDA' + + @property + def is_gga(self) -> bool: + """Check if functional is GGA type (including hybrids)""" + return self.functional_type in ['GGA', 'hybrid-GGA'] + + @property + def is_meta_gga(self) -> bool: + """Check if functional is meta-GGA type (including hybrids)""" + return self.functional_type in ['meta-GGA', 'hybrid-meta-GGA'] + + @property + def is_hybrid(self) -> bool: + """Check if functional is a hybrid""" + return 'hybrid' in self.functional_type + + +# Registry of functional requirements +_FUNCTIONAL_REQUIREMENTS: Dict[str, FunctionalRequirements] = { + # LDA functionals + 'LDA_PZ': FunctionalRequirements( + needs_gradient=False, + needs_tau=False, + functional_type='LDA' + ), + 'LDA_PW': FunctionalRequirements( + needs_gradient=False, + needs_tau=False, + functional_type='LDA' + ), + + # GGA functionals + 'GGA_PBE': FunctionalRequirements( + needs_gradient=True, + needs_tau=False, + functional_type='GGA' + ), + + # Hybrid GGA functionals + 'PBE0': FunctionalRequirements( + needs_gradient=True, + needs_tau=False, + functional_type='hybrid-GGA', + needs_orbitals=True # Needs orbitals for exact exchange + ), + 'HF': FunctionalRequirements( + needs_gradient=False, + needs_tau=False, + functional_type='hybrid-GGA', + needs_orbitals=True + ), + + # meta-GGA functionals + 'SCAN': FunctionalRequirements( + needs_gradient=True, + needs_tau=True, + functional_type='meta-GGA' + ), + 'RSCAN': FunctionalRequirements( + needs_gradient=True, + needs_tau=True, + functional_type='meta-GGA' + ), + 'R2SCAN': FunctionalRequirements( + needs_gradient=True, + needs_tau=True, + functional_type='meta-GGA' + ), + + # Optimized Effective Potential + 'OEPx': FunctionalRequirements( + needs_gradient=True, + needs_tau=False, + functional_type='OEP', + needs_orbitals=True + ), + + # Random Phase Approximation + 'RPA': FunctionalRequirements( + needs_gradient=True, + needs_tau=False, + functional_type='RPA', + needs_orbitals=True + ), + + # Pure exact exchange + 'None': FunctionalRequirements( + needs_gradient=False, + needs_tau=False, + functional_type='None' + ), +} + + +def get_functional_requirements(xc_functional: str) -> FunctionalRequirements: + """ + Get computational requirements for a given XC functional + + This function returns what computational quantities are needed + for a specific exchange-correlation functional: + - LDA: only density ρ + - GGA: density ρ + gradient |∇ρ| + - meta-GGA: density ρ + gradient |∇ρ| + kinetic energy density τ + + Parameters + ---------- + xc_functional : str + Name of the XC functional (e.g., 'LDA_PZ', 'GGA_PBE', 'SCAN') + + Returns + ------- + requirements : FunctionalRequirements + Object containing: + - needs_gradient: bool + - needs_tau: bool + - functional_type: str + - needs_orbitals: bool + + Raises + ------ + ValueError + If the functional is not recognized + + Examples + -------- + >>> req = get_functional_requirements('LDA_PZ') + >>> req.needs_gradient + False + >>> req.needs_tau + False + + >>> req = get_functional_requirements('GGA_PBE') + >>> req.needs_gradient + True + >>> req.needs_tau + False + + >>> req = get_functional_requirements('SCAN') + >>> req.needs_gradient + True + >>> req.needs_tau + True + """ + if xc_functional not in _FUNCTIONAL_REQUIREMENTS: + available = ', '.join(_FUNCTIONAL_REQUIREMENTS.keys()) + raise ValueError( + f"Unknown XC functional: '{xc_functional}'\n" + f"Available functionals: {available}" + ) + + return _FUNCTIONAL_REQUIREMENTS[xc_functional] + + +def register_functional( + name: str, + needs_gradient: bool, + needs_tau: bool, + functional_type: FunctionalType, + needs_orbitals: bool = False + ) -> None: + """ + Register a new functional with its requirements + + This allows users to add custom functionals to the registry. + + Parameters + ---------- + name : str + Name of the functional + needs_gradient : bool + Whether gradient is needed + needs_tau : bool + Whether kinetic energy density is needed + functional_type : str + Type of functional + needs_orbitals : bool, optional + Whether orbitals are needed (for hybrid/OEP/RPA) + + Examples + -------- + >>> register_functional( + ... name='MY_CUSTOM_GGA', + ... needs_gradient=True, + ... needs_tau=False, + ... functional_type='GGA' + ... ) + """ + _FUNCTIONAL_REQUIREMENTS[name] = FunctionalRequirements( + needs_gradient=needs_gradient, + needs_tau=needs_tau, + functional_type=functional_type, + needs_orbitals=needs_orbitals + ) + + +def list_available_functionals() -> list[str]: + """ + List all registered functionals + + Returns + ------- + functionals : list[str] + List of functional names + """ + return list(_FUNCTIONAL_REQUIREMENTS.keys()) + + +def get_functionals_by_type(functional_type: FunctionalType) -> list[str]: + """ + Get all functionals of a specific type + + Parameters + ---------- + functional_type : str + Type to filter by ('LDA', 'GGA', 'meta-GGA', etc.) + + Returns + ------- + functionals : list[str] + List of functional names matching the type + """ + return [ + name for name, req in _FUNCTIONAL_REQUIREMENTS.items() + if req.functional_type == functional_type + ] + + + +if __name__ == "__main__": + print(list_available_functionals()) + print(get_functional_requirements('GGA_PBE')) \ No newline at end of file diff --git a/utils/atom/xc/gga_pbe.py b/utils/atom/xc/gga_pbe.py new file mode 100644 index 00000000..2abc4506 --- /dev/null +++ b/utils/atom/xc/gga_pbe.py @@ -0,0 +1,382 @@ +""" +GGA PBE (Generalized Gradient Approximation - Perdew-Burke-Ernzerhof) Functional + +Implements the PBE GGA functional for exchange and correlation. + +Two-Stage Implementation: +========================= +Stage 1 (Generic): PBE functional in its original form + - Uses ρ and σ = |∇ρ|² in generic form + - Returns v_generic (∂ε/∂ρ), e_generic (ε), and de_dsigma (∂ε/∂σ) + +Stage 2 (Spherical): Transform potential to radial atomic form + - Apply gradient correction: V = ∂ε/∂ρ - (2/r²)·d/dr[r²·∂ε/∂σ·dρ/dr] + - Energy density ε remains unchanged (scalar, coordinate-independent) + +Reference: + Perdew, Burke, and Ernzerhof, Phys. Rev. Lett. 77, 3865 (1996) +""" + +from __future__ import annotations +import numpy as np +from typing import Optional +from dataclasses import dataclass + +from .evaluator import XCEvaluator, XCParameters, GenericXCResult, DensityData + + +@dataclass +class PBEParameters(XCParameters): + """ + Parameters for PBE GGA functional. + + All parameters can be optimized using autodiff for delta learning. + + Attributes + ---------- + mu : float + PBE gradient enhancement parameter + Standard: 0.2195149727645171 + kappa : float + PBE parameter κ + Standard: 0.804 + """ + functional_name: str = 'GGA_PBE' # Fixed for this functional + mu: float = 0.2195149727645171 # Default: standard PBE value + kappa: float = 0.804 # Default: standard PBE value + + +class GGA_PBE(XCEvaluator): + """ + GGA-PBE exchange-correlation functional. + + Requires: + - ρ(r): electron density + - |∇ρ(r)|: density gradient magnitude + - derivative_matrix: for spherical coordinate transformation + + Two-stage calculation: + 1. Generic form: PBE formulas with ρ and |∇ρ| + 2. Spherical transform: Convert gradient terms to radial form + + Examples + -------- + >>> from atomic_dft.mesh import MeshBuilder + >>> from atomic_dft.xc import GGA_PBE + >>> + >>> mesh = MeshBuilder(...).build() + >>> D = mesh.derivative_matrix + >>> + >>> evaluator = GGA_PBE(derivative_matrix=D) + >>> density_data = DensityData(rho=rho, grad_rho=grad_rho) + >>> potential_data = evaluator.compute_xc(density_data) + """ + + def __init__( + self, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None, + params: Optional[XCParameters] = None + ): + """ + Initialize GGA-PBE evaluator. + + Parameters + ---------- + derivative_matrix : np.ndarray + FEM derivative matrix for gradient transformations + REQUIRED for GGA functionals + r_quad : np.ndarray, optional + Radial quadrature nodes (coordinates) + Required for spherical coordinate transformations + params : XCParameters, optional + Functional parameters + + Raises + ------ + ValueError + If derivative_matrix is None (required for GGA) + """ + if derivative_matrix is None: + raise ValueError( + "GGA_PBE requires derivative_matrix for gradient transformations" + ) + if r_quad is None: + raise ValueError( + "GGA_PBE requires r_quad for spherical coordinate transformations" + ) + super().__init__(derivative_matrix=derivative_matrix, r_quad=r_quad, params=params) + + def _default_params(self) -> PBEParameters: + """ + Return default PBE parameters. + + Returns + ------- + params : PBEParameters + Standard PBE parameters (Perdew, Burke, Ernzerhof 1996) + """ + return PBEParameters() # All defaults are in the class definition + + + + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute PBE exchange in GENERIC form (Stage 1). + + Implements PBE exchange as published, using ρ and σ = |∇ρ|². + + Parameters + ---------- + density_data : DensityData + Container with rho and grad_rho + + Returns + ------- + result : GenericXCResult + Exchange results with: + - v_generic: ∂εₓ/∂ρ (V_1_X_term in reference) + - e_generic: εₓ (ex in reference) + - de_dsigma: ∂εₓ/∂σ (V_2_X_term/rho in reference) + - de_dtau: None (GGA doesn't use tau) + + Raises + ------ + ValueError + If grad_rho is None (required for GGA) + + Notes + ----- + PBE exchange enhancement factor: + F_x(s) = 1 + κ - κ/(1 + μs²/κ) + where s = |∇ρ|/(2k_F ρ) is the reduced gradient + + The de_dsigma term is essential for the spherical transformation: + V_x^spherical = v_generic - (2/r²)·d/dr[r²·de_dsigma·dρ/dr] + """ + rho = density_data.rho + grad_rho = density_data.grad_rho + + if grad_rho is None: + raise ValueError("GGA_PBE requires grad_rho for exchange calculation") + + # PBE parameters + mu = self.params.mu + kappa = self.params.kappa + + # Constants + threefourth_divpi = 3.0 / 4.0 / np.pi + sixpi2_1_3 = (6.0 * (np.pi**2))**(1.0/3.0) + sixpi2m1_3 = 1.0 / sixpi2_1_3 + mu_divkappa = mu / kappa + + # Spin-unpolarized: rho_up = rho_down = rho/2 + rho_updn = rho / 2.0 + rho_updnm1_3 = rho_updn**(-1.0/3.0) + rhomot = rho_updnm1_3 + + # LDA exchange energy density + ex_lsd = -threefourth_divpi * sixpi2_1_3 * (rhomot * rhomot * rho_updn) + + # Reduced gradient variable + rho_inv = rhomot * rhomot * rhomot + coeffss = (1.0/4.0) * sixpi2m1_3 * sixpi2m1_3 * (rho_inv * rho_inv * rhomot * rhomot) + + # sigma = |∇ρ|² + sigma = grad_rho**2 + # Avoid division by zero + sigma = np.where(sigma < 1e-20, 1e-20, sigma) + + # s² term + ss = (sigma / 4.0) * coeffss + divss = 1.0 / (1.0 + mu_divkappa * ss) + + # Enhancement factor and derivatives + dfxdss = mu * (divss**2) + fx = 1.0 + kappa * (1.0 - divss) + + # Derivatives w.r.t. density and gradient + dssdn = (-8.0/3.0) * (ss * rho_inv) + dfxdn = dfxdss * dssdn + dssdg = 2.0 * coeffss + dfxdg = dfxdss * dssdg + + # Energy density + ex = ex_lsd * fx + + # Potential: ∂(ρ·εx)/∂ρ = εx + ρ·∂εx/∂ρ + v_x_generic = ex_lsd * ((4.0/3.0) * fx + rho_updn * dfxdn) + + # Derivative w.r.t. sigma (needed for spherical transform) + # de_x_dsigma = ∂εx/∂σ = V_2_X_term from reference code + # V_2_X_term = 0.5*ex_lsd*rho_updn*dfxdg + de_x_dsigma = 0.5 * ex_lsd * rho_updn * dfxdg + + return GenericXCResult( + v_generic=v_x_generic, + e_generic=ex, + de_dsigma=de_x_dsigma, + de_dtau=None + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute PBE correlation in GENERIC form (Stage 1). + + Implements PBE correlation as published, using ρ and σ = |∇ρ|². + + Parameters + ---------- + density_data : DensityData + Container with rho and grad_rho + + Returns + ------- + result : GenericXCResult + Correlation results with: + - v_generic: ∂εc/∂ρ (V_1_C_term in reference) + - e_generic: εc (ec in reference) + - de_dsigma: ∂εc/∂σ (V_2_C_term/rho in reference) + - de_dtau: None + + Raises + ------ + ValueError + If grad_rho is None (required for GGA) + + Notes + ----- + PBE correlation is based on the LDA correlation plus gradient corrections. + """ + rho = density_data.rho + grad_rho = density_data.grad_rho + + if grad_rho is None: + raise ValueError("GGA_PBE requires grad_rho for correlation calculation") + + # PBE correlation parameter + beta = 0.066725 + + # Constants + rsfac = 0.6203504908994000 + sq_rsfac = rsfac**(0.5) + sq_rsfac_inverse = 1.0 / sq_rsfac + third = 1.0 / 3.0 + twom1_3 = 2.0**(-1.0/3.0) + + # Perdew-Wang LDA correlation parameters + ec0_aa = 0.031091 + ec0_a1 = 0.21370 + ec0_b1 = 7.5957 + ec0_b2 = 3.5876 + ec0_b3 = 1.6382 + ec0_b4 = 0.49294 + + gamma = (1.0 - np.log(2.0)) / ((np.pi)**2) + gamma_inv = 1.0 / gamma + coeff_tt = 1.0 / ((4.0*4.0/np.pi) * ((3.0*(np.pi)**2)**(third))) + + # Spin-unpolarized: rho_up = rho_down = rho/2 + rho_u_d_1_3 = (rho / 2.0)**(-1.0/3.0) + rho_m_1_3 = twom1_3 * rho_u_d_1_3 + rho_tot_inverse = (rho_m_1_3**3) + rhotmo6 = (rho_m_1_3)**(0.5) + rhoto6 = rho * (rho_m_1_3**2) * rhotmo6 + + # Seitz radius rs + rs = rsfac * rho_m_1_3 + sqr_rs = sq_rsfac * rhotmo6 + rsm1_2 = sq_rsfac_inverse * rhoto6 + + # LDA correlation (Perdew-Wang parametrization) + ec0_q0 = -2.0 * ec0_aa * (1.0 + ec0_a1 * rs) + ec0_q1 = 2.0 * ec0_aa * (ec0_b1 * sqr_rs + ec0_b2 * rs + + ec0_b3 * rs * sqr_rs + ec0_b4 * rs * rs) + ec0_q1p = ec0_aa * (ec0_b1 * rsm1_2 + 2.0 * ec0_b2 + + 3.0 * ec0_b3 * sqr_rs + 4.0 * ec0_b4 * rs) + ec0_den = 1.0 / (ec0_q1 * ec0_q1 + ec0_q1) + + # Compute logarithm carefully to avoid numerical issues + ec0_log = np.zeros(len(rho)) + f1 = 1.0 / ec0_q1 + y1 = np.argwhere(f1 < 1)[:, 0] + f1_less_than_1 = f1[y1] + y2 = np.argwhere(f1 >= 1)[:, 0] + f1_greater_than_1 = f1[y2] + ec0_log[y1] = np.log1p(f1_less_than_1) + ec0_log[y2] = np.log(1 + f1_greater_than_1) + # Avoid exact zeros + ec0_log = np.where(ec0_log == 0, 1e-15, ec0_log) + + # LDA correlation energy density and potential + ecrs0 = ec0_q0 * ec0_log + ec = ecrs0 + decrs0_drs = -2.0 * ec0_aa * ec0_a1 * ec0_log - ec0_q0 * ec0_q1p * ec0_den + v_c_lda = ecrs0 - (rs / 3.0) * decrs0_drs + + # PBE gradient correction + bb = ecrs0 * gamma_inv + exp_pbe = np.exp(-bb) + dbb_drs = decrs0_drs * gamma_inv + cc = 1.0 / (exp_pbe - 1.0) + dcc_dbb = cc * cc * exp_pbe + dcc_drs = dcc_dbb * dbb_drs + coeff_aa = beta * gamma_inv + aa = coeff_aa * cc + daa_drs = coeff_aa * dcc_drs + + # Gradient term t + dtt_dg = 2.0 * (rho_tot_inverse * rho_tot_inverse) * rho_m_1_3 * coeff_tt + sigma = grad_rho**2 + tt = 0.5 * sigma * dtt_dg + + # A(rs, t) and derivatives + xx = aa * tt + dxx_drs = daa_drs * tt + dxx_dtt = aa + + # Padé approximant + pade_den = 1.0 / (1.0 + xx * (1.0 + xx)) + pade = (1.0 + xx) * pade_den + dpade_dxx = -xx * (2.0 + xx) * (pade_den**2) + dpade_drs = dpade_dxx * dxx_drs + dpade_dtt = dpade_dxx * dxx_dtt + + # H(rs, t) + qq = tt * pade + dqq_drs = tt * dpade_drs + dqq_dtt = pade + tt * dpade_dtt + + # Gradient correction to correlation energy + arg_rr = 1.0 + beta * gamma_inv * qq + div_rr = 1.0 / arg_rr + rr = gamma * np.log(arg_rr) + drr_dqq = beta * div_rr + drr_drs = drr_dqq * dqq_drs + drr_dtt = drr_dqq * dqq_dtt + + # Full correlation potential and energy + drohh_drho = rr - third * rs * drr_drs - (7.0/3.0) * tt * drr_dtt + ec = ec + rr + v_c_generic = v_c_lda + drohh_drho + + # Derivative w.r.t. sigma (needed for spherical transform) + # de_c_dsigma = ∂εc/∂σ = V_2_C_term from reference code + # V_2_C_term = rho * dtt_dg * drr_dtt + de_c_dsigma = rho * dtt_dg * drr_dtt + + return GenericXCResult( + v_generic=v_c_generic, + e_generic=ec, + de_dsigma=de_c_dsigma, + de_dtau=None + ) + diff --git a/utils/atom/xc/hybrid.py b/utils/atom/xc/hybrid.py new file mode 100644 index 00000000..ea655158 --- /dev/null +++ b/utils/atom/xc/hybrid.py @@ -0,0 +1,310 @@ +""" +Hartree-Fock Exchange Calculation + +Implements exact (Hartree-Fock) exchange for hybrid functionals. +This is used for orbital-dependent functionals like PBE0, B3LYP, etc. + +Reference implementation: datagen/tools/HF_EX.py +""" + +from __future__ import annotations +import numpy as np +from typing import Dict, Optional, Tuple, TYPE_CHECKING + +if TYPE_CHECKING: + from ..utils.occupation_states import OccupationInfo + from ..mesh.operators import RadialOperatorsBuilder + +# Error messages +L_VALUES_MUST_BE_INTEGERS_ERROR = \ + "parameter l_values in class OccupationInfo must be integers, get type {} instead" + +ORBITALS_MUST_BE_A_NUMPY_ARRAY_ERROR = \ + "parameter orbitals must be a numpy array, get type {} instead" +ORBITALS_MUST_BE_A_2D_NUMPY_ARRAY_ERROR = \ + "parameter orbitals must be a 2D numpy array, get dimension {} instead" +ORBITALS_MUST_HAVE_N_GRID_ROWS_ERROR = \ + "parameter orbitals must have n_grid rows, get {} instead" +ORBITALS_MUST_HAVE_N_ORBITALS_COLUMNS_ERROR = \ + "parameter orbitals must have n_orbitals columns, get {} instead" + + + +def factorial(n: int) -> int: + """ + Compute factorial n! = n * (n-1) * ... * 2 * 1 + + For n = 0, returns 1. + + Uses lookup table for common values to avoid repeated computation. + """ + assert n >= 0 and isinstance(n, int) + + if n == 0: return 1 + elif n == 1: return 1 + elif n == 2: return 2 + elif n == 3: return 6 + elif n == 4: return 24 + elif n == 5: return 120 + elif n == 6: return 720 + elif n == 7: return 5040 + elif n == 8: return 40320 + else: + # Use iterative approach to avoid recursion depth issues + result = 40320 + for i in range(9, n + 1): + result *= i + return result + + +def _wigner_3j_000(l1: int, l2: int, L: int) -> float: + """ + Wigner 3j symbol (l1 l2 L; 0 0 0) with built-in selection rules. + """ + J = l1 + l2 + L + # parity: l1 + l2 + L must be even + if (J & 1) == 1: + return 0.0 + # triangle inequalities + if l1 < abs(l2 - L) or l1 > l2 + L: + return 0.0 + if l2 < abs(l1 - L) or l2 > l1 + L: + return 0.0 + if L < abs(l1 - l2) or L > l1 + l2: + return 0.0 + + g = J // 2 + W = (-1)**g + W *= np.sqrt( + factorial(J - 2*l1) * factorial(J - 2*l2) * factorial(J - 2*L) + / factorial(J + 1) + ) + W *= factorial(g) / (factorial(g - l1) * factorial(g - l2) * factorial(g - L)) + return float(W) + + +def _radial_kernel(l: int, r_nodes: np.ndarray, r_weights: np.ndarray) -> np.ndarray: + """ + Compute kernel K^(l) with entries: + K_ij^(l) = [ r_<^l / r_>^(l+1) ] * (w_i w_j) / (2l + 1), + where r_< = min(r_i, r_j), r_> = max(r_i, r_j). + + This term represents the radial part of the spherical harmonic expansion of the Coulomb interaction. + """ + r_min = np.minimum(r_nodes, r_nodes.reshape(-1, 1)) + r_max = np.maximum(r_nodes, r_nodes.reshape(-1, 1)) + + return ((r_min / r_max)**l / r_max) * (r_weights * r_weights.reshape(-1, 1)) / (2*l + 1) + + +class HartreeFockExchange: + """ + Hartree-Fock Exchange Calculator + + Computes exact (Hartree-Fock) exchange for hybrid functionals. + This is used for orbital-dependent functionals like PBE0, B3LYP, etc. + """ + + def __init__( + self, + ops_builder : 'RadialOperatorsBuilder', + occupation_info: 'OccupationInfo' + ): + """ + Initialize HF exchange calculator. + + Parameters + ---------- + ops_builder + RadialOperatorsBuilder instance containing quadrature data + occupation_info : OccupationInfo + Occupation information containing l_values and occupations + """ + self.ops_builder = ops_builder + self.occupation_info = occupation_info + + # Extract quadrature data from ops_builder + self.quadrature_nodes = ops_builder.quadrature_nodes + self.quadrature_weights = ops_builder.quadrature_weights + self.n_grid = len(self.quadrature_nodes) + + # Extract occupation data + self.l_values = occupation_info.l_values + self.occupations = occupation_info.occupations + self.n_orbitals = len(self.l_values) + + assert self.l_values.dtype == int, \ + L_VALUES_MUST_BE_INTEGERS_ERROR.format(self.l_values.dtype) + + + + def _compute_exchange_matrix( + self, + l_value : int, + orbitals : np.ndarray) -> np.ndarray: + + # interpolation_matrix: (n_quad, n_physical) + interpolation_matrix = self.ops_builder.global_interpolation_matrix + + # Determine l's range + l_min = np.min(np.abs(l_value - self.l_values)) + l_max = np.max(l_value + self.l_values) + l_coupling = np.arange(int(l_min), int(l_max) + 1) + + # Compute exchange matrix on physical grid + n_physical = interpolation_matrix.shape[1] # (n_quad, n_physical) + H_hf_exchange_matrix = np.zeros((n_physical, n_physical), dtype=float) + + + for l_prime in l_coupling: + # Angular part: compute vectorized alpha without in-place modification + w3j_values = np.array([ + _wigner_3j_000(int(l_value), int(lj), int(l_prime)) for lj in self.l_values + ], dtype=float) + + # Radial part: compute the radial coupling kernel K^(L) + radial_kernel = _radial_kernel( + int(l_prime), self.quadrature_nodes, self.quadrature_weights + ) + + # Compute exchange matrix contribution + H_hf_exchange_matrix_l_contribution_at_quadrature_nodes = np.einsum( + 'jn,ln,n->jl', + orbitals, # (n_grid, n_orbitals) + orbitals, # (n_grid, n_orbitals) + (2 * self.l_values + 1) * (w3j_values ** 2), # (n_orbitals, ) + optimize=True, + ) * radial_kernel + + H_hf_exchange_matrix += (2 * l_prime + 1) * \ + np.einsum( + 'ij,lk,il->jk', + interpolation_matrix, # (n_quad, n_physical) + interpolation_matrix, # (n_quad, n_physical) + H_hf_exchange_matrix_l_contribution_at_quadrature_nodes, # (n_quad, n_quad) + optimize=True, + ) + + # Be careful with the sign change of the exchange matrix here. + return - H_hf_exchange_matrix + + + def compute_exchange_matrices_dict( + self, + orbitals: np.ndarray + ) -> Dict[int, np.ndarray]: + """ + Compute Hartree-Fock exchange matrices for all l channels. + + This method calculates HF exchange matrices for each angular momentum + channel separately and returns them as a dictionary. + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) at quadrature points + Shape: (n_grid, n_orbitals) + + Returns + ------- + Dict[int, np.ndarray] + Dictionary mapping l values to HF exchange matrices + Keys are unique l values from occupation_info + Values are HF exchange matrices of shape (n_physical, n_physical) + """ + # Check Type and shape + assert isinstance(orbitals, np.ndarray), \ + ORBITALS_MUST_BE_A_NUMPY_ARRAY_ERROR.format(type(orbitals)) + assert orbitals.ndim == 2, \ + ORBITALS_MUST_BE_A_2D_NUMPY_ARRAY_ERROR.format(orbitals.ndim) + assert orbitals.shape[0] == self.n_grid, \ + ORBITALS_MUST_HAVE_N_GRID_ROWS_ERROR.format(orbitals.shape[0]) + assert orbitals.shape[1] == self.n_orbitals, \ + ORBITALS_MUST_HAVE_N_ORBITALS_COLUMNS_ERROR.format(orbitals.shape[1]) + + # Compute HF exchange matrices for all l channels + H_hf_exchange_matrices_dict : Dict[int, np.ndarray] = {} + for l_value in self.occupation_info.unique_l_values: + H_hf_exchange_matrix = self._compute_exchange_matrix(l_value, orbitals) + H_hf_exchange_matrices_dict[l_value] = H_hf_exchange_matrix + + return H_hf_exchange_matrices_dict + + + def compute_exchange_energy( + self, + orbitals: np.ndarray + ) -> float: + """ + Compute Hartree-Fock exchange energy. + + This method calculates the total HF exchange energy using the same + logic as the reference implementation but adapted to our data structures. + + Parameters + ---------- + orbitals : np.ndarray + Kohn-Sham orbitals (radial wavefunctions) at quadrature points + Shape: (n_grid, n_orbitals) + + Returns + ------- + float + Total Hartree-Fock exchange energy (scalar) + """ + # Check Type and shape + assert isinstance(orbitals, np.ndarray), \ + ORBITALS_MUST_BE_A_NUMPY_ARRAY_ERROR.format(type(orbitals)) + assert orbitals.ndim == 2, \ + ORBITALS_MUST_BE_A_2D_NUMPY_ARRAY_ERROR.format(orbitals.ndim) + assert orbitals.shape[0] == self.n_grid, \ + ORBITALS_MUST_HAVE_N_GRID_ROWS_ERROR.format(orbitals.shape[0]) + assert orbitals.shape[1] == self.n_orbitals, \ + ORBITALS_MUST_HAVE_N_ORBITALS_COLUMNS_ERROR.format(orbitals.shape[1]) + + # Extract occupation data + l_values = self.l_values # Angular momentum quantum numbers + occupations = self.occupations # Occupation numbers + + # Initialize total exchange energy + E_HF = 0.0 + + # Loop over all possible l values for coupling + max_l = np.max(l_values) + for l_coupling in range(0, 2 * max_l + 1): + + # Create Wigner 3j symbol matrix for this l coupling + wigner_matrix = np.zeros((len(l_values), len(l_values))) + for i1 in range(len(l_values)): + for i2 in range(len(l_values)): + wigner_matrix[i1, i2] = _wigner_3j_000(int(l_values[i1]), int(l_values[i2]), int(l_coupling))**2 + + # Create occupation matrix + occ_matrix = occupations * occupations.reshape(-1, 1) + + # Compute radial kernel for this l coupling + r_kernel = _radial_kernel(l_coupling, self.quadrature_nodes, self.quadrature_weights) + + # Compute exchange energy contribution for this l coupling + # This is the complex einsum from the reference code: + # 'ij,il,ik,jk,jl,kl->' + # where: + # - ij: occupation * wigner matrix + # - il,ik: orbitals (first two indices) + # - jk,jl: orbitals (second two indices) + # - kl: radial kernel + exchange_contribution = -0.25 * (2 * l_coupling + 1) * np.einsum( + 'ij,li,ki,kj,lj,kl->', + occ_matrix * wigner_matrix, + orbitals, # il + orbitals, # ik + orbitals, # jk + orbitals, # jl + r_kernel, # kl + optimize=True + ) + + E_HF += exchange_contribution + + return E_HF + diff --git a/utils/atom/xc/lda.py b/utils/atom/xc/lda.py new file mode 100644 index 00000000..10a21781 --- /dev/null +++ b/utils/atom/xc/lda.py @@ -0,0 +1,383 @@ +""" +LDA (Local Density Approximation) Functionals + +Implements LDA exchange-correlation functionals: +- LDA_PZ: Slater exchange + Perdew-Zunger correlation (uses VWN in current implementation) +- LDA_PW: Slater exchange + Perdew-Wang correlation + +LDA functionals only depend on local density ρ(r), not on gradients or tau. +Therefore, no spherical transformation is needed (already in radial form). +""" + +from __future__ import annotations +import numpy as np +from dataclasses import dataclass +from .evaluator import XCEvaluator, XCParameters, GenericXCResult, DensityData + + +@dataclass +class LDASVWNParameters(XCParameters): + """ + Parameters for LDA_PZ functional (Slater + VWN correlation, matching SPARC's LDA_PZ name). + + All parameters can be optimized using autodiff for delta learning. + + Attributes + ---------- + C_x : float + Exchange multiplier (scales the exchange contribution) + Standard: 1.0 (no scaling) + - C_x = 1.0: standard Slater exchange + - C_x > 1.0: enhanced exchange + - C_x < 1.0: reduced exchange + + # VWN Correlation Parameters (Vosko-Wilk-Nusair 1980) + A : float + VWN parameter A (controls correlation strength) + Standard: 0.0621814 + b : float + VWN parameter b + Standard: 3.72744 + c : float + VWN parameter c + Standard: 12.9352 + y0 : float + VWN parameter y + Standard: -0.10498 + """ + functional_name: str = 'LDA_PZ' # Fixed for this functional (matches SPARC naming) + + # Slater exchange multiplier + C_x: float = 1.0 # Default: 1.0 (standard Slater) + + # VWN correlation (standard values from VWN 1980) + A : float = 0.0621814 + b : float = 3.72744 + c : float = 12.9352 + y0: float = -0.10498 + +@dataclass +class LDASPWParameters(XCParameters): + """ + Parameters for LDA_PW functional (Slater + Perdew-Wang). + + All parameters can be optimized using autodiff for delta learning. + + Attributes + ---------- + C_x : float + Exchange multiplier (scales the exchange contribution) + Standard: 1.0 (no scaling) + + # Perdew-Wang Correlation Parameters (Perdew-Wang 1992) + A : float + PW parameter A + Standard: 0.031091 + alpha1 : float + PW parameter α₁ + Standard: 0.21370 + beta1 : float + PW parameter β₁ + Standard: 7.5957 + beta2 : float + PW parameter β₂ + Standard: 3.5876 + beta3 : float + PW parameter β₃ + Standard: 1.6382 + beta4 : float + PW parameter β₄ + Standard: 0.49294 + """ + functional_name: str = 'LDA_PW' # Fixed for this functional (matches SPARC naming) + + # Slater exchange multiplier + C_x: float = 1.0 # Default: 1.0 (standard Slater) + + # Perdew-Wang correlation parameters (standard values from PW 1992) + A: float = 0.031091 + alpha1: float = 0.21370 + beta1 : float = 7.5957 + beta2 : float = 3.5876 + beta3 : float = 1.6382 + beta4 : float = 0.49294 + + +class LDA_SVWN(XCEvaluator): + """ + LDA with Slater exchange and Vosko-Wilk-Nusair correlation. + + Note: This is mapped to 'LDA_PZ' to match SPARC naming convention, + though SPARC's LDA_PZ uses Perdew-Zunger correlation instead. + + Exchange: Slater (1951) + Correlation: Vosko, Wilk, Nusair (1980) + + Only requires electron density ρ(r). + No gradient transformation needed (LDA is already local). + """ + + def _default_params(self) -> LDASVWNParameters: + """ + Return default LDA-SVWN parameters. + + Returns + ------- + params : LDASVWNParameters + Standard Slater exchange (C_x=1.0) + VWN correlation parameters + """ + return LDASVWNParameters() # All defaults are in the class definition + + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute Slater exchange in generic form. + + For LDA, the generic form IS the spherical form (no gradients involved). + + Parameters + ---------- + density_data : DensityData + Container with electron density ρ(r) + + Returns + ------- + result : GenericXCResult + Exchange results with: + - v_generic: Vₓ(ρ) (exchange potential) + - e_generic: εₓ(ρ) (exchange energy density) + - de_dsigma: None (LDA has no gradient dependence) + - de_dtau: None (LDA has no tau dependence) + + Notes + ----- + Slater exchange (1951): + εₓ(ρ) = C_x * [-3/(4π) * (3π²)^(1/3) * ρ^(1/3)] + Vₓ(ρ) = C_x * [-0.9847450218427 * ρ^(1/3)] + + where C_x is a multiplier (default: 1.0 for standard Slater). + """ + rho = density_data.rho + rho_cbrt = rho**(1/3) # Cube root of density + + # Standard Slater exchange (before multiplier) + e_x_standard = -0.7385587663820224 * rho_cbrt # (3/4) * (3π²)^(1/3) / π + v_x_standard = -0.9847450218426966 * rho_cbrt # (3π²)^(1/3) / π + + # Apply exchange multiplier (for delta learning optimization) + C_x = self.params.C_x + e_x = C_x * e_x_standard + v_x = C_x * v_x_standard + + return GenericXCResult( + v_generic=v_x, + e_generic=e_x, + de_dsigma=None, # LDA: no gradient dependence + de_dtau=None # LDA: no tau dependence + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute VWN (Vosko-Wilk-Nusair) correlation in generic form. + + For LDA, the generic form IS the spherical form (no gradients involved). + + Parameters + ---------- + density_data : DensityData + Container with electron density ρ(r) + + Returns + ------- + result : GenericXCResult + Correlation results with: + - v_generic: Vc(ρ) (correlation potential) + - e_generic: εc(ρ) (correlation energy density) + - de_dsigma: None (LDA has no gradient dependence) + - de_dtau: None (LDA has no tau dependence) + + Notes + ----- + VWN correlation (1980): + A parametrization of the correlation energy for the uniform electron gas. + + Reference: + Vosko, Wilk, Nusair, Can. J. Phys. 58, 1200 (1980) + """ + rho = density_data.rho + rho_cbrt = rho**(1/3) # Cube root of density + + # Get VWN parameters from self.params (can be optimized via autodiff!) + A = self.params.A + b = self.params.b + c = self.params.c + y0 = self.params.y0 + + # Compute rs (Wigner-Seitz radius) and its square root + rs_wigner_seitz = (3 / (4 * np.pi))**(1/3) / rho_cbrt + rs_sqrt = rs_wigner_seitz**(0.5) + + # Auxiliary quantities for VWN parametrization + Q_vwn = (4*c - b**2)**(0.5) + poly_y0 = y0**2 + b*y0 + c # Polynomial at y0 + poly_y = rs_sqrt**2 + b*rs_sqrt + c # Polynomial at y = sqrt(rs) + + # VWN correlation energy density + log_term1 = np.log(rs_sqrt**2 / poly_y) + arctan_term = 2*b/Q_vwn * np.arctan(Q_vwn / (2*rs_sqrt + b)) + log_term2 = np.log((rs_sqrt - y0)**2 / poly_y) + arctan_term2 = 2*(b + 2*y0)/Q_vwn * np.arctan(Q_vwn / (2*rs_sqrt + b)) + + e_c = A/2 * ( + log_term1 + + arctan_term + - b*y0/poly_y0 * (log_term2 + arctan_term2) + ) + + # VWN correlation potential (functional derivative) + potential_correction = A/6 * (c*(rs_sqrt - y0) - b*y0*rs_sqrt) / ((rs_sqrt - y0) * poly_y) + v_c = e_c - potential_correction + + return GenericXCResult( + v_generic=v_c, + e_generic=e_c, + de_dsigma=None, # LDA: no gradient dependence + de_dtau=None # LDA: no tau dependence + ) + + +class LDA_SPW(XCEvaluator): + """ + LDA with Slater exchange and Perdew-Wang correlation. + + Exchange: Slater (1951) + Correlation: Perdew-Wang (1992) + + Only requires electron density ρ(r). + No gradient transformation needed (LDA is already local). + """ + + def _default_params(self) -> LDASPWParameters: + """ + Return default LDA-SPW parameters. + + Returns + ------- + params : LDASPWParameters + Standard Slater exchange (C_x=1.0) + Perdew-Wang correlation parameters + """ + return LDASPWParameters() # All defaults are in the class definition + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute Slater exchange (same as LDA_PZ). + + Parameters + ---------- + density_data : DensityData + Container with electron density + + Returns + ------- + result : GenericXCResult + Exchange results + + Notes + ----- + Uses the same Slater exchange as LDA_PZ. + Only the correlation part differs (Perdew-Wang vs VWN). + """ + rho = density_data.rho + rho_cbrt = rho**(1/3) # Cube root of density + + # Standard Slater exchange (before multiplier) + e_x_standard = -0.7385587663820224 * rho_cbrt # (3/4) * (3π²)^(1/3) / π + v_x_standard = -0.9847450218426966 * rho_cbrt # (3π²)^(1/3) / π + + # Apply exchange multiplier + C_x = self.params.C_x + e_x = C_x * e_x_standard + v_x = C_x * v_x_standard + + return GenericXCResult( + v_generic=v_x, + e_generic=e_x, + de_dsigma=None, + de_dtau=None + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute Perdew-Wang correlation. + + Parameters + ---------- + density_data : DensityData + Container with electron density + + Returns + ------- + result : GenericXCResult + Correlation results + + Notes + ----- + Perdew-Wang 1992 correlation parametrization. + See: Perdew & Wang, Phys. Rev. B 45, 13244 (1992) + """ + rho = density_data.rho + rho_cbrt = rho**(1/3) # Cube root of density + + # Get Perdew-Wang parameters from self.params (can be optimized via autodiff!) + A = self.params.A + alpha1 = self.params.alpha1 + beta1 = self.params.beta1 + beta2 = self.params.beta2 + beta3 = self.params.beta3 + beta4 = self.params.beta4 + + # Compute rs (Wigner-Seitz radius) and its powers + rs_wigner_seitz = ((0.75 / np.pi)**(1/3)) * (1 / rho_cbrt) + rs_sqrt = np.sqrt(rs_wigner_seitz) # rs^(1/2) + rs_inv_sqrt = 1 / rs_sqrt # rs^(-1/2) + rs_3_2 = rs_wigner_seitz * rs_sqrt # rs^(3/2) + rs_squared = rs_wigner_seitz**2 # rs^2 + + # Compute omega function and its rs-derivative (PW parametrization) + omega = 2*A * (beta1*rs_sqrt + beta2*rs_wigner_seitz + beta3*rs_3_2 + beta4*rs_squared) + d_omega_d_rs = A * (beta1*rs_inv_sqrt + 2*beta2 + 3*beta3*rs_sqrt + 4*beta4*rs_wigner_seitz) + + # Logarithmic term + log_term = np.log(1 + 1/omega) + + # PW correlation energy density + prefactor = -2*A * (1 + alpha1*rs_wigner_seitz) + e_c = prefactor * log_term + + # PW correlation potential (functional derivative) + rs_derivative_term = (rs_wigner_seitz/3) * ( + -2*A*alpha1*log_term + - (prefactor*d_omega_d_rs) / (omega + omega**2) + ) + v_c = e_c - rs_derivative_term + + return GenericXCResult( + v_generic=v_c, + e_generic=e_c, + de_dsigma=None, + de_dtau=None + ) \ No newline at end of file diff --git a/utils/atom/xc/meta_scan.py b/utils/atom/xc/meta_scan.py new file mode 100644 index 00000000..2e48542b --- /dev/null +++ b/utils/atom/xc/meta_scan.py @@ -0,0 +1,1111 @@ +""" +Meta-GGA SCAN Family Functionals + +Implements meta-GGA functionals that require: +- ρ(r): electron density +- |∇ρ(r)|: density gradient +- τ(r): kinetic energy density + +Two-Stage Implementation: +========================= +Stage 1 (Generic): SCAN functional in its original form + - Uses ρ, σ = |∇ρ|², and τ in generic form + - Returns v_generic, e_generic, de_dsigma, and de_dtau + +Stage 2 (Spherical): Transform potential to radial atomic form + - Apply gradient correction (like GGA) + - Apply kinetic energy density corrections + - Energy density ε remains unchanged + +Functionals: +- SCAN: Strongly Constrained and Appropriately Normed +- RSCAN: Regularized SCAN (matches SPARC naming) +- R2SCAN: Revised rSCAN (matches SPARC naming) +""" + +from __future__ import annotations +import numpy as np +from typing import Optional, Tuple +from dataclasses import dataclass + +from .evaluator import XCEvaluator, XCParameters, GenericXCResult, DensityData + + +@dataclass +class SCANParameters(XCParameters): + """ + Parameters for SCAN meta-GGA functional. + + SCAN has many internal parameters. Most are fixed by design. + Listed here are the key tunable ones (if needed for delta learning). + + Attributes + ---------- + (Most SCAN parameters are hardcoded in the functional for now) + """ + functional_name: str = 'SCAN' # Fixed for this functional + + +@dataclass +class rSCANParameters(XCParameters): + """ + Parameters for rSCAN meta-GGA functional. + + Regularized SCAN variant with improved numerical behavior. + """ + functional_name: str = 'RSCAN' # Fixed for this functional (matches SPARC naming) + + +@dataclass +class r2SCANParameters(XCParameters): + """ + Parameters for r²SCAN meta-GGA functional. + + Revised regularized SCAN with further improvements. + """ + functional_name: str = 'R2SCAN' # Fixed for this functional (matches SPARC naming) + + + +def _get_rho_tau_and_sigma(density_data: DensityData) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + rho = density_data.rho + grad_rho = density_data.grad_rho + tau = density_data.tau + sigma = grad_rho**2 # σ = |∇ρ|² + + if grad_rho is None or tau is None: + raise ValueError("rSCAN requires grad_rho and tau") + + # Avoid division by zero + rho[rho<1e-15] = 1e-15 + sigma[sigma<1e-15] = 1e-15 + + return rho, tau, sigma + + + + +class SCAN(XCEvaluator): + """ + SCAN meta-GGA functional. + + Requires: + - ρ(r): electron density + - |∇ρ(r)|: density gradient magnitude + - τ(r): kinetic energy density + - derivative_matrix: for spherical coordinate transformation + + Two-stage calculation: + 1. Generic form: SCAN formulas with ρ, |∇ρ|, τ + 2. Spherical transform: Convert to radial form with proper derivatives + + References + ---------- + Sun, Ruzsinszky, Perdew, Phys. Rev. Lett. 115, 036402 (2015) + """ + + def __init__( + self, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None, + params: Optional[XCParameters] = None + ): + """Initialize SCAN evaluator.""" + if derivative_matrix is None: + raise ValueError( + "SCAN requires derivative_matrix for gradient/tau transformations" + ) + super().__init__(derivative_matrix=derivative_matrix, r_quad=r_quad, params=params) + + def _default_params(self) -> SCANParameters: + """Return default SCAN parameters.""" + return SCANParameters() + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute SCAN exchange in GENERIC form (Stage 1). + + Implements SCAN exchange as published, using ρ, σ = |∇ρ|², and τ. + + Parameters + ---------- + rho : np.ndarray + Electron density ρ(r) + grad_rho : np.ndarray + Density gradient magnitude |∇ρ| + tau : np.ndarray + Kinetic energy density τ + + Returns + ------- + result : GenericXCResult + Exchange results with: + - v_generic: ∂εₓ/∂ρ + - e_generic: εₓ + - de_dsigma: ∂εₓ/∂σ + - de_dtau: ∂εₓ/∂τ (meta-GGA specific!) + + Raises + ------ + ValueError + If grad_rho or tau is None + + Notes + ----- + SCAN exchange depends on the iso-orbital indicator α: + α = (τ - τ_W) / τ_unif + where τ_W = |∇ρ|²/(8ρ) is the von Weizsäcker kinetic energy density + """ + + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + + N_q = len(rho) + normDrho = sigma**(0.5) + def compute_basic_variables_metaGGA(rho,normDrho,tau): + s = normDrho/(2*((3*np.pi**2)**(1/3))*rho**(4/3)) + tauw = (normDrho**2)/(8*rho) + tauUnif = 3/10*((3*np.pi**2)**(2/3))*rho**(5/3) + alpha = (tau-tauw)/tauUnif + DsDn = -2*normDrho/(3*((3*np.pi**2)**(1/3))*rho**(7/3)) + DsDDn = 1/(2*((3*np.pi**2)**(1/3))*rho**(4/3)) + DtauwDn = -(normDrho**2)/(8*rho**2) + DtauwDDn = normDrho/(4*rho) + DtauUnifDn = ((3*np.pi**2)**(2/3))/2*rho**(2/3) + DalphaDn = (-DtauwDn*tauUnif - (tau-tauw)*DtauUnifDn)/(tauUnif**2) + DalphaDDn = (-DtauwDDn)/tauUnif + DalphaDtau = 1/tauUnif + return [s,alpha,DsDn,DsDDn,DalphaDn,DalphaDDn,DalphaDtau] + + s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau = compute_basic_variables_metaGGA(rho, normDrho, tau) + + epsixUnif = -3/(4*np.pi)*(3*np.pi**2*rho)**(1/3) + k1 = 0.065 + muak = 10/81 + b2 = (5913/405000)**(1/2) + b1 = 511/13500/(2*b2) + b3 = 0.5 + b4 = muak*muak/k1 -1606/18225 - b1**2 + + x = muak*(s**2)*(1+b4*(s**2)/muak*np.exp(-np.abs(b4)*(s**2)/muak))+(b1*(s**2) + b2*(1-alpha)*np.exp(-b3*(1-alpha)**2))**2 + hx1 = 1+k1 - k1/(1+x/k1) + hx0 = 1.174 + c1x = 0.667 + c2x = 0.8 + dx = 1.24 + alphaG1 = (alpha>1) + alphaE1 = (alpha==1) + alphaL1 = (alpha<1) + + fx= np.zeros((N_q)) + fx[alphaG1] = -dx*np.exp(c2x/(1-alpha[alphaG1])) + fx[alphaE1] = 0 + fx[alphaL1] = np.exp(-c1x*(alpha[alphaL1])/(1-alpha[alphaL1])) + a1 = 4.9479 + gx = 1-np.exp(-a1*(s**(-0.5))) + + Fx = (hx1+fx*(hx0-hx1))*gx + ex = epsixUnif*Fx + + s2 = s*s + term1 = 1+(b4*s2)/muak*np.exp(-np.abs(b4)*s2/muak) + term2 = s2*(b4/muak*np.exp(-np.abs(b4)*s2/muak) + b4*s2/muak*np.exp(-np.abs(b4)*s2/muak)*(-np.abs(b4)/muak)) + term3 = 2*(b1*s2+b2*(1-alpha)*np.exp(-b3*(1-alpha)**2)) + term4 = b2*(-np.exp(-b3*(1-alpha)**2)+(1-alpha)*np.exp(-b3*(1-alpha)**2)*(2*b3*(1-alpha))) + DxDs = 2*s*(muak*(term1+term2)+b1*term3) + DxDalpha = term3*term4 + DxDn = DsDn*DxDs+ DalphaDn*DxDalpha + DxDDn = DsDDn*DxDs + DalphaDDn*DxDalpha + DxDtau = DalphaDtau*DxDalpha + + DgxDn = -np.exp(-a1*s**(-0.5))*(a1/2*s**(-1.5))*DsDn + DgxDDn = -np.exp(-a1*s**(-0.5))*(a1/2*s**(-1.5))*DsDDn + Dhx1Dx = 1/(1+x/k1)**2 + Dhx1Dn = DxDn*Dhx1Dx + Dhx1DDn = DxDDn*Dhx1Dx + Dhx1Dtau = DxDtau*Dhx1Dx + DfxDalpha = np.zeros((N_q)) + DfxDalpha[alphaG1] = -dx*np.exp(c2x/(1-alpha[alphaG1]))*(c2x/(1-alpha[alphaG1])**2) + DfxDalpha[alphaE1] = 0 + DfxDalpha[alphaL1] = np.exp(-c1x*alpha[alphaL1]/(1-alpha[alphaL1]))*(-c1x/(1-alpha[alphaL1])**2) + DfxDn = DfxDalpha*DalphaDn + DfxDDn = DfxDalpha*DalphaDDn + DfxDtau = DfxDalpha*DalphaDtau + + DFxDn = (hx1+fx*(hx0-hx1))*DgxDn + gx*(1-fx)*Dhx1Dn + gx*(hx0-hx1)*DfxDn + DFxDDn = (hx1+fx*(hx0-hx1))*DgxDDn + gx*(1-fx)*Dhx1DDn + gx*(hx0-hx1)*DfxDDn + DFxDtau = gx*(1-fx)*Dhx1Dtau + gx*(hx0-hx1)*DfxDtau + + DepsixUnifDn = -((3*np.pi**2)**(1/3))/(4*np.pi)*(rho**(-2/3)) + v1x = (epsixUnif+rho*DepsixUnifDn)*Fx + rho*epsixUnif*DFxDn + v2x = rho*epsixUnif*DFxDDn/normDrho + v3x = rho*epsixUnif*DFxDtau + + + + return GenericXCResult( + v_generic=v1x, + e_generic=ex, + de_dsigma=v2x, + de_dtau=v3x + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute SCAN correlation in GENERIC form (Stage 1). + + Parameters + ---------- + density_data : DensityData + Container with rho, grad_rho, and tau + + Returns + ------- + result : GenericXCResult + Correlation results with all derivatives + + Raises + ------ + ValueError + If grad_rho or tau is None + """ + + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + N_q = len(rho) + normDrho = sigma**(0.5) + def compute_basic_variables_metaGGA(rho,normDrho,tau): + s = normDrho/(2*((3*np.pi**2)**(1/3))*rho**(4/3)) + tauw = (normDrho**2)/(8*rho) + tauUnif = 3/10*((3*np.pi**2)**(2/3))*rho**(5/3) + alpha = (tau-tauw)/tauUnif + DsDn = -2*normDrho/(3*((3*np.pi**2)**(1/3))*rho**(7/3)) + DsDDn = 1/(2*((3*np.pi**2)**(1/3))*rho**(4/3)) + DtauwDn = -(normDrho**2)/(8*rho**2) + DtauwDDn = normDrho/(4*rho) + DtauUnifDn = ((3*np.pi**2)**(2/3))/2*rho**(2/3) + DalphaDn = (-DtauwDn*tauUnif - (tau-tauw)*DtauUnifDn)/(tauUnif**2) + DalphaDDn = (-DtauwDDn)/tauUnif + DalphaDtau = 1/tauUnif + return [s,alpha,DsDn,DsDDn,DalphaDn,DalphaDDn,DalphaDtau] + + s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau = compute_basic_variables_metaGGA(rho, normDrho, tau) + + zeta = 0 + phi = ((1+zeta)**(2/3)+(1-zeta)**(2/3))/2 + rs = (0.75/(np.pi*rho))**(1/3) + + b1c = 0.0285764 + b2c = 0.0889 + b3c = 0.125541 + ecLDA0 = -b1c/(1+b2c*(rs**(0.5))+b3c*(rs)) + dx = 0.5*((1+zeta)**(4/3)+(1-zeta)**(4/3)) + cx0 = -3/(4*np.pi)*(9*np.pi/4)**(1/3) + Gc = (1-2.3631*(dx-1))*(1-zeta**12) + w0 = np.exp(-ecLDA0/b1c)-1 + betaConst = 0.06672455060314922 + betaRsInf = betaConst*0.1/0.1778 + f0 = -0.9 + xiInf0 = ((3*(np.pi**2)/16)**(2/3))*(betaRsInf*1/(cx0-f0)) + gInf0s = (1+4*xiInf0*s**2)**(-0.25) + H0 = b1c*np.log(1+w0*(1-gInf0s)) + ec0 = (ecLDA0+H0)*Gc + + sqr_rs = rs**(0.5) + rsm1_2 = 1/sqr_rs + beta = betaConst*(1+0.1*rs)/(1+0.1778*rs) + p=1 + AA = 0.0310907 + alpha1 = 0.21370 + beta1 = 7.5957 + beta2 = 3.5876 + beta3 = 1.6382 + beta4 = 0.49294 + + ec0_q0 = -2*AA*(1+alpha1*rs) + ec0_q1 = 2*(AA)*(beta1*sqr_rs+beta2*rs+beta3*rs*sqr_rs+beta4*rs*rs) + ec0_q1p = AA*(beta1*rsm1_2+2*beta2+3*beta3*sqr_rs+4*beta4*rs) + ec0_den = 1/(ec0_q1*ec0_q1+ec0_q1) + ec0_log = np.zeros((N_q)) + + f1 = 1/ec0_q1 + y1 = np.argwhere(f1<1)[:,0] + f1_less_than_1 = f1[y1] + y2 = np.argwhere(f1>=1)[:,0] + f1_greater_than_1 = f1[y2] + ec0_log_for_f1_greater_than_1 = np.log(1+f1_greater_than_1) + ec0_log_for_f1_less_than_1 = np.log1p(f1_less_than_1) + ec0_log[y1] = ec0_log_for_f1_less_than_1 + ec0_log[y2] = ec0_log_for_f1_greater_than_1 + if np.any(ec0_log == 0): + y = np.argwhere(ec0_log==0)[:,0] + ec0_log[y] = 1e-15 + + ecrs0 = ec0_q0*ec0_log + ec_lsda1 = ecrs0 + Dec_lsda1Drs = -2*AA*alpha1*ec0_log-ec0_q0*ec0_q1p*ec0_den + + r = 0.031091 + w1 = np.exp(-ec_lsda1/(r*phi**3))-1 + + A = beta/(r*w1) + t = (((3*np.pi**2)/16)**(1/3))*s/(phi*sqr_rs) + g = (1+4*A*t*t)**(-0.25) + H1 = r*(phi**3)*np.log(1+w1*(1-g)) + ec1 = ec_lsda1+H1 + + c1c = 0.64 + c2c = 1.5 + dc = 0.7 + alphaG1 = (alpha>1) + alphaE1 = (alpha==1) + alphaL1 = (alpha<1) + fc = np.zeros((N_q)) + fc[alphaG1] = -dc*np.exp(c2c/(1-alpha[alphaG1])) + fc[alphaE1] = 0 + fc[alphaL1] = np.exp(-c1c*alpha[alphaL1]/(1-alpha[alphaL1])) + ec = ec1+fc*(ec0-ec1) + + DzetaDn = 0 + DrsDn = -4*np.pi/9*(4*np.pi/3*rho)**(-4/3) + DdxDn = (4/3*(1+zeta)**(1/3) - 4/3*(1-zeta)**(1/3))*DzetaDn + DGcDn = -2.3631*DdxDn*(1-zeta**12) + (1-2.3631*(dx-1))*((12*zeta**11)*(DzetaDn)) + DgInf0sDs = -0.25*((1+4*xiInf0*s*s)**(-1.25))*(4*xiInf0*2*s) + DgInf0sDn = DgInf0sDs*DsDn + DgInf0sDDn = DgInf0sDs*DsDDn + DecLDA0Dn = b1c*(0.5*b2c*rs**(-0.5)+b3c)/((1+b2c*rs**(0.5)+b3c*rs)**2)*DrsDn + Dw0Dn = (w0+1)*(-DecLDA0Dn/b1c) + DH0Dn = b1c*(Dw0Dn*(1-gInf0s)-w0*DgInf0sDn)/(1+w0*(1-gInf0s)) + DH0DDn = b1c*(-w0*DgInf0sDDn)/(1+w0*(1-gInf0s)) + + Dec0Dn = (DecLDA0Dn+DH0Dn)*Gc + (ecLDA0+H0)*DGcDn + Dec0DDn = DH0DDn*Gc + + Dec_lsda1Dn = -(rs/rho/3)*(-2*AA*alpha1*np.log(1+1/(2*AA*(beta1*sqr_rs+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1)))))-((-2*AA*(1+alpha1*rs))*(AA*(beta1*(rs**(-0.5))+2*beta2+3*beta3*(rs**(0.5))+2*(p+1)*beta4*(rs**p))))/((2*AA*(beta1*sqr_rs+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1))))*(2*AA*(beta1*sqr_rs+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1))))+(2*AA*(beta1*(rs**(0.5))+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1)))))) + DbetaDn = 0.066725*(0.1*(1+0.1778*rs)-0.1778*(1+0.1*rs))/((1+0.1778*rs)**2)*DrsDn + DphiDn = 0.5*(2/3*(1+zeta)**(-1/3) - 2/3*(1-zeta)**(-1/3))*DzetaDn + DtDn = ((3*(np.pi**2)/16)**(1/3))*(phi*sqr_rs*DsDn-s*(DphiDn*sqr_rs+phi*DrsDn/(2*sqr_rs)))/((phi**2)*rs) + DtDDn = t*DsDDn/s + Dw1Dn = (w1+1)*(-((r*phi**3)*Dec_lsda1Dn-r*ec_lsda1*(3*(phi**2)*DphiDn))/((r*phi**3)**2)) + DADn = (w1*DbetaDn - beta*Dw1Dn)/(r*w1**2) + DgDn = (-0.25*(1+4*A*t*t)**(-1.25))*(4*(DADn*t*t+2*A*t*DtDn)) + DgDDn = (-0.25*(1+4*A*t*t)**(-1.25))*(4*2*A*t*DtDDn) + DH1Dn = r*((3*phi**2)*DphiDn*np.log(1+w1*(1-g)) + (phi**3)*(Dw1Dn*(1-g)-w1*DgDn)/(1+w1*(1-g))) + DH1DDn = r*((phi**3)*(-w1*DgDDn)/(1+w1*(1-g))) + Dec1Dn = Dec_lsda1Dn + DH1Dn + Dec1DDn = DH1DDn + + DfcDalpha = np.zeros((N_q)) + DfcDalpha[alphaG1] = fc[alphaG1]*(c2c/(1-alpha[alphaG1])**2) + DfcDalpha[alphaE1] = 0 + DfcDalpha[alphaL1] = fc[alphaL1]*(-c1c/(1-alpha[alphaL1])**2) + DfcDn = DfcDalpha*DalphaDn + DfcDDn = DfcDalpha*DalphaDDn + DfcDtau = DfcDalpha*DalphaDtau + DepsiloncDn = Dec1Dn + fc*(Dec0Dn-Dec1Dn) + DfcDn*(ec0-ec1) + DepsiloncDDn = Dec1DDn + fc*(Dec0DDn - Dec1DDn) + DfcDDn*(ec0-ec1) + DepsiloncDtau = DfcDtau*(ec0-ec1) + v1c = ec + rho*DepsiloncDn + v2c = rho*(DepsiloncDDn)/normDrho + v3c = rho*DepsiloncDtau + + + + return GenericXCResult( + v_generic = v1c, + e_generic = ec, + de_dsigma = v2c, + de_dtau = v3c + ) + + +class rSCAN(XCEvaluator): + """ + rSCAN (regularized SCAN) meta-GGA functional. + + Regularized version of SCAN with improved numerical stability. + + References + ---------- + Bartók, Yates, Phys. Rev. B 99, 235103 (2019) + """ + + def __init__( + self, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None, + params: Optional[XCParameters] = None + ): + """Initialize rSCAN evaluator.""" + if derivative_matrix is None: + raise ValueError("rSCAN requires derivative_matrix") + super().__init__(derivative_matrix=derivative_matrix, r_quad=r_quad, params=params) + + def _default_params(self) -> rSCANParameters: + """Return default rSCAN parameters.""" + return rSCANParameters() + + + + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """ + Compute rSCAN exchange in generic form. + + Similar to SCAN but with regularized enhancement factor. + """ + + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + + normDrho = sigma**(0.5) + + s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau = \ + self._compute_basic_rscan_variables(rho, normDrho, tau) + + ex, v_x_generic, de_x_dsigma, de_x_dtau = \ + self._rSCAN_exchange(rho, s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau) + + de_x_dsigma = de_x_dsigma / normDrho + + return GenericXCResult( + v_generic = v_x_generic, + e_generic = ex, + de_dsigma = de_x_dsigma, + de_dtau = de_x_dtau + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """Compute rSCAN correlation in generic form.""" + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + + # original code, without modification + normDrho = sigma**(0.5) + + s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau = \ + self._compute_basic_rscan_variables(rho, normDrho, tau) + + ec, v_c_generic, de_c_dsigma, de_c_dtau = \ + self._rSCAN_correlation(rho, s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau) + + de_c_dsigma = de_c_dsigma / normDrho + + # np.savetxt("v_c_generic.txt", v_c_generic) + # np.savetxt("ec.txt", ec) + # np.savetxt("de_c_dsigma.txt", de_c_dsigma) + # np.savetxt("de_c_dtau.txt", de_c_dtau) + # raise ValueError("Stop here") + + return GenericXCResult( + v_generic = v_c_generic, + e_generic = ec, + de_dsigma = de_c_dsigma, + de_dtau = de_c_dtau + ) + + + @staticmethod + def _compute_basic_rscan_variables(rho, normDrho, tau): + s = normDrho/((2*(3*np.pi**2)**(1/3))*rho**(4/3)) + tauw = (normDrho**2)/(8*rho) + tauUnif = 3/10*((3*np.pi**2)**(2/3))*rho**(5/3) + alpha = (tau-tauw)/(tauUnif+1e-4) + alphaP = (alpha**3)/(alpha**2+1e-3) + + DsDn = -2*normDrho/((3*(3*np.pi**2)**(1/3))*rho**(7/3)) + DsDDn = 1/((2*(3*np.pi**2)**(1/3))*rho**(4/3)) + DtauwDn = -(normDrho**2)/(8*rho**2) + DtauwDDn = normDrho/(4*rho) + + DtauUnifDn = ((3*np.pi**2)**(2/3))/2 * rho**(2/3) + DalphaDn = (-DtauwDn*(tauUnif+1e-4)-(tau-tauw)*DtauUnifDn)/(tauUnif+1e-4)**2 + DalphaDDn = -DtauwDDn/(tauUnif+1e-4) + DalphaDtau = 1/(tauUnif+1e-4) + DalphaDalpha = (3*alpha**2*(alpha**2+1e-3)-alpha**3*(2*alpha))/(alpha**2+1e-3)**2 + DalphaPDn = DalphaDalpha*DalphaDn + DalphaPDDn = DalphaDalpha*DalphaDDn + DalphaPDtau = DalphaDalpha*DalphaDtau + + return [s, alphaP ,DsDn, DsDDn, DalphaPDn, DalphaPDDn, DalphaPDtau] + + + @staticmethod + def _rSCAN_correlation(rho, s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau): + N_q = len(rho) + + zeta = 0 + phi = ((1+zeta)**(2/3)+(1-zeta)**(2/3))/2 + rs = (0.75/(np.pi*rho))**(1/3) + b1c = 0.0285764 + b2c = 0.0889 + b3c = 0.125541 + ecLDA0 = -b1c/(1+b2c*(rs**(0.5))+b3c*rs) + dx = 0.5*((1+zeta)**(4/3)+(1-zeta)**(4/3)) + cx0 = -3/(4*np.pi)*(9*np.pi/4)**(1/3) + Gc = (1-2.3631*(dx-1))*(1-zeta**12) + w0 = np.exp(-ecLDA0/b1c)-1 + betaConst = 0.06672455060314922 + betaRsInf = betaConst*0.1/0.1778 + f0 = -0.9 + xiInf0 = (((3*np.pi**2)/16)**(2/3))*(betaRsInf*1/(cx0-f0)) + gInf0s = (1+4*xiInf0*s**2)**(-0.25) + H0 = b1c*np.log(1+w0*(1-gInf0s)) + ec0 = (ecLDA0+H0)*Gc + sqr_rs = rs**(0.5) + rsm1_2 = 1/sqr_rs + beta = betaConst*(1+0.1*rs)/(1+0.1778*rs) + p=1 + AA = 0.0310907 + alpha1 = 0.21370 + beta1 = 7.5957 + beta2 = 3.5876 + beta3 = 1.6382 + beta4 = 0.49294 + + ec0_q0 = -2*AA*(1+alpha1*rs) + ec0_q1 = 2*AA*(beta1*sqr_rs+beta2*rs+beta3*rs*sqr_rs+beta4*rs*rs) + ec0_q1p = AA*(beta1*rsm1_2+2*beta2+3*beta3*sqr_rs+4*beta4*rs) + ec0_den = 1/(ec0_q1*ec0_q1+ec0_q1) + ec0_log = np.zeros((N_q)) + + f1 = 1/ec0_q1 + y1 = np.argwhere(f1<1)[:,0] + f1_less_than_1 = f1[y1] + y2 = np.argwhere(f1>=1)[:,0] + f1_greater_than_1 = f1[y2] + ec0_log_for_f1_greater_than_1 = np.log(1+f1_greater_than_1) + ec0_log_for_f1_less_than_1 = np.log1p(f1_less_than_1) + ec0_log[y1] = ec0_log_for_f1_less_than_1 + ec0_log[y2] = ec0_log_for_f1_greater_than_1 + if np.any(ec0_log == 0): + y = np.argwhere(ec0_log==0)[:,0] + ec0_log[y] = 1e-15 + + ecrs0 = ec0_q0*ec0_log + ec_lsda1 = ecrs0 + Dec_lsda1Drs = -2*AA*alpha1*ec0_log - ec0_q0*ec0_q1p*ec0_den + + r = 0.031091 + w1 = np.exp(-ec_lsda1/(r*phi**3))-1 + 1e-15 + A = beta/(r*w1) + t = (((3*np.pi**2)/16)**(1/3))*s/(phi*sqr_rs) + g = (1+4*A*t*t)**(-0.25) + H1 = r*(phi**3)*np.log(1+w1*(1-g)) + ec1 = ec_lsda1 + H1 + + c1c = 0.64 + c2c = 1.5 + dc = 0.7 + + alphaG25 = (alpha>2.5) + alpha0To25 = ((alpha>=0) & (alpha<=2.5)) + alphaL0 = (alpha<0) + fc = np.zeros((N_q)) + fc[alphaG25] = -dc*np.exp(c2c/(1-alpha[alphaG25])) + fc[alpha0To25] = 1 + (-0.64)*alpha[alpha0To25] + (-0.4352)*alpha[alpha0To25]**2 + (-1.535685604549)*alpha[alpha0To25]**3 + + (3.061560252175)*alpha[alpha0To25]**4 + (-1.915710236206)*alpha[alpha0To25]**5 + 0.516884468372*alpha[alpha0To25]**6 + + (-0.051848879792)*alpha[alpha0To25]**7 + + fc[alphaL0] = np.exp(-c1c*alpha[alphaL0]/(1-alpha[alphaL0])) + ec = ec1 + fc*(ec0-ec1) + + DzetaDn = 0 + DrsDn = -4*np.pi/9*(4*np.pi/3*rho)**(-4/3) + DdxDn = (4/3*(1+zeta)**(1/3)-4/3*(1-zeta)**(1/3))*DzetaDn + DGcDn = -2.3631*DdxDn*(1-zeta**12) + (1-2.3631*(dx-1))*((12*zeta**11)*DzetaDn) + DgInf0sDs = (-0.25*(1+4*xiInf0*s*s)**(-1.25))*(4*xiInf0*2*s) + DgInf0sDn = DgInf0sDs*DsDn + DgInf0sDDn = DgInf0sDs*DsDDn + DecLDA0Dn = b1c*(0.5*b2c*rs**(-0.5)+b3c)/((1+b2c*rs**(0.5)+b3c*rs)**(2))*DrsDn + Dw0Dn = (w0+1)*(-DecLDA0Dn/b1c) + DH0Dn = b1c*(Dw0Dn*(1-gInf0s)-w0*DgInf0sDn)/(1+w0*(1-gInf0s)) + DH0DDn = b1c*(-w0*DgInf0sDDn)/(1+w0*(1-gInf0s)) + Dec0Dn = (DecLDA0Dn + DH0Dn)*Gc + (ecLDA0+H0)*DGcDn + Dec0DDn = DH0DDn*Gc + + Dec_lsda1Dn = -(rs/rho/3)*(-2*AA*alpha1*np.log(1+1/(2*AA*(beta1*sqr_rs+beta2*rs + beta3*(rs**1.5)+beta4*(rs**(p+1))))) + -((-2*AA*(1+alpha1*rs))*(AA*(beta1*(rs**(-0.5))+2*beta2 + 3*beta3*(rs**(0.5))+2*(p+1)*beta4*(rs**p)))) + /((2*AA*(beta1*sqr_rs+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1)))) + *(2*AA*(beta1*sqr_rs + beta2*rs + beta3*(rs**1.5)+beta4*(rs**(p+1)))) + (2*AA*(beta1*(rs**(0.5))+beta2*rs+beta3*(rs**1.5)+beta4*(rs**(p+1)))))) + + DbetaDn = 0.066725*(0.1*(1+0.1778*rs)-0.1778*(1+0.1*rs))/((1+0.1778*rs)**2)*DrsDn + DphiDn = 0.5*(2/3*(1+zeta)**(-1/3) - 2/3*(1-zeta)**(-1/3))*DzetaDn + DtDn = ((3*np.pi**2)/16)**(1/3)*(phi*sqr_rs*DsDn-s*(DphiDn*sqr_rs+phi*DrsDn/(2*sqr_rs)))/((phi**2)*rs) + DtDDn = t*DsDDn/s + Dw1Dn = (1+w1)*(-(r*phi**3*Dec_lsda1Dn-r*ec_lsda1*(3*phi**2*DphiDn)))/((r*phi**3)**2) + DADn = (w1*DbetaDn-beta*Dw1Dn)/(r*w1**2) + DgDn = -0.25*(1+4*A*t*t)**(-1.25)*(4*(DADn*t*t+2*A*t*DtDn)) + DgDDn = -0.25*(1+4*A*t*t)**(-1.25)*(4*2*A*t*DtDDn) + DH1Dn = r*(3*phi**2*DphiDn*np.log(1+w1*(1-g))+phi**3*(Dw1Dn*(1-g)-w1*DgDn)/(1+w1*(1-g))) + DH1DDn = r*(phi**3*(-w1*DgDDn)/(1+w1*(1-g))) + Dec1Dn = Dec_lsda1Dn + DH1Dn + Dec1DDn = DH1DDn + + DfcDalpha = np.zeros((N_q)) + DfcDalpha[alphaG25] = fc[alphaG25]*(c2c/(1-alpha[alphaG25])**2) + DfcDalpha[alpha0To25] = (-0.64) + (-0.4352)*alpha[alpha0To25]*2 + (-1.535685604549)*alpha[alpha0To25]**2*3 + + 3.061560252175*alpha[alpha0To25]**3*4 + (-1.915710236206)*alpha[alpha0To25]**4*5 + 0.516884468372*alpha[alpha0To25]**5*6 + + (-0.051848879792)*alpha[alpha0To25]**6*7 + + DfcDalpha[alphaL0] = fc[alphaL0]*(-c1c/(1-alpha[alphaL0])**2) + DfcDn = DfcDalpha*DalphaDn + DfcDDn = DfcDalpha*DalphaDDn + DfcDtau = DfcDalpha*DalphaDtau + DepsiloncDn = Dec1Dn + fc*(Dec0Dn-Dec1Dn) + DfcDn*(ec0-ec1) + DepsiloncDDn = Dec1DDn + fc*(Dec0DDn-Dec1DDn)+ DfcDDn*(ec0-ec1) + DepsiloncDtau = DfcDtau*(ec0-ec1) + v1c = ec + rho*DepsiloncDn + v2c = rho*DepsiloncDDn + v3c = rho*DepsiloncDtau + + return [ec, v1c, v2c, v3c] + + + @staticmethod + def _rSCAN_exchange(rho, s, alpha, DsDn, DsDDn, DalphaDn, DalphaDDn, DalphaDtau): + N_q = len(rho) + epsixUnif = -3/(4*np.pi)*(3*(np.pi**2)*rho)**(1/3) + + k1 = 0.065 + muak = 10/81 + b2 = np.sqrt(5913/405000) + b1 = 511/13500/(2*b2) + b3 = 0.5 + b4 = muak*muak/k1 -1606/18225 - b1*b1 + + x = (muak*s**2)*(1+b4*(s**2)/muak*np.exp(-np.abs(b4)*(s**2)/muak)) + (b1*s**2+b2*(1-alpha)*np.exp(-b3*(1-alpha)**2))**2 + hx1 = 1+k1 - k1/(1+x/k1) + hx0 = 1.174 + + c1x = 0.667 + c2x = 0.8 + dx = 1.24 + alphaG25 = (alpha>2.5) + alpha0To25 = ((alpha>=0) & (alpha<=2.5)) + alphaL0 =(alpha<0) + fx = np.zeros((N_q)) + fx[alphaG25] = -dx*np.exp(c2x/(1-alpha[alphaG25])) + fx[alpha0To25] = 1 + (-0.667)*alpha[alpha0To25] + (-0.4445555)*alpha[alpha0To25]**2 + (-0.663086601049)*alpha[alpha0To25]**3 + + 1.451297044490*alpha[alpha0To25]**4 + (-0.887998041597)*alpha[alpha0To25]**5 + 0.234528941479*alpha[alpha0To25]**6 + + (-0.023185843322)*alpha[alpha0To25]**7 + fx[alphaL0] = np.exp(-c1x*alpha[alphaL0]/(1-alpha[alphaL0])) + a1 = 4.9479 + gx = 1-np.exp(-a1*s**(-0.5)) + Fx = (hx1 + fx*(hx0-hx1))*gx + + ex = epsixUnif*Fx + s2 = s*s + term1 = 1 + (b4*s2)/muak*np.exp(-np.abs(b4)*s2/muak) + term2 = s2*(b4/muak*np.exp(-np.abs(b4)*s2/muak) + b4*s2/muak*np.exp(-np.abs(b4)*s2/muak)*(-np.abs(b4)/muak)) + term3 = 2*(b1*s2 + b2*(1-alpha)*np.exp(-b3*(1-alpha)**2)) + term4 = b2*(-np.exp(-b3*(1-alpha)**2) + (1-alpha)*(np.exp(-b3*(1-alpha)**2))*(2*b3*(1-alpha))) + DxDs = 2*s*(muak*(term1+term2) + b1*term3) + DxDalpha = term3*term4 + DxDn = DsDn*DxDs + DalphaDn*DxDalpha + DxDDn = DsDDn*DxDs + DalphaDDn*DxDalpha + DxDtau = DalphaDtau*DxDalpha + + DgxDn = -np.exp(-a1*s**(-0.5))*(a1/2*s**(-1.5))*DsDn + DgxDDn = -np.exp(-a1*s**(-0.5))*(a1/2*s**(-1.5))*DsDDn + Dhx1Dx = 1/(1+x/k1)**2 + Dhx1Dn = DxDn*Dhx1Dx + Dhx1DDn = DxDDn*Dhx1Dx + Dhx1Dtau = DxDtau*Dhx1Dx + + DfxDalpha = np.zeros((N_q)) + DfxDalpha[alphaG25] = -dx*np.exp(c2x/(1-alpha[alphaG25]))*(c2x/(1-alpha[alphaG25])**2) + DfxDalpha[alpha0To25] = -0.667 + (-0.4445555)*alpha[alpha0To25]*2 + (-0.663086601049)*(alpha[alpha0To25]**2)*3 + + 1.451297044490*(alpha[alpha0To25]**3)*4 + (-0.887998041597)*(alpha[alpha0To25]**4)*5 + 0.234528941479*(alpha[alpha0To25]**5)*6 + + (-0.023185843322)*(alpha[alpha0To25]**6)*7 + DfxDalpha[alphaL0] = np.exp(-c1x*alpha[alphaL0]/(1-alpha[alphaL0]))*(-c1x/(1-alpha[alphaL0])**2) + + DfxDn = DfxDalpha*DalphaDn + DfxDDn = DfxDalpha*DalphaDDn + DfxDtau =DfxDalpha*DalphaDtau + + DFxDn = (hx1 + fx*(hx0-hx1))*DgxDn + gx*(1-fx)*Dhx1Dn + gx*(hx0-hx1)*DfxDn + DFxDDn = (hx1 + fx*(hx0-hx1))*DgxDDn + gx*(1-fx)*Dhx1DDn + gx*(hx0-hx1)*DfxDDn + DFxDtau = gx*(1-fx)*Dhx1Dtau + gx*(hx0-hx1)*DfxDtau + + DepsixUnifDn = -((3*np.pi**2)**(1/3))/(4*np.pi)*rho**(-2/3) + + v1x = (epsixUnif + rho*DepsixUnifDn)*Fx + rho*epsixUnif*DFxDn + v2x = rho*epsixUnif*DFxDDn + v3x = rho*epsixUnif*DFxDtau + return [ex,v1x,v2x,v3x] + + +class r2SCAN(XCEvaluator): + """ + r²SCAN (revised regularized SCAN) meta-GGA functional. + + Further improved version with better performance. + + References + ---------- + Furness et al., J. Phys. Chem. Lett. 11, 8208 (2020) + """ + + def __init__( + self, + derivative_matrix: Optional[np.ndarray] = None, + r_quad: Optional[np.ndarray] = None, + params: Optional[XCParameters] = None + ): + """Initialize r2SCAN evaluator.""" + if derivative_matrix is None: + raise ValueError("r2SCAN requires derivative_matrix") + super().__init__(derivative_matrix=derivative_matrix, r_quad=r_quad, params=params) + + def _default_params(self) -> r2SCANParameters: + """Return default r2SCAN parameters.""" + return r2SCANParameters() + + + def compute_exchange_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """Compute r2SCAN exchange in generic form.""" + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + + N_q = len(rho) + normDrho = sigma**(0.5) + def ex_basicr2SCANvariables(rho,normDrho,tau): + s = normDrho/(2*(3*np.pi**2)**(1/3)*rho**(4/3)) + p = s**2 + tauw = (normDrho**2)/(8*rho) + tauUnif = 3/10*(3*np.pi**2)**(2/3)*(rho**(5/3)) + eta = 0.001 + alpha = (tau-tauw)/(tauUnif+eta*tauw) + # print("alpahxmax",np.max(np.abs(alpha))) + DsDn = -2*normDrho/(3*(3*np.pi**2)**(1/3)*rho**(7/3)) + DpDn = 2*s*DsDn + DsDDn = 1/(2*(3*np.pi**2)**(1/3)*rho**(4/3)) + DpDDn = 2*s*DsDDn + DtauwDn = -normDrho**2/(8*rho**2) + DtauwDDn = normDrho/(4*rho) + DtauUnifDn = (3*np.pi**2)**(2/3)/2*rho**(2/3) + DalphaDn = (-DtauwDn*(tauUnif+eta*tauw) - (tau-tauw)*(DtauUnifDn+eta*DtauwDn))/((tauUnif+eta*tauw)**2) + + DalphaDDn = (-DtauwDDn*(tauUnif+eta*tauw) - (tau-tauw)*eta*DtauwDDn)/((tauUnif+eta*tauw)**2) + DalphaDtau = 1/(tauUnif+eta*tauw) + + return [p, alpha,DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau] + + + p, alpha, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau = ex_basicr2SCANvariables(rho, normDrho, tau) + + def exchanger2SCAN(rho,p,alpha,DpDn,DpDDn,DalphaDn, DalphaDDn, DalphaDtau): + epsixUnif = -3/(4*np.pi)*(3*np.pi**2*rho)**(1/3) + + k0 = 0.174 + k1 = 0.065 + muak = 10/81 + + eta = 0.001 + Ceta = 20/27 + eta*5/3 + C2 = -0.162742 + dp2 = 0.361 + x = (Ceta*C2*np.exp(-p**2/dp2**4)+muak)*p + hx0 = 1+k0 + hx1 = 1+k1 - k1/(1+x/k1) + + c1x = 0.667 + c2x = 0.8 + dx = 1.24 + alphaG25 = (alpha>2.5) + alpha0To25 = ((alpha>=0) & (alpha<=2.5)) + alphaL0 = (alpha<0) + + fx = np.zeros((N_q)) + fx[alphaG25] = -dx*np.exp(c2x/(1-alpha[alphaG25])) + fx[alpha0To25] = 1 + (-0.667)*alpha[alpha0To25] + (-0.4445555)*alpha[alpha0To25]**2 + (-0.663086601049)*alpha[alpha0To25]**3 + + 1.451297044490*alpha[alpha0To25]**4 + (-0.887998041597)*alpha[alpha0To25]**5 + 0.234528941479*alpha[alpha0To25]**6 + + (-0.023185843322)*alpha[alpha0To25]**7 + + fx[alphaL0] = np.exp(-c1x*alpha[alphaL0]/(1-alpha[alphaL0])) + a1 = 4.9479 + gx = 1-np.exp(-a1*p**(-0.25)) + Fx = (hx1 + fx*(hx0-hx1))*gx + + ex = epsixUnif*Fx + + DxDp = (Ceta*C2*np.exp(-p**2/dp2**4)+muak) + Ceta*C2*np.exp(-p**2/dp2**4)*(-2*p/dp2**4)*p + DxDn = DxDp*DpDn + DxDDn = DpDDn*DxDp + + DgxDn = -np.exp(-a1*p**(-0.25))*(a1/4*p**(-1.25))*DpDn + DgxDDn = -np.exp(-a1*p**(-0.25))*(a1/4*p**(-1.25))*DpDDn + Dhx1Dx = 1/(1+x/k1)**2 + Dhx1Dn = DxDn*Dhx1Dx + Dhx1DDn = DxDDn*Dhx1Dx + + DfxDalpha = np.zeros((N_q)) + DfxDalpha[alphaG25] = -dx*np.exp(c2x/(1-alpha[alphaG25]))*(c2x/(1-alpha[alphaG25])**2) + DfxDalpha[alpha0To25] = (-0.667) + (-0.4445555)*alpha[alpha0To25]*2 + (-0.663086601049)*alpha[alpha0To25]**2*3 + + 1.451297044490*alpha[alpha0To25]**3*4 + (-0.887998041597)*alpha[alpha0To25]**4*5 + 0.234528941479*alpha[alpha0To25]**5*6 + + (-0.023185843322)*alpha[alpha0To25]**6*7 + + DfxDalpha[alphaL0] = np.exp(-c1x*alpha[alphaL0]/(1-alpha[alphaL0]))*(-c1x/(1-alpha[alphaL0])**2) + DfxDn = DfxDalpha*DalphaDn + DfxDDn = DfxDalpha*DalphaDDn + DfxDtau = DfxDalpha*DalphaDtau + + DFxDn = (hx1 + fx*(hx0-hx1))*DgxDn + gx*(1-fx)*Dhx1Dn + gx*(hx0-hx1)*DfxDn + DFxDDn = (hx1 + fx*(hx0-hx1))*DgxDDn + gx*(1-fx)*Dhx1DDn + gx*(hx0-hx1)*DfxDDn + + DFxDtau = gx*(hx0-hx1)*DfxDtau + + DepsixUnifDn = -(3*np.pi**2)**(1/3)/(4*np.pi)*rho**(-2/3) + v1x = (epsixUnif + rho*DepsixUnifDn)*Fx + rho*epsixUnif*DFxDn + v2x = rho*epsixUnif*DFxDDn + v3x = rho*epsixUnif*DFxDtau + + return [ex, v1x, v2x, v3x] + ex, v1x, v2x, v3x = exchanger2SCAN(rho, p, alpha, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau) + v2x = v2x/normDrho + + return GenericXCResult( + v_generic = v1x, + e_generic = ex, + de_dsigma = v2x, + de_dtau = v3x + ) + + + def compute_correlation_generic( + self, + density_data: DensityData + ) -> GenericXCResult: + """Compute r2SCAN correlation in generic form.""" + rho, tau, sigma = _get_rho_tau_and_sigma(density_data) + + N_q = len(rho) + normDrho = sigma**(0.5) + def co_basicr2SCANvariables(rho, normDrho, tau): + s = normDrho/(2*(3*np.pi**2)**(1/3)*rho**(4/3)) + p = s**2 + zeta = 0 + tauw = (normDrho**2)/(8*rho) + ds = 1 + tauUnif= 3/10*(3*np.pi**2)**(2/3)*(rho**(5/3)) + eta = 0.001 + alpha = (tau-tauw)/(tauUnif+eta*tauw) + # print("alpahcmac",np.max(np.abs(alpha))) + DsDn = -2*normDrho/(3*(3*np.pi**2)**(1/3)*rho**(7/3)) + DpDn = 2*s*DsDn + DsDDn = 1/(2*(3*np.pi**2)**(1/3)*rho**(4/3)) + DpDDn = 2*s*DsDDn + DtauwDn = -normDrho**2/(8*rho**2) + DtauwDDn = normDrho/(4*rho) + + DtauUnifDn = (3*np.pi**2)**(2/3)/2*rho**(2/3) + + DalphaDn = (-DtauwDn*(tauUnif+eta*tauw) - (tau-tauw)*(DtauUnifDn+eta*DtauwDn))/((tauUnif+eta*tauw)**2) + DalphaDDn = (-DtauwDDn*(tauUnif+eta*tauw) - (tau-tauw)*eta*DtauwDDn)/((tauUnif+eta*tauw)**2) + DalphaDtau = 1/(tauUnif+eta*tauw) + + return [s, p, alpha, DsDn, DsDDn, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau] + + s, p, alpha, DsDn, DsDDn, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau = co_basicr2SCANvariables(rho, normDrho, tau) + + def correlationr2SCAN(rho, s, p, alpha, DsDn, DsDDn, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau): + phi = 1 + rs = (0.75/(np.pi*rho))**(1/3) + + b1c = 0.0285764 + b2c = 0.0889 + b3c = 0.125541 + ecLDA0 = -b1c/(1+b2c*(rs**(0.5))+b3c*rs) + dx = 1 + cx0 = -3/(4*np.pi)*(9*np.pi/4)**(1/3) + Gc = 1 + w0 = np.exp(-ecLDA0/b1c)-1 + betaConst = 0.06672455060314922 + betaRsInf = betaConst*0.1/0.1778 + f0 = -0.9 + chiInf = (3*np.pi**2/16)**(2/3)*(betaRsInf*1/(cx0-f0)) + + gInf0s = (1+4*chiInf*(s**2))**(-0.25) + H0 = b1c*np.log(1+w0*(1-gInf0s)) + ec0 = ecLDA0 + H0 + + sqr_rs = rs**(0.5) + rsm1_2 = 1/sqr_rs + beta = betaConst*(1+0.1*rs)/(1+0.1778*rs) + + AAec0 = 0.0310907 + alpha1ec0 = 0.21370 + beta1ec0 = 7.5957 + beta2ec0 = 3.5876 + beta3ec0 = 1.6382 + beta4ec0 = 0.49294 + + ec0_q0 = -2*AAec0*(1+alpha1ec0*rs) + ec0_q1 = 2*AAec0*(beta1ec0*sqr_rs + beta2ec0*rs + beta3ec0*rs*sqr_rs + beta4ec0*rs*rs) + ec0_q1p = AAec0*(beta1ec0*rsm1_2 + 2*beta2ec0 + 3*beta3ec0*sqr_rs + 4*beta4ec0*rs) + ec0_den = 1/(ec0_q1*ec0_q1 + ec0_q1) + ec0_log = np.zeros((N_q)) + + f1 = 1/ec0_q1 + y1 = np.argwhere(f1<1)[:,0] + f1_less_than_1 = f1[y1] + y2 = np.argwhere(f1>=1)[:,0] + f1_greater_than_1 = f1[y2] + ec0_log_for_f1_greater_than_1 = np.log(1+f1_greater_than_1) + ec0_log_for_f1_less_than_1 = np.log1p(f1_less_than_1) + ec0_log[y1] = ec0_log_for_f1_less_than_1 + ec0_log[y2] = ec0_log_for_f1_greater_than_1 + if np.any(ec0_log == 0): + y = np.argwhere(ec0_log==0)[:,0] + ec0_log[y] = 1e-15 + + ecrs0 = ec0_q0*ec0_log + decrs0_drs = -2*AAec0*alpha1ec0*ec0_log - ec0_q0*ec0_q1p*ec0_den + + f_zeta = 0 + fp_zeta = 0 + zeta4 = 0 + + ec_lsda1 = ecrs0 + declsda1_drs = decrs0_drs + + r = 0.031091 + w1 = np.exp(-ec_lsda1/r)-1 + t = ((3*np.pi**2)/16)**(1/3)*s/sqr_rs + + y = beta/(r*w1)*(t**2) + + deltafc2 = 1*(-0.64) + 2*(-0.4352) + 3*(-1.535685604549) + 4*3.061560252175 + 5*(-1.915710236206) + 6*0.516884468372 + 7*(-0.051848879792) + + ds = 1 + eta = 0.001 + dp2 = 0.361 + ec_lsda0 = ecLDA0 + declsda0_drs = b1c*(0.5*b2c*rs**(-0.5)+b3c)/((1+b2c*rs**(0.5) + b3c*rs)**2) + + deltayPart1 = deltafc2/(27*r*w1) + deltayPart2 = 20*rs*(declsda0_drs-declsda1_drs) - 45*eta*(ec_lsda0-ec_lsda1) + deltayPart3 = p*np.exp(-p**2/dp2**4) + + deltay = deltayPart1*deltayPart2*deltayPart3 + + g = (1+4*(y-deltay))**(-0.25) + H1 = r*phi**3*np.log(1+w1*(1-g)) + ec1 = ec_lsda1+H1 + + c1c = 0.64 + c2c = 1.5 + dc = 0.7 + alphaG25 = (alpha>2.5) + alpha0To25 = ((alpha>=0) & (alpha<=2.5)) + alphaL0 = (alpha<0) + + fc = np.zeros((N_q)) + fc[alphaG25] = -dc*np.exp(c2c/(1-alpha[alphaG25])) + fc[alpha0To25] = 1 + (-0.64)*alpha[alpha0To25] + (-0.4352)*alpha[alpha0To25]**2 + (-1.535685604549)*alpha[alpha0To25]**3 + + 3.061560252175*alpha[alpha0To25]**4 + (-1.915710236206)*alpha[alpha0To25]**5 + 0.516884468372*alpha[alpha0To25]**6 + + (-0.051848879792)*alpha[alpha0To25]**7 + fc[alphaL0] = np.exp(-c1c*alpha[alphaL0]/(1-alpha[alphaL0])) + ec = ec1 + fc*(ec0-ec1) + + DrsDn = -4*np.pi/9*(4*np.pi/3*rho)**(-4/3) + DgInf0sDs = -0.25*(1+4*chiInf*s*s)**(-1.25)*(4*chiInf*2*s) + DgInf0sDn = DgInf0sDs*DsDn + DgInf0sDDn = DgInf0sDs*DsDDn + DecLDA0Dn = b1c*(0.5*b2c*rs**(-0.5)+b3c)/((1+b2c*rs**(0.5)+b3c*rs)**2)*DrsDn + Dw0Dn = (w0+1)*(-DecLDA0Dn/b1c) + DH0Dn = b1c*(Dw0Dn*(1-gInf0s)-w0*DgInf0sDn)/(1+w0*(1-gInf0s)) + DH0DDn = b1c*(-w0*DgInf0sDDn)/(1+w0*(1-gInf0s)) + Dec0Dn = DecLDA0Dn + DH0Dn + Dec0DDn = DH0DDn + + dec_lsda1_drs = decrs0_drs + + dec0log_drs = -ec0_q1p*ec0_den + dec0q0_drs = -2*AAec0*alpha1ec0 + dec0q1p_drs = AAec0*((-0.5*beta1ec0*rsm1_2/rs + 3*0.5*beta3ec0*rsm1_2+4*beta4ec0)) + dec0den_drs = -(2*ec0_q1*ec0_q1p+ec0_q1p)/(ec0_q1*ec0_q1+ec0_q1)**2 + d2ecrs0_drs2 = -2*AAec0*alpha1ec0*dec0log_drs - (dec0q0_drs*ec0_q1p*ec0_den+ec0_q0*dec0q1p_drs*ec0_den+ec0_q0*ec0_q1p*dec0den_drs) + d2eclsda1_drs2 = d2ecrs0_drs2 + + Ddeclsda1_drsDn = d2eclsda1_drs2*DrsDn + + Dec_lsda1Dn = (-rs/3*dec_lsda1_drs)/rho + DbetaDn = 0.066725*(0.1*(1+0.1778*rs) - 0.1778*(1+0.1*rs))/((1+0.1778*rs)**2)*DrsDn + + DtDn = (3*np.pi**2/16)**(1/3)*(sqr_rs*DsDn - s*(DrsDn/(2*sqr_rs)))/rs + DtDDn = t*DsDDn/s + + Dw1Dn = (w1+1)*(-(r*Dec_lsda1Dn)/(r**2)) + DyDn = (w1*DbetaDn - beta*Dw1Dn)/(r*w1**2)*(t**2) + beta/(r*w1)*(2*t)*DtDn + DyDDn = beta/(r*w1) * (2*t)*DtDDn + + Declsda0Dn = declsda0_drs*DrsDn + + d2eclsda0_drs2 = b1c*((0.5*b2c*(-0.5)*rs**(-1.5))*((1+b2c*rs**(0.5)+b3c*rs)**2)-(0.5*b2c*rs**(-0.5)+b3c)*2*(1+b2c*rs**(0.5)+b3c*rs)*(0.5*b2c*rs**(-0.5)+b3c))/(((1+b2c*rs**(0.5)+b3c*rs)**2)**2) + Ddeclsda0_drsDn = d2eclsda0_drs2*DrsDn + + d_deltayPart1_dn = 0 + 0 + deltafc2/(27*r)*(-1)*w1**(-2)*Dw1Dn + d_deltayPart2_dn = 20*(declsda0_drs-declsda1_drs)*DrsDn + 20*rs*(Ddeclsda0_drsDn - Ddeclsda1_drsDn) - 45*eta*(Declsda0Dn - Dec_lsda1Dn) + d_deltayPart3_dp = np.exp(-p**2/dp2**4) + p*np.exp(-p**2/dp2**4)*(-2*p/dp2**4) + + DdeltayDn = d_deltayPart1_dn*deltayPart2*deltayPart3 + deltayPart1*d_deltayPart2_dn*deltayPart3 + deltayPart1*deltayPart2*d_deltayPart3_dp*DpDn + + DdeltayDDn = deltayPart1*deltayPart2*d_deltayPart3_dp*DpDDn + + DgDn = -0.25*(1+4*(y-deltay))**(-1.25)*(4*(DyDn-DdeltayDn)) + DgDDn = -0.25*(1+4*(y-deltay))**(-1.25)*(4*(DyDDn-DdeltayDDn)) + + DH1Dn = r*((Dw1Dn*(1-g)-w1*DgDn)/(1+w1*(1-g))) + DH1DDn = r*((-w1*DgDDn)/(1+w1*(1-g))) + + Dec1Dn = Dec_lsda1Dn + DH1Dn + Dec1DDn = DH1DDn + + DfcDalpha = np.zeros((N_q)) + DfcDalpha[alphaG25] = fc[alphaG25]*(c2c/(1-alpha[alphaG25])**2) + DfcDalpha[alpha0To25] = (-0.64) + (-0.4352)*alpha[alpha0To25]*2 + (-1.535685604549)*alpha[alpha0To25]**2*3 + + 3.061560252175*alpha[alpha0To25]**3*4 + (-1.915710236206)*alpha[alpha0To25]**4*5 + 0.516884468372*alpha[alpha0To25]**5*6 + + (-0.051848879792)*alpha[alpha0To25]**6*7 + DfcDalpha[alphaL0] = fc[alphaL0]*(-c1c/(1-alpha[alphaL0])**2) + DfcDn = DfcDalpha*DalphaDn + DfcDDn = DfcDalpha*DalphaDDn + DfcDtau = DfcDalpha*DalphaDtau + DepsiloncDn = Dec1Dn + fc*(Dec0Dn-Dec1Dn) + DfcDn*(ec0-ec1) + DepsiloncDDn = Dec1DDn + fc*(Dec0DDn-Dec1DDn) + DfcDDn*(ec0-ec1) + DepsiloncDtau = DfcDtau*(ec0-ec1) + + v1c = ec + rho*DepsiloncDn + v2c = rho*DepsiloncDDn + v3c = rho*DepsiloncDtau + + return [ec, v1c, v2c,v3c] + ec, v1c, v2c, v3c = correlationr2SCAN(rho, s, p, alpha, DsDn, DsDDn, DpDn, DpDDn, DalphaDn, DalphaDDn, DalphaDtau) + v2c = v2c/normDrho + + return GenericXCResult( + v_generic = v1c, + e_generic = ec, + de_dsigma = v2c, + de_dtau = v3c + ) + + + + + +if __name__ == "__main__": + pass \ No newline at end of file diff --git a/utils/atom/xc/oep.py b/utils/atom/xc/oep.py new file mode 100644 index 00000000..e1a8cc30 --- /dev/null +++ b/utils/atom/xc/oep.py @@ -0,0 +1,12 @@ +from __future__ import annotations +import numpy as np +from typing import Tuple, Any + +class OEPBuilder: + """Build OEP exchange/correlation potentials from eigenstates. Placeholder.""" + def __init__(self, lamda: float = 1.0): + self.lamda = float(lamda) + + def build(self, eigvals: np.ndarray, eigvecs: np.ndarray, meta: dict[str, Any]) -> Tuple[np.ndarray, np.ndarray]: + """Return (Vx_OEP, Vc_OEP) on quadrature grid.""" + raise NotImplementedError("OEP builder not implemented yet.") diff --git a/utils/atom/xc/rpa.py b/utils/atom/xc/rpa.py new file mode 100644 index 00000000..6173f1bf --- /dev/null +++ b/utils/atom/xc/rpa.py @@ -0,0 +1,12 @@ +from __future__ import annotations +import numpy as np +from typing import Any + +class RPACorrelation: + """Compute RPA correlation energy from eigenstates. Placeholder.""" + def __init__(self, q_omega: int, cutoff_freq: float = 0.0): + self.q_omega = int(q_omega) + self.cutoff_freq = float(cutoff_freq) + + def energy(self, eigvals: np.ndarray, eigvecs: np.ndarray, meta: dict[str, Any]) -> float: + raise NotImplementedError("RPA correlation energy not implemented yet.") diff --git a/utils/pdos/README.md b/utils/pdos/README.md new file mode 100644 index 00000000..6b445200 --- /dev/null +++ b/utils/pdos/README.md @@ -0,0 +1,348 @@ +# calculate_pdos – PDOS Calculator for SPARC + +## Overview +calculate_pdos.py is a Python script that provides a set of tools for processing SPARC output files and calculating **Projected Density of States (PDOS)** for electronic structure analysis. The calculator supports full system PDOS calculation, selective atom analysis, automatic atomic orbital generation, and k-point parallelization for efficient computation of electronic properties from first-principles calculations. + +## Prerequisites + +Before using the PDOS calculator, ensure you have the following Python packages installed: + +- **Python 3.10 or later** +- **Numpy** - Numerical computing library +- **Scipy** - Scientific computing library (includes linalg, interpolate, sparse, special modules) +- **PyYAML** - YAML configuration file parsing + + +You can install the required packages using pip: + +```bash +pip install numpy scipy pyyaml +``` + + +## SPARC Input File Requirements + +Before running PDOS calculations, ensure your SPARC input file (`.inpt`) contains the following settings, so that you will get the required `.eigen` and `.psi` files for PDOS calculation: + +```bash +PRINT_EIGEN: 1 # Required: Print eigenvalues +PRINT_ORBITAL: 1 # Required: Print wavefunctions for projection +``` + + +The PDOS calculator automatically handles both: +- **Static systems**: Direct PDOS calculation from the provided structure +- **Relaxation final states**: Uses the final relaxed geometry for PDOS calculation + +**Important**: Since PDOS requires electronic density projection onto atomic orbitals, both the wavefunction data (`.psi` file) and eigenvalue data (`.eigen` file) are essential and must be generated by setting `PRINT_ORBITAL: 1` and `PRINT_EIGEN: 1` in your SPARC input. + + + +## PDOS File Requirements + +For a given `sparc_path` like `examples/Al_FCC/Al`, the script will automatically look for the following files: + +### Required Files +- **`examples/Al_FCC/Al.out`** - SPARC output file containing most calculation results +- **`examples/Al_FCC/Al.eigen`** - Eigenvalues file +- **`examples/Al_FCC/Al.psi`** - Wavefunction file (generated with `PRINT_ORBITAL: 1`) + +### Geometry Files (Choose One) +- **`examples/Al_FCC/Al.static`** - Static geometry file (for static calculations) +- **`examples/Al_FCC/Al.geopt`** - Geometry optimization file (for relaxation final states) + +**Note**: The script automatically detects whether to use `.static` or `.geopt` based on file availability. When performing cell relaxation with `relax_flag=2` (fixing atomic fractional coordinates while relaxing cell), the program also automatically looks for the `.ion` file to determine absolute atomic positions. + +### Atomic Orbital Definition + +The program requires atomic orbital definitions for projection. Two methods are supported: + +#### Method 1: Automatic Generation (Default) +- The program reads pseudopotential paths for each elements from the `.out` file +- Generates atomic orbitals using the corresponding XC functional for each atom + +#### Method 2: UPF Files (Optional) +- Place UPF files directly in the SPARC output directory +- Use naming convention: `Element.upf` (e.g., `Al.upf`, `Si.upf`) +- Program prioritizes UPF files over automatic generation if UPF files are provided +- **Hybrid approach**: You can mix both methods - use UPF files for some atoms and automatic generation for others +- **UPF file sources**: Pre-computed UPF files are available at [SPMS-psps repository](https://github.com/SPARC-X/SPMS-psps/tree/master/upf) for various elements and exchange-correlation functionals + + + + +## Usage + +### Method 1: Simple Mode (Default Settings) + +The simplest way to run PDOS calculation with default parameters: + +```bash +python calculate_pdos.py --path=path_to_sparc_output_dir +``` + +This method performs full PDOS calculation for all atoms and orbitals using default settings, and automatically creates output in the `PDOS_output` directory. The default settings will be detailed in the Configuration File Format section below. + + + + + + +### Method 2: Using Configuration File + +For advanced users who need detailed control over calculation parameters: + +```bash +python calculate_pdos.py --config=path_to_yaml_file.yaml +``` + +This method allows for fine-tuned settings such as k-point parallelization, selective atom PDOS calculation to reduce computation time, custom energy ranges, and other advanced parameters. + + + +## Configuration File Format + +The configuration file should be in YAML format with the following parameters: + +```yaml +# SPARC output path (directory and base filename) +sparc_path: "examples/Al_FCC/Al" + +# Output directory for PDOS results (optional) +output_dir: null # If null, uses sparc_directory/PDOS_output + +# Gaussian broadening width (eV) +gaussian_width: 0.2721140795 # If not specified, set 0.2721140795 by default + +# Energy range for plotting (eV) +min_E_plot: 5.0 # If not specified, will be set according to the minimum energy eigenvalues +max_E_plot: 65.0 # If not specified, will be set according to the minimum energy eigenvalues + +# Number of energy points for PDOS calculation +N_PDOS: 1000 # If not set, set 1000 by default + +# Whether to sum over all the m index for the orbital +sum_over_m_index: False # False by default + +# Full pdos calculation settings (If not set, compute PDOS for all atm's oprbitals) +full_pdos_calculation: True # True by default +atom_type: ["Al", 13] # Can be either (a list of) element name(s) or atomic number(s) +atom_index_for_specified_atom_type: [0, 1] # Label the atoms in the same order as in .static/.geopt file + +# Whether to use k-point parallelization +k_point_parallelization: True +``` + +### Parameter Descriptions + +- **`sparc_path`** (string, required) +Path to SPARC output files, consists of directory and base filename (`sparc_directory/base_filename`). +- **`output_dir`** (string, optional) +Custom output directory. Default: `null` (uses `sparc_directory/PDOS_output`) +- **`gaussian_width`** (float, optional) +Gaussian broadening width for visualization (in eV). Default: `0.2721140795` +- **`N_PDOS`** (integer, optional) +Number of energy points for visualization in DOS and PDOS. Default: `1000` +- **`min_E_plot`** (float, optional) +Minimum energy for visualization (in eV). Default: minimum eigenvalue - 5 × gaussian_width +- **`max_E_plot`** (float, optional) +Maximum energy for visualization (in eV). Default: maximum eigenvalue + 5 × gaussian_width +- **`sum_over_m_index`** (boolean, optional) +Sum over magnetic quantum number m for orbitals (e.g., 3px+3py+3pz → 3p). Default: `False` +- **`full_pdos_calculation`** (boolean, optional) +Compute PDOS for all atoms. If False, requires `atom_type` and `atom_index_for_specified_atom_type`. Default: `True` +- **`atom_type`** (list, optional) +Atom types to include. Can be element names (e.g., "Al", "Si") or atomic numbers (e.g., 13, 14). Default: All atoms +- **`atom_index_for_specified_atom_type`** (list, optional) +Specific atom indices (0-indexed). For example, `atom_type=["Al", "Si"]`, `atom_index_for_specified_atom_type=[1, 0]` calculates PDOS for the 2nd Al atom and 1st Si atom. Default: All atoms of specified types. +- **`k_point_parallelization`** (boolean, optional) +Enable k-point parallel processing. Default: `None` (auto-detect: parallel if k-points > 4, sequential if k-points ≤ 4) +- **`recompute_pdos`** (boolean, optional) +Whether to recompute the PDOS calculation. Default: `True` +- **`projection_datapath`** (string, optional) +Path to load pre-computed projection data when `recompute_pdos=False`. Default: None +- **`print_projection_data`** (boolean, optional) +Whether to print the projection data to file. Default: `False` +- **`orthogonalize_atomic_orbitals`** (boolean, optional) +Whether to orthogonalize the atomic orbitals. Default: `False` + +## Output + +The script will create a `PDOS_output` directory (or custom directory if specified) containing: +- `DOS.txt` - Total density of states +- `PDOS.txt` - Projected density of states + +## Examples: Single-atom System (Al FCC) +Consider a simple Al FCC system. The `examples/Al_FCC` folder contains SPARC calculation results with the following files: + +``` +examples/Al_FCC/ +├── Al.out # SPARC output file (required) +├── Al.static # Static file with atomic positions (required) +├── Al.eigen # Eigenvalues file (required) +├── Al.psi # Wavefunction file (required) +├── Al.upf # Aluminum UPF file (optional, for custom atomic orbitals) +├── other_files... # Other files in the folder (will be ignored) +``` + +**Note**: The folder may contain other files, which will not affect the PDOS calculation as the program automatically ignores them. The program will: +- Use the provided UPF file (`Al.upf`) as atomic basis sets for projection for all Al atoms +- If UPF files are not provided, the program will read pseudopotential paths from the `.out` file and use the built-in generator to create default atomic orbitals +- Perform PDOS calculations for all Al atoms and their orbitals + +#### Full System PDOS Calculation with default parameters: +```bash +python calculate_pdos.py --path=examples/Al_FCC/Al +``` + +Or equivalently using configuration file: +```yaml +# config_Al_FCC.yaml +sparc_path: "examples/Al_FCC/Al" +gaussian_width: 0.2721140795 +min_E_plot: 5.0 +max_E_plot: 65.0 +N_PDOS: 1000 +sum_over_m_index: False +full_pdos_calculation: True +``` + +```bash +python calculate_pdos.py --config=config_Al_FCC.yaml +``` + +## Output Files and Results Discussion + +For the provided Al FCC example, the program generates output files that can be analyzed as follows: + +### DOS.txt +- **Column 1**: Energy levels (in eV) +- **Column 2**: Total electron density projection, representing the occupied states of the system at different energy levels (states/eV) + +This file characterizes the overall electronic structure of the system by showing how many electronic states are available at each energy level. + +```yaml +# DOS.txt +Energy(eV) DOS +5.0000000000 0.0000000000 +5.0600600601 0.0000000000 +5.1201201201 0.0000000000 +5.1801801802 0.0000000000 +5.2402402402 0.0000000000 +5.3003003003 0.0000000000 +... +``` + + +### PDOS.txt +The PDOS file contains detailed metadata and projected density of states data. The file structure includes: + +**Metadata Section**: +- **Basic calculation info**: Fermi level, broadening, grid points, energy range +- **System info**: Number of bands, k-points, atom types, orbitals +- **Calculation parameters**: M-index summation, orbital orthogonalization +- **Atom-specific info**: Atom type, position, PDOS units + +**Data Section**: +- **Energy column**: Energy levels (in eV) +- **Orbital columns**: PDOS values for each orbital + +```yaml +# PDOS.txt structure +:Description: +:Desc_PDOS: Projected density of states for each orbital. Unit=states/eV +:Desc_FERMI_LEVEL: Fermi level energy. Unit=eV +:Desc_BROADENING: Gaussian broadening parameter for DOS calculation. Unit=eV +... + +:BASIC_INFO: +:FERMI_LEVEL: 32.432 +:BROADENING: 0.272 +... + +:PDOS_INFO: + :ATOM_TYPE: Al + :ATOMIC_NUMBER: 13 + :ATOM_INDEX: 0 + :ATOM_POSITION_CARTESIAN: [0. 0. 0.] + :ATOM_POSITION_FRACTIONAL: [0. 0. 0.] + :PDOS_UNIT: states/eV + :HEADER_FORMAT: (nl,m) + Energy(eV) (3s, m=0) (3p, m=-1) (3p, m=0) (3p, m=1) + 5.0000000000 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0600600601 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + ... +``` + + +## Python Class Interface + +In addition to the command-line interface, the PDOS calculation can also be accessed programmatically by importing the `PDOSCalculator` class. This allows users to customize workflows, post-process results, or integrate PDOS calculations into larger pipelines. + +## Example Usage: Al FCC System +```python +from calculate_pdos import PDOSCalculator + +# Example system: Al FCC +upf_fname_list = [ + './examples/Al_FCC/Al.upf', # Optional UPF file + # If no UPF files provided, program will use built-in generator +] + +output_fname = './examples/Al_FCC/Al.out' +static_fname = './examples/Al_FCC/Al.static' +eigen_fname = './examples/Al_FCC/Al.eigen' +psi_fname = './examples/Al_FCC/Al.psi' +out_dirname = './examples/Al_FCC/PDOS_output' + +# Initialize PDOSCalculator +pdos_calculator = PDOSCalculator( + upf_fname_list = upf_fname_list, # Optional: can be None for automatic generation + output_fname = output_fname, + eigen_fname = eigen_fname, + static_fname = static_fname, + psi_fname = psi_fname, + out_dirname = out_dirname, + r_cut_max = 15.0, # Optional: cutoff radius in Bohr + atomic_wave_function_tol = 1e-5, # Optional: tolerance for atomic wave functions + orthogonalize_atomic_orbitals = False, # Optional: whether to orthogonalize orbitals + is_relaxation = False, # Optional: whether from relaxation calculation + k_point_parallelization = True, # Optional: enable k-point parallelization +) + +# Run the PDOS calculation +E, PDOS, DOS = \ + pdos_calculator.run( + mu_PDOS = 0.2721140795, # Gaussian broadening width in eV + N_PDOS = 1000, # Number of energy points + min_E_plot = 5.0, # Minimum energy in eV (optional, auto-determined if None) + max_E_plot = 65.0, # Maximum energy in eV (optional, auto-determined if None) + sum_over_m_index = False, # Whether to sum over magnetic quantum number m + print_projection_data = False, # Whether to save projection data + ) + +# Some downstream analysis +print("E.shape = ", E.shape) # (N_PDOS,) +print("DOS.shape = ", DOS.shape) # (N_PDOS,) +print("PDOS.shape = ", PDOS.shape) # (N_PDOS, number_of_orbitals) +... + +# For selective atom calculation +E_single_atom, PDOS_single_atom, DOS_single_atom = \ + pdos_calculator.run_single_atom( + atom_type = "Al", # or atomic number 13 + atom_index_for_specified_atom_type = 0, # 0-indexed + mu_PDOS = 0.2721140795, + N_PDOS = 1000, + min_E_plot = 5.0, + max_E_plot = 65.0, + sum_over_m_index = False, + ) + +# Some downstream analysis +print("E_single_atom.shape = ", E_single_atom.shape) # (N_PDOS,) +print("DOS_single_atom.shape = ", DOS_single_atom.shape) # (N_PDOS,) +print("PDOS_single_atom.shape = ", PDOS_single_atom.shape) # (N_PDOS, number_of_orbitals_for_single_atom) +... + +``` \ No newline at end of file diff --git a/utils/pdos/__init__.py b/utils/pdos/__init__.py new file mode 100644 index 00000000..af68d2c0 --- /dev/null +++ b/utils/pdos/__init__.py @@ -0,0 +1,11 @@ +""" +PDOS Calculator Package + +This package provides functionality to calculate Projected Density of States (PDOS) +from SPARC output files. +""" + +from .calculate_pdos import PDOSCalculator + +__all__ = ["PDOSCalculator"] + diff --git a/utils/pdos/calculate_pdos.py b/utils/pdos/calculate_pdos.py new file mode 100644 index 00000000..ee046631 --- /dev/null +++ b/utils/pdos/calculate_pdos.py @@ -0,0 +1,4857 @@ + +""" +PDOS Calculator for SPARC Output Files + + This module provides functionality to calculate Projected Density of States (PDOS) + from SPARC (Spatial Partitioning of Atomic orbitals for Rapid Computation) output files. + + The calculator supports: + - Full system PDOS calculation for all atoms and orbitals + - Selective atom PDOS calculation for specific atoms + - Automatic atomic orbital generation or custom UPF file support + - K-point parallelization for large systems + - Multiple exchange-correlation functionals support + + @file calculate_pdos.py + @brief PDOS Calculator for SPARC output files + @authors Qihao Cheng + Shashikant Kumar + Phanish Suryanarayana + + Copyright (c) 2025 Material Physics & Mechanics Group, Georgia Tech. +""" + + +import os +import sys +import re +import shutil +import time +import argparse +import logging +import yaml +import traceback +import math +from pathlib import Path +from functools import partial + +from typing import List, Optional, Tuple, Dict, Any, Union, Callable +from dataclasses import dataclass, field + +import numpy as np +from scipy.linalg import fractional_matrix_power + +import warnings +warnings.filterwarnings('ignore', category=RuntimeWarning, message='invalid value encountered in divide') + + +# Regex patterns +SCIENTIFIC_NOTATION_PATTERN = r'[+-]?\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?' + +# Type check errors +NATOM_TYPE_NOT_INTEGER_ERROR = \ + "parameter natom_types must be an integer, get {} instead" +OUT_DIRNAME_NOT_STRING_ERROR = \ + "parameter out_dirname must be a string, get {} instead" +FNAME_NOT_STRING_ERROR = \ + "parameter fname must be a string, get {} instead" +SAVE_FNAME_NOT_STRING_ERROR = \ + "parameter save_fname must be a string, get {} instead" +MU_PDOS_NOT_FLOAT_ERROR = \ + "parameter mu_PDOS must be a float, get {} instead" +N_PDOS_NOT_INTEGER_ERROR = \ + "parameter N_PDOS must be an integer, get {} instead" +MIN_E_PLOT_NOT_FLOAT_ERROR = \ + "parameter min_E_plot must be a float, get {} instead" +MAX_E_PLOT_NOT_FLOAT_ERROR = \ + "parameter max_E_plot must be a float, get {} instead" +R_CUT_MAX_NOT_FLOAT_OR_LIST_ERROR = \ + "parameter r_cut_max must be a float or a list, get {} instead" +R_CUT_MAX_NUM_NOT_EQUAL_TO_NATOM_TYPES_ERROR = \ + "number of r_cut_max must be equal to the number of atom types, get {} instead" +ATOMIC_WAVE_FUNCTION_TOL_NOT_FLOAT_ERROR = \ + "parameter atomic_wave_function_tol must be a float, get {} instead" +ATOMIC_WAVE_FUNCTION_TOL_NOT_POSITIVE_ERROR = \ + "parameter atomic_wave_function_tol must be positive, get {} instead" +ORTHOGONALIZE_ATOMIC_ORBITALS_NOT_BOOL_ERROR = \ + "parameter orthogonalize_atomic_orbitals must be a bool, get {} instead" +RELAX_FLAG_NOT_INTEGER_ERROR = \ + "parameter relax_flag must be an integer, get {} instead" +RELAX_FLAG_NOT_VALID_ERROR = \ + "parameter relax_flag must be 1, 2, or 3, get {} instead" +K_POINT_PARALLELIZATION_NOT_BOOL_ERROR = \ + "parameter k_point_parallelization must be a bool, get {} instead" +K_POINT_FRACTIONAL_INPUT_NOT_NP_ARRAY_ERROR = \ + "parameter k_point_fractional must be a numpy array, get {} instead" + +# Boundary condition errors +BCX_NOT_D_OR_P_ERROR = \ + "parameter bcx must be either 'D' or 'P', get {} instead" +BCY_NOT_D_OR_P_ERROR = \ + "parameter bcy must be either 'D' or 'P', get {} instead" +BCZ_NOT_D_OR_P_ERROR = \ + "parameter bcz must be either 'D' or 'P', get {} instead" + + +ATOM_TYPE_NOT_FOUND_ERROR = \ + "parameter atom_type {} not found in the atom_species_list" +ATOM_TYPE_INDEX_NOT_INTEGER_ERROR = \ + "parameter atom_type_index must be an integer, get {} instead" +ATOM_TYPE_NOT_INTEGER_OR_STRING_ERROR = \ + "parameter atom type must be an integer or a string, get {} instead" +ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_NOT_INTEGER_ERROR = \ + "parameter atom_index_for_specified_atom_type must be an integer, get {} instead" +ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_NOT_FOUND_ERROR = \ + "parameter atom index {} for specified atom type {} not found" +ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_OUT_OF_BOUND_ERROR = \ + "parameter atom index {} for specified atom type {} is out of bound" +ATOM_TYPE_AND_ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_LENGTH_MISMATCH_ERROR = \ + "The length of atom_type and atom_index_for_specified_atom_type must be the same, get {} and {} instead" +ATOM_COUNT_LIST_NOT_LIST_ERROR = \ + "parameter atom_count_list must be a list, get type {} instead" + +# Atomic wave function generator check errors +ATOMIC_WAVE_FUNCTION_GENERATOR_NOT_CALLABLE_ERROR = \ + "parameter atomic_wave_function_generator must be a callable, get {} instead" +ATOMIC_WAVE_FUNCTION_GENERATOR_NOT_VALID_ERROR = \ + "parameter atomic_wave_function_generator is not valid, got error {}" +ATOMIC_WAVE_FUNCTION_GENERATOR_NO_UPF_FILES_PROVIDED_WARNING = \ + "WARNING: No UPF files provided, please provide the function to generate the atomic wave functions as instructed in the documentation." +ATOMIC_WAVE_FUNCTION_GENERATOR_NO_UPF_FILES_PROVIDED_ERROR = \ + "No UPF files provided, please provide the function to generate the atomic wave functions as instructed in the documentation." + +# Projection data from txt path check errors +LOAD_PROJECTION_DATA_FROM_TXT_PATH_NOT_STRING_ERROR = \ + "parameter load_projection_data_from_txt_path must be a string, get {} instead" +LOAD_PROJECTION_DATA_FROM_TXT_PATH_NOT_EXIST_ERROR = \ + "Data projections file not found at {}" + +# File existence check errors +FNAME_NOT_EXIST_ERROR = \ + "file {} does not exist" +OUTPUT_FNAME_NOT_EXIST_ERROR = \ + "output file {} does not exist" +EIGEN_FNAME_NOT_EXIST_ERROR = \ + "eigen file {} does not exist" +IS_RELAXATION_NOT_BOOL_ERROR = \ + "parameter is_relaxation must be a bool, get type {} instead" +STATIC_FNAME_NOT_EXIST_ERROR = \ + "static file {} does not exist" +GEOPT_FNAME_NOT_EXIST_ERROR = \ + "geopt file {} does not exist" +ION_FNAME_NOT_EXIST_ERROR = \ + "ion file {} does not exist" +ORBITAL_FNAME_NOT_EXIST_ERROR = \ + "orbital file {} does not exist" + +# Output file check errors +OUTPUT_FNAME_NOT_STRING_ERROR = \ + "output filename must be a string, get {} instead" +INVALID_LATTICE_VECTOR_FORMAT_ERROR = \ + "Invalid lattice vector format in line: {}" +LATVEC_SCALE_OR_CELL_NOT_FOUND_ERROR = \ + "LATVEC_SCALE or CELL not found in the output file, cannot determine the lattice type" +NUMBER_OF_ATOM_TYPES_NOT_EQUAL_TO_OUTPUT_FILE_ERROR = \ + "number of atom types must be equal to the number of atom types in the output file, get {} instead" +NUMBER_OF_ATOM_COUNTS_NOT_EQUAL_TO_OUTPUT_FILE_ERROR = \ + "number of atom counts must be equal to the number of atom types in the output file, get {} instead" +ATOM_TYPE_NOT_EQUAL_TO_OUTPUT_FILE_ERROR = \ + "atom type must be equal to the index of the atom type in the output file, get {} instead" + +XC_FUNCTIONAL_NOT_STRING_ERROR = \ + "parameter xc_functional must be a string, get {} instead" +XC_FUNCTIONAL_NOT_VALID_ERROR = \ + "parameter xc_functional must be a valid XC functional, get {} instead" + + +# UPF file check errors +UPF_FNAME_LIST_NOT_LIST_ERROR = \ + "parameter upf_fname_list must be a list, get {} instead" +UPF_FNAME_NUM_NOT_EQUAL_TO_NATOM_TYPES_ERROR = \ + "number of upf file names must be equal to the number of atom types, get {} instead" +UPF_FNAME_NOT_ENDING_WITH_UPF_ERROR = \ + "The upf file's name must end with .upf, get {} instead" +UPF_FNAME_NOT_STRING_ERROR = \ + "The upf file's name must be a string, get {} instead" +UPF_FNAME_NOT_EXIST_ERROR = \ + "The upf file {} does not exist" + +# Static / geopt file check errors +STATIC_FNAME_NOT_STRING_ERROR = \ + "The static filename must be a string, get {} instead" +GEOPT_FNAME_NOT_STRING_ERROR = \ + "The geopt filename must be a string, get {} instead" +GEOPT_FNAME_NOT_ENDING_WITH_GEOPT_ERROR = \ + "The geopt filename must end with .geopt, get {} instead" +ION_FNAME_NOT_STRING_ERROR = \ + "The ion filename must be a string, get {} instead" + +# Eigen file check errors +EIGEN_FNAME_NOT_STRING_ERROR = \ + "The eigen filename must be a string, get {} instead" +NUMBER_OF_KPOINTS_NOT_EQUAL_TO_EIGEN_FILE_ERROR = \ + "Expected {} weight indices, got {}" +KPOINT_NUMBER_NOT_EQUAL_TO_EIGEN_FILE_ERROR = \ + "Expected k-point number {}, got {}" +KPOINT_WEIGHTS_NOT_FOUND_ERROR = \ + "No k-point weights found for k-point {}" +EIGEN_FILE_NO_EIGENVALUES_AND_OCCUPATIONS_FOUND_ERROR = \ + "No eigenvalues and occupations found for k-point {} in line {}" + +# Orbital file check errors +ORBITAL_FNAME_NOT_STRING_ERROR = \ + "The psi filename must be a string, get {} instead" + +# Atom orbitals check errors +INVALID_ATOM_INPUT_ERROR = \ + "parameter atom_type_index must be an integer, get {} instead" +INDEX_MASK_DICT_INPUT_NOT_DICT_ERROR = \ + "parameter index_mask_dict must be a dict, get {} instead" +INDEX_MASK_AND_EFFECTIVE_GRID_POINT_POSITIONS_DICT_NOT_FOUND_ERROR = \ + "The (0,0,0) shift index is not in the index_mask_and_effective_grid_point_positions_dict" +ATOM_INDEX_MASK_AND_EFFECTIVE_GRID_POINT_POSITIONS_DICT_EMPTY_ERROR = \ + "The index_mask_and_effective_grid_point_positions_dict is empty, please call atom_wise_compute_index_mask_and_effective_grid_point_positions_dict() first." +PHI_ORBITAL_INPUT_NOT_PHI_ORBITAL_ERROR = \ + "parameter phi_orbital must be a PDOSCalculator.PhiOrbital, get {} instead" +PHI_ORBITALS_NOT_EQUAL_TO_EXPECTED_NUM_ERROR = \ + "Expected {} phi orbitals, got {} instead" + + +# Overlap matrix check errors +DV_NOT_FLOAT_ERROR = \ + "parameter dV must be a float, get {} instead" +ATOMS_INPUT_NOT_LIST_ERROR = \ + "parameter atoms must be a list, get {} instead" +ATOM_INPUT_NOT_ATOM_ERROR = \ + "Elements in the atoms list must be PDOSCalculator.Atom, get type {} instead" +ATOM_LIST_NOT_LIST_ERROR = \ + "parameter atom_list must be a list, get {} instead" +TWO_ATOMS_NOT_SAME_ERROR = \ + "The two atoms are not the same, the id for the two atoms are {} and {}" +TWO_ORBITALS_NOT_SAME_ERROR = \ + "The two orbitals are not the same, the id for the two orbitals are {} and {}" + + +# PDOS calculation check errors +INDEX_MASK_NOT_FOUND_ERROR = \ + "The index_mask is not found for the shifted unit cell ({}, {}, {})" +LATTICE_VECTOR_NOT_NORMALIZED_ERROR = \ + "Lattice vector direction {} is not normalized, norm = {}" + + +# Some typings +RCUT_MAX_TYPE = \ + Union[List[float], float] +ShiftIndexVectorType = \ + Tuple[int, int, int] +FractionalKPointVectorType = \ + Tuple[float, float, float] # (kx_frac, ky_frac, kz_frac) +ShiftIndexListType = \ + Union[List[int], List[List[int]]] # Shift index of each atom, depends on the type of self.r_cut_max, if the r_cut_max is a list, then the shift index is a list of list of integers, otherwise it is a list of integers +PhiValueDictType = \ + Dict[ShiftIndexVectorType, np.ndarray[float]] # (x_index_shift, y_index_shift, z_index_shift) -> phi_value +NormalizationFactorDictType = \ + Dict[FractionalKPointVectorType, float] # (kx_frac, ky_frac, kz_frac) -> normalization factor +TotalOrbitalsInUnitCellDictType = \ + Dict[FractionalKPointVectorType, np.ndarray[np.complex128]] # (kx_frac, ky_frac, kz_frac) -> total orbitals in the unit cell, size = (tot_grid_pt, ) +IndexMaskDictType = \ + Dict[ShiftIndexVectorType, Tuple[np.ndarray[bool], np.ndarray[float]]] # (x_index_shift, y_index_shift, z_index_shift) -> (index_mask, effective_grid_point_positions_array) +AtomicWaveFunctionGeneratorType = \ + Optional[Callable[[int], Tuple[np.ndarray[float], np.ndarray[float], np.ndarray[float], Dict[str, Any]]]] # atomic_number -> (r_array, orbitals, n_l_orbitals, info_dict) + +# Warning messages +GEOPT_FNAME_PROVIDED_BUT_IS_RELAXATION_FALSE_WARNING = \ + "WARNING: geopt_fname is provided, but is_relaxation is False, so geopt_fname will be ignored" +STATIC_FNAME_PROVIDED_BUT_IS_RELAXATION_TRUE_WARNING = \ + "WARNING: static_fname is provided, but is_relaxation is True, so static_fname will be ignored" +LATTICE_VECTOR_NOT_NORMALIZED_WARNING = \ + "WARNING: Lattice vector direction {} is not normalized, norm = {}" +LATVEC_SECTION_NOT_FOUND_WARNING = \ + "Warning: Parameter 'LATVEC' section not found in output file, trying to determine the lattice type from LATVEC_SCALE, perceed as the lattice is orthogonal" +NOT_ORTHOGONALIZE_ATOMIC_ORBITALS_OVERLAP_MATRIX_NOT_PRINTED_WARNING = \ + "WARNING: Since we are not to orthogonalize the atomic orbitals, the overlap matrix is not printed" + + +# PDOS output format +pdos_output_header_msg = \ +""" +:Description: +:Desc_PDOS: Projected density of states for each orbital. Unit=states/eV +:Desc_FERMI_LEVEL: Fermi level energy. Unit=eV +:Desc_BROADENING: Gaussian broadening parameter for DOS calculation. Unit=eV +:Desc_GRID_POINTS: Number of energy grid points for PDOS calculation +:Desc_MIN_E: Minimum energy for PDOS calculation. Unit=eV +:Desc_MAX_E: Maximum energy for PDOS calculation. Unit=eV +:Desc_BAND_NUM: Number of bands included in the calculation +:Desc_KPT_NUM: Number of k-points used in the calculation +:Desc_ATOM_TYPE_NUM: Number of atom types in the system +:Desc_TOT_ORBITALS: Total number of atomic orbitals +:Desc_PROJ_ORBITALS: Total number of projected orbitals +:Desc_VOLUME: Lattice unit cell volume. Unit=Bohr^3 +:Desc_CALCULATION_TIME: Total calculation time. Unit=seconds +:Desc_M_INDEX_SUMMED_OVER: Whether the m index is summed over +:Desc_ORTHOGONALIZE_ATOMIC_ORBITALS: Whether the atomic orbitals are orthogonalized +:Desc_ATOM_INDEX_FOR_PDOS: The index of the atom for which the PDOS is calculated +:Desc_PDOS_INFO: The information of the PDOS + :Desc_ATOM_TYPE: The type of the atom + :Desc_ATOMIC_NUMBER: The atomic number of the atom + :Desc_ATOM_INDEX: The index of the atom + :Desc_ATOM_POSITION_CARTESIAN: The position of the atom in Cartesian coordinates + :Desc_ATOM_POSITION_FRACTIONAL: The fractional position of the atom + :Desc_PDOS_UNIT: The unit of the PDOS value + :Desc_HEADER_FORMAT: The format of the header + + +:BASIC_INFO: +:FERMI_LEVEL: {fermi_level:.3f} +:BROADENING: {broadening:.3f} +:GRID_POINTS: {grid_points} +:MIN_E: {min_energy:.3f} +:MAX_E: {max_energy:.3f} +:BAND_NUM: {bands} +:KPT_NUM: {kpoints} +:ATOM_TYPE_NUM: {atom_type_num} +:TOT_ORBITALS: {orbitals} +:PROJ_ORBITALS: {proj_orbitals} +:VOLUME: {volume:.3f} +:CALCULATION_TIME: {calculation_time:.3f} +:M_INDEX_SUMMED_OVER: {m_index_summed_over} +:ORTHOGONALIZE_ATOMIC_ORBITALS: {orthogonalize_atomic_orbitals} +:ATOM_INDEX_FOR_PDOS: {atom_index_for_pdos} + + +""" + +pdos_info_msg = \ +""" +:PDOS_INFO: + :ATOM_TYPE: {atom_type} + :ATOMIC_NUMBER: {atomic_number} + :ATOM_INDEX: {atom_index} + :ATOM_POSITION_CARTESIAN: {atom_position_cartesian} + :ATOM_POSITION_FRACTIONAL: {atom_position_fractional} + :PDOS_UNIT: {pdos_unit} + :HEADER_FORMAT: {header_format} +""" + + + + +def gauss_distribution(x, s): + return np.exp(-x**2 / (s ** 2)) / (s * np.sqrt(np.pi)) + + +def _compute_pdos_dos( + eig_eV, # shape (band, kpt), in eV + DATA_projections, # list/array length K, each element (band, M) complex coefficients P_{n,k,mu} + kpt_wts_store, # shape (kpt,) + mu_eV, # broadening parameter, in eV + N_PDOS, # number of energy grid points + min_E_plot, + max_E_plot, + + spin_deg=2.0, # spin degeneracy factor + kpt_mesh_shape=None # if need to keep the MATLAB's / (kpt1*kpt2*kpt3), pass a (kpt1,kpt2,kpt3) + ): + """ + Return: + E: (N,) eV + PDOS_plot: (N, M) projected DOS with atomic orbitals as columns + DOS: (N,) total DOS + """ + bands, K = eig_eV.shape + # assemble P as (K, band, M) + # print("DATA_projections shape = ", DATA_projections.shape) + # print("mean of DATA_projections = ", np.mean(DATA_projections)) + + P_list = [np.asarray(Pk) for Pk in DATA_projections] # each (band, M) + M = P_list[0].shape[1] + P = np.stack(P_list, axis=0) # (K, band, M) + + # energy grid + if (min_E_plot is None) and (max_E_plot is None): + Emin = np.min(eig_eV) - 5.0 * mu_eV + Emax = np.max(eig_eV) + 5.0 * mu_eV + else: + Emin = min_E_plot + Emax = max_E_plot + + E = np.linspace(Emin, Emax, N_PDOS) + + # accumulate PDOS + PDOS_plot = np.zeros((N_PDOS, M), dtype=float) + DOS = np.zeros((N_PDOS,), dtype=float) + + for i in range(K): + lam = eig_eV[:, i] # (band,) + w = float(kpt_wts_store[i]) + G = gauss_distribution(E[:, None] - lam[None, :], mu_eV) # (N, band) + + # PDOS contribution: G (N×band) × |P|^2 (band×M) → (N×M) + W = np.abs(P[i])**2 # (band, M) + PDOS_plot += w * (G @ W) + + # DOS contribution: each band has a Gaussian, weight w + DOS += w * np.sum(G, axis=1) + + # normalization + total_w = np.sum(kpt_wts_store) + PDOS_plot *= (spin_deg / total_w) + DOS *= (spin_deg / total_w) + + return E, PDOS_plot, DOS + + +def _find_last_line_index(keyword, lines: List[str]): + for i in reversed(range(len(lines))): + if keyword in lines[i]: + return i + return -1 + + +def read_psi(filename, endian="<", verbose=True): + """ + Read the binary wave function file (.psi) in the same layout as the MATLAB version. + + Parameters + ---------- + filename : str + file path + endian : str + byte order, default is little endian("<"); if the file is written by a big endian machine, use ">" + verbose : bool + whether to print the information consistent with the MATLAB version + + Returns + ------- + psi : np.ndarray + array of shape (Nd * Nspinor_eig, nband, nkpt), + it is arranged as (spinor-blocked, band, kpt) + header : dict + header information (Nx, Ny, Nz, Nd, dx, dy, dz, dV, Nspinor_eig, isGamma, nspin, nkpt, nband) + per_band_meta : list[dict] + metadata for each (kpt, band): spin_index, kpt_index, kpt_vec(3,), band_indx + the index order is outer loop of kpt, inner loop of band + """ + def _read(f, dtype, count=1): + # read count elements from the file, return a numpy array + dt = np.dtype(dtype).newbyteorder(endian) + nbytes = dt.itemsize * count + buf = f.read(nbytes) + if len(buf) != nbytes: + raise EOFError("Unexpected end of file while reading binary data.") + return np.frombuffer(buf, dtype=dt, count=count) + + with open(filename, "rb") as f: + Nx = int(_read(f, np.int32)[0]) + Ny = int(_read(f, np.int32)[0]) + Nz = int(_read(f, np.int32)[0]) + Nd = int(_read(f, np.int32)[0]) + + dx = float(_read(f, np.float64)[0]) + dy = float(_read(f, np.float64)[0]) + dz = float(_read(f, np.float64)[0]) + dV = float(_read(f, np.float64)[0]) + + Nspinor_eig = int(_read(f, np.int32)[0]) + isGamma = int(_read(f, np.int32)[0]) + nspin = int(_read(f, np.int32)[0]) + nkpt = int(_read(f, np.int32)[0]) + nband = int(_read(f, np.int32)[0]) + + assert Nd == Nx * Ny * Nz, "Nd != Nx*Ny*Nz" + + if verbose: + print(f" Nx {Nx}, Ny {Ny}, Nz {Nz}\n" + f" dx {dx},dy {dy}, dz {dz}\n" + f" dV {dV}, isgamma {isGamma}, Nspinor_eig {Nspinor_eig}\n" + f" nspin {nspin}, nkpt {nkpt}, nband {nband}") + + psi = np.zeros((Nd * Nspinor_eig, nband, nkpt), dtype=np.complex128 if not isGamma else np.float64) + per_band_meta = [] + + for kpt in range(nkpt): + for band in range(nband): + spin_index = int(_read(f, np.int32)[0]) + kpt_index = int(_read(f, np.int32)[0]) + kpt_vec = _read(f, np.float64, 3).astype(float) + band_indx = int(_read(f, np.int32)[0]) + + if verbose: + print(f"extracting spin_indx {spin_index}, kpt_indx {kpt_index}, " + f"kpt_vec {kpt_vec[0]:.6f} {kpt_vec[1]:.6f} {kpt_vec[2]:.6f},band_indx {band_indx}") + + per_band_meta.append({ + "spin_index": spin_index, + "kpt_index": kpt_index, + "kpt_vec": kpt_vec, + "band_indx": band_indx, + }) + + # fill psi + for spinor in range(Nspinor_eig): + start = spinor * Nd + end = (spinor + 1) * Nd + + if isGamma: + # real number: fread([1 Nd],'double')' -> column vector in MATLAB + arr = _read(f, np.float64, Nd) + # directly put the column vector into psi + psi[start:end, band, kpt] = arr + else: + # complex number: fread([2 Nd],'double') -> 2×Nd(column-major) in MATLAB, then complex(row1, row2).' + raw = _read(f, np.float64, 2 * Nd) + # restore to (2, Nd) column-major shape (simulate MATLAB column-major) + raw = np.reshape(raw, (2, Nd), order='F') + arr = raw[0, :] + 1j * raw[1, :] + psi[start:end, band, kpt] = arr + + header = dict( + Nx=Nx, Ny=Ny, Nz=Nz, Nd=Nd, + dx=dx, dy=dy, dz=dz, dV=dV, + Nspinor_eig=Nspinor_eig, isGamma=isGamma, + nspin=nspin, nkpt=nkpt, nband=nband + ) + return psi, header, per_band_meta + + + +def get_psp_fname_list(output_fname : str): + assert isinstance(output_fname, str), OUTPUT_FNAME_NOT_STRING_ERROR.format(type(output_fname)) + assert os.path.exists(output_fname), OUTPUT_FNAME_NOT_EXIST_ERROR.format(output_fname) + + output_dir = Path(output_fname).parent + + with open(output_fname, 'r') as f: + lines = f.read().splitlines() + + psp_fname_list = [] + for line in lines: + if "Pseudopotential" in line.split(): + psp_fname_list.append(os.path.join(output_dir, line.split()[-1])) + + return psp_fname_list + + +def render_progress(completed: int, total: int, start_ts: float, bar_len: int = 28) -> str: + """Render a single progress bar""" + pct = completed / total if total else 0.0 + filled = int(pct * bar_len) + bar = "#" * filled + "-" * (bar_len - filled) + elapsed = time.time() - start_ts + rate = completed / elapsed if elapsed > 0 else 0.0 + eta = (total - completed) / rate if rate > 0 else math.inf + eta_str = f"{eta:>6.1f}s" if math.isfinite(eta) else " inf s" + return f"[{bar}] {completed}/{total} ({pct:>6.2%}) | elapsed {elapsed:>6.1f}s | eta {eta_str}" + + + +def spherical_harmonics(X, Y, Z, l, m): + """ + RealSphericalHarmonics calculates real spherical harmonics + + Parameters + ---------- + X : np.ndarray[float] + The x coordinates of the positions + Y : np.ndarray[float] + The y coordinates of the positions + Z : np.ndarray[float] + The z coordinates of the positions + l : int + The azimuthal quantum number + m : int + The magnetic quantum number + + Returns + ------- + Ylm : np.ndarray[float] + The real spherical harmonics at the given positions (X,Y,Z) + + """ + assert isinstance(l, int), "l must be an integer" + assert isinstance(m, int), "m must be an integer" + assert l >= 0, "l must be greater than or equal to 0" + assert -l <= m <= l, "m must be between -l and l" + + if l > 2: + raise ValueError("Only less than or equal to 2 supported.") + + r = np.sqrt(X**2 + Y**2 + Z**2) + + if l == 0: + # l=0 + C00 = 0.282094791773878 # 0.5*sqrt(1/pi) + Ylm = C00 * np.ones_like(X) + + elif l == 1: + # l=1 + C1m1 = 0.488602511902920 # sqrt(3/(4*pi)) + C10 = 0.488602511902920 # sqrt(3/(4*pi)) + C1p1 = 0.488602511902920 # sqrt(3/(4*pi)) + if m == -1: + Ylm = C1m1 * (Y / r) + elif m == 0: + Ylm = C10 * (Z / r) + elif m == 1: + Ylm = C1p1 * (X / r) + + elif l == 2: + # l=2 + C2m2 = 1.092548430592079 # 0.5*sqrt(15/pi) + C2m1 = 1.092548430592079 # 0.5*sqrt(15/pi) + C20 = 0.315391565252520 # 0.25*sqrt(5/pi) + C2p1 = 1.092548430592079 # 0.5*sqrt(15/pi) + C2p2 = 0.546274215296040 # 0.25*sqrt(15/pi) + + r2 = r * r + if m == -2: + Ylm = C2m2 * (X * Y) / r2 + elif m == -1: + Ylm = C2m1 * (Y * Z) / r2 + elif m == 0: + Ylm = C20 * (-X**2 - Y**2 + 2*Z**2) / r2 + elif m == 1: + Ylm = C2p1 * (Z * X) / r2 + elif m == 2: + Ylm = C2p2 * (X**2 - Y**2) / r2 + + elif l == 3: + C3m3 = 0.590043589926644; # 0.25*sqrt(35/(2*pi)) + C3m2 = 2.890611442640554; # 0.5*sqrt(105/(pi)) + C3m1 = 0.457045799464466; # 0.25*sqrt(21/(2*pi)) + C30 = 0.373176332590115; # 0.25*sqrt(7/pi) + C3p1 = 0.457045799464466; # 0.25*sqrt(21/(2*pi)) + C3p2 = 1.445305721320277; # 0.25*sqrt(105/(pi)) + C3p3 = 0.590043589926644; # 0.25*sqrt(35/(2*pi)) + r3 = r**3 + if m == -3: + Ylm = C3m3*(3*X**2 - Y**2)*Y/r3 + elif m == -2: + Ylm = C3m2*(X*Y*Z)/r3 + elif m == -1: + Ylm = C3m1*Y*(4*Z**2 - X**2 - Y**2)/r3 + elif m == 0: + Ylm = C30*Z*(2*Z**2-3*X**2-3*Y**2)/r3 + elif m == 1: + Ylm = C3p1*X*(4*Z**2 - X**2 - Y**2)/r3 + elif m == 2: + Ylm = C3p2*Z*(X**2 - Y**2)/r3 + elif m == 3: + Ylm = C3p3*X*(X**2-3*Y**2)/r3 + + elif l == 4: + r4 = r**4 + if m == -4: + Ylm = (3.0/4.0)*np.sqrt(35.0/np.pi)*(X*Y*(X**2 - Y**2))/r4 + elif m == -3: + Ylm = (3.0/4.0)*np.sqrt(35.0/(2.0*np.pi))*((3.0*X**2 - Y**2)*Y*Z)/r4 + elif m == -2: + Ylm = (3.0/4.0)*np.sqrt(5.0/np.pi)*(X*Y*(7.0*Z**2 - r**2))/r4 + elif m == -1: + Ylm = (3.0/4.0)*np.sqrt(5.0/(2.0*np.pi))*(Y*Z*(7.0*Z**2 - 3.0*r**2))/r4 + elif m == 0: + Ylm = (3.0/16.0)*np.sqrt(1.0/np.pi)*(35.0*Z**4 - 30.0*Z**2*r**2 + 3.0*r**4)/r4 + elif m == 1: + Ylm = (3.0/4.0)*np.sqrt(5.0/(2.0*np.pi))*(X*Z*(7.0*Z**2 - 3.0*r**2))/r4 + elif m == 2: + Ylm = (3.0/8.0)*np.sqrt(5.0/np.pi)*((X**2 - Y**2)*(7.0*Z**2 - r**2))/r4 + elif m == 3: + Ylm = (3.0/4.0)*np.sqrt(35.0/(2.0*np.pi))*((X**2 - 3.0*Y**2)*X*Z)/r4 + elif m == 4: + Ylm = (3.0/16.0)*np.sqrt(35.0/np.pi)*((X**2*(X**2 - 3.0*Y**2) - Y**2*(3.0*X**2 - Y**2)))/r4 + + elif l == 5: + r5 = r**5 + p = np.sqrt(X**2 + Y**2) + p4 = p**4 + if m == -5: + Ylm = (3.0*np.sqrt(2.0*77.0/np.pi)/32.0)*(8.0*X**4*Y - 4.0*X**2*Y**3 + 4.0*Y**5 - 3.0*Y*p4)/r5 + elif m == -4: + Ylm = (3.0/16.0)*np.sqrt(385.0/np.pi)*(4.0*X**3*Y - 4.0*X*Y**3)*Z/r5 + elif m == -3: + Ylm = (np.sqrt(2.0*385.0/np.pi)/32.0)*((3.0*Y*p*p - 4.0*Y**3)*(9.0*Z**2 - r**2))/r5 + elif m == -2: + Ylm = (1.0/8.0)*np.sqrt(1155.0/np.pi)*(2.0*X*Y*(3.0*Z**3 - Z*r**2))/r5 + elif m == -1: + Ylm = (1.0/16.0)*np.sqrt(165.0/np.pi)*Y*(21.0*Z**4 - 14.0*r**2*Z**2 + r**4)/r5 + elif m == 0: + Ylm = (1.0/16.0)*np.sqrt(11.0/np.pi)*(63.0*Z**5 - 70.0*Z**3*r**2 + 15.0*Z*r**4)/r5 + elif m == 1: + Ylm = (1.0/16.0)*np.sqrt(165.0/np.pi)*X*(21.0*Z**4 - 14.0*r**2*Z**2 + r**4)/r5 + elif m == 2: + Ylm = (1.0/8.0)*np.sqrt(1155.0/np.pi)*((X**2 - Y**2)*(3.0*Z**3 - r**2*Z))/r5 + elif m == 3: + Ylm = (np.sqrt(2.0*385.0/np.pi)/32.0)*((4.0*X**3 - 3.0*p*p*X)*(9.0*Z**2 - r**2))/r5 + elif m == 4: + Ylm = (3.0/16.0)*np.sqrt(385.0/np.pi)*(4.0*(X**4 + Y**4) - 3.0*p4)*Z/r5 + elif m == 5: + Ylm = (3.0*np.sqrt(2.0)/32.0)*np.sqrt(77.0/np.pi)*(4.0*X**5 + 8.0*X*Y**4 - 4.0*X**3*Y**2 - 3.0*X*p4)/r5 + + elif l == 6: + r6 = r**6 + p = np.sqrt(X**2 + Y**2) + p2 = p*p + p4 = p2*p2 + if m == -6: + Ylm = (np.sqrt(2.0*3003.0/np.pi)/64.0)*(12.0*X**5*Y + 12.0*X*Y**5 - 8.0*X**3*Y**3 - 6.0*X*Y*p4)/r6 + elif m == -5: + Ylm = (3.0/32.0)*np.sqrt(2.0*1001.0/np.pi)*(8.0*X**4*Y - 4.0*X**2*Y**3 + 4.0*Y**5 - 3.0*Y*p4)*Z/r6 + elif m == -4: + Ylm = (3.0/32.0)*np.sqrt(91.0/np.pi)*(4.0*X**3*Y - 4.0*X*Y**3)*(11.0*Z**2 - r**2)/r6 + elif m == -3: + Ylm = (np.sqrt(2.0*1365.0/np.pi)/32.0)*(-4.0*Y**3 + 3.0*Y*p2)*(11.0*Z**3 - 3.0*Z*r**2)/r6 + elif m == -2: + Ylm = (np.sqrt(2.0*1365.0/np.pi)/64.0)*(2.0*X*Y)*(33.0*Z**4 - 18.0*Z**2*r**2 + r**4)/r6 + elif m == -1: + Ylm = (np.sqrt(273.0/np.pi)/16.0)*Y*(33.0*Z**5 - 30.0*Z**3*r**2 + 5.0*Z*r**4)/r6 + elif m == 0: + Ylm = (np.sqrt(13.0/np.pi)/32.0)*(231.0*Z**6 - 315.0*Z**4*r**2 + 105.0*Z**2*r**4 - 5.0*r**6)/r6 + elif m == 1: + Ylm = (np.sqrt(273.0/np.pi)/16.0)*X*(33.0*Z**5 - 30.0*Z**3*r**2 + 5.0*Z*r**4)/r6 + elif m == 2: + Ylm = (np.sqrt(2.0*1365.0/np.pi)/64.0)*(X**2 - Y**2)*(33.0*Z**4 - 18.0*Z**2*r**2 + r**4)/r6 + elif m == 3: + Ylm = (np.sqrt(2.0*1365.0/np.pi)/32.0)*(4.0*X**3 - 3.0*X*p2)*(11.0*Z**3 - 3.0*Z*r**2)/r6 + elif m == 4: + Ylm = (3.0/32.0)*np.sqrt(91.0/np.pi)*(4.0*X**4 + 4.0*Y**4 - 3.0*p4)*(11.0*Z**2 - r**2)/r6 + elif m == 5: + Ylm = (3.0/32.0)*np.sqrt(2.0*1001.0/np.pi)*(4.0*X**5 + 8.0*X*Y**4 - 4.0*X**3*Y**2 - 3.0*X*p4)*Z/r6 + elif m == 6: + Ylm = (np.sqrt(2.0*3003.0/np.pi)/64.0)*(4.0*X**6 - 4.0*Y**6 + 12.0*X**2*Y**4 - 12.0*X**4*Y**2 + 3.0*Y**2*p4 - 3.0*X**2*p4)/r6 + + else: + # Shouldn't reach here due to the l>6 check + raise ValueError("Only less than or equal to 6 supported.") + + if l > 0: + Ylm[r < 1e-9] = 0. + + return Ylm + + +def atomic_number_to_name(atomic_number): + if atomic_number == 1: return "H" + elif atomic_number == 2: return "He" + elif atomic_number == 3: return "Li" + elif atomic_number == 4: return "Be" + elif atomic_number == 5: return "B" + elif atomic_number == 6: return "C" + elif atomic_number == 7: return "N" + elif atomic_number == 8: return "O" + elif atomic_number == 9: return "F" + elif atomic_number == 10: return "Ne" + elif atomic_number == 11: return "Na" + elif atomic_number == 12: return "Mg" + elif atomic_number == 13: return "Al" + elif atomic_number == 14: return "Si" + elif atomic_number == 15: return "P" + elif atomic_number == 16: return "S" + elif atomic_number == 17: return "Cl" + elif atomic_number == 18: return "Ar" + elif atomic_number == 19: return "K" + elif atomic_number == 20: return "Ca" + elif atomic_number == 21: return "Sc" + elif atomic_number == 22: return "Ti" + elif atomic_number == 23: return "V" + elif atomic_number == 24: return "Cr" + elif atomic_number == 25: return "Mn" + elif atomic_number == 26: return "Fe" + elif atomic_number == 27: return "Co" + elif atomic_number == 28: return "Ni" + elif atomic_number == 29: return "Cu" + elif atomic_number == 30: return "Zn" + elif atomic_number == 31: return "Ga" + elif atomic_number == 32: return "Ge" + elif atomic_number == 33: return "As" + elif atomic_number == 34: return "Se" + elif atomic_number == 35: return "Br" + elif atomic_number == 36: return "Kr" + elif atomic_number == 37: return "Rb" + elif atomic_number == 38: return "Sr" + elif atomic_number == 39: return "Y" + elif atomic_number == 40: return "Zr" + elif atomic_number == 41: return "Nb" + elif atomic_number == 42: return "Mo" + elif atomic_number == 43: return "Tc" + elif atomic_number == 44: return "Ru" + elif atomic_number == 45: return "Rh" + elif atomic_number == 46: return "Pd" + elif atomic_number == 47: return "Ag" + elif atomic_number == 48: return "Cd" + elif atomic_number == 49: return "In" + elif atomic_number == 50: return "Sn" + elif atomic_number == 51: return "Sb" + elif atomic_number == 52: return "Te" + elif atomic_number == 53: return "I" + elif atomic_number == 54: return "Xe" + elif atomic_number == 55: return "Cs" + elif atomic_number == 56: return "Ba" + elif atomic_number == 57: return "La" + elif atomic_number == 58: return "Ce" + elif atomic_number == 59: return "Pr" + elif atomic_number == 60: return "Nd" + elif atomic_number == 61: return "Pm" + elif atomic_number == 62: return "Sm" + elif atomic_number == 63: return "Eu" + elif atomic_number == 64: return "Gd" + elif atomic_number == 65: return "Tb" + elif atomic_number == 66: return "Dy" + elif atomic_number == 67: return "Ho" + elif atomic_number == 68: return "Er" + elif atomic_number == 69: return "Tm" + elif atomic_number == 70: return "Yb" + elif atomic_number == 71: return "Lu" + elif atomic_number == 72: return "Hf" + elif atomic_number == 73: return "Ta" + elif atomic_number == 74: return "W" + elif atomic_number == 75: return "Re" + elif atomic_number == 76: return "Os" + elif atomic_number == 77: return "Ir" + elif atomic_number == 78: return "Pt" + elif atomic_number == 79: return "Au" + elif atomic_number == 80: return "Hg" + elif atomic_number == 81: return "Tl" + elif atomic_number == 82: return "Pb" + elif atomic_number == 83: return "Bi" + elif atomic_number == 84: return "Po" + elif atomic_number == 85: return "At" + elif atomic_number == 86: return "Rn" + elif atomic_number == 87: return "Fr" + elif atomic_number == 88: return "Ra" + elif atomic_number == 89: return "Ac" + elif atomic_number == 90: return "Th" + elif atomic_number == 91: return "Pa" + elif atomic_number == 92: return "U" + elif atomic_number == 93: return "Np" + else: + raise ValueError(f"Atomic number {atomic_number} is not supported") + + +def name_to_atomic_number(name: str) -> int: + if name == "H": return "01" + elif name == "He": return "02" + elif name == "Li": return "03" + elif name == "Be": return "04" + elif name == "B": return "05" + elif name == "C": return "06" + elif name == "N": return "07" + elif name == "O": return "08" + elif name == "F": return "09" + elif name == "Ne": return "10" + elif name == "Na": return "11" + elif name == "Mg": return "12" + elif name == "Al": return "13" + elif name == "Si": return "14" + elif name == "P": return "15" + elif name == "S": return "16" + elif name == "Cl": return "17" + elif name == "Ar": return "18" + elif name == "K": return "19" + elif name == "Ca": return "20" + elif name == "Sc": return "21" + elif name == "Ti": return "22" + elif name == "V": return "23" + elif name == "Cr": return "24" + elif name == "Mn": return "25" + elif name == "Fe": return "26" + elif name == "Co": return "27" + elif name == "Ni": return "28" + elif name == "Cu": return "29" + elif name == "Zn": return "30" + elif name == "Ga": return "31" + elif name == "Ge": return "32" + elif name == "As": return "33" + elif name == "Se": return "34" + elif name == "Br": return "35" + elif name == "Kr": return "36" + elif name == "Rb": return "37" + elif name == "Sr": return "38" + elif name == "Y": return "39" + elif name == "Zr": return "40" + elif name == "Nb": return "41" + elif name == "Mo": return "42" + elif name == "Tc": return "43" + elif name == "Ru": return "44" + elif name == "Rh": return "45" + elif name == "Pd": return "46" + elif name == "Ag": return "47" + elif name == "Cd": return "48" + elif name == "In": return "49" + elif name == "Sn": return "50" + elif name == "Sb": return "51" + elif name == "Te": return "52" + elif name == "I": return "53" + elif name == "Xe": return "54" + elif name == "Cs": return "55" + elif name == "Ba": return "56" + elif name == "La": return "57" + elif name == "Ce": return "58" + elif name == "Pr": return "59" + elif name == "Nd": return "60" + elif name == "Pm": return "61" + elif name == "Sm": return "62" + elif name == "Eu": return "63" + elif name == "Gd": return "64" + elif name == "Tb": return "65" + elif name == "Dy": return "66" + elif name == "Ho": return "67" + elif name == "Er": return "68" + elif name == "Tm": return "69" + elif name == "Yb": return "70" + elif name == "Lu": return "71" + elif name == "Hf": return "72" + elif name == "Ta": return "73" + elif name == "W": return "74" + elif name == "Re": return "75" + elif name == "Os": return "76" + elif name == "Ir": return "77" + elif name == "Pt": return "78" + elif name == "Au": return "79" + elif name == "Hg": return "80" + elif name == "Tl": return "81" + elif name == "Pb": return "82" + elif name == "Bi": return "83" + elif name == "Po": return "84" + elif name == "At": return "85" + elif name == "Rn": return "86" + elif name == "Fr": return "87" + elif name == "Ra": return "88" + elif name == "Ac": return "89" + elif name == "Th": return "90" + elif name == "Pa": return "91" + elif name == "U": return "92" + elif name == "Np": return "93" + else: + raise ValueError(f"Atomic number {name} is not supported") + + +def number_to_spdf(number: int) -> str: + assert number in [0, 1, 2, 3, 4, 5], "number must be in [0, 1, 2, 3, 4, 5]" + return { + 0: "s", + 1: "p", + 2: "d", + 3: "f", + 4: "g", + 5: "h", + }[number] + + +def get_default_generator_for_atomic_wave_function(xc_functional, psp_file_path): + """ + Get default generator for atomic wave functions using AtomicDFTSolver. + + This function creates a generator that uses AtomicDFTSolver to compute + atomic wave functions for a given atomic number. + + Args: + XC_functional: Exchange-correlation functional name + psp_dir_path: Path to pseudopotential directory + """ + + assert xc_functional in ['LDA_PW', 'LDA_PZ', 'GGA_PBE', 'HF', 'PBE0', 'SCAN','RSCAN','R2SCAN'], XC_FUNCTIONAL_NOT_VALID_ERROR.format(xc_functional) + assert os.path.exists(psp_file_path), "psp_file_path {} does not exist".format(psp_file_path) + + # Add parent directory to path in order to import AtomicDFTSolver + parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + if parent_dir not in sys.path: + sys.path.insert(0, parent_dir) + try: + from atom.solver import AtomicDFTSolver + except ImportError: + raise ImportError("AtomicDFTSolver class is not found in the path. Make sure you have place the atom folder in the path {}".format(parent_dir)) + + psp_dir_path = os.path.dirname(psp_file_path) + psp_file_name = os.path.basename(psp_file_path) + + def generator(atomic_number: int): + print(f"\t Generating atomic wave function for atomic number {atomic_number}") + atomic_dft_solver = AtomicDFTSolver( + atomic_number = atomic_number, + xc_functional = xc_functional, + psp_dir_path = psp_dir_path, + psp_file_name = psp_file_name, + all_electron_flag = False, + print_debug = False, + ) + + results = atomic_dft_solver.solve() + + grid = results['uniform_grid'] + orbitals = results['orbitals_on_uniform_grid'] + occupation_info = results['occupation_info'] + info_dict = results + + n_l_orbitals = np.zeros((2, occupation_info.n_states)) + n_l_orbitals[:, 0] = occupation_info.occ_n + n_l_orbitals[:, 1] = occupation_info.occ_l + return grid, orbitals, n_l_orbitals, info_dict + + return generator + + + +_G = {} + +def _shm_from_ndarray(arr: np.ndarray): + """Create shared memory from ndarray; return (meta, owner_shm).""" + from multiprocessing import shared_memory + shm = shared_memory.SharedMemory(create=True, size=arr.nbytes) + view = np.ndarray(arr.shape, dtype=arr.dtype, buffer=shm.buf) + view[:] = arr # copy once + meta = {"name": shm.name, "shape": arr.shape, "dtype": str(arr.dtype)} + return meta, shm # remember to close+unlink at the end + + +def _ndarray_from_shm(meta): + """Attach to shared memory and return (shm, ndarray view).""" + + from multiprocessing import shared_memory + shm = shared_memory.SharedMemory(name=meta["name"]) + view = np.ndarray(meta["shape"], dtype=np.dtype(meta["dtype"]), buffer=shm.buf) + return shm, view + + + +def _init_worker_for_single_atom(psi_meta, I_indices, kpts_store, latvec, latvec_inv, + is_orthogonal_lattice, Lx, Ly, Lz, atom_packed, atoms, + dV, mutiply_weights, start_idx, end_idx, kpt_num): + """Initializer for single atom projection worker""" + psi_shm, psi_view = _ndarray_from_shm(psi_meta) + _G["psi_shm"] = psi_shm + _G["psi_total"] = psi_view + _G["I_indices"] = I_indices + _G["kpts_store"] = kpts_store + _G["latvec"] = latvec + _G["latvec_inv"] = latvec_inv + _G["is_orthogonal_lattice"] = is_orthogonal_lattice + _G["Lx"], _G["Ly"], _G["Lz"] = Lx, Ly, Lz + _G["atoms_packed"] = atom_packed # packed single atom data + _G["atoms"] = atoms # full atoms list for calculate_orbital_weights + _G["dV"] = dV + _G["mutiply_weights"] = mutiply_weights + _G["start_idx"] = start_idx + _G["end_idx"] = end_idx + _G["kpt_num"] = kpt_num + + +# ===== Unified worker for complete k-point processing (overlap + projection) ===== +def _process_single_kpoint_complete_worker(kpt_index: int): + """ + Unified worker function that processes a complete k-point: + 1. Compute overlap matrix or orbital weights + 2. Compute S^(-1/2) or w^(-1/2) + 3. Compute projection + 4. Apply orthogonalization/weights + Returns the final P_single_kpt_array + + This is the parallel version of the inner k-point loop in sequential version. + """ + import numpy as np + from scipy.linalg import fractional_matrix_power + + psi_total = _G["psi_total"] + I_indices = _G["I_indices"] + kpts_store = _G["kpts_store"] + atoms = _G["atoms"] + dV = _G["dV"] + orthogonalize = _G["orthogonalize_atomic_orbitals"] + mutiply_weights = _G["mutiply_weights"] + out_dirname = _G.get("out_dirname", None) + print_overlap = _G.get("print_overlap_matrix", False) + tot_orbital_num = _G.get("tot_orbital_num", 0) + kpt_num = _G.get("kpt_num", 0) + + # Get k-point fractional coordinates + kx_frac = kpts_store[kpt_index, 0] + ky_frac = kpts_store[kpt_index, 1] + kz_frac = kpts_store[kpt_index, 2] + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]) + + # Get the wavefunction + psi_kpt = psi_total[:, :, kpt_index] + perm = I_indices[:, kpt_index].astype(int) + psi_kpt = psi_kpt[:, perm] # (tot_grid_pt, band_num) + band_num = psi_kpt.shape[1] + + # ===== Step 1: Compute overlap matrix or orbital weights (reuse classmethod) ===== + if orthogonalize: + save_fname = None + if print_overlap and out_dirname is not None: + save_fname = out_dirname + f"/overlap_matrix_kpt_{kpt_index}.txt" + + _overlap_matrix = PDOSCalculator.calculate_overlap_matrix( + atoms=atoms, + dV=dV, + k_point_fractional=k_point_fractional, + save_fname=save_fname, + ) + _S_inv_sqrt = fractional_matrix_power(_overlap_matrix, -0.5) + else: + _orbital_weights = PDOSCalculator.calculate_orbital_weights( + atoms=atoms, + dV=dV, + k_point_fractional=k_point_fractional, + ) + _w_inv_sqrt = _orbital_weights ** (-0.5) + + # ===== Step 2: Compute projection ===== + P_single_kpt_array = np.zeros((band_num, tot_orbital_num), dtype=np.complex128) + + orbital_index = 0 + for atom in atoms: + for orbital in atom.phi_orbitals_list: + # Construct total orbital in unit cell with Bloch phases (use classmethod) + _phi_orbital_unit_cell = PDOSCalculator.construct_total_orbitals_in_unit_cell( + phi_orbital=orbital, + k_point_fractional=k_point_fractional, + index_mask_dict=atom.index_mask_and_effective_grid_point_positions_dict + ) + + # Compute projection + projected_value = np.sum(_phi_orbital_unit_cell[:, np.newaxis] * psi_kpt, axis=0) + + # Compute normalization factor (use classmethod) + normalization_factor = PDOSCalculator.compute_normalization_factor( + dV=dV, + phi_orbital=orbital, + k_point_fractional=k_point_fractional, + index_mask_dict=atom.index_mask_and_effective_grid_point_positions_dict + ) + + P_single_kpt_array[:, orbital_index] = projected_value * normalization_factor + orbital_index += 1 + + # ===== Step 3: Apply orthogonalization/weights ===== + if mutiply_weights: + if orthogonalize: + P_single_kpt_array = np.einsum("jk,kl->jl", P_single_kpt_array, _S_inv_sqrt) + else: + P_single_kpt_array = np.einsum("jk,k->jk", P_single_kpt_array, _w_inv_sqrt) + + print(f"\t kpt_index = {kpt_index + 1:>3d} calculation done!! ({kpt_num} k-points in total)") + return kpt_index, P_single_kpt_array + + +# ===== Initializer for unified worker ===== +def _init_unified_worker(psi_meta, I_indices, kpts_store, atoms, dV, + orthogonalize_atomic_orbitals, mutiply_weights, + out_dirname, print_overlap_matrix, tot_orbital_num, kpt_num): + """Initialize worker for complete k-point processing.""" + psi_shm, psi_view = _ndarray_from_shm(psi_meta) + _G["psi_shm"] = psi_shm + _G["psi_total"] = psi_view + _G["I_indices"] = I_indices + _G["kpts_store"] = kpts_store + _G["atoms"] = atoms + _G["dV"] = dV + _G["orthogonalize_atomic_orbitals"] = orthogonalize_atomic_orbitals + _G["mutiply_weights"] = mutiply_weights + _G["out_dirname"] = out_dirname + _G["print_overlap_matrix"] = print_overlap_matrix + _G["tot_orbital_num"] = tot_orbital_num + _G["kpt_num"] = kpt_num + + + +def _process_single_kpoint_for_single_atom_worker(kpt_index: int): + import numpy as np + psi_total = _G["psi_total"] + I_indices = _G["I_indices"] + kpts_store = _G["kpts_store"] + latvec = _G["latvec"] + latvec_inv = _G["latvec_inv"] + is_orth = _G["is_orthogonal_lattice"] + Lx, Ly, Lz = _G["Lx"], _G["Ly"], _G["Lz"] + atom = _G["atoms_packed"] + atoms_full = _G["atoms"] # Need full atoms list for calculate_orbital_weights + kpt_num = _G.get("kpt_num", 0) + dV = _G.get("dV", 1.0) + mutiply_weights = _G.get("mutiply_weights", True) + start_idx = _G.get("start_idx", 0) + end_idx = _G.get("end_idx", 0) + + # Get k-point fractional coordinates + kx_frac = kpts_store[kpt_index, 0] + ky_frac = kpts_store[kpt_index, 1] + kz_frac = kpts_store[kpt_index, 2] + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]) + + # ---- get the psi of the k-point (view, no copy) and reorder the bands ---- + psi_kpt = psi_total[:, :, kpt_index] + perm = I_indices[:, kpt_index].astype(int) + psi_kpt = psi_kpt[:, perm] # (Nd, band_num) + band_num = psi_kpt.shape[1] + + # Compute the orbital weights for this k-point (reuse classmethod) + _orbital_weights = PDOSCalculator.calculate_orbital_weights( + atoms=atoms_full, + dV=dV, + k_point_fractional=k_point_fractional, + ) + _w_inv_sqrt = _orbital_weights ** (-0.5) + + # ---- result: shape (band_num, atom.num_orbitals) ---- + result = np.zeros((band_num, atom["num_orbitals"]), dtype=np.complex128) + + orbital_index = 0 + for orb in atom["orbitals"]: + # Reconstruct phi_value_dict and index_mask_dict from entries + phi_value_dict = {} + index_mask_dict = {} + for e in orb["entries"]: + ijk = tuple(e["ijk"]) + phi_value_dict[ijk] = e["phi"] + index_mask_dict[ijk] = (e["mask"], None) + + # Create temporary PhiOrbital object to use classmethod + temp_orbital = PDOSCalculator.PhiOrbital(n=0, l=0, m=0) + temp_orbital.phi_value_dict = phi_value_dict + + # Construct total orbital in unit cell with Bloch phases (use classmethod) + _phi_orbital_unit_cell = PDOSCalculator.construct_total_orbitals_in_unit_cell( + phi_orbital=temp_orbital, + k_point_fractional=k_point_fractional, + index_mask_dict=index_mask_dict + ) + + # Compute projection + projected_value = np.sum(_phi_orbital_unit_cell[:, np.newaxis] * psi_kpt, axis=0) + + # Compute normalization factor for this k-point (use classmethod) + normalization_factor = PDOSCalculator.compute_normalization_factor( + dV=dV, + phi_orbital=temp_orbital, + k_point_fractional=k_point_fractional, + index_mask_dict=index_mask_dict + ) + + result[:, orbital_index] = projected_value * normalization_factor + orbital_index += 1 + + # Apply weights to this k-point (same as sequential version) + if mutiply_weights: + result = np.einsum("jk,k->jk", result, _w_inv_sqrt[start_idx:end_idx]) + + print(f"\t kpt_index = {kpt_index + 1:>3d} calculation done!! ({kpt_num} k-points in total)") + return kpt_index, result + + +class PDOSCalculator: + """ + PDOS Calculator Class - Python version of MATLAB PDOS code for SPARC output files + """ + # Super parameters + k_point_parallel_threshold : int = 4 # if the number of k-points is greater than this threshold, use parallel calculation + + # File / Directory names - upon input + natom_types : int # number of atom types + upf_fname_list : List[str] # list of upf file names + output_fname : str # SPARC's output file name + eigen_fname : str # eigen file name + is_relaxation : bool # whether the result is from relaxation + static_fname : Optional[str] # static file name + geopt_fname : Optional[str] # geopt file name + psi_fname : str # orbital file name, usually the .psi file output by SPARC + out_dirname : str # PDOS output directory name + + + # Parameters for PDOS calculation at initial stage + r_cut_max : RCUT_MAX_TYPE # maximum cutoff radius for the atomic wave functions + atomic_wave_function_tol : float # tolerance for the atomic wave functions + orthogonalize_atomic_orbitals : bool # whether to orthogonalize the atomic orbitals + atomic_wave_function_generator : AtomicWaveFunctionGeneratorType # function to generate the atomic wave functions + print_overlap_matrix : bool # whether to print the overlap matrix + + + # Parameters for PDOS calculation at running stage + mu_PDOS : float # in eV, Gaussian width for DOS calculation + N_PDOS : int # number of points in PDOS + min_E_plot : float # min energy value (eV) for which PDOS is calculated + max_E_plot : float # max energy value (eV) for which PDOS is calculated + load_projection_data_from_txt_path : Optional[str] # path to the projection data file + print_projection_data : bool # whether to print the projection data + sum_over_m_index : bool # whether to sum over the m index + + + # Parameters from SPARC's output file (.out) + ## The following parameters are used for both orthogonal and non-orthogonal lattices + bcx : str # boundary condition in the x-direction, P for periodic, D for Dirichlet + bcy : str # boundary condition in the y-direction, P for periodic, D for Dirichlet + bcz : str # boundary condition in the z-direction, P for periodic, D for Dirichlet + band_num : int # number of bands + kpt_num : int # number of symmetry adapted k-points + fermi : float # Fermi level + + xc_functional : str # exchange-correlation functional + psp_fname_list : List[str] # list of psp file names + + tot_atoms_num : int # total number of atoms + atom_count_list : List[int] # number of atoms of each type + is_orthogonal_lattice : bool # whether the lattice is orthogonal + relax_flag : Optional[int] = None # relaxation flag + + + kpt1 : int # number of k-points in the x-direction + kpt2 : int # number of k-points in the y-direction + kpt3 : int # number of k-points in the z-direction + Nx : int # number of grid points in the x-direction + Ny : int # number of grid points in the y-direction + Nz : int # number of grid points in the z-direction + Lx : float # lattice constant in the x-direction (in Bohr) + Ly : float # lattice constant in the y-direction (in Bohr) + Lz : float # lattice constant in the z-direction (in Bohr) + + dx : float # grid spacing in the x-direction (in Bohr) + dy : float # grid spacing in the y-direction (in Bohr) + dz : float # grid spacing in the z-direction (in Bohr) + + x_lattice_vector : np.ndarray[float] # x-lattice vector + y_lattice_vector : np.ndarray[float] # y-lattice vector + z_lattice_vector : np.ndarray[float] # z-lattice vector + + ## If is_orthogonal_lattice is False, then the lattice is not orthogonal, and the following extra parameters are initialized later + # Non-orthogonal lattice parameters + latvec : np.ndarray[float] # 3x3 lattice vectors matrix (in Bohr) + latvec_inv : np.ndarray[float] # inverse of lattice vectors matrix + latvec_det : float # determinant of lattice vectors matrix + cell_volume : float # unit cell volume (in Bohr^3) + jacobian_det : float # Jacobian determinant for coordinate transformation + metric_tensor : np.ndarray[float] # metric tensor g_ij = a_i · a_j + metric_tensor_inv : np.ndarray[float] # inverse of metric tensor + + + # Parameters from UPF files (.upf) + @dataclass + class PseudoWaveFunction: + n: int = 0 # principal quantum number + l: int = 0 # angular momentum quantum number + no_m: int = 0 # number of m quantum states + chi : List[float] = field(default_factory=list) # chi(r) + r : List[float] = field(default_factory=list) # r-grid + phi_r: List[float] = field(default_factory=list) # phi(r) + + @dataclass + class AtomicWaveFunction: + atom_type_index: int # atom type index + atom_species: str # atom species + upf_fname: str # upf file name + r_cut: int # cutoff radius, no greater than 10.0 Bohr + num_psdwfn: int # number of pseudo-wavefunctions + num_orbitals: int # total number of orbitals + psdwfn_list: List['PDOSCalculator.PseudoWaveFunction'] = field(default_factory=list) + + atomic_wave_function_list : List[AtomicWaveFunction] # list of atom wave functions + + + # Parameters from SPARC's static file (.static) or geopt file (.geopt) + @dataclass + class Atom: + atom_type_index: int # atom type index + atom_posn_frac: np.ndarray[float] # fractional coordinates of the atom + atom_posn_cart: np.ndarray[float] # cartesian coordinates of the atom + + # Other parameters related to the grid-wise phi orbitals, will be updated when .run() is called. + # For index_mask_and_r_norm_dict, the key is a tuple of 3 integers, which specifies the index shift of the unit cell in the x, y, z directions. + # (x_index_shift, y_index_shift, z_index_shift) + # - For example, (0, 0, 0) means the grid points are in the unit cell with index (0, 0, 0), and index_mask specifies the grid points where the orbital takes non-zero values. + # - Since the cutoff radius is fixed for each atom, the index_mask is the same for all atoms, even if the orbitals are different. + # - r_norm_array is the distance between the atom and the grid points, in Bohr + # index_mask : np.ndarray[bool] + # - specifies the grid points where the orbital takes non-zero values. + # - Use self.cartesian_gridwise_coord[index_mask] to get the cartesian coordinates of the grid points + # r_norm_array : np.ndarray[float] + # - the distance between the atom and the grid points, in Bohr + index_mask_and_effective_grid_point_positions_dict: IndexMaskDictType = field(default_factory=dict) # (x_index_shift, y_index_shift, z_index_shift) -> (index_mask, effective_grid_point_positions_array) + + r_cut : float = 0.0 # cutoff radius, in Bohr + num_psdwfn : int = 0 # number of pseudo wave functions + num_orbitals : int = 0 # total number of orbitals + phi_orbitals_list: List['PDOSCalculator.PhiOrbital'] = field(default_factory=list) # list of phi orbitals, len(phi_orbitals_list) = num_orbitals + + atoms : List[Atom] # list of atoms + + + # Data class for the phi orbitals, stored in the Atom.phi_orbitals_list + @dataclass + class PhiOrbital: + n: int # principal quantum number (optional, for bookkeeping) + l: int # angular momentum + m: int # magnetic quantum number + + # If the atom will not overlap with itself, then the normalization factor is 1.0, otherwise it should be calculated by considering different images inside the unit cell + normalization_factor_dict : NormalizationFactorDictType = field(default_factory=dict) # (x_index_shift, y_index_shift, z_index_shift) -> normalization factor for the PhiOrbital, this factor is needed when you place the atom inside the unit cell + + # total_orbitals_in_unit_cell : np.ndarray[np.complex128] # total orbitals in the unit cell, size = (tot_grid_pt, ) + total_orbitals_in_unit_cell_dict : TotalOrbitalsInUnitCellDictType = field(default_factory=dict) # (x_index_shift, y_index_shift, z_index_shift) -> total orbitals in the unit cell, size = (tot_grid_pt, ) + + # Phi(r) values at the effective grid points, corresponding to the index of the grid points in Atom.index_mask_dict + phi_value_dict : PhiValueDictType = field(default_factory=dict) # (x_index_shift, y_index_shift, z_index_shift) -> phi_value + + + + # Parameters from SPARC's eigen file (.eigen) + eign : np.ndarray[float] # (totkpt, band_num) energies sorted ascending within each k + occ : np.ndarray[float] # (totkpt, band_num) occupations sorted according to eign + I_indices : np.ndarray[int] # (band_num, totkpt) argsort indices for each k + kpts_store : np.ndarray[float] # (totkpt, 3) k-vectors + kpt_wts_store : np.ndarray[float] # (totkpt,) weights * (kpt1*kpt2*kpt3) + + + # Parameters from the SPARC's orbital file (.psi) + psi_total : np.ndarray[float] # (tot_grid_pt, band_num, totkpt) + header : Dict[str, Any] # header information, some already parsed from the SPARC's output file (.out), while contains some other information like "isGamma", "Nspinor_eig", "nspin", etc. + per_band_meta : List[Dict[str, Any]] # Information for the bands in each k-point + + + # Parameters related to the cartesian coordinates of the grid points, and its relations to the cut-off radius + x_coord : np.ndarray[float] # x-coordinate of the unit cell + y_coord : np.ndarray[float] # y-coordinate of the unit cell + z_coord : np.ndarray[float] # z-coordinate of the unit cell + x_shift_index_list : ShiftIndexListType # All x-shift indices that should be considered + y_shift_index_list : ShiftIndexListType # All y-shift indices that should be considered + z_shift_index_list : ShiftIndexListType # All z-shift indices that should be considered + tot_grid_pt : int # total number of grid points in the unit cell + cartesian_gridwise_coord : np.ndarray[float] # cartesian coordinates of all the grid points in the unit cell + + # Parameters for the PDOS calculation + tot_orbital_num : int # total number of orbitals + overlap_matrix : Optional[np.ndarray[float]] # overlap matrix of different orbitals + S_inv_sqrt : Optional[np.ndarray[float]] # inverse square root of the overlap matrix + data_projections : np.ndarray[float] # coefficients of the projection of the wavefunction onto the atomic orbital basis + + + # Initialization flags + out_file_loaded_flag : bool = False # whether the SPARC's output file (.out) is loaded + atomic_orbitals_loaded_flag : bool = False # whether the atomic orbitals are loaded, usually from the UPF files (.upf), but can be from other sources + eigen_file_loaded_flag : bool = False # whether the eigen file is loaded + static_file_loaded_flag : bool = False # whether the static file is loaded + psi_file_loaded_flag : bool = False # whether the psi file is loaded + + + def __init__(self, + upf_fname_list : Optional[List[str]], # list of upf file names + output_fname : str, # SPARC's output file name + eigen_fname : str, # eigen file name + static_fname : Optional[str], # static file name + psi_fname : str, # orbital file name + out_dirname : str, # PDOS output directory name + r_cut_max : Union[List[float], float] = 15.0, # maximum cutoff radius for the atomic wave functions + atomic_wave_function_tol : float = 1e-5, # tolerance for the atomic wave functions + orthogonalize_atomic_orbitals : bool = False, # whether to orthogonalize the atomic orbitals + is_relaxation : bool = False, # The result is from relaxation + geopt_fname : Optional[str] = None, # geopt file name + k_point_parallelization : Optional[bool] = None, # whether to use k-point parallelization + ): + """ + 1. Initialize the PDOSCalculator class + """ + time1 = time.time() + + # output_fname check + assert isinstance(output_fname, str), OUTPUT_FNAME_NOT_STRING_ERROR.format(type(output_fname)) + self.check_fname_existence(output_fname) + self.natom_types, self.atom_species_list = self.parse_atom_species_from_sparc_out_file(output_fname = output_fname) + + # upf_fname_list check + self.check_upf_fname_list_or_get_default_atomic_wave_function_generators( + upf_fname_list = upf_fname_list, + natom_types = self.natom_types) + + # natom_types check + assert isinstance(self.natom_types, int), NATOM_TYPE_NOT_INTEGER_ERROR.format(type(self.natom_types)) + + + # eigen_fname check + assert isinstance(eigen_fname, str), EIGEN_FNAME_NOT_STRING_ERROR.format(type(eigen_fname)) + self.check_fname_existence(eigen_fname) + + + # static_fname / geopt_fname check + assert isinstance(is_relaxation, bool), IS_RELAXATION_NOT_BOOL_ERROR.format(type(is_relaxation)) + if not is_relaxation: + assert isinstance(static_fname, str), STATIC_FNAME_NOT_STRING_ERROR.format(type(static_fname)) + self.check_fname_existence(static_fname) + if geopt_fname is not None: + print(GEOPT_FNAME_PROVIDED_BUT_IS_RELAXATION_FALSE_WARNING) + else: + assert isinstance(geopt_fname, str), GEOPT_FNAME_NOT_STRING_ERROR.format(type(geopt_fname)) + self.check_fname_existence(geopt_fname) + if static_fname is not None: + print(STATIC_FNAME_PROVIDED_BUT_IS_RELAXATION_TRUE_WARNING) + + # psi_fname check + assert isinstance(psi_fname, str), ORBITAL_FNAME_NOT_STRING_ERROR.format(type(psi_fname)) + self.check_fname_existence(psi_fname) + + # out_dirname check + assert isinstance(out_dirname, str), OUT_DIRNAME_NOT_STRING_ERROR.format(type(out_dirname)) + if os.path.exists(out_dirname): + shutil.rmtree(out_dirname) + os.makedirs(out_dirname) + + # r_cut_max and atomic_wave_function_tol check + assert isinstance(r_cut_max, (float, list)), R_CUT_MAX_NOT_FLOAT_OR_LIST_ERROR.format(type(r_cut_max)) + if isinstance(r_cut_max, list): + assert len(r_cut_max) == self.natom_types, R_CUT_MAX_NUM_NOT_EQUAL_TO_NATOM_TYPES_ERROR.format(len(r_cut_max)) + assert isinstance(atomic_wave_function_tol, float), ATOMIC_WAVE_FUNCTION_TOL_NOT_FLOAT_ERROR.format(type(atomic_wave_function_tol)) + assert atomic_wave_function_tol > 0.0, ATOMIC_WAVE_FUNCTION_TOL_NOT_POSITIVE_ERROR.format(atomic_wave_function_tol) + + # orthogonalize_atomic_orbitals check + assert isinstance(orthogonalize_atomic_orbitals, bool), ORTHOGONALIZE_ATOMIC_ORBITALS_NOT_BOOL_ERROR.format(type(orthogonalize_atomic_orbitals)) + + + # k_point_parallelization check + if k_point_parallelization is not None: + assert isinstance(k_point_parallelization, bool), K_POINT_PARALLELIZATION_NOT_BOOL_ERROR.format(type(k_point_parallelization)) + if k_point_parallelization: + self.k_point_parallel_threshold = 1 + else: + self.k_point_parallel_threshold = 1e9 + + + # set input parameters - file names + self.output_fname : str = output_fname + self.upf_fname_list : Optional[List[str]] = upf_fname_list + self.eigen_fname : str = eigen_fname + self.static_fname : Optional[str] = static_fname + self.geopt_fname : Optional[str] = geopt_fname + self.psi_fname : str = psi_fname + self.out_dirname : str = out_dirname + self.is_relaxation : bool = is_relaxation + + # set input parameters - PDOS calculation parameters + self.r_cut_max : Union[List[float], float] = r_cut_max + self.atomic_wave_function_tol : float = atomic_wave_function_tol + self.orthogonalize_atomic_orbitals : bool = orthogonalize_atomic_orbitals + + + """ + 2. Read in the SPARC's output file as program's input + """ + time2 = time.time() + + + self.eV2Ha = 1/27.21140795 + self.Ha2eV = 27.21140795 + + # read in the SPARC's output file (.out) + self.read_sparc_out_file_parameters(fname = output_fname) + + + # read in the upf files (.upf), if provided + self.atomic_wave_function_list : List[PDOSCalculator.AtomicWaveFunction] = [] + if self.upf_fname_list is not None: + for index, upf_fname in enumerate(self.upf_fname_list): + if upf_fname == "Default": + atomic_number = int(name_to_atomic_number(self.atom_species_list[index])) + atomic_wave_function_generator = get_default_generator_for_atomic_wave_function(xc_functional = self.xc_functional, psp_file_path = self.psp_fname_list[index]) + atomic_wave_function = self.read_atomic_wave_function_from_atomic_wave_function_generator( + atomic_wave_function_generator = atomic_wave_function_generator, + atom_type_index = index, + atomic_number = atomic_number, + atom_species = self.atom_species_list[index]) + else: + atomic_wave_function = self.read_atomic_wave_function_from_upf_file(fname = upf_fname, atom_type_index = index, atom_species = self.atom_species_list[index]) + self.atomic_wave_function_list.append(atomic_wave_function) + else: + for index, atom_species in enumerate(self.atom_species_list): + atomic_number = int(name_to_atomic_number(atom_species)) + atomic_wave_function_generator = get_default_generator_for_atomic_wave_function(xc_functional = self.xc_functional, psp_file_path = self.psp_fname_list[index]) + atomic_wave_function = self.read_atomic_wave_function_from_atomic_wave_function_generator( + atomic_wave_function_generator = atomic_wave_function_generator, + atom_type_index = index, + atomic_number = atomic_number, + atom_species = atom_species) + self.atomic_wave_function_list.append(atomic_wave_function) + + + + # read in the SPARC's static file (.static) + if not self.is_relaxation: + self.read_sparc_static_file_parameters(fname = static_fname, atom_count_list = self.atom_count_list) + else: + self.read_sparc_geopt_file_parameters(fname = geopt_fname, atom_count_list = self.atom_count_list) + + + + # read in the SPARC's eigen file (.eigen) + self.read_sparc_eigen_file_parameters(fname = eigen_fname) + + + # # read in the SPARC's orbital file (.psi) + self.read_sparc_orbital_file_parameters(fname = psi_fname) + + + + """ + 3. Get cartesian coordinates and other information of the unit cell + """ + time3 = time.time() + self.get_cartesian_coordinates_for_the_unit_cell() + + + """ + 4. Update the atom's orbital information + """ + time4 = time.time() + + for atom in self.atoms: + self.atom_wise_compute_index_mask_and_effective_grid_point_positions_dict(atom = atom) + self.atom_wise_compute_grid_wise_phi_orbitals(atom = atom) + # self.atom_wise_compute_normalization_factor_in_unit_cell(atom = atom) + self.tot_orbital_num = self.get_total_number_of_orbitals(atoms = self.atoms) + + + time_final = time.time() + + self.time_init = time1 + self.step1_time = time2 - time1 + self.step2_time = time3 - time2 + self.step3_time = time4 - time3 + self.step4_time = time_final - time4 + + + + def run(self, + mu_PDOS : float = 0.2721140795, # in eV, Gaussian width for DOS calculation + N_PDOS : int = 1000, # number of points in PDOS + min_E_plot : Optional[float] = None, # min energy value (eV) for which PDOS is calculated + max_E_plot : Optional[float] = None, # max energy value (eV) for which PDOS is calculated + load_projection_data_from_txt_path : Optional[str] = None, + print_projection_data = False, + sum_over_m_index = True, + print_overlap_matrix = False, + ): + + # set the min_E_plot and max_E_plot + if min_E_plot is None: + min_E_plot = self.eign.min() * self.Ha2eV - 5.0 * mu_PDOS + if max_E_plot is None: + max_E_plot = self.eign.max() * self.Ha2eV + 5.0 * mu_PDOS + + # type check + assert isinstance(mu_PDOS, float), MU_PDOS_NOT_FLOAT_ERROR.format(type(mu_PDOS)) + assert isinstance(N_PDOS, int), N_PDOS_NOT_INTEGER_ERROR.format(type(N_PDOS)) + assert isinstance(min_E_plot, float), MIN_E_PLOT_NOT_FLOAT_ERROR.format(type(min_E_plot)) # in eV + assert isinstance(max_E_plot, float), MAX_E_PLOT_NOT_FLOAT_ERROR.format(type(max_E_plot)) # in eV + if load_projection_data_from_txt_path is not None: + assert isinstance(load_projection_data_from_txt_path, str), LOAD_PROJECTION_DATA_FROM_TXT_PATH_NOT_STRING_ERROR.format(type(load_projection_data_from_txt_path)) + assert os.path.exists(load_projection_data_from_txt_path), LOAD_PROJECTION_DATA_FROM_TXT_PATH_NOT_EXIST_ERROR.format(load_projection_data_from_txt_path) + + self.mu_PDOS : float = mu_PDOS + self.N_PDOS : int = N_PDOS + self.min_E_plot : float = min_E_plot + self.max_E_plot : float = max_E_plot + + """ + 5. Project wavefuntions onto the atomic orbital basis. + """ + time5 = time.time() + if load_projection_data_from_txt_path is not None: + # projection_path = self.out_dirname + "/data_projections.txt" + assert os.path.exists(load_projection_data_from_txt_path), "Data projections file not found at {}".format(load_projection_data_from_txt_path) + data_projections, kpts_red = self.load_projections_from_txt(path = load_projection_data_from_txt_path) + print("\t data_projections.shape = ", data_projections.shape) + else: + data_projections = self.project_wavefunction_onto_atomic_orbital_basis_and_return_the_corresponding_coefficients( + orthogonalize_atomic_orbitals = self.orthogonalize_atomic_orbitals, + mutiply_weights = True, + save_fname = self.out_dirname + "/data_projections.txt" if print_projection_data else None, + print_overlap_matrix = print_overlap_matrix, + ) + + + # self.calculate_pdos(overlap_matrix = self.overlap_matrix) + """ + 6. Compute Projected Density of States (PDOS), and output the PDOS and DOS to the output directory + """ + time6 = time.time() + + E, PDOS_plot, DOS = self.compute_pdos_dos(data_projections = data_projections) + + # initialize the pdos_header + dos_header = "Energy(eV) DOS" + + # sum over the m index + if sum_over_m_index: + PDOS_plot = self._sum_over_m_index(PDOS_plot = PDOS_plot) + column_header_format = "(nl)" + else: + column_header_format = "(nl,m)" + + + print("Saving the PDOS and DOS to the output directory") + + np.savetxt(self.out_dirname + "/DOS.txt", + np.column_stack([E, DOS]), + header = dos_header, comments='', fmt="%.10f") + + with open(self.out_dirname + "/PDOS.txt", "w") as f: + f.write(pdos_output_header_msg.format( + fermi_level = self.fermi, + broadening = self.mu_PDOS, + grid_points = self.N_PDOS, + min_energy = self.min_E_plot, + max_energy = self.max_E_plot, + bands = self.band_num, + kpoints = self.kpt_num, + atom_type_num = self.natom_types, + orbitals = self.tot_orbital_num, + proj_orbitals = len(PDOS_plot[0]), + volume = self.cell_volume, + calculation_time = time6 - self.time_init, + m_index_summed_over = sum_over_m_index, + atom_index_for_pdos = "All", + column_header_format = column_header_format, + orthogonalize_atomic_orbitals = self.orthogonalize_atomic_orbitals,)) + + for atom_index, atom in enumerate(self.atoms): + start_idx, end_idx = self._get_atom_orbital_indices(target_atom = atom, sum_over_m_index = sum_over_m_index) + pdos_header, pdos_info_str = self._get_pdos_header_for_single_atom( + sum_over_m_index = sum_over_m_index, + atom_of_interest = atom, + ) + + with open(self.out_dirname + "/PDOS.txt", "a") as f: + atom_name = self.atom_species_list[atom.atom_type_index] + f.write(pdos_info_msg.format( + atom_type = atom_name, + atomic_number = name_to_atomic_number(atom_name), + atom_index = atom_index, + atom_position_cartesian = atom.atom_posn_cart, + atom_position_fractional = atom.atom_posn_frac, + pdos_unit = "states/eV", + header_format = column_header_format,)) + np.savetxt(f, + np.column_stack([E, PDOS_plot[:, start_idx:end_idx]]), + header = pdos_header, + comments='', + fmt='\t%.10f',) + + time_final = time.time() + + # print("DOS.shape = ", DOS.shape) + # print("DOS.sum() = ", DOS.sum()) + # print("DOS.sum() * (E[1] - E[0]) = ", DOS.sum() * (E[1] - E[0])) + + + self.step5_time = time6 - time5 + self.step6_time = time_final - time6 + + self.print_time_taken(load_projection_data_from_txt_path = load_projection_data_from_txt_path) + + return E, PDOS_plot, DOS + + + def _sum_over_m_index(self, PDOS_plot : np.ndarray): + print("summing over the m index") + + atom_nl_index_lists : List[List[int]] = [] + total_number_of_nl_orbitals = 0 + for atom_index, atom in enumerate(self.atoms): + atom_type = self.atom_species_list[atom.atom_type_index] + nl_index_list : List[int] = [] + + for orbital in atom.phi_orbitals_list: + if (orbital.n, orbital.l) not in nl_index_list: + nl_index_list.append((orbital.n, orbital.l)) + atom_nl_index_lists.append(nl_index_list) + total_number_of_nl_orbitals += len(nl_index_list) + + + # initialize the PDOS_plot_summed + atoms_nl_combination_number_list = [len(atom_nl_index_list) for atom_nl_index_list in atom_nl_index_lists] + PDOS_plot_summed = np.zeros((PDOS_plot.shape[0], sum(atoms_nl_combination_number_list))) + + # sum over the m index + orbital_index, summed_orbital_index = 0, 0 + for atom_index, atom_nl_index_list in enumerate(atom_nl_index_lists): + for (n, l) in atom_nl_index_list: + number_of_m = 2 * l + 1 + PDOS_plot_summed[:, summed_orbital_index] = np.sum(PDOS_plot[:, orbital_index:orbital_index + number_of_m], axis=1) + + summed_orbital_index += 1 + orbital_index += number_of_m + + assert summed_orbital_index == PDOS_plot_summed.shape[1], "summed_orbital_index != PDOS_plot_summed.shape[1]" + return PDOS_plot_summed + + + + def print_time_taken(self, load_projection_data_from_txt_path : Optional[str] = None): + print("[Step 1] Time taken to initialize the PDOSCalculator class : {:7.4f} secs".format(self.step1_time)) + print("[Step 2] Time taken to read in the SPARC's output file : {:7.4f} secs".format(self.step2_time)) + print("[Step 3] Time taken to get cartesian coordinates and others : {:7.4f} secs".format(self.step3_time)) + print("[Step 4] Time taken to update the atom's orbital information : {:7.4f} secs".format(self.step4_time)) + # if self.orthogonalize_atomic_orbitals: + # print("[Step 5] Time taken to calculate the overlap matrix S : {:7.4f} secs".format(self.step5_time)) + # print("[Step 6] Time taken to compute S^(-1/2) : {:7.4f} secs".format(self.step6_time)) + # else: + # print("[Step 5] Time taken to calculate orbital weights w : {:7.4f} secs".format(self.step5_time)) + # print("[Step 6] Time taken to calculate w^(-1/2) : {:7.4f} secs".format(self.step6_time)) + + if load_projection_data_from_txt_path is not None: + print("[Step 5] Time taken to load the projection data from txt : {:7.4f} secs".format(self.step5_time)) + else: + print("[Step 5] Time taken to project wfn onto the atomic orbital : {:7.4f} secs, {:.4f} secs per k-point".format(self.step5_time, self.step5_time / self.kpt_num)) + + print("[Step 6] Time taken to compute and save the PDOS and DOS : {:7.4f} secs".format(self.step6_time)) + + total_time = self.step1_time + self.step2_time + self.step3_time + self.step4_time + self.step5_time + self.step6_time + print("Total time taken: {:7.4f} secs".format(total_time)) + + + def run_single_atom(self, + atom_type : Union[int, str, List[int], List[str]], + atom_index_for_specified_atom_type : Union[int, List[int]], + mu_PDOS : float = 0.2721140795, # in eV, Gaussian width for DOS calculation + N_PDOS : int = 1000, # number of points in PDOS + min_E_plot : Optional[float] = None, # min energy value (eV) for which PDOS is calculated + max_E_plot : Optional[float] = None, # max energy value (eV) for which PDOS is calculated + load_projection_data_from_txt_path : Optional[str] = None, + print_projection_data : bool = False, + sum_over_m_index : bool = True, + print_overlap_matrix : bool = False, + ): + """ + Run the PDOSCalculator class for a single atom + """ + + if min_E_plot is None: + min_E_plot = self.eign.min() * self.Ha2eV - 5.0 * mu_PDOS + if max_E_plot is None: + max_E_plot = self.eign.max() * self.Ha2eV + 5.0 * mu_PDOS + + + # Type check + assert isinstance(mu_PDOS, float), MU_PDOS_NOT_FLOAT_ERROR.format(type(mu_PDOS)) + assert isinstance(N_PDOS, int), N_PDOS_NOT_INTEGER_ERROR.format(type(N_PDOS)) + assert isinstance(min_E_plot, float), MIN_E_PLOT_NOT_FLOAT_ERROR.format(type(min_E_plot)) # in eV + assert isinstance(max_E_plot, float), MAX_E_PLOT_NOT_FLOAT_ERROR.format(type(max_E_plot)) # in eV + + self.mu_PDOS : float = mu_PDOS + self.N_PDOS : int = N_PDOS + self.min_E_plot : float = min_E_plot + self.max_E_plot : float = max_E_plot + + # initialize the pdos_atom_type_list and pdos_atom_index_list + self._initialize_pdos_atom_type_and_index_list( + atom_type = atom_type, + atom_index_for_specified_atom_type = atom_index_for_specified_atom_type) + assert hasattr(self, "pdos_atom_type_list"), "pdos_atom_type_list is not initialized" + assert hasattr(self, "pdos_atom_index_list"), "pdos_atom_index_list is not initialized" + + """ + 5. Project wavefuntions onto the atomic orbital basis. + """ + time5 = time.time() + P_single_atom_array_list : List[np.ndarray] = [] + if load_projection_data_from_txt_path is not None: + # projection_path = self.out_dirname + "/data_projections.txt" + assert os.path.exists(load_projection_data_from_txt_path), "Data projections file not found at {}".format(load_projection_data_from_txt_path) + data_projections, kpts_red = self.load_projections_from_txt(path = load_projection_data_from_txt_path) + + print("data_projections.shape = ", data_projections.shape) + for pdos_atom_index in self.pdos_atom_index_list: + atom_of_interest = self.atoms[pdos_atom_index] + start_idx, end_idx = self._get_atom_orbital_indices(target_atom = atom_of_interest) + + P_single_atom_array = data_projections[:, :, start_idx:end_idx] + P_single_atom_array_list.append(P_single_atom_array) + else: + P_single_atom_array_list = self._project_single_atom_wavefunction_onto_atomic_orbital_basis( + pdos_atom_index_list = self.pdos_atom_index_list, + orthogonalize_atomic_orbitals = self.orthogonalize_atomic_orbitals, + save_fname = self.out_dirname + "/data_projections.txt" if print_projection_data else None, + print_overlap_matrix = print_overlap_matrix, + ) + self.P_single_atom_array_list = P_single_atom_array_list + + + + """ + 6. Compute Projected Density of States (PDOS) + """ + time6 = time.time() + + # Computation + E_list : List[np.ndarray] = [] + DOS_list : List[np.ndarray] = [] + PDOS_plot_list : List[np.ndarray] = [] + for idx, pdos_atom_index in enumerate(self.pdos_atom_index_list): + atom_of_interest = self.atoms[pdos_atom_index] + E, PDOS_plot, DOS = self.compute_pdos_dos(data_projections = self.P_single_atom_array_list[idx]) + E_list.append(E) + DOS_list.append(DOS) + PDOS_plot_list.append(PDOS_plot) + + + # Output + print("Saving the PDOS and DOS to the output directory") + + with open(self.out_dirname + "/PDOS.txt", "w") as f: + f.write(pdos_output_header_msg.format( + fermi_level = self.fermi, + broadening = self.mu_PDOS, + grid_points = self.N_PDOS, + min_energy = self.min_E_plot, + max_energy = self.max_E_plot, + bands = self.band_num, + kpoints = self.kpt_num, + atom_type_num = self.natom_types, + orbitals = self.tot_orbital_num, + proj_orbitals = sum(len(PDOS_plot_list[idx][0]) for idx in range(len(self.pdos_atom_index_list))), + volume = self.cell_volume, + calculation_time = time6 - self.time_init, + atom_index_for_pdos = self.pdos_atom_index_list, + m_index_summed_over = sum_over_m_index, + orthogonalize_atomic_orbitals = self.orthogonalize_atomic_orbitals,)) + + for idx, pdos_atom_index in enumerate(self.pdos_atom_index_list): + atom = self.atoms[pdos_atom_index] + E = E_list[idx] + PDOS_plot = PDOS_plot_list[idx] + + # initialize the pdos_header + pdos_header, pdos_info_str = self._get_pdos_header_for_single_atom(sum_over_m_index = sum_over_m_index, atom_of_interest = atom_of_interest) + + # sum over the m index + if sum_over_m_index: + PDOS_plot = self._sum_over_m_index_for_single_atom(PDOS_plot = PDOS_plot, atom = atom_of_interest) + column_header_format = "(nl)" + else: + column_header_format = "(nl,m)" + + start_idx, end_idx = self._get_atom_orbital_indices( + target_atom = atom, + sum_over_m_index = sum_over_m_index) + pdos_header, pdos_info_str = self._get_pdos_header_for_single_atom( + sum_over_m_index = sum_over_m_index, + atom_of_interest = atom,) + + with open(self.out_dirname + "/PDOS.txt", "a") as f: + atom_name = self.atom_species_list[atom.atom_type_index] + f.write(pdos_info_msg.format( + atom_type = atom_name, + atomic_number = name_to_atomic_number(atom_name), + atom_index = pdos_atom_index, + atom_position_cartesian = atom.atom_posn_cart, + atom_position_fractional = atom.atom_posn_frac, + pdos_unit = "states/eV", + header_format = column_header_format,)) + np.savetxt(f, + np.column_stack([E, PDOS_plot]), + header = pdos_header, + comments='', + fmt='\t%.10f',) + + + time_final = time.time() + + self.step5_time = time6 - time5 + self.step6_time = time_final - time6 + self.print_time_taken() + + return E, PDOS_plot, DOS + + + def _initialize_pdos_atom_type_and_index_list( + self, atom_type : Union[int, str, List[int], List[str]], + atom_index_for_specified_atom_type : Union[int, List[int]]) -> Tuple[List[str], List[int]]: + + # type check for atom_type and atom_index_for_specified_atom_type + if isinstance(atom_type, Union[int, str]): + assert isinstance(atom_index_for_specified_atom_type, int), ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_NOT_INTEGER_ERROR.format(type(atom_index_for_specified_atom_type)) + atom_type_list = [atom_type,] + atom_index_for_specified_atom_type_list = [atom_index_for_specified_atom_type,] + elif isinstance(atom_type, list): + assert len(atom_type) == len(atom_index_for_specified_atom_type), ATOM_TYPE_AND_ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_LENGTH_MISMATCH_ERROR.format(len(atom_type), len(atom_index_for_specified_atom_type)) + for i in range(len(atom_type)): + assert isinstance(atom_type[i], Union[int, str]), ATOM_TYPE_NOT_INTEGER_OR_STRING_ERROR.format(type(atom_type[i])) + assert isinstance(atom_index_for_specified_atom_type[i], int), ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_NOT_INTEGER_ERROR.format(type(atom_index_for_specified_atom_type[i])) + atom_type_list = atom_type + atom_index_for_specified_atom_type_list = atom_index_for_specified_atom_type + else: + raise ValueError("atom_type must be an integer or a string or a list of integers or a list of strings") + + + # initialize the pdos_atom_type_list and pdos_atom_index_list + self.pdos_atom_type_list = [] + self.pdos_atom_index_list = [] + for idx, _atom_type in enumerate(atom_type_list): + _atom_index_for_specified_atom_type = atom_index_for_specified_atom_type_list[idx] + if isinstance(_atom_type, int): + _atom_type = atomic_number_to_name(_atom_type) + + # further check the atom_type and atom_index_for_specified_atom_type + assert _atom_type in self.atom_species_list, ATOM_TYPE_NOT_FOUND_ERROR.format(_atom_type) + _atom_type_index = self.atom_species_list.index(_atom_type) + _atom_num_for_specified_atom_type = self.atom_count_list[_atom_type_index] + assert _atom_index_for_specified_atom_type < _atom_num_for_specified_atom_type, \ + ATOM_INDEX_FOR_SPECIFIED_ATOM_TYPE_OUT_OF_BOUND_ERROR.format(_atom_type, _atom_index_for_specified_atom_type) + + _index_in_total_atom_list = int(np.sum(self.atom_count_list[:_atom_type_index]) + _atom_index_for_specified_atom_type) + self.pdos_atom_type_list.append(_atom_type) + self.pdos_atom_index_list.append(_index_in_total_atom_list) + + return self.pdos_atom_type_list, self.pdos_atom_index_list + + + def _get_pdos_header_for_single_atom(self, sum_over_m_index : bool, atom_of_interest : Atom): + # initialize the pdos_header + header_parts = ["\tEnergy(eV) "] + if not sum_over_m_index: + atom_type = self.atom_species_list[atom_of_interest.atom_type_index] + for orbital in atom_of_interest.phi_orbitals_list: + desc = f"({orbital.n}{number_to_spdf(orbital.l)}, m={orbital.m})" + header_parts.append(desc) + # Join with proper spacing + pdos_header = " \t".join([f"{part:<12}" for part in header_parts]) + pdos_info_str = \ + "Number of Projected DOS = " + str(atom_of_interest.num_orbitals) + "\n" + \ + "Orbitals are labeled as AtomType(n,l,m)" + "\n" + else: + atom_type = self.atom_species_list[atom_of_interest.atom_type_index] + nl_index_list : List[int] = [] + + for orbital in atom_of_interest.phi_orbitals_list: + if (orbital.n, orbital.l) not in nl_index_list: + nl_index_list.append((orbital.n, orbital.l)) + + for (n, l) in nl_index_list: + desc = f"({n}{number_to_spdf(l)})" + header_parts.append(desc) + + # Join with proper spacing + pdos_header = " \t".join([f"{part:<12}" for part in header_parts]) + pdos_info_str = \ + "The m index is summed over" + "\n" + \ + "Number of Projected DOS = " + str(len(nl_index_list)) + "\n" + \ + "Orbitals are labeled as AtomType(n,l)" + "\n" + return pdos_header, pdos_info_str + + + + def _sum_over_m_index_for_single_atom(self, PDOS_plot : np.ndarray, atom : Atom): + print("summing over the m index") + + # get the nl index list + nl_index_list : List[int] = [] + + for orbital in atom.phi_orbitals_list: + if (orbital.n, orbital.l) not in nl_index_list: + nl_index_list.append((orbital.n, orbital.l)) + + + # initialize the PDOS_plot_summed + PDOS_plot_summed = np.zeros((PDOS_plot.shape[0], len(nl_index_list))) + + # sum over the m index + orbital_index, summed_orbital_index = 0, 0 + for (n, l) in nl_index_list: + number_of_m = 2 * l + 1 + PDOS_plot_summed[:, summed_orbital_index] = np.sum(PDOS_plot[:, orbital_index:orbital_index + number_of_m], axis=1) + + summed_orbital_index += 1 + orbital_index += number_of_m + + assert orbital_index == atom.num_orbitals, "orbital_index != atom.num_orbitals" + return PDOS_plot_summed + + + + def run_single_orbital(self, + atom_type : Union[int, str], # atomic number or atom type name + orbital_index : int, + mu_PDOS : float = 0.2721140795, # in eV, Gaussian width for DOS calculation + N_PDOS : int = 1000, # number of points in PDOS + min_E_plot : float = -20., # min energy value (eV) for which PDOS is calculated + max_E_plot : float = 20., # max energy value (eV) for which PDOS is calculated + print_projection_data = False, + ): + raise NotImplementedError("Not to run the single orbital is not implemented yet") + + + def _interp1d_spline_or_linear(self, x_grid, y_grid, x_query): + """ + Try cubic spline (SciPy). If SciPy not available, fall back to numpy.interp (linear). + - x_grid, y_grid: 1D arrays (ascending x_grid) + - x_query: 1D array of query points (will be clipped into [x_grid[0], x_grid[-1]]) + Returns: y(x_query) as 1D array. + """ + xg = np.asarray(x_grid, dtype=float) + yg = np.asarray(y_grid, dtype=float) + xq = np.asarray(x_query, dtype=float) + + # clip to the grid range (MATLAB uses rcut + r_grid to cover, usually not out of bounds, but here is more safe) + xq = np.clip(xq, xg[0], xg[-1]) + + try: + # use SciPy's cubic spline, equivalent to MATLAB's 'spline' style + from scipy import CubicSpline + cs = CubicSpline(xg, yg, extrapolate=False) + yq = cs(xq) + # out of range will give nan (extrapolate=False), but we have clipped, so no problem + # still do a safe treatment + yq = np.where(np.isfinite(yq), yq, 0.0) + return yq + except Exception: + # if SciPy is not available or fails, use linear interpolation + return np.interp(xq, xg, yg) + + + def get_cartesian_coordinates_for_the_unit_cell(self): + """ + Updated parameters + x_coord : np.ndarray[float] # x-coordinate of the unit cell + y_coord : np.ndarray[float] # y-coordinate of the unit cell + z_coord : np.ndarray[float] # z-coordinate of the unit cell + x_shift_index_list : ShiftIndexListType # All x-shift indices that should be considered + y_shift_index_list : ShiftIndexListType # All y-shift indices that should be considered + z_shift_index_list : ShiftIndexListType # All z-shift indices that should be considered + tot_grid_pt : int # total number of grid points in the unit cell + cartesian_gridwise_coord : np.ndarray[float] # cartesian coordinates of the grid points for the input of the psi file + """ + if self.is_orthogonal_lattice: + # Orthogonal lattice implementation + self.get_cartesian_coordinates_for_orthogonal_lattice() + else: + # Non-orthogonal lattice implementation + self.get_cartesian_coordinates_for_non_orthogonal_lattice() + + + def get_cartesian_coordinates_for_orthogonal_lattice(self): + # get the cartesian coordinates for the unit cell + x_coord = np.linspace(0, self.Lx, self.Nx + 1)[:-1] + y_coord = np.linspace(0, self.Ly, self.Ny + 1)[:-1] + z_coord = np.linspace(0, self.Lz, self.Nz + 1)[:-1] + + # get the cartesian coordinates for the unit cell + X, Y, Z = np.meshgrid(x_coord, y_coord, z_coord, indexing='ij') + cartesian_gridwise_coord = np.stack([X.ravel(order='F'), + Y.ravel(order='F'), + Z.ravel(order='F')], axis=-1) + + + # get the x, y, z shift index for each type of atom + x_shift_index_list, y_shift_index_list, z_shift_index_list = [], [], [] + if isinstance(self.r_cut_max, float): + rcut = self.r_cut_max + x_idx_max = max(0, int(np.floor(rcut / self.Lx)) + 1) + y_idx_max = max(0, int(np.floor(rcut / self.Ly)) + 1) + z_idx_max = max(0, int(np.floor(rcut / self.Lz)) + 1) + x_shift_index_list = list(range(-x_idx_max, x_idx_max + 1)) + y_shift_index_list = list(range(-y_idx_max, y_idx_max + 1)) + z_shift_index_list = list(range(-z_idx_max, z_idx_max + 1)) + if self.bcx == "D": + x_shift_index_list = [0] + if self.bcy == "D": + y_shift_index_list = [0] + if self.bcz == "D": + z_shift_index_list = [0] + + elif isinstance(self.r_cut_max, list): + for rcut in self.r_cut_max: + x_idx_max = max(0, int(np.floor(rcut / self.Lx)) + 1) + y_idx_max = max(0, int(np.floor(rcut / self.Ly)) + 1) + z_idx_max = max(0, int(np.floor(rcut / self.Lz)) + 1) + # x-direction + if self.bcx == "D": + x_shift_index_list.append([0]) + elif self.bcx == "P": + x_shift_index_list.append(list(range(-x_idx_max, x_idx_max + 1))) + else: + raise ValueError(BCX_NOT_D_OR_P_ERROR.format(self.bcx)) + + # y-direction + if self.bcy == "D": + y_shift_index_list.append([0]) + elif self.bcy == "P": + y_shift_index_list.append(list(range(-y_idx_max, y_idx_max + 1))) + else: + raise ValueError(BCY_NOT_D_OR_P_ERROR.format(self.bcy)) + + # z-direction + if self.bcz == "D": + z_shift_index_list.append([0]) + elif self.bcz == "P": + z_shift_index_list.append(list(range(-z_idx_max, z_idx_max + 1))) + else: + raise ValueError(BCZ_NOT_D_OR_P_ERROR.format(self.bcz)) + + else: + raise ValueError(R_CUT_MAX_NOT_FLOAT_OR_LIST_ERROR.format(type(self.r_cut_max))) + + # store the parsed parameters in the class + self.x_coord = x_coord + self.y_coord = y_coord + self.z_coord = z_coord + self.x_shift_index_list = x_shift_index_list + self.y_shift_index_list = y_shift_index_list + self.z_shift_index_list = z_shift_index_list + self.tot_grid_pt = self.Nx * self.Ny * self.Nz + self.cartesian_gridwise_coord = cartesian_gridwise_coord + + + def get_cartesian_coordinates_for_non_orthogonal_lattice(self): + """ + Get cartesian coordinates for non-orthogonal lattice + """ + # Create fractional coordinates grid (0 to 1 in each direction) + x_frac = np.linspace(0, 1, self.Nx, endpoint=False) + y_frac = np.linspace(0, 1, self.Ny, endpoint=False) + z_frac = np.linspace(0, 1, self.Nz, endpoint=False) + + # Create 3D grid in fractional coordinates + X_frac, Y_frac, Z_frac = np.meshgrid(x_frac, y_frac, z_frac, indexing='ij') + + # Convert to cartesian coordinates using lattice vectors + # r_cart = A * r_frac where A is the lattice vectors matrix + cartesian_gridwise_coord = np.zeros((self.Nx * self.Ny * self.Nz, 3)) + + for i in range(self.Nx): + for j in range(self.Ny): + for k in range(self.Nz): + idx = i + j * self.Nx + k * self.Nx * self.Ny + frac_coord = np.array([X_frac[i, j, k], Y_frac[i, j, k], Z_frac[i, j, k]]) + # Convert fractional to cartesian: r_cart = A * r_frac + # Since self.latvec is now column vectors, we use A^T * r_frac + cart_coord = np.dot(self.latvec, frac_coord) + cartesian_gridwise_coord[idx, :] = cart_coord + + + # Calculate shift indices for non-orthogonal lattice using proper cutoff analysis + x_shift_index_list, y_shift_index_list, z_shift_index_list = [], [], [] + + if isinstance(self.r_cut_max, float): + rcut = self.r_cut_max + shift_indices = self.calculate_shift_indices_for_cutoff(rcut) + x_shift_index_list = shift_indices[0] + y_shift_index_list = shift_indices[1] + z_shift_index_list = shift_indices[2] + if self.bcx == "D": + x_shift_index_list = [0] + if self.bcy == "D": + y_shift_index_list = [0] + if self.bcz == "D": + z_shift_index_list = [0] + + elif isinstance(self.r_cut_max, list): + for rcut in self.r_cut_max: + shift_indices = self.calculate_shift_indices_for_cutoff(rcut) + # x-direction + if self.bcx == "D": + x_shift_index_list.append([0]) + elif self.bcx == "P": + x_shift_index_list.append(shift_indices[0]) + else: + raise ValueError(BCX_NOT_D_OR_P_ERROR.format(self.bcx)) + + # y-direction + if self.bcy == "D": + y_shift_index_list.append([0]) + elif self.bcy == "P": + y_shift_index_list.append(shift_indices[1]) + else: + raise ValueError(BCY_NOT_D_OR_P_ERROR.format(self.bcy)) + + # z-direction + if self.bcz == "D": + z_shift_index_list.append([0]) + elif self.bcz == "P": + z_shift_index_list.append(shift_indices[2]) + else: + raise ValueError(BCZ_NOT_D_OR_P_ERROR.format(self.bcz)) + + + # Store parameters + self.x_coord = x_frac + self.y_coord = y_frac + self.z_coord = z_frac + self.x_shift_index_list = x_shift_index_list + self.y_shift_index_list = y_shift_index_list + self.z_shift_index_list = z_shift_index_list + self.tot_grid_pt = self.Nx * self.Ny * self.Nz + self.cartesian_gridwise_coord = cartesian_gridwise_coord + + + def calculate_shift_indices_for_cutoff(self, rcut): + """ + Calculate shift indices that properly cover the cutoff sphere in non-orthogonal lattice + + For non-orthogonal lattice, the cutoff sphere in cartesian space becomes + an ellipsoid in fractional space. We need to find all integer shifts that + could contain points within the cutoff radius. + + Args: + rcut: cutoff radius in Bohr + + Returns: + tuple: (x_shifts, y_shifts, z_shifts) lists of shift indices + """ + # Method: Analytical approach using metric tensor + # The cutoff condition in cartesian space: |r| <= rcut + # In fractional space: r_frac^T * G * r_frac <= rcut^2 + # where G is the metric tensor G_ij = a_i · a_j + + # Calculate the metric tensor G = A^T * A where A is the lattice vector matrix + G = np.dot(self.latvec.T, self.latvec) + + # For a conservative approach, we find the maximum extent in each direction + # by considering the ellipsoid equation: r_frac^T * G * r_frac <= rcut^2 + + # We can find the maximum extent in each direction by setting other coordinates to zero + # and solving for the maximum value of each coordinate + + max_shifts = [] + + for i in range(3): + # Set other coordinates to zero and find maximum extent in direction i + # The ellipsoid equation becomes: G[i,i] * x_i^2 <= rcut^2 + # So: x_i <= rcut / sqrt(G[i,i]) + + max_extent = rcut / np.sqrt(G[i, i]) + max_shift = int(np.ceil(max_extent)) + 1 # Add buffer + + max_shifts.append(max_shift) + + # Create shift lists + x_shifts = list(range(-max_shifts[0], max_shifts[0] + 1)) + y_shifts = list(range(-max_shifts[1], max_shifts[1] + 1)) + z_shifts = list(range(-max_shifts[2], max_shifts[2] + 1)) + + return x_shifts, y_shifts, z_shifts + + + def atom_wise_compute_index_mask_and_effective_grid_point_positions_dict(self, atom : 'PDOSCalculator.Atom'): + """ + Updated parameters + atom.r_cut : float + cutoff radius, in Bohr + atom.index_mask_and_effective_grid_point_positions_dict : IndexMaskDictType + (x_index_shift, y_index_shift, z_index_shift) -> (index_mask, effective_grid_point_positions_array) + """ + + assert isinstance(atom, self.Atom), INVALID_ATOM_INPUT_ERROR.format(type(atom)) + + # Prepare the parameters + atom_type_index = atom.atom_type_index + atom_posn_cart = atom.atom_posn_cart + rcut = self.atomic_wave_function_list[atom_type_index].r_cut + if isinstance(self.r_cut_max, float): + x_shift_index_range, y_shift_index_range, z_shift_index_range = self.x_shift_index_list, self.y_shift_index_list, self.z_shift_index_list + elif isinstance(self.r_cut_max, list): + x_shift_index_range, y_shift_index_range, z_shift_index_range = self.x_shift_index_list[atom_type_index], self.y_shift_index_list[atom_type_index], self.z_shift_index_list[atom_type_index] + else: + raise ValueError(R_CUT_MAX_NOT_FLOAT_OR_LIST_ERROR.format(type(self.r_cut_max))) + + # Compute the atom-centered cartesian coordinates of the unit cell + atom_centered_cart_coord_of_unit_cell = self.cartesian_gridwise_coord - atom_posn_cart + + # Update the parameters + atom.r_cut = rcut + atom.index_mask_and_effective_grid_point_positions_dict.clear() + + for x_shift_index in x_shift_index_range: + for y_shift_index in y_shift_index_range: + for z_shift_index in z_shift_index_range: + if self.is_orthogonal_lattice: + # Orthogonal lattice: direct vector addition + shifted_vector = x_shift_index * self.x_lattice_vector + y_shift_index * self.y_lattice_vector + z_shift_index * self.z_lattice_vector + else: + # Non-orthogonal lattice: use lattice vectors matrix + # For shift in fractional coordinates, convert to cartesian + shifted_vector = x_shift_index * self.latvec[:, 0] + y_shift_index * self.latvec[:, 1] + z_shift_index * self.latvec[:, 2] + + atom_centered_cart_coord_of_shifted_unit_cell = atom_centered_cart_coord_of_unit_cell + shifted_vector + + # Compute the distance between the atom and the shifted unit cell + r_norm_array = np.linalg.norm(atom_centered_cart_coord_of_shifted_unit_cell, axis = -1) + + # Compute the index mask for the shifted unit cell, if not all False, then update the index_mask_and_r_norm_dict + index_mask = r_norm_array <= rcut + + # Get the effective grid point position array + effective_grid_point_position_array = atom_centered_cart_coord_of_shifted_unit_cell[index_mask] + + if not np.all(index_mask == False): + atom.index_mask_and_effective_grid_point_positions_dict[(x_shift_index, y_shift_index, z_shift_index)] = (index_mask, effective_grid_point_position_array) + + assert (0, 0, 0) in atom.index_mask_and_effective_grid_point_positions_dict, INDEX_MASK_AND_EFFECTIVE_GRID_POINT_POSITIONS_DICT_NOT_FOUND_ERROR + + + def atom_wise_compute_grid_wise_phi_orbitals(self, atom : 'PDOSCalculator.Atom'): + """ + Compute the grid-wise Phi_{nlm}(r) orbitals for the atom + Phi_{nlm}(r) = phi_{nl}(r) * Y_{lm}(r) + + Updated parameters + atom.num_orbitals : int # total number of orbitals + atom.phi_orbitals_list : List['PDOSCalculator.PhiOrbital'] # list of Phi_{nlm}(r) orbitals + """ + assert isinstance(atom, self.Atom), INVALID_ATOM_INPUT_ERROR.format(type(atom)) + assert len(atom.index_mask_and_effective_grid_point_positions_dict) > 0, ATOM_INDEX_MASK_AND_EFFECTIVE_GRID_POINT_POSITIONS_DICT_EMPTY_ERROR + + + # Get some related paramters + atom_type_index : int = atom.atom_type_index # atom type index + atomic_wfn_info : PDOSCalculator.AtomicWaveFunction = self.atomic_wave_function_list[atom_type_index] # atomic wave function information + num_psdwfn : int = atomic_wfn_info.num_psdwfn # number of pseudo wave functions + psdwfn_list : List[PDOSCalculator.PseudoWaveFunction] = atomic_wfn_info.psdwfn_list # pseudo wave function list + + + + # Some preparation + atom.phi_orbitals_list.clear() + phi_r_dict : PhiValueDictType = {} + + + # First, loop over all pseudo wave functions, corresponding to quantum number n and l + for psdwfn_index in range(num_psdwfn): + psdwfn_info : PDOSCalculator.PseudoWaveFunction = psdwfn_list[psdwfn_index] + n : int = psdwfn_info.n # principal quantum number + l : int = psdwfn_info.l # angular momentum quantum number + no_m : int = psdwfn_info.no_m # number of magnetic quantum number m + + + # Compute the phi_{nl}(r) array for all shift index vectors + phi_r_dict.clear() + for shift_index_vector in atom.index_mask_and_effective_grid_point_positions_dict.keys(): + _index_mask, effective_grid_point_positions_array = atom.index_mask_and_effective_grid_point_positions_dict[shift_index_vector] + r_norm_array = np.linalg.norm(effective_grid_point_positions_array, axis = -1) + phi_r_array = self._interp1d_spline_or_linear( + x_grid = psdwfn_info.r, + y_grid = psdwfn_info.phi_r, + x_query = r_norm_array) + phi_r_dict[shift_index_vector] = phi_r_array + + # Then, loop over all magnetic quantum number m + for m_index in range(no_m): + m = m_index - l + + # initialize the PhiOrbital object + phi_orbital = PDOSCalculator.PhiOrbital(n = n, l = l, m = m) #, normalization_factor = 1.0) + phi_orbital.phi_value_dict.clear() + + # Finally, loop over all shift index vectors, corresponding to the shifted unit cell + for shift_index_vector in atom.index_mask_and_effective_grid_point_positions_dict.keys(): + _index_mask, effective_grid_point_positions_array = atom.index_mask_and_effective_grid_point_positions_dict[shift_index_vector] + + # Get phi_{nl}(r) array + phi_r_array = phi_r_dict[shift_index_vector] + + # Calculate Y_{lm}(r) array + Ylm_array = spherical_harmonics(X = effective_grid_point_positions_array[:, 0], + Y = effective_grid_point_positions_array[:, 1], + Z = effective_grid_point_positions_array[:, 2], + l = l, m = m) + + # Calculate Phi_{nlm}(r) array + Phi_nlm_r_array = phi_r_array * Ylm_array + + # Store the Phi_{nlm}(r) array + phi_orbital.phi_value_dict[shift_index_vector] = Phi_nlm_r_array + + # Append the PhiOrbital object to the list + atom.phi_orbitals_list.append(phi_orbital) + + # End of loop over all magnetic quantum number m + + assert len(atom.phi_orbitals_list) == atomic_wfn_info.num_orbitals, PHI_ORBITALS_NOT_EQUAL_TO_EXPECTED_NUM_ERROR.format(len(atom.phi_orbitals_list), atomic_wfn_info.num_orbitals) + atom.num_psdwfn = num_psdwfn + atom.num_orbitals = len(atom.phi_orbitals_list) + + + + @classmethod + def get_total_number_of_orbitals(cls, atoms : List[Atom]): + """ + Get the total number of atoms + """ + assert isinstance(atoms, list), "atoms must be a list, get {} instead".format(type(atoms)) + num_orbitals = 0 + for atom in atoms: + assert isinstance(atom, PDOSCalculator.Atom), "atom must be a PDOSCalculator.Atom, get {} instead".format(type(atom)) + num_orbitals += atom.num_orbitals + + return num_orbitals + + + @classmethod + def calculate_overlap_matrix(cls, + atoms : List['PDOSCalculator.Atom'], + dV : float, + k_point_fractional : np.ndarray[float], + save_fname : Optional[str] = None, + ) -> np.ndarray[float]: + """ + Compute the overlap matrix, size = (num_orbitals, num_orbitals) + """ + # print("Calculating the overlap matrix") + + # Type check + assert isinstance(k_point_fractional, np.ndarray), K_POINT_FRACTIONAL_INPUT_NOT_NP_ARRAY_ERROR.format(type(k_point_fractional)) + assert isinstance(atoms, list), ATOMS_INPUT_NOT_LIST_ERROR.format(type(atoms)) + for atom in atoms: + assert isinstance(atom, PDOSCalculator.Atom), ATOM_INPUT_NOT_ATOM_ERROR.format(type(atom)) + assert isinstance(dV, float), DV_NOT_FLOAT_ERROR.format(type(dV)) + if save_fname is not None: + assert isinstance(save_fname, str), SAVE_FNAME_NOT_STRING_ERROR.format(type(save_fname)) + + # Get the total number of orbitals + num_atoms = len(atoms) + num_orbitals = cls.get_total_number_of_orbitals(atoms) + overlap_matrix = np.zeros((num_orbitals, num_orbitals), dtype = np.complex128) + + # Loop over different atoms + row_index = 0 + for atom_i_index, atom_i in enumerate(atoms): + num_orbitals_i = atom_i.num_orbitals + + # initialize the column index as the row index, because the overlap matrix is symmetric + col_index = row_index + + # Computing the overlap matrix between the same atom's orbitals + block_overlap_matrix = cls._calculate_overlap_matrix_between_two_atoms( + atom1 = atom_i, + atom2 = atom_i, + is_same_atom = True, + k_point_fractional = k_point_fractional, + dV = dV, + ) + + # Update the overlap matrix + overlap_matrix[row_index:row_index + num_orbitals_i, col_index:col_index + num_orbitals_i] = block_overlap_matrix + + # Update the column index + col_index += num_orbitals_i + + # Computing the overlap matrix between different atoms' orbitals + for atom_j_index in range(atom_i_index + 1, num_atoms): + atom_j = atoms[atom_j_index] + num_orbitals_j = atom_j.num_orbitals + + # Computing the overlap matrix between different atoms' orbitals + block_overlap_matrix = cls._calculate_overlap_matrix_between_two_atoms( + atom1 = atom_i, + atom2 = atom_j, + is_same_atom = False, + k_point_fractional = k_point_fractional, + dV = dV, + ) + + # Update the overlap matrix + overlap_matrix[row_index:row_index + num_orbitals_i, col_index:col_index + num_orbitals_j] = block_overlap_matrix + overlap_matrix[col_index:col_index + num_orbitals_j, row_index:row_index + num_orbitals_i] = block_overlap_matrix.conj().T + + # Update the column index + col_index += num_orbitals_j + + # Update the row index + row_index += num_orbitals_i + + # Multiply the overlap matrix by the volume element dV + # overlap_matrix *= dV + + # Save the overlap matrix + if save_fname is not None: + np.savetxt(save_fname, overlap_matrix, fmt = "%10.6f") + + # check if the overlap matrix is Hermitian + assert np.allclose(overlap_matrix, overlap_matrix.conj().T), "The overlap matrix is not Hermitian" + + # Clear the total orbitals in the unit cell dictionary for all atoms + # cls.clear_total_orbitals_in_unit_cell_dict(atoms) + + return overlap_matrix + + + @staticmethod + def clear_total_orbitals_in_unit_cell_dict(atoms : List['PDOSCalculator.Atom']): + """ + Clear the total orbitals in the unit cell dictionary for all atoms + """ + assert isinstance(atoms, list), ATOMS_INPUT_NOT_LIST_ERROR.format(type(atoms)) + for atom in atoms: + assert isinstance(atom, PDOSCalculator.Atom), ATOM_INPUT_NOT_ATOM_ERROR.format(type(atom)) + for phi_orbital in atom.phi_orbitals_list: + phi_orbital.total_orbitals_in_unit_cell_dict.clear() + + + @classmethod + def calculate_orbital_weights(cls, + atoms : List['PDOSCalculator.Atom'], + dV : float, + k_point_fractional : np.ndarray[float], + ) -> np.ndarray[float]: + """ + Compute the orbital weights, size = (num_orbitals, ) + """ + # print("Calculating the orbital weights") + + # Type check + assert isinstance(atoms, list), ATOMS_INPUT_NOT_LIST_ERROR.format(type(atoms)) + for atom in atoms: + assert isinstance(atom, PDOSCalculator.Atom), ATOM_INPUT_NOT_ATOM_ERROR.format(type(atom)) + assert isinstance(dV, float), DV_NOT_FLOAT_ERROR.format(type(dV)) + + # Get the total number of orbitals + num_atoms = len(atoms) + num_orbitals = cls.get_total_number_of_orbitals(atoms) + orbital_weights = np.zeros((num_orbitals, ),) + + # Loop over different atoms + index = 0 + for atom_index, atom in enumerate(atoms): + for idx_1, phi_orbital_1 in enumerate(atom.phi_orbitals_list): + weight_value = cls._calculate_overlap_between_two_orbitals( + phi_orbital_1 = phi_orbital_1, + phi_orbital_2 = phi_orbital_1, + k_point_fractional = k_point_fractional, + is_same_orbital = True, + index_mask_dict_1 = atom.index_mask_and_effective_grid_point_positions_dict, + dV = dV, + ) + assert np.isclose(weight_value.imag, 0.), "The weight value of the same orbital should always be real, got {} instead".format(weight_value) + orbital_weights[index + idx_1] = weight_value.real + index += atom.num_orbitals + assert index == num_orbitals, "The number of orbitals is not equal to the expected number, got {} instead".format(index) + + # Multiply the orbital's weights by the volume element dV + # orbital_weights *= dV + # print("orbital_weights = ", orbital_weights) + return orbital_weights + + + + @classmethod + def _calculate_overlap_matrix_between_two_atoms(cls, + atom1 : 'PDOSCalculator.Atom', + atom2 : 'PDOSCalculator.Atom', + k_point_fractional : np.ndarray[float], + is_same_atom : bool, + dV : float, + ) -> np.ndarray[float]: + """ + Compute the overlap matrix between two atoms, size = (atom1.num_orbitals, atom2.num_orbitals) + - Parameter dV is not considered here, because it is a constant for all atoms, and will be multiplied later + - If same_atom is True, then the overlap matrix is computed between the same atom, otherwise it is computed between two different atoms + """ + num_orbitals_1 = atom1.num_orbitals + num_orbitals_2 = atom2.num_orbitals + overlap_matrix = np.zeros((num_orbitals_1, num_orbitals_2), dtype = np.complex128) + + # If the two atoms are the same, then the overlap matrix is computed between the same atom's orbitals, and should be symmetric + if is_same_atom: + assert id(atom1) == id(atom2), TWO_ATOMS_NOT_SAME_ERROR.format(id(atom1), id(atom2)) + num_orbitals_1 = num_orbitals_2 = atom1.num_orbitals + + for idx_1, phi_orbital_1 in enumerate(atom1.phi_orbitals_list): + # Diagonal elements + overlap_matrix[idx_1, idx_1] = cls._calculate_overlap_between_two_orbitals( + phi_orbital_1 = phi_orbital_1, + phi_orbital_2 = phi_orbital_1, + k_point_fractional = k_point_fractional, + is_same_orbital = True, + index_mask_dict_1 = atom1.index_mask_and_effective_grid_point_positions_dict, + dV = dV, + ) + + # Off-diagonal elements: always zero, so commented out + for idx_2 in range(idx_1 + 1, num_orbitals_1): + phi_orbital_2 = atom1.phi_orbitals_list[idx_2] + overlap_value = cls._calculate_overlap_between_two_orbitals(phi_orbital_1 = phi_orbital_1, + phi_orbital_2 = phi_orbital_2, + k_point_fractional = k_point_fractional, + is_same_orbital = False, + index_mask_dict_1 = atom1.index_mask_and_effective_grid_point_positions_dict, + index_mask_dict_2 = atom1.index_mask_and_effective_grid_point_positions_dict, + dV = dV, + ) + if not np.isclose(overlap_value, 0.): + pass + # print(f"WARNING: The overlap matrix for the same atom's orbitals should always be diagonal, but got non-zero value {overlap_value} for the index ({idx_1}, {idx_2}).") + overlap_matrix[idx_1, idx_2] = overlap_value + overlap_matrix[idx_2, idx_1] = overlap_value.conj() + # assert np.isclose(overlap_value, 0.), "The overlap matrix for the same atom's orbitals should always be diagonal, but got non-zero value {} for the index ({}, {}).".format(overlap_value, idx_1, idx_2) + + # If the two atoms are different, then the overlap matrix is computed between two different atoms' orbitals + else: + # If the distance between the two atoms is greater than the sum of the cutoff radii, then the overlap matrix is zero. + if np.linalg.norm(atom1.atom_posn_cart - atom2.atom_posn_cart) > atom1.r_cut + atom2.r_cut: + return overlap_matrix + + for idx_1, phi_orbital_1 in enumerate(atom1.phi_orbitals_list): + for idx_2, phi_orbital_2 in enumerate(atom2.phi_orbitals_list): + overlap_value = cls._calculate_overlap_between_two_orbitals(phi_orbital_1 = phi_orbital_1, + phi_orbital_2 = phi_orbital_2, + k_point_fractional = k_point_fractional, + is_same_orbital = False, + index_mask_dict_1 = atom1.index_mask_and_effective_grid_point_positions_dict, + index_mask_dict_2 = atom2.index_mask_and_effective_grid_point_positions_dict, + dV = dV, + ) + overlap_matrix[idx_1, idx_2] = overlap_value + + return overlap_matrix + + + @classmethod + def _calculate_overlap_between_two_orbitals(cls, + phi_orbital_1 : 'PDOSCalculator.PhiOrbital', + phi_orbital_2 : 'PDOSCalculator.PhiOrbital', + k_point_fractional : np.ndarray[float], + is_same_orbital : bool, + dV : float, + index_mask_dict_1 : Optional[IndexMaskDictType] = None, + index_mask_dict_2 : Optional[IndexMaskDictType] = None, + ) -> np.ndarray[np.complex128]: + """ + Compute the overlap between two orbitals, size = (num_orbitals_1, num_orbitals_2) + - If same_orbital is True, then the overlap is computed between the same orbital, and the index_mask_dict_1 and index_mask_dict_2 is not needed + """ + # assert isinstance(phi_orbital_1, PDOSCalculator.PhiOrbital), "phi_orbital_1 must be a PDOSCalculator.PhiOrbital, get {} instead".format(type(phi_orbital_1)) + # assert isinstance(phi_orbital_2, PDOSCalculator.PhiOrbital), "phi_orbital_2 must be a PDOSCalculator.PhiOrbital, get {} instead".format(type(phi_orbital_2)) + + overlap_value = 0.0 + if is_same_orbital: + assert id(phi_orbital_1) == id(phi_orbital_2), TWO_ORBITALS_NOT_SAME_ERROR.format(id(phi_orbital_1), id(phi_orbital_2)) + # If two orbitals are the same, then the overlap is computed between the same orbital, so just the square of all the phi_value_dict values + # _phi_orbital_unit_cell = cls.construct_total_orbitals_in_unit_cell(phi_orbital = phi_orbital_1, k_point_fractional = k_point_fractional, index_mask_dict = index_mask_dict_1) + # overlap_value = (phi_orbital_1.normalization_factor ** 2) * np.sum(_phi_orbital_unit_cell.conj() * _phi_orbital_unit_cell) + overlap_value = np.array(1.0, dtype = np.complex128) + else: + # If two orbitals are different, then the overlap is computed between two different orbitals, so just the product of the phi_value_dict values + _phi_orbital_unit_cell_1 = cls.construct_total_orbitals_in_unit_cell(phi_orbital = phi_orbital_1, k_point_fractional = k_point_fractional, index_mask_dict = index_mask_dict_1) + _phi_orbital_unit_cell_2 = cls.construct_total_orbitals_in_unit_cell(phi_orbital = phi_orbital_2, k_point_fractional = k_point_fractional, index_mask_dict = index_mask_dict_2) + + _normalization_factor_1 = cls.compute_normalization_factor(dV = dV, phi_orbital = phi_orbital_1, k_point_fractional = k_point_fractional, index_mask_dict = index_mask_dict_1) + _normalization_factor_2 = cls.compute_normalization_factor(dV = dV, phi_orbital = phi_orbital_2, k_point_fractional = k_point_fractional, index_mask_dict = index_mask_dict_2) + overlap_value = (_normalization_factor_1 * _normalization_factor_2) * np.sum(_phi_orbital_unit_cell_1.conj() * _phi_orbital_unit_cell_2) * dV + + assert overlap_value.shape == (), "The overlap value must be a scalar, got {} instead".format(overlap_value.shape) + + return overlap_value + + + @classmethod + def compute_normalization_factor(cls, + dV : float, + phi_orbital : 'PDOSCalculator.PhiOrbital', + k_point_fractional : np.ndarray[float], + index_mask_dict : 'PDOSCalculator.IndexMaskDictType') -> np.ndarray[float]: + """ + Compute the normalization factor for a given phi orbital + """ + assert isinstance(dV, float), DV_NOT_FLOAT_ERROR.format(type(dV)) + assert isinstance(phi_orbital, PDOSCalculator.PhiOrbital), PHI_ORBITAL_INPUT_NOT_PHI_ORBITAL_ERROR.format(type(phi_orbital)) + assert isinstance(k_point_fractional, np.ndarray), K_POINT_FRACTIONAL_INPUT_NOT_NP_ARRAY_ERROR.format(type(k_point_fractional)) + assert isinstance(index_mask_dict, dict), INDEX_MASK_DICT_INPUT_NOT_DICT_ERROR.format(type(index_mask_dict)) + + # Convert k_point_fractional to tuple for use as dictionary key (numpy arrays are unhashable) + k_point_key = tuple(k_point_fractional) + + # If the normalization factor is already computed, then return it + if k_point_key in phi_orbital.normalization_factor_dict: + return phi_orbital.normalization_factor_dict[k_point_key] + + # If the normalization factor is not computed, then compute it + _phi_orbital_unit_cell = cls.construct_total_orbitals_in_unit_cell( + phi_orbital = phi_orbital, + k_point_fractional = k_point_fractional, + index_mask_dict = index_mask_dict) + integral_value = np.sum(_phi_orbital_unit_cell.real**2 + _phi_orbital_unit_cell.imag**2) * dV + normalization_factor = 1 / np.sqrt(integral_value) + + # Store in cache using tuple key + phi_orbital.normalization_factor_dict[k_point_key] = normalization_factor + + return normalization_factor + + + @staticmethod + def construct_total_orbitals_in_unit_cell( + phi_orbital : 'PDOSCalculator.PhiOrbital', + k_point_fractional : np.ndarray[float], + index_mask_dict : 'PDOSCalculator.IndexMaskDictType') -> np.ndarray[np.complex128]: + + assert isinstance(phi_orbital, PDOSCalculator.PhiOrbital), PHI_ORBITAL_INPUT_NOT_PHI_ORBITAL_ERROR.format(type(phi_orbital)) + assert isinstance(k_point_fractional, np.ndarray), K_POINT_FRACTIONAL_INPUT_NOT_NP_ARRAY_ERROR.format(type(k_point_fractional)) + assert isinstance(index_mask_dict, dict), INDEX_MASK_DICT_INPUT_NOT_DICT_ERROR.format(type(index_mask_dict)) + + # Convert k_point_fractional to tuple for use as dictionary key (numpy arrays are unhashable) + k_point_key = tuple(k_point_fractional) + + # If the total orbitals in the unit cell is already computed, then return it + if k_point_key in phi_orbital.total_orbitals_in_unit_cell_dict: + return phi_orbital.total_orbitals_in_unit_cell_dict[k_point_key] + + # If the total orbitals in the unit cell is not computed, then compute it + _phi_orbital_unit_cell = np.zeros_like(index_mask_dict[(0,0,0)][0], dtype=np.complex128) + + for shift_index_vector, phi_value in phi_orbital.phi_value_dict.items(): + _index_mask, _ = index_mask_dict[shift_index_vector] + bloch_phase = np.exp(1j * 2 * np.pi * np.dot(k_point_fractional, shift_index_vector)) + _phi_orbital_unit_cell[_index_mask] += phi_value * bloch_phase + + # Store in cache using tuple key + phi_orbital.total_orbitals_in_unit_cell_dict[k_point_key] = _phi_orbital_unit_cell + + return _phi_orbital_unit_cell + + + @staticmethod + def compute_normalization_factor_in_unit_cell_with_certain_k_point( + dV : float, + k_point_fractional : np.ndarray[float], + phi_orbital : 'PDOSCalculator.PhiOrbital', + index_mask_dict : 'PDOSCalculator.IndexMaskDictType') -> np.ndarray[float]: + """ + Compute the normalization factor in the unit cell with a certain k-point + """ + raise NotImplementedError("This function is deprecated, please use compute_normalization_factor() instead") + assert isinstance(dV, float), DV_NOT_FLOAT_ERROR.format(type(dV)) + assert isinstance(k_point_fractional, np.ndarray), K_POINT_FRACTIONAL_INPUT_NOT_NP_ARRAY_ERROR.format(type(k_point_fractional)) + assert isinstance(phi_orbital, PDOSCalculator.PhiOrbital), PHI_ORBITAL_INPUT_NOT_PHI_ORBITAL_ERROR.format(type(phi_orbital)) + assert isinstance(index_mask_dict, dict), INDEX_MASK_DICT_INPUT_NOT_DICT_ERROR.format(type(index_mask_dict)) + + _phi_orbital_unit_cell = np.zeros_like(index_mask_dict[(0,0,0)][0], dtype=np.complex128) + + for shift_index_vector, phi_value in phi_orbital.phi_value_dict.items(): + _index_mask, _ = index_mask_dict[shift_index_vector] + bloch_phase = np.exp(1j * 2 * np.pi * np.dot(k_point_fractional, shift_index_vector)) + _phi_orbital_unit_cell[_index_mask] += phi_value * bloch_phase + + integral_value = np.sum(_phi_orbital_unit_cell.real**2 + _phi_orbital_unit_cell.imag**2) * dV + normalization_factor = 1 / np.sqrt(integral_value) + + return normalization_factor + + + + def project_wavefunction_onto_atomic_orbital_basis_and_return_the_corresponding_coefficients(self, + orthogonalize_atomic_orbitals : bool = True, + mutiply_weights : bool = True, + save_fname : Optional[str] = None, + print_overlap_matrix : bool = False, # print overlap matrix + ) -> np.ndarray[float]: + r""" + Project the wavefunction onto the atomic orbital basis, and return the corresponding coefficients + \begin{equation} + P_{n \mathbf{k}, \mu}=\int \psi_{n \mathbf{k}}^*(\mathbf{r}) \Phi_\mu^{\text {orth }}(\mathbf{r}) d^3 \mathbf{r} + \end{equation} + + return: + P_all_array : np.ndarray[float], shape = (kpt_num, band_num, tot_orbital_num) + """ + print("Projecting the wavefunction onto the atomic orbital basis, and return the corresponding coefficients") + + # Sequential version + if self.kpt_num <= self.k_point_parallel_threshold: + print("\t Using sequential version") + P_all_array = self._project_wavefunction_onto_atomic_orbital_basis_sequential( + orthogonalize_atomic_orbitals = orthogonalize_atomic_orbitals, + print_overlap_matrix = print_overlap_matrix, + mutiply_weights = mutiply_weights) + else: + print("\t Using parallel version") + P_all_array = self._project_wavefunction_onto_atomic_orbital_basis_parallel( + orthogonalize_atomic_orbitals = orthogonalize_atomic_orbitals, + print_overlap_matrix = print_overlap_matrix, + mutiply_weights = mutiply_weights) + + # ===== save: k-point + combination coefficients P_{n,k,mu} ===== + if save_fname is not None: + print(f"\t Saving to {save_fname} ...") + A = P_all_array # (K, B, M) complex + K, B, M = A.shape + k_red = self.kpts_store[:K, :] # (K,3) reduced k + + import os + os.makedirs(os.path.dirname(save_fname), exist_ok=True) + with open(save_fname, "w") as f: + f.write("# columns: kpt band mu kx_red ky_red kz_red Re(P_nkmu) Im(P_nkmu)\n") + for k in range(K): + # 1-based indices like MATLAB + kpt_col = np.full((B*M, 1), k+1, dtype=int) + band_col = np.repeat(np.arange(1, B+1), M).reshape(-1, 1) + mu_col = np.tile(np.arange(1, M+1), B).reshape(-1, 1) + kred_col = np.tile(k_red[k], (B*M, 1)) # (B*M, 3) + Pk = A[k] # (B, M) + Re = Pk.real.reshape(-1, 1) + Im = Pk.imag.reshape(-1, 1) + rows = np.hstack([kpt_col, band_col, mu_col, kred_col, Re, Im]) + np.savetxt(f, rows, + fmt=["%d","%d","%d","%.8f","%.8f","%.8f","%.15e","%.15e"]) + + return P_all_array + + + + def project_wavefunction_onto_single_atom_atomic_orbital_basis_and_return_the_corresponding_coefficients(self, + atom_index: int, + mutiply_weights: bool = True, + save_fname: Optional[str] = None) -> np.ndarray[float]: + """ + Project the wavefunction onto the atomic orbital basis of a single atom, and return the corresponding coefficients + This function is called only if we are not to orthogonalize the atomic orbitals + """ + atom = self.atoms[atom_index] + assert isinstance(atom, PDOSCalculator.Atom), "atom must be a PDOSCalculator.Atom, get type {} instead".format(type(atom)) + assert isinstance(mutiply_weights, bool), "mutiply_weights must be a bool, get type {} instead".format(type(mutiply_weights)) + + atom_name = self.atom_species_list[atom.atom_type_index] + print("Projecting the wavefunction onto the atomic orbital basis of a single atom") + print("\tatom_type = {}, atomic_number = {}, atom_index = {}, num_orbitals = {}".format(atom_name, name_to_atomic_number(atom_name), atom_index, atom.num_orbitals)) + if self.kpt_num <= self.k_point_parallel_threshold: + print("\t Using sequential version") + P_single_atom_array = self._project_wavefunction_onto_single_atom_atomic_orbital_basis_sequential(atom = atom, mutiply_weights = mutiply_weights) + else: + print("\t Using parallel version") + P_single_atom_array = self._project_wavefunction_onto_single_atom_atomic_orbital_basis_parallel(atom = atom, mutiply_weights = mutiply_weights) + + + # ===== save: k-point + combination coefficients P_{n,k,mu} ===== + if save_fname is not None: + print("WARNING: Not to orthogonalize the atomic orbitals is not implemented yet, so not saving the projection data") + + + # raise NotImplementedError("Not to orthogonalize the atomic orbitals is not implemented yet") + return P_single_atom_array + + + def _project_wavefunction_onto_atomic_orbital_basis_sequential(self, + orthogonalize_atomic_orbitals : bool = True, + print_overlap_matrix : bool = False, + mutiply_weights : bool = True + ) -> np.ndarray[float]: + """ + Project the wavefunction onto the atomic orbital basis, and return the corresponding coefficients + """ + + # Initialize the P_all_array + P_all_array = np.zeros((self.kpt_num, self.band_num, self.tot_orbital_num), dtype = np.complex128) + if orthogonalize_atomic_orbitals: + self.overlap_matrix = np.zeros((self.kpt_num, self.tot_orbital_num, self.tot_orbital_num), dtype = np.complex128) + self.orbital_weights = None + else: + self.overlap_matrix = None + self.orbital_weights = np.zeros((self.kpt_num, self.tot_orbital_num,), dtype = np.complex128) + + # Loop over all k-points + for kpt_index in range(self.kpt_num): + + # Initialize the P_single_kpt_array + P_single_kpt_array = np.zeros((self.band_num, self.tot_orbital_num), dtype = np.complex128) + + # Get the k-vector (note the scaling of box length) + kx_frac = self.kpts_store[kpt_index, 0] + ky_frac = self.kpts_store[kpt_index, 1] + kz_frac = self.kpts_store[kpt_index, 2] + + # Get the wavefunction of the k-point and rearangeig by columns + psi_kpt = self.psi_total[:, :, kpt_index] + perm = self.I_indices[:, kpt_index].astype(int) + psi_kpt = psi_kpt[:, perm] # (tot_grid_pt, band_num) + + # Compute the overlap matrix + if orthogonalize_atomic_orbitals: + _overlap_matrix = self.calculate_overlap_matrix( + atoms = self.atoms, + dV = self.dV, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + save_fname = self.out_dirname + "/overlap_matrix_kpt_{}.txt".format(kpt_index) if print_overlap_matrix else None, + ) + self.overlap_matrix[kpt_index, :, :] = _overlap_matrix + else: + _orbital_weights = self.calculate_orbital_weights( + atoms = self.atoms, + dV = self.dV, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + ) + self.orbital_weights[kpt_index, :] = _orbital_weights + + # S_inv_sqrt.shape = (total_orbitals_num, total_orbitals_num) + # In principle, you should still compute Phi^{orth} as Phi * S_inv_sqrt, but the stacked Phi array is not + # readily available. So, we prospone the calculation of such mutiplication after the projection is completed, namely + # \bra \psi_{nk} | \Phi_{\mu}^{orth} \ket = \bra \psi_{nk} | \Phi_{\nu} \ket S^{-1/2}_{\mu\nu} + + if self.overlap_matrix is not None: + _S_inv_sqrt = fractional_matrix_power(_overlap_matrix, -0.5) + else: + _w_inv_sqrt = _orbital_weights ** (-0.5) + + # Compute the overlap with the atomic orbitals + orbital_index = 0 + for atom in self.atoms: + + for orbital in atom.phi_orbitals_list: + + # compute the overlap with the atomic orbitals + _phi_orbital_unit_cell = self.construct_total_orbitals_in_unit_cell( + phi_orbital = orbital, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + index_mask_dict = atom.index_mask_and_effective_grid_point_positions_dict, + ) + projected_value = np.sum(_phi_orbital_unit_cell[:, np.newaxis] * psi_kpt, axis = 0) + + + # Compute the normalization factor + normalization_factor = self.compute_normalization_factor( + dV = self.dV, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + phi_orbital = orbital, + index_mask_dict = atom.index_mask_and_effective_grid_point_positions_dict, + ) + + # Update the P_all_array + P_single_kpt_array[:, orbital_index] = projected_value * normalization_factor + + # Update the orbital index + orbital_index += 1 + + # Orthogonalize the P_single_kpt_array + if mutiply_weights: + if orthogonalize_atomic_orbitals: + P_single_kpt_array = np.einsum("jk,kl->jl", P_single_kpt_array, _S_inv_sqrt) + else: + P_single_kpt_array = np.einsum("jk,k->jk", P_single_kpt_array, _w_inv_sqrt) + + # Update the P_all_array + P_all_array[kpt_index, :, :] = P_single_kpt_array + + print(f"\r\t {kpt_index + 1} out of {self.kpt_num} k-points done!!", end='', flush=True) + + print() # New line after progress updates + # Multiply by the discrete volume element dV + P_all_array *= self.dV + + + return P_all_array + + + def _project_wavefunction_onto_single_atom_atomic_orbital_basis_sequential(self, + atom: 'PDOSCalculator.Atom', + mutiply_weights: bool = True) -> np.ndarray[float]: + """ + Project the wavefunction onto the atomic orbital basis, and return the corresponding coefficients + When this function is called, we are not to orthogonalize the atomic orbitals + """ + + # Initialize the P_single_atom_array + P_single_atom_array = np.zeros((self.kpt_num, self.band_num, atom.num_orbitals), dtype = np.complex128) + + # Loop over all k-points + for kpt_index in range(self.kpt_num): + + # Initialize the P_single_kpt_single_atom_array + P_single_kpt_single_atom_array = np.zeros((self.band_num, atom.num_orbitals), dtype = np.complex128) + + # Get the k-vector (note the scaling of box length) + kx_frac = self.kpts_store[kpt_index, 0] + ky_frac = self.kpts_store[kpt_index, 1] + kz_frac = self.kpts_store[kpt_index, 2] + + # Get the wavefunction of the k-point and rearangeig by columns + psi_kpt = self.psi_total[:, :, kpt_index] + perm = self.I_indices[:, kpt_index].astype(int) + psi_kpt = psi_kpt[:, perm] # (tot_grid_pt, band_num) + + # Compute the orbital weights + _orbital_weights = self.calculate_orbital_weights( + atoms = self.atoms, + dV = self.dV, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + ) + _w_inv_sqrt = _orbital_weights ** (-0.5) + + # Compute the overlap with the atomic orbitals + for orbital_index, orbital in enumerate(atom.phi_orbitals_list): + + # Loop over all the shifted unit cells and compute the overlap + _phi_orbital_unit_cell = self.construct_total_orbitals_in_unit_cell( + phi_orbital = orbital, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + index_mask_dict = atom.index_mask_and_effective_grid_point_positions_dict, + ) + projected_value = np.sum(_phi_orbital_unit_cell[:, np.newaxis] * psi_kpt, axis = 0) + + # Compute the normalization factor + normalization_factor = self.compute_normalization_factor( + dV = self.dV, + k_point_fractional = np.array([kx_frac, ky_frac, kz_frac]), + phi_orbital = orbital, + index_mask_dict = atom.index_mask_and_effective_grid_point_positions_dict, + ) + + # Update the P_all_array + P_single_kpt_single_atom_array[:, orbital_index] = projected_value * normalization_factor + + # Orthogonalize the P_all_array + start_idx, end_idx = self._get_atom_orbital_indices(target_atom = atom) + if mutiply_weights: + P_single_kpt_single_atom_array = np.einsum("jk,k->jk", P_single_kpt_single_atom_array, _w_inv_sqrt[start_idx : end_idx]) + + # Update the P_single_atom_array + P_single_atom_array[kpt_index, :, :] = P_single_kpt_single_atom_array + + print(f"\r\t {kpt_index + 1} out of {self.kpt_num} k-points done!!", end='', flush=True) + + print() # New line after progress updates + # Multiply by the discrete volume element dV + P_single_atom_array *= self.dV + + return P_single_atom_array + + + def _get_atom_orbital_indices(self, target_atom: 'PDOSCalculator.Atom', sum_over_m_index : bool = False) -> tuple[int, int]: + """ + Get the starting and ending orbital indices for a specific atom in the global orbital numbering. + Returns (start_index, end_index) where end_index is exclusive. + """ + assert isinstance(target_atom, PDOSCalculator.Atom), "target_atom must be a PDOSCalculator.Atom, get type {} instead".format(type(target_atom)) + assert isinstance(sum_over_m_index, bool), "sum_over_m_index must be a bool, get type {} instead".format(type(sum_over_m_index)) + + start_index = 0 + if not sum_over_m_index: + for atom in self.atoms: + if id(atom) == id(target_atom): + return start_index, start_index + atom.num_orbitals + start_index += atom.num_orbitals + raise ValueError(f"Target atom not found in atoms list") + else: + for atom in self.atoms: + if id(atom) == id(target_atom): + return start_index, start_index + atom.num_psdwfn + start_index += atom.num_orbitals + raise ValueError(f"Target atom not found in atoms list") + + + def _project_single_atom_wavefunction_onto_atomic_orbital_basis(self, + pdos_atom_index_list : List[int], + orthogonalize_atomic_orbitals : bool = True, + save_fname : Optional[str] = None, + print_overlap_matrix : bool = False, + ) -> np.ndarray[float]: + + """ + Project the wavefunction onto the atomic orbital basis, and return the corresponding coefficients + """ + P_single_atom_array_list = [] + + if orthogonalize_atomic_orbitals: + # initialize the P_all_array + P_all_array = self.project_wavefunction_onto_atomic_orbital_basis_and_return_the_corresponding_coefficients( + orthogonalize_atomic_orbitals = True, + mutiply_weights = True, + save_fname = save_fname, + print_overlap_matrix = print_overlap_matrix, + ) + for pdos_atom_index in pdos_atom_index_list: + # get the atom + atom = self.atoms[pdos_atom_index] + start_idx, end_idx = self._get_atom_orbital_indices(target_atom = atom) + _P_single_atom_array = P_all_array[:, :, start_idx : end_idx] + P_single_atom_array_list.append(_P_single_atom_array) + else: + # not to orthogonalize the atomic orbitals, thus all the calculation can be accelerated + for pdos_atom_index in pdos_atom_index_list: + if print_overlap_matrix: + print(NOT_ORTHOGONALIZE_ATOMIC_ORBITALS_OVERLAP_MATRIX_NOT_PRINTED_WARNING) + + _P_single_atom_array = self.project_wavefunction_onto_single_atom_atomic_orbital_basis_and_return_the_corresponding_coefficients( + atom_index = pdos_atom_index, + mutiply_weights = True, + save_fname = save_fname) + P_single_atom_array_list.append(_P_single_atom_array) + + return P_single_atom_array_list + + + def _project_wavefunction_onto_atomic_orbital_basis_parallel(self, + orthogonalize_atomic_orbitals: bool = True, + print_overlap_matrix: bool = False, + mutiply_weights: bool = True, + ) -> np.ndarray: + """ + Parallel projection: unified worker that processes complete k-point calculation. + Same logic as sequential version, but parallelized over k-points. + """ + import multiprocessing as mp + import time + + # Initialize overlap matrix or orbital weights storage (same as sequential version) + if orthogonalize_atomic_orbitals: + self.overlap_matrix = np.zeros((self.kpt_num, self.tot_orbital_num, self.tot_orbital_num), dtype=np.complex128) + self.orbital_weights = None + else: + self.overlap_matrix = None + self.orbital_weights = np.zeros((self.kpt_num, self.tot_orbital_num,), dtype=np.complex128) + + # Put psi_total into shared memory + time_shm_start = time.time() + psi_meta, psi_owner = _shm_from_ndarray(self.psi_total) + time_shm_end = time.time() + print(f"\t Shared memory warm-up time: {time_shm_end - time_shm_start:.4f} seconds ({self.psi_total.nbytes / 1024 / 1024:.2f} MB)") + + # Result array + P_all_array = np.zeros((self.kpt_num, self.band_num, self.tot_orbital_num), dtype=np.complex128) + + # Setup initializer arguments for unified worker + initargs = ( + psi_meta, + self.I_indices, + self.kpts_store, + self.atoms, + self.dV, + orthogonalize_atomic_orbitals, + mutiply_weights, + self.out_dirname, + print_overlap_matrix, + self.tot_orbital_num, + self.kpt_num, + ) + + # Parallel processing: each worker processes one complete k-point + with mp.Pool(processes=mp.cpu_count(), + initializer=_init_unified_worker, + initargs=initargs) as pool: + chunksize = max(1, self.kpt_num // (4 * mp.cpu_count()) or 1) + for kpt_index, result in pool.imap_unordered( + _process_single_kpoint_complete_worker, range(self.kpt_num), chunksize=chunksize): + P_all_array[kpt_index, :, :] = result + + # Multiply by dV (same as sequential version) + P_all_array *= self.dV + + # Release shared memory + psi_owner.close() + psi_owner.unlink() + + return P_all_array + + + def _project_wavefunction_onto_single_atom_atomic_orbital_basis_parallel( + self, atom: 'PDOSCalculator.Atom', mutiply_weights: bool = True) -> np.ndarray[float]: + """ + Project the wavefunction onto the atomic orbital basis, and return the corresponding coefficients. + Same logic as sequential version. + """ + import multiprocessing as mp + import time + + # Get atom orbital indices for weights + start_idx, end_idx = self._get_atom_orbital_indices(target_atom=atom) + + # --- pack the single atom into a pure numpy structure for serialization --- + atom_packed = { + "num_orbitals": atom.num_orbitals, + "orbitals": [] + } + for orbital in atom.phi_orbitals_list: + entries = [] + for (i, j, k), phi_value in orbital.phi_value_dict.items(): + mask, _ = atom.index_mask_and_effective_grid_point_positions_dict.get((i, j, k), (None, None)) + assert mask is not None, INDEX_MASK_NOT_FOUND_ERROR.format(i, j, k) + entries.append({ + "ijk": (int(i), int(j), int(k)), + "phi": np.asarray(phi_value), + "mask": np.asarray(mask) + }) + atom_packed["orbitals"].append({"entries": entries}) + + # --- 1) put psi_total into shared memory (only copy once) --- + time_shm_start = time.time() + psi_meta, psi_owner = _shm_from_ndarray(self.psi_total) + time_shm_end = time.time() + print(f"\t Shared memory warm-up time: {time_shm_end - time_shm_start:.4f} seconds ({self.psi_total.nbytes / 1024 / 1024:.2f} MB)") + + try: + # --- 2) pre-allocate the result --- + P_single_atom_array = np.zeros((self.kpt_num, self.band_num, atom.num_orbitals), dtype=np.complex128) + + # --- 3) start the pool: use the _init_worker_for_single_atom --- + initargs = ( + psi_meta, + self.I_indices, + self.kpts_store, + getattr(self, "latvec", None), + getattr(self, "latvec_inv", None), + self.is_orthogonal_lattice, + self.Lx, self.Ly, self.Lz, + atom_packed, # packed atom data + self.atoms, # full atoms list for calculate_orbital_weights + self.dV, + mutiply_weights, + start_idx, + end_idx, + self.kpt_num, + ) + + with mp.Pool(processes=mp.cpu_count(), + initializer=_init_worker_for_single_atom, + initargs=initargs) as pool: + chunksize = max(1, self.kpt_num // (4*mp.cpu_count()) or 1) + for kpt_index, result in pool.imap_unordered( + _process_single_kpoint_for_single_atom_worker, + range(self.kpt_num), + chunksize=chunksize + ): + P_single_atom_array[kpt_index, :, :] = result + + # --- 4) post-processing: multiply by dV (same as sequential version) --- + P_single_atom_array *= self.dV + + finally: + # --- 5) clean up the shared memory --- + psi_owner.close() + psi_owner.unlink() + + return P_single_atom_array + + + + @classmethod + def load_projections_from_txt(cls, path: str) -> Tuple[np.ndarray, np.ndarray]: + """ + Read the combination coefficients file (text) output by the save routine + Column order: kpt band mu kx_red ky_red kz_red Re(P) Im(P) + + Returns + ------- + P : np.ndarray + complex array of shape (K, B, M), corresponding to P_{n,k,mu} + kpts_red : np.ndarray + shape (K, 3) reduced k-point coordinates + """ + # read in (automatically skip the header starting with #; support comma or blank separation) + arr = np.genfromtxt(path, comments="#", delimiter=None) + if arr.ndim == 1: # only one row + arr = arr[None, :] + + if arr.shape[1] < 8: + raise ValueError("Input file must have at least 8 columns: " + "kpt band mu kx_red ky_red kz_red Re Im") + + kpt_col = arr[:, 0].astype(int) + band_col = arr[:, 1].astype(int) + mu_col = arr[:, 2].astype(int) + kx_red = arr[:, 3] + ky_red = arr[:, 4] + kz_red = arr[:, 5] + Re = arr[:, 6] + Im = arr[:, 7] + + K = int(kpt_col.max()) + B = int(band_col.max()) + M = int(mu_col.max()) + + # Basic consistency check + expected = K * B * M + if arr.shape[0] != expected: + raise ValueError(f"Row count mismatch: got {arr.shape[0]}, expected {expected} (= K*B*M).") + + # Construct P(k,b,m) + P = np.empty((K, B, M), dtype=np.complex128) + P[kpt_col - 1, band_col - 1, mu_col - 1] = Re + 1j * Im + + # Extract the reduced coordinates of each kpt (each kpt should be consistent, take the first one) + kpts_red = np.zeros((K, 3), dtype=float) + for kk in range(1, K + 1): + mask = (kpt_col == kk) + if not np.any(mask): + raise ValueError(f"No rows found for kpt={kk}") + kpts_red[kk - 1, 0] = kx_red[mask][0] + kpts_red[kk - 1, 1] = ky_red[mask][0] + kpts_red[kk - 1, 2] = kz_red[mask][0] + + return P, kpts_red + + + + def compute_pdos_dos(self, data_projections : np.ndarray): + E, PDOS_plot, DOS = _compute_pdos_dos( + eig_eV = self.eign * self.Ha2eV, + DATA_projections = data_projections, + kpt_wts_store = self.kpt_wts_store, + mu_eV = self.mu_PDOS, + N_PDOS = self.N_PDOS, + min_E_plot = self.min_E_plot, + max_E_plot = self.max_E_plot, + kpt_mesh_shape = (self.kpt1, self.kpt2, self.kpt3), + ) + return E, PDOS_plot, DOS + + + def __print_parameters(self): + + + # Print initialization parameters + self.print_initialization_parameters() + + # Print SPARC's output file parameters (.out) + self.print_sparc_out_file_parameters() + + # Print SPARC's static file parameters (.static) + self.print_sparc_static_file_parameters() + + # Print SPARC's eigen file parameters (.eigen) + self.print_sparc_eigen_file_parameters() + + # Print SPARC's orbital file parameters (.psi) + self.print_sparc_orbital_file_parameters() + + # Print UPF files parameters (.upf) + for i in range(self.natom_types): + self.print_atomic_wave_function(self.atomic_wave_function_list[i]) + + # Print the index mask, effective grid point positions and phi_orbitals_list information for all atoms + self.print_atoms_updated_parameters() + + + + def print_parameters(self, save_fname : Optional[str] = None): + """ + Some visualization, if necessary + Although all printing/plotting actions are nested in this function, they can be called separately + """ + if save_fname is not None: + assert isinstance(save_fname, str), SAVE_FNAME_NOT_STRING_ERROR.format(type(save_fname)) + + # Create a log file + log_file_path = os.path.join(self.out_dirname, save_fname) + log_file = open(log_file_path, 'w', encoding='utf-8') + + # Redirect the standard output + class TeeOutput: + def __init__(self, file): + self.file = file + self.stdout = sys.stdout + + def write(self, text): + self.stdout.write(text) + self.file.write(text) + self.file.flush() + + def flush(self): + self.stdout.flush() + self.file.flush() + + sys.stdout = TeeOutput(log_file) + + # Print the parameters + self.__print_parameters() + + # Close the log file + if save_fname is not None: + log_file.close() + sys.stdout = sys.__stdout__ + + + + # @print_time("Time taken to read the SPARC's output file (function={}) : {:.4f} seconds \n") + def read_sparc_out_file_parameters(self, fname : str): + assert isinstance(fname, str), FNAME_NOT_STRING_ERROR.format(type(fname)) + print("Reading the SPARC's output file") + print("\t fname = ", fname) + + # read the SPARC's output file + with open(fname, 'r') as f: + lines = f.read().splitlines() + + # KPOINT_GRID + kpt_values = re.findall(r'\d+', lines[_find_last_line_index("KPOINT_GRID", lines)]) + self.kpt1, self.kpt2, self.kpt3 = map(int, kpt_values) + + # FD_GRID + fd_values = re.findall(r'\d+', lines[_find_last_line_index("FD_GRID", lines)]) + self.Nx, self.Ny, self.Nz = map(int, fd_values) + + # XC_FUNCTIONAL + self.xc_functional = lines[_find_last_line_index("EXCHANGE_CORRELATION", lines)].split()[-1] + + # BC + parts = lines[_find_last_line_index("BC", lines)].split() + self.bcx, self.bcy, self.bcz = parts[1], parts[2], parts[3] + + # NSTATES + self.band_num = int(re.findall(r'\d+', lines[_find_last_line_index("NSTATES", lines)])[0]) + + # Number of symmetry adapted k-points + self.kpt_num = int(re.findall(r'\d+', lines[_find_last_line_index("Number of symmetry adapted k-points", lines)])[0]) + + # Fermi level + fermi_str = re.findall(r'[+-]?[0-9]+\.[0-9]+E[+-]?[0-9]+', lines[_find_last_line_index("Fermi level", lines)])[0] + self.fermi = float(fermi_str) * self.Ha2eV + + # get the psp file names + self.psp_fname_list = get_psp_fname_list(output_fname = fname) + + # update the number of grid points according to the boundary conditions + if self.bcx == "D": self.Nx = self.Nx + 1 + if self.bcy == "D": self.Ny = self.Ny + 1 + if self.bcz == "D": self.Nz = self.Nz + 1 + + # parse the atom types and species + self.atom_count_list = self.parse_atom_types_from_sparc_out_file(fname = fname) + self.tot_atoms_num = sum(self.atom_count_list) + self.out_file_loaded_flag = True + + if not self.is_relaxation: + # Lattice setup will be handled by check_lattice_type() method + self.check_and_setup_lattice_parameters(lines = lines) + else: + # Read in the relaxation flag for furthur usage + self.relax_flag = int(re.findall(r'\d+', lines[_find_last_line_index("RELAX_FLAG", lines)])[0]) + print("\t self.relax_flag = ", self.relax_flag) + + # check if all the parameters are read in correctly + self.check_sparc_out_file_parameters() + + + def check_and_setup_lattice_parameters(self, lines : List[str]): + """ + Check and setup the lattice type based on the input file + """ + # Check if LATVEC is present in the output file + with open(self.output_fname, 'r') as f: + content = f.read() + + self.is_orthogonal_lattice = self.check_orthogonal_lattice(lines = lines) + + if self.is_orthogonal_lattice: + self.setup_orthogonal_lattice(lines = lines) + else: + self.setup_non_orthogonal_lattice(lines = lines) + + + def check_orthogonal_lattice(self, lines : List[str]) -> bool: + """ + Check if the lattice is orthogonal + return: + True : orthogonal lattice + False : non-orthogonal lattice + """ + # try to directly determine the lattice type from lattice vectors, if proviced + + # Find LATVEC section (these are normalized direction vectors) + latvec_start = -1 + for i, line in enumerate(lines): + if 'LATVEC:' in line: + latvec_start = i + 1 + break + + if latvec_start == -1: + print(LATVEC_SECTION_NOT_FOUND_WARNING) + return True + else: + + # Read three lattice vector directions (normalized) + latvec_lines = lines[latvec_start:latvec_start + 3] + latvec_directions = np.zeros((3, 3)) + + for i, line in enumerate(latvec_lines): + values = [float(x) for x in line.strip().split()] + if len(values) != 3: + raise ValueError(INVALID_LATTICE_VECTOR_FORMAT_ERROR.format(line)) + + if not np.isclose(np.linalg.norm(values), 1.0, atol = 1e-6): + values = np.array(values) / np.linalg.norm(values) + assert np.isclose(np.linalg.norm(values), 1.0, atol = 1e-6), LATTICE_VECTOR_NOT_NORMALIZED_ERROR.format(i+1, np.linalg.norm(values)) + + latvec_directions[i, :] = values + + return np.allclose(latvec_directions, np.eye(3), atol = 1e-6) + + + + def setup_orthogonal_lattice(self, lines : List[str]): + """ + Setup parameters for orthogonal lattice + """ + + # For orthogonal lattice, the lattice vectors are the same as the lattice constants + self.Lx, self.Ly, self.Lz = self.get_lattice_scale_from_output_file(lines = lines) + + # calculate the lattice vectors + self.x_lattice_vector = np.array([self.Lx, 0, 0]) + self.y_lattice_vector = np.array([0, self.Ly, 0]) + self.z_lattice_vector = np.array([0, 0, self.Lz]) + + # calculate the grid spacing + self.dx = self.Lx / self.Nx + self.dy = self.Ly / self.Ny + self.dz = self.Lz / self.Nz + + # calculate the volume of the unit grid cell + self.dV = self.dx * self.dy * self.dz + + # Cell volume + self.cell_volume = self.Lx * self.Ly * self.Lz + + + def setup_non_orthogonal_lattice(self, lines : List[str]): + """ + Setup parameters for non-orthogonal lattice + """ + # Read lattice vectors from output file + self.read_lattice_vectors_and_cell_scale_from_output_for_non_orthogonal_lattice(lines = lines) + + # Calculate derived quantities + self.calculate_non_orthogonal_parameters() + + # Check the lattice parameters + self.check_lattice_parameters() + + + @staticmethod + def get_lattice_scale_from_output_file(lines : List[str]) -> Tuple[float, float, float]: + """ + Get lattice scale from output file + """ + # For non-orthogonal lattice, read CELL parameters (these are the actual lengths) + try: + cell_line = lines[_find_last_line_index("CELL", lines)] + cell_values = re.findall(SCIENTIFIC_NOTATION_PATTERN, cell_line) # Match both regular floats and scientific notation (e.g., 7.1968E+00) + assert len(cell_values) == 3 + return map(float, cell_values) + except: + pass + + try: + latvec_line = lines[_find_last_line_index("LATVEC_SCALE", lines)] + latvec_values = re.findall(SCIENTIFIC_NOTATION_PATTERN, latvec_line) # Match both regular floats and scientific notation (e.g., 7.1968E+00) + assert len(latvec_values) == 3 + return map(float, latvec_values) + except: + raise ValueError(LATVEC_SCALE_OR_CELL_NOT_FOUND_ERROR) + + def read_lattice_vectors_and_cell_scale_from_output_for_non_orthogonal_lattice(self, lines : List[str]): + """ + Read lattice vectors and cell scale from SPARC output file + Initialized paramters: + self.Lx, self.Ly, self.Lz : float + self.latvec : np.ndarray[float] + """ + # For non-orthogonal lattice, read CELL parameters (these are the actual lengths) + self.Lx, self.Ly, self.Lz = self.get_lattice_scale_from_output_file(lines = lines) + + # Find LATVEC section (these are normalized direction vectors) + latvec_start = -1 + for i, line in enumerate(lines): + if 'Lattice vectors (Bohr)' in line: + latvec_start = i + 1 + break + + if latvec_start == -1: + raise ValueError("Cell section not found in output file") + + # Read three lattice vector directions (normalized) + latvec_row = np.zeros((3, 3)) + latvec_lines = lines[latvec_start:latvec_start + 3] + + for i, line in enumerate(latvec_lines): + values = [float(x) for x in line.strip().split()] + if len(values) != 3: + raise ValueError(INVALID_LATTICE_VECTOR_FORMAT_ERROR.format(line)) + + if not np.isclose(np.linalg.norm(values), 1.0, atol = 1e-6): + print(LATTICE_VECTOR_NOT_NORMALIZED_WARNING.format(i+1, np.linalg.norm(values))) + # values = np.array(values) / np.linalg.norm(values) + # assert np.isclose(np.linalg.norm(values), 1.0, atol = 1e-6), LATTICE_VECTOR_NOT_NORMALIZED_ERROR.format(i+1, np.linalg.norm(values)) + + latvec_row[i, :] = values + + # Store as column vectors (transpose) for compatibility with our code + self.latvec = latvec_row.T + + print("\t Cell lengths: Lx={:.6f}, Ly={:.6f}, Lz={:.6f} Bohr".format(self.Lx, self.Ly, self.Lz)) + print("\t Actual lattice vectors (Bohr):") + print("\t a1 = ({:.6f}, {:.6f}, {:.6f})".format(self.latvec[0, 0], self.latvec[1, 0], self.latvec[2, 0])) + print("\t a2 = ({:.6f}, {:.6f}, {:.6f})".format(self.latvec[0, 1], self.latvec[1, 1], self.latvec[2, 1])) + print("\t a3 = ({:.6f}, {:.6f}, {:.6f})".format(self.latvec[0, 2], self.latvec[1, 2], self.latvec[2, 2])) + + + def calculate_non_orthogonal_parameters(self): + """ + Calculate derived parameters for non-orthogonal lattice + """ + + # Calculate determinant and inverse + self.latvec_det = np.linalg.det(self.latvec) + if abs(self.latvec_det) < 1e-12: + raise ValueError("Lattice vectors are linearly dependent") + self.latvec_inv = np.linalg.inv(self.latvec) + + # Cell volume is the determinant of the lattice vectors matrix + self.cell_volume = abs(self.latvec_det) + + # Calculate metric tensor g_ij = a_i · a_j + self.metric_tensor = np.dot(self.latvec, self.latvec.T) + self.metric_tensor_inv = np.linalg.inv(self.metric_tensor) + + # Jacobian determinant for coordinate transformation + self.jacobian_det = abs(self.latvec_det) + + # Set lattice vectors for compatibility + self.x_lattice_vector = self.latvec[:, 0] + self.y_lattice_vector = self.latvec[:, 1] + self.z_lattice_vector = self.latvec[:, 2] + + + # calculate the grid spacing + # For non-orthogonal lattice, we need to calculate grid spacing based on actual lattice vectors + # The grid spacing should be calculated from the actual lattice vector lengths + # We use the CELL values (which are the actual lengths) divided by grid points + self.dx = self.Lx / self.Nx + self.dy = self.Ly / self.Ny + self.dz = self.Lz / self.Nz + + # Calculate volume element + # For non-orthogonal lattice, the volume element is the cell volume divided by total grid points + self.dV = self.cell_volume / (self.Nx * self.Ny * self.Nz) + + print(f"Cell volume: {self.cell_volume:.6f} Bohr³") + print(f"Volume element dV: {self.dV:.6e} Bohr³") + + + def parse_atom_types_from_sparc_out_file(self, fname: str) -> List[int]: + """ + Parse atomic species and counts from output file. + Example match: 'Number of atoms of type 1 : 2' + return: + atom_count_list : List[int] , number of atoms of each type + """ + atom_type_list = [] + atom_count_list = [] + + with open(fname, 'r') as f: + lines = f.readlines() + + # pattern: Number of atoms of type 1 : 2 + pattern = re.compile(r'Number of atoms of type\s+(\d+)\s*:\s*(\d+)') + + for line in lines: + match = pattern.search(line) + if match: + atom_type_list.append(int(match.group(1))) + atom_count_list.append(int(match.group(2))) + + + # check if the number of atoms is correct + assert len(atom_type_list) == self.natom_types, NUMBER_OF_ATOM_TYPES_NOT_EQUAL_TO_OUTPUT_FILE_ERROR.format(len(atom_type_list)) + assert len(atom_count_list) == self.natom_types, NUMBER_OF_ATOM_COUNTS_NOT_EQUAL_TO_OUTPUT_FILE_ERROR.format(len(atom_count_list)) + for i in range(self.natom_types): + assert atom_type_list[i] == i+1, ATOM_TYPE_NOT_EQUAL_TO_OUTPUT_FILE_ERROR.format(atom_type_list[i]) + + return atom_count_list + + + @classmethod + def parse_atom_species_from_sparc_out_file(cls, output_fname: str) -> Tuple[int, List[str]]: + """ + Parse atomic species names from output file. + Example match: 'Atom type 1 (valence electrons) : Al 3' + return: + natom_types : int , number of atom types + atom_species_list : List[str] , names of atomic species + """ + atom_species_list = [] + + with open(output_fname, 'r') as f: + lines = f.readlines() + + # pattern: Atom type 1 (valence electrons) : Al 3 + pattern = re.compile(r'Atom type\s+(\d+)\s*\([^)]*\)\s*:\s*(\w+)') + + for line in lines: + match = pattern.search(line) + if match: + atom_type_num = int(match.group(1)) + atom_species = match.group(2) + atom_species_list.append(atom_species) + + # Sort by atom type number to ensure correct order + atom_species_list = [x for _, x in sorted(zip(range(1, len(atom_species_list) + 1), atom_species_list))] + natom_types = len(atom_species_list) + + # check if the number of atom species is correct + assert natom_types != 0, f"Number of atom species ({len(atom_species_list)}) is 0" + + return natom_types, atom_species_list + + + def read_atomic_wave_function_from_upf_file(self, fname: str, atom_type_index: int, atom_species: str) -> 'PDOSCalculator.AtomicWaveFunction': + """ + Parse the atomic wave function for one atom type from a UPF file (.upf) + """ + assert isinstance(atom_type_index, int), f"atom_index must be int, got {type(atom_type_index)}" + + # reading the upf file for each type of element + with open(fname, 'r') as f: + lines = f.read().splitlines() + + # ---- Find all PP_CHI entries ---- + chi_indices = [i for i, line in enumerate(lines) if 'PP_CHI' in line] + num_psdwfn = len(chi_indices) // 2 + + AtomicWF = PDOSCalculator.AtomicWaveFunction( + atom_type_index=atom_type_index, + upf_fname=fname, + atom_species=atom_species, + r_cut=self.r_cut_max[atom_type_index] if isinstance(self.r_cut_max, list) else self.r_cut_max, + num_psdwfn=num_psdwfn, + num_orbitals=0, + ) + AtomicWF.psdwfn_list.clear() + + r_cut_orbitals = [] + + for k in range(num_psdwfn): + psdwfn = PDOSCalculator.PseudoWaveFunction() + + # extract l + l_line = lines[chi_indices[2 * k] + 8] + psdwfn.l = int(re.findall(r'\d+', l_line)[0]) + psdwfn.no_m = 2 * psdwfn.l + 1 + AtomicWF.num_orbitals += psdwfn.no_m + + # extract n + n_line = lines[chi_indices[2 * k] + 7] + psdwfn.n = int(re.findall(r'\d+', n_line)[0]) + + # extract chi(r) + chi_start = chi_indices[2 * k] + 9 + chi_end = chi_indices[2 * k + 1] - 1 + chi = [] + for line in lines[chi_start:chi_end+1]: + numbers = re.findall(r'[+-]?[0-9]+\.[0-9]+E[+-]?[0-9]+', line) + chi.extend(map(float, numbers)) + chi = np.array(chi) + psdwfn.chi = chi + + # extract r-grid from PP_R section + r_indices = [i for i, line in enumerate(lines) if 'PP_R' in line] + if len(r_indices) < 2: + raise ValueError("PP_R section not found or malformed.") + r_lines = lines[r_indices[0]+1 : r_indices[1]] + r = [] + for line in r_lines: + numbers = re.findall(r'\d+\.\d+', line) + r.extend(map(float, numbers)) + psdwfn.r = r + + # construct phi_r + phi_r = np.zeros_like(chi) + phi_r[1:] = chi[1:] / r[1:] # phi_r(r) = chi(r) / r, for r > 0 + phi_r[0] = phi_r[1] # phi_r(0) = phi_r(1), for r = 0 + psdwfn.phi_r = phi_r + + # update r_cut variable in AtomicWF according to the tolerance and r_cut_max + r_cut_max_index = len(psdwfn.r) - 1 + for i in range(len(psdwfn.r)): + integral = np.trapezoid(np.array(psdwfn.chi[:i+1]) ** 2, psdwfn.r[:i+1]) + if abs(integral - 1.0) < self.atomic_wave_function_tol: + r_cut_max_index = i + break + r_cut_orbitals.append(psdwfn.r[r_cut_max_index]) + # print(f"\t atomic wave function {atom_species} r_cut = {AtomicWF.r_cut}") + + # append psdwfn to AtomicWF + AtomicWF.psdwfn_list.append(psdwfn) + # print(f"\t atomic wave function {atom_species}, n={psdwfn.n}, l={psdwfn.l} r_cut = {psdwfn.r[r_cut_max_index]}") + + + # # check if r_cut_max is acceptable + # # update r_cut variable in AtomicWF according to the tolerance and r_cut_max + # for i in range(len(psdwfn.r)): + # if psdwfn.r[i] > AtomicWF.r_cut: + # r_cut_max_index = i + # break + # integral_test = np.trapezoid(np.array(psdwfn.chi[:r_cut_max_index+1]) ** 2, psdwfn.r[:r_cut_max_index+1]) + # print(f"\t atomic wave function {atom_species}, n={psdwfn.n}, l={psdwfn.l}: integral_chi²(r) in [0, 10] = {integral_test}") + + + # update the r_cut variable in AtomicWF according to the tolerance and r_cut_max + AtomicWF.r_cut = min(AtomicWF.r_cut, max(r_cut_orbitals)) + + # print the r_cut value + # print(f"\t atomic wave function {atom_species} r_cut = {AtomicWF.r_cut}") + + return AtomicWF + + + def read_atomic_wave_function_from_atomic_wave_function_generator(self, + atomic_wave_function_generator: AtomicWaveFunctionGeneratorType, + atom_type_index: int, + atomic_number: int, + atom_species: str) -> 'PDOSCalculator.AtomicWaveFunction': + """ + Read the atomic wave function from the atomic wave function generator + """ + assert callable(atomic_wave_function_generator), \ + ATOMIC_WAVE_FUNCTION_GENERATOR_NOT_CALLABLE_ERROR.format(type(atomic_wave_function_generator)) + r_array, orbitals, n_l_orbitals, info_dict = atomic_wave_function_generator(atomic_number = atomic_number) + + # Validate input shapes + assert r_array.ndim == 1, f"r_array should be 1D, got shape {r_array.shape}" + assert orbitals.ndim == 2, f"orbitals should be 2D, got shape {orbitals.shape}" + assert n_l_orbitals.ndim == 2, f"n_l_orbitals should be 2D, got shape {n_l_orbitals.shape}" + assert n_l_orbitals.shape[1] == 2, f"n_l_orbitals second dimension should be 2, got {n_l_orbitals.shape[1]}" + assert orbitals.shape[1] == n_l_orbitals.shape[0], f"Number of orbitals ({orbitals.shape[1]}) should match n_l_orbitals first dimension ({n_l_orbitals.shape[0]})" + + AtomicWF = PDOSCalculator.AtomicWaveFunction( + atom_type_index = atom_type_index, + atom_species = atom_species, + upf_fname = None, + r_cut = self.r_cut_max[atom_type_index] if isinstance(self.r_cut_max, list) else self.r_cut_max, # Use the full r_array as r_cut for all angular directions + num_psdwfn = orbitals.shape[1], # Number of orbitals + num_orbitals = 0, # n_l_orbitals array with shape (#orbitals, 2) + ) + + # Clear existing psdwfn_list and populate with orbital data + AtomicWF.psdwfn_list.clear() + + # Create PseudoWaveFunction objects for each orbital + r_cut_orbitals = [] + for k in range(orbitals.shape[1]): + psdwfn = PDOSCalculator.PseudoWaveFunction() + + # Extract n and l from n_l_orbitals + n_val = int(n_l_orbitals[k, 0]) # First column is n + l_val = int(n_l_orbitals[k, 1]) # Second column is l + + psdwfn.n = n_val + psdwfn.l = l_val + psdwfn.no_m = 2 * l_val + 1 # Number of m values for this l + AtomicWF.num_orbitals += psdwfn.no_m + + # compute the phi_r value + chi, r = orbitals[:, k], r_array + phi_r = np.zeros_like(chi) + phi_r[1:] = chi[1:] / r[1:] # phi_r(r) = chi(r) / r, for r > 0 + phi_r[0] = phi_r[1] # phi_r(0) = phi_r(1), for r = 0 + + # Extract the orbital data for this specific orbital + psdwfn.chi = chi # Wave function values for this orbital + psdwfn.r = r_array # Radial grid points + psdwfn.phi_r = phi_r # Same as phi for atomic orbitals + + # update r_cut variable in AtomicWF according to the tolerance and r_cut_max + r_cut_max_index = len(psdwfn.r) - 1 + for i in range(len(psdwfn.r)): + integral = np.trapezoid(np.array(psdwfn.chi[:i+1]) ** 2, psdwfn.r[:i+1]) + if abs(integral - 1.0) < self.atomic_wave_function_tol: + r_cut_max_index = i + break + r_cut_orbitals.append(psdwfn.r[r_cut_max_index]) + + # Append to AtomicWF + AtomicWF.psdwfn_list.append(psdwfn) + + # update the r_cut variable in AtomicWF according to the tolerance and r_cut_max + AtomicWF.r_cut = min(AtomicWF.r_cut, max(r_cut_orbitals)) + + return AtomicWF + + + def atom_wise_compute_normalization_factor_in_unit_cell(self, atom: 'PDOSCalculator.Atom'): + """ + Normalize the atomic wave functions + """ + assert isinstance(atom, PDOSCalculator.Atom), ATOM_INPUT_NOT_ATOM_ERROR.format(type(atom)) + assert len(atom.phi_orbitals_list) == atom.num_orbitals, PHI_ORBITALS_NOT_EQUAL_TO_EXPECTED_NUM_ERROR.format(atom.num_orbitals, len(atom.phi_orbitals_list)) + + for phi_orbital in atom.phi_orbitals_list: + + # initialize the grid-wise phi orbitals to zero in the unit cell + + _phi_orbital_unit_cell = self.construct_total_orbitals_in_unit_cell( + phi_orbital = phi_orbital, + k_point_fractional = np.array([0, 0, 0]), + index_mask_dict = atom.index_mask_and_effective_grid_point_positions_dict) + + # normalize the grid-wise phi orbitals + integral_of_phi_orbital_unit_cell = np.sum(_phi_orbital_unit_cell ** 2) * self.dV + phi_orbital.normalization_factor = 1 / np.sqrt(integral_of_phi_orbital_unit_cell) + + + # @print_time("Time taken to read the SPARC's static file (function={}) : {:.4f} seconds \n") + def read_sparc_static_file_parameters(self, fname: str, atom_count_list: List[int]): + """ + Read atomic positions (fractional and cartesian) from SPARC .static file. + """ + assert isinstance(fname, str), STATIC_FNAME_NOT_STRING_ERROR.format(type(fname)) + assert isinstance(atom_count_list, list), ATOM_COUNT_LIST_NOT_LIST_ERROR.format(type(atom_count_list)) + + print("Reading the SPARC's static file") + print("\t fname = ", fname) + print("\t number of atoms = ", sum(atom_count_list)) + + with open(fname, 'r') as f: + lines = f.read().splitlines() + + atom_position_indices = [i for i, line in enumerate(lines) if "Fractional coordinates" in line] + assert len(atom_position_indices) == len(atom_count_list), \ + f"Expected {len(atom_count_list)} atomic blocks, but found {len(atom_position_indices)}" + + atoms = [] + for atom_type_index, natom in enumerate(atom_count_list): + start_index = atom_position_indices[atom_type_index] + for j in range(1, natom + 1): + line = lines[start_index + j] + frac_coords = [float(x) for x in re.findall(r'\d+\.\d+', line)] + assert len(frac_coords) == 3, f"Expected 3 fractional coordinates, got {frac_coords}" + if self.is_orthogonal_lattice: + atom = PDOSCalculator.Atom( + atom_type_index = atom_type_index, + atom_posn_frac = np.array(frac_coords, dtype = float), + atom_posn_cart = np.array([self.Lx * frac_coords[0], self.Ly * frac_coords[1], self.Lz * frac_coords[2]], dtype = float) + ) + else: + atom = PDOSCalculator.Atom( + atom_type_index = atom_type_index, + atom_posn_frac = np.array(frac_coords, dtype = float), + atom_posn_cart = np.array(self.latvec @ frac_coords, dtype = float) + ) + atoms.append(atom) + + # store the parsed atoms in the class + self.atoms = atoms + + + def read_sparc_ion_file_parameters(self, fname: str, atom_count_list: List[int]): + """ + Read atomic positions (fractional and cartesian) from SPARC .ion file. + """ + assert isinstance(fname, str), ION_FNAME_NOT_STRING_ERROR.format(type(fname)) + assert isinstance(atom_count_list, list), ATOM_COUNT_LIST_NOT_LIST_ERROR.format(type(atom_count_list)) + + raise NotImplementedError("read_sparc_ion_file_parameters is not implemented") + + + + def read_sparc_geopt_file_parameters(self, fname: str, atom_count_list: List[int],): + assert isinstance(fname, str), GEOPT_FNAME_NOT_STRING_ERROR.format(type(fname)) + assert isinstance(atom_count_list, list), ATOM_COUNT_LIST_NOT_LIST_ERROR.format(type(atom_count_list)) + assert isinstance(self.relax_flag, int), RELAX_FLAG_NOT_INTEGER_ERROR.format(type(self.relax_flag)) + assert self.relax_flag in [1, 2, 3], RELAX_FLAG_NOT_VALID_ERROR.format(self.relax_flag) + + print("Reading the SPARC's geopt file") + print("\t fname = ", fname) + print("\t number of atoms = ", sum(atom_count_list)) + + with open(fname, 'r') as f: + geopt_lines = f.read().splitlines() + + # read in the lattice parameters from the .geopt file + self.is_orthogonal_lattice = False + self.setup_non_orthogonal_lattice(lines = geopt_lines) + + # read in the atomic positions from the .geopt or .ion file + if self.relax_flag == 1 or self.relax_flag == 3: + _last_R_index = int(_find_last_line_index("R(Bohr)", geopt_lines)) + assert _last_R_index != -1, "R(Bohr) not found in the .geopt file" + + use_frac_coords = False + atom_cart_position_indices = [_last_R_index + i for i in range(len(atom_count_list))] + atom_position_lines = geopt_lines # lines containing the cartesian coordinates of the atoms + + elif self.relax_flag == 2: + # This is when the fractional coordinates are fixed during the relaxation, but the cell size is not fixed + # secretly ask for the .ion file, and read the parameters from the .ion file + assert fname.endswith(".geopt"), GEOPT_FNAME_NOT_ENDING_WITH_GEOPT_ERROR.format(fname) + ion_fname = fname.replace(".geopt", ".ion") + assert os.path.exists(ion_fname), ION_FNAME_NOT_EXIST_ERROR.format(ion_fname) + + # read in the atomic positions from the .ion file + with open(ion_fname, 'r') as f: + atom_position_lines = f.read().splitlines() + + # check if the .ion file uses fractional coordinates or cartesian coordinates + atom_frac_position_indices = [i for i, line in enumerate(atom_position_lines) if "COORD_FRAC" in line] + if len(atom_frac_position_indices) == 0: + atom_cart_position_indices = [i for i, line in enumerate(atom_position_lines) if "COORD" in line] + assert len(atom_cart_position_indices) == len(atom_count_list), \ + f"Expected {len(atom_count_list)} atomic blocks, but found {len(atom_cart_position_indices)}" + use_frac_coords = False + else: + assert len(atom_frac_position_indices) == len(atom_count_list), \ + f"Expected {len(atom_count_list)} atomic blocks, but found {len(atom_frac_position_indices)}" + use_frac_coords = True + else: + raise ValueError(f"relax_flag must be 1, 2, or 3, got {self.relax_flag}") # This error should never be raised + + + atoms = [] + + # loop over each atom type + for atom_type_index, natom in enumerate(atom_count_list): + start_index = atom_frac_position_indices[atom_type_index] if use_frac_coords else atom_cart_position_indices[atom_type_index] + + # loop over each atom in the current atom type + for j in range(1, natom + 1): + line = atom_position_lines[start_index + j] + + if use_frac_coords: + _frac_coords = [float(x) for x in re.findall(SCIENTIFIC_NOTATION_PATTERN, line)] + assert len(_frac_coords) == 3, f"Expected 3 fractional coordinates, got {_frac_coords}" + atom = PDOSCalculator.Atom( + atom_type_index = atom_type_index, + atom_posn_frac = np.array(_frac_coords, dtype = float), + atom_posn_cart = np.array(self.latvec @ _frac_coords, dtype = float) + ) + else: + _cart_coords = [float(x) for x in re.findall(SCIENTIFIC_NOTATION_PATTERN, line)] + assert len(_cart_coords) == 3, f"Expected 3 cartesian coordinates, got {_cart_coords}" + atom = PDOSCalculator.Atom( + atom_type_index = atom_type_index, + atom_posn_frac = np.array(self.latvec_inv @ _cart_coords, dtype = float), + atom_posn_cart = np.array(_cart_coords, dtype = float) + ) + + atoms.append(atom) + + # store the parsed atoms in the class + self.atoms = atoms + + + + # @print_time("Time taken to read the SPARC's eigen file (function={}) : {:.4f} seconds \n") + def read_sparc_eigen_file_parameters(self, fname : str): + """ + Read in the SPARC's eigen file (.eigen) + eign : (totkpt, band) energies sorted ascending within each k + I_indices : (band, totkpt) argsort indices for each k + kpts_store : (totkpt, 3) k-vectors + kpt_wts_store : (totkpt,) weights * (kpt1*kpt2*kpt3) + + """ + assert isinstance(fname, str), EIGEN_FNAME_NOT_STRING_ERROR.format(type(fname)) + + + print("Reading the SPARC's eigen file") + print("\t fname = ", fname) + print("\t number of k-points = ", self.kpt_num) + print("\t number of bands = ", self.band_num) + + + kpts_store = [] + kpt_wts_store = [] + + eign_array = np.zeros((self.band_num, self.kpt_num)) # (band, kpt), original order + eign_sorted_array = np.zeros((self.band_num, self.kpt_num)) # (band, kpt), sorted order + occ_array = np.zeros((self.band_num, self.kpt_num)) # (band, kpt), original order + occ_sorted_array = np.zeros((self.band_num, self.kpt_num)) # (band, kpt), sorted order + I_indices_array = np.zeros((self.band_num, self.kpt_num)) # (band, kpt), indexing + + + kvec_re = re.compile(r"kred\s*#(\d+)\s*=\s*\(\s*(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)\s*\)") + wgt_re = re.compile(r"=\s*(-?\d+\.\d+)") + eign_re = re.compile(r"\s*(\d+)\s+([-+]?\d+\.\d+E[-+]?\d+)\s+([-+]?\d+\.\d+)") + + + with open(fname, 'r') as f: + lines = f.read().splitlines() + + # Find the line indices for the k-point weights + kpt_vector_indices = [i for i, line in enumerate(lines) if "kred" in line] + assert len(kpt_vector_indices) == self.kpt_num, NUMBER_OF_KPOINTS_NOT_EQUAL_TO_EIGEN_FILE_ERROR.format(self.kpt_num, len(kpt_vector_indices)) + + + for kpt_index in range(self.kpt_num): + + # extract k-point vector + kvec_line = lines[kpt_vector_indices[kpt_index]] + kvec_match = re.search(kvec_re, kvec_line) + if kvec_match: + kvec_number = int(kvec_match.group(1)) + kvec_x = float(kvec_match.group(2)) + kvec_y = float(kvec_match.group(3)) + kvec_z = float(kvec_match.group(4)) + assert kvec_number == kpt_index + 1, KPOINT_NUMBER_NOT_EQUAL_TO_EIGEN_FILE_ERROR.format(kpt_index + 1, kvec_number) + kpts_store.append([kvec_x, kvec_y, kvec_z]) + + # extract k-point weights + wgt_line = lines[kpt_vector_indices[kpt_index] + 1] + wgt_match = re.search(wgt_re, wgt_line) + if wgt_match: + weight = float(wgt_match.group(1)) + kpt_wts_store.append(weight) + else: + raise ValueError(KPOINT_WEIGHTS_NOT_FOUND_ERROR.format(kpt_index + 1)) + + # extract eigenvalues and occ + eig_start = kpt_vector_indices[kpt_index] + 3 + eig_end = kpt_vector_indices[kpt_index] + 3 + self.band_num + eig_temp = [] + occ_temp = [] + for line in lines[eig_start:eig_end]: + eign_match = re.search(eign_re, line) + if eign_match: + eig_temp.append(float(eign_match.group(2))) # Ha + occ_temp.append(float(eign_match.group(3))) # may be 2.0 or fractional + else: + raise ValueError(EIGEN_FILE_NO_EIGENVALUES_AND_OCCUPATIONS_FOUND_ERROR.format(kpt_index + 1, line)) + + # sorting & indexing + indexing = np.argsort(eig_temp, axis=0) + + eign_array[:, kpt_index] = np.asarray(eig_temp, dtype=float) + eign_sorted_array[:, kpt_index] = eign_array[indexing, kpt_index] + occ_array[:, kpt_index] = np.asarray(occ_temp, dtype=float) + occ_sorted_array[:, kpt_index] = occ_array[indexing, kpt_index] + I_indices_array[:, kpt_index] = indexing + + + # store the parsed parameters in the class + self.I_indices = I_indices_array # indexing + self.eign = eign_sorted_array # already sorted + self.occ = occ_sorted_array # already sorted + + self.kpts_store = np.asarray(kpts_store, dtype=float) + self.kpt_wts_store = np.asarray(kpt_wts_store, dtype=float) + + + + # @print_time("Time taken to read the SPARC's orbital file (function={}) : {:.4f} seconds \n") + def read_sparc_orbital_file_parameters(self, fname : str): + """ + Read in the SPARC's orbital file (.psi) + """ + assert isinstance(fname, str), "fname must be a string, get {} instead".format(type(fname)) + print("Reading the SPARC's orbital file") + + psi_total, header, per_band_meta = read_psi(fname, verbose=False) + + self.check_valid_psi_header(header = header) + + print("\t fname = ", fname) + print("\t psi_total.shape = ", psi_total.shape) + + self.psi_total = psi_total + self.header = header + self.per_band_meta = per_band_meta + + + # psi_kpt = psi_total[:, :, 0] + # for band_index in range(4): + # psi_per_band = psi_kpt[:, band_index] + # norm_with_header_dV = np.sum(psi_per_band.real**2 + psi_per_band.imag**2).real * self.header['dV'] + # norm_with_correct_dV = np.sum(psi_per_band.real**2 + psi_per_band.imag**2).real * self.dV + # print("\t band[{}] squared sum (header dV): {:.6f}, (correct dV): {:.6f}".format( + # band_index, norm_with_header_dV, norm_with_correct_dV)) + # print("self.dV = ", self.dV) + # print("header['dV'] = ", self.header['dV']) + # print("Ratio header['dV']/self.dV = {:.6f}".format(self.header['dV'] / self.dV)) + # print("header = \n", self.header) + # print("self.per_band_meta = \n", self.per_band_meta) + + + + @classmethod + def check_fname_existence(cls, fname : str): + """ + Check if the file exists + """ + assert isinstance(fname, str), FNAME_NOT_STRING_ERROR.format(type(fname)) + assert os.path.exists(fname), FNAME_NOT_EXIST_ERROR.format(fname) + + + @classmethod + def check_valid_atomic_wave_function_generator(cls, atomic_wave_function_generator : AtomicWaveFunctionGeneratorType): + assert callable(atomic_wave_function_generator), ATOMIC_WAVE_FUNCTION_GENERATOR_NOT_CALLABLE_ERROR.format(type(atomic_wave_function_generator)) + r_array, orbitals, n_l_orbitals, info_dict = None, None, None, None + + try: + r_array, orbitals, n_l_orbitals, info_dict = atomic_wave_function_generator(Atomic_number = 12) + except Exception as e: + raise ValueError(ATOMIC_WAVE_FUNCTION_GENERATOR_NOT_VALID_ERROR.format(e)) + + assert isinstance(r_array, np.ndarray), "r_array must be a numpy array, get {} instead".format(type(r_array)) + assert isinstance(orbitals, np.ndarray), "orbitals must be a numpy array, get {} instead".format(type(orbitals)) + assert isinstance(n_l_orbitals, np.ndarray), "n_l_orbitals must be a numpy array, get {} instead".format(type(n_l_orbitals)) + assert isinstance(info_dict, dict), "info_dict must be a dictionary, get {} instead".format(type(info_dict)) + assert len(r_array) == len(orbitals), "The number of r_array points must be equal to the number of orbitals" + + print("r_array.shape = ", r_array.shape) + print("orbitals.shape = ", orbitals.shape) + print("n_l_orbitals.shape = ", n_l_orbitals.shape) + print("n_l_orbitals = ", n_l_orbitals) + # print("info_dict = ", info_dict) + # raise ValueError("test") + pass + + + + + @classmethod + def check_upf_fname_list_or_get_default_atomic_wave_function_generators(cls, + upf_fname_list : Optional[List[str]], + natom_types : int): + + if upf_fname_list is not None: + assert isinstance(upf_fname_list, list), UPF_FNAME_LIST_NOT_LIST_ERROR.format(type(upf_fname_list)) + assert len(upf_fname_list) == natom_types, UPF_FNAME_NUM_NOT_EQUAL_TO_NATOM_TYPES_ERROR.format(len(upf_fname_list)) + + for upf_fname in upf_fname_list: + if upf_fname == "Default": + continue + else: + assert isinstance(upf_fname, str), UPF_FNAME_NOT_STRING_ERROR.format(type(upf_fname)) + assert upf_fname.endswith(".upf"), UPF_FNAME_NOT_ENDING_WITH_UPF_ERROR.format(upf_fname) + cls.check_fname_existence(upf_fname) + # TODO : check the order of the upf_fname_list, it should be the same as the order of the atoms in the unit cell + else: + raise ValueError(ATOMIC_WAVE_FUNCTION_GENERATOR_NO_UPF_FILES_PROVIDED_ERROR) + + + def check_sparc_out_file_parameters(self): + """ + Check if the output parameters are correctly read in + """ + # type check + assert isinstance(self.kpt1, int), "kpt1 must be an integer, get {} instead".format(type(self.kpt1)) + assert isinstance(self.kpt2, int), "kpt2 must be an integer, get {} instead".format(type(self.kpt2)) + assert isinstance(self.kpt3, int), "kpt3 must be an integer, get {} instead".format(type(self.kpt3)) + assert isinstance(self.Nx, int), "Nx must be an integer, get {} instead".format(type(self.Nx)) + assert isinstance(self.Ny, int), "Ny must be an integer, get {} instead".format(type(self.Ny)) + assert isinstance(self.Nz, int), "Nz must be an integer, get {} instead".format(type(self.Nz)) + assert isinstance(self.bcx, str), "bcx must be a string, get {} instead".format(type(self.bcx)) + assert isinstance(self.bcy, str), "bcy must be a string, get {} instead".format(type(self.bcy)) + assert isinstance(self.bcz, str), "bcz must be a string, get {} instead".format(type(self.bcz)) + assert isinstance(self.band_num, int), "band must be an integer, get {} instead".format(type(self.band_num)) + assert isinstance(self.kpt_num, int), "kpt must be an integer, get {} instead".format(type(self.kpt_num)) + assert isinstance(self.fermi, float), "fermi must be a float, get {} instead".format(type(self.fermi)) + assert isinstance(self.psp_fname_list, list), "psp_fname_list must be a list, get {} instead".format(type(self.psp_fname_list)) + + # value check + assert self.kpt1 > 0, "kpt1 must be a positive integer, get {} instead".format(self.kpt1) + assert self.kpt2 > 0, "kpt2 must be a positive integer, get {} instead".format(self.kpt2) + assert self.kpt3 > 0, "kpt3 must be a positive integer, get {} instead".format(self.kpt3) + assert self.Nx > 0, "Nx must be a positive integer, get {} instead".format(self.Nx) + assert self.Ny > 0, "Ny must be a positive integer, get {} instead".format(self.Ny) + assert self.Nz > 0, "Nz must be a positive integer, get {} instead".format(self.Nz) + assert self.bcx in ["P", "D"], "bcx must be either P or D, get {} instead".format(self.bcx) + assert self.bcy in ["P", "D"], "bcy must be either P or D, get {} instead".format(self.bcy) + assert self.bcz in ["P", "D"], "bcz must be either P or D, get {} instead".format(self.bcz) + assert self.band_num > 0, "band must be a positive integer, get {} instead".format(self.band_num) + for atom_index, psp_fname in enumerate(self.psp_fname_list): + assert isinstance(psp_fname, str), "psp_fname must be a string, get {} instead".format(type(psp_fname)) + if self.upf_fname_list is not None: + upf_fname = self.upf_fname_list[atom_index] + if upf_fname == "Default": + self.check_fname_existence(psp_fname) + else: + self.check_fname_existence(upf_fname) + else: + self.check_fname_existence(psp_fname) + + if not self.is_relaxation: + self.check_lattice_parameters() + else: + assert isinstance(self.relax_flag, int), RELAX_FLAG_NOT_INTEGER_ERROR.format(type(self.relax_flag)) + assert self.relax_flag in [1, 2, 3], RELAX_FLAG_NOT_VALID_ERROR.format(self.relax_flag) + + + + def check_lattice_parameters(self): + assert isinstance(self.Lx, float), "Lx must be a float, get {} instead".format(type(self.Lx)) + assert isinstance(self.Ly, float), "Ly must be a float, get {} instead".format(type(self.Ly)) + assert isinstance(self.Lz, float), "Lz must be a float, get {} instead".format(type(self.Lz)) + + assert self.Lx > 0, "Lx must be a positive float, get {} instead".format(self.Lx) + assert self.Ly > 0, "Ly must be a positive float, get {} instead".format(self.Ly) + assert self.Lz > 0, "Lz must be a positive float, get {} instead".format(self.Lz) + + + def check_valid_psi_header(self, header : dict): + try: + assert isinstance(header, dict), "header must be a dictionary, get {} instead".format(type(header)) + # grid number check + assert header["Nx"] == self.Nx, "Nx = {} != header['Nx'] = {}".format(self.Nx, header["Nx"]) + assert header["Ny"] == self.Ny, "Ny = {} != header['Ny'] = {}".format(self.Ny, header["Ny"]) + assert header["Nz"] == self.Nz, "Nz = {} != header['Nz'] = {}".format(self.Nz, header["Nz"]) + assert header["Nd"] == self.Nx * self.Ny * self.Nz, "Nd = {} != header['Nd'] = {}".format(self.Nx * self.Ny * self.Nz, header["Nd"]) + + # grid spacing check + assert np.isclose(header["dx"], self.dx, atol=3e-2), "dx = {} != header['dx'] = {}".format(self.dx, header["dx"]) + assert np.isclose(header["dy"], self.dy, atol=3e-2), "dy = {} != header['dy'] = {}".format(self.dy, header["dy"]) + assert np.isclose(header["dz"], self.dz, atol=3e-2), "dz = {} != header['dz'] = {}".format(self.dz, header["dz"]) + assert np.isclose(header["dV"], self.dV, atol=3e-3), "dV = {} != header['dV'] = {}".format(self.dV, header["dV"]) + + # nband and nkpt check + assert header["nband"] == self.band_num, "nband = {} != header['nband'] = {}".format(self.band_num, header["nband"]) + assert header["nkpt"] == self.kpt_num, "nkpt = {} != header['nkpt'] = {}".format(self.kpt_num, header["nkpt"]) + except Exception as e: + print("\t Warning: Error in checking valid psi header: {}".format(e)) + + + def print_initialization_parameters(self): + """ + Print the input parameters + """ + print("File / Directory parameters:") + print("\t natom_types: {}".format(self.natom_types)) + print("\t upf_fname_list: {}".format(self.upf_fname_list)) + print("\t output_fname: {}".format(self.output_fname)) + print("\t eigen_fname: {}".format(self.eigen_fname)) + print("\t static_fname: {}".format(self.static_fname)) + print("\t psi_fname: {}".format(self.psi_fname)) + print("\t out_dirname: {}".format(self.out_dirname)) + + print("PDOS calculation parameters:") + print("\t mu_PDOS: {:.4f} eV".format(self.mu_PDOS)) + print("\t N_PDOS: {}".format(self.N_PDOS)) + print("\t min_E_plot: {:.2f} eV".format(self.min_E_plot)) + print("\t max_E_plot: {:.2f} eV".format(self.max_E_plot)) + print("\t r_cut_max: {:.2f} Bohr".format(self.r_cut_max)) + print("\n") + + + def print_sparc_out_file_parameters(self): + """ + Print the parameters read in from the SPARC's output file (.out) + """ + # print the results + print("SPARC's output file parameters:") + print("\t kpt1: {}".format(self.kpt1)) + print("\t kpt2: {}".format(self.kpt2)) + print("\t kpt3: {}".format(self.kpt3)) + print("\t Nx: {}".format(self.Nx)) + print("\t Ny: {}".format(self.Ny)) + print("\t Nz: {}".format(self.Nz)) + print("\t Lx: {:.4f} Bohr".format(self.Lx)) + print("\t Ly: {:.4f} Bohr".format(self.Ly)) + print("\t Lz: {:.4f} Bohr".format(self.Lz)) + print("\t bcx: {}".format(self.bcx)) + print("\t bcy: {}".format(self.bcy)) + print("\t bcz: {}".format(self.bcz)) + print("\t band_num: {}".format(self.band_num)) + print("\t kpt_num: {}".format(self.kpt_num)) + print("\t fermi: {:.6f} eV".format(self.fermi)) + print("\t dx: {:.4f} Bohr".format(self.dx)) + print("\t dy: {:.4f} Bohr".format(self.dy)) + print("\t dz: {:.4f} Bohr".format(self.dz)) + + print("\t tot_atoms: {}".format(self.tot_atoms_num)) + print("\t atom_count_list: {}".format(self.atom_count_list)) + print("\t atom_species_list: {}".format(self.atom_species_list)) + + if not self.is_orthogonal_lattice and not self.is_relaxation: + self.print_non_orthogonal_lattice_parameters() + + print("\n") + + + def print_non_orthogonal_lattice_parameters(self): + print("Non-orthogonal lattice parameters:") + print("\t latvec:") + print("\t\t a1 = {}".format(self.latvec[:, 0])) + print("\t\t a2 = {}".format(self.latvec[:, 1])) + print("\t\t a3 = {}".format(self.latvec[:, 2])) + + print("\t latvec_matrix: \n{}".format(self.latvec)) + print("\t latvec_inv_matrix: \n{}".format(self.latvec_inv)) + print("\t cell_volume: {:.6f} Bohr³".format(self.cell_volume)) + print("\t dV: {:.6f} Bohr³".format(self.dV)) + + + + def print_atomic_wave_function(self, atomic_wave_function : 'PDOSCalculator.AtomicWaveFunction'): + """ + Print the atomic wave function from the UPF file (.upf) + """ + assert isinstance(atomic_wave_function, PDOSCalculator.AtomicWaveFunction), "atomic_wave_function must be a PDOSCalculator.AtomicWaveFunction, get {} instead".format(type(atomic_wave_function)) + + print("atomic_wavefunction from file [{}]".format(atomic_wave_function.upf_fname)) + print("\t atom_type_index: {}".format(atomic_wave_function.atom_type_index)) + print("\t r_cut: {}".format(atomic_wave_function.r_cut)) + print("\t # (pseudo-wave functions): {}".format(atomic_wave_function.num_psdwfn)) + print("\t # (orbitals): {}".format(atomic_wave_function.num_orbitals)) + for psdwfn in atomic_wave_function.psdwfn_list: + print("\t pseudo-wave function [n = {}, l = {}, #(m) = {}]".format(psdwfn.n, psdwfn.l, psdwfn.no_m)) + print("\t\t length of chi(r): {}".format(len(psdwfn.chi))) + print("\t\t length of r-grid: {}".format(len(psdwfn.r))) + print("\t\t length of phi(r): {}".format(len(psdwfn.phi_r))) + print("\n") + + + def plot_atomic_wave_function(self, atomic_wave_function : 'PDOSCalculator.AtomicWaveFunction', save_fname : Optional[str] = None): + """ + Plot the atomic wave function + """ + assert isinstance(atomic_wave_function, PDOSCalculator.AtomicWaveFunction), "atomic_wave_function must be a PDOSCalculator.AtomicWaveFunction, get {} instead".format(type(atomic_wave_function)) + + atom_type = atomic_wave_function.atom_species + if save_fname is None: + save_fname = os.path.join(self.out_dirname, atom_type + '.png') + + + import matplotlib.pyplot as plt + + # plot the atomic wave function + plt.figure(figsize=(10, 5)) + for psdwfn in atomic_wave_function.psdwfn_list: + plt.plot(psdwfn.r, psdwfn.phi_r, label = 'n = {}, l = {}'.format(psdwfn.n, psdwfn.l)) + + # plot the cutoff radius + plt.axvline(x = atomic_wave_function.r_cut, color = 'red', linestyle = '--', label = 'cutoff radius') + + plt.xlabel('r (Bohr)') + plt.ylabel('phi(r)') + plt.title('Atomic Wave Function for atom {}'.format(atom_type)) + + plt.legend(loc="upper right") + plt.grid(linestyle='--') + plt.savefig(save_fname) + + + def print_sparc_static_file_parameters(self): + """ + Print the parameters from the SPARC's static file (.static) + """ + print("SPARC's static file parameters:") + print("\t fname = ", self.static_fname) + print("\t natoms = ", len(self.atoms)) + print("\t natom_types = ", self.natom_types) + print("\t atom_species_list = ", self.atom_species_list) + if not self.is_orthogonal_lattice: + print("\t atoms' positions in cartesian coordinates:") + for atom_index, atom in enumerate(self.atoms): + print("\t\t atom{}.atom_posn_cart = {}".format(atom_index, atom.atom_posn_cart)) + print("\n") + + + def print_sparc_eigen_file_parameters(self): + """ + Print the parameters from the SPARC's eigen file (.eigen) + """ + print("SPARC's eigen file parameters") + print("\t fname = ", self.eigen_fname) + print("\t number of bands = ", self.band_num) + print("\t number of k-points = ", self.kpt_num) + print("\t sum of weighted occupations = ", np.sum(self.occ* self.kpt_wts_store)) + + print("\t eign.shape = ", self.eign.shape) + print("\t occ.shape = ", self.occ.shape) + print("\t I_indices.shape = ", self.I_indices.shape) + + for i in range(self.kpt_num): + print("\t k-point {}".format(i)) + print("\t\t sum(occ) = ", sum(self.occ[:, i])) + print("\t\t k-vector = ", self.kpts_store[i, :]) + print("\t\t k-point weight = ", self.kpt_wts_store[i]) + print("\n") + + + def print_sparc_orbital_file_parameters(self, print_band_meta_in_details : bool = False): + """ + Print the parameters from the SPARC's orbital file (.psi) + """ + print("SPARC's orbital file parameters:") + print("\t fname = ", self.orbital_fname) + print("\t header['nband'] = ", self.header['nband']) + print("\t header['nkpt'] = ", self.header['nkpt']) + print("\t per_band_meta's length = ", len(self.per_band_meta)) + print("\t psi_total.shape = ", self.psi_total.shape) + + msg = "\t\t band_meta : 'spin_index' = {}, kpt_index = {}, band_index = {}, kpt_vec = ({:.2f}, {:.2f}, {:.2f})" + if print_band_meta_in_details: + for band_meta in self.per_band_meta: + band_meta_msg = msg.format( + band_meta['spin_index'], band_meta['kpt_index'], band_meta['band_indx'], + self.kpts_store[band_meta['kpt_index'], 0], self.kpts_store[band_meta['kpt_index'], 1], self.kpts_store[band_meta['kpt_index'], 2] + ) + print(band_meta_msg) + print("\n") + + + def print_atoms_updated_parameters(self): + """ + Print the index mask, effective grid point positions and phi_orbitals_list information for all atoms + """ + print("--------------------------------------------------------------------------------------------") + print(" Printing the updated parameters of all atoms ") + print("--------------------------------------------------------------------------------------------") + print("tot_orbital_num = ", self.tot_orbital_num) + + for atom_index, atom in enumerate(self.atoms): + print("atom_index = {}".format(atom_index)) + print("\t atom_type_index = {}".format(atom.atom_type_index)) + print("\t atom_posn_cart = {}".format(atom.atom_posn_cart)) + print("\t rcut = {} Bohr".format(atom.r_cut)) + print("\t len(atom.index_mask_and_effective_grid_point_positions_dict) = {}".format(len(atom.index_mask_and_effective_grid_point_positions_dict))) + print("\t len(atom.phi_orbitals_list) = {}".format(len(atom.phi_orbitals_list))) + for phi_orbital in atom.phi_orbitals_list: + print("\t\t phi_orbital.n = {}, phi_orbital.l = {}, phi_orbital.m = {}".format(phi_orbital.n, phi_orbital.l, phi_orbital.m)) + print("\t\t len(phi_orbital.phi_value_dict) = {}".format(len(phi_orbital.phi_value_dict))) + for shift_index_vector, phi_value_array in phi_orbital.phi_value_dict.items(): + print("\t\t\t shift_index_vector = {}, len(phi_value_array) = {}".format(shift_index_vector, len(phi_value_array))) + + print("--------------------------------------------------------------------------------------------") + + + + +def dict2namespace(config): + """Convert dictionary to namespace object recursively.""" + namespace = argparse.Namespace() + for key, value in config.items(): + if isinstance(value, dict): + new_value = dict2namespace(value) + else: + new_value = value + setattr(namespace, key, new_value) + return namespace + + +def parse_args_and_config(config_path=None, doc_path=None): + """Parse command line arguments and configuration file.""" + parser = argparse.ArgumentParser(description="PDOS Calculator for SPARC output files") + parser.add_argument("--config", type=str, help="Path to the configuration file.") + parser.add_argument("--path", type=str, help="Path to SPARC output directory (simple mode)") + + args = parser.parse_args() + + if config_path is not None: + args.config = config_path + + + + + # args.log documents the actual path for saving the running related data + # args.log = os.path.join(args.run, args.doc) + + # Parse config file if provided + if args.config: + with open(args.config, 'r') as f: + config = yaml.load(f, Loader=yaml.FullLoader) + new_config = dict2namespace(config) + else: + # Simple mode with just path + if not args.path: + raise ValueError("Either --config or --path must be provided") + + # Create default config for simple mode + config = { + 'sparc_path': args.path, + 'output_dir': None, # Will be set to parent directory of sparc_path + 'gaussian_width': 0.1, + 'max_E_plot': None, + 'min_E_plot': None, + 'N_PDOS': 1000, + 'print_single_atom': False, + 'atom_type': None, + 'atom_index_for_specified_atom_type': 0 + } + new_config = dict2namespace(config) + + # Create log directory if it doesn't exist + # os.makedirs(args.log, exist_ok=True) + + # Setup logging + # level = getattr(logging, args.verbose.upper(), None) + # if not isinstance(level, int): + # raise ValueError('level {} not supported'.format(args.verbose)) + + # Remove all the existing handler + log = logging.getLogger() + for handler in log.handlers[:]: + log.removeHandler(handler) + + handler1 = logging.StreamHandler() # Output to the terminal + # handler2 = logging.FileHandler(os.path.join(args.log, 'stdout.txt')) # output to the stdout.txt file + formatter = logging.Formatter('%(levelname)s-%(filename)s-%(asctime)s-%(message)s') + handler1.setFormatter(formatter) + # handler2.setFormatter(formatter) + logger = logging.getLogger() + logger.addHandler(handler1) + # logger.addHandler(handler2) + # logger.setLevel(level) + + return args, new_config + + +def setup_file_paths(config): + """Setup file paths based on configuration.""" + sparc_path = config.sparc_path + + # Extract directory and base name + # Normalize path separators for the current OS + sparc_path = os.path.normpath(sparc_path) + if '/' in sparc_path or '\\' in sparc_path: + sparc_dir = os.path.dirname(sparc_path) + base_name = os.path.basename(sparc_path) + else: + sparc_dir = '.' + base_name = sparc_path + + # Set output directory + if config.output_dir is None: + # Use a subdirectory within the SPARC directory for PDOS output + output_dir = os.path.join(sparc_dir, "PDOS_output") + else: + output_dir = config.output_dir + + # Construct file paths + output_fname = os.path.join(sparc_dir, f"{base_name}.out") + static_fname = os.path.join(sparc_dir, f"{base_name}.static") + geopt_fname = os.path.join(sparc_dir, f"{base_name}.geopt") + eigen_fname = os.path.join(sparc_dir, f"{base_name}.eigen") + psi_fname = os.path.join(sparc_dir, f"{base_name}.psi") + + + # Check if required files exist + required_files = [output_fname, eigen_fname, psi_fname] + missing_files = [f for f in required_files if not os.path.exists(f)] + if os.path.exists(static_fname): + is_relaxation = False + elif os.path.exists(geopt_fname): + is_relaxation = True + else: + missing_files.append(static_fname) + missing_files.append(geopt_fname) + raise FileNotFoundError(f"Both static and geopt files not found: {static_fname} or {geopt_fname}") + + if missing_files: + raise FileNotFoundError(f"Required files not found: {missing_files}") + + # Check if UPF file exists, if not, we'll use default generator + upf_fname_list = get_upf_fname_list(output_fname = output_fname) + + return { + 'is_relaxation': is_relaxation, + 'output_fname': output_fname, + 'static_fname': static_fname if not is_relaxation else None, + 'geopt_fname': geopt_fname if is_relaxation else None, + 'eigen_fname': eigen_fname, + 'psi_fname': psi_fname, + 'upf_fname_list': upf_fname_list, + 'output_dir': output_dir, + 'natom_types': len(upf_fname_list) if upf_fname_list else 1 + } + + +def get_upf_fname_list(output_fname : str): + assert isinstance(output_fname, str), OUTPUT_FNAME_NOT_STRING_ERROR.format(type(output_fname)) + assert os.path.exists(output_fname), OUTPUT_FNAME_NOT_EXIST_ERROR.format(output_fname) + output_dir = Path(output_fname).parent + natom_types, atom_species_list = PDOSCalculator.parse_atom_species_from_sparc_out_file(output_fname = output_fname) + upf_fname_list_temp = [os.path.join(output_dir, f"{atom_species_list[i]}.upf") for i in range(natom_types)] + upf_fname_list = [] + for upf_fname_temp in upf_fname_list_temp: + if os.path.exists(upf_fname_temp): + upf_fname_list.append(upf_fname_temp) + else: + upf_fname_list.append("Default") + + return upf_fname_list + + + + + +def main(): + """Main function to run PDOS calculation.""" + try: + # Parse arguments and configuration + args, config = parse_args_and_config() + + # Present all the information in the terminal/stdout.txt file + # logging.info("Writing log file to {}".format(args.log)) + # logging.info("Exp instance id = {}".format(os.getpid())) + logging.info("Config=") + logging.info(">" * 80) + logging.info(config) + logging.info("<" * 80) + + # Setup file paths + file_paths_config = setup_file_paths(config) + + # Run calculation + if not hasattr(config, 'full_pdos_calculation'): + config.full_pdos_calculation = True + if not hasattr(config, 'sum_over_m_index'): + config.sum_over_m_index = False + if not hasattr(config, 'gaussian_width'): + config.gaussian_width = 0.2721140795 + if not hasattr(config, 'N_PDOS'): + config.N_PDOS = 1000 + if not hasattr(config, 'min_E_plot'): + config.min_E_plot = None + if not hasattr(config, 'max_E_plot'): + config.max_E_plot = None + if not hasattr(config, 'print_projection_data'): + config.print_projection_data = False + if not hasattr(config, 'recompute_pdos'): + config.recompute_pdos = False + if not hasattr(config, 'projection_datapath'): + config.projection_datapath = None + if not hasattr(config, 'orthogonalize_atomic_orbitals'): + config.orthogonalize_atomic_orbitals = False + if not hasattr(config, 'k_point_parallelization'): + config.k_point_parallelization = None + + assert isinstance(config.orthogonalize_atomic_orbitals, bool), \ + ORTHOGONALIZE_ATOMIC_ORBITALS_NOT_BOOL_ERROR.format(type(config.orthogonalize_atomic_orbitals)) + # print("is_relaxation = ", file_paths_config['is_relaxation']) + + # Create PDOS calculator + pdos_calculator = PDOSCalculator( + upf_fname_list = file_paths_config['upf_fname_list'], + output_fname = file_paths_config['output_fname'], + eigen_fname = file_paths_config['eigen_fname'], + static_fname = file_paths_config['static_fname'], + geopt_fname = file_paths_config['geopt_fname'], + psi_fname = file_paths_config['psi_fname'], + out_dirname = file_paths_config['output_dir'], + is_relaxation = file_paths_config['is_relaxation'], + orthogonalize_atomic_orbitals = config.orthogonalize_atomic_orbitals, + k_point_parallelization = config.k_point_parallelization, + ) + + + if not config.full_pdos_calculation: + if config.atom_type is None: + raise ValueError("atom_type must be specified when print_single_atom is True") + if config.atom_index_for_specified_atom_type is None: + raise ValueError("atom_index_for_specified_atom_type must be specified when print_single_atom is True") + + pdos_calculator.run_single_atom( + atom_type = config.atom_type, + atom_index_for_specified_atom_type = config.atom_index_for_specified_atom_type, + mu_PDOS = config.gaussian_width, + N_PDOS = config.N_PDOS, + min_E_plot = config.min_E_plot, + max_E_plot = config.max_E_plot, + load_projection_data_from_txt_path = config.projection_datapath if not config.recompute_pdos else None, + print_projection_data = config.print_projection_data, + sum_over_m_index = config.sum_over_m_index + ) + else: + pdos_calculator.run( + mu_PDOS = config.gaussian_width, + N_PDOS = config.N_PDOS, + min_E_plot = config.min_E_plot, + max_E_plot = config.max_E_plot, + print_projection_data = config.print_projection_data, + sum_over_m_index = config.sum_over_m_index, + load_projection_data_from_txt_path = config.projection_datapath if not config.recompute_pdos else None, + ) + + logging.info("PDOS calculation completed successfully!") + + except Exception as e: + logging.error(f"Error during PDOS calculation: {str(e)}") + logging.error(traceback.format_exc()) + sys.exit(1) + + + + +if __name__ == "__main__": + main() + diff --git a/utils/pdos/config.yaml b/utils/pdos/config.yaml new file mode 100644 index 00000000..22510aa0 --- /dev/null +++ b/utils/pdos/config.yaml @@ -0,0 +1,43 @@ +# PDOS Calculator Configuration File +# Example configuration for calculate_pdos.py + +# SPARC output path (directory and base filename) +# Example: "Al_BCC_1/Al" will look for Al_BCC_1/Al.out, Al_BCC_1/Al.static, etc. +sparc_path: "examples/Al_FCC/Al" + +# Output directory for PDOS results +# If not specified, will use the same directory as sparc_path +output_dir: null + +# Gaussian broadening width (eV) +gaussian_width: 0.2721140795 +# Energy range for plotting (eV) +# min_E_plot: 5.0 +# max_E_plot: 65.0 + +# Number of energy points for PDOS calculation +N_PDOS: 1000 + +# # Whether to sum over the m index for the PDOS calculation +# sum_over_m_index: False # True by default + +# # Whether to recompute the PDOS +# recompute_pdos: True + +# # If not recompute the PDOS, then we directly load the PDOS data from the txt file +# projection_datapath: "Al_FCC_0/data_projections.txt" + +# # Whether to print the projection data +# print_projection_data: False + +# # Whether to orthogonalize the atomic orbitals +# orthogonalize_atomic_orbitals: False # False by default + +# # Single atom calculation settings +# full_pdos_calculation: False +# atom_type: ["Al", 13] # Can be element name (e.g., "Al") or atomic number (e.g., 13) +# atom_index_for_specified_atom_type: [0, 1] # Index of the atom in the static file + + +# # whether to use k-point parallelization +# k_point_parallelization: True \ No newline at end of file diff --git a/utils/pdos/example_usage.py b/utils/pdos/example_usage.py new file mode 100644 index 00000000..aefa3fc6 --- /dev/null +++ b/utils/pdos/example_usage.py @@ -0,0 +1,63 @@ + +from calculate_pdos import PDOSCalculator + +# Example system: Al FCC +upf_fname_list = [ + './examples/Al_FCC/Al.upf', # Optional UPF file + # If no UPF files provided, program will use built-in generator +] + +output_fname = './examples/Al_FCC/Al.out' +static_fname = './examples/Al_FCC/Al.static' +eigen_fname = './examples/Al_FCC/Al.eigen' +psi_fname = './examples/Al_FCC/Al.psi' +out_dirname = './examples/Al_FCC/PDOS_output' + +# Initialize PDOSCalculator +pdos_calculator = PDOSCalculator( + upf_fname_list = upf_fname_list, # Optional: can be None for automatic generation + output_fname = output_fname, + eigen_fname = eigen_fname, + static_fname = static_fname, + psi_fname = psi_fname, + out_dirname = out_dirname, + r_cut_max = 15.0, # Optional: cutoff radius in Bohr + atomic_wave_function_tol = 1e-5, # Optional: tolerance for atomic wave functions + orthogonalize_atomic_orbitals = False, # Optional: whether to orthogonalize orbitals + is_relaxation = False, # Optional: whether from relaxation calculation + k_point_parallelization = True, # Optional: enable k-point parallelization +) + +# Run the PDOS calculation +E, PDOS, DOS = \ + pdos_calculator.run( + mu_PDOS = 0.2721140795, # Gaussian broadening width in eV + N_PDOS = 1000, # Number of energy points + min_E_plot = 5.0, # Minimum energy in eV (optional, auto-determined if None) + max_E_plot = 65.0, # Maximum energy in eV (optional, auto-determined if None) + sum_over_m_index = False, # Whether to sum over magnetic quantum number m + print_projection_data = False, # Whether to save projection data + ) + +# Some downstream analysis +print("E.shape = ", E.shape) # (N_PDOS,) +print("DOS.shape = ", DOS.shape) # (N_PDOS,) +print("PDOS.shape = ", PDOS.shape) # (N_PDOS, number_of_orbitals) + + +# For selective atom calculation +E_single_atom, PDOS_single_atom, DOS_single_atom = \ + pdos_calculator.run_single_atom( + atom_type = "Al", # or atomic number 13 + atom_index_for_specified_atom_type = 0, # 0-indexed + mu_PDOS = 0.2721140795, + N_PDOS = 1000, + min_E_plot = 5.0, + max_E_plot = 65.0, + sum_over_m_index = False, + ) + +# Some downstream analysis +print("E_single_atom.shape = ", E_single_atom.shape) # (N_PDOS,) +print("DOS_single_atom.shape = ", DOS_single_atom.shape) # (N_PDOS,) +print("PDOS_single_atom.shape = ", PDOS_single_atom.shape) # (N_PDOS, number_of_orbitals_for_single_atom) \ No newline at end of file diff --git a/utils/pdos/examples/Al_FCC/Al.dens b/utils/pdos/examples/Al_FCC/Al.dens new file mode 100644 index 00000000..8cc9cdff --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.dens @@ -0,0 +1,252 @@ +Electron density in Cube format printed by SPARC-X (Print time: Tue Oct 14 13:54:05 2025) +Cell length: 7.653391 7.653391 7.653391, boundary condition: P P P. + 4 0.000000 0.000000 0.000000 + 11 0.695763 0.000000 0.000000 + 11 0.000000 0.695763 0.000000 + 11 0.000000 0.000000 0.695763 + 13 3.000000 0.000000 0.000000 0.000000 + 13 3.000000 3.826696 3.826696 0.000000 + 13 3.000000 3.826696 0.000000 3.826696 + 13 3.000000 0.000000 3.826696 3.826696 + 1.192969E-03 1.169432E-02 2.388269E-02 2.696169E-02 2.423446E-02 2.235198E-02 + 2.235198E-02 2.423446E-02 2.696170E-02 2.388274E-02 1.169447E-02 + 1.169440E-02 1.820252E-02 2.551679E-02 2.721708E-02 2.492058E-02 2.349822E-02 + 2.349822E-02 2.492058E-02 2.721709E-02 2.551681E-02 1.820255E-02 + 2.388273E-02 2.551681E-02 2.879104E-02 2.822583E-02 2.731507E-02 2.709905E-02 + 2.709905E-02 2.731507E-02 2.822584E-02 2.879105E-02 2.551681E-02 + 2.696171E-02 2.721710E-02 2.822584E-02 2.942942E-02 3.024330E-02 2.940729E-02 + 2.940729E-02 3.024331E-02 2.942942E-02 2.822584E-02 2.721710E-02 + 2.423447E-02 2.492059E-02 2.731507E-02 3.024330E-02 2.704918E-02 1.794724E-02 + 1.794724E-02 2.704918E-02 3.024331E-02 2.731508E-02 2.492059E-02 + 2.235199E-02 2.349823E-02 2.709905E-02 2.940729E-02 1.794724E-02 4.295122E-03 + 4.295127E-03 1.794724E-02 2.940729E-02 2.709906E-02 2.349823E-02 + 2.235199E-02 2.349823E-02 2.709905E-02 2.940729E-02 1.794723E-02 4.295120E-03 + 4.295126E-03 1.794724E-02 2.940729E-02 2.709905E-02 2.349823E-02 + 2.423446E-02 2.492058E-02 2.731506E-02 3.024329E-02 2.704917E-02 1.794723E-02 + 1.794723E-02 2.704917E-02 3.024330E-02 2.731507E-02 2.492059E-02 + 2.696169E-02 2.721708E-02 2.822582E-02 2.942940E-02 3.024329E-02 2.940728E-02 + 2.940728E-02 3.024329E-02 2.942941E-02 2.822583E-02 2.721708E-02 + 2.388271E-02 2.551679E-02 2.879102E-02 2.822582E-02 2.731506E-02 2.709904E-02 + 2.709904E-02 2.731506E-02 2.822583E-02 2.879103E-02 2.551679E-02 + 1.169436E-02 1.820251E-02 2.551678E-02 2.721708E-02 2.492058E-02 2.349822E-02 + 2.349822E-02 2.492058E-02 2.721708E-02 2.551680E-02 1.820253E-02 + 1.169431E-02 1.820250E-02 2.551679E-02 2.721708E-02 2.492058E-02 2.349822E-02 + 2.349822E-02 2.492058E-02 2.721709E-02 2.551680E-02 1.820252E-02 + 1.820251E-02 2.244620E-02 2.687635E-02 2.728076E-02 2.536251E-02 2.437341E-02 + 2.437341E-02 2.536251E-02 2.728076E-02 2.687637E-02 2.244620E-02 + 2.551681E-02 2.687636E-02 2.851901E-02 2.768911E-02 2.715041E-02 2.730398E-02 + 2.730398E-02 2.715041E-02 2.768911E-02 2.851902E-02 2.687637E-02 + 2.721710E-02 2.728077E-02 2.768911E-02 2.864416E-02 2.991952E-02 3.017058E-02 + 3.017059E-02 2.991953E-02 2.864417E-02 2.768912E-02 2.728077E-02 + 2.492059E-02 2.536251E-02 2.715041E-02 2.991953E-02 2.926327E-02 2.396614E-02 + 2.396614E-02 2.926327E-02 2.991953E-02 2.715042E-02 2.536252E-02 + 2.349823E-02 2.437341E-02 2.730398E-02 3.017058E-02 2.396614E-02 1.387711E-02 + 1.387711E-02 2.396614E-02 3.017059E-02 2.730398E-02 2.437341E-02 + 2.349822E-02 2.437341E-02 2.730397E-02 3.017058E-02 2.396613E-02 1.387710E-02 + 1.387710E-02 2.396613E-02 3.017058E-02 2.730398E-02 2.437341E-02 + 2.492058E-02 2.536250E-02 2.715040E-02 2.991951E-02 2.926326E-02 2.396613E-02 + 2.396613E-02 2.926326E-02 2.991952E-02 2.715041E-02 2.536251E-02 + 2.721708E-02 2.728075E-02 2.768910E-02 2.864415E-02 2.991951E-02 3.017057E-02 + 3.017057E-02 2.991951E-02 2.864415E-02 2.768910E-02 2.728075E-02 + 2.551679E-02 2.687634E-02 2.851900E-02 2.768910E-02 2.715040E-02 2.730397E-02 + 2.730397E-02 2.715040E-02 2.768910E-02 2.851901E-02 2.687635E-02 + 1.820249E-02 2.244619E-02 2.687634E-02 2.728075E-02 2.536250E-02 2.437341E-02 + 2.437341E-02 2.536250E-02 2.728075E-02 2.687636E-02 2.244618E-02 + 2.388270E-02 2.551679E-02 2.879103E-02 2.822583E-02 2.731506E-02 2.709905E-02 + 2.709905E-02 2.731506E-02 2.822583E-02 2.879103E-02 2.551679E-02 + 2.551679E-02 2.687635E-02 2.851901E-02 2.768911E-02 2.715041E-02 2.730398E-02 + 2.730398E-02 2.715041E-02 2.768911E-02 2.851902E-02 2.687636E-02 + 2.879104E-02 2.851901E-02 2.766619E-02 2.687390E-02 2.731311E-02 2.823737E-02 + 2.823737E-02 2.731312E-02 2.687391E-02 2.766620E-02 2.851902E-02 + 2.822584E-02 2.768911E-02 2.687390E-02 2.713981E-02 2.871323E-02 3.011892E-02 + 3.011893E-02 2.871324E-02 2.713981E-02 2.687391E-02 2.768911E-02 + 2.731507E-02 2.715041E-02 2.731311E-02 2.871323E-02 3.032298E-02 3.022111E-02 + 3.022111E-02 3.032298E-02 2.871324E-02 2.731312E-02 2.715041E-02 + 2.709905E-02 2.730397E-02 2.823737E-02 3.011892E-02 3.022110E-02 2.643894E-02 + 2.643894E-02 3.022111E-02 3.011893E-02 2.823738E-02 2.730398E-02 + 2.709905E-02 2.730397E-02 2.823736E-02 3.011891E-02 3.022110E-02 2.643894E-02 + 2.643894E-02 3.022110E-02 3.011892E-02 2.823737E-02 2.730397E-02 + 2.731506E-02 2.715040E-02 2.731310E-02 2.871322E-02 3.032297E-02 3.022110E-02 + 3.022110E-02 3.032297E-02 2.871323E-02 2.731311E-02 2.715040E-02 + 2.822582E-02 2.768909E-02 2.687389E-02 2.713979E-02 2.871322E-02 3.011891E-02 + 3.011891E-02 2.871322E-02 2.713980E-02 2.687390E-02 2.768910E-02 + 2.879102E-02 2.851900E-02 2.766618E-02 2.687389E-02 2.731310E-02 2.823736E-02 + 2.823736E-02 2.731311E-02 2.687389E-02 2.766618E-02 2.851900E-02 + 2.551678E-02 2.687634E-02 2.851900E-02 2.768910E-02 2.715040E-02 2.730397E-02 + 2.730397E-02 2.715040E-02 2.768910E-02 2.851901E-02 2.687634E-02 + 2.696170E-02 2.721709E-02 2.822583E-02 2.942941E-02 3.024330E-02 2.940729E-02 + 2.940729E-02 3.024330E-02 2.942941E-02 2.822583E-02 2.721709E-02 + 2.721709E-02 2.728076E-02 2.768911E-02 2.864416E-02 2.991953E-02 3.017059E-02 + 3.017059E-02 2.991953E-02 2.864416E-02 2.768911E-02 2.728076E-02 + 2.822583E-02 2.768911E-02 2.687390E-02 2.713981E-02 2.871324E-02 3.011893E-02 + 3.011893E-02 2.871324E-02 2.713981E-02 2.687391E-02 2.768911E-02 + 2.942941E-02 2.864416E-02 2.713980E-02 2.662493E-02 2.769250E-02 2.903884E-02 + 2.903884E-02 2.769250E-02 2.662494E-02 2.713981E-02 2.864416E-02 + 3.024330E-02 2.991952E-02 2.871322E-02 2.769249E-02 2.791847E-02 2.848320E-02 + 2.848320E-02 2.791848E-02 2.769250E-02 2.871324E-02 2.991953E-02 + 2.940728E-02 3.017057E-02 3.011891E-02 2.903882E-02 2.848319E-02 2.796803E-02 + 2.796803E-02 2.848320E-02 2.903883E-02 3.011893E-02 3.017058E-02 + 2.940728E-02 3.017057E-02 3.011891E-02 2.903882E-02 2.848318E-02 2.796802E-02 + 2.796802E-02 2.848319E-02 2.903883E-02 3.011892E-02 3.017058E-02 + 3.024328E-02 2.991950E-02 2.871321E-02 2.769248E-02 2.791846E-02 2.848319E-02 + 2.848319E-02 2.791847E-02 2.769249E-02 2.871323E-02 2.991951E-02 + 2.942940E-02 2.864414E-02 2.713979E-02 2.662492E-02 2.769248E-02 2.903882E-02 + 2.903882E-02 2.769249E-02 2.662493E-02 2.713980E-02 2.864415E-02 + 2.822582E-02 2.768909E-02 2.687389E-02 2.713979E-02 2.871322E-02 3.011891E-02 + 3.011892E-02 2.871323E-02 2.713980E-02 2.687390E-02 2.768910E-02 + 2.721708E-02 2.728075E-02 2.768910E-02 2.864415E-02 2.991952E-02 3.017058E-02 + 3.017058E-02 2.991952E-02 2.864415E-02 2.768910E-02 2.728075E-02 + 2.423446E-02 2.492059E-02 2.731507E-02 3.024330E-02 2.704918E-02 1.794723E-02 + 1.794723E-02 2.704918E-02 3.024330E-02 2.731507E-02 2.492059E-02 + 2.492059E-02 2.536251E-02 2.715041E-02 2.991952E-02 2.926328E-02 2.396614E-02 + 2.396614E-02 2.926328E-02 2.991953E-02 2.715041E-02 2.536251E-02 + 2.731507E-02 2.715041E-02 2.731311E-02 2.871323E-02 3.032298E-02 3.022112E-02 + 3.022112E-02 3.032299E-02 2.871324E-02 2.731312E-02 2.715041E-02 + 3.024330E-02 2.991952E-02 2.871323E-02 2.769249E-02 2.791847E-02 2.848320E-02 + 2.848321E-02 2.791848E-02 2.769251E-02 2.871324E-02 2.991953E-02 + 2.704918E-02 2.926326E-02 3.032297E-02 2.791846E-02 2.604732E-02 2.551993E-02 + 2.551993E-02 2.604733E-02 2.791848E-02 3.032298E-02 2.926328E-02 + 1.794723E-02 2.396612E-02 3.022109E-02 2.848318E-02 2.551992E-02 2.419104E-02 + 2.419105E-02 2.551993E-02 2.848320E-02 3.022111E-02 2.396614E-02 + 1.794722E-02 2.396612E-02 3.022109E-02 2.848318E-02 2.551991E-02 2.419104E-02 + 2.419104E-02 2.551992E-02 2.848319E-02 3.022111E-02 2.396614E-02 + 2.704916E-02 2.926325E-02 3.032295E-02 2.791845E-02 2.604731E-02 2.551992E-02 + 2.551992E-02 2.604732E-02 2.791847E-02 3.032297E-02 2.926326E-02 + 3.024328E-02 2.991950E-02 2.871321E-02 2.769248E-02 2.791846E-02 2.848318E-02 + 2.848319E-02 2.791846E-02 2.769249E-02 2.871322E-02 2.991951E-02 + 2.731506E-02 2.715040E-02 2.731310E-02 2.871322E-02 3.032296E-02 3.022110E-02 + 3.022110E-02 3.032297E-02 2.871323E-02 2.731311E-02 2.715040E-02 + 2.492058E-02 2.536251E-02 2.715040E-02 2.991951E-02 2.926326E-02 2.396613E-02 + 2.396613E-02 2.926327E-02 2.991952E-02 2.715041E-02 2.536251E-02 + 2.235199E-02 2.349823E-02 2.709905E-02 2.940728E-02 1.794723E-02 4.295115E-03 + 4.295113E-03 1.794724E-02 2.940729E-02 2.709905E-02 2.349823E-02 + 2.349823E-02 2.437341E-02 2.730397E-02 3.017058E-02 2.396614E-02 1.387711E-02 + 1.387711E-02 2.396615E-02 3.017059E-02 2.730398E-02 2.437341E-02 + 2.709905E-02 2.730397E-02 2.823737E-02 3.011892E-02 3.022112E-02 2.643896E-02 + 2.643896E-02 3.022113E-02 3.011894E-02 2.823738E-02 2.730398E-02 + 2.940728E-02 3.017057E-02 3.011891E-02 2.903883E-02 2.848320E-02 2.796804E-02 + 2.796804E-02 2.848321E-02 2.903884E-02 3.011893E-02 3.017059E-02 + 1.794723E-02 2.396613E-02 3.022110E-02 2.848319E-02 2.551992E-02 2.419105E-02 + 2.419105E-02 2.551993E-02 2.848320E-02 3.022112E-02 2.396614E-02 + 4.295113E-03 1.387710E-02 2.643893E-02 2.796802E-02 2.419104E-02 2.199204E-02 + 2.199205E-02 2.419105E-02 2.796803E-02 2.643895E-02 1.387711E-02 + 4.295113E-03 1.387709E-02 2.643892E-02 2.796801E-02 2.419103E-02 2.199204E-02 + 2.199204E-02 2.419105E-02 2.796803E-02 2.643894E-02 1.387711E-02 + 1.794723E-02 2.396611E-02 3.022108E-02 2.848317E-02 2.551991E-02 2.419104E-02 + 2.419104E-02 2.551992E-02 2.848319E-02 3.022110E-02 2.396613E-02 + 2.940727E-02 3.017056E-02 3.011890E-02 2.903881E-02 2.848318E-02 2.796802E-02 + 2.796802E-02 2.848319E-02 2.903883E-02 3.011892E-02 3.017057E-02 + 2.709904E-02 2.730396E-02 2.823736E-02 3.011891E-02 3.022109E-02 2.643893E-02 + 2.643894E-02 3.022110E-02 3.011892E-02 2.823737E-02 2.730397E-02 + 2.349822E-02 2.437341E-02 2.730397E-02 3.017057E-02 2.396613E-02 1.387710E-02 + 1.387710E-02 2.396613E-02 3.017058E-02 2.730397E-02 2.437341E-02 + 2.235199E-02 2.349822E-02 2.709905E-02 2.940728E-02 1.794723E-02 4.295116E-03 + 4.295117E-03 1.794724E-02 2.940729E-02 2.709905E-02 2.349823E-02 + 2.349823E-02 2.437341E-02 2.730397E-02 3.017058E-02 2.396614E-02 1.387711E-02 + 1.387711E-02 2.396614E-02 3.017059E-02 2.730398E-02 2.437341E-02 + 2.709905E-02 2.730397E-02 2.823737E-02 3.011892E-02 3.022111E-02 2.643896E-02 + 2.643896E-02 3.022112E-02 3.011894E-02 2.823738E-02 2.730398E-02 + 2.940728E-02 3.017057E-02 3.011891E-02 2.903883E-02 2.848320E-02 2.796804E-02 + 2.796804E-02 2.848321E-02 2.903884E-02 3.011893E-02 3.017058E-02 + 1.794723E-02 2.396612E-02 3.022109E-02 2.848319E-02 2.551992E-02 2.419105E-02 + 2.419105E-02 2.551993E-02 2.848320E-02 3.022111E-02 2.396614E-02 + 4.295116E-03 1.387710E-02 2.643893E-02 2.796802E-02 2.419104E-02 2.199204E-02 + 2.199205E-02 2.419105E-02 2.796803E-02 2.643895E-02 1.387711E-02 + 4.295116E-03 1.387709E-02 2.643892E-02 2.796801E-02 2.419104E-02 2.199204E-02 + 2.199204E-02 2.419105E-02 2.796803E-02 2.643894E-02 1.387710E-02 + 1.794723E-02 2.396611E-02 3.022108E-02 2.848317E-02 2.551991E-02 2.419104E-02 + 2.419104E-02 2.551992E-02 2.848319E-02 3.022110E-02 2.396613E-02 + 2.940727E-02 3.017056E-02 3.011890E-02 2.903881E-02 2.848318E-02 2.796802E-02 + 2.796802E-02 2.848319E-02 2.903883E-02 3.011892E-02 3.017057E-02 + 2.709904E-02 2.730396E-02 2.823736E-02 3.011890E-02 3.022109E-02 2.643893E-02 + 2.643893E-02 3.022110E-02 3.011892E-02 2.823737E-02 2.730397E-02 + 2.349822E-02 2.437341E-02 2.730397E-02 3.017057E-02 2.396612E-02 1.387710E-02 + 1.387710E-02 2.396613E-02 3.017058E-02 2.730397E-02 2.437341E-02 + 2.423446E-02 2.492059E-02 2.731506E-02 3.024329E-02 2.704917E-02 1.794723E-02 + 1.794723E-02 2.704918E-02 3.024330E-02 2.731507E-02 2.492059E-02 + 2.492059E-02 2.536251E-02 2.715040E-02 2.991952E-02 2.926327E-02 2.396614E-02 + 2.396614E-02 2.926328E-02 2.991953E-02 2.715041E-02 2.536251E-02 + 2.731506E-02 2.715040E-02 2.731311E-02 2.871323E-02 3.032298E-02 3.022112E-02 + 3.022112E-02 3.032299E-02 2.871324E-02 2.731312E-02 2.715041E-02 + 3.024329E-02 2.991951E-02 2.871322E-02 2.769249E-02 2.791847E-02 2.848320E-02 + 2.848321E-02 2.791848E-02 2.769251E-02 2.871324E-02 2.991952E-02 + 2.704917E-02 2.926325E-02 3.032296E-02 2.791846E-02 2.604732E-02 2.551993E-02 + 2.551993E-02 2.604733E-02 2.791848E-02 3.032298E-02 2.926327E-02 + 1.794723E-02 2.396612E-02 3.022109E-02 2.848318E-02 2.551992E-02 2.419105E-02 + 2.419105E-02 2.551993E-02 2.848320E-02 3.022111E-02 2.396613E-02 + 1.794722E-02 2.396612E-02 3.022108E-02 2.848318E-02 2.551992E-02 2.419104E-02 + 2.419105E-02 2.551993E-02 2.848319E-02 3.022110E-02 2.396613E-02 + 2.704916E-02 2.926324E-02 3.032295E-02 2.791845E-02 2.604731E-02 2.551992E-02 + 2.551992E-02 2.604732E-02 2.791847E-02 3.032297E-02 2.926326E-02 + 3.024328E-02 2.991950E-02 2.871321E-02 2.769248E-02 2.791846E-02 2.848318E-02 + 2.848318E-02 2.791846E-02 2.769249E-02 2.871323E-02 2.991951E-02 + 2.731506E-02 2.715039E-02 2.731310E-02 2.871321E-02 3.032296E-02 3.022109E-02 + 3.022109E-02 3.032297E-02 2.871323E-02 2.731311E-02 2.715040E-02 + 2.492058E-02 2.536250E-02 2.715040E-02 2.991951E-02 2.926325E-02 2.396613E-02 + 2.396613E-02 2.926326E-02 2.991952E-02 2.715041E-02 2.536251E-02 + 2.696170E-02 2.721709E-02 2.822582E-02 2.942940E-02 3.024329E-02 2.940728E-02 + 2.940728E-02 3.024330E-02 2.942941E-02 2.822583E-02 2.721709E-02 + 2.721709E-02 2.728076E-02 2.768910E-02 2.864415E-02 2.991952E-02 3.017058E-02 + 3.017059E-02 2.991953E-02 2.864416E-02 2.768911E-02 2.728076E-02 + 2.822583E-02 2.768910E-02 2.687390E-02 2.713980E-02 2.871323E-02 3.011893E-02 + 3.011893E-02 2.871324E-02 2.713981E-02 2.687391E-02 2.768911E-02 + 2.942941E-02 2.864415E-02 2.713980E-02 2.662493E-02 2.769250E-02 2.903884E-02 + 2.903884E-02 2.769251E-02 2.662494E-02 2.713981E-02 2.864416E-02 + 3.024329E-02 2.991951E-02 2.871322E-02 2.769249E-02 2.791847E-02 2.848320E-02 + 2.848320E-02 2.791848E-02 2.769250E-02 2.871324E-02 2.991952E-02 + 2.940728E-02 3.017057E-02 3.011891E-02 2.903882E-02 2.848319E-02 2.796803E-02 + 2.796803E-02 2.848320E-02 2.903883E-02 3.011892E-02 3.017058E-02 + 2.940727E-02 3.017056E-02 3.011890E-02 2.903882E-02 2.848319E-02 2.796803E-02 + 2.796803E-02 2.848319E-02 2.903883E-02 3.011892E-02 3.017057E-02 + 3.024328E-02 2.991950E-02 2.871321E-02 2.769248E-02 2.791846E-02 2.848319E-02 + 2.848319E-02 2.791847E-02 2.769249E-02 2.871323E-02 2.991951E-02 + 2.942940E-02 2.864414E-02 2.713979E-02 2.662492E-02 2.769248E-02 2.903882E-02 + 2.903882E-02 2.769249E-02 2.662493E-02 2.713980E-02 2.864415E-02 + 2.822582E-02 2.768909E-02 2.687389E-02 2.713979E-02 2.871322E-02 3.011891E-02 + 3.011891E-02 2.871322E-02 2.713980E-02 2.687390E-02 2.768910E-02 + 2.721709E-02 2.728075E-02 2.768909E-02 2.864414E-02 2.991951E-02 3.017057E-02 + 3.017057E-02 2.991952E-02 2.864416E-02 2.768911E-02 2.728076E-02 + 2.388272E-02 2.551680E-02 2.879102E-02 2.822582E-02 2.731506E-02 2.709904E-02 + 2.709904E-02 2.731506E-02 2.822583E-02 2.879104E-02 2.551680E-02 + 2.551680E-02 2.687636E-02 2.851901E-02 2.768910E-02 2.715040E-02 2.730397E-02 + 2.730397E-02 2.715041E-02 2.768911E-02 2.851902E-02 2.687636E-02 + 2.879104E-02 2.851901E-02 2.766619E-02 2.687390E-02 2.731311E-02 2.823737E-02 + 2.823738E-02 2.731312E-02 2.687391E-02 2.766620E-02 2.851902E-02 + 2.822583E-02 2.768910E-02 2.687390E-02 2.713980E-02 2.871323E-02 3.011893E-02 + 3.011893E-02 2.871324E-02 2.713981E-02 2.687391E-02 2.768911E-02 + 2.731506E-02 2.715040E-02 2.731311E-02 2.871323E-02 3.032298E-02 3.022111E-02 + 3.022111E-02 3.032298E-02 2.871324E-02 2.731312E-02 2.715041E-02 + 2.709904E-02 2.730397E-02 2.823736E-02 3.011892E-02 3.022111E-02 2.643895E-02 + 2.643894E-02 3.022111E-02 3.011893E-02 2.823737E-02 2.730397E-02 + 2.709904E-02 2.730396E-02 2.823736E-02 3.011891E-02 3.022110E-02 2.643894E-02 + 2.643894E-02 3.022110E-02 3.011892E-02 2.823737E-02 2.730397E-02 + 2.731506E-02 2.715039E-02 2.731310E-02 2.871322E-02 3.032296E-02 3.022110E-02 + 3.022110E-02 3.032297E-02 2.871323E-02 2.731311E-02 2.715040E-02 + 2.822582E-02 2.768909E-02 2.687389E-02 2.713979E-02 2.871322E-02 3.011891E-02 + 3.011891E-02 2.871323E-02 2.713980E-02 2.687390E-02 2.768910E-02 + 2.879102E-02 2.851900E-02 2.766618E-02 2.687389E-02 2.731310E-02 2.823736E-02 + 2.823736E-02 2.731311E-02 2.687390E-02 2.766619E-02 2.851901E-02 + 2.551679E-02 2.687635E-02 2.851900E-02 2.768909E-02 2.715040E-02 2.730396E-02 + 2.730397E-02 2.715040E-02 2.768910E-02 2.851901E-02 2.687635E-02 + 1.169441E-02 1.820251E-02 2.551678E-02 2.721708E-02 2.492058E-02 2.349822E-02 + 2.349822E-02 2.492058E-02 2.721709E-02 2.551680E-02 1.820253E-02 + 1.820252E-02 2.244619E-02 2.687635E-02 2.728075E-02 2.536251E-02 2.437341E-02 + 2.437341E-02 2.536251E-02 2.728076E-02 2.687637E-02 2.244619E-02 + 2.551680E-02 2.687636E-02 2.851901E-02 2.768911E-02 2.715041E-02 2.730398E-02 + 2.730398E-02 2.715041E-02 2.768911E-02 2.851902E-02 2.687636E-02 + 2.721709E-02 2.728076E-02 2.768911E-02 2.864416E-02 2.991953E-02 3.017059E-02 + 3.017059E-02 2.991953E-02 2.864417E-02 2.768912E-02 2.728077E-02 + 2.492059E-02 2.536251E-02 2.715041E-02 2.991953E-02 2.926328E-02 2.396614E-02 + 2.396614E-02 2.926328E-02 2.991953E-02 2.715042E-02 2.536251E-02 + 2.349822E-02 2.437341E-02 2.730397E-02 3.017058E-02 2.396614E-02 1.387711E-02 + 1.387711E-02 2.396614E-02 3.017059E-02 2.730398E-02 2.437341E-02 + 2.349822E-02 2.437341E-02 2.730397E-02 3.017058E-02 2.396613E-02 1.387711E-02 + 1.387710E-02 2.396613E-02 3.017058E-02 2.730398E-02 2.437341E-02 + 2.492058E-02 2.536250E-02 2.715040E-02 2.991951E-02 2.926326E-02 2.396613E-02 + 2.396613E-02 2.926326E-02 2.991952E-02 2.715041E-02 2.536251E-02 + 2.721708E-02 2.728075E-02 2.768909E-02 2.864415E-02 2.991951E-02 3.017057E-02 + 3.017058E-02 2.991952E-02 2.864415E-02 2.768910E-02 2.728075E-02 + 2.551678E-02 2.687634E-02 2.851900E-02 2.768909E-02 2.715040E-02 2.730397E-02 + 2.730397E-02 2.715040E-02 2.768910E-02 2.851901E-02 2.687635E-02 + 1.820251E-02 2.244618E-02 2.687634E-02 2.728075E-02 2.536250E-02 2.437340E-02 + 2.437340E-02 2.536250E-02 2.728076E-02 2.687636E-02 2.244618E-02 diff --git a/utils/pdos/examples/Al_FCC/Al.eigen b/utils/pdos/examples/Al_FCC/Al.eigen new file mode 100644 index 00000000..e6286155 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.eigen @@ -0,0 +1,17 @@ +Final eigenvalues (Ha) and occupation numbers + +kred #1 = (0.500000,0.500000,0.500000) +weight = 1.000000 +n eigval occ +1 2.155289503627E-02 1.965482468593 +2 2.155290528615E-02 1.965482120897 +3 2.155294972389E-02 1.965480613442 +4 2.269820908888E-02 1.895367282017 +5 2.543098384753E-02 1.081785346040 +6 2.543104271465E-02 1.081756109282 +7 2.543104975635E-02 1.081752611966 +8 2.566916789454E-02 0.962893452348 +9 1.846810297541E-01 0.000000000000 +10 1.846810433632E-01 0.000000000000 +11 5.999274350749E-01 0.000000000000 +12 6.006998878977E-01 0.000000000000 diff --git a/utils/pdos/examples/Al_FCC/Al.inpt b/utils/pdos/examples/Al_FCC/Al.inpt new file mode 100644 index 00000000..7e42218c --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.inpt @@ -0,0 +1,24 @@ +LATVEC: + 1.0 0.0 0.0 + 0.0 1.0 0.0 + 0.0 0.0 1.0 + +CELL: 7.653391 7.653391 7.653391 +KPOINT_GRID: 1 1 1 +KPOINT_SHIFT: 0.5 0.5 0.5 +BC: P P P + +MESH_SPACING: 0.7 + + + +EXCHANGE_CORRELATION: GGA_PBE +TOL_SCF: 1e-5 +SMEARING: 0.001 +ELEC_TEMP_TYPE: fd +PRINT_DENSITY: 1 +CALC_STRESS: 1 +PRINT_EIGEN: 1 +PRINT_ORBITAL: 1 + + diff --git a/utils/pdos/examples/Al_FCC/Al.ion b/utils/pdos/examples/Al_FCC/Al.ion new file mode 100644 index 00000000..e06cba46 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.ion @@ -0,0 +1,12 @@ +ATOM_TYPE: Al +N_TYPE_ATOM: 4 +COORD_FRAC: + 0.0 0.0 0.0 + 0.5 0.5 0.0 + 0.5 0.0 0.5 + 0.0 0.5 0.5 + +PSEUDO_POT: Al.psp8 + + + diff --git a/utils/pdos/examples/Al_FCC/Al.out b/utils/pdos/examples/Al_FCC/Al.out new file mode 100644 index 00000000..193588e8 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.out @@ -0,0 +1,153 @@ +*************************************************************************** +* SPARC (version June 17, 2025) * +* Copyright (c) 2020 Material Physics & Mechanics Group, Georgia Tech * +* Distributed under GNU General Public License 3 (GPL) * +* Start time: Tue Oct 14 13:54:05 2025 * +*************************************************************************** + Input parameters +*************************************************************************** +CELL: 7.653391 7.653391 7.653391 +LATVEC: +1.000000000000000 0.000000000000000 0.000000000000000 +0.000000000000000 1.000000000000000 0.000000000000000 +0.000000000000000 0.000000000000000 1.000000000000000 +FD_GRID: 11 11 11 +FD_ORDER: 12 +BC: P P P +KPOINT_GRID: 1 1 1 +KPOINT_SHIFT: 0.5 0.5 0.5 +SPIN_TYP: 0 +ELEC_TEMP_TYPE: Fermi-Dirac +SMEARING: 0.001 +EXCHANGE_CORRELATION: GGA_PBE +HUBBARD_FLAG: 0 +NSTATES: 12 +CHEB_DEGREE: 14 +CHEFSI_BOUND_FLAG: 0 +CALC_STRESS: 1 +MAXIT_SCF: 100 +MINIT_SCF: 2 +MAXIT_POISSON: 3000 +TOL_SCF: 1.00E-05 +POISSON_SOLVER: AAR +TOL_POISSON: 1.00E-07 +TOL_LANCZOS: 1.00E-02 +TOL_PSEUDOCHARGE: 1.00E-08 +MIXING_VARIABLE: density +MIXING_PRECOND: kerker +TOL_PRECOND: 4.84E-04 +PRECOND_KERKER_KTF: 1 +PRECOND_KERKER_THRESH: 0.1 +MIXING_PARAMETER: 0.3 +MIXING_HISTORY: 7 +PULAY_FREQUENCY: 1 +PULAY_RESTART: 0 +REFERENCE_CUTOFF: 0.5 +RHO_TRIGGER: 4 +NUM_CHEFSI: 1 +FIX_RAND: 0 +VERBOSITY: 1 +PRINT_FORCES: 1 +PRINT_ATOMS: 1 +PRINT_EIGEN: 1 +PRINT_DENSITY: 1 +PRINT_ORBITAL: 1 0 0 0 0 0 11 +PRINT_ENERGY_DENSITY: 0 +OUTPUT_FILE: Al +*************************************************************************** + Cell +*************************************************************************** +Lattice vectors (Bohr): +7.653391000000000 0.000000000000000 0.000000000000000 +0.000000000000000 7.653391000000000 0.000000000000000 +0.000000000000000 0.000000000000000 7.653391000000000 +Volume: 4.4829273833E+02 (Bohr^3) +Density: 2.4074928004E-01 (amu/Bohr^3), 2.6978058721E+00 (g/cc) +*************************************************************************** + Parallelization +*************************************************************************** +NP_SPIN_PARAL: 1 +NP_KPOINT_PARAL: 1 +NP_BAND_PARAL: 1 +NP_DOMAIN_PARAL: 1 1 1 +NP_DOMAIN_PHI_PARAL: 1 1 1 +EIG_SERIAL_MAXNS: 1500 +*************************************************************************** + Initialization +*************************************************************************** +Number of processors : 1 +Mesh spacing : 0.695763 (Bohr) +Number of symmetry adapted k-points: 1 +Output printed to : Al.out +Final eigenvalues printed to : Al.eigen +Total number of atom types : 1 +Total number of atoms : 4 +Total number of electrons : 12 +Atom type 1 (valence electrons) : Al 3 +Pseudopotential : Al.psp8 +Atomic mass : 26.9815385 +Pseudocharge radii of atom type 1 : 9.04 9.04 9.04 (x, y, z dir) +Number of atoms of type 1 : 4 +Estimated total memory usage : 2.19 MB +Estimated memory per processor : 2.19 MB +=================================================================== + Self Consistent Field (SCF#1) +=================================================================== +Iteration Free Energy (Ha/atom) SCF Error Timing (sec) +1 -2.3351847085E+00 2.258E-01 0.038 +2 -2.3348782892E+00 2.098E-01 0.011 +3 -2.3333487208E+00 1.355E-01 0.010 +4 -2.3335778960E+00 1.846E-01 0.010 +5 -2.3328142785E+00 1.436E-01 0.010 +6 -2.3324473094E+00 2.901E-02 0.012 +7 -2.3324657808E+00 4.476E-02 0.011 +8 -2.3324515109E+00 3.604E-02 0.009 +9 -2.3324323716E+00 1.671E-02 0.010 +10 -2.3324287201E+00 1.469E-02 0.009 +11 -2.3324261747E+00 8.621E-03 0.009 +12 -2.3324254862E+00 5.246E-03 0.009 +13 -2.3324250818E+00 7.183E-04 0.009 +14 -2.3324250949E+00 1.141E-03 0.009 +15 -2.3324250613E+00 2.777E-04 0.009 +16 -2.3324250552E+00 2.470E-04 0.009 +17 -2.3324250707E+00 2.790E-04 0.009 +18 -2.3324250666E+00 1.563E-04 0.009 +19 -2.3324250772E+00 7.178E-05 0.009 +20 -2.3324250888E+00 6.015E-05 0.009 +21 -2.3324250698E+00 4.028E-05 0.009 +22 -2.3324250704E+00 2.041E-05 0.009 +23 -2.3324250781E+00 3.269E-05 0.009 +24 -2.3324250617E+00 2.998E-05 0.009 +25 -2.3324250772E+00 8.503E-06 0.010 +Total number of SCF: 25 +==================================================================== + Energy and force calculation +==================================================================== +Free energy per atom : -2.3324250772E+00 (Ha/atom) +Total free energy : -9.3297003089E+00 (Ha) +Band structure energy : 2.7735486472E-01 (Ha) +Exchange correlation energy : -4.3431931097E+00 (Ha) +Self and correction energy : -1.2497908030E+01 (Ha) +-Entropy*kb*T : -6.4573090840E-03 (Ha) +Fermi level : 2.5594920710E-02 (Ha) +RMS force : 2.5768133206E-06 (Ha/Bohr) +Maximum force : 2.7411429704E-06 (Ha/Bohr) +Time for force calculation : 0.046 (sec) +Pressure : -9.8648903148E+00 (GPa) +Maximum stress : 9.8648955572E+00 (GPa) +Time for stress calculation : 0.104 (sec) +*************************************************************************** + Timing info +*************************************************************************** +Total walltime : 0.457 sec +___________________________________________________________________________ + +*************************************************************************** +* Material Physics & Mechanics Group, Georgia Tech * +* PI: Phanish Suryanarayana * +* List of contributors: See the documentation * +* Citation: See README.md or the documentation for details * +* Acknowledgements: U.S. DOE SC (DE-SC0019410), U.S. DOE NNSA (ASC) * +* {Preliminary developments: U.S. NSF (1333500,1663244,1553212)} * +*************************************************************************** + diff --git a/utils/pdos/examples/Al_FCC/Al.psi b/utils/pdos/examples/Al_FCC/Al.psi new file mode 100644 index 00000000..2861ebdb Binary files /dev/null and b/utils/pdos/examples/Al_FCC/Al.psi differ diff --git a/utils/pdos/examples/Al_FCC/Al.psp8 b/utils/pdos/examples/Al_FCC/Al.psp8 new file mode 100644 index 00000000..04fb29e4 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.psp8 @@ -0,0 +1,3686 @@ +Al ONCVPSP-4.0.1 r_core= 1.92652 1.94971 1.94971 + 13.0000 3.0000 220721 zatom,zion,pspd + 8 11 2 4 600 0 pspcod,pspxc,lmax,lloc,mmax,r2well + 5.99000000 5.00000000 0.00000000 rchrg fchrg qchrg + 2 2 2 0 0 nproj + 1 1 extension_switch + 0 3.9020927307898E+00 3.2229335348000E-01 + 1 0.0000000000000E+00 -4.4526610176732E-10 1.3609380011825E-09 + 2 1.0000000000000E-02 3.6237216640807E-02 -2.4226846868975E-02 + 3 2.0000000000000E-02 7.2388363722540E-02 -4.8245715403825E-02 + 4 3.0000000000000E-02 1.0836819360102E-01 -7.1851066883961E-02 + 5 4.0000000000000E-02 1.4409309274637E-01 -9.4842212312218E-02 + 6 5.0000000000000E-02 1.7948187462598E-01 -1.1702566386781E-01 + 7 6.0000000000000E-02 2.1445654389821E-01 -1.3821739924576E-01 + 8 7.0000000000000E-02 2.4894302288219E-01 -1.5824501146116E-01 + 9 8.0000000000000E-02 2.8287183171482E-01 -1.7694971805722E-01 + 10 9.0000000000000E-02 3.1617871415235E-01 -1.9418820532762E-01 + 11 1.0000000000000E-01 3.4880520161627E-01 -2.0983428512506E-01 + 12 1.1000000000000E-01 3.8069910881252E-01 -2.2378034405738E-01 + 13 1.2000000000000E-01 4.1181495506212E-01 -2.3593856734408E-01 + 14 1.3000000000000E-01 4.4211430635978E-01 -2.4624192228955E-01 + 15 1.4000000000000E-01 4.7156603411496E-01 -2.5464488919460E-01 + 16 1.5000000000000E-01 5.0014648751702E-01 -2.6112393054125E-01 + 17 1.6000000000000E-01 5.2783957748935E-01 -2.6567769241064E-01 + 18 1.7000000000000E-01 5.5463677124663E-01 -2.6832693529572E-01 + 19 1.8000000000000E-01 5.8053699753102E-01 -2.6911419470965E-01 + 20 1.9000000000000E-01 6.0554646366524E-01 -2.6810317523093E-01 + 21 2.0000000000000E-01 6.2967838661081E-01 -2.6537788482759E-01 + 22 2.1000000000000E-01 6.5295264124573E-01 -2.6104151942980E-01 + 23 2.2000000000000E-01 6.7539533006527E-01 -2.5521511073309E-01 + 24 2.3000000000000E-01 6.9703827945138E-01 -2.4803595308074E-01 + 25 2.4000000000000E-01 7.1791846853852E-01 -2.3965582795676E-01 + 26 2.5000000000000E-01 7.3807739751719E-01 -2.3023904709099E-01 + 27 2.6000000000000E-01 7.5756040294976E-01 -2.1996033740344E-01 + 28 2.7000000000000E-01 7.7641592831979E-01 -2.0900259297162E-01 + 29 2.8000000000000E-01 7.9469475858622E-01 -1.9755452086665E-01 + 30 2.9000000000000E-01 8.1244922796210E-01 -1.8580820905300E-01 + 31 3.0000000000000E-01 8.2973241047828E-01 -1.7395664556500E-01 + 32 3.1000000000000E-01 8.4659730312097E-01 -1.6219121884875E-01 + 33 3.2000000000000E-01 8.6309601144629E-01 -1.5069922948127E-01 + 34 3.3000000000000E-01 8.7927894757233E-01 -1.3966144344630E-01 + 35 3.4000000000000E-01 8.9519405033009E-01 -1.2924971675562E-01 + 36 3.5000000000000E-01 9.1088603712034E-01 -1.1962472046137E-01 + 37 3.6000000000000E-01 9.2639569667547E-01 -1.1093379401607E-01 + 38 3.7000000000000E-01 9.4175923146853E-01 -1.0330895351282E-01 + 39 3.8000000000000E-01 9.5700765795045E-01 -9.6865079597865E-02 + 40 3.9000000000000E-01 9.7216627213696E-01 -9.1698307806427E-02 + 41 4.0000000000000E-01 9.8725418731707E-01 -8.7884641756803E-02 + 42 4.1000000000000E-01 1.0022839498227E+00 -8.5478807071773E-02 + 43 4.2000000000000E-01 1.0172612378945E+00 -8.4513361110012E-02 + 44 4.3000000000000E-01 1.0321846477124E+00 -8.4998070614668E-02 + 45 4.4000000000000E-01 1.0470455696396E+00 -8.6919566257464E-02 + 46 4.5000000000000E-01 1.0618281566726E+00 -9.0241279807683E-02 + 47 4.6000000000000E-01 1.0765093860039E+00 -9.4903666327211E-02 + 48 4.7000000000000E-01 1.0910592135035E+00 -1.0082471042064E-01 + 49 4.8000000000000E-01 1.1054408198228E+00 -1.0790071219541E-01 + 50 4.9000000000000E-01 1.1196109457348E+00 -1.1600734524805E-01 + 51 5.0000000000000E-01 1.1335203132541E+00 -1.2500097572933E-01 + 52 5.1000000000000E-01 1.1471141280495E+00 -1.3472022839180E-01 + 53 5.2000000000000E-01 1.1603326576761E+00 -1.4498778252372E-01 + 54 5.3000000000000E-01 1.1731118792328E+00 -1.5561237786090E-01 + 55 5.4000000000000E-01 1.1853841891925E+00 -1.6639100797510E-01 + 56 5.5000000000000E-01 1.1970791673827E+00 -1.7711127629499E-01 + 57 5.6000000000000E-01 1.2081243864103E+00 -1.8755388785372E-01 + 58 5.7000000000000E-01 1.2184462572378E+00 -1.9749524809769E-01 + 59 5.8000000000000E-01 1.2279709011430E+00 -2.0671013865926E-01 + 60 5.9000000000000E-01 1.2366250379216E+00 -2.1497443890806E-01 + 61 6.0000000000000E-01 1.2443368799445E+00 -2.2206786136581E-01 + 62 6.1000000000000E-01 1.2510370215488E+00 -2.2777666870860E-01 + 63 6.2000000000000E-01 1.2566593132295E+00 -2.3189634009414E-01 + 64 6.3000000000000E-01 1.2611417102151E+00 -2.3423415494107E-01 + 65 6.4000000000000E-01 1.2644270852388E+00 -2.3461166305067E-01 + 66 6.5000000000000E-01 1.2664639956759E+00 -2.3286701109020E-01 + 67 6.6000000000000E-01 1.2672073956818E+00 -2.2885709694290E-01 + 68 6.7000000000000E-01 1.2666192845497E+00 -2.2245952525276E-01 + 69 6.8000000000000E-01 1.2646692831888E+00 -2.1357433963802E-01 + 70 6.9000000000000E-01 1.2613351314078E+00 -2.0212550948891E-01 + 71 7.0000000000000E-01 1.2566030995589E+00 -1.8806215197808E-01 + 72 7.1000000000000E-01 1.2504683090507E+00 -1.7135947286556E-01 + 73 7.2000000000000E-01 1.2429349572528E+00 -1.5201941284132E-01 + 74 7.3000000000000E-01 1.2340164433976E+00 -1.3007098948302E-01 + 75 7.4000000000000E-01 1.2237353932026E+00 -1.0557032837508E-01 + 76 7.5000000000000E-01 1.2121235810926E+00 -7.8600380500836E-02 + 77 7.6000000000000E-01 1.1992217500764E+00 -4.9270326640719E-02 + 78 7.7000000000000E-01 1.1850793305124E+00 -1.7714673143061E-02 + 79 7.8000000000000E-01 1.1697540601690E+00 1.5907952956873E-02 + 80 7.9000000000000E-01 1.1533115091423E+00 5.1416297956352E-02 + 81 8.0000000000000E-01 1.1358245143075E+00 8.8608249701278E-02 + 82 8.1000000000000E-01 1.1173725290545E+00 1.2726286177798E-01 + 83 8.2000000000000E-01 1.0980408950690E+00 1.6714261236960E-01 + 84 8.3000000000000E-01 1.0779200438615E+00 2.0799587360054E-01 + 85 8.4000000000000E-01 1.0571046366028E+00 2.4955956458546E-01 + 86 8.5000000000000E-01 1.0356926515927E+00 2.9156195908248E-01 + 87 8.6000000000000E-01 1.0137844293481E+00 3.3372561665236E-01 + 88 8.7000000000000E-01 9.9148168585317E-01 3.7577040456971E-01 + 89 8.8000000000000E-01 9.6888650494746E-01 4.1741657644119E-01 + 90 8.9000000000000E-01 9.4610032114398E-01 4.5838787257470E-01 + 91 9.0000000000000E-01 9.2322290435369E-01 4.9841460662669E-01 + 92 9.1000000000000E-01 9.0035135805101E-01 5.3723670293993E-01 + 93 9.2000000000000E-01 8.7757914234098E-01 5.7460664927221E-01 + 94 9.3000000000000E-01 8.5499513318318E-01 6.1029233031438E-01 + 95 9.4000000000000E-01 8.3268272869381E-01 6.4407970848687E-01 + 96 9.5000000000000E-01 8.1071901298647E-01 6.7577531998998E-01 + 97 9.6000000000000E-01 7.8917398743026E-01 7.0520855593946E-01 + 98 9.7000000000000E-01 7.6810987850514E-01 7.3223370063460E-01 + 99 9.8000000000000E-01 7.4758053062851E-01 7.5673170155295E-01 + 100 9.9000000000000E-01 7.2763089141933E-01 7.7861164852057E-01 + 101 1.0000000000000E+00 7.0829659586915E-01 7.9781194263759E-01 + 102 1.0100000000000E+00 6.8960365481276E-01 8.1430113890993E-01 + 103 1.0200000000000E+00 6.7156825194538E-01 8.2807845011992E-01 + 104 1.0300000000000E+00 6.5419665243330E-01 8.3917390321319E-01 + 105 1.0400000000000E+00 6.3748522492215E-01 8.4764814335042E-01 + 106 1.0500000000000E+00 6.2142057747563E-01 8.5359188472836E-01 + 107 1.0600000000000E+00 6.0597980669092E-01 8.5712501127014E-01 + 108 1.0700000000000E+00 5.9113085795341E-01 8.5839533426778E-01 + 109 1.0800000000000E+00 5.7683299351925E-01 8.5757701800560E-01 + 110 1.0900000000000E+00 5.6303736387466E-01 8.5486868822718E-01 + 111 1.1000000000000E+00 5.4968767661875E-01 8.5049124202117E-01 + 112 1.1100000000000E+00 5.3672095597565E-01 8.4468538121737E-01 + 113 1.1200000000000E+00 5.2406838496781E-01 8.3770889468903E-01 + 114 1.1300000000000E+00 5.1165622129068E-01 8.2983371799916E-01 + 115 1.1400000000000E+00 4.9940677703338E-01 8.2134280157060E-01 + 116 1.1500000000000E+00 4.8723945159552E-01 8.1252682098032E-01 + 117 1.1600000000000E+00 4.7507180647258E-01 8.0368076503468E-01 + 118 1.1700000000000E+00 4.6282067002458E-01 7.9510043896164E-01 + 119 1.1800000000000E+00 4.5040325991548E-01 7.8707892132675E-01 + 120 1.1900000000000E+00 4.3773831061728E-01 7.7990301413321E-01 + 121 1.2000000000000E+00 4.2474719321828E-01 7.7384972598479E-01 + 122 1.2100000000000E+00 4.1135501476151E-01 7.6918282817009E-01 + 123 1.2200000000000E+00 3.9749168446856E-01 7.6614952306123E-01 + 124 1.2300000000000E+00 3.8309293447398E-01 7.6497726331723E-01 + 125 1.2400000000000E+00 3.6810128310524E-01 7.6587075904436E-01 + 126 1.2500000000000E+00 3.5246692929054E-01 7.6900920830089E-01 + 127 1.2600000000000E+00 3.3614856734948E-01 7.7454378418099E-01 + 128 1.2700000000000E+00 3.1911411222513E-01 7.8259540915326E-01 + 129 1.2800000000000E+00 3.0134132613083E-01 7.9325284442623E-01 + 130 1.2900000000000E+00 2.8281833860326E-01 8.0657111889308E-01 + 131 1.3000000000000E+00 2.6354405307618E-01 8.2257031866142E-01 + 132 1.3100000000000E+00 2.4352843428823E-01 8.4123475439780E-01 + 133 1.3200000000000E+00 2.2279267210696E-01 8.6251251972444E-01 + 134 1.3300000000000E+00 2.0136921868648E-01 8.8631544971141E-01 + 135 1.3400000000000E+00 1.7930169724588E-01 9.1251948421111E-01 + 136 1.3500000000000E+00 1.5664468215767E-01 9.4096543638736E-01 + 137 1.3600000000000E+00 1.3346335144636E-01 9.7146016237570E-01 + 138 1.3700000000000E+00 1.0983301421506E-01 1.0037781235791E+00 + 139 1.3800000000000E+00 8.5838516906744E-02 1.0376633287647E+00 + 140 1.3900000000000E+00 6.1573533670679E-02 1.0728316388731E+00 + 141 1.4000000000000E+00 3.7139747412047E-02 1.1089734133753E+00 + 142 1.4100000000000E+00 1.2645929358662E-02 1.1457564731050E+00 + 143 1.4200000000000E+00 -1.1793073854096E-02 1.1828293508639E+00 + 144 1.4300000000000E+00 -3.6057435495273E-02 1.2198247977350E+00 + 145 1.4400000000000E+00 -6.0023515381761E-02 1.2563635100004E+00 + 146 1.4500000000000E+00 -8.3565085925359E-02 1.2920580388944E+00 + 147 1.4600000000000E+00 -1.0655460490848E-01 1.3265168431204E+00 + 148 1.4700000000000E+00 -1.2886452170802E-01 1.3593484422031E+00 + 149 1.4800000000000E+00 -1.5036860321538E-01 1.3901656273089E+00 + 150 1.4900000000000E+00 -1.7094326537695E-01 1.4185896851977E+00 + 151 1.5000000000000E+00 -1.9046889610512E-01 1.4442545904611E+00 + 152 1.5100000000000E+00 -2.0883115528847E-01 1.4668111211797E+00 + 153 1.5200000000000E+00 -2.2592223776103E-01 1.4859308535818E+00 + 154 1.5300000000000E+00 -2.4164208537653E-01 1.5013099922237E+00 + 155 1.5400000000000E+00 -2.5589953476796E-01 1.5126729936112E+00 + 156 1.5500000000000E+00 -2.6861338795561E-01 1.5197759430451E+00 + 157 1.5600000000000E+00 -2.7971339368934E-01 1.5224096467753E+00 + 158 1.5700000000000E+00 -2.8914112826794E-01 1.5204024042646E+00 + 159 1.5800000000000E+00 -2.9685076556069E-01 1.5136224284766E+00 + 160 1.5900000000000E+00 -3.0280972705376E-01 1.5019798855676E+00 + 161 1.6000000000000E+00 -3.0699920394537E-01 1.4854285291544E+00 + 162 1.6100000000000E+00 -3.0941454460649E-01 1.4639669084080E+00 + 163 1.6200000000000E+00 -3.1006550209501E-01 1.4376391335369E+00 + 164 1.6300000000000E+00 -3.0897633784683E-01 1.4065351867456E+00 + 165 1.6400000000000E+00 -3.0618577914674E-01 1.3707907714046E+00 + 166 1.6500000000000E+00 -3.0174682950314E-01 1.3305866969482E+00 + 167 1.6600000000000E+00 -2.9572643257876E-01 1.2861478018175E+00 + 168 1.6700000000000E+00 -2.8820499186509E-01 1.2377414215853E+00 + 169 1.6800000000000E+00 -2.7927574980305E-01 1.1856754141546E+00 + 170 1.6900000000000E+00 -2.6904403153899E-01 1.1302957585822E+00 + 171 1.7000000000000E+00 -2.5762635993983E-01 1.0719837485787E+00 + 172 1.7100000000000E+00 -2.4514944986453E-01 1.0111528060387E+00 + 173 1.7200000000000E+00 -2.3174909098254E-01 9.4824494400473E-01 + 174 1.7300000000000E+00 -2.1756892963152E-01 8.8372691223362E-01 + 175 1.7400000000000E+00 -2.0275916130183E-01 8.1808606195443E-01 + 176 1.7500000000000E+00 -1.8747514631342E-01 7.5182596947144E-01 + 177 1.7600000000000E+00 -1.7187596209956E-01 6.8546186091191E-01 + 178 1.7700000000000E+00 -1.5612290622350E-01 6.1951588264229E-01 + 179 1.7800000000000E+00 -1.4037796482060E-01 5.5451226363910E-01 + 180 1.7900000000000E+00 -1.2480226157110E-01 4.9097241738319E-01 + 181 1.8000000000000E+00 -1.0955450051568E-01 4.2941002464911E-01 + 182 1.8100000000000E+00 -9.4789438773465E-02 3.7032621736759E-01 + 183 1.8200000000000E+00 -8.0656324284123E-02 3.1420462429227E-01 + 184 1.8300000000000E+00 -6.7297505837702E-02 2.6150705383035E-01 + 185 1.8400000000000E+00 -5.4849084202917E-02 2.1267590243222E-01 + 186 1.8500000000000E+00 -4.3437508052910E-02 1.6812240181028E-01 + 187 1.8600000000000E+00 -3.3174898028252E-02 1.2821091056832E-01 + 188 1.8700000000000E+00 -2.4161069616334E-02 9.3266495933668E-02 + 189 1.8800000000000E+00 -1.6482323691684E-02 6.3570970912343E-02 + 190 1.8900000000000E+00 -1.0210609454547E-02 3.9360255899480E-02 + 191 1.9000000000000E+00 -5.4048638966018E-03 2.0830072751187E-02 + 192 1.9100000000000E+00 -2.0858734062744E-03 8.0393670034514E-03 + 193 1.9200000000000E+00 -3.6980760350374E-04 1.4257547580075E-03 + 194 1.9300000000000E+00 4.8086080050191E-05 -1.8554054000548E-04 + 195 1.9400000000000E+00 -9.0394501798162E-06 3.4860632451168E-05 + 196 1.9500 0. -0. + 197 1.9600 0. -0. + 198 1.9700 0. -0. + 199 1.9800 0. 0. + 200 1.9900 0. 0. + 201 2.0000 0. 0. + 202 2.0100 0. 0. + 203 2.0200 0. 0. + 204 2.0300 0. 0. + 205 2.0400 0. 0. + 206 2.0500 0. 0. + 207 2.0600 0. 0. + 208 2.0700 0. 0. + 209 2.0800 0. 0. + 210 2.0900 0. 0. + 211 2.1000 0. 0. + 212 2.1100 0. 0. + 213 2.1200 0. 0. + 214 2.1300 0. 0. + 215 2.1400 0. 0. + 216 2.1500 0. 0. + 217 2.1600 0. 0. + 218 2.1700 0. 0. + 219 2.1800 0. 0. + 220 2.1900 0. 0. + 221 2.2000 0. 0. + 222 2.2100 0. 0. + 223 2.2200 0. 0. + 224 2.2300 0. 0. + 225 2.2400 0. 0. + 226 2.2500 0. 0. + 227 2.2600 0. 0. + 228 2.2700 0. 0. + 229 2.2800 0. 0. + 230 2.2900 0. 0. + 231 2.3000 0. 0. + 232 2.3100 0. 0. + 233 2.3200 0. 0. + 234 2.3300 0. 0. + 235 2.3400 0. 0. + 236 2.3500 0. 0. + 237 2.3600 0. 0. + 238 2.3700 0. 0. + 239 2.3800 0. 0. + 240 2.3900 0. 0. + 241 2.4000 0. 0. + 242 2.4100 0. 0. + 243 2.4200 0. 0. + 244 2.4300 0. 0. + 245 2.4400 0. 0. + 246 2.4500 0. 0. + 247 2.4600 0. 0. + 248 2.4700 0. 0. + 249 2.4800 0. 0. + 250 2.4900 0. 0. + 251 2.5000 0. 0. + 252 2.5100 0. 0. + 253 2.5200 0. 0. + 254 2.5300 0. 0. + 255 2.5400 0. 0. + 256 2.5500 0. 0. + 257 2.5600 0. 0. + 258 2.5700 0. 0. + 259 2.5800 0. 0. + 260 2.5900 0. 0. + 261 2.6000 0. 0. + 262 2.6100 0. 0. + 263 2.6200 0. 0. + 264 2.6300 0. 0. + 265 2.6400 0. 0. + 266 2.6500 0. 0. + 267 2.6600 0. 0. + 268 2.6700 0. 0. + 269 2.6800 0. 0. + 270 2.6900 0. 0. + 271 2.7000 0. 0. + 272 2.7100 0. 0. + 273 2.7200 0. 0. + 274 2.7300 0. 0. + 275 2.7400 0. 0. + 276 2.7500 0. 0. + 277 2.7600 0. 0. + 278 2.7700 0. 0. + 279 2.7800 0. 0. + 280 2.7900 0. 0. + 281 2.8000 0. 0. + 282 2.8100 0. 0. + 283 2.8200 0. 0. + 284 2.8300 0. 0. + 285 2.8400 0. 0. + 286 2.8500 0. 0. + 287 2.8600 0. 0. + 288 2.8700 0. 0. + 289 2.8800 0. 0. + 290 2.8900 0. 0. + 291 2.9000 0. 0. + 292 2.9100 0. 0. + 293 2.9200 0. 0. + 294 2.9300 0. 0. + 295 2.9400 0. 0. + 296 2.9500 0. 0. + 297 2.9600 0. 0. + 298 2.9700 0. 0. + 299 2.9800 0. 0. + 300 2.9900 0. 0. + 301 3.0000 0. 0. + 302 3.0100 0. 0. + 303 3.0200 0. 0. + 304 3.0300 0. 0. + 305 3.0400 0. 0. + 306 3.0500 0. 0. + 307 3.0600 0. 0. + 308 3.0700 0. 0. + 309 3.0800 0. 0. + 310 3.0900 0. 0. + 311 3.1000 0. 0. + 312 3.1100 0. 0. + 313 3.1200 0. 0. + 314 3.1300 0. 0. + 315 3.1400 0. 0. + 316 3.1500 0. 0. + 317 3.1600 0. 0. + 318 3.1700 0. 0. + 319 3.1800 0. 0. + 320 3.1900 0. 0. + 321 3.2000 0. 0. + 322 3.2100 0. 0. + 323 3.2200 0. 0. + 324 3.2300 0. 0. + 325 3.2400 0. 0. + 326 3.2500 0. 0. + 327 3.2600 0. 0. + 328 3.2700 0. 0. + 329 3.2800 0. 0. + 330 3.2900 0. 0. + 331 3.3000 0. 0. + 332 3.3100 0. 0. + 333 3.3200 0. 0. + 334 3.3300 0. 0. + 335 3.3400 0. 0. + 336 3.3500 0. 0. + 337 3.3600 0. 0. + 338 3.3700 0. 0. + 339 3.3800 0. 0. + 340 3.3900 0. 0. + 341 3.4000 0. 0. + 342 3.4100 0. 0. + 343 3.4200 0. 0. + 344 3.4300 0. 0. + 345 3.4400 0. 0. + 346 3.4500 0. 0. + 347 3.4600 0. 0. + 348 3.4700 0. 0. + 349 3.4800 0. 0. + 350 3.4900 0. 0. + 351 3.5000 0. 0. + 352 3.5100 0. 0. + 353 3.5200 0. 0. + 354 3.5300 0. 0. + 355 3.5400 0. 0. + 356 3.5500 0. 0. + 357 3.5600 0. 0. + 358 3.5700 0. 0. + 359 3.5800 0. 0. + 360 3.5900 0. 0. + 361 3.6000 0. 0. + 362 3.6100 0. 0. + 363 3.6200 0. 0. + 364 3.6300 0. 0. + 365 3.6400 0. 0. + 366 3.6500 0. 0. + 367 3.6600 0. 0. + 368 3.6700 0. 0. + 369 3.6800 0. 0. + 370 3.6900 0. 0. + 371 3.7000 0. 0. + 372 3.7100 0. 0. + 373 3.7200 0. 0. + 374 3.7300 0. 0. + 375 3.7400 0. 0. + 376 3.7500 0. 0. + 377 3.7600 0. 0. + 378 3.7700 0. 0. + 379 3.7800 0. 0. + 380 3.7900 0. 0. + 381 3.8000 0. 0. + 382 3.8100 0. 0. + 383 3.8200 0. 0. + 384 3.8300 0. 0. + 385 3.8400 0. 0. + 386 3.8500 0. 0. + 387 3.8600 0. 0. + 388 3.8700 0. 0. + 389 3.8800 0. 0. + 390 3.8900 0. 0. + 391 3.9000 0. 0. + 392 3.9100 0. 0. + 393 3.9200 0. 0. + 394 3.9300 0. 0. + 395 3.9400 0. 0. + 396 3.9500 0. 0. + 397 3.9600 0. 0. + 398 3.9700 0. 0. + 399 3.9800 0. 0. + 400 3.9900 0. 0. + 401 4.0000 0. 0. + 402 4.0100 0. 0. + 403 4.0200 0. 0. + 404 4.0300 0. 0. + 405 4.0400 0. 0. + 406 4.0500 0. 0. + 407 4.0600 0. 0. + 408 4.0700 0. 0. + 409 4.0800 0. 0. + 410 4.0900 0. 0. + 411 4.1000 0. 0. + 412 4.1100 0. 0. + 413 4.1200 0. 0. + 414 4.1300 0. 0. + 415 4.1400 0. 0. + 416 4.1500 0. 0. + 417 4.1600 0. 0. + 418 4.1700 0. 0. + 419 4.1800 0. 0. + 420 4.1900 0. 0. + 421 4.2000 0. 0. + 422 4.2100 0. 0. + 423 4.2200 0. 0. + 424 4.2300 0. 0. + 425 4.2400 0. 0. + 426 4.2500 0. 0. + 427 4.2600 0. 0. + 428 4.2700 0. 0. + 429 4.2800 0. 0. + 430 4.2900 0. 0. + 431 4.3000 0. 0. + 432 4.3100 0. 0. + 433 4.3200 0. 0. + 434 4.3300 0. 0. + 435 4.3400 0. 0. + 436 4.3500 0. 0. + 437 4.3600 0. 0. + 438 4.3700 0. 0. + 439 4.3800 0. 0. + 440 4.3900 0. 0. + 441 4.4000 0. 0. + 442 4.4100 0. 0. + 443 4.4200 0. 0. + 444 4.4300 0. 0. + 445 4.4400 0. 0. + 446 4.4500 0. 0. + 447 4.4600 0. 0. + 448 4.4700 0. 0. + 449 4.4800 0. 0. + 450 4.4900 0. 0. + 451 4.5000 0. 0. + 452 4.5100 0. 0. + 453 4.5200 0. 0. + 454 4.5300 0. 0. + 455 4.5400 0. 0. + 456 4.5500 0. 0. + 457 4.5600 0. 0. + 458 4.5700 0. 0. + 459 4.5800 0. 0. + 460 4.5900 0. 0. + 461 4.6000 0. 0. + 462 4.6100 0. 0. + 463 4.6200 0. 0. + 464 4.6300 0. 0. + 465 4.6400 0. 0. + 466 4.6500 0. 0. + 467 4.6600 0. 0. + 468 4.6700 0. 0. + 469 4.6800 0. 0. + 470 4.6900 0. 0. + 471 4.7000 0. 0. + 472 4.7100 0. 0. + 473 4.7200 0. 0. + 474 4.7300 0. 0. + 475 4.7400 0. 0. + 476 4.7500 0. 0. + 477 4.7600 0. 0. + 478 4.7700 0. 0. + 479 4.7800 0. 0. + 480 4.7900 0. 0. + 481 4.8000 0. 0. + 482 4.8100 0. 0. + 483 4.8200 0. 0. + 484 4.8300 0. 0. + 485 4.8400 0. 0. + 486 4.8500 0. 0. + 487 4.8600 0. 0. + 488 4.8700 0. 0. + 489 4.8800 0. 0. + 490 4.8900 0. 0. + 491 4.9000 0. 0. + 492 4.9100 0. 0. + 493 4.9200 0. 0. + 494 4.9300 0. 0. + 495 4.9400 0. 0. + 496 4.9500 0. 0. + 497 4.9600 0. 0. + 498 4.9700 0. 0. + 499 4.9800 0. 0. + 500 4.9900 0. 0. + 501 5.0000 0. 0. + 502 5.0100 0. 0. + 503 5.0200 0. 0. + 504 5.0300 0. 0. + 505 5.0400 0. 0. + 506 5.0500 0. 0. + 507 5.0600 0. 0. + 508 5.0700 0. 0. + 509 5.0800 0. 0. + 510 5.0900 0. 0. + 511 5.1000 0. 0. + 512 5.1100 0. 0. + 513 5.1200 0. 0. + 514 5.1300 0. 0. + 515 5.1400 0. 0. + 516 5.1500 0. 0. + 517 5.1600 0. 0. + 518 5.1700 0. 0. + 519 5.1800 0. 0. + 520 5.1900 0. 0. + 521 5.2000 0. 0. + 522 5.2100 0. 0. + 523 5.2200 0. 0. + 524 5.2300 0. 0. + 525 5.2400 0. 0. + 526 5.2500 0. 0. + 527 5.2600 0. 0. + 528 5.2700 0. 0. + 529 5.2800 0. 0. + 530 5.2900 0. 0. + 531 5.3000 0. 0. + 532 5.3100 0. 0. + 533 5.3200 0. 0. + 534 5.3300 0. 0. + 535 5.3400 0. 0. + 536 5.3500 0. 0. + 537 5.3600 0. 0. + 538 5.3700 0. 0. + 539 5.3800 0. 0. + 540 5.3900 0. 0. + 541 5.4000 0. 0. + 542 5.4100 0. 0. + 543 5.4200 0. 0. + 544 5.4300 0. 0. + 545 5.4400 0. 0. + 546 5.4500 0. 0. + 547 5.4600 0. 0. + 548 5.4700 0. 0. + 549 5.4800 0. 0. + 550 5.4900 0. 0. + 551 5.5000 0. 0. + 552 5.5100 0. 0. + 553 5.5200 0. 0. + 554 5.5300 0. 0. + 555 5.5400 0. 0. + 556 5.5500 0. 0. + 557 5.5600 0. 0. + 558 5.5700 0. 0. + 559 5.5800 0. 0. + 560 5.5900 0. 0. + 561 5.6000 0. 0. + 562 5.6100 0. 0. + 563 5.6200 0. 0. + 564 5.6300 0. 0. + 565 5.6400 0. 0. + 566 5.6500 0. 0. + 567 5.6600 0. 0. + 568 5.6700 0. 0. + 569 5.6800 0. 0. + 570 5.6900 0. 0. + 571 5.7000 0. 0. + 572 5.7100 0. 0. + 573 5.7200 0. 0. + 574 5.7300 0. 0. + 575 5.7400 0. 0. + 576 5.7500 0. 0. + 577 5.7600 0. 0. + 578 5.7700 0. 0. + 579 5.7800 0. 0. + 580 5.7900 0. 0. + 581 5.8000 0. 0. + 582 5.8100 0. 0. + 583 5.8200 0. 0. + 584 5.8300 0. 0. + 585 5.8400 0. 0. + 586 5.8500 0. 0. + 587 5.8600 0. 0. + 588 5.8700 0. 0. + 589 5.8800 0. 0. + 590 5.8900 0. 0. + 591 5.9000 0. 0. + 592 5.9100 0. 0. + 593 5.9200 0. 0. + 594 5.9300 0. 0. + 595 5.9400 0. 0. + 596 5.9500 0. 0. + 597 5.9600 0. 0. + 598 5.9700 0. 0. + 599 5.9800 0. 0. + 600 5.9900 0. 0. + 1 2.0252822697396E+00 3.7854215469311E-01 + 1 0.0000000000000E+00 3.5192408882889E-09 -2.8668541776633E-09 + 2 1.0000000000000E-02 2.5161059672502E-04 -4.6742789304119E-04 + 3 2.0000000000000E-02 9.9865782344347E-04 -1.8622047231846E-03 + 4 3.0000000000000E-02 2.2179236096426E-03 -4.1619227322192E-03 + 5 4.0000000000000E-02 3.8711612651851E-03 -7.3296100120759E-03 + 6 5.0000000000000E-02 5.9057637460695E-03 -1.1314286436412E-02 + 7 6.0000000000000E-02 8.2556855727425E-03 -1.6051730840245E-02 + 8 7.0000000000000E-02 1.0842604971830E-02 -2.1465448506370E-02 + 9 8.0000000000000E-02 1.3577309292921E-02 -2.7467825150430E-02 + 10 9.0000000000000E-02 1.6361283465063E-02 -3.3961450919219E-02 + 11 1.0000000000000E-01 1.9088478248363E-02 -4.0840595466017E-02 + 12 1.1000000000000E-01 2.1647232345852E-02 -4.7992812976321E-02 + 13 1.2000000000000E-01 2.3922320107120E-02 -5.5300654117640E-02 + 14 1.3000000000000E-01 2.5797094610452E-02 -6.2643460304570E-02 + 15 1.4000000000000E-01 2.7155694381738E-02 -6.9899214427270E-02 + 16 1.5000000000000E-01 2.7885280918135E-02 -7.6946421305477E-02 + 17 1.6000000000000E-01 2.7878273547995E-02 -8.3665990614220E-02 + 18 1.7000000000000E-01 2.7034547986082E-02 -8.9943094889061E-02 + 19 1.8000000000000E-01 2.5263565237922E-02 -9.5668975461157E-02 + 20 1.9000000000000E-01 2.2486398266713E-02 -1.0074266979300E-01 + 21 2.0000000000000E-01 1.8637625051628E-02 -1.0507263467707E-01 + 22 2.1000000000000E-01 1.3667058322520E-02 -1.0857824110936E-01 + 23 2.2000000000000E-01 7.5412843318327E-03 -1.1119111834026E-01 + 24 2.3000000000000E-01 2.4498549343067E-04 -1.1285632661494E-01 + 25 2.4000000000000E-01 -8.2179754522273E-03 -1.1353334041716E-01 + 26 2.5000000000000E-01 -1.7823728933435E-02 -1.1319682659510E-01 + 27 2.6000000000000E-01 -2.8527845453814E-02 -1.1183720453966E-01 + 28 2.7000000000000E-01 -4.0265067987568E-02 -1.0946097856956E-01 + 29 2.8000000000000E-01 -5.2949338079220E-02 -1.0609083581147E-01 + 30 2.9000000000000E-01 -6.6474119864881E-02 -1.0176550610738E-01 + 31 3.0000000000000E-01 -8.0713022149761E-02 -9.6539383789708E-02 + 32 3.1000000000000E-01 -9.5520714565304E-02 -9.0481914494603E-02 + 33 3.2000000000000E-01 -1.1073412974428E-01 -8.3676753488510E-02 + 34 3.3000000000000E-01 -1.2617393944864E-01 -7.6220705218914E-02 + 35 3.4000000000000E-01 -1.4164628871717E-01 -6.8222456921831E-02 + 36 3.5000000000000E-01 -1.5694476842033E-01 -5.9801122083963E-02 + 37 3.6000000000000E-01 -1.7185260316943E-01 -5.1084612325116E-02 + 38 3.7000000000000E-01 -1.8614502837245E-01 -4.2207858798197E-02 + 39 3.8000000000000E-01 -1.9959182740464E-01 -3.3310906464175E-02 + 40 3.9000000000000E-01 -2.1195999740719E-01 -2.4536906556018E-02 + 41 4.0000000000000E-01 -2.2301651017702E-01 -1.6030034170428E-02 + 42 4.1000000000000E-01 -2.3253113299460E-01 -7.9333591956754E-03 + 43 4.2000000000000E-01 -2.4027927307890E-01 -3.8669967844523E-04 + 44 4.3000000000000E-01 -2.4604480867715E-01 6.4755127614856E-03 + 45 4.4000000000000E-01 -2.4962286960361E-01 1.2526325752306E-02 + 46 4.5000000000000E-01 -2.5082253034214E-01 1.7648287804730E-02 + 47 4.6000000000000E-01 -2.4946937962016E-01 2.1735370032625E-02 + 48 4.7000000000000E-01 -2.4540793163989E-01 2.4694760320779E-02 + 49 4.8000000000000E-01 -2.3850384590186E-01 2.6448503771036E-02 + 50 4.9000000000000E-01 -2.2864592475575E-01 2.6934965092674E-02 + 51 5.0000000000000E-01 -2.1574786043820E-01 2.6110090779802E-02 + 52 5.1000000000000E-01 -1.9974970637430E-01 2.3948451411019E-02 + 53 5.2000000000000E-01 -1.8061905089160E-01 2.0444047183362E-02 + 54 5.3000000000000E-01 -1.5835187518027E-01 1.5610862818542E-02 + 55 5.4000000000000E-01 -1.3297308128446E-01 9.4831612162033E-03 + 56 5.5000000000000E-01 -1.0453668007707E-01 2.1155086344941E-03 + 57 5.6000000000000E-01 -7.3125633499344E-02 -6.4174722910978E-03 + 58 5.7000000000000E-01 -3.8851349783511E-02 -1.6021621770399E-02 + 59 5.8000000000000E-01 -1.8528348614068E-03 -2.6584030761473E-02 + 60 5.9000000000000E-01 3.7704492361853E-02 -3.7974090368325E-02 + 61 6.0000000000000E-01 7.9630308782664E-02 -5.0044791988226E-02 + 62 6.1000000000000E-01 1.2371120355456E-01 -6.2634264016313E-02 + 63 6.2000000000000E-01 1.6971278175900E-01 -7.5567527626511E-02 + 64 6.3000000000000E-01 2.1738203096579E-01 -8.8658451062811E-02 + 65 6.4000000000000E-01 2.6644992278769E-01 -1.0171187903543E-01 + 66 6.5000000000000E-01 3.1663421830214E-01 -1.1452591126194E-01 + 67 6.6000000000000E-01 3.6764244336473E-01 -1.2689430195984E-01 + 68 6.7000000000000E-01 4.1917499741257E-01 -1.3860895021608E-01 + 69 6.8000000000000E-01 4.7092835738675E-01 -1.4946244965819E-01 + 70 6.9000000000000E-01 5.2259833691915E-01 -1.5925066475370E-01 + 71 7.0000000000000E-01 5.7388335995299E-01 -1.6777530038706E-01 + 72 7.1000000000000E-01 6.2448770751468E-01 -1.7484643111791E-01 + 73 7.2000000000000E-01 6.7412469643592E-01 -1.8028495671897E-01 + 74 7.3000000000000E-01 7.2251974944185E-01 -1.8392495122600E-01 + 75 7.4000000000000E-01 7.6941331716943E-01 -1.8561587380156E-01 + 76 7.5000000000000E-01 8.1456361434796E-01 -1.8522461120910E-01 + 77 7.6000000000000E-01 8.5774913454328E-01 -1.8263732359661E-01 + 78 7.7000000000000E-01 8.9877091051284E-01 -1.7776106757937E-01 + 79 7.8000000000000E-01 9.3745449031090E-01 -1.7052517326207E-01 + 80 7.9000000000000E-01 9.7365160278241E-01 -1.6088235481979E-01 + 81 8.0000000000000E-01 1.0072414899502E+00 -1.4880953752987E-01 + 82 8.1000000000000E-01 1.0381318879833E+00 -1.3430838767091E-01 + 83 8.2000000000000E-01 1.0662596428847E+00 -1.1740553543922E-01 + 84 8.3000000000000E-01 1.0915909516950E+00 -9.8152484928225E-02 + 85 8.4000000000000E-01 1.1141212248228E+00 -7.6625209225166E-02 + 86 8.5000000000000E-01 1.1338745700094E+00 -5.2923432749532E-02 + 87 8.6000000000000E-01 1.1509029033702E+00 -2.7169607037882E-02 + 88 8.7000000000000E-01 1.1652846978415E+00 4.9240978352701E-04 + 89 8.8000000000000E-01 1.1771233841593E+00 2.9898955655427E-02 + 90 8.9000000000000E-01 1.1865454241252E+00 6.0868431394778E-02 + 91 9.0000000000000E-01 1.1936980803236E+00 9.3203410083351E-02 + 92 9.1000000000000E-01 1.1987469105784E+00 1.2669296411172E-01 + 93 9.2000000000000E-01 1.2018730192313E+00 1.6111518189483E-01 + 94 9.3000000000000E-01 1.2032701007194E+00 1.9623984354821E-01 + 95 9.4000000000000E-01 1.2031413139028E+00 2.3183122245750E-01 + 96 9.5000000000000E-01 1.2016960280798E+00 2.6765097772194E-01 + 97 9.6000000000000E-01 1.1991464836076E+00 3.0346110093278E-01 + 98 9.7000000000000E-01 1.1957044114868E+00 3.3902687968433E-01 + 99 9.8000000000000E-01 1.1915776571416E+00 3.7411983962539E-01 + 100 9.9000000000000E-01 1.1869668539259E+00 4.0852062675395E-01 + 101 1.0000000000000E+00 1.1820621915934E+00 4.4202179204497E-01 + 102 1.0100000000000E+00 1.1770403240965E+00 4.7443044137597E-01 + 103 1.0200000000000E+00 1.1720614596156E+00 5.0557071507614E-01 + 104 1.0300000000000E+00 1.1672666736999E+00 5.3528606325410E-01 + 105 1.0400000000000E+00 1.1627754838283E+00 5.6344128533888E-01 + 106 1.0500000000000E+00 1.1586837206161E+00 5.8992430497694E-01 + 107 1.0600000000000E+00 1.1550617273218E+00 6.1464765452994E-01 + 108 1.0700000000000E+00 1.1519529153104E+00 6.3754964687542E-01 + 109 1.0800000000000E+00 1.1493726987224E+00 6.5859521599882E-01 + 110 1.0900000000000E+00 1.1473078268723E+00 6.7777641191021E-01 + 111 1.1000000000000E+00 1.1457161278768E+00 6.9511253970310E-01 + 112 1.1100000000000E+00 1.1445266717827E+00 7.1064993701819E-01 + 113 1.1200000000000E+00 1.1436403560726E+00 7.2446138874244E-01 + 114 1.1300000000000E+00 1.1429309109495E+00 7.3664518240423E-01 + 115 1.1400000000000E+00 1.1422463163121E+00 7.4732381235056E-01 + 116 1.1500000000000E+00 1.1414106168820E+00 7.5664234537420E-01 + 117 1.1600000000000E+00 1.1402261166304E+00 7.6476646491303E-01 + 118 1.1700000000000E+00 1.1384759285133E+00 7.7188021523975E-01 + 119 1.1800000000000E+00 1.1359268506497E+00 7.7818347112162E-01 + 120 1.1900000000000E+00 1.1323325355253E+00 7.8388916221289E-01 + 121 1.2000000000000E+00 1.1274369146150E+00 7.8922028490413E-01 + 122 1.2100000000000E+00 1.1209778370947E+00 7.9440673742095E-01 + 123 1.2200000000000E+00 1.1126908780392E+00 7.9968201663914E-01 + 124 1.2300000000000E+00 1.1023132687962E+00 8.0527981727843E-01 + 125 1.2400000000000E+00 1.0895879000655E+00 8.1143057586462E-01 + 126 1.2500000000000E+00 1.0742673466654E+00 8.1835800305473E-01 + 127 1.2600000000000E+00 1.0561178620466E+00 8.2627564859578E-01 + 128 1.2700000000000E+00 1.0349232903340E+00 8.3538354331968E-01 + 129 1.2800000000000E+00 1.0104888440525E+00 8.4586496215210E-01 + 130 1.2900000000000E+00 9.8264469671770E-01 8.5788335114711E-01 + 131 1.3000000000000E+00 9.5124934115110E-01 8.7157946003532E-01 + 132 1.3100000000000E+00 9.1619266668700E-01 8.8706871972600E-01 + 133 1.3200000000000E+00 8.7739871134190E-01 9.0443890165578E-01 + 134 1.3300000000000E+00 8.3482804852123E-01 9.2374809282378E-01 + 135 1.3400000000000E+00 7.8847977186185E-01 9.4502301686964E-01 + 136 1.3500000000000E+00 7.3839304633482E-01 9.6825772764703E-01 + 137 1.3600000000000E+00 6.8464819868518E-01 9.9341269748984E-01 + 138 1.3700000000000E+00 6.2736732565523E-01 1.0204143177659E+00 + 139 1.3800000000000E+00 5.6671440408884E-01 1.0491548244817E+00 + 140 1.3900000000000E+00 5.0289489295456E-01 1.0794926566356E+00 + 141 1.4000000000000E+00 4.3615482340259E-01 1.1112532498379E+00 + 142 1.4100000000000E+00 3.6677937922619E-01 1.1442302624066E+00 + 143 1.4200000000000E+00 2.9509097631907E-01 1.1781872258599E+00 + 144 1.4300000000000E+00 2.2144685593879E-01 1.2128596064668E+00 + 145 1.4400000000000E+00 1.4623621268450E-01 1.2479572593542E+00 + 146 1.4500000000000E+00 6.9876883965658E-02 1.2831672517157E+00 + 147 1.4600000000000E+00 -7.1883665937190E-03 1.3181570268917E+00 + 148 1.4700000000000E+00 -8.4495934109491E-02 1.3525778766616E+00 + 149 1.4800000000000E+00 -1.6156578314722E-01 1.3860686849806E+00 + 150 1.4900000000000E+00 -2.3790613716809E-01 1.4182599026983E+00 + 151 1.5000000000000E+00 -3.1301839579664E-01 1.4487777095409E+00 + 152 1.5100000000000E+00 -3.8640222568218E-01 1.4772483168947E+00 + 153 1.5200000000000E+00 -4.5756076802719E-01 1.5033023626933E+00 + 154 1.5300000000000E+00 -5.2600590381452E-01 1.5265793480492E+00 + 155 1.5400000000000E+00 -5.9126351641844E-01 1.5467320641935E+00 + 156 1.5500000000000E+00 -6.5287869063882E-01 1.5634309578062E+00 + 157 1.5600000000000E+00 -7.1042078727687E-01 1.5763683829572E+00 + 158 1.5700000000000E+00 -7.6348833317442E-01 1.5852626886273E+00 + 159 1.5800000000000E+00 -8.1171366816437E-01 1.5898620921410E+00 + 160 1.5900000000000E+00 -8.5476729261153E-01 1.5899482907999E+00 + 161 1.6000000000000E+00 -8.9236186214186E-01 1.5853397665502E+00 + 162 1.6100000000000E+00 -9.2425577973096E-01 1.5758947416050E+00 + 163 1.6200000000000E+00 -9.5025633951191E-01 1.5615137465584E+00 + 164 1.6300000000000E+00 -9.7022238142921E-01 1.5421417666258E+00 + 165 1.6400000000000E+00 -9.8406642112848E-01 1.5177699361599E+00 + 166 1.6500000000000E+00 -9.9175622522692E-01 1.4884367565244E+00 + 167 1.6600000000000E+00 -9.9331580822361E-01 1.4542288176325E+00 + 168 1.6700000000000E+00 -9.8882583376341E-01 1.4152810089759E+00 + 169 1.6800000000000E+00 -9.7842340966356E-01 1.3717762116816E+00 + 170 1.6900000000000E+00 -9.6230127297789E-01 1.3239444689856E+00 + 171 1.7000000000000E+00 -9.4070636832662E-01 1.2720616384397E+00 + 172 1.7100000000000E+00 -9.1393782967989E-01 1.2164475350868E+00 + 173 1.7200000000000E+00 -8.8234438266779E-01 1.1574635807000E+00 + 174 1.7300000000000E+00 -8.4632119121563E-01 1.0955099798940E+00 + 175 1.7400000000000E+00 -8.0630617879186E-01 1.0310224494310E+00 + 176 1.7500000000000E+00 -7.6277586073492E-01 9.6446853228353E-01 + 177 1.7600000000000E+00 -7.1624072989748E-01 8.9634353291696E-01 + 178 1.7700000000000E+00 -6.6724024318180E-01 8.2716611476997E-01 + 179 1.7800000000000E+00 -6.1633746133891E-01 7.5747360497771E-01 + 180 1.7900000000000E+00 -5.6411339861788E-01 6.8781705494319E-01 + 181 1.8000000000000E+00 -5.1116114245251E-01 6.1875610847059E-01 + 182 1.8100000000000E+00 -4.5807980624056E-01 5.5085373138829E-01 + 183 1.8200000000000E+00 -4.0546837678240E-01 4.8467085128566E-01 + 184 1.8300000000000E+00 -3.5391955582456E-01 4.2076102485343E-01 + 185 1.8400000000000E+00 -3.0401353002782E-01 3.5966487612878E-01 + 186 1.8500000000000E+00 -2.5631187752900E-01 3.0190461594386E-01 + 187 1.8600000000000E+00 -2.1135381630777E-01 2.4798167459996E-01 + 188 1.8700000000000E+00 -1.6965049781578E-01 1.9837131518899E-01 + 189 1.8800000000000E+00 -1.3167245017664E-01 1.5350792134018E-01 + 190 1.8900000000000E+00 -9.7849074849526E-02 1.1378786022816E-01 + 191 1.9000000000000E+00 -6.8564234590286E-02 7.9565667633433E-02 + 192 1.9100000000000E+00 -4.4152243907078E-02 5.1150583225683E-02 + 193 1.9200000000000E+00 -2.4902826628267E-02 2.8813302764518E-02 + 194 1.9300000000000E+00 -1.0976118325706E-02 1.2688635723805E-02 + 195 1.9400000000000E+00 -2.7485814407191E-03 3.1758001975503E-03 + 196 1.9500000000000E+00 2.6288052426677E-05 -3.0443901718058E-05 + 197 1.9600000000000E+00 4.8351689568342E-05 -5.5848044296363E-05 + 198 1.9700 -0. 0. + 199 1.9800 0. -0. + 200 1.9900 0. -0. + 201 2.0000 0. 0. + 202 2.0100 0. 0. + 203 2.0200 0. 0. + 204 2.0300 0. 0. + 205 2.0400 0. 0. + 206 2.0500 0. 0. + 207 2.0600 0. 0. + 208 2.0700 0. 0. + 209 2.0800 0. 0. + 210 2.0900 0. 0. + 211 2.1000 0. 0. + 212 2.1100 0. 0. + 213 2.1200 0. 0. + 214 2.1300 0. 0. + 215 2.1400 0. 0. + 216 2.1500 0. 0. + 217 2.1600 0. 0. + 218 2.1700 0. 0. + 219 2.1800 0. 0. + 220 2.1900 0. 0. + 221 2.2000 0. 0. + 222 2.2100 0. 0. + 223 2.2200 0. 0. + 224 2.2300 0. 0. + 225 2.2400 0. 0. + 226 2.2500 0. 0. + 227 2.2600 0. 0. + 228 2.2700 0. 0. + 229 2.2800 0. 0. + 230 2.2900 0. 0. + 231 2.3000 0. 0. + 232 2.3100 0. 0. + 233 2.3200 0. 0. + 234 2.3300 0. 0. + 235 2.3400 0. 0. + 236 2.3500 0. 0. + 237 2.3600 0. 0. + 238 2.3700 0. 0. + 239 2.3800 0. 0. + 240 2.3900 0. 0. + 241 2.4000 0. 0. + 242 2.4100 0. 0. + 243 2.4200 0. 0. + 244 2.4300 0. 0. + 245 2.4400 0. 0. + 246 2.4500 0. 0. + 247 2.4600 0. 0. + 248 2.4700 0. 0. + 249 2.4800 0. 0. + 250 2.4900 0. 0. + 251 2.5000 0. 0. + 252 2.5100 0. 0. + 253 2.5200 0. 0. + 254 2.5300 0. 0. + 255 2.5400 0. 0. + 256 2.5500 0. 0. + 257 2.5600 0. 0. + 258 2.5700 0. 0. + 259 2.5800 0. 0. + 260 2.5900 0. 0. + 261 2.6000 0. 0. + 262 2.6100 0. 0. + 263 2.6200 0. 0. + 264 2.6300 0. 0. + 265 2.6400 0. 0. + 266 2.6500 0. 0. + 267 2.6600 0. 0. + 268 2.6700 0. 0. + 269 2.6800 0. 0. + 270 2.6900 0. 0. + 271 2.7000 0. 0. + 272 2.7100 0. 0. + 273 2.7200 0. 0. + 274 2.7300 0. 0. + 275 2.7400 0. 0. + 276 2.7500 0. 0. + 277 2.7600 0. 0. + 278 2.7700 0. 0. + 279 2.7800 0. 0. + 280 2.7900 0. 0. + 281 2.8000 0. 0. + 282 2.8100 0. 0. + 283 2.8200 0. 0. + 284 2.8300 0. 0. + 285 2.8400 0. 0. + 286 2.8500 0. 0. + 287 2.8600 0. 0. + 288 2.8700 0. 0. + 289 2.8800 0. 0. + 290 2.8900 0. 0. + 291 2.9000 0. 0. + 292 2.9100 0. 0. + 293 2.9200 0. 0. + 294 2.9300 0. 0. + 295 2.9400 0. 0. + 296 2.9500 0. 0. + 297 2.9600 0. 0. + 298 2.9700 0. 0. + 299 2.9800 0. 0. + 300 2.9900 0. 0. + 301 3.0000 0. 0. + 302 3.0100 0. 0. + 303 3.0200 0. 0. + 304 3.0300 0. 0. + 305 3.0400 0. 0. + 306 3.0500 0. 0. + 307 3.0600 0. 0. + 308 3.0700 0. 0. + 309 3.0800 0. 0. + 310 3.0900 0. 0. + 311 3.1000 0. 0. + 312 3.1100 0. 0. + 313 3.1200 0. 0. + 314 3.1300 0. 0. + 315 3.1400 0. 0. + 316 3.1500 0. 0. + 317 3.1600 0. 0. + 318 3.1700 0. 0. + 319 3.1800 0. 0. + 320 3.1900 0. 0. + 321 3.2000 0. 0. + 322 3.2100 0. 0. + 323 3.2200 0. 0. + 324 3.2300 0. 0. + 325 3.2400 0. 0. + 326 3.2500 0. 0. + 327 3.2600 0. 0. + 328 3.2700 0. 0. + 329 3.2800 0. 0. + 330 3.2900 0. 0. + 331 3.3000 0. 0. + 332 3.3100 0. 0. + 333 3.3200 0. 0. + 334 3.3300 0. 0. + 335 3.3400 0. 0. + 336 3.3500 0. 0. + 337 3.3600 0. 0. + 338 3.3700 0. 0. + 339 3.3800 0. 0. + 340 3.3900 0. 0. + 341 3.4000 0. 0. + 342 3.4100 0. 0. + 343 3.4200 0. 0. + 344 3.4300 0. 0. + 345 3.4400 0. 0. + 346 3.4500 0. 0. + 347 3.4600 0. 0. + 348 3.4700 0. 0. + 349 3.4800 0. 0. + 350 3.4900 0. 0. + 351 3.5000 0. 0. + 352 3.5100 0. 0. + 353 3.5200 0. 0. + 354 3.5300 0. 0. + 355 3.5400 0. 0. + 356 3.5500 0. 0. + 357 3.5600 0. 0. + 358 3.5700 0. 0. + 359 3.5800 0. 0. + 360 3.5900 0. 0. + 361 3.6000 0. 0. + 362 3.6100 0. 0. + 363 3.6200 0. 0. + 364 3.6300 0. 0. + 365 3.6400 0. 0. + 366 3.6500 0. 0. + 367 3.6600 0. 0. + 368 3.6700 0. 0. + 369 3.6800 0. 0. + 370 3.6900 0. 0. + 371 3.7000 0. 0. + 372 3.7100 0. 0. + 373 3.7200 0. 0. + 374 3.7300 0. 0. + 375 3.7400 0. 0. + 376 3.7500 0. 0. + 377 3.7600 0. 0. + 378 3.7700 0. 0. + 379 3.7800 0. 0. + 380 3.7900 0. 0. + 381 3.8000 0. 0. + 382 3.8100 0. 0. + 383 3.8200 0. 0. + 384 3.8300 0. 0. + 385 3.8400 0. 0. + 386 3.8500 0. 0. + 387 3.8600 0. 0. + 388 3.8700 0. 0. + 389 3.8800 0. 0. + 390 3.8900 0. 0. + 391 3.9000 0. 0. + 392 3.9100 0. 0. + 393 3.9200 0. 0. + 394 3.9300 0. 0. + 395 3.9400 0. 0. + 396 3.9500 0. 0. + 397 3.9600 0. 0. + 398 3.9700 0. 0. + 399 3.9800 0. 0. + 400 3.9900 0. 0. + 401 4.0000 0. 0. + 402 4.0100 0. 0. + 403 4.0200 0. 0. + 404 4.0300 0. 0. + 405 4.0400 0. 0. + 406 4.0500 0. 0. + 407 4.0600 0. 0. + 408 4.0700 0. 0. + 409 4.0800 0. 0. + 410 4.0900 0. 0. + 411 4.1000 0. 0. + 412 4.1100 0. 0. + 413 4.1200 0. 0. + 414 4.1300 0. 0. + 415 4.1400 0. 0. + 416 4.1500 0. 0. + 417 4.1600 0. 0. + 418 4.1700 0. 0. + 419 4.1800 0. 0. + 420 4.1900 0. 0. + 421 4.2000 0. 0. + 422 4.2100 0. 0. + 423 4.2200 0. 0. + 424 4.2300 0. 0. + 425 4.2400 0. 0. + 426 4.2500 0. 0. + 427 4.2600 0. 0. + 428 4.2700 0. 0. + 429 4.2800 0. 0. + 430 4.2900 0. 0. + 431 4.3000 0. 0. + 432 4.3100 0. 0. + 433 4.3200 0. 0. + 434 4.3300 0. 0. + 435 4.3400 0. 0. + 436 4.3500 0. 0. + 437 4.3600 0. 0. + 438 4.3700 0. 0. + 439 4.3800 0. 0. + 440 4.3900 0. 0. + 441 4.4000 0. 0. + 442 4.4100 0. 0. + 443 4.4200 0. 0. + 444 4.4300 0. 0. + 445 4.4400 0. 0. + 446 4.4500 0. 0. + 447 4.4600 0. 0. + 448 4.4700 0. 0. + 449 4.4800 0. 0. + 450 4.4900 0. 0. + 451 4.5000 0. 0. + 452 4.5100 0. 0. + 453 4.5200 0. 0. + 454 4.5300 0. 0. + 455 4.5400 0. 0. + 456 4.5500 0. 0. + 457 4.5600 0. 0. + 458 4.5700 0. 0. + 459 4.5800 0. 0. + 460 4.5900 0. 0. + 461 4.6000 0. 0. + 462 4.6100 0. 0. + 463 4.6200 0. 0. + 464 4.6300 0. 0. + 465 4.6400 0. 0. + 466 4.6500 0. 0. + 467 4.6600 0. 0. + 468 4.6700 0. 0. + 469 4.6800 0. 0. + 470 4.6900 0. 0. + 471 4.7000 0. 0. + 472 4.7100 0. 0. + 473 4.7200 0. 0. + 474 4.7300 0. 0. + 475 4.7400 0. 0. + 476 4.7500 0. 0. + 477 4.7600 0. 0. + 478 4.7700 0. 0. + 479 4.7800 0. 0. + 480 4.7900 0. 0. + 481 4.8000 0. 0. + 482 4.8100 0. 0. + 483 4.8200 0. 0. + 484 4.8300 0. 0. + 485 4.8400 0. 0. + 486 4.8500 0. 0. + 487 4.8600 0. 0. + 488 4.8700 0. 0. + 489 4.8800 0. 0. + 490 4.8900 0. 0. + 491 4.9000 0. 0. + 492 4.9100 0. 0. + 493 4.9200 0. 0. + 494 4.9300 0. 0. + 495 4.9400 0. 0. + 496 4.9500 0. 0. + 497 4.9600 0. 0. + 498 4.9700 0. 0. + 499 4.9800 0. 0. + 500 4.9900 0. 0. + 501 5.0000 0. 0. + 502 5.0100 0. 0. + 503 5.0200 0. 0. + 504 5.0300 0. 0. + 505 5.0400 0. 0. + 506 5.0500 0. 0. + 507 5.0600 0. 0. + 508 5.0700 0. 0. + 509 5.0800 0. 0. + 510 5.0900 0. 0. + 511 5.1000 0. 0. + 512 5.1100 0. 0. + 513 5.1200 0. 0. + 514 5.1300 0. 0. + 515 5.1400 0. 0. + 516 5.1500 0. 0. + 517 5.1600 0. 0. + 518 5.1700 0. 0. + 519 5.1800 0. 0. + 520 5.1900 0. 0. + 521 5.2000 0. 0. + 522 5.2100 0. 0. + 523 5.2200 0. 0. + 524 5.2300 0. 0. + 525 5.2400 0. 0. + 526 5.2500 0. 0. + 527 5.2600 0. 0. + 528 5.2700 0. 0. + 529 5.2800 0. 0. + 530 5.2900 0. 0. + 531 5.3000 0. 0. + 532 5.3100 0. 0. + 533 5.3200 0. 0. + 534 5.3300 0. 0. + 535 5.3400 0. 0. + 536 5.3500 0. 0. + 537 5.3600 0. 0. + 538 5.3700 0. 0. + 539 5.3800 0. 0. + 540 5.3900 0. 0. + 541 5.4000 0. 0. + 542 5.4100 0. 0. + 543 5.4200 0. 0. + 544 5.4300 0. 0. + 545 5.4400 0. 0. + 546 5.4500 0. 0. + 547 5.4600 0. 0. + 548 5.4700 0. 0. + 549 5.4800 0. 0. + 550 5.4900 0. 0. + 551 5.5000 0. 0. + 552 5.5100 0. 0. + 553 5.5200 0. 0. + 554 5.5300 0. 0. + 555 5.5400 0. 0. + 556 5.5500 0. 0. + 557 5.5600 0. 0. + 558 5.5700 0. 0. + 559 5.5800 0. 0. + 560 5.5900 0. 0. + 561 5.6000 0. 0. + 562 5.6100 0. 0. + 563 5.6200 0. 0. + 564 5.6300 0. 0. + 565 5.6400 0. 0. + 566 5.6500 0. 0. + 567 5.6600 0. 0. + 568 5.6700 0. 0. + 569 5.6800 0. 0. + 570 5.6900 0. 0. + 571 5.7000 0. 0. + 572 5.7100 0. 0. + 573 5.7200 0. 0. + 574 5.7300 0. 0. + 575 5.7400 0. 0. + 576 5.7500 0. 0. + 577 5.7600 0. 0. + 578 5.7700 0. 0. + 579 5.7800 0. 0. + 580 5.7900 0. 0. + 581 5.8000 0. 0. + 582 5.8100 0. 0. + 583 5.8200 0. 0. + 584 5.8300 0. 0. + 585 5.8400 0. 0. + 586 5.8500 0. 0. + 587 5.8600 0. 0. + 588 5.8700 0. 0. + 589 5.8800 0. 0. + 590 5.8900 0. 0. + 591 5.9000 0. 0. + 592 5.9100 0. 0. + 593 5.9200 0. 0. + 594 5.9300 0. 0. + 595 5.9400 0. 0. + 596 5.9500 0. 0. + 597 5.9600 0. 0. + 598 5.9700 0. 0. + 599 5.9800 0. 0. + 600 5.9900 0. 0. + 2 -2.9159785658699E+00 -4.7574726963570E-01 + 1 0.0000000000000E+00 -4.4872391479628E-10 9.6014946839550E-10 + 2 1.0000000000000E-02 1.0682717887143E-05 -2.2508883245372E-06 + 3 2.0000000000000E-02 8.5470324349640E-05 -1.8106420365262E-05 + 4 3.0000000000000E-02 2.8850934902043E-04 -6.1664894798847E-05 + 5 4.0000000000000E-02 6.8402372543789E-04 -1.4799837788900E-04 + 6 5.0000000000000E-02 1.3363389144656E-03 -2.9360598172708E-04 + 7 6.0000000000000E-02 2.3098888590982E-03 -5.1682751244006E-04 + 8 7.0000000000000E-02 3.6692005846669E-03 -8.3820542699521E-04 + 9 8.0000000000000E-02 5.4788517071846E-03 -1.2807839973802E-03 + 10 9.0000000000000E-02 7.8033966592136E-03 -1.8703357506983E-03 + 11 1.0000000000000E-01 1.0707258078248E-02 -2.6355066141221E-03 + 12 1.1000000000000E-01 1.4254580516384E-02 -3.6078727215827E-03 + 13 1.2000000000000E-01 1.8509044410200E-02 -4.8219035095550E-03 + 14 1.3000000000000E-01 2.3533639083049E-02 -6.3148275139877E-03 + 15 1.4000000000000E-01 2.9390394424398E-02 -8.1263991497761E-03 + 16 1.5000000000000E-01 3.6140071787705E-02 -1.0298566676615E-02 + 17 1.6000000000000E-01 4.3841815554186E-02 -1.2875043498086E-02 + 18 1.7000000000000E-01 5.2552767709534E-02 -1.5900786871904E-02 + 19 1.8000000000000E-01 6.2327648658168E-02 -1.9421389994648E-02 + 20 1.9000000000000E-01 7.3218308340415E-02 -2.3482395232850E-02 + 21 2.0000000000000E-01 8.5273252506636E-02 -2.8128537971474E-02 + 22 2.1000000000000E-01 9.8537149725299E-02 -3.3402932111847E-02 + 23 2.2000000000000E-01 1.1305032534601E-01 -3.9346209645917E-02 + 24 2.3000000000000E-01 1.2884824919162E-01 -4.5995627937066E-02 + 25 2.4000000000000E-01 1.4596102420559E-01 -5.3384159327851E-02 + 26 2.5000000000000E-01 1.6441288362207E-01 -6.1539578452525E-02 + 27 2.6000000000000E-01 1.8422170445049E-01 -7.0483563142115E-02 + 28 2.7000000000000E-01 2.0539854516705E-01 -8.0230825060527E-02 + 29 2.8000000000000E-01 2.2794721547990E-01 -9.0788286194397E-02 + 30 2.9000000000000E-01 2.5186388588100E-01 -1.0215431703419E-01 + 31 3.0000000000000E-01 2.7713674441562E-01 -1.1431805173012E-01 + 32 3.1000000000000E-01 3.0374570769383E-01 -1.2725879469015E-01 + 33 3.2000000000000E-01 3.3166219264028E-01 -1.4094553201726E-01 + 34 3.3000000000000E-01 3.6084895483655E-01 -1.5533655987490E-01 + 35 3.4000000000000E-01 3.9125999856193E-01 -1.7037924033839E-01 + 36 3.5000000000000E-01 4.2284056279454E-01 -1.8600989356100E-01 + 37 3.6000000000000E-01 4.5552718650548E-01 -2.0215383317774E-01 + 38 3.7000000000000E-01 4.8924785557946E-01 -2.1872554981862E-01 + 39 3.8000000000000E-01 5.2392223263775E-01 -2.3562904543471E-01 + 40 3.9000000000000E-01 5.5946196994130E-01 -2.5275831888871E-01 + 41 4.0000000000000E-01 5.9577110442784E-01 -2.6999800096087E-01 + 42 4.1000000000000E-01 6.3274653280433E-01 -2.8722413460625E-01 + 43 4.2000000000000E-01 6.7027856349201E-01 -3.0430509400699E-01 + 44 4.3000000000000E-01 7.0825154112311E-01 -3.2110263373006E-01 + 45 4.4000000000000E-01 7.4654453823189E-01 -3.3747305716063E-01 + 46 4.5000000000000E-01 7.8503210778600E-01 -3.5326849137111E-01 + 47 4.6000000000000E-01 8.2358508928167E-01 -3.6833825373666E-01 + 48 4.7000000000000E-01 8.6207146029299E-01 -3.8253029395112E-01 + 49 4.8000000000000E-01 9.0035722463604E-01 -3.9569269366181E-01 + 50 4.9000000000000E-01 9.3830732769326E-01 -4.0767520475107E-01 + 51 5.0000000000000E-01 9.7578658895445E-01 -4.1833080636958E-01 + 52 5.1000000000000E-01 1.0126606414760E+00 -4.2751726018844E-01 + 53 5.2000000000000E-01 1.0487968677457E+00 -4.3509864299751E-01 + 54 5.3000000000000E-01 1.0840653213739E+00 -4.4094683574517E-01 + 55 5.4000000000000E-01 1.1183396241103E+00 -4.4494294839501E-01 + 56 5.5000000000000E-01 1.1514978279193E+00 -4.4697866056623E-01 + 57 5.6000000000000E-01 1.1834232322180E+00 -4.4695745882341E-01 + 58 5.7000000000000E-01 1.2140051469073E+00 -4.4479575267651E-01 + 59 5.8000000000000E-01 1.2431395924779E+00 -4.4042385283029E-01 + 60 5.9000000000000E-01 1.2707299292624E+00 -4.3378679696454E-01 + 61 6.0000000000000E-01 1.2966874088059E+00 -4.2484501030924E-01 + 62 6.1000000000000E-01 1.3209316413387E+00 -4.1357479047603E-01 + 63 6.2000000000000E-01 1.3433909744367E+00 -3.9996860838767E-01 + 64 6.3000000000000E-01 1.3640027791340E+00 -3.8403521967792E-01 + 65 6.4000000000000E-01 1.3827136409918E+00 -3.6579958357827E-01 + 66 6.5000000000000E-01 1.3994794549105E+00 -3.4530258902843E-01 + 67 6.6000000000000E-01 1.4142654237775E+00 -3.2260059050257E-01 + 68 6.7000000000000E-01 1.4270459623555E+00 -2.9776475879429E-01 + 69 6.8000000000000E-01 1.4378045091142E+00 -2.7088025470740E-01 + 70 6.9000000000000E-01 1.4465332499719E+00 -2.4204523621684E-01 + 71 7.0000000000000E-01 1.4532327591292E+00 -2.1136971215420E-01 + 72 7.1000000000000E-01 1.4579115633157E+00 -1.7897425779603E-01 + 73 7.2000000000000E-01 1.4605856368297E+00 -1.4498860985540E-01 + 74 7.3000000000000E-01 1.4612778357006E+00 -1.0955016026275E-01 + 75 7.4000000000000E-01 1.4600172801377E+00 -7.2802369740434E-02 + 76 7.5000000000000E-01 1.4568386951303E+00 -3.4893123500723E-02 + 77 7.6000000000000E-01 1.4517817196239E+00 4.0269475958820E-03 + 78 7.7000000000000E-01 1.4448901951030E+00 4.3806156412207E-02 + 79 7.8000000000000E-01 1.4362114446591E+00 8.4293435103456E-02 + 80 7.9000000000000E-01 1.4257955537057E+00 1.2533997258568E-01 + 81 8.0000000000000E-01 1.4136946634194E+00 1.6680079000165E-01 + 82 8.1000000000000E-01 1.3999622877373E+00 2.0853623103770E-01 + 83 8.2000000000000E-01 1.3846526643242E+00 2.5041334505203E-01 + 84 8.3000000000000E-01 1.3678201493568E+00 2.9230714242255E-01 + 85 8.4000000000000E-01 1.3495186652421E+00 3.3410170329079E-01 + 86 8.5000000000000E-01 1.3298012095236E+00 3.7569112294668E-01 + 87 8.6000000000000E-01 1.3087194322345E+00 4.1698027943857E-01 + 88 8.7000000000000E-01 1.2863232878409E+00 4.5788541157325E-01 + 89 8.8000000000000E-01 1.2626607667077E+00 4.9833449825484E-01 + 90 8.9000000000000E-01 1.2377777097230E+00 5.3826743306201E-01 + 91 9.0000000000000E-01 1.2117177083555E+00 5.7763599103665E-01 + 92 9.1000000000000E-01 1.1845220910133E+00 6.1640358781063E-01 + 93 9.2000000000000E-01 1.1562299951464E+00 6.5454483438503E-01 + 94 9.3000000000000E-01 1.1268785230980E+00 6.9204489405024E-01 + 95 9.4000000000000E-01 1.0965029783009E+00 7.2889865104981E-01 + 96 9.5000000000000E-01 1.0651371770388E+00 7.6510970359853E-01 + 97 9.6000000000000E-01 1.0328138296826E+00 8.0068919671998E-01 + 98 9.7000000000000E-01 9.9956498407940E-01 8.3565451302663E-01 + 99 9.8000000000000E-01 9.6542252264209E-01 8.7002784198660E-01 + 100 9.9000000000000E-01 9.3041870367797E-01 9.0383465036315E-01 + 101 1.0000000000000E+00 8.9458673661607E-01 9.3710207834566E-01 + 102 1.0100000000000E+00 8.5796138006887E-01 9.6985728737814E-01 + 103 1.0200000000000E+00 8.2057955109895E-01 1.0021257868126E+00 + 104 1.0300000000000E+00 7.8248093366990E-01 1.0339297672435E+00 + 105 1.0400000000000E+00 7.4370857405021E-01 1.0652864687040E+00 + 106 1.0500000000000E+00 7.0430945091315E-01 1.0962066118140E+00 + 107 1.0600000000000E+00 6.6433500803951E-01 1.1266929194578E+00 + 108 1.0700000000000E+00 6.2384163788042E-01 1.1567387556417E+00 + 109 1.0800000000000E+00 5.8289110477564E-01 1.1863269068435E+00 + 110 1.0900000000000E+00 5.4155089733791E-01 1.2154285294316E+00 + 111 1.1000000000000E+00 4.9989450040305E-01 1.2440022846239E+00 + 112 1.1100000000000E+00 4.5800157799388E-01 1.2719936799956E+00 + 113 1.1200000000000E+00 4.1595805994147E-01 1.2993346337718E+00 + 114 1.1300000000000E+00 3.7385612613639E-01 1.3259432750744E+00 + 115 1.1400000000000E+00 3.3179408382199E-01 1.3517239899972E+00 + 116 1.1500000000000E+00 2.8987613488055E-01 1.3765677198767E+00 + 117 1.1600000000000E+00 2.4821203166977E-01 1.4003525144795E+00 + 118 1.1700000000000E+00 2.0691662162923E-01 1.4229443390750E+00 + 119 1.1800000000000E+00 1.6610928256344E-01 1.4441981305652E+00 + 120 1.1900000000000E+00 1.2591325219751E-01 1.4639590940552E+00 + 121 1.2000000000000E+00 8.6454857275386E-02 1.4820642275106E+00 + 122 1.2100000000000E+00 4.7862649088425E-02 1.4983440585495E+00 + 123 1.2200000000000E+00 1.0266453884876E-02 1.5126245739496E+00 + 124 1.2300000000000E+00 -2.6203651934293E-02 1.5247293192453E+00 + 125 1.2400000000000E+00 -6.1418430576078E-02 1.5344816428186E+00 + 126 1.2500000000000E+00 -9.5250623104683E-02 1.5417070562483E+00 + 127 1.2600000000000E+00 -1.2757612765828E-01 1.5462356803988E+00 + 128 1.2700000000000E+00 -1.5827520122349E-01 1.5479047448284E+00 + 129 1.2800000000000E+00 -1.8723366986382E-01 1.5465611066322E+00 + 130 1.2900000000000E+00 -2.1434413180044E-01 1.5420637538190E+00 + 131 1.3000000000000E+00 -2.3950713745398E-01 1.5342862577718E+00 + 132 1.3100000000000E+00 -2.6263233048618E-01 1.5231191392883E+00 + 133 1.3200000000000E+00 -2.8363953402645E-01 1.5084721131265E+00 + 134 1.3300000000000E+00 -3.0245976663900E-01 1.4902761769153E+00 + 135 1.3400000000000E+00 -3.1903617317472E-01 1.4684855117032E+00 + 136 1.3500000000000E+00 -3.3332485645399E-01 1.4430791633149E+00 + 137 1.3600000000000E+00 -3.4529559673153E-01 1.4140624760212E+00 + 138 1.3700000000000E+00 -3.5493244710069E-01 1.3814682528177E+00 + 139 1.3800000000000E+00 -3.6223419437208E-01 1.3453576197661E+00 + 140 1.3900000000000E+00 -3.6721467651105E-01 1.3058205753930E+00 + 141 1.4000000000000E+00 -3.6990294939913E-01 1.2629762099593E+00 + 142 1.4100000000000E+00 -3.7034329750797E-01 1.2169725835484E+00 + 143 1.4200000000000E+00 -3.6859508497753E-01 1.1679862562191E+00 + 144 1.4300000000000E+00 -3.6473244557915E-01 1.1162214679468E+00 + 145 1.4400000000000E+00 -3.5884381208238E-01 1.0619089706573E+00 + 146 1.4500000000000E+00 -3.5103128758999E-01 1.0053045192359E+00 + 147 1.4600000000000E+00 -3.4140986347007E-01 9.4668703300792E-01 + 148 1.4700000000000E+00 -3.3010649051906E-01 8.8635644365220E-01 + 149 1.4800000000000E+00 -3.1725901194828E-01 8.2463124985668E-01 + 150 1.4900000000000E+00 -3.0301496865087E-01 7.6184580315361E-01 + 151 1.5000000000000E+00 -2.8753028895810E-01 6.9834735323248E-01 + 152 1.5100000000000E+00 -2.7096787670350E-01 6.3449288456187E-01 + 153 1.5200000000000E+00 -2.5349611286260E-01 5.7064577931313E-01 + 154 1.5300000000000E+00 -2.3528728730319E-01 5.0717234432409E-01 + 155 1.5400000000000E+00 -2.1651597824153E-01 4.4443824211219E-01 + 156 1.5500000000000E+00 -1.9735739784541E-01 3.8280486773054E-01 + 157 1.5600000000000E+00 -1.7798572303807E-01 3.2262571451371E-01 + 158 1.5700000000000E+00 -1.5857243092754E-01 2.6424277246619E-01 + 159 1.5800000000000E+00 -1.3928465840809E-01 2.0798300318960E-01 + 160 1.5900000000000E+00 -1.2028360534946E-01 1.5415493481730E-01 + 161 1.6000000000000E+00 -1.0172300040562E-01 1.0304541942773E-01 + 162 1.6100000000000E+00 -8.3747647840742E-02 5.4916593849292E-02 + 163 1.6200000000000E+00 -6.6492072892564E-02 1.0003082663661E-02 + 164 1.6300000000000E+00 -5.0079282080133E-02 -3.1490520417598E-02 + 165 1.6400000000000E+00 -3.4619653534504E-02 -6.9391859741300E-02 + 166 1.6500000000000E+00 -2.0209970888541E-02 -1.0356268399419E-01 + 167 1.6600000000000E+00 -6.9326125422759E-03 -1.3390034608900E-01 + 168 1.6700000000000E+00 5.1450937684539E-03 -1.6033891552351E-01 + 169 1.6800000000000E+00 1.5971343200500E-02 -1.8284988674460E-01 + 170 1.6900000000000E+00 2.5510147072134E-02 -2.0144247196360E-01 + 171 1.7000000000000E+00 3.3741443644969E-02 -2.1616347197014E-01 + 172 1.7100000000000E+00 4.0661025180037E-02 -2.2709672371639E-01 + 173 1.7200000000000E+00 4.6280282345407E-02 -2.3436212872176E-01 + 174 1.7300000000000E+00 5.0625769366793E-02 -2.3811427161246E-01 + 175 1.7400000000000E+00 5.3738595594019E-02 -2.3854064329135E-01 + 176 1.7500000000000E+00 5.5673651377155E-02 -2.3585948826906E-01 + 177 1.7600000000000E+00 5.6498678268280E-02 -2.3031730049017E-01 + 178 1.7700000000000E+00 5.6293195574249E-02 -2.2218599652882E-01 + 179 1.7800000000000E+00 5.5147297143536E-02 -2.1175979921637E-01 + 180 1.7900000000000E+00 5.3160333953361E-02 -1.9935186855067E-01 + 181 1.8000000000000E+00 5.0439499600931E-02 -1.8529072027811E-01 + 182 1.8100000000000E+00 4.7098336948350E-02 -1.6991647482505E-01 + 183 1.8200000000000E+00 4.3255186881937E-02 -1.5357697754005E-01 + 184 1.8300000000000E+00 3.9031574875922E-02 -1.3662384938844E-01 + 185 1.8400000000000E+00 3.4550617260957E-02 -1.1940828713632E-01 + 186 1.8500000000000E+00 2.9935070408265E-02 -1.0227613402298E-01 + 187 1.8600000000000E+00 2.5303637614343E-02 -8.5561920316439E-02 + 188 1.8700000000000E+00 2.0770306591763E-02 -6.9586075877414E-02 + 189 1.8800000000000E+00 1.6449762334267E-02 -5.4656545024692E-02 + 190 1.8900000000000E+00 1.2449531002761E-02 -4.1059344616364E-02 + 191 1.9000000000000E+00 8.8686933437633E-03 -2.9055478478775E-02 + 192 1.9100000000000E+00 5.7967295264727E-03 -1.8878152158149E-02 + 193 1.9200000000000E+00 3.3137135277579E-03 -1.0734117043229E-02 + 194 1.9300000000000E+00 1.4781230253499E-03 -4.7654269484593E-03 + 195 1.9400000000000E+00 3.7424531802422E-04 -1.2013010593677E-03 + 196 1.9500000000000E+00 -3.6454342297712E-06 1.1643231976233E-05 + 197 1.9600000000000E+00 -6.6837132764144E-06 2.1330713101699E-05 + 198 1.9700 0. -0. + 199 1.9800 -0. 0. + 200 1.9900 -0. 0. + 201 2.0000 0. 0. + 202 2.0100 0. 0. + 203 2.0200 0. 0. + 204 2.0300 0. 0. + 205 2.0400 0. 0. + 206 2.0500 0. 0. + 207 2.0600 0. 0. + 208 2.0700 0. 0. + 209 2.0800 0. 0. + 210 2.0900 0. 0. + 211 2.1000 0. 0. + 212 2.1100 0. 0. + 213 2.1200 0. 0. + 214 2.1300 0. 0. + 215 2.1400 0. 0. + 216 2.1500 0. 0. + 217 2.1600 0. 0. + 218 2.1700 0. 0. + 219 2.1800 0. 0. + 220 2.1900 0. 0. + 221 2.2000 0. 0. + 222 2.2100 0. 0. + 223 2.2200 0. 0. + 224 2.2300 0. 0. + 225 2.2400 0. 0. + 226 2.2500 0. 0. + 227 2.2600 0. 0. + 228 2.2700 0. 0. + 229 2.2800 0. 0. + 230 2.2900 0. 0. + 231 2.3000 0. 0. + 232 2.3100 0. 0. + 233 2.3200 0. 0. + 234 2.3300 0. 0. + 235 2.3400 0. 0. + 236 2.3500 0. 0. + 237 2.3600 0. 0. + 238 2.3700 0. 0. + 239 2.3800 0. 0. + 240 2.3900 0. 0. + 241 2.4000 0. 0. + 242 2.4100 0. 0. + 243 2.4200 0. 0. + 244 2.4300 0. 0. + 245 2.4400 0. 0. + 246 2.4500 0. 0. + 247 2.4600 0. 0. + 248 2.4700 0. 0. + 249 2.4800 0. 0. + 250 2.4900 0. 0. + 251 2.5000 0. 0. + 252 2.5100 0. 0. + 253 2.5200 0. 0. + 254 2.5300 0. 0. + 255 2.5400 0. 0. + 256 2.5500 0. 0. + 257 2.5600 0. 0. + 258 2.5700 0. 0. + 259 2.5800 0. 0. + 260 2.5900 0. 0. + 261 2.6000 0. 0. + 262 2.6100 0. 0. + 263 2.6200 0. 0. + 264 2.6300 0. 0. + 265 2.6400 0. 0. + 266 2.6500 0. 0. + 267 2.6600 0. 0. + 268 2.6700 0. 0. + 269 2.6800 0. 0. + 270 2.6900 0. 0. + 271 2.7000 0. 0. + 272 2.7100 0. 0. + 273 2.7200 0. 0. + 274 2.7300 0. 0. + 275 2.7400 0. 0. + 276 2.7500 0. 0. + 277 2.7600 0. 0. + 278 2.7700 0. 0. + 279 2.7800 0. 0. + 280 2.7900 0. 0. + 281 2.8000 0. 0. + 282 2.8100 0. 0. + 283 2.8200 0. 0. + 284 2.8300 0. 0. + 285 2.8400 0. 0. + 286 2.8500 0. 0. + 287 2.8600 0. 0. + 288 2.8700 0. 0. + 289 2.8800 0. 0. + 290 2.8900 0. 0. + 291 2.9000 0. 0. + 292 2.9100 0. 0. + 293 2.9200 0. 0. + 294 2.9300 0. 0. + 295 2.9400 0. 0. + 296 2.9500 0. 0. + 297 2.9600 0. 0. + 298 2.9700 0. 0. + 299 2.9800 0. 0. + 300 2.9900 0. 0. + 301 3.0000 0. 0. + 302 3.0100 0. 0. + 303 3.0200 0. 0. + 304 3.0300 0. 0. + 305 3.0400 0. 0. + 306 3.0500 0. 0. + 307 3.0600 0. 0. + 308 3.0700 0. 0. + 309 3.0800 0. 0. + 310 3.0900 0. 0. + 311 3.1000 0. 0. + 312 3.1100 0. 0. + 313 3.1200 0. 0. + 314 3.1300 0. 0. + 315 3.1400 0. 0. + 316 3.1500 0. 0. + 317 3.1600 0. 0. + 318 3.1700 0. 0. + 319 3.1800 0. 0. + 320 3.1900 0. 0. + 321 3.2000 0. 0. + 322 3.2100 0. 0. + 323 3.2200 0. 0. + 324 3.2300 0. 0. + 325 3.2400 0. 0. + 326 3.2500 0. 0. + 327 3.2600 0. 0. + 328 3.2700 0. 0. + 329 3.2800 0. 0. + 330 3.2900 0. 0. + 331 3.3000 0. 0. + 332 3.3100 0. 0. + 333 3.3200 0. 0. + 334 3.3300 0. 0. + 335 3.3400 0. 0. + 336 3.3500 0. 0. + 337 3.3600 0. 0. + 338 3.3700 0. 0. + 339 3.3800 0. 0. + 340 3.3900 0. 0. + 341 3.4000 0. 0. + 342 3.4100 0. 0. + 343 3.4200 0. 0. + 344 3.4300 0. 0. + 345 3.4400 0. 0. + 346 3.4500 0. 0. + 347 3.4600 0. 0. + 348 3.4700 0. 0. + 349 3.4800 0. 0. + 350 3.4900 0. 0. + 351 3.5000 0. 0. + 352 3.5100 0. 0. + 353 3.5200 0. 0. + 354 3.5300 0. 0. + 355 3.5400 0. 0. + 356 3.5500 0. 0. + 357 3.5600 0. 0. + 358 3.5700 0. 0. + 359 3.5800 0. 0. + 360 3.5900 0. 0. + 361 3.6000 0. 0. + 362 3.6100 0. 0. + 363 3.6200 0. 0. + 364 3.6300 0. 0. + 365 3.6400 0. 0. + 366 3.6500 0. 0. + 367 3.6600 0. 0. + 368 3.6700 0. 0. + 369 3.6800 0. 0. + 370 3.6900 0. 0. + 371 3.7000 0. 0. + 372 3.7100 0. 0. + 373 3.7200 0. 0. + 374 3.7300 0. 0. + 375 3.7400 0. 0. + 376 3.7500 0. 0. + 377 3.7600 0. 0. + 378 3.7700 0. 0. + 379 3.7800 0. 0. + 380 3.7900 0. 0. + 381 3.8000 0. 0. + 382 3.8100 0. 0. + 383 3.8200 0. 0. + 384 3.8300 0. 0. + 385 3.8400 0. 0. + 386 3.8500 0. 0. + 387 3.8600 0. 0. + 388 3.8700 0. 0. + 389 3.8800 0. 0. + 390 3.8900 0. 0. + 391 3.9000 0. 0. + 392 3.9100 0. 0. + 393 3.9200 0. 0. + 394 3.9300 0. 0. + 395 3.9400 0. 0. + 396 3.9500 0. 0. + 397 3.9600 0. 0. + 398 3.9700 0. 0. + 399 3.9800 0. 0. + 400 3.9900 0. 0. + 401 4.0000 0. 0. + 402 4.0100 0. 0. + 403 4.0200 0. 0. + 404 4.0300 0. 0. + 405 4.0400 0. 0. + 406 4.0500 0. 0. + 407 4.0600 0. 0. + 408 4.0700 0. 0. + 409 4.0800 0. 0. + 410 4.0900 0. 0. + 411 4.1000 0. 0. + 412 4.1100 0. 0. + 413 4.1200 0. 0. + 414 4.1300 0. 0. + 415 4.1400 0. 0. + 416 4.1500 0. 0. + 417 4.1600 0. 0. + 418 4.1700 0. 0. + 419 4.1800 0. 0. + 420 4.1900 0. 0. + 421 4.2000 0. 0. + 422 4.2100 0. 0. + 423 4.2200 0. 0. + 424 4.2300 0. 0. + 425 4.2400 0. 0. + 426 4.2500 0. 0. + 427 4.2600 0. 0. + 428 4.2700 0. 0. + 429 4.2800 0. 0. + 430 4.2900 0. 0. + 431 4.3000 0. 0. + 432 4.3100 0. 0. + 433 4.3200 0. 0. + 434 4.3300 0. 0. + 435 4.3400 0. 0. + 436 4.3500 0. 0. + 437 4.3600 0. 0. + 438 4.3700 0. 0. + 439 4.3800 0. 0. + 440 4.3900 0. 0. + 441 4.4000 0. 0. + 442 4.4100 0. 0. + 443 4.4200 0. 0. + 444 4.4300 0. 0. + 445 4.4400 0. 0. + 446 4.4500 0. 0. + 447 4.4600 0. 0. + 448 4.4700 0. 0. + 449 4.4800 0. 0. + 450 4.4900 0. 0. + 451 4.5000 0. 0. + 452 4.5100 0. 0. + 453 4.5200 0. 0. + 454 4.5300 0. 0. + 455 4.5400 0. 0. + 456 4.5500 0. 0. + 457 4.5600 0. 0. + 458 4.5700 0. 0. + 459 4.5800 0. 0. + 460 4.5900 0. 0. + 461 4.6000 0. 0. + 462 4.6100 0. 0. + 463 4.6200 0. 0. + 464 4.6300 0. 0. + 465 4.6400 0. 0. + 466 4.6500 0. 0. + 467 4.6600 0. 0. + 468 4.6700 0. 0. + 469 4.6800 0. 0. + 470 4.6900 0. 0. + 471 4.7000 0. 0. + 472 4.7100 0. 0. + 473 4.7200 0. 0. + 474 4.7300 0. 0. + 475 4.7400 0. 0. + 476 4.7500 0. 0. + 477 4.7600 0. 0. + 478 4.7700 0. 0. + 479 4.7800 0. 0. + 480 4.7900 0. 0. + 481 4.8000 0. 0. + 482 4.8100 0. 0. + 483 4.8200 0. 0. + 484 4.8300 0. 0. + 485 4.8400 0. 0. + 486 4.8500 0. 0. + 487 4.8600 0. 0. + 488 4.8700 0. 0. + 489 4.8800 0. 0. + 490 4.8900 0. 0. + 491 4.9000 0. 0. + 492 4.9100 0. 0. + 493 4.9200 0. 0. + 494 4.9300 0. 0. + 495 4.9400 0. 0. + 496 4.9500 0. 0. + 497 4.9600 0. 0. + 498 4.9700 0. 0. + 499 4.9800 0. 0. + 500 4.9900 0. 0. + 501 5.0000 0. 0. + 502 5.0100 0. 0. + 503 5.0200 0. 0. + 504 5.0300 0. 0. + 505 5.0400 0. 0. + 506 5.0500 0. 0. + 507 5.0600 0. 0. + 508 5.0700 0. 0. + 509 5.0800 0. 0. + 510 5.0900 0. 0. + 511 5.1000 0. 0. + 512 5.1100 0. 0. + 513 5.1200 0. 0. + 514 5.1300 0. 0. + 515 5.1400 0. 0. + 516 5.1500 0. 0. + 517 5.1600 0. 0. + 518 5.1700 0. 0. + 519 5.1800 0. 0. + 520 5.1900 0. 0. + 521 5.2000 0. 0. + 522 5.2100 0. 0. + 523 5.2200 0. 0. + 524 5.2300 0. 0. + 525 5.2400 0. 0. + 526 5.2500 0. 0. + 527 5.2600 0. 0. + 528 5.2700 0. 0. + 529 5.2800 0. 0. + 530 5.2900 0. 0. + 531 5.3000 0. 0. + 532 5.3100 0. 0. + 533 5.3200 0. 0. + 534 5.3300 0. 0. + 535 5.3400 0. 0. + 536 5.3500 0. 0. + 537 5.3600 0. 0. + 538 5.3700 0. 0. + 539 5.3800 0. 0. + 540 5.3900 0. 0. + 541 5.4000 0. 0. + 542 5.4100 0. 0. + 543 5.4200 0. 0. + 544 5.4300 0. 0. + 545 5.4400 0. 0. + 546 5.4500 0. 0. + 547 5.4600 0. 0. + 548 5.4700 0. 0. + 549 5.4800 0. 0. + 550 5.4900 0. 0. + 551 5.5000 0. 0. + 552 5.5100 0. 0. + 553 5.5200 0. 0. + 554 5.5300 0. 0. + 555 5.5400 0. 0. + 556 5.5500 0. 0. + 557 5.5600 0. 0. + 558 5.5700 0. 0. + 559 5.5800 0. 0. + 560 5.5900 0. 0. + 561 5.6000 0. 0. + 562 5.6100 0. 0. + 563 5.6200 0. 0. + 564 5.6300 0. 0. + 565 5.6400 0. 0. + 566 5.6500 0. 0. + 567 5.6600 0. 0. + 568 5.6700 0. 0. + 569 5.6800 0. 0. + 570 5.6900 0. 0. + 571 5.7000 0. 0. + 572 5.7100 0. 0. + 573 5.7200 0. 0. + 574 5.7300 0. 0. + 575 5.7400 0. 0. + 576 5.7500 0. 0. + 577 5.7600 0. 0. + 578 5.7700 0. 0. + 579 5.7800 0. 0. + 580 5.7900 0. 0. + 581 5.8000 0. 0. + 582 5.8100 0. 0. + 583 5.8200 0. 0. + 584 5.8300 0. 0. + 585 5.8400 0. 0. + 586 5.8500 0. 0. + 587 5.8600 0. 0. + 588 5.8700 0. 0. + 589 5.8800 0. 0. + 590 5.8900 0. 0. + 591 5.9000 0. 0. + 592 5.9100 0. 0. + 593 5.9200 0. 0. + 594 5.9300 0. 0. + 595 5.9400 0. 0. + 596 5.9500 0. 0. + 597 5.9600 0. 0. + 598 5.9700 0. 0. + 599 5.9800 0. 0. + 600 5.9900 0. 0. + 4 + 1 0.0000000000000E+00 -2.7392696720782E+00 + 2 1.0000000000000E-02 -2.7392215082763E+00 + 3 2.0000000000000E-02 -2.7390768516102E+00 + 4 3.0000000000000E-02 -2.7388358333454E+00 + 5 4.0000000000000E-02 -2.7384985677445E+00 + 6 5.0000000000000E-02 -2.7380652140687E+00 + 7 6.0000000000000E-02 -2.7375359760041E+00 + 8 7.0000000000000E-02 -2.7369111008800E+00 + 9 8.0000000000000E-02 -2.7361908787147E+00 + 10 9.0000000000000E-02 -2.7353756411130E+00 + 11 1.0000000000000E-01 -2.7344657600146E+00 + 12 1.1000000000000E-01 -2.7334616463048E+00 + 13 1.2000000000000E-01 -2.7323637483000E+00 + 14 1.3000000000000E-01 -2.7311725501189E+00 + 15 1.4000000000000E-01 -2.7298885699537E+00 + 16 1.5000000000000E-01 -2.7285123582420E+00 + 17 1.6000000000000E-01 -2.7270444957643E+00 + 18 1.7000000000000E-01 -2.7254855916790E+00 + 19 1.8000000000000E-01 -2.7238362814954E+00 + 20 1.9000000000000E-01 -2.7220972250111E+00 + 21 2.0000000000000E-01 -2.7202691042068E+00 + 22 2.1000000000000E-01 -2.7183526211396E+00 + 23 2.2000000000000E-01 -2.7163484958079E+00 + 24 2.3000000000000E-01 -2.7142574640259E+00 + 25 2.4000000000000E-01 -2.7120802753135E+00 + 26 2.5000000000000E-01 -2.7098176907857E+00 + 27 2.6000000000000E-01 -2.7074704810876E+00 + 28 2.7000000000000E-01 -2.7050394243528E+00 + 29 2.8000000000000E-01 -2.7025253041926E+00 + 30 2.9000000000000E-01 -2.6999289077407E+00 + 31 3.0000000000000E-01 -2.6972510237380E+00 + 32 3.1000000000000E-01 -2.6944924406723E+00 + 33 3.2000000000000E-01 -2.6916539449686E+00 + 34 3.3000000000000E-01 -2.6887363192333E+00 + 35 3.4000000000000E-01 -2.6857403405683E+00 + 36 3.5000000000000E-01 -2.6826667789299E+00 + 37 3.6000000000000E-01 -2.6795163955609E+00 + 38 3.7000000000000E-01 -2.6762899414732E+00 + 39 3.8000000000000E-01 -2.6729881560004E+00 + 40 3.9000000000000E-01 -2.6696117654181E+00 + 41 4.0000000000000E-01 -2.6661614816019E+00 + 42 4.1000000000000E-01 -2.6626380007851E+00 + 43 4.2000000000000E-01 -2.6590420023580E+00 + 44 4.3000000000000E-01 -2.6553741477316E+00 + 45 4.4000000000000E-01 -2.6516350792775E+00 + 46 4.5000000000000E-01 -2.6478254193328E+00 + 47 4.6000000000000E-01 -2.6439457692683E+00 + 48 4.7000000000000E-01 -2.6399967086339E+00 + 49 4.8000000000000E-01 -2.6359787943761E+00 + 50 4.9000000000000E-01 -2.6318925601269E+00 + 51 5.0000000000000E-01 -2.6277385155786E+00 + 52 5.1000000000000E-01 -2.6235171459265E+00 + 53 5.2000000000000E-01 -2.6192289114155E+00 + 54 5.3000000000000E-01 -2.6148742469544E+00 + 55 5.4000000000000E-01 -2.6104535618319E+00 + 56 5.5000000000000E-01 -2.6059672395302E+00 + 57 5.6000000000000E-01 -2.6014156376233E+00 + 58 5.7000000000000E-01 -2.5967990877900E+00 + 59 5.8000000000000E-01 -2.5921178959213E+00 + 60 5.9000000000000E-01 -2.5873723423418E+00 + 61 6.0000000000000E-01 -2.5825626821384E+00 + 62 6.1000000000000E-01 -2.5776891455980E+00 + 63 6.2000000000000E-01 -2.5727519387619E+00 + 64 6.3000000000000E-01 -2.5677512440973E+00 + 65 6.4000000000000E-01 -2.5626872212827E+00 + 66 6.5000000000000E-01 -2.5575600081027E+00 + 67 6.6000000000000E-01 -2.5523697214700E+00 + 68 6.7000000000000E-01 -2.5471164585525E+00 + 69 6.8000000000000E-01 -2.5418002980204E+00 + 70 6.9000000000000E-01 -2.5364213013892E+00 + 71 7.0000000000000E-01 -2.5309795144799E+00 + 72 7.1000000000000E-01 -2.5254749689846E+00 + 73 7.2000000000000E-01 -2.5199076841129E+00 + 74 7.3000000000000E-01 -2.5142776683317E+00 + 75 7.4000000000000E-01 -2.5085849212046E+00 + 76 7.5000000000000E-01 -2.5028294352977E+00 + 77 7.6000000000000E-01 -2.4970111981380E+00 + 78 7.7000000000000E-01 -2.4911301942510E+00 + 79 7.8000000000000E-01 -2.4851864072580E+00 + 80 7.9000000000000E-01 -2.4791798219786E+00 + 81 8.0000000000000E-01 -2.4731104265866E+00 + 82 8.1000000000000E-01 -2.4669782147954E+00 + 83 8.2000000000000E-01 -2.4607831880195E+00 + 84 8.3000000000000E-01 -2.4545253575707E+00 + 85 8.4000000000000E-01 -2.4482047467971E+00 + 86 8.5000000000000E-01 -2.4418213932385E+00 + 87 8.6000000000000E-01 -2.4353753507197E+00 + 88 8.7000000000000E-01 -2.4288666914030E+00 + 89 8.8000000000000E-01 -2.4222955077720E+00 + 90 8.9000000000000E-01 -2.4156619145433E+00 + 91 9.0000000000000E-01 -2.4089660505312E+00 + 92 9.1000000000000E-01 -2.4022080803967E+00 + 93 9.2000000000000E-01 -2.3953881962075E+00 + 94 9.3000000000000E-01 -2.3885066191329E+00 + 95 9.4000000000000E-01 -2.3815636007013E+00 + 96 9.5000000000000E-01 -2.3745594241945E+00 + 97 9.6000000000000E-01 -2.3674944057656E+00 + 98 9.7000000000000E-01 -2.3603688954939E+00 + 99 9.8000000000000E-01 -2.3531832782298E+00 + 100 9.9000000000000E-01 -2.3459379743736E+00 + 101 1.0000000000000E+00 -2.3386334404307E+00 + 102 1.0100000000000E+00 -2.3312701694836E+00 + 103 1.0200000000000E+00 -2.3238486914660E+00 + 104 1.0300000000000E+00 -2.3163695733160E+00 + 105 1.0400000000000E+00 -2.3088334189652E+00 + 106 1.0500000000000E+00 -2.3012408692183E+00 + 107 1.0600000000000E+00 -2.2935926014450E+00 + 108 1.0700000000000E+00 -2.2858893291832E+00 + 109 1.0800000000000E+00 -2.2781318015886E+00 + 110 1.0900000000000E+00 -2.2703208027864E+00 + 111 1.1000000000000E+00 -2.2624571510801E+00 + 112 1.1100000000000E+00 -2.2545416981060E+00 + 113 1.1200000000000E+00 -2.2465753278420E+00 + 114 1.1300000000000E+00 -2.2385589555852E+00 + 115 1.1400000000000E+00 -2.2304935268293E+00 + 116 1.1500000000000E+00 -2.2223800160795E+00 + 117 1.1600000000000E+00 -2.2142194256645E+00 + 118 1.1700000000000E+00 -2.2060127844444E+00 + 119 1.1800000000000E+00 -2.1977611465812E+00 + 120 1.1900000000000E+00 -2.1894655902116E+00 + 121 1.2000000000000E+00 -2.1811272162064E+00 + 122 1.2100000000000E+00 -2.1727471468867E+00 + 123 1.2200000000000E+00 -2.1643265247828E+00 + 124 1.2300000000000E+00 -2.1558665114616E+00 + 125 1.2400000000000E+00 -2.1473682863420E+00 + 126 1.2500000000000E+00 -2.1388330456416E+00 + 127 1.2600000000000E+00 -2.1302620013227E+00 + 128 1.2700000000000E+00 -2.1216563801696E+00 + 129 1.2800000000000E+00 -2.1130174229145E+00 + 130 1.2900000000000E+00 -2.1043463834652E+00 + 131 1.3000000000000E+00 -2.0956445282327E+00 + 132 1.3100000000000E+00 -2.0869131355504E+00 + 133 1.3200000000000E+00 -2.0781534951886E+00 + 134 1.3300000000000E+00 -2.0693669079889E+00 + 135 1.3400000000000E+00 -2.0605546855949E+00 + 136 1.3500000000000E+00 -2.0517181502593E+00 + 137 1.3600000000000E+00 -2.0428586348117E+00 + 138 1.3700000000000E+00 -2.0339774826429E+00 + 139 1.3800000000000E+00 -2.0250760478601E+00 + 140 1.3900000000000E+00 -2.0161556954684E+00 + 141 1.4000000000000E+00 -2.0072178016613E+00 + 142 1.4100000000000E+00 -1.9982637541849E+00 + 143 1.4200000000000E+00 -1.9892949527564E+00 + 144 1.4300000000000E+00 -1.9803128095323E+00 + 145 1.4400000000000E+00 -1.9713187496517E+00 + 146 1.4500000000000E+00 -1.9623142117814E+00 + 147 1.4600000000000E+00 -1.9533006487064E+00 + 148 1.4700000000000E+00 -1.9442795279448E+00 + 149 1.4800000000000E+00 -1.9352523323372E+00 + 150 1.4900000000000E+00 -1.9262205606730E+00 + 151 1.5000000000000E+00 -1.9171857282677E+00 + 152 1.5100000000000E+00 -1.9081493675410E+00 + 153 1.5200000000000E+00 -1.8991130285386E+00 + 154 1.5300000000000E+00 -1.8900782794434E+00 + 155 1.5400000000000E+00 -1.8810467070023E+00 + 156 1.5500000000000E+00 -1.8720199169182E+00 + 157 1.5600000000000E+00 -1.8629995341791E+00 + 158 1.5700000000000E+00 -1.8539872032912E+00 + 159 1.5800000000000E+00 -1.8449845884704E+00 + 160 1.5900000000000E+00 -1.8359933737254E+00 + 161 1.6000000000000E+00 -1.8270152628724E+00 + 162 1.6100000000000E+00 -1.8180519794425E+00 + 163 1.6200000000000E+00 -1.8091052665206E+00 + 164 1.6300000000000E+00 -1.8001768864746E+00 + 165 1.6400000000000E+00 -1.7912686205786E+00 + 166 1.6500000000000E+00 -1.7823822685659E+00 + 167 1.6600000000000E+00 -1.7735196480544E+00 + 168 1.6700000000000E+00 -1.7646825938868E+00 + 169 1.6800000000000E+00 -1.7558729573566E+00 + 170 1.6900000000000E+00 -1.7470926053490E+00 + 171 1.7000000000000E+00 -1.7383434193649E+00 + 172 1.7100000000000E+00 -1.7296272944353E+00 + 173 1.7200000000000E+00 -1.7209461379579E+00 + 174 1.7300000000000E+00 -1.7123018684072E+00 + 175 1.7400000000000E+00 -1.7036964139401E+00 + 176 1.7500000000000E+00 -1.6951317109239E+00 + 177 1.7600000000000E+00 -1.6866097023351E+00 + 178 1.7700000000000E+00 -1.6781323360738E+00 + 179 1.7800000000000E+00 -1.6697015631729E+00 + 180 1.7900000000000E+00 -1.6613193359162E+00 + 181 1.8000000000000E+00 -1.6529876058918E+00 + 182 1.8100000000000E+00 -1.6447083218923E+00 + 183 1.8200000000000E+00 -1.6364834271738E+00 + 184 1.8300000000000E+00 -1.6283148603816E+00 + 185 1.8400000000000E+00 -1.6202045298086E+00 + 186 1.8500000000000E+00 -1.6121542447919E+00 + 187 1.8600000000000E+00 -1.6041656615430E+00 + 188 1.8700000000000E+00 -1.5962402808528E+00 + 189 1.8800000000000E+00 -1.5883794485976E+00 + 190 1.8900000000000E+00 -1.5805843494204E+00 + 191 1.9000000000000E+00 -1.5728560058728E+00 + 192 1.9100000000000E+00 -1.5651953391874E+00 + 193 1.9200000000000E+00 -1.5576031405110E+00 + 194 1.9300000000000E+00 -1.5500783944914E+00 + 195 1.9400000000000E+00 -1.5426169004064E+00 + 196 1.9500000000000E+00 -1.5352137799514E+00 + 197 1.9600000000000E+00 -1.5278672652558E+00 + 198 1.9700000000000E+00 -1.5205758106563E+00 + 199 1.9800000000000E+00 -1.5133380662266E+00 + 200 1.9900000000000E+00 -1.5061540435633E+00 + 201 2.0000000000000E+00 -1.4990236677885E+00 + 202 2.0100000000000E+00 -1.4919461982952E+00 + 203 2.0200000000000E+00 -1.4849213354008E+00 + 204 2.0300000000000E+00 -1.4779486183207E+00 + 205 2.0400000000000E+00 -1.4710275932847E+00 + 206 2.0500000000000E+00 -1.4641578020526E+00 + 207 2.0600000000000E+00 -1.4573387805689E+00 + 208 2.0700000000000E+00 -1.4505700646711E+00 + 209 2.0800000000000E+00 -1.4438511924657E+00 + 210 2.0900000000000E+00 -1.4371817067600E+00 + 211 2.1000000000000E+00 -1.4305611570724E+00 + 212 2.1100000000000E+00 -1.4239891012947E+00 + 213 2.1200000000000E+00 -1.4174651070373E+00 + 214 2.1300000000000E+00 -1.4109887526934E+00 + 215 2.1400000000000E+00 -1.4045596282553E+00 + 216 2.1500000000000E+00 -1.3981773359026E+00 + 217 2.1600000000000E+00 -1.3918414903981E+00 + 218 2.1700000000000E+00 -1.3855517193118E+00 + 219 2.1800000000000E+00 -1.3793076630944E+00 + 220 2.1900000000000E+00 -1.3731089750205E+00 + 221 2.2000000000000E+00 -1.3669553210221E+00 + 222 2.2100000000000E+00 -1.3608463794260E+00 + 223 2.2200000000000E+00 -1.3547818406103E+00 + 224 2.2300000000000E+00 -1.3487614065950E+00 + 225 2.2400000000000E+00 -1.3427847905756E+00 + 226 2.2500000000000E+00 -1.3368517164110E+00 + 227 2.2600000000000E+00 -1.3309619180764E+00 + 228 2.2700000000000E+00 -1.3251151390869E+00 + 229 2.2800000000000E+00 -1.3193111318998E+00 + 230 2.2900000000000E+00 -1.3135496573012E+00 + 231 2.3000000000000E+00 -1.3078304837842E+00 + 232 2.3100000000000E+00 -1.3021533869206E+00 + 233 2.3200000000000E+00 -1.2965181487319E+00 + 234 2.3300000000000E+00 -1.2909245570619E+00 + 235 2.3400000000000E+00 -1.2853724049561E+00 + 236 2.3500000000000E+00 -1.2798614900470E+00 + 237 2.3600000000000E+00 -1.2743916139510E+00 + 238 2.3700000000000E+00 -1.2689625816765E+00 + 239 2.3800000000000E+00 -1.2635742010459E+00 + 240 2.3900000000000E+00 -1.2582262821321E+00 + 241 2.4000000000000E+00 -1.2529186367120E+00 + 242 2.4100000000000E+00 -1.2476510777363E+00 + 243 2.4200000000000E+00 -1.2424234188178E+00 + 244 2.4300000000000E+00 -1.2372354737392E+00 + 245 2.4400000000000E+00 -1.2320870559789E+00 + 246 2.4500000000000E+00 -1.2269779782581E+00 + 247 2.4600000000000E+00 -1.2219080521082E+00 + 248 2.4700000000000E+00 -1.2168770874593E+00 + 249 2.4800000000000E+00 -1.2118848922500E+00 + 250 2.4900000000000E+00 -1.2069312720584E+00 + 251 2.5000000000000E+00 -1.2020160297568E+00 + 252 2.5100000000000E+00 -1.1971389651873E+00 + 253 2.5200000000000E+00 -1.1922998748602E+00 + 254 2.5300000000000E+00 -1.1874985516761E+00 + 255 2.5400000000000E+00 -1.1827347846701E+00 + 256 2.5500000000000E+00 -1.1780083587793E+00 + 257 2.5600000000000E+00 -1.1733190546339E+00 + 258 2.5700000000000E+00 -1.1686666483712E+00 + 259 2.5800000000000E+00 -1.1640509114734E+00 + 260 2.5900000000000E+00 -1.1594716106279E+00 + 261 2.6000000000000E+00 -1.1549285076122E+00 + 262 2.6100000000000E+00 -1.1504213592006E+00 + 263 2.6200000000000E+00 -1.1459499170948E+00 + 264 2.6300000000000E+00 -1.1415139278775E+00 + 265 2.6400000000000E+00 -1.1371131329881E+00 + 266 2.6500000000000E+00 -1.1327472687211E+00 + 267 2.6600000000000E+00 -1.1284160662466E+00 + 268 2.6700000000000E+00 -1.1241192516519E+00 + 269 2.6800000000000E+00 -1.1198565460052E+00 + 270 2.6900000000000E+00 -1.1156276654393E+00 + 271 2.7000000000000E+00 -1.1114323212554E+00 + 272 2.7100000000000E+00 -1.1072702200469E+00 + 273 2.7200000000000E+00 -1.1031410638414E+00 + 274 2.7300000000000E+00 -1.0990445502613E+00 + 275 2.7400000000000E+00 -1.0949803727018E+00 + 276 2.7500000000000E+00 -1.0909482205245E+00 + 277 2.7600000000000E+00 -1.0869477792676E+00 + 278 2.7700000000000E+00 -1.0829787308702E+00 + 279 2.7800000000000E+00 -1.0790407539110E+00 + 280 2.7900000000000E+00 -1.0751335238584E+00 + 281 2.8000000000000E+00 -1.0712567133333E+00 + 282 2.8100000000000E+00 -1.0674099923826E+00 + 283 2.8200000000000E+00 -1.0635930287616E+00 + 284 2.8300000000000E+00 -1.0598054882244E+00 + 285 2.8400000000000E+00 -1.0560470348224E+00 + 286 2.8500000000000E+00 -1.0523173312087E+00 + 287 2.8600000000000E+00 -1.0486160389468E+00 + 288 2.8700000000000E+00 -1.0449428188234E+00 + 289 2.8800000000000E+00 -1.0412973311637E+00 + 290 2.8900000000000E+00 -1.0376792361481E+00 + 291 2.9000000000000E+00 -1.0340881941293E+00 + 292 2.9100000000000E+00 -1.0305238659480E+00 + 293 2.9200000000000E+00 -1.0269859132470E+00 + 294 2.9300000000000E+00 -1.0234739987826E+00 + 295 2.9400000000000E+00 -1.0199877867311E+00 + 296 2.9500000000000E+00 -1.0165269429903E+00 + 297 2.9600000000000E+00 -1.0130911354756E+00 + 298 2.9700000000000E+00 -1.0096800344086E+00 + 299 2.9800000000000E+00 -1.0062933125969E+00 + 300 2.9900000000000E+00 -1.0029306457071E+00 + 301 3.0000000000000E+00 -9.9959171252634E-01 + 302 3.0100000000000E+00 -9.9627619521478E-01 + 303 3.0200000000000E+00 -9.9298377954643E-01 + 304 3.0300000000000E+00 -9.8971415513869E-01 + 305 3.0400000000000E+00 -9.8646701566985E-01 + 306 3.0500000000000E+00 -9.8324205908380E-01 + 307 3.0600000000000E+00 -9.8003898778169E-01 + 308 3.0700000000000E+00 -9.7685750880018E-01 + 309 3.0800000000000E+00 -9.7369733397583E-01 + 310 3.0900000000000E+00 -9.7055818009581E-01 + 311 3.1000000000000E+00 -9.6743976903398E-01 + 312 3.1100000000000E+00 -9.6434182787269E-01 + 313 3.1200000000000E+00 -9.6126408901037E-01 + 314 3.1300000000000E+00 -9.5820629025478E-01 + 315 3.1400000000000E+00 -9.5516817490141E-01 + 316 3.1500000000000E+00 -9.5214949179765E-01 + 317 3.1600000000000E+00 -9.4914999539334E-01 + 318 3.1700000000000E+00 -9.4616944577760E-01 + 319 3.1800000000000E+00 -9.4320760869717E-01 + 320 3.1900000000000E+00 -9.4026425556509E-01 + 321 3.2000000000000E+00 -9.3733916347478E-01 + 322 3.2100000000000E+00 -9.3443211517651E-01 + 323 3.2200000000000E+00 -9.3154289900027E-01 + 324 3.2300000000000E+00 -9.2867130883439E-01 + 325 3.2400000000000E+00 -9.2581714414478E-01 + 326 3.2500000000000E+00 -9.2298020988018E-01 + 327 3.2600000000000E+00 -9.2016031633082E-01 + 328 3.2700000000000E+00 -9.1735727907065E-01 + 329 3.2800000000000E+00 -9.1457091889968E-01 + 330 3.2900000000000E+00 -9.1180106172571E-01 + 331 3.3000000000000E+00 -9.0904753844164E-01 + 332 3.3100000000000E+00 -9.0631018481175E-01 + 333 3.3200000000000E+00 -9.0358884134703E-01 + 334 3.3300000000000E+00 -9.0088335317121E-01 + 335 3.3400000000000E+00 -8.9819356988200E-01 + 336 3.3500000000000E+00 -8.9551934540733E-01 + 337 3.3600000000000E+00 -8.9286053785672E-01 + 338 3.3700000000000E+00 -8.9021700936879E-01 + 339 3.3800000000000E+00 -8.8758862595533E-01 + 340 3.3900000000000E+00 -8.8497525734261E-01 + 341 3.4000000000000E+00 -8.8237677681034E-01 + 342 3.4100000000000E+00 -8.7979306102931E-01 + 343 3.4200000000000E+00 -8.7722398989801E-01 + 344 3.4300000000000E+00 -8.7466944637868E-01 + 345 3.4400000000000E+00 -8.7212931633355E-01 + 346 3.4500000000000E+00 -8.6960348836191E-01 + 347 3.4600000000000E+00 -8.6709185363832E-01 + 348 3.4700000000000E+00 -8.6459430575260E-01 + 349 3.4800000000000E+00 -8.6211074055181E-01 + 350 3.4900000000000E+00 -8.5964105598529E-01 + 351 3.5000000000000E+00 -8.5718515195256E-01 + 352 3.5100000000000E+00 -8.5474293015498E-01 + 353 3.5200000000000E+00 -8.5231429395122E-01 + 354 3.5300000000000E+00 -8.4989914821718E-01 + 355 3.5400000000000E+00 -8.4749739921054E-01 + 356 3.5500000000000E+00 -8.4510895444038E-01 + 357 3.5600000000000E+00 -8.4273372254212E-01 + 358 3.5700000000000E+00 -8.4037161315801E-01 + 359 3.5800000000000E+00 -8.3802253682354E-01 + 360 3.5900000000000E+00 -8.3568640485969E-01 + 361 3.6000000000000E+00 -8.3336312927172E-01 + 362 3.6100000000000E+00 -8.3105262265391E-01 + 363 3.6200000000000E+00 -8.2875479810132E-01 + 364 3.6300000000000E+00 -8.2646956912769E-01 + 365 3.6400000000000E+00 -8.2419684959032E-01 + 366 3.6500000000000E+00 -8.2193655362146E-01 + 367 3.6600000000000E+00 -8.1968859556651E-01 + 368 3.6700000000000E+00 -8.1745288992889E-01 + 369 3.6800000000000E+00 -8.1522935132148E-01 + 370 3.6900000000000E+00 -8.1301789442483E-01 + 371 3.7000000000000E+00 -8.1081843395154E-01 + 372 3.7100000000000E+00 -8.0863088461730E-01 + 373 3.7200000000000E+00 -8.0645516111781E-01 + 374 3.7300000000000E+00 -8.0429117811201E-01 + 375 3.7400000000000E+00 -8.0213885021080E-01 + 376 3.7500000000000E+00 -7.9999809197169E-01 + 377 3.7600000000000E+00 -7.9786881789860E-01 + 378 3.7700000000000E+00 -7.9575094244686E-01 + 379 3.7800000000000E+00 -7.9364438003298E-01 + 380 3.7900000000000E+00 -7.9154904504897E-01 + 381 3.8000000000000E+00 -7.8946485188102E-01 + 382 3.8100000000000E+00 -7.8739171493197E-01 + 383 3.8200000000000E+00 -7.8532954864754E-01 + 384 3.8300000000000E+00 -7.8327826754575E-01 + 385 3.8400000000000E+00 -7.8123778624929E-01 + 386 3.8500000000000E+00 -7.7920801952063E-01 + 387 3.8600000000000E+00 -7.7718888229928E-01 + 388 3.8700000000000E+00 -7.7518028974105E-01 + 389 3.8800000000000E+00 -7.7318215725890E-01 + 390 3.8900000000000E+00 -7.7119440056505E-01 + 391 3.9000000000000E+00 -7.6921693571407E-01 + 392 3.9100000000000E+00 -7.6724967914646E-01 + 393 3.9200000000000E+00 -7.6529254773266E-01 + 394 3.9300000000000E+00 -7.6334545881692E-01 + 395 3.9400000000000E+00 -7.6140833026093E-01 + 396 3.9500000000000E+00 -7.5948108048687E-01 + 397 3.9600000000000E+00 -7.5756362851946E-01 + 398 3.9700000000000E+00 -7.5565589402712E-01 + 399 3.9800000000000E+00 -7.5375779736145E-01 + 400 3.9900000000000E+00 -7.5186925959541E-01 + 401 4.0000000000000E+00 -7.4999020255949E-01 + 402 4.0100000000000E+00 -7.4812054887597E-01 + 403 4.0200000000000E+00 -7.4626022199115E-01 + 404 4.0300000000000E+00 -7.4440914620490E-01 + 405 4.0400000000000E+00 -7.4256724669826E-01 + 406 4.0500000000000E+00 -7.4073444955798E-01 + 407 4.0600000000000E+00 -7.3891068179876E-01 + 408 4.0700000000000E+00 -7.3709587138264E-01 + 409 4.0800000000000E+00 -7.3528994723541E-01 + 410 4.0900000000000E+00 -7.3349283926065E-01 + 411 4.1000000000000E+00 -7.3170447835033E-01 + 412 4.1100000000000E+00 -7.2992479639306E-01 + 413 4.1200000000000E+00 -7.2815372627921E-01 + 414 4.1300000000000E+00 -7.2639120190322E-01 + 415 4.1400000000000E+00 -7.2463715816354E-01 + 416 4.1500000000000E+00 -7.2289153095920E-01 + 417 4.1600000000000E+00 -7.2115425718404E-01 + 418 4.1700000000000E+00 -7.1942527471858E-01 + 419 4.1800000000000E+00 -7.1770452241953E-01 + 420 4.1900000000000E+00 -7.1599194010733E-01 + 421 4.2000000000000E+00 -7.1428746855019E-01 + 422 4.2100000000000E+00 -7.1259104944647E-01 + 423 4.2200000000000E+00 -7.1090262540564E-01 + 424 4.2300000000000E+00 -7.0922213992759E-01 + 425 4.2400000000000E+00 -7.0754953738037E-01 + 426 4.2500000000000E+00 -7.0588476297565E-01 + 427 4.2600000000000E+00 -7.0422776274322E-01 + 428 4.2700000000000E+00 -7.0257848350450E-01 + 429 4.2800000000000E+00 -7.0093687284496E-01 + 430 4.2900000000000E+00 -6.9930287908582E-01 + 431 4.3000000000000E+00 -6.9767645125496E-01 + 432 4.3100000000000E+00 -6.9605753905740E-01 + 433 4.3200000000000E+00 -6.9444609284538E-01 + 434 4.3300000000000E+00 -6.9284206358849E-01 + 435 4.3400000000000E+00 -6.9124540284342E-01 + 436 4.3500000000000E+00 -6.8965606272425E-01 + 437 4.3600000000000E+00 -6.8807399587271E-01 + 438 4.3700000000000E+00 -6.8649915542902E-01 + 439 4.3800000000000E+00 -6.8493149500333E-01 + 440 4.3900000000000E+00 -6.8337096864764E-01 + 441 4.4000000000000E+00 -6.8181753082872E-01 + 442 4.4100000000000E+00 -6.8027113640195E-01 + 443 4.4200000000000E+00 -6.7873174058593E-01 + 444 4.4300000000000E+00 -6.7719929893858E-01 + 445 4.4400000000000E+00 -6.7567376733412E-01 + 446 4.4500000000000E+00 -6.7415510194144E-01 + 447 4.4600000000000E+00 -6.7264325920395E-01 + 448 4.4700000000000E+00 -6.7113819582051E-01 + 449 4.4800000000000E+00 -6.6963986872814E-01 + 450 4.4900000000000E+00 -6.6814823508609E-01 + 451 4.5000000000000E+00 -6.6666325226126E-01 + 452 4.5100000000000E+00 -6.6518487781552E-01 + 453 4.5200000000000E+00 -6.6371306949426E-01 + 454 4.5300000000000E+00 -6.6224778521659E-01 + 455 4.5400000000000E+00 -6.6078898306729E-01 + 456 4.5500000000000E+00 -6.5933662128985E-01 + 457 4.5600000000000E+00 -6.5789065828148E-01 + 458 4.5700000000000E+00 -6.5645105258944E-01 + 459 4.5800000000000E+00 -6.5501776290853E-01 + 460 4.5900000000000E+00 -6.5359074808053E-01 + 461 4.6000000000000E+00 -6.5216996709450E-01 + 462 4.6100000000000E+00 -6.5075537908853E-01 + 463 4.6200000000000E+00 -6.4934694335288E-01 + 464 4.6300000000000E+00 -6.4794461933400E-01 + 465 4.6400000000000E+00 -6.4654836663979E-01 + 466 4.6500000000000E+00 -6.4515814504589E-01 + 467 4.6600000000000E+00 -6.4377391450273E-01 + 468 4.6700000000000E+00 -6.4239563514361E-01 + 469 4.6800000000000E+00 -6.4102326729343E-01 + 470 4.6900000000000E+00 -6.3965677147801E-01 + 471 4.7000000000000E+00 -6.3829610843415E-01 + 472 4.7100000000000E+00 -6.3694123912003E-01 + 473 4.7200000000000E+00 -6.3559212472604E-01 + 474 4.7300000000000E+00 -6.3424872668589E-01 + 475 4.7400000000000E+00 -6.3291100668792E-01 + 476 4.7500000000000E+00 -6.3157892668660E-01 + 477 4.7600000000000E+00 -6.3025244891382E-01 + 478 4.7700000000000E+00 -6.2893153589043E-01 + 479 4.7800000000000E+00 -6.2761615043734E-01 + 480 4.7900000000000E+00 -6.2630625568650E-01 + 481 4.8000000000000E+00 -6.2500181509166E-01 + 482 4.8100000000000E+00 -6.2370279243859E-01 + 483 4.8200000000000E+00 -6.2240915185482E-01 + 484 4.8300000000000E+00 -6.2112085781907E-01 + 485 4.8400000000000E+00 -6.1983787516985E-01 + 486 4.8500000000000E+00 -6.1856016911342E-01 + 487 4.8600000000000E+00 -6.1728770523141E-01 + 488 4.8700000000000E+00 -6.1602044948715E-01 + 489 4.8800000000000E+00 -6.1475836823152E-01 + 490 4.8900000000000E+00 -6.1350142820814E-01 + 491 4.9000000000000E+00 -6.1224959655726E-01 + 492 4.9100000000000E+00 -6.1100284081904E-01 + 493 4.9200000000000E+00 -6.0976112893613E-01 + 494 4.9300000000000E+00 -6.0852442925484E-01 + 495 4.9400000000000E+00 -6.0729271052573E-01 + 496 4.9500000000000E+00 -6.0606594190339E-01 + 497 4.9600000000000E+00 -6.0484409294492E-01 + 498 4.9700000000000E+00 -6.0362713360775E-01 + 499 4.9800000000000E+00 -6.0241503424667E-01 + 500 4.9900000000000E+00 -6.0120776560965E-01 + 501 5.0000000000000E+00 -6.0000529883309E-01 + 502 5.0100000000000E+00 -5.9880760543625E-01 + 503 5.0200000000000E+00 -5.9761465731463E-01 + 504 5.0300000000000E+00 -5.9642642673287E-01 + 505 5.0400000000000E+00 -5.9524288631693E-01 + 506 5.0500000000000E+00 -5.9406400904534E-01 + 507 5.0600000000000E+00 -5.9288976824010E-01 + 508 5.0700000000000E+00 -5.9172013755699E-01 + 509 5.0800000000000E+00 -5.9055509097514E-01 + 510 5.0900000000000E+00 -5.8939460278640E-01 + 511 5.1000000000000E+00 -5.8823864758417E-01 + 512 5.1100000000000E+00 -5.8708720025193E-01 + 513 5.1200000000000E+00 -5.8594023595138E-01 + 514 5.1300000000000E+00 -5.8479773011052E-01 + 515 5.1400000000000E+00 -5.8365965841143E-01 + 516 5.1500000000000E+00 -5.8252599677797E-01 + 517 5.1600000000000E+00 -5.8139672136343E-01 + 518 5.1700000000000E+00 -5.8027180853819E-01 + 519 5.1800000000000E+00 -5.7915123487751E-01 + 520 5.1900000000000E+00 -5.7803497714924E-01 + 521 5.2000000000000E+00 -5.7692301230198E-01 + 522 5.2100000000000E+00 -5.7581531745331E-01 + 523 5.2200000000000E+00 -5.7471186987819E-01 + 524 5.2300000000000E+00 -5.7361264699798E-01 + 525 5.2400000000000E+00 -5.7251762636965E-01 + 526 5.2500000000000E+00 -5.7142678567527E-01 + 527 5.2600000000000E+00 -5.7034010271228E-01 + 528 5.2700000000000E+00 -5.6925755538413E-01 + 529 5.2800000000000E+00 -5.6817912169119E-01 + 530 5.2900000000000E+00 -5.6710477972264E-01 + 531 5.3000000000000E+00 -5.6603450769755E-01 + 532 5.3100000000000E+00 -5.6496828381550E-01 + 533 5.3200000000000E+00 -5.6390608629628E-01 + 534 5.3300000000000E+00 -5.6284789300507E-01 + 535 5.3400000000000E+00 -5.6179368248202E-01 + 536 5.3500000000000E+00 -5.6074343505167E-01 + 537 5.3600000000000E+00 -5.5969712944247E-01 + 538 5.3700000000000E+00 -5.5865474321284E-01 + 539 5.3800000000000E+00 -5.5761625301557E-01 + 540 5.3900000000000E+00 -5.5658163468224E-01 + 541 5.4000000000000E+00 -5.5555089392050E-01 + 542 5.4100000000000E+00 -5.5452395943853E-01 + 543 5.4200000000000E+00 -5.5350080313175E-01 + 544 5.4300000000000E+00 -5.5248134013012E-01 + 545 5.4400000000000E+00 -5.5146573921212E-01 + 546 5.4500000000000E+00 -5.5045418308968E-01 + 547 5.4600000000000E+00 -5.4944687023909E-01 + 548 5.4700000000000E+00 -5.4844370752474E-01 + 549 5.4800000000000E+00 -5.4744425961923E-01 + 550 5.4900000000000E+00 -5.4644815372931E-01 + 551 5.5000000000000E+00 -5.4545503046859E-01 + 552 5.5100000000000E+00 -5.4446513801899E-01 + 553 5.5200000000000E+00 -5.4347861835718E-01 + 554 5.5300000000000E+00 -5.4249576056366E-01 + 555 5.5400000000000E+00 -5.4151649835681E-01 + 556 5.5500000000000E+00 -5.4054080508591E-01 + 557 5.5600000000000E+00 -5.3956861805896E-01 + 558 5.5700000000000E+00 -5.3859991077764E-01 + 559 5.5800000000000E+00 -5.3763467829585E-01 + 560 5.5900000000000E+00 -5.3667289962066E-01 + 561 5.6000000000000E+00 -5.3571455509590E-01 + 562 5.6100000000000E+00 -5.3475962530155E-01 + 563 5.6200000000000E+00 -5.3380809255937E-01 + 564 5.6300000000000E+00 -5.3285994139474E-01 + 565 5.6400000000000E+00 -5.3191515276373E-01 + 566 5.6500000000000E+00 -5.3097370863533E-01 + 567 5.6600000000000E+00 -5.3003559116270E-01 + 568 5.6700000000000E+00 -5.2910078271200E-01 + 569 5.6800000000000E+00 -5.2816926585904E-01 + 570 5.6900000000000E+00 -5.2724102324858E-01 + 571 5.7000000000000E+00 -5.2631603764719E-01 + 572 5.7100000000000E+00 -5.2539429194215E-01 + 573 5.7200000000000E+00 -5.2447576914044E-01 + 574 5.7300000000000E+00 -5.2356045236767E-01 + 575 5.7400000000000E+00 -5.2264832486706E-01 + 576 5.7500000000000E+00 -5.2173936999839E-01 + 577 5.7600000000000E+00 -5.2083357123701E-01 + 578 5.7700000000000E+00 -5.1993091217284E-01 + 579 5.7800000000000E+00 -5.1903137650938E-01 + 580 5.7900000000000E+00 -5.1813494806270E-01 + 581 5.8000000000000E+00 -5.1724161076053E-01 + 582 5.8100000000000E+00 -5.1635134864122E-01 + 583 5.8200000000000E+00 -5.1546414585287E-01 + 584 5.8300000000000E+00 -5.1457998665233E-01 + 585 5.8400000000000E+00 -5.1369885540430E-01 + 586 5.8500000000000E+00 -5.1282073658037E-01 + 587 5.8600000000000E+00 -5.1194561475815E-01 + 588 5.8700000000000E+00 -5.1107347462036E-01 + 589 5.8800000000000E+00 -5.1020430095392E-01 + 590 5.8900000000000E+00 -5.0933807864908E-01 + 591 5.9000000000000E+00 -5.0847479269853E-01 + 592 5.9100000000000E+00 -5.0761442819654E-01 + 593 5.9200000000000E+00 -5.0675697033810E-01 + 594 5.9300000000000E+00 -5.0590240441809E-01 + 595 5.9400000000000E+00 -5.0505071583041E-01 + 596 5.9500000000000E+00 -5.0420189006715E-01 + 597 5.9600000000000E+00 -5.0335591271779E-01 + 598 5.9700000000000E+00 -5.0251276946837E-01 + 599 5.9800000000000E+00 -5.0167244610069E-01 + 600 5.9900000000000E+00 -5.0083492849148E-01 + 1 0.0000000000000E+00 1.7279395960699E+00 -2.8544944186137E-12 -3.2818961903209E+00 4.8721007228636E-09 1.7511699882688E+01 + 2 1.0000000000000E-02 1.7277755085569E+00 -3.2816043408479E-02 -3.2810206661771E+00 1.7509264726253E-01 1.7504391709746E+01 + 3 2.0000000000000E-02 1.7272833335637E+00 -6.5614578770270E-02 -3.2783948246224E+00 3.5003912808222E-01 1.7482470752039E+01 + 4 3.0000000000000E-02 1.7264633336563E+00 -9.8378112654101E-02 -3.2740208575596E+00 5.2469343636479E-01 1.7445962547257E+01 + 5 4.0000000000000E-02 1.7253159462011E+00 -1.3108918084313E-01 -3.2679024154750E+00 6.9890988671178E-01 1.7394907182277E+01 + 6 5.0000000000000E-02 1.7238417829997E+00 -1.6373036290264E-01 -3.2600446034375E+00 8.7254327476546E-01 1.7329360778298E+01 + 7 6.0000000000000E-02 1.7220416297787E+00 -1.9628429669857E-01 -3.2504539754862E+00 1.0454490375499E+00 1.7249395490412E+01 + 8 7.0000000000000E-02 1.7199164455342E+00 -2.2873369285270E-01 -3.2391385274152E+00 1.2174834138074E+00 1.7155099507047E+01 + 9 8.0000000000000E-02 1.7174673617326E+00 -2.6106134911744E-01 -3.2261076879614E+00 1.3885035994561E+00 1.7046578534734E+01 + 10 9.0000000000000E-02 1.7146956813672E+00 -2.9325016465516E-01 -3.2113723085159E+00 1.5583679000355E+00 1.6923941467602E+01 + 11 1.0000000000000E-01 1.7116028778738E+00 -3.2528315420610E-01 -3.1949446511539E+00 1.7269358913963E+00 1.6787337233507E+01 + 12 1.1000000000000E-01 1.7081905939044E+00 -3.5714346212935E-01 -3.1768383752049E+00 1.8940685761918E+00 1.6636908220664E+01 + 13 1.2000000000000E-01 1.7044606399612E+00 -3.8881437630184E-01 -3.1570685222802E+00 2.0596285218338E+00 1.6472818769762E+01 + 14 1.3000000000000E-01 1.7004149928927E+00 -4.2027934185997E-01 -3.1356514997952E+00 2.2234800218683E+00 1.6295250445783E+01 + 15 1.4000000000000E-01 1.6960557942533E+00 -4.5152197476912E-01 -3.1126050630123E+00 2.3854892383693E+00 1.6104396271646E+01 + 16 1.5000000000000E-01 1.6913853485275E+00 -4.8252607520624E-01 -3.0879482956304E+00 2.5455243462616E+00 1.5900464125300E+01 + 17 1.6000000000000E-01 1.6864061212222E+00 -5.1327564074121E-01 -3.0617015889424E+00 2.7034556748487E+00 1.5683678271318E+01 + 18 1.7000000000000E-01 1.6811207368274E+00 -5.4375487930266E-01 -3.0338866195867E+00 2.8591558485407E+00 1.5454273855205E+01 + 19 1.8000000000000E-01 1.6755319766489E+00 -5.7394822191450E-01 -3.0045263259302E+00 3.0124999201775E+00 1.5212500663901E+01 + 20 1.9000000000000E-01 1.6696427765145E+00 -6.0384033518952E-01 -2.9736448831054E+00 3.1633655051998E+00 1.4958621318761E+01 + 21 2.0000000000000E-01 1.6634562243569E+00 -6.3341613356669E-01 -2.9412676767408E+00 3.3116329103103E+00 1.4692911643111E+01 + 22 2.1000000000000E-01 1.6569755576755E+00 -6.6266079127954E-01 -2.9074212754135E+00 3.4571852595225E+00 1.4415659163687E+01 + 23 2.2000000000000E-01 1.6502041608793E+00 -6.9155975404264E-01 -2.8721334018672E+00 3.5999086157797E+00 1.4127163916154E+01 + 24 2.3000000000000E-01 1.6431455625152E+00 -7.2009875044444E-01 -2.8354329030273E+00 3.7396920990542E+00 1.3827737408366E+01 + 25 2.4000000000000E-01 1.6358034323836E+00 -7.4826380303420E-01 -2.7973497188556E+00 3.8764280007586E+00 1.3517702277403E+01 + 26 2.5000000000000E-01 1.6281815785446E+00 -7.7604123909205E-01 -2.7579148500858E+00 4.0100118931118E+00 1.3197391992817E+01 + 27 2.6000000000000E-01 1.6202839442182E+00 -8.0341770107078E-01 -2.7171603248804E+00 4.1403427353750E+00 1.2867150372172E+01 + 28 2.7000000000000E-01 1.6121146045816E+00 -8.3038015669916E-01 -2.6751191644536E+00 4.2673229744841E+00 1.2527331138024E+01 + 29 2.8000000000000E-01 1.6036777634678E+00 -8.5691590873639E-01 -2.6318253477047E+00 4.3908586420356E+00 1.2178297364083E+01 + 30 2.9000000000000E-01 1.5949777499675E+00 -8.8301260436818E-01 -2.5873137749091E+00 4.5108594462284E+00 1.1820421195941E+01 + 31 3.0000000000000E-01 1.5860190149399E+00 -9.0865824423522E-01 -2.5416202305121E+00 4.6272388589839E+00 1.1454083180239E+01 + 32 3.1000000000000E-01 1.5768061274340E+00 -9.3384119108526E-01 -2.4947813450764E+00 4.7399141983450E+00 1.1079671910534E+01 + 33 3.2000000000000E-01 1.5673437710265E+00 -9.5855017804073E-01 -2.4468345564295E+00 4.8488067056616E+00 1.0697583388456E+01 + 34 3.3000000000000E-01 1.5576367400778E+00 -9.8277431647396E-01 -2.3978180700645E+00 4.9538416180730E+00 1.0308220652945E+01 + 35 3.4000000000000E-01 1.5476899359121E+00 -1.0065031034829E+00 -2.3477708188424E+00 5.0549482356550E+00 9.9119931742047E+00 + 36 3.5000000000000E-01 1.5375083629243E+00 -1.0297264289606E+00 -2.2967324220495E+00 5.1520599832132E+00 9.5093163632242E+00 + 37 3.6000000000000E-01 1.5270971246186E+00 -1.0524345822522E+00 -2.2447431438611E+00 5.2451144670147E+00 9.1006109783399E+00 + 38 3.7000000000000E-01 1.5164614195822E+00 -1.0746182583942E+00 -2.1918438512667E+00 5.3340535261730E+00 8.6863027433706E+00 + 39 3.8000000000000E-01 1.5056065373991E+00 -1.0962685639295E+00 -2.1380759715071E+00 5.4188232784870E+00 8.2668216161016E+00 + 40 3.9000000000000E-01 1.4945378545077E+00 -1.1173770222961E+00 -2.0834814490801E+00 5.4993741610460E+00 7.8426013670494E+00 + 41 4.0000000000000E-01 1.4832608300068E+00 -1.1379355787824E+00 -2.0281027023681E+00 5.5756609652080E+00 7.4140790115376E+00 + 42 4.1000000000000E-01 1.4717810014139E+00 -1.1579366050482E+00 -1.9719825799427E+00 5.6476428662860E+00 6.9816942233095E+00 + 43 4.2000000000000E-01 1.4601039803811E+00 -1.1773729032069E+00 -1.9151643166005E+00 5.7152834474953E+00 6.5458888249862E+00 + 44 4.3000000000000E-01 1.4482354483714E+00 -1.1962377094669E+00 -1.8576914891863E+00 5.7785507186540E+00 6.1071062157007E+00 + 45 4.4000000000000E-01 1.4361811523020E+00 -1.2145246973307E+00 -1.7996079722571E+00 5.8374171291549E+00 5.6657908228483E+00 + 46 4.5000000000000E-01 1.4239469001567E+00 -1.2322279803499E+00 -1.7409578936446E+00 5.8918595755597E+00 5.2223875580362E+00 + 47 4.6000000000000E-01 1.4115385565741E+00 -1.2493421144351E+00 -1.6817855899675E+00 5.9418594036977E+00 4.7773412707912E+00 + 48 4.7000000000000E-01 1.3989620384136E+00 -1.2658620997221E+00 -1.6221355621524E+00 5.9874024052428E+00 4.3310962046385E+00 + 49 4.8000000000000E-01 1.3862233103060E+00 -1.2817833819920E+00 -1.5620524310140E+00 6.0284788088792E+00 3.8840954223128E+00 + 50 4.9000000000000E-01 1.3733283801921E+00 -1.2971018536492E+00 -1.5015808929521E+00 6.0650832661451E+00 3.4367803236764E+00 + 51 5.0000000000000E-01 1.3602832948529E+00 -1.3118138542556E+00 -1.4407656758161E+00 6.0972148318380E+00 2.9895900831753E+00 + 52 5.1000000000000E-01 1.3470941354375E+00 -1.3259161706261E+00 -1.3796514949930E+00 6.1248769391393E+00 2.5429611242470E+00 + 53 5.2000000000000E-01 1.3337670129917E+00 -1.3394060364851E+00 -1.3182830097690E+00 6.1480773694992E+00 2.0973265938049E+00 + 54 5.3000000000000E-01 1.3203080639927E+00 -1.3522811316889E+00 -1.2567047800190E+00 6.1668282174819E+00 1.6531158654887E+00 + 55 5.4000000000000E-01 1.3067234458934E+00 -1.3645395810161E+00 -1.1949612232730E+00 6.1811458502961E+00 1.2107540221068E+00 + 56 5.5000000000000E-01 1.2930193326808E+00 -1.3761799525318E+00 -1.1330965722126E+00 6.1910508624784E+00 7.7066136574198E-01 + 57 5.6000000000000E-01 1.2792019104533E+00 -1.3872012555285E+00 -1.0711548326448E+00 6.1965680256637E+00 3.3325292936187E-01 + 58 5.7000000000000E-01 1.2652773730202E+00 -1.3976029380489E+00 -1.0091797420022E+00 6.1977262334246E+00 -1.0106200833082E-01 + 59 5.8000000000000E-01 1.2512519175289E+00 -1.4073848839976E+00 -9.4721472841945E-01 6.1945584414940E+00 -5.3188037528942E-01 + 60 5.9000000000000E-01 1.2371317401216E+00 -1.4165474098458E+00 -8.8530287042991E-01 6.1871016032682E+00 -9.5880577093825E-01 + 61 6.0000000000000E-01 1.2229230316284E+00 -1.4250912609367E+00 -8.2348685732928E-01 6.1753966009860E+00 -1.3814489224585E+00 + 62 6.1000000000000E-01 1.2086319732984E+00 -1.4330176073976E+00 -7.6180895025108E-01 6.1594881723278E+00 -1.7994280812987E+00 + 63 6.2000000000000E-01 1.1942647325739E+00 -1.4403280396671E+00 -7.0031094399615E-01 6.1394248328618E+00 -2.2123694705289E+00 + 64 6.3000000000000E-01 1.1798274589116E+00 -1.4470245636440E+00 -6.3903412965832E-01 6.1152587944368E+00 -2.6199076885853E+00 + 65 6.4000000000000E-01 1.1653262796532E+00 -1.4531095954668E+00 -5.7801925808727E-01 6.0870458794464E+00 -3.0216860898588E+00 + 66 6.5000000000000E-01 1.1507672959511E+00 -1.4585859559326E+00 -5.1730650422703E-01 6.0548454314145E+00 -3.4173571651555E+00 + 67 6.6000000000000E-01 1.1361565787509E+00 -1.4634568645630E+00 -4.5693543236810E-01 6.0187202216805E+00 -3.8065829076372E+00 + 68 6.7000000000000E-01 1.1215001648356E+00 -1.4677259333281E+00 -3.9694496234965E-01 5.9787363527831E+00 -4.1890351445171E+00 + 69 6.8000000000000E-01 1.1068040529333E+00 -1.4713971600368E+00 -3.3737333674552E-01 5.9349631582571E+00 -4.5643958926217E+00 + 70 6.9000000000000E-01 1.0920741998939E+00 -1.4744749214049E+00 -2.7825808906830E-01 5.8874730992986E+00 -4.9323576736961E+00 + 71 7.0000000000000E-01 1.0773165169356E+00 -1.4769639658092E+00 -2.1963601302277E-01 5.8363416583828E+00 -5.2926237660310E+00 + 72 7.1000000000000E-01 1.0625368659656E+00 -1.4788694057403E+00 -1.6154313283743E-01 5.7816472298363E+00 -5.6449085232896E+00 + 73 7.2000000000000E-01 1.0477410559785E+00 -1.4801967099645E+00 -1.0401467470301E-01 5.7234710078456E+00 -5.9889376790462E+00 + 74 7.3000000000000E-01 1.0329348395333E+00 -1.4809516954049E+00 -4.7085039345803E-02 5.6618968718977E+00 -6.3244485094091E+00 + 75 7.4000000000000E-01 1.0181239093141E+00 -1.4811405187547E+00 9.2122242422278E-03 5.5970112696987E+00 -6.6511901195538E+00 + 76 7.5000000000000E-01 1.0033138947750E+00 -1.4807696678333E+00 6.4844443891162E-02 5.5289030979441E+00 -6.9689236321907E+00 + 77 7.6000000000000E-01 9.8851035887298E-01 -1.4798459526975E+00 1.1977984813874E-01 5.4576635810775E+00 -7.2774223802209E+00 + 78 7.7000000000000E-01 9.7371879489156E-01 -1.4783764965205E+00 1.7398758889481E-01 5.3833861482684E+00 -7.5764721407313E+00 + 79 7.8000000000000E-01 9.5894462335558E-01 -1.4763687262495E+00 2.2743776286438E-01 5.3061663086042E+00 -7.8658712082941E+00 + 80 7.9000000000000E-01 9.4419318904126E-01 -1.4738303630563E+00 2.8010143171668E-01 5.2261015247688E+00 -8.1454305398395E+00 + 81 8.0000000000000E-01 9.2946975808253E-01 -1.4707694125917E+00 3.3195064098631E-01 5.1432910856033E+00 -8.4149739757050E+00 + 82 8.1000000000000E-01 9.1477951517570E-01 -1.4671941550582E+00 3.8295843768987E-01 5.0578359771631E+00 -8.6743382313085E+00 + 83 8.2000000000000E-01 9.0012756088432E-01 -1.4631131351118E+00 4.3309888665423E-01 4.9698387538315E+00 -8.9233730568343E+00 + 84 8.3000000000000E-01 8.8551890904575E-01 -1.4585351516083E+00 4.8234708554104E-01 4.8794034065229E+00 -9.1619412132101E+00 + 85 8.4000000000000E-01 8.7095848428107E-01 -1.4534692472049E+00 5.3067917856884E-01 4.7866352337446E+00 -9.3899186074867E+00 + 86 8.5000000000000E-01 8.5645111960962E-01 -1.4479246978315E+00 5.7807236892071E-01 4.6916407075889E+00 -9.6071943195423E+00 + 87 8.6000000000000E-01 8.4200155416937E-01 -1.4419110020446E+00 6.2450492983877E-01 4.5945273459587E+00 -9.8136707386755E+00 + 88 8.7000000000000E-01 8.2761443104434E-01 -1.4354378702769E+00 6.6995621439617E-01 4.4954035774760E+00 -1.0009262901382E+01 + 89 8.8000000000000E-01 8.1329429520000E-01 -1.4285152139951E+00 7.1440666397205E-01 4.3943786107946E+00 -1.0193899142129E+01 + 90 8.9000000000000E-01 7.9904559152745E-01 -1.4211531347803E+00 7.5783781539448E-01 4.2915622981341E+00 -1.0367522834581E+01 + 91 9.0000000000000E-01 7.8487266299715E-01 -1.4133619133432E+00 8.0023230676437E-01 4.1870650464358E+00 -1.0530087566461E+01 + 92 9.1000000000000E-01 7.7077974892275E-01 -1.4051519984884E+00 8.4157388206348E-01 4.0809976072299E+00 -1.0681548881640E+01 + 93 9.2000000000000E-01 7.5677098333560E-01 -1.3965339960368E+00 8.8184739464459E-01 3.9734709029555E+00 -1.0821926828825E+01 + 94 9.3000000000000E-01 7.4285039346990E-01 -1.3875186577210E+00 9.2103880763720E-01 3.8645963250505E+00 -1.0951152913728E+01 + 95 9.4000000000000E-01 7.2902189835932E-01 -1.3781168700829E+00 9.5913519772468E-01 3.7544848299174E+00 -1.1069286307147E+01 + 96 9.5000000000000E-01 7.1528930754442E-01 -1.3683396433438E+00 9.9612475156787E-01 3.6432475495151E+00 -1.1176322110320E+01 + 97 9.6000000000000E-01 7.0165631989138E-01 -1.3581981003080E+00 1.0319967654119E+00 3.5309952686164E+00 -1.1272293267489E+01 + 98 9.7000000000000E-01 6.8812652252161E-01 -1.3477034652830E+00 1.0667416417776E+00 3.4178384220881E+00 -1.1357243505118E+01 + 99 9.8000000000000E-01 6.7470338985195E-01 -1.3368670530374E+00 1.1003508851838E+00 3.3038869543487E+00 -1.1431227537555E+01 + 100 9.9000000000000E-01 6.6139028274509E-01 -1.3257002578068E+00 1.1328170966729E+00 3.1892502052820E+00 -1.1494311763554E+01 + 101 1.0000000000000E+00 6.4819044776961E-01 -1.3142145423609E+00 1.1641339671719E+00 3.0740367928508E+00 -1.1546574204920E+01 + 102 1.0100000000000E+00 6.3510701656899E-01 -1.3024214271426E+00 1.1942962696929E+00 2.9583544977009E+00 -1.1588104089860E+01 + 103 1.0200000000000E+00 6.2214300533889E-01 -1.2903324794911E+00 1.2232998504103E+00 2.8423101526091E+00 -1.1619001844513E+01 + 104 1.0300000000000E+00 6.0930131441162E-01 -1.2779593029596E+00 1.2511416186225E+00 2.7260095319525E+00 -1.1639378615051E+01 + 105 1.0400000000000E+00 5.9658472794701E-01 -1.2653135267382E+00 1.2778195356378E+00 2.6095572455443E+00 -1.1649356149699E+01 + 106 1.0500000000000E+00 5.8399591372846E-01 -1.2524067951944E+00 1.3033326026028E+00 2.4930566342153E+00 -1.1649066404820E+01 + 107 1.0600000000000E+00 5.7153742306290E-01 -1.2392507575395E+00 1.3276808473051E+00 2.3766096685538E+00 -1.1638651471065E+01 + 108 1.0700000000000E+00 5.5921169078346E-01 -1.2258570576330E+00 1.3508653099777E+00 2.2603168544346E+00 -1.1618263283659E+01 + 109 1.0800000000000E+00 5.4702103535342E-01 -1.2122373239308E+00 1.3728880281398E+00 2.1442771165580E+00 -1.1588060844411E+01 + 110 1.0900000000000E+00 5.3496765906973E-01 -1.1984031595967E+00 1.3937520205356E+00 2.0285877672565E+00 -1.1548219893297E+01 + 111 1.1000000000000E+00 5.2305364836484E-01 -1.1843661327693E+00 1.4134612698670E+00 1.9133442963182E+00 -1.1498909010785E+01 + 112 1.1100000000000E+00 5.1128097420478E-01 -1.1701377670143E+00 1.4320207055856E+00 1.7986404802786E+00 -1.1440327876889E+01 + 113 1.1200000000000E+00 4.9965149258191E-01 -1.1557295319490E+00 1.4494361842212E+00 1.6845680321300E+00 -1.1372661958010E+01 + 114 1.1300000000000E+00 4.8816694510050E-01 -1.1411528340692E+00 1.4657144706643E+00 1.5712168385768E+00 -1.1296116805013E+01 + 115 1.1400000000000E+00 4.7682895965296E-01 -1.1264190077636E+00 1.4808632176305E+00 1.4586745707864E+00 -1.1210908214324E+01 + 116 1.1500000000000E+00 4.6563905118500E-01 -1.1115393065453E+00 1.4948909442409E+00 1.3470268756449E+00 -1.1117242067889E+01 + 117 1.1600000000000E+00 4.5459862254732E-01 -1.0965248944890E+00 1.5078070151649E+00 1.2363571162007E+00 -1.1015356972754E+01 + 118 1.1700000000000E+00 4.4370896543191E-01 -1.0813868378945E+00 1.5196216170896E+00 1.1267464360975E+00 -1.0905465779494E+01 + 119 1.1800000000000E+00 4.3297126139054E-01 -1.0661360971731E+00 1.5303457370680E+00 1.0182736316360E+00 -1.0787822805749E+01 + 120 1.1900000000000E+00 4.2238658293323E-01 -1.0507835189688E+00 1.5399911374800E+00 9.1101507741148E-01 -1.0662653284315E+01 + 121 1.2000000000000E+00 4.1195589470432E-01 -1.0353398285201E+00 1.5485703331655E+00 8.0504480074865E-01 -1.0530212930972E+01 + 122 1.2100000000000E+00 4.0168005473375E-01 -1.0198156222595E+00 1.5560965660613E+00 7.0043421527403E-01 -1.0390753382382E+01 + 123 1.2200000000000E+00 3.9155981576101E-01 -1.0042213606706E+00 1.5625837800369E+00 5.9725231150222E-01 -1.0244521978801E+01 + 124 1.2300000000000E+00 3.8159582662935E-01 -9.8856736139100E-01 1.5680465960173E+00 4.9556543859736E-01 -1.0091790335811E+01 + 125 1.2400000000000E+00 3.7178863374764E-01 -9.7286379257650E-01 1.5725002850262E+00 3.9543734522005E-01 -9.9328088937378E+00 + 126 1.2500000000000E+00 3.6213868261726E-01 -9.5712066652710E-01 1.5759607429574E+00 2.9692916957534E-01 -9.7678538373085E+00 + 127 1.2600000000000E+00 3.5264631942145E-01 -9.4134783357364E-01 1.5784444630683E+00 2.0009930248142E-01 -9.5971893395287E+00 + 128 1.2700000000000E+00 3.4331179267444E-01 -9.2555497623816E-01 1.5799685095823E+00 1.0500351390851E-01 -9.4210855645841E+00 + 129 1.2800000000000E+00 3.3413525492763E-01 -9.0975160365794E-01 1.5805504905402E+00 1.1694790882204E-02 -9.2398216434649E+00 + 130 1.2900000000000E+00 3.2511676453016E-01 -8.9394704628639E-01 1.5802085300942E+00 -7.9776613450617E-02 -9.0536663075544E+00 + 131 1.3000000000000E+00 3.1625628744110E-01 -8.7815045086801E-01 1.5789612414529E+00 -1.6936316000394E-01 -8.8628984284406E+00 + 132 1.3100000000000E+00 3.0755369909055E-01 -8.6237077568464E-01 1.5768276990792E+00 -2.5702014124578E-01 -8.6677980463722E+00 + 133 1.3200000000000E+00 2.9900878628686E-01 -8.4661678608478E-01 1.5738274107364E+00 -3.4270558371076E-01 -8.4686367313098E+00 + 134 1.3300000000000E+00 2.9062124916715E-01 -8.3089705028592E-01 1.5699802901989E+00 -4.2638028136257E-01 -8.2656969360440E+00 + 135 1.3400000000000E+00 2.8239070318848E-01 -8.1521993545469E-01 1.5653066291555E+00 -5.0800785589430E-01 -8.0592566979542E+00 + 136 1.3500000000000E+00 2.7431668115677E-01 -7.9959360406806E-01 1.5598270693172E+00 -5.8755465191348E-01 -7.8495880230315E+00 + 137 1.3600000000000E+00 2.6639863529074E-01 -7.8402601054848E-01 1.5535625752552E+00 -6.6498979984012E-01 -7.6369737946392E+00 + 138 1.3700000000000E+00 2.5863593931817E-01 -7.6852489817640E-01 1.5465344060915E+00 -7.4028520552395E-01 -7.4216832808524E+00 + 139 1.3800000000000E+00 2.5102789060154E-01 -7.5309779628099E-01 1.5387640886161E+00 -8.1341546454504E-01 -7.2039922216271E+00 + 140 1.3900000000000E+00 2.4357371229050E-01 -7.3775201769940E-01 1.5302733896451E+00 -8.8435795889309E-01 -6.9841737079840E+00 + 141 1.4000000000000E+00 2.3627255549833E-01 -7.2249465651495E-01 1.5210842888158E+00 -9.5309273022518E-01 -6.7624926436418E+00 + 142 1.4100000000000E+00 2.2912350149968E-01 -7.0733258606074E-01 1.5112189519964E+00 -1.0196025029387E+00 -6.5392187748928E+00 + 143 1.4200000000000E+00 2.2212556394691E-01 -6.9227245719243E-01 1.5006997043783E+00 -1.0838726769096E+00 -6.3146161476731E+00 + 144 1.4300000000000E+00 2.1527769110243E-01 -6.7732069682738E-01 1.4895490040600E+00 -1.1458912560944E+00 -6.0889426277615E+00 + 145 1.4400000000000E+00 2.0857876808426E-01 -6.6248350674522E-01 1.4777894162423E+00 -1.2056488256982E+00 -5.8624577960781E+00 + 146 1.4500000000000E+00 2.0202761912235E-01 -6.4776686264577E-01 1.4654435873009E+00 -1.2631385519135E+00 -5.6354147625563E+00 + 147 1.4600000000000E+00 1.9562300982300E-01 -6.3317651346561E-01 1.4525342194549E+00 -1.3183560860036E+00 -5.4080611939798E+00 + 148 1.4700000000000E+00 1.8936364943888E-01 -6.1871798094260E-01 1.4390840460230E+00 -1.3712995684193E+00 -5.1806451545129E+00 + 149 1.4800000000000E+00 1.8324819314215E-01 -6.0439655942980E-01 1.4251158065945E+00 -1.4219695777781E+00 -4.9534056397449E+00 + 150 1.4900000000000E+00 1.7727524429823E-01 -5.9021731595271E-01 1.4106522231694E+00 -1.4703690548724E+00 -4.7265780535847E+00 + 151 1.5000000000000E+00 1.7144335673779E-01 -5.7618509050313E-01 1.3957159765599E+00 -1.5165032895026E+00 -4.5003954738717E+00 + 152 1.5100000000000E+00 1.6575103702466E-01 -5.6230449656774E-01 1.3803296831556E+00 -1.5603798656429E+00 -4.2750830686398E+00 + 153 1.5200000000000E+00 1.6019674671724E-01 -5.4857992188581E-01 1.3645158723518E+00 -1.6020085829936E+00 -4.0508601522995E+00 + 154 1.5300000000000E+00 1.5477890462131E-01 -5.3501552942908E-01 1.3482969646523E+00 -1.6414014243779E+00 -3.8279437317714E+00 + 155 1.5400000000000E+00 1.4949588903185E-01 -5.2161525859917E-01 1.3316952499524E+00 -1.6785725079989E+00 -3.6065422312265E+00 + 156 1.5500000000000E+00 1.4434603996188E-01 -5.0838282663932E-01 1.3147328667053E+00 -1.7135379947372E+00 -3.3868582455562E+00 + 157 1.5600000000000E+00 1.3932766135615E-01 -4.9532173024962E-01 1.2974317816707E+00 -1.7463160622392E+00 -3.1690908438398E+00 + 158 1.5700000000000E+00 1.3443902328762E-01 -4.8243524740454E-01 1.2798137699874E+00 -1.7769268344439E+00 -2.9534301002464E+00 + 159 1.5800000000000E+00 1.2967836413483E-01 -4.6972643936462E-01 1.2619003962018E+00 -1.8053923012996E+00 -2.7400602322619E+00 + 160 1.5900000000000E+00 1.2504389273822E-01 -4.5719815287497E-01 1.2437129958022E+00 -1.8317362741375E+00 -2.5291606641850E+00 + 161 1.6000000000000E+00 1.2053379053347E-01 -4.4485302254602E-01 1.2252726573224E+00 -1.8559843222063E+00 -2.3209031805689E+00 + 162 1.6100000000000E+00 1.1614621366030E-01 -4.3269347340955E-01 1.2066002051333E+00 -1.8781636917281E+00 -2.1154516393961E+00 + 163 1.6200000000000E+00 1.1187929504468E-01 -4.2072172364317E-01 1.1877161830693E+00 -1.8983032382666E+00 -1.9129648439998E+00 + 164 1.6300000000000E+00 1.0773114645315E-01 -4.0893978745490E-01 1.1686408385513E+00 -1.9164333791725E+00 -1.7135950230295E+00 + 165 1.6400000000000E+00 1.0369986051739E-01 -3.9734947812468E-01 1.1493941073515E+00 -1.9325860075445E+00 -1.5174855937012E+00 + 166 1.6500000000000E+00 9.9783512727693E-02 -3.8595241119286E-01 1.1299955992759E+00 -1.9467944177431E+00 -1.3247739148143E+00 + 167 1.6600000000000E+00 9.5980163393853E-02 -3.7475000778913E-01 1.1104645843960E+00 -1.9590932503015E+00 -1.1355913650084E+00 + 168 1.6700000000000E+00 9.2287859572027E-02 -3.6374349809608E-01 1.0908199799463E+00 -1.9695184200519E+00 -9.5006110350307E-01 + 169 1.6800000000000E+00 8.8704636956375E-02 -3.5293392493987E-01 1.0710803379786E+00 -1.9781070323778E+00 -7.6829855044162E-01 + 170 1.6900000000000E+00 8.5228521734165E-02 -3.4232214750048E-01 1.0512638338379E+00 -1.9848973176281E+00 -5.9041374362981E-01 + 171 1.7000000000000E+00 8.1857532403220E-02 -3.3190884513384E-01 1.0313882551623E+00 -1.9899285751245E+00 -4.1650912627035E-01 + 172 1.7100000000000E+00 7.8589681550589E-02 -3.2169452130135E-01 1.0114709916086E+00 -1.9932410813144E+00 -2.4667854087827E-01 + 173 1.7200000000000E+00 7.5422977591439E-02 -3.1167950759703E-01 9.9152902551215E-01 -1.9948760221004E+00 -8.1010574128590E-02 + 174 1.7300000000000E+00 7.2355426467216E-02 -3.0186396786518E-01 9.7157892299543E-01 -1.9948754402146E+00 8.0413336219593E-02 + 175 1.7400000000000E+00 6.9385033302185E-02 -2.9224790240445E-01 9.5163682582611E-01 -1.9932821464075E+00 2.3752021007458E-01 + 176 1.7500000000000E+00 6.6509804017551E-02 -2.8283115224812E-01 9.3171844414450E-01 -1.9901396501941E+00 3.9024311019480E-01 + 177 1.7600000000000E+00 6.3727746902412E-02 -2.7361340351444E-01 9.1183904972685E-01 -1.9854921010081E+00 5.3852108581115E-01 + 178 1.7700000000000E+00 6.1036874140891E-02 -2.6459419182126E-01 8.9201346995624E-01 -1.9793842196507E+00 6.8230198375055E-01 + 179 1.7800000000000E+00 5.8435203294826E-02 -2.5577290675696E-01 8.7225608247849E-01 -1.9718612082262E+00 8.2153920065807E-01 + 180 1.7900000000000E+00 5.5920758741501E-02 -2.4714879640142E-01 8.5258081075587E-01 -1.9629687185842E+00 9.5619137756025E-01 + 181 1.8000000000000E+00 5.3491573065949E-02 -2.3872097188814E-01 8.3300111970085E-01 -1.9527527643004E+00 1.0862288868981E+00 + 182 1.8100000000000E+00 5.1145688407437E-02 -2.3048841200836E-01 8.1353001278551E-01 -1.9412596192681E+00 1.2116235468230E+00 + 183 1.8200000000000E+00 4.8881157759756E-02 -2.2244996783547E-01 7.9418002940926E-01 -1.9285358493842E+00 1.3323507581198E+00 + 184 1.8300000000000E+00 4.6696046225181E-02 -2.1460436738102E-01 7.7496324212259E-01 -1.9146281933004E+00 1.4484016069627E+00 + 185 1.8400000000000E+00 4.4588432221699E-02 -2.0695022027038E-01 7.5589125590189E-01 -1.8995834260721E+00 1.5597708154162E+00 + 186 1.8500000000000E+00 4.2556408643479E-02 -1.9948602241731E-01 7.3697520776022E-01 -1.8834484074497E+00 1.6664502961615E+00 + 187 1.8600000000000E+00 4.0598083974621E-02 -1.9221016070966E-01 7.1822576560090E-01 -1.8662700375382E+00 1.7684446579602E+00 + 188 1.8700000000000E+00 3.8711583355897E-02 -1.8512091770152E-01 6.9965312892465E-01 -1.8480950867808E+00 1.8657680212233E+00 + 189 1.8800000000000E+00 3.6895049604747E-02 -1.7821647628587E-01 6.8126703027991E-01 -1.8289702035551E+00 1.9584334101200E+00 + 190 1.8900000000000E+00 3.5146644188525E-02 -1.7149492436197E-01 6.6307673631274E-01 -1.8089418767955E+00 2.0464613774133E+00 + 191 1.9000000000000E+00 3.3464548151192E-02 -1.6495425948253E-01 6.4509105005639E-01 -1.7880563454688E+00 2.1298788979036E+00 + 192 1.9100000000000E+00 3.1846962993640E-02 -1.5859239347738E-01 6.2731831353310E-01 -1.7663595635695E+00 2.2087170555042E+00 + 193 1.9200000000000E+00 3.0292111507914E-02 -1.5240715704846E-01 6.0976641085351E-01 -1.7438971482904E+00 2.2830121929708E+00 + 194 1.9300000000000E+00 2.8798238565660E-02 -1.4639630433116E-01 5.9244277187506E-01 -1.7207143257823E+00 2.3528057146223E+00 + 195 1.9400000000000E+00 2.7363611861144E-02 -1.4055751741655E-01 5.7535437633399E-01 -1.6968558878225E+00 2.4181432123083E+00 + 196 1.9500000000000E+00 2.5986522609259E-02 -1.3488841083007E-01 5.5850775839970E-01 -1.6723661479860E+00 2.4790748932676E+00 + 197 1.9600000000000E+00 2.4665286198991E-02 -1.2938653596269E-01 5.4190901169121E-01 -1.6472888939771E+00 2.5356555236391E+00 + 198 1.9700000000000E+00 2.3398242802821E-02 -1.2404938544920E-01 5.2556379476475E-01 -1.6216673458709E+00 2.5879437882615E+00 + 199 1.9800000000000E+00 2.2183757942631E-02 -1.1887439748990E-01 5.0947733696665E-01 -1.5955441181130E+00 2.6360021933676E+00 + 200 1.9900000000000E+00 2.1020223012692E-02 -1.1385896011180E-01 4.9365444469078E-01 -1.5689611807963E+00 2.6798970716035E+00 + 201 2.0000000000000E+00 1.9906055760358E-02 -1.0900041536524E-01 4.7809950800846E-01 -1.5419598221119E+00 2.7196984305048E+00 + 202 2.0100000000000E+00 1.8839700725129E-02 -1.0429606345245E-01 4.6281650766518E-01 -1.5145806131593E+00 2.7554796227605E+00 + 203 2.0200000000000E+00 1.7819629636791E-02 -9.9743166784438E-02 4.4780902241846E-01 -1.4868633757853E+00 2.7873170728304E+00 + 204 2.0300000000000E+00 1.6844341773353E-02 -9.5338953962790E-02 4.3308023667673E-01 -1.4588471529821E+00 2.8152902148469E+00 + 205 2.0400000000000E+00 1.5912364279554E-02 -9.1080623683866E-02 4.1863294843850E-01 -1.4305701782349E+00 2.8394814254095E+00 + 206 2.0500000000000E+00 1.5022252446731E-02 -8.6965348561842E-02 4.0446957753356E-01 -1.4020698479371E+00 2.8599756882697E+00 + 207 2.0600000000000E+00 1.4172589954875E-02 -8.2990278868151E-02 3.9059217411667E-01 -1.3733826967457E+00 2.8768603438530E+00 + 208 2.0700000000000E+00 1.3361989077717E-02 -7.9152546184770E-02 3.7700242739954E-01 -1.3445443746888E+00 2.8902249706888E+00 + 209 2.0800000000000E+00 1.2589090851725E-02 -7.5449266969028E-02 3.6370167461050E-01 -1.3155896252296E+00 2.9001612826716E+00 + 210 2.0900000000000E+00 1.1852565209902E-02 -7.1877546027777E-02 3.5069091015947E-01 -1.2865522647810E+00 2.9067629355327E+00 + 211 2.1000000000000E+00 1.1151111081309E-02 -6.8434479898925E-02 3.3797079500573E-01 -1.2574651646849E+00 2.9101252037201E+00 + 212 2.1100000000000E+00 1.0483456457232E-02 -6.5117160138399E-02 3.2554166618393E-01 -1.2283602362454E+00 2.9103448362263E+00 + 213 2.1200000000000E+00 9.8483584249774E-03 -6.1922676511149E-02 3.1340354647579E-01 -1.1992684163227E+00 2.9075199857132E+00 + 214 2.1300000000000E+00 9.2446031702210E-03 -5.8848120084760E-02 3.0155615422188E-01 -1.1702196536358E+00 2.9017500485710E+00 + 215 2.1400000000000E+00 8.6710059489323E-03 -5.5890586224235E-02 2.8999891326588E-01 -1.1412428981242E+00 2.8931353148545E+00 + 216 2.1500000000000E+00 8.1264110298397E-03 -5.3047177486877E-02 2.7873096297776E-01 -1.1123660930342E+00 2.8817768744654E+00 + 217 2.1600000000000E+00 7.6096916084515E-03 -5.0315006416576E-02 2.6775116836126E-01 -1.0836161670318E+00 2.8677765267102E+00 + 218 2.1700000000000E+00 7.1197496936417E-03 -4.7691198236638E-02 2.5705813023339E-01 -1.0550190278274E+00 2.8512365997552E+00 + 219 2.1800000000000E+00 6.6555159678170E-03 -4.5172893440502E-02 2.4665019545743E-01 -1.0265995583273E+00 2.8322596933625E+00 + 220 2.1900000000000E+00 6.2159496216885E-03 -4.2757250280019E-02 2.3652546719919E-01 -9.9838161468831E-01 2.8109485603194E+00 + 221 2.2000000000000E+00 5.8000381646738E-03 -4.0441447151059E-02 2.2668181520193E-01 -9.7038802519725E-01 2.7874059947800E+00 + 222 2.2100000000000E+00 5.4067972119572E-03 -3.8222684876344E-02 2.1711688606480E-01 -9.4264059058075E-01 2.7617346832142E+00 + 223 2.2200000000000E+00 5.0352702492347E-03 -3.6098188885532E-02 2.0782811350969E-01 -9.1516008598389E-01 2.7340370250974E+00 + 224 2.2300000000000E+00 4.6845283761723E-03 -3.4065211292781E-02 1.9881272862072E-01 -8.8796626466533E-01 2.7044149719760E+00 + 225 2.2400000000000E+00 4.3536700295986E-03 -3.2121032872090E-02 1.9006777003791E-01 -8.6107786310159E-01 2.6729699200657E+00 + 226 2.2500000000000E+00 4.0418206874539E-03 -3.0262964931009E-02 1.8159009409547E-01 -8.3451260707390E-01 2.6398025947742E+00 + 227 2.2600000000000E+00 3.7481325545072E-03 -2.8488351083284E-02 1.7337638489284E-01 -8.0828721896150E-01 2.6050129146658E+00 + 228 2.2700000000000E+00 3.4717842308493E-03 -2.6794568921173E-02 1.6542316428713E-01 -7.8241742668359E-01 2.5686998293871E+00 + 229 2.2800000000000E+00 3.2119803641614E-03 -2.5179031588304E-02 1.5772680178585E-01 -7.5691797394983E-01 2.5309612243674E+00 + 230 2.2900000000000E+00 2.9679512867472E-03 -2.3639189254148E-02 1.5028352433441E-01 -7.3180263136371E-01 2.4918938233324E+00 + 231 2.3000000000000E+00 2.7389526383080E-03 -2.2172530491189E-02 1.4308942598782E-01 -7.0708420847835E-01 2.4515930792301E+00 + 232 2.3100000000000E+00 2.5242649754274E-03 -2.0776583555984E-02 1.3614047745572E-01 -6.8277456725020E-01 2.4101530443789E+00 + 233 2.3200000000000E+00 2.3231933687214E-03 -1.9448917575476E-02 1.2943253550612E-01 -6.5888463651110E-01 2.3676662780044E+00 + 234 2.3300000000000E+00 2.1350669885921E-03 -1.8187143640007E-02 1.2296135222047E-01 -6.3542442732833E-01 2.3242237618682E+00 + 235 2.3400000000000E+00 1.9592386805112E-03 -1.6988915804565E-02 1.1672258409159E-01 -6.1240304917153E-01 2.2799148164707E+00 + 236 2.3500000000000E+00 1.7950845307437E-03 -1.5851931999866E-02 1.1071180095470E-01 -5.8982872698591E-01 2.2348270129303E+00 + 237 2.3600000000000E+00 1.6420034234052E-03 -1.4773934855003E-02 1.0492449474384E-01 -5.6770881910741E-01 2.1890460885211E+00 + 238 2.3700000000000E+00 1.4994165897265E-03 -1.3752712433434E-02 9.9356088065226E-02 -5.4604983596989E-01 2.1426558710378E+00 + 239 2.3800000000000E+00 1.3667671503830E-03 -1.2786098884187E-02 9.4001942579449E-02 -5.2485745956639E-01 2.0957382178721E+00 + 240 2.3900000000000E+00 1.2435196517301E-03 -1.1871975010221E-02 8.8857367186402E-02 -5.0413656339814E-01 2.0483729576790E+00 + 241 2.4000000000000E+00 1.1291595967604E-03 -1.1008268755958E-02 8.3917626007640E-02 -4.8389123306828E-01 2.0006378299697E+00 + 242 2.4100000000000E+00 1.0231929715781E-03 -1.0192955616015E-02 7.9177946160504E-02 -4.6412478749078E-01 1.9526084218751E+00 + 243 2.4200000000000E+00 9.2514576817581E-04 -9.4240589672737E-03 7.4633525315895E-02 -4.4483980066188E-01 1.9043581268415E+00 + 244 2.4300000000000E+00 8.3456350426317E-04 -8.6996503264653E-03 7.0279539037285E-02 -4.2603812378471E-01 1.8559581053637E+00 + 245 2.4400000000000E+00 7.5101074088066E-04 -8.0178495354843E-03 6.6111147896500E-02 -4.0772090775039E-01 1.8074772486374E+00 + 246 2.4500000000000E+00 6.7407059851474E-04 -7.3768248766636E-03 6.2123504362797E-02 -3.8988862606300E-01 1.7589821388302E+00 + 247 2.4600000000000E+00 6.0334427240186E-04 -6.7747931203178E-03 5.8311759460634E-02 -3.7254109806876E-01 1.7105370211959E+00 + 248 2.4700000000000E+00 5.3845054768284E-04 -6.2100195068755E-03 5.4671069193920E-02 -3.5567751244125E-01 1.6622037827564E+00 + 249 2.4800000000000E+00 4.7902531505410E-04 -5.6808176659450E-03 5.1196600734770E-02 -3.3929645084629E-01 1.6140419343717E+00 + 250 2.4900000000000E+00 4.2472108753699E-04 -5.1855494746767E-03 4.7883538374360E-02 -3.2339591178496E-01 1.5661085960805E+00 + 251 2.5000000000000E+00 3.7520651895314E-04 -4.7226248578139E-03 4.4727089234787E-02 -3.0797333456292E-01 1.5184584861135E+00 + 252 2.5100000000000E+00 3.3016592468049E-04 -4.2905015318261E-03 4.1722488740976E-02 -2.9302562333965E-01 1.4711439134446E+00 + 253 2.5200000000000E+00 2.8929880524288E-04 -3.8876846955234E-03 3.8865005851497E-02 -2.7854917123812E-01 1.4242147768838E+00 + 254 2.5300000000000E+00 2.5231937324581E-04 -3.5127266695696E-03 3.6149948048501E-02 -2.6453988443953E-01 1.3777185685088E+00 + 255 2.5400000000000E+00 2.1895608416211E-04 -3.1642264873008E-03 3.3572666086873E-02 -2.5099320619910E-01 1.3317003814595E+00 + 256 2.5500000000000E+00 1.8895117144916E-04 -2.8408294392521E-03 3.1128558503699E-02 -2.3790414080385E-01 1.2862029181630E+00 + 257 2.5600000000000E+00 1.6206018643583E-04 -2.5412265737847E-03 2.8813075888731E-02 -2.2526727741572E-01 1.2412665028959E+00 + 258 2.5700000000000E+00 1.3805154341336E-04 -2.2641541561957E-03 2.6621724916839E-02 -2.1307681377456E-01 1.1969291008124E+00 + 259 2.5800000000000E+00 1.1670607033894E-04 -2.0083930886933E-03 2.4550072144668E-02 -2.0132657967502E-01 1.1532263394476E+00 + 260 2.5900000000000E+00 9.7816565517456E-05 -1.7727682935673E-03 2.2593747573651E-02 -1.9001006021816E-01 1.1101915331483E+00 + 261 2.6000000000000E+00 8.1187360629182E-05 -1.5561480618892E-03 2.0748447981729E-02 -1.7912041882503E-01 1.0678557087812E+00 + 262 2.6100000000000E+00 6.6633890437644E-05 -1.3574433700496E-03 1.9009940026202E-02 -1.6865051995857E-01 1.0262476363267E+00 + 263 2.6200000000000E+00 5.3982269473916E-05 -1.1756071663840E-03 1.7374063121027E-02 -1.5859295152849E-01 9.8539386274447E-01 + 264 2.6300000000000E+00 4.3068876002626E-05 -1.0096336301499E-03 1.5836732091834E-02 -1.4894004693902E-01 9.4531874806289E-01 + 265 2.6400000000000E+00 3.3739943527935E-05 -8.5855740505562E-04 1.4393939612209E-02 -1.3968390676892E-01 9.0604450383849E-01 + 266 2.6500000000000E+00 2.5851160071999E-05 -7.2145280947983E-04 1.3041758425257E-02 -1.3081642005655E-01 8.6759123378856E-01 + 267 2.6600000000000E+00 1.9267275472602E-05 -5.9743302556248E-04 1.1776343354273E-02 -1.2232928516264E-01 8.2997697703508E-01 + 268 2.6700000000000E+00 1.3861716879640E-05 -4.8564926921110E-04 1.0593933107046E-02 -1.1421403019078E-01 7.9321775351712E-01 + 269 2.6800000000000E+00 9.5162126340516E-06 -3.8528994306319E-04 9.4908518782935E-03 -1.0646203294501E-01 7.5732761151340E-01 + 270 2.6900000000000E+00 6.1204247064436E-06 -2.9557977444797E-04 8.4635107548268E-03 -9.9064540399804E-02 7.2231867692369E-01 + 271 2.7000000000000E+00 3.5715898106727E-06 -2.1577894022943E-04 7.5084089286095E-03 -9.2012687670573E-02 6.8820120419921E-01 + 272 2.7100000000000E+00 1.7741693319294E-06 -1.4518218047052E-04 6.6221347226483E-03 -8.5297516468698E-02 6.5498362859397E-01 + 273 2.7200000000000E+00 6.3950817107885E-07 -8.3117902770427E-05 5.8013664349292E-03 -7.8909993024394E-02 6.2267262007281E-01 + 274 2.7300000000000E+00 8.5502571664075E-08 -2.8947279005480E-05 5.0428730059204E-03 -7.2841025466037E-02 5.9127313856731E-01 + 275 2.7400000000000E+00 3.6277025349434E-08 1.7936663694881E-05 4.3435145149897E-03 -6.7081480638155E-02 5.6078849026009E-01 + 276 2.7500000000000E+00 4.2187028044418E-07 5.8109956133464E-05 3.7002425115215E-03 -6.1622200353654E-02 5.3122038483365E-01 + 277 2.7600000000000E+00 1.1779304947142E-06 9.2118602748695E-05 3.1101001863818E-03 -5.6454017070388E-02 5.0256899345871E-01 + 278 2.7700000000000E+00 2.2454195617136E-06 1.2047949821446E-04 2.5702223894963E-03 -5.1567768981605E-02 4.7483300765741E-01 + 279 2.7800000000000E+00 3.5703265870939E-06 1.4368134353045E-04 2.0778354995239E-03 -4.6954314516627E-02 4.4800969875770E-01 + 280 2.7900000000000E+00 5.1033905291551E-06 1.6218556004410E-04 1.6302571514691E-03 -4.2604546243098E-02 4.2209497770143E-01 + 281 2.8000000000000E+00 6.7998319588576E-06 1.7642720008051E-04 1.2248958282871E-03 -3.8509404170294E-02 3.9708345519803E-01 + 282 2.8100000000000E+00 8.6190938988892E-06 1.8681585286050E-04 8.5925032245936E-04 -3.4659888450865E-02 3.7296850205086E-01 + 283 2.8200000000000E+00 1.0524591704802E-05 1.9373654434673E-04 5.3090907357598E-04 -3.1047071476410E-02 3.4974230965327E-01 + 284 2.8300000000000E+00 1.2483471895081E-05 1.9755062994663E-04 2.3754938797210E-04 -2.7662109370121E-02 3.2739595045434E-01 + 285 2.8400000000000E+00 1.4466379879290E-05 1.9859667878442E-04 -2.3063453520238E-05 -2.4496252874168E-02 3.0591943817479E-01 + 286 2.8500000000000E+00 1.6447236476898E-05 1.9719134854331E-04 -2.5307719369041E-04 -2.1540857636756E-02 2.8530178779958E-01 + 287 2.8600000000000E+00 1.8403023130710E-05 1.9363024984240E-04 -4.5455369697839E-04 -1.8787393901863E-02 2.6553107520436E-01 + 288 2.8700000000000E+00 2.0313575716565E-05 1.8818879909490E-04 -6.2947014135322E-04 -1.6227455602923E-02 2.4659449635825E-01 + 289 2.8800000000000E+00 2.2161386807565E-05 1.8112305909434E-04 -7.7972029828242E-04 -1.3852768868892E-02 2.2847842598500E-01 + 290 2.8900000000000E+00 2.3931416291906E-05 1.7267056629172E-04 -9.0711589472648E-04 -1.1655199945754E-02 2.1116847549794E-01 + 291 2.9000000000000E+00 2.5610910184600E-05 1.6305114413361E-04 -1.0133880515431E-03 -9.6267625432406E-03 1.9464955020976E-01 + 292 2.9100000000000E+00 2.7189227503243E-05 1.5246770163579E-04 -1.1001887925010E-03 -7.7596246133254E-03 1.7890590570881E-01 + 293 2.9200000000000E+00 2.8657675054923E-05 1.4110701651014E-04 -1.1690926182031E-03 -6.0461145689171E-03 1.6392120333558E-01 + 294 2.9300000000000E+00 3.0009349968012E-05 1.2914050232301E-04 -1.2215981395921E-03 -4.4787269535898E-03 1.4967856468580E-01 + 295 2.9400000000000E+00 3.1238989822376E-05 1.1672495894157E-04 -1.2591297652293E-03 -3.0501275701933E-03 1.3616062504795E-01 + 296 2.9500000000000E+00 3.2342830189171E-05 1.0400330596831E-04 -1.2830394374447E-03 -1.7531580820802E-03 1.2334958572471E-01 + 297 2.9600000000000E+00 3.3318469425351E-05 9.1105298501214E-05 -1.2946084116937E-03 -5.8084009586571E-04 1.1122726513408E-01 + 298 2.9700000000000E+00 3.4164740531041E-05 7.8148224962602E-05 -1.2950490743383E-03 4.7362125993468E-04 9.9775148676628E-02 + 299 2.9800000000000E+00 3.4881589895869E-05 6.5237586563375E-05 -1.2855067937209E-03 1.4168342484898E-03 8.8974437299584E-02 + 300 2.9900000000000E+00 3.5469962747265E-05 5.2467758083370E-05 -1.2670617995948E-03 2.2552179176488E-03 7.8806094718609E-02 + 301 3.0000000000000E+00 3.5931695110032E-05 3.9922629801437E-05 -1.2407310865144E-03 2.9949999576789E-03 6.9250893262846E-02 + 302 3.0100000000000E+00 3.6269412092784E-05 2.7676230193912E-05 -1.2074703360410E-03 3.6422150109003E-03 6.0289458246075E-02 + 303 3.0200000000000E+00 3.6486432301835E-05 1.5793329450011E-05 -1.1681758540675E-03 4.2027034169560E-03 5.1902310875251E-02 + 304 3.0300000000000E+00 3.6586678195794E-05 4.3300234425653E-06 -1.1236865181519E-03 4.6821103802887E-03 4.4069909646391E-02 + 305 3.0400000000000E+00 3.6574592180600E-05 -6.6657017127098E-06 -1.0747857314900E-03 5.0858855433598E-03 3.6772690213416E-02 + 306 3.0500000000000E+00 3.6455058253489E-05 -1.7153424718918E-05 -1.0222033789380E-03 5.4192829513493E-03 2.9991103703235E-02 + 307 3.0600000000000E+00 3.6233328997685E-05 -2.7099763681288E-05 -9.6661778162067E-04 5.6873613917301E-03 2.3705653445458E-02 + 308 3.0700000000000E+00 3.5914957734801E-05 -3.6477870216403E-05 -9.0865764634774E-04 5.8949850933274E-03 1.7896930095752E-02 + 309 3.0800000000000E+00 3.5505735636732E-05 -4.5266943041208E-05 -8.4890400615620E-04 6.0468247685266E-03 1.2545645155931E-02 + 310 3.0900000000000E+00 3.5011633608268E-05 -5.3451760856797E-05 -7.8789214907659E-04 6.1473589825358E-03 7.6326628826892E-03 + 311 3.1000000000000E+00 3.4438748739404E-05 -6.1022234522766E-05 -7.2611353120434E-04 6.2008758337343E-03 3.1390305680064E-03 + 312 3.1100000000000E+00 3.3793255147858E-05 -6.7972978177858E-05 -6.6401767203950E-04 6.2114749288156E-03 -9.5399278691643E-04 + 313 3.1200000000000E+00 3.3081359006916E-05 -7.4302899315636E-05 -6.0201402803016E-04 6.1830696361837E-03 -4.6649094513372E-03 + 314 3.1300000000000E+00 3.2309257589171E-05 -8.0014807375629E-05 -5.4047384290522E-04 6.1193896019401E-03 -8.0119575459724E-03 + 315 3.1400000000000E+00 3.1483102122347E-05 -8.5115040799295E-05 -4.7973197100538E-04 6.0239835115098E-03 -1.1013087228243E-02 + 316 3.1500000000000E+00 3.0608964292982E-05 -8.9613112101640E-05 -4.2008867234881E-04 5.9002220818214E-03 -1.3685938468503E-02 + 317 3.1600000000000E+00 2.9692806202411E-05 -9.3521370799033E-05 -3.6181137627437E-04 5.7513012676608E-03 -1.6047820411128E-02 + 318 3.1700000000000E+00 2.8740453611805E-05 -9.6854683767022E-05 -3.0513641232697E-04 5.5802456667059E-03 -1.8115692297375E-02 + 319 3.1800000000000E+00 2.7757572293747E-05 -9.9630132761968E-05 -2.5027070595750E-04 5.3899121073151E-03 -1.9906145951309E-02 + 320 3.1900000000000E+00 2.6749647326022E-05 -1.0186672870167E-04 -1.9739343759678E-04 5.1829934040342E-03 -2.1435389771503E-02 + 321 3.2000000000000E+00 2.5721965161179E-05 -1.0358514235145E-04 -1.4665766340034E-04 4.9620222657085E-03 -2.2719234208360E-02 + 322 3.2100000000000E+00 2.4679598305286E-05 -1.0480745102355E-04 -9.8191896112571E-05 4.7293753412249E-03 -2.3773078715294E-02 + 323 3.2200000000000E+00 2.3627392457666E-05 -1.0555690087037E-04 -5.2101645031464E-05 4.4872773891599E-03 -2.4611900131958E-02 + 324 3.2300000000000E+00 2.2569955942239E-05 -1.0585768438226E-04 -8.4709134506476E-06 4.2378055555951E-03 -2.5250242483069E-02 + 325 3.2400000000000E+00 2.1511651301722E-05 -1.0573473262587E-04 3.2636346818451E-05 3.9828937480883E-03 -2.5702208149184E-02 + 326 3.2500000000000E+00 2.0456588882665E-05 -1.0521352182729E-04 7.1174825497628E-05 3.7243370900183E-03 -2.5981450370144E-02 + 327 3.2600000000000E+00 1.9408622302430E-05 -1.0431989381129E-04 1.0711648831291E-04 3.4637964448858E-03 -2.6101167042104E-02 + 328 3.2700000000000E+00 1.8371345624078E-05 -1.0307988988654E-04 1.4044925752788E-04 3.2028029945510E-03 -2.6074095777077E-02 + 329 3.2800000000000E+00 1.7348092149909E-05 -1.0151959768082E-04 1.7117573791116E-04 2.9427628627578E-03 -2.5912510175048E-02 + 330 3.2900000000000E+00 1.6341934658617E-05 -9.9665010495679E-05 1.9931198971738E-04 2.6849617677366E-03 -2.5628217283444E-02 + 331 3.3000000000000E+00 1.5355687015651E-05 -9.7541898692548E-05 2.2488634765998E-04 2.4305696970745E-03 -2.5232556183942E-02 + 332 3.3100000000000E+00 1.4391906982081E-05 -9.5175692655038E-05 2.4793828734877E-04 2.1806455883222E-03 -2.4736397683587E-02 + 333 3.3200000000000E+00 1.3452900169136E-05 -9.2591376859439E-05 2.6851733785582E-04 1.9361420105196E-03 -2.4150145051734E-02 + 334 3.3300000000000E+00 1.2540724965637E-05 -8.9813394572095E-05 2.8668204172363E-04 1.6979098300725E-03 -2.3483735751164E-02 + 335 3.3400000000000E+00 1.1657198401427E-05 -8.6865562734587E-05 3.0249896084719E-04 1.4667028577907E-03 -2.2746644125902E-02 + 336 3.3500000000000E+00 1.0803902777679E-05 -8.3770996529812E-05 3.1604172935448E-04 1.2431824610786E-03 -2.1947885004094E-02 + 337 3.3600000000000E+00 9.9821930411895E-06 -8.0552043225412E-05 3.2739015174828E-04 1.0279221393991E-03 -2.1096018160164E-02 + 338 3.3700000000000E+00 9.1932047390248E-06 -7.7230224764027E-05 3.3662934721232E-04 8.2141204701065E-04 -2.0199153607271E-02 + 339 3.3800000000000E+00 8.4378625424945E-06 -7.3826188736391E-05 3.4384893824622E-04 6.2406346288529E-04 -1.9264957662120E-02 + 340 3.3900000000000E+00 7.7168891842009E-06 -7.0359667187500E-05 3.4914228427496E-04 4.3621319236747E-04 -1.8300659724440E-02 + 341 3.4000000000000E+00 7.0308148066210E-06 -6.6849442932416E-05 3.5260575836555E-04 2.5812790152707E-04 -1.7313059740177E-02 + 342 3.4100000000000E+00 6.3799865753804E-06 -6.3313322818904E-05 3.5433806742659E-04 9.0008369799932E-05 -1.6308536293448E-02 + 343 3.4200000000000E+00 5.7645785625453E-06 -5.9768117652469E-05 3.5443961403759E-04 -6.8006337367219E-05 -1.5293055287299E-02 + 344 3.4300000000000E+00 5.1846017645965E-06 -5.6229628216133E-05 3.5301189999910E-04 -2.1583478931153E-04 -1.4272179165616E-02 + 345 3.4400000000000E+00 4.6399142645263E-06 -5.2712637135162E-05 3.5015696981352E-04 -3.5344920192004E-04 -1.3251076635358E-02 + 346 3.4500000000000E+00 4.1302314163461E-06 -4.9230906024555E-05 3.4597689389866E-04 -4.8087155251978E-04 -1.2234532834980E-02 + 347 3.4600000000000E+00 3.6551360627037E-06 -4.5797177696931E-05 3.4057328984195E-04 -5.9816979511587E-04 -1.1226959918590E-02 + 348 3.4700000000000E+00 3.2140886796265E-06 -4.2423182886471E-05 3.3404688121297E-04 -7.0545418648795E-04 -1.0232407994811E-02 + 349 3.4800000000000E+00 2.8064374574709E-06 -3.9119651283989E-05 3.2649709236349E-04 -8.0287372047381E-04 -9.2545763953662E-03 + 350 3.4900000000000E+00 2.4314282298169E-06 -3.5896326371121E-05 3.1802167847022E-04 -8.9061267891499E-04 -8.2968252201810E-03 + 351 3.5000000000000E+00 2.0882142550042E-06 -3.2761983853537E-05 3.0871638937554E-04 -9.6888729704282E-04 -7.3621871290437E-03 + 352 3.5100000000000E+00 1.7758657815251E-06 -2.9724453229555E-05 2.9867466625305E-04 -1.0379425497453E-03 -6.4533793326832E-03 + 353 3.5200000000000E+00 1.4933793950879E-06 -2.6790642284224E-05 2.8798736977079E-04 -1.0980490571367E-03 -5.5728157551936E-03 + 354 3.5300000000000E+00 1.2396870993934E-06 -2.3966564111014E-05 2.7674253859806E-04 -1.1495001134021E-03 -4.7226193165966E-03 + 355 3.5400000000000E+00 1.0136651195235E-06 -2.1257366425190E-05 2.6502517701737E-04 -1.1926088384297E-03 -3.9046343079986E-03 + 356 3.5500000000000E+00 8.1414240155744E-07 -1.8667362854290E-05 2.5291707037967E-04 -1.2277054535747E-03 -3.1204388245504E-03 + 357 3.5600000000000E+00 6.3990878705150E-07 -1.6200065927574E-05 2.4049662720288E-04 -1.2551346822772E-03 -2.3713572212468E-03 + 358 3.5700000000000E+00 4.8972285750771E-07 -1.3858221549474E-05 2.2783874662647E-04 -1.2752532743558E-03 -1.6584725641039E-03 + 359 3.5800000000000E+00 3.6231941675248E-07 -1.1643844621824E-05 2.1501470999630E-04 -1.2884276560473E-03 -9.8263903871297E-04 + 360 3.5900000000000E+00 2.5641662679707E-07 -9.5582557130895E-06 2.0209209536587E-04 -1.2950317019535E-03 -3.4449429897546E-04 + 361 3.6000000000000E+00 1.7072275501140E-07 -7.6021183707497E-06 1.8913471358277E-04 -1.2954446322751E-03 2.5552829386671E-04 + 362 3.6100000000000E+00 1.0394256630918E-07 -5.7754770960597E-06 1.7620256492512E-04 -1.2900490292225E-03 8.1718753906151E-04 + 363 3.6200000000000E+00 5.4783310724169E-08 -4.0777955083795E-06 1.6335181477899E-04 -1.2792289769333E-03 1.3404224277034E-03 + 364 3.6300000000000E+00 2.1960352080808E-08 -2.5079948215321E-06 1.5063478756649E-04 -1.2633683172275E-03 1.8253403264792E-03 + 365 3.6400000000000E+00 4.2023895534089E-09 -1.0644921359085E-06 1.3809997724699E-04 -1.2428490254511E-03 2.2722053734769E-03 + 366 3.6500000000000E+00 2.5631609307991E-10 2.5476130945905E-07 1.2579207377032E-04 -1.2180496988691E-03 2.6814270695748E-03 + 367 3.6600000000000E+00 8.8916813853202E-09 1.4522423411147E-06 1.1375200381526E-04 -1.1893441598451E-03 3.0535491190256E-03 + 368 3.6700000000000E+00 2.8904789010502E-08 2.5308184434400E-06 1.0201698516200E-04 -1.1571001681118E-03 3.3892385099176E-03 + 369 3.6800000000000E+00 5.9122416925402E-08 3.4937110116974E-06 9.0620593244500E-05 -1.1216782416179E-03 3.6892748692143E-03 + 370 3.6900000000000E+00 9.8405175524189E-08 4.3444593076585E-06 7.9592839039702E-05 -1.0834305822284E-03 3.9545400976806E-03 + 371 3.7000000000000E+00 1.4565051133074E-07 5.0868852311454E-06 6.8960257214645E-05 -1.0427001033442E-03 4.1860082996715E-03 + 372 3.7100000000000E+00 1.9979535798840E-07 5.7250590700389E-06 5.8746003352836E-05 -9.9981955732876E-04 4.3847360285289E-03 + 373 3.7200000000000E+00 2.5981845707033E-07 6.2632661805194E-06 4.8969959701528E-05 -9.5511075796615E-04 4.5518528403902E-03 + 374 3.7300000000000E+00 3.2474234217628E-07 6.7059748777910E-06 3.9648847809889E-05 -9.0888389683623E-04 4.6885521944755E-03 + 375 3.7400000000000E+00 3.9363501728936E-07 7.0578053455123E-06 3.0796348099148E-05 -8.6143694785292E-04 4.7960826715096E-03 + 376 3.7500000000000E+00 4.6561132137204E-07 7.3234999164219E-06 2.2423224345776E-05 -8.1305515893291E-04 4.8757395584570E-03 + 377 3.7600000000000E+00 5.3983400890339E-07 7.5078944921479E-06 1.4537453402755E-05 -7.6401062530743E-04 4.9288567655902E-03 + 378 3.7700000000000E+00 6.1551454703242E-07 7.6158913761937E-06 7.1443583375807E-06 -7.1456194230353E-04 4.9567991142179E-03 + 379 3.7800000000000E+00 6.9191364954612E-07 7.6524333967064E-06 2.4674495837278E-07 -6.6495393332164E-04 4.9609549750694E-03 + 380 3.7900000000000E+00 7.6834155883738E-07 7.6224794264274E-06 -6.1549594190125E-06 -6.1541744957571E-04 4.9427292722243E-03 + 381 3.8000000000000E+00 8.4415808921467E-07 7.5309813164374E-06 -1.2062565623301E-05 -5.6616923806584E-04 4.9035368533139E-03 + 382 3.8100000000000E+00 9.1877244755464E-07 7.3828621876354E-06 -1.7479981001981E-05 -5.1741187401798E-04 4.8447962155333E-03 + 383 3.8200000000000E+00 9.9164284360620E-07 7.1829962214989E-06 -2.2413067914182E-05 -4.6933375406357E-04 4.7679236076567E-03 + 384 3.8300000000000E+00 1.0622759044515E-06 6.9361897639940E-06 -2.6869501788312E-05 -4.2210914704350E-04 4.6743274770885E-03 + 385 3.8400000000000E+00 1.1302259091503E-06 6.6471639499302E-06 -3.0858630679109E-05 -3.7589829785536E-04 4.5654032935586E-03 + 386 3.8500000000000E+00 1.1950938538540E-06 6.3205386396330E-06 -3.4391335483942E-05 -3.3084758205292E-04 4.4425287135830E-03 + 387 3.8600000000000E+00 1.2565263659354E-06 5.9608177996533E-06 -3.7479892376608E-05 -2.8708970637247E-04 4.3070591061424E-03 + 388 3.8700000000000E+00 1.3142144770419E-06 5.5723762266060E-06 -4.0137837266643E-05 -2.4474395265997E-04 4.1603234206456E-03 + 389 3.8800000000000E+00 1.3678922700380E-06 5.1594476054367E-06 -4.2379832846067E-05 -2.0391646144610E-04 4.0036203942139E-03 + 390 3.8900000000000E+00 1.4173354157919E-06 4.7261139160590E-06 -4.4221538961168E-05 -1.6470055116475E-04 3.8382150991971E-03 + 391 3.9000000000000E+00 1.4623596048628E-06 4.2762960674611E-06 -4.5679485814316E-05 -1.2717707149226E-04 3.6653358078875E-03 + 392 3.9100000000000E+00 1.5028188996469E-06 3.8137458407418E-06 -4.6770951506612E-05 -9.1414784728940E-05 3.4861711878901E-03 + 393 3.9200000000000E+00 1.5386040035973E-06 3.3420389854357E-06 -4.7513842895504E-05 -5.7470775479364E-05 3.3018677980723E-03 + 394 3.9300000000000E+00 1.5696404744032E-06 2.8645695212075E-06 -4.7926581151688E-05 -2.5390882330931E-05 3.1135278942400E-03 + 395 3.9400000000000E+00 1.5958868816428E-06 2.3845451468173E-06 -4.8027991484623E-05 4.7898490991753E-06 2.9222075242515E-03 + 396 3.9500000000000E+00 1.6173329240657E-06 1.9049837265278E-06 -4.7837197479213E-05 3.3046695517227E-05 2.7289149062589E-03 + 397 3.9600000000000E+00 1.6339975216385E-06 1.4287108244246E-06 -4.7373520487129E-05 5.9364771470138E-05 2.5346090837800E-03 + 398 3.9700000000000E+00 1.6459268785288E-06 9.5835819892088E-07 -4.6656383434441E-05 8.3738530727163E-05 2.3401988383400E-03 + 399 3.9800000000000E+00 1.6531925478650E-06 4.9636325464308E-07 -4.5705220259670E-05 1.0617126066614E-04 2.1465418601224E-03 + 400 3.9900000000000E+00 1.6558894839043E-06 4.4969361076968E-08 -4.4539389913538E-05 1.2667456708320E-04 1.9544441555533E-03 + 401 4.0000000000000E+00 1.6541341096897E-06 -3.9377298988681E-07 -4.3178095882239E-05 1.4526785600104E-04 1.7646596877288E-03 + 402 4.0100000000000E+00 1.6480623973590E-06 -8.1800424680566E-07 -4.1640310798466E-05 1.6197781235434E-04 1.5778902354646E-03 + 403 4.0200000000000E+00 1.6378279684055E-06 -1.2260531349435E-06 -3.9944706139865E-05 1.7683787763755E-04 1.3947854594003E-03 + 404 4.0300000000000E+00 1.6236002326766E-06 -1.6164333189202E-06 -3.8109587468431E-05 1.8988773112574E-04 1.2159431653420E-03 + 405 4.0400000000000E+00 1.6055625513792E-06 -1.9878394330479E-06 -3.6152834405636E-05 2.0117277186314E-04 1.0419097521663E-03 + 406 4.0500000000000E+00 1.5839104557174E-06 -2.3391425532275E-06 -3.4091846188536E-05 2.1074360894307E-04 8.7318083225364E-04 + 407 4.0600000000000E+00 1.5588499040051E-06 -2.6693851346492E-06 -3.1943491999228E-05 2.1865555665962E-04 7.1020201477841E-04 + 408 4.0700000000000E+00 1.5305955949641E-06 -2.9777754848399E-06 -2.9724066388209E-05 2.2496813898724E-04 5.5336983873075E-04 + 409 4.0800000000000E+00 1.4993693423084E-06 -3.2636818231014E-06 -2.7449249715647E-05 2.2974460498486E-04 4.0303284413707E-04 + 410 4.0900000000000E+00 1.4653985005629E-06 -3.5266259434996E-06 -2.5134073120147E-05 2.3305145320210E-04 2.5949277401821E-04 + 411 4.1000000000000E+00 1.4289144691056E-06 -3.7662765882459E-06 -2.2792888501517E-05 2.3495797182327E-04 1.2300588821323E-04 + 412 4.1100000000000E+00 1.3901512522087E-06 -3.9824425067273E-06 -2.0439342771542E-05 2.3553578968028E-04 -6.2156119710167E-06 + 413 4.1200000000000E+00 1.3493440963649E-06 -4.1750653031703E-06 -1.8086356656787E-05 2.3485844362044E-04 -1.2800206765300E-04 + 414 4.1300000000000E+00 1.3067282000253E-06 -4.3442120923715E-06 -1.5746107753537E-05 2.3300096143258E-04 -2.4222476162976E-04 + 415 4.1400000000000E+00 1.2625374913390E-06 -4.4900679814244E-06 -1.3430017560363E-05 2.3003945961584E-04 -3.4879423945827E-04 + 416 4.1500000000000E+00 1.2170034918259E-06 -4.6129284869767E-06 -1.1148742608835E-05 2.2605076083834E-04 -4.4765857350131E-04 + 417 4.1600000000000E+00 1.1703542459359E-06 -4.7131918322486E-06 -8.9121691906122E-06 2.2111202637528E-04 -5.3880156420320E-04 + 418 4.1700000000000E+00 1.1228133348875E-06 -4.7913512472090E-06 -6.7294117485373E-06 2.1530040862477E-04 -6.2224090272612E-04 + 419 4.1800000000000E+00 1.0745989658717E-06 -4.8479872594150E-06 -4.6088146386623E-06 2.0869272173084E-04 -6.9802629582907E-04 + 420 4.1900000000000E+00 1.0259231341932E-06 -4.8837599949632E-06 -2.5579570576647E-06 2.0136513001983E-04 -7.6623755929840E-04 + 421 4.2000000000000E+00 9.7699086982340E-07 -4.8994015940151E-06 -5.8366103316260E-07 1.9339285773597E-04 -8.2698270196929E-04 + 422 4.2100000000000E+00 9.2799955118179E-07 -4.8957086626616E-06 1.3079978006354E-06 1.8484991567867E-04 -8.8039598826562E-04 + 423 4.2200000000000E+00 8.7913829947593E-07 -4.8735348898027E-06 3.1116767954383E-06 1.7580884889190E-04 -9.2663600618606E-04 + 424 4.2300000000000E+00 8.3058744483609E-07 -4.8337837985830E-06 4.8227504459762E-06 1.6634050324920E-04 -9.6588373743573E-04 + 425 4.2400000000000E+00 7.8251806096681E-07 -4.7774016404085E-06 6.4372922921619E-06 1.5651381032989E-04 -9.9834063362583E-04 + 426 4.2500000000000E+00 7.3509157567347E-07 -4.7053705354274E-06 7.9520548234920E-06 1.4639559327106E-04 -1.0242267216099E-03 + 427 4.2600000000000E+00 6.8845944334458E-07 -4.6187017640718E-06 9.3644474514748E-06 1.3605038959968E-04 -1.0437787208082E-03 + 428 4.2700000000000E+00 6.4276288670591E-07 -4.5184293270113E-06 1.0672512877013E-05 1.2554029390067E-04 -1.0572481990734E-03 + 429 4.2800000000000E+00 5.9813270163598E-07 -4.4056037463279E-06 1.1874901967656E-05 1.1492481869256E-04 -1.0648997634762E-03 + 430 4.2900000000000E+00 5.5468912004527E-07 -4.2812860867763E-06 1.2970847243652E-05 1.0426077219202E-04 -1.0670092833782E-03 + 431 4.3000000000000E+00 5.1254173496350E-07 -4.1465423092073E-06 1.3960135395187E-05 9.3602155154274E-05 -1.0638621724449E-03 + 432 4.3100000000000E+00 4.7178947778861E-07 -4.0024378484821E-06 1.4843078685115E-05 8.3000073359602E-05 -1.0557517075900E-03 + 433 4.3200000000000E+00 4.3252064938299E-07 -3.8500325070865E-06 1.5620485648725E-05 7.2502667193139E-05 -1.0429774073028E-03 + 434 4.3300000000000E+00 3.9481300129894E-07 -3.6903756594110E-06 1.6293631221849E-05 6.2155057456222E-05 -1.0258434702430E-03 + 435 4.3400000000000E+00 3.5873386216791E-07 -3.5245017068377E-06 1.6864226197465E-05 5.1999305568283E-05 -1.0046572616504E-03 + 436 4.3500000000000E+00 3.2434030910331E-07 -3.3534259032699E-06 1.7334386639320E-05 4.2074389657850E-05 -9.7972787840493E-04 + 437 4.3600000000000E+00 2.9167937891838E-07 -3.1781404436103E-06 1.7706602918288E-05 3.2416194008928E-05 -9.5136476809750E-04 + 438 4.3700000000000E+00 2.6078831687439E-07 -2.9996108685242E-06 1.7983708745047E-05 2.3057512060537E-05 -9.1987641717950E-04 + 439 4.3800000000000E+00 2.3169485957193E-07 -2.8187728053051E-06 1.8168850444808E-05 1.4028062494144E-05 -8.8556911526777E-04 + 440 4.3900000000000E+00 2.0441754990780E-07 -2.6365289722758E-06 1.8265456194658E-05 5.3545169380848E-06 -8.4874577817900E-04 + 441 4.4000000000000E+00 1.7896607909149E-07 -2.4537465262218E-06 1.8277205839511E-05 -2.9394606702352E-06 -8.0970485291309E-04 + 442 4.4100000000000E+00 1.5534165428481E-07 -2.2712546974275E-06 1.8208001069277E-05 -1.0833164183511E-05 -7.6873929129090E-04 + 443 4.4200000000000E+00 1.3353738953138E-07 -2.0898427019966E-06 1.8061936006412E-05 -1.8308785480207E-05 -7.2613559089067E-04 + 444 4.4300000000000E+00 1.1353871343673E-07 -1.9102579805064E-06 1.7843268726321E-05 -2.5351345498364E-05 -6.8217291987577E-04 + 445 4.4400000000000E+00 9.5323795915831E-08 -1.7332046870775E-06 1.7556393236486E-05 -3.1948616754549E-05 -6.3712230456607E-04 + 446 4.4500000000000E+00 7.8863987263195E-08 -1.5593424663158E-06 1.7205812386293E-05 -3.8091038210721E-05 -5.9124589354074E-04 + 447 4.4600000000000E+00 6.4124266866819E-08 -1.3892855062796E-06 1.6796111763072E-05 -4.3771623251137E-05 -5.4479629677145E-04 + 448 4.4700000000000E+00 5.1063703954746E-08 -1.2236018247697E-06 1.6331934265429E-05 -4.8985860978255E-05 -4.9801598711698E-04 + 449 4.4800000000000E+00 3.9635919647540E-08 -1.0628128277506E-06 1.5817955996610E-05 -5.3731612445145E-05 -4.5113678082527E-04 + 450 4.4900000000000E+00 2.9789554556925E-08 -9.0739309353129E-07 1.5258863074065E-05 -5.8009001724699E-05 -4.0437938226811E-04 + 451 4.5000000000000E+00 2.1468739130227E-08 -7.5777037747217E-07 1.4659329448895E-05 -6.1820302507495E-05 -3.5795299314280E-04 + 452 4.5100000000000E+00 1.4613558083269E-08 -6.1432584652849E-07 1.4023996144933E-05 -6.5169821863607E-05 -3.1205499408188E-04 + 453 4.5200000000000E+00 9.1605163179659E-09 -4.7739450459904E-07 1.3357451418651E-05 -6.8063780338807E-05 -2.6687068346156E-04 + 454 4.5300000000000E+00 5.0429975458954E-09 -3.4726581338190E-07 1.2664212232071E-05 -7.0510190114523E-05 -2.2257308027445E-04 + 455 4.5400000000000E+00 2.1917137742454E-09 -2.2418449493323E-07 1.1948707050100E-05 -7.2518731860514E-05 -1.7932278852647E-04 + 456 4.5500000000000E+00 5.3515120225579E-10 -1.0835149680195E-07 1.1215259638152E-05 -7.4100629514435E-05 -1.3726791423013E-04 + 457 4.5600000000000E+00 2.2899938158366E-16 7.4886115989308E-11 1.0468074348354E-05 -7.5268525584863E-05 -9.6544041591059E-05 + 458 4.5700000000000E+00 5.1157524206084E-10 1.0097774876589E-07 9.7112225814047E-06 -7.6036356135129E-05 -5.7274260233920E-05 + 459 4.5800000000000E+00 1.9942248567383E-09 1.9428018135984E-07 8.9486303521853E-06 -7.6419225499146E-05 -1.9569240347976E-05 + 460 4.5900000000000E+00 4.3717208057623E-09 2.7994376323326E-07 8.1840673580973E-06 -7.6433283460352E-05 1.6472641528369E-05 + 461 4.6000000000000E+00 7.5676364201263E-09 3.5796694694396E-07 7.4211370823418E-06 -7.6095602764118E-05 5.0765134416708E-05 + 462 4.6100000000000E+00 1.1505708049209E-08 4.2838335015571E-07 6.6632681277896E-06 -7.5424058620275E-05 8.3233902660566E-05 + 463 4.6200000000000E+00 1.6110175081493E-08 4.9125997474955E-07 5.9137068712924E-06 -7.4437211424114E-05 1.1381627577180E-04 + 464 4.6300000000000E+00 2.1306107077168E-08 5.4669534538265E-07 5.1755111172161E-06 -7.3154190882291E-05 1.4246096260465E-04 + 465 4.6400000000000E+00 2.7019708814339E-08 5.9481759956612E-07 4.4515449847979E-06 -7.1594583965527E-05 1.6912773192761E-04 + 466 4.6500000000000E+00 3.3178604922428E-08 6.3578253556330E-07 3.7444749287811E-06 -6.9778326486717E-05 1.9378706246147E-04 + 467 4.6600000000000E+00 3.9712109655573E-08 6.6977160817762E-07 3.0567667054277E-06 -6.7725597035258E-05 2.1641976403641E-04 + 468 4.6700000000000E+00 4.6551471184676E-08 6.9698992063487E-07 2.3906835039337E-06 -6.5456716271787E-05 2.3701657502116E-04 + 469 4.6800000000000E+00 5.3630097397611E-08 7.1766419598716E-07 1.7482850258791E-06 -6.2992049906944E-05 2.5557773700022E-04 + 470 4.6900000000000E+00 6.0883764869187E-08 7.3204072677488E-07 1.1314274470408E-06 -6.0351915018597E-05 2.7211254782854E-04 + 471 4.7000000000000E+00 6.8250801383186E-08 7.4038335988279E-07 5.4176440044503E-07 -5.7556492689877E-05 2.8663890117690E-04 + 472 4.7100000000000E+00 7.5672252235760E-08 7.4297147431817E-07 -1.9251254859374E-08 -5.4625744157712E-05 2.9918280921620E-04 + 473 4.7200000000000E+00 8.3092027022649E-08 7.4009797661328E-07 -5.5036485677579E-07 -5.1579331596471E-05 3.0977791273319E-04 + 474 4.7300000000000E+00 9.0457022848343E-08 7.3206735024885E-07 -1.0505165533098E-06 -4.8436545044639E-05 3.1846498548614E-04 + 475 4.7400000000000E+00 9.7717231637446E-08 7.1919371790835E-07 -1.5188372409627E-06 -4.5216233170146E-05 3.2529142785224E-04 + 476 4.7500000000000E+00 1.0482582748457E-07 7.0179895416299E-07 -1.9546438320929E-06 -4.1936739408241E-05 3.3031075688699E-04 + 477 4.7600000000000E+00 1.1173923350954E-07 6.8021086446046E-07 -2.3574339032218E-06 -3.8615843893113E-05 3.3358209680546E-04 + 478 4.7700000000000E+00 1.1841717352625E-07 6.5476139429353E-07 -2.7268797842731E-06 -3.5270709426163E-05 3.3516966451120E-04 + 479 4.7800000000000E+00 1.2482270455013E-07 6.2578491683052E-07 -3.0628221439306E-06 -3.1917833223943E-05 3.3514226019674E-04 + 480 4.7900000000000E+00 1.3092223195801E-07 5.9361659334788E-07 -3.3652631234509E-06 -2.8573003978479E-05 3.3357276309073E-04 + 481 4.8000000000000E+00 1.3668551055275E-07 5.5859077841961E-07 -3.6343590303101E-06 -2.5251263021004E-05 3.3053762751548E-04 + 482 4.8100000000000E+00 1.4208562835386E-07 5.2103952552757E-07 -3.8704127127953E-06 -2.1966871345353E-05 3.2611639192858E-04 + 483 4.8200000000000E+00 1.4709897604681E-07 4.8129116759940E-07 -4.0738656251878E-06 -1.8733281395016E-05 3.2039119654577E-04 + 484 4.8300000000000E+00 1.5170520377590E-07 4.3966895386620E-07 -4.2452895724320E-06 -1.5563112890872E-05 3.1344630598345E-04 + 485 4.8400000000000E+00 1.5588716341378E-07 3.9648980230338E-07 -4.3853783258655E-06 -1.2468134297621E-05 3.0536765166812E-04 + 486 4.8500000000000E+00 1.5963083923770E-07 3.5206312602957E-07 -4.4949390471172E-06 -9.4592484849619E-06 2.9624238520671E-04 + 487 4.8600000000000E+00 1.6292526768042E-07 3.0668972438520E-07 -4.5748835087134E-06 -6.5464822438310E-06 2.8615844083032E-04 + 488 4.8700000000000E+00 1.6576244591779E-07 2.6066079814381E-07 -4.6262193716213E-06 -3.7389809694973E-06 2.7520412312946E-04 + 489 4.8800000000000E+00 1.6813723128167E-07 2.1425703349766E-07 -4.6500413558341E-06 -1.0450069375890E-06 2.6346770668020E-04 + 490 4.8900000000000E+00 1.7004723174724E-07 1.6774776121838E-07 -4.6475223455306E-06 1.5280587521760E-06 2.5103704959348E-04 + 491 4.9000000000000E+00 1.7149268891152E-07 1.2139023452206E-07 -4.6199046866681E-06 3.9737098925578E-06 2.3799923434086E-04 + 492 4.9100000000000E+00 1.7247635382994E-07 7.5428975130048E-08 -4.5684914669578E-06 6.2863057257823E-06 2.2444022229723E-04 + 493 4.9200000000000E+00 1.7300335634681E-07 3.0095198495443E-08 -4.4946378564538E-06 8.4610582356847E-06 2.1044452564435E-04 + 494 4.9300000000000E+00 1.7308107026511E-07 -1.4393652034629E-08 -4.3997427439426E-06 1.0494015967472E-05 1.9609490707063E-04 + 495 4.9400000000000E+00 1.7271897335531E-07 -5.7834304246042E-08 -4.2852404390245E-06 1.2382045129052E-05 1.8147209473173E-04 + 496 4.9500000000000E+00 1.7192850337753E-07 -1.0003797806107E-07 -4.1525925418980E-06 1.4122807959438E-05 1.6665451668356E-04 + 497 4.9600000000000E+00 1.7072291293379E-07 -1.4083060927735E-07 -4.0032801889176E-06 1.5714738470159E-05 1.5171806279222E-04 + 498 4.9700000000000E+00 1.6911712106499E-07 -1.8005300994077E-07 -3.8387964344521E-06 1.7157015939988E-05 1.3673586279133E-04 + 499 4.9800000000000E+00 1.6712756329205E-07 -2.1756095569995E-07 -3.6606388863879E-06 1.8449536276445E-05 1.2177808477370E-04 + 500 4.9900000000000E+00 1.6477204311371E-07 -2.5322518892139E-07 -3.4703027760553E-06 1.9592881561070E-05 1.0691176014969E-04 + 501 5.0000000000000E+00 1.6206958202970E-07 -2.8693136364639E-07 -3.2692742215656E-06 2.0588287834424E-05 9.2200624992179E-05 + 502 5.0100000000000E+00 1.5904027019841E-07 -3.1857992552503E-07 -3.0590238070674E-06 2.1437611369304E-05 7.7704981698271E-05 + 503 5.0200000000000E+00 1.5570512082262E-07 -3.4808592142746E-07 -2.8410006360944E-06 2.2143293895147E-05 6.3481585305332E-05 + 504 5.0300000000000E+00 1.5208592467143E-07 -3.7537875752923E-07 -2.6166266215574E-06 2.2708326547619E-05 4.9583546651532E-05 + 505 5.0400000000000E+00 1.4820510707008E-07 -4.0040190236728E-07 -2.3872911296530E-06 2.3136212906766E-05 3.6060255842211E-05 + 506 5.0500000000000E+00 1.4408559054915E-07 -4.2311253407164E-07 -2.1543461205187E-06 2.3430931706107E-05 2.2957329420544E-05 + 507 5.0600000000000E+00 1.3975065903486E-07 -4.4348114376265E-07 -1.9191015549611E-06 2.3596898736770E-05 1.0316562866375E-05 + 508 5.0700000000000E+00 1.3522382590740E-07 -4.6149109488143E-07 -1.6828211700271E-06 2.3638928382395E-05 -1.8241184517063E-06 + 509 5.0800000000000E+00 1.3052870932308E-07 -4.7713814157169E-07 -1.4467187583796E-06 2.3562195509694E-05 -1.3430658477840E-05 + 510 5.0900000000000E+00 1.2568891025068E-07 -4.9042991160895E-07 -1.2119547298912E-06 2.3372196964641E-05 -2.4472807987984E-05 + 511 5.1000000000000E+00 1.2072789530947E-07 -5.0138535620232E-07 -9.7963303675111E-07 2.3074713079155E-05 -3.4923770963793E-05 + 512 5.1100000000000E+00 1.1566888815403E-07 -5.1003417395441E-07 -7.5079859467515E-07 2.2675770080200E-05 -4.4760486322959E-05 + 513 5.1200000000000E+00 1.1053476449897E-07 -5.1641620808566E-07 -5.2643499009253E-07 2.2181602754026E-05 -5.3963589399336E-05 + 514 5.1300000000000E+00 1.0534795242303E-07 -5.2058082056512E-07 -3.0746252941532E-07 2.1598620367368E-05 -6.2519932845525E-05 + 515 5.1400000000000E+00 1.0013034217504E-07 -5.2258625559693E-07 -9.4736762266833E-08 2.0933369356196E-05 -7.0418905755270E-05 + 516 5.1500000000000E+00 9.4903200292840E-08 -5.2249898509828E-07 1.1095271674995E-07 2.0192503426535E-05 -7.7653710465784E-05 + 517 5.1600000000000E+00 8.9687089074662E-08 -5.2039303950519E-07 3.0888315660940E-07 1.9382702829006E-05 -8.4211136786075E-05 + 518 5.1700000000000E+00 8.4501796161126E-08 -5.1634934303960E-07 4.9839910739860E-07 1.8510698878800E-05 -9.0086187656359E-05 + 519 5.1800000000000E+00 7.9366268853558E-08 -5.1045503941860E-07 6.7891267465125E-07 1.7583152077293E-05 -9.5288495542508E-05 + 520 5.1900000000000E+00 7.4298553540561E-08 -5.0280280922821E-07 8.4990312509839E-07 1.6607022144777E-05 -9.9807269760031E-05 + 521 5.2000000000000E+00 6.9315745489854E-08 -4.9349020663139E-07 1.0109167972506E-06 1.5589047639492E-05 -1.0365624229057E-04 + 522 5.2100000000000E+00 6.4433943433438E-08 -4.8261899366981E-07 1.1615647837340E-06 1.4536101750107E-05 -1.0668021014405E-04 + 523 5.2200000000000E+00 5.9668209130859E-08 -4.7029447223966E-07 1.3015278698610E-06 1.3453892152803E-05 -1.0925285511019E-04 + 524 5.2300000000000E+00 5.5032536745816E-08 -4.5662484721742E-07 1.4305487981907E-06 1.2348315495650E-05 -1.1149910165614E-04 + 525 5.2400000000000E+00 5.0539827013660E-08 -4.4172059378903E-07 1.5484427978174E-06 1.1226767975738E-05 -1.1430732472086E-04 + 526 5.2500000000000E+00 4.6201866436911E-08 -4.2569382994574E-07 1.6550546441255E-06 1.0093297680912E-05 -1.1586649184300E-04 + 527 5.2600000000000E+00 4.2029314797304E-08 -4.0865772500204E-07 1.7502968651695E-06 8.9534961118780E-06 -1.1501695118054E-04 + 528 5.2700000000000E+00 3.8031697744106E-08 -3.9072579154267E-07 1.8341284850172E-06 7.7992309611824E-06 -1.0900995683392E-04 + 529 5.2800000000000E+00 3.4217404082395E-08 -3.7201175252824E-07 1.9066325567192E-06 6.6602348689109E-06 -1.0248491835833E-04 + 530 5.2900000000000E+00 3.0593689796362E-08 -3.5262868512932E-07 1.9679536930143E-06 5.5640308220428E-06 -1.0089316733208E-04 + 531 5.3000000000000E+00 2.7166687139602E-08 -3.3268922850738E-07 2.0181219384375E-06 4.5726069097233E-06 -1.1021805442650E-04 + 532 5.3100000000000E+00 2.3941417953709E-08 -3.1230257078419E-07 2.0574365285453E-06 3.6121038959968E-06 -1.2634874981982E-04 + 533 5.3200000000000E+00 2.0921812201779E-08 -2.9157487935963E-07 2.0863171113048E-06 2.5291037122300E-06 -1.3758527917053E-04 + 534 5.3300000000000E+00 1.8110731191971E-08 -2.7061008710179E-07 2.1058388218173E-06 1.1788244423796E-06 -1.3497853009327E-04 + 535 5.3400000000000E+00 1.5509994442313E-08 -2.4951248494997E-07 2.1158373087327E-06 -3.8431072736680E-07 -1.1306336162260E-04 + 536 5.3500000000000E+00 1.3120410472121E-08 -2.2838988177477E-07 2.1128716451737E-06 -1.6754946240811E-06 -7.3307074876541E-05 + 537 5.3600000000000E+00 1.0941874891472E-08 -2.0733511564415E-07 2.0950001869168E-06 -2.3705987896701E-06 -2.0350033591651E-05 + 538 5.3700000000000E+00 8.9734583313283E-09 -1.8641995869890E-07 2.0599070667153E-06 -2.2313144538584E-06 3.9644405221822E-05 + 539 5.3800000000000E+00 7.2126244210379E-09 -1.6579380067613E-07 2.0248756086060E-06 -1.7132140881949E-06 6.0272539240771E-05 + 540 5.3900000000000E+00 5.6564366918718E-09 -1.4553950935344E-07 1.9983783174265E-06 -1.2859211183696E-06 1.4941652145019E-05 + 541 5.4000000000000E+00 4.3015605973097E-09 -1.2592464027824E-07 1.9937667421163E-06 -1.2732367372749E-06 -1.3379355671290E-04 + 542 5.4100000000000E+00 3.1437463730403E-09 -1.0655775170044E-07 1.9856189003378E-06 -2.7013231159141E-06 -3.2667057733097E-04 + 543 5.4200000000000E+00 2.1783068178851E-09 -8.7318444614341E-08 1.9518788514054E-06 -6.1438858301921E-06 -5.1139268940989E-04 + 544 5.4300000000000E+00 1.3949513724961E-09 -6.7948180474695E-08 1.8697152868545E-06 -1.2329207577603E-05 -6.2811080105596E-04 + 545 5.4400000000000E+00 7.9315141160048E-10 -4.9319942641602E-08 1.7220815578159E-06 -1.9878033813438E-05 -6.3906672668722E-04 + 546 5.4500000000000E+00 3.6884136016365E-10 -3.2551861409292E-08 1.5013104900347E-06 -2.6893563608503E-05 -5.2608692268020E-04 + 547 5.4600000000000E+00 1.1663926729099E-10 -1.8755959564449E-08 1.2029117031998E-06 -3.1405961147770E-05 -2.7717709114935E-04 + 548 5.4700000000000E+00 7.3220254443294E-12 -8.5481751853887E-09 8.5244932903759E-07 -3.2312837703632E-05 6.5932038219893E-05 + 549 5.4800000000000E+00 -1.4506905674577E-11 -1.8327381617769E-09 5.0673807352928E-07 -2.9781867632440E-05 4.0663620619005E-04 + 550 5.4900000000000E+00 1.1065059939086E-12 1.6293767220058E-09 2.1690987515593E-07 -2.4172365237800E-05 6.5775490910960E-04 + 551 5.5000000000000E+00 7.1957896452494E-12 2.3518542870603E-09 2.9441340774737E-08 -1.6285413000202E-05 7.4067484079938E-04 + 552 5.5100000000000E+00 7.4293793985358E-12 1.5030020061227E-09 -7.2212124956044E-08 -8.0196718629374E-06 6.9033843815550E-04 + 553 5.5200000000000E+00 8.6533695138881E-13 1.1073230934656E-10 -1.0123463780415E-07 -9.7319558313507E-07 5.3589608624898E-04 + 554 5.5300000000000E+00 2.9094155402658E-13 -5.3409833506878E-10 -8.4400018129776E-08 2.8385266121138E-06 3.2828187073061E-04 + 555 5.5400000000000E+00 1.5483874123784E-13 -6.0859023376677E-10 -4.2244187823544E-08 4.0753078363853E-06 1.1388939286389E-04 + 556 5.5500000000000E+00 2.7783393297853E-15 -2.8916942923655E-10 3.1409753513902E-09 3.4327833373741E-06 -6.1834036281783E-05 + 557 5.5600000000000E+00 -3.2674499575917E-13 -3.7603529568553E-11 2.7811752151663E-08 2.0804163866073E-06 -1.5028577091524E-04 + 558 5.5700000000000E+00 -5.5459193516679E-13 3.2451173920012E-11 2.8363711654801E-08 6.8548792024475E-07 -1.5264319251038E-04 + 559 5.5800000000000E+00 -3.3881611106834E-13 3.2628912663700E-11 1.4969941699027E-08 -4.7451193984815E-07 -1.0263777543924E-04 + 560 5.5900000000000E+00 0.0000000000000E+00 3.3767728001276E-12 -1.5146449349685E-10 -1.0794043582871E-06 -3.7823763989778E-05 + 561 5.6000000000000E+00 0.0000000000000E+00 9.4717537816936E-12 -4.4143663816171E-09 -1.0080109000333E-06 4.2437295910045E-06 + 562 5.6100000000000E+00 0.0000000000000E+00 6.9662963351447E-12 -4.1210448793789E-09 -5.4052628710934E-07 2.9369782110673E-05 + 563 5.6200000000000E+00 0.0000000000000E+00 6.4376046665684E-13 -8.4454519955145E-10 4.3906453208343E-08 3.5769618267005E-05 + 564 5.6300000000000E+00 0.0000000000000E+00 -2.1551929639570E-12 4.4574152860536E-11 2.5561755488592E-07 2.9637142361316E-05 + 565 5.6400000000000E+00 0.0000000000000E+00 -2.4855988871580E-12 3.0269239343047E-10 2.4329370313615E-07 1.4933667124808E-05 + 566 5.6500000000000E+00 0.0000000000000E+00 -1.0001719040109E-12 1.9056769714665E-10 9.5252139955905E-08 -1.5924071087034E-06 + 567 5.6600000000000E+00 0.0000000000000E+00 1.4821343005824E-13 8.1242027002945E-11 -1.8517813829540E-08 -1.0717822194258E-05 + 568 5.6700000000000E+00 0.0000000000000E+00 2.7770226048885E-13 8.5577920031169E-11 -4.1863621084831E-08 -1.0419544859972E-05 + 569 5.6800000000000E+00 0.0000000000000E+00 1.8921645101118E-13 4.5526829078417E-11 -3.0421544755365E-08 -5.1597280225100E-06 + 570 5.6900000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -3.7215453959010E-12 -3.3183164470669E-09 1.0926862840118E-06 + 571 5.7000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -2.1005719960218E-11 7.1960930428364E-10 2.5512843889968E-06 + 572 5.7100000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.9594589014840E-11 2.1945084948266E-09 2.1582928443099E-06 + 573 5.7200000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -4.9817466165161E-12 1.0578117466502E-09 5.8187815913417E-07 + 574 5.7300000000000E+00 0.0000000000000E+00 0.0000000000000E+00 1.7465650850184E-12 7.5411678426017E-10 -2.1826975260581E-07 + 575 5.7400000000000E+00 0.0000000000000E+00 0.0000000000000E+00 2.5139549233218E-12 7.0412692791175E-10 -3.6224914214192E-07 + 576 5.7500000000000E+00 0.0000000000000E+00 0.0000000000000E+00 1.4190691964767E-12 3.1139892215040E-10 -2.2484137455386E-07 + 577 5.7600000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -4.1845701242275E-14 -8.4479338359746E-11 -2.0837694360313E-08 + 578 5.7700000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.3088478506061E-13 -1.9364319184594E-10 7.8288905340933E-09 + 579 5.7800000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.1480437022639E-13 -1.5562081533134E-10 1.6871756921309E-08 + 580 5.7900000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.9141196533226E-14 -2.4564506180686E-11 7.1371701670775E-09 + 581 5.8000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 1.9250975743002E-11 7.0100500150980E-09 + 582 5.8100000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 2.4572052754407E-11 6.0357710457226E-09 + 583 5.8200000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 1.2523814562574E-11 2.3664629010087E-09 + 584 5.8300000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -6.8751033536732E-13 -9.3582002228989E-10 + 585 5.8400000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.7765994132252E-12 -1.7538817581140E-09 + 586 5.8500000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.4821184587610E-12 -1.3324356477270E-09 + 587 5.8600000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -2.0443503404030E-13 -1.6381191710057E-10 + 588 5.8700000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 5.0335789862651E-14 1.9424153136281E-10 + 589 5.8800000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 6.5265402948415E-14 2.3622022618044E-10 + 590 5.8900000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 3.4364634209576E-14 1.1985136279837E-10 + 591 5.9000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -7.8061296565361E-12 + 592 5.9100000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -2.0675473604723E-11 + 593 5.9200000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -1.7632119695098E-11 + 594 5.9300000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -3.2663318280309E-12 + 595 5.9400000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 8.3868060024559E-13 + 596 5.9500000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 1.1491600165116E-12 + 597 5.9600000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 6.6541701479568E-13 + 598 5.9700000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -8.1227092968016E-15 + 599 5.9800000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -2.9313981203294E-14 + 600 5.9900000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 0.0000000000000E+00 -2.8026838005393E-14 + 1 0.0000000000000E+00 8.6492087511576E-03 7.5898950798268E+01 1.8182964717041E+04 + 2 1.0000000000000E-02 8.6685331430122E-03 5.7548082370848E+01 1.3844112022512E+04 + 3 2.0000000000000E-02 8.7265246887720E-03 4.3586713328548E+01 1.0610597434208E+04 + 4 3.0000000000000E-02 8.8232384369704E-03 3.2839757225619E+01 8.1612268195679E+03 + 5 4.0000000000000E-02 8.9587658769047E-03 2.4550591844940E+01 6.2914344955091E+03 + 6 5.0000000000000E-02 9.1332345557351E-03 1.8181318747892E+01 4.8599856052453E+03 + 7 6.0000000000000E-02 9.3468075437353E-03 1.3318088324809E+01 3.7624359065834E+03 + 8 7.0000000000000E-02 9.5996827507556E-03 9.6360345233155E+00 2.9200893248911E+03 + 9 8.0000000000000E-02 9.8920920969573E-03 6.8783634318632E+00 2.2731936239226E+03 + 10 9.0000000000000E-02 1.0224300541455E-02 4.8415521791725E+00 1.7761919148744E+03 + 11 1.0000000000000E-01 1.0596604973079E-02 3.3641775581878E+00 1.3942558689869E+03 + 12 1.1000000000000E-01 1.1009332968024E-02 2.3182557500211E+00 1.1007057721649E+03 + 13 1.2000000000000E-01 1.1462841419657E-02 1.6024416906498E+00 8.7507203208413E+02 + 14 1.3000000000000E-01 1.1957515046225E-02 1.1366493180986E+00 7.0163026657095E+02 + 15 1.4000000000000E-01 1.2493764782630E-02 8.5777485969639E-01 5.6828980011358E+02 + 16 1.5000000000000E-01 1.3072026062808E-02 7.1628473524584E-01 4.6574760562645E+02 + 17 1.6000000000000E-01 1.3692756999557E-02 6.7348603737343E-01 3.8684253830092E+02 + 18 1.7000000000000E-01 1.4356436468958E-02 6.9933901406702E-01 3.2606125463045E+02 + 19 1.8000000000000E-01 1.5063562106716E-02 7.7070182241027E-01 2.7915936587647E+02 + 20 1.9000000000000E-01 1.5814648223932E-02 8.6992083583428E-01 2.4287037940507E+02 + 21 2.0000000000000E-01 1.6610223649912E-02 9.8369718922413E-01 2.1468170287545E+02 + 22 2.1000000000000E-01 1.7450829509682E-02 1.1021740368940E+00 1.9266204058085E+02 + 23 2.2000000000000E-01 1.8337016943899E-02 1.2182007197101E+00 1.7532831560770E+02 + 24 2.3000000000000E-01 1.9269344778762E-02 1.3267401671993E+00 1.6154308502927E+02 + 25 2.4000000000000E-01 2.0248377153498E-02 1.4243938149977E+00 1.5043550162417E+02 + 26 2.5000000000000E-01 2.1274681112826E-02 1.5090235409282E+00 1.4134042574400E+02 + 27 2.6000000000000E-01 2.2348824171650E-02 1.5794530552868E+00 1.3375147982320E+02 + 28 2.7000000000000E-01 2.3471371859025E-02 1.6352330425239E+00 1.2728477940860E+02 + 29 2.8000000000000E-01 2.4642885248216E-02 1.6764563128715E+00 1.2165083517203E+02 + 30 2.9000000000000E-01 2.5863918479405E-02 1.7036117651392E+00 1.1663273414796E+02 + 31 3.0000000000000E-01 2.7135016281310E-02 1.7174687334530E+00 1.1206918444468E+02 + 32 3.1000000000000E-01 2.8456711497715E-02 1.7189856176794E+00 1.0784135433519E+02 + 33 3.2000000000000E-01 2.9829522624566E-02 1.7092382559428E+00 1.0386268061360E+02 + 34 3.3000000000000E-01 3.1253951363016E-02 1.6893644320109E+00 1.0007099773270E+02 + 35 3.4000000000000E-01 3.2730480193438E-02 1.6605215144285E+00 9.6422475144848E+01 + 36 3.5000000000000E-01 3.4259569975168E-02 1.6238546966536E+00 9.2886959127906E+01 + 37 3.6000000000000E-01 3.5841657576397E-02 1.5804737229338E+00 8.9444403132058E+01 + 38 3.7000000000000E-01 3.7477153538350E-02 1.5314363547450E+00 8.6082140650899E+01 + 39 3.8000000000000E-01 3.9166439777625E-02 1.4777371531793E+00 8.2792809666863E+01 + 40 3.9000000000000E-01 4.0909867330300E-02 1.4203004222736E+00 7.9572780611711E+01 + 41 4.0000000000000E-01 4.2707754141165E-02 1.3599763805148E+00 7.6420973029725E+01 + 42 4.1000000000000E-01 4.4560382901260E-02 1.2975398090408E+00 7.3337971859465E+01 + 43 4.2000000000000E-01 4.6467998936689E-02 1.2336905723784E+00 7.0325374169284E+01 + 44 4.3000000000000E-01 4.8430808151525E-02 1.1690555272853E+00 6.7385312627638E+01 + 45 4.4000000000000E-01 5.0448975027512E-02 1.1041914327081E+00 6.4520113988549E+01 + 46 4.5000000000000E-01 5.2522620683159E-02 1.0395885532884E+00 6.1732060210401E+01 + 47 4.6000000000000E-01 5.4651820994746E-02 9.7567471361306E-01 5.9023227102674E+01 + 48 4.7000000000000E-01 5.6836604781750E-02 9.1281961318296E-01 5.6395381070225E+01 + 49 4.8000000000000E-01 5.9076952059157E-02 8.5133925500690E-01 5.3849918952442E+01 + 50 4.9000000000000E-01 6.1372792359156E-02 7.9150037554519E-01 5.1387839408900E+01 + 51 5.0000000000000E-01 6.3724003124753E-02 7.3352479185273E-01 4.9009736996539E+01 + 52 5.1000000000000E-01 6.6130408177894E-02 6.7759360437747E-01 4.6715812181533E+01 + 53 5.2000000000000E-01 6.8591776264764E-02 6.2385121192990E-01 4.4505892161115E+01 + 54 5.3000000000000E-01 7.1107819681032E-02 5.7240910966399E-01 4.2379458637858E+01 + 55 5.4000000000000E-01 7.3678192979908E-02 5.2334945217457E-01 4.0335679670512E+01 + 56 5.5000000000000E-01 7.6302491765990E-02 4.7672837258211E-01 3.8373443483562E+01 + 57 5.6000000000000E-01 7.8980251578006E-02 4.3257905521061E-01 3.6491392701015E+01 + 58 5.7000000000000E-01 8.1710946863656E-02 3.9091456455448E-01 3.4687957916735E+01 + 59 5.8000000000000E-01 8.4493990049887E-02 3.5173043699648E-01 3.2961389853995E+01 + 60 5.9000000000000E-01 8.7328730712023E-02 3.1500704444450E-01 3.1309789624407E+01 + 61 6.0000000000000E-01 9.0214454845264E-02 2.8071174091872E-01 2.9731136789464E+01 + 62 6.1000000000000E-01 9.3150384242152E-02 2.4880080431823E-01 2.8223315071130E+01 + 63 6.2000000000000E-01 9.6135675979635E-02 2.1922118627575E-01 2.6784135662581E+01 + 64 6.3000000000000E-01 9.9169422019389E-02 1.9191208328604E-01 2.5411358165286E+01 + 65 6.4000000000000E-01 1.0225064892509E-01 1.6680634226584E-01 2.4102709230998E+01 + 66 6.5000000000000E-01 1.0537831770022E-01 1.4383171344696E-01 2.2855899022410E+01 + 67 6.6000000000000E-01 1.0855132375004E-01 1.2291196308122E-01 2.1668635628383E+01 + 68 6.7000000000000E-01 1.1176849697108E-01 1.0396785789639E-01 2.0538637582135E+01 + 69 6.8000000000000E-01 1.1502860197160E-01 8.6918032624176E-02 1.9463644636048E+01 + 70 6.9000000000000E-01 1.1833033842607E-01 7.1679751256327E-02 1.8441426946850E+01 + 71 7.0000000000000E-01 1.2167234156654E-01 5.8169571995292E-02 1.7469792821346E+01 + 72 7.1000000000000E-01 1.2505318281373E-01 4.6303925171861E-02 1.6546595166693E+01 + 73 7.2000000000000E-01 1.2847137054994E-01 3.5999612715368E-02 1.5669736781484E+01 + 74 7.3000000000000E-01 1.3192535103596E-01 2.7174237094128E-02 1.4837174615052E+01 + 75 7.4000000000000E-01 1.3541350947350E-01 1.9746567001255E-02 1.4046923113154E+01 + 76 7.5000000000000E-01 1.3893417121438E-01 1.3636846449018E-02 1.3297056758700E+01 + 77 7.6000000000000E-01 1.4248560311708E-01 8.7670533567250E-03 1.2585711906897E+01 + 78 7.7000000000000E-01 1.4606601505105E-01 5.0611131745418E-03 1.1911088005111E+01 + 79 7.8000000000000E-01 1.4967356154832E-01 2.4450725792234E-03 1.1271448279079E+01 + 80 7.9000000000000E-01 1.5330634360156E-01 8.4723780763307E-04 1.0665119958934E+01 + 81 8.0000000000000E-01 1.5696241060725E-01 1.9828175920176E-04 1.0090494111331E+01 + 82 8.1000000000000E-01 1.6063976245176E-01 4.3132359808715E-04 9.5460251361205E+00 + 83 8.2000000000000E-01 1.6433635173780E-01 1.4819842182580E-03 9.0302299802279E+00 + 84 8.3000000000000E-01 1.6805008614782E-01 3.2884205983285E-03 8.5416871151734E+00 + 85 8.4000000000000E-01 1.7177883094043E-01 5.7913417659188E-03 8.0790353193568E+00 + 86 8.5000000000000E-01 1.7552041157535E-01 8.9340088117211E-03 7.6409723012677E+00 + 87 8.6000000000000E-01 1.7927261646155E-01 1.2662221139403E-02 7.2262531953980E+00 + 88 8.7000000000000E-01 1.8303319982268E-01 1.6924290907114E-02 6.8336889586412E+00 + 89 8.8000000000000E-01 1.8679988467342E-01 2.1671007407768E-02 6.4621446913872E+00 + 90 8.9000000000000E-01 1.9057036589964E-01 2.6855592946811E-02 6.1105379043249E+00 + 91 9.0000000000000E-01 1.9434231343452E-01 3.2433651605955E-02 5.7778367491090E+00 + 92 9.1000000000000E-01 1.9811337552261E-01 3.8363112127921E-02 5.4630582285084E+00 + 93 9.2000000000000E-01 2.0188118206302E-01 4.4604166019045E-02 5.1652663994001E+00 + 94 9.3000000000000E-01 2.0564334802239E-01 5.1119201842062E-02 4.8835705799775E+00 + 95 9.4000000000000E-01 2.0939747690813E-01 5.7872736559509E-02 4.6171235707807E+00 + 96 9.5000000000000E-01 2.1314116429165E-01 6.4831344687400E-02 4.3651198976060E+00 + 97 9.6000000000000E-01 2.1687200137139E-01 7.1963585928340E-02 4.1267940829897E+00 + 98 9.7000000000000E-01 2.2058757856462E-01 7.9239931871725E-02 3.9014189517697E+00 + 99 9.8000000000000E-01 2.2428548911738E-01 8.6632692275554E-02 3.6883039751864E+00 + 100 9.9000000000000E-01 2.2796333272100E-01 9.4115941378420E-02 3.4867936570778E+00 + 101 1.0000000000000E+00 2.3161871912433E-01 1.0166544463115E-01 3.2962659649382E+00 + 102 1.0100000000000E+00 2.3524927172995E-01 1.0925858618419E-01 3.1161308079278E+00 + 103 1.0200000000000E+00 2.3885263116330E-01 1.1687429741915E-01 2.9458285633342E+00 + 104 1.0300000000000E+00 2.4242645880322E-01 1.2449298676954E-01 2.7848286524845E+00 + 105 1.0400000000000E+00 2.4596844026285E-01 1.3209647103770E-01 2.6326281666718E+00 + 106 1.0500000000000E+00 2.4947628880991E-01 1.3966790837952E-01 2.4887505432976E+00 + 107 1.0600000000000E+00 2.5294774871555E-01 1.4719173309815E-01 2.3527442921161E+00 + 108 1.0700000000000E+00 2.5638059852141E-01 1.5465359235981E-01 2.2241817712071E+00 + 109 1.0800000000000E+00 2.5977265421485E-01 1.6204028492001E-01 2.1026580120808E+00 + 110 1.0900000000000E+00 2.6312177230268E-01 1.6933970192670E-01 1.9877895931406E+00 + 111 1.1000000000000E+00 2.6642585277430E-01 1.7654076984702E-01 1.8792135605717E+00 + 112 1.1100000000000E+00 2.6968284194564E-01 1.8363339554699E-01 1.7765863956070E+00 + 113 1.1200000000000E+00 2.7289073517586E-01 1.9060841353847E-01 1.6795830270181E+00 + 114 1.1300000000000E+00 2.7604757944942E-01 1.9745753539344E-01 1.5878958876029E+00 + 115 1.1400000000000E+00 2.7915147581686E-01 2.0417330131444E-01 1.5012340133797E+00 + 116 1.1500000000000E+00 2.8220058168814E-01 2.1074903383852E-01 1.4193221841530E+00 + 117 1.1600000000000E+00 2.8519311297343E-01 2.1717879364292E-01 1.3419001040841E+00 + 118 1.1700000000000E+00 2.8812734606658E-01 2.2345733741168E-01 1.2687216208781E+00 + 119 1.1800000000000E+00 2.9100161966782E-01 2.2958007771432E-01 1.1995539821900E+00 + 120 1.1900000000000E+00 2.9381433644242E-01 2.3554304483998E-01 1.1341771278493E+00 + 121 1.2000000000000E+00 2.9656396451341E-01 2.4134285052305E-01 1.0723830165083E+00 + 122 1.2100000000000E+00 2.9924903878685E-01 2.4697665348876E-01 1.0139749853329E+00 + 123 1.2200000000000E+00 3.0186816210922E-01 2.5244212673998E-01 9.5876714137103E-01 + 124 1.2300000000000E+00 3.0442000625707E-01 2.5773742649877E-01 9.0658378325825E-01 + 125 1.2400000000000E+00 3.0690331276010E-01 2.6286116270858E-01 8.5725885194928E-01 + 126 1.2500000000000E+00 3.0931689355936E-01 2.6781237099546E-01 8.1063540919539E-01 + 127 1.2600000000000E+00 3.1165963150326E-01 2.7259048597886E-01 7.6656514252476E-01 + 128 1.2700000000000E+00 3.1393048068453E-01 2.7719531581594E-01 7.2490789552332E-01 + 129 1.2800000000000E+00 3.1612846662214E-01 2.8162701785681E-01 6.8553122225633E-01 + 130 1.2900000000000E+00 3.1825268629280E-01 2.8588607528374E-01 6.4830996471684E-01 + 131 1.3000000000000E+00 3.2030230801726E-01 2.8997327460480E-01 6.1312585223548E-01 + 132 1.3100000000000E+00 3.2227657120708E-01 2.9388968387245E-01 5.7986712183515E-01 + 133 1.3200000000000E+00 3.2417478597828E-01 2.9763663150203E-01 5.4842815856452E-01 + 134 1.3300000000000E+00 3.2599633263849E-01 3.0121568557280E-01 5.1870915489450E-01 + 135 1.3400000000000E+00 3.2774066105485E-01 3.0462863350783E-01 4.9061578831091E-01 + 136 1.3500000000000E+00 3.2940728991004E-01 3.0787746204769E-01 4.6405891628342E-01 + 137 1.3600000000000E+00 3.3099580585438E-01 3.1096433745675E-01 4.3895428783485E-01 + 138 1.3700000000000E+00 3.3250586256185E-01 3.1389158593064E-01 4.1522227097430E-01 + 139 1.3800000000000E+00 3.3393717969833E-01 3.1666167420689E-01 3.9278759529188E-01 + 140 1.3900000000000E+00 3.3528954181041E-01 3.1927719041805E-01 3.7157910904115E-01 + 141 1.4000000000000E+00 3.3656279714299E-01 3.2174082526403E-01 3.5152955005700E-01 + 142 1.4100000000000E+00 3.3775685639415E-01 3.2405535361818E-01 3.3257532987198E-01 + 143 1.4200000000000E+00 3.3887169141562E-01 3.2622361671402E-01 3.1465633040322E-01 + 144 1.4300000000000E+00 3.3990733386692E-01 3.2824850508652E-01 2.9771571258554E-01 + 145 1.4400000000000E+00 3.4086387383122E-01 3.3013294245884E-01 2.8169973632637E-01 + 146 1.4500000000000E+00 3.4174145840085E-01 3.3187987077105E-01 2.6655759115582E-01 + 147 1.4600000000000E+00 3.4254029023979E-01 3.3349223654028E-01 2.5224123694274E-01 + 148 1.4700000000000E+00 3.4326062613045E-01 3.3497297872060E-01 2.3870525404797E-01 + 149 1.4800000000000E+00 3.4390277551163E-01 3.3632501819793E-01 2.2590670228983E-01 + 150 1.4900000000000E+00 3.4446709901401E-01 3.3755124901015E-01 2.1380498810759E-01 + 151 1.5000000000000E+00 3.4495400699931E-01 3.3865453133112E-01 2.0236173932613E-01 + 152 1.5100000000000E+00 3.4536395810866E-01 3.3963768620013E-01 1.9154068695073E-01 + 153 1.5200000000000E+00 3.4569745782517E-01 3.4050349192251E-01 1.8130755345361E-01 + 154 1.5300000000000E+00 3.4595505705540E-01 3.4125468201446E-01 1.7162994705420E-01 + 155 1.5400000000000E+00 3.4613735073382E-01 3.4189394452130E-01 1.6247726153933E-01 + 156 1.5500000000000E+00 3.4624497645360E-01 3.4242392250444E-01 1.5382058121764E-01 + 157 1.5600000000000E+00 3.4627861312692E-01 3.4284721547158E-01 1.4563259065107E-01 + 158 1.5700000000000E+00 3.4623897967711E-01 3.4316638151647E-01 1.3788748885345E-01 + 159 1.5800000000000E+00 3.4612683376461E-01 3.4338393993892E-01 1.3056090768738E-01 + 160 1.5900000000000E+00 3.4594297054804E-01 3.4350237413116E-01 1.2362983424536E-01 + 161 1.6000000000000E+00 3.4568822148133E-01 3.4352413453990E-01 1.1707253699184E-01 + 162 1.6100000000000E+00 3.4536345314716E-01 3.4345164154329E-01 1.1086849553548E-01 + 163 1.6200000000000E+00 3.4496956612661E-01 3.4328728811562E-01 1.0499833386165E-01 + 164 1.6300000000000E+00 3.4450749390443E-01 3.4303344218400E-01 9.9443756900674E-02 + 165 1.6400000000000E+00 3.4397820180889E-01 3.4269244861533E-01 9.4187490311701E-02 + 166 1.6500000000000E+00 3.4338268598468E-01 3.4226663079957E-01 8.9213223366238E-02 + 167 1.6600000000000E+00 3.4272197239719E-01 3.4175829182042E-01 8.4505554819492E-02 + 168 1.6700000000000E+00 3.4199711586584E-01 3.4116971522471E-01 8.0049941658134E-02 + 169 1.6800000000000E+00 3.4120919912423E-01 3.4050316541689E-01 7.5832650612780E-02 + 170 1.6900000000000E+00 3.4035933190408E-01 3.3976088771597E-01 7.1840712322422E-02 + 171 1.7000000000000E+00 3.3944865004038E-01 3.3894510811885E-01 6.8061878037022E-02 + 172 1.7100000000000E+00 3.3847831459434E-01 3.3805803281712E-01 6.4484578743844E-02 + 173 1.7200000000000E+00 3.3744951099112E-01 3.3710184751499E-01 6.1097886603064E-02 + 174 1.7300000000000E+00 3.3636344816882E-01 3.3607871659427E-01 5.7891478578897E-02 + 175 1.7400000000000E+00 3.3522135773554E-01 3.3499078216898E-01 5.4855602153993E-02 + 176 1.7500000000000E+00 3.3402449313096E-01 3.3384016306818E-01 5.1981043017084E-02 + 177 1.7600000000000E+00 3.3277412878922E-01 3.3262895378089E-01 4.9259094616739E-02 + 178 1.7700000000000E+00 3.3147155929974E-01 3.3135922339175E-01 4.6681529477529E-02 + 179 1.7800000000000E+00 3.3011809856286E-01 3.3003301453190E-01 4.4240572178815E-02 + 180 1.7900000000000E+00 3.2871507893744E-01 3.2865234236423E-01 4.1928873900508E-02 + 181 1.8000000000000E+00 3.2726385037730E-01 3.2721919361862E-01 3.9739488444602E-02 + 182 1.8100000000000E+00 3.2576577955429E-01 3.2573552568871E-01 3.7665849645754E-02 + 183 1.8200000000000E+00 3.2422224896540E-01 3.2420326579859E-01 3.5701750088761E-02 + 184 1.8300000000000E+00 3.2263465602195E-01 3.2262431024507E-01 3.3841321055241E-02 + 185 1.8400000000000E+00 3.2100441212181E-01 3.2100052371865E-01 3.2079013626260E-02 + 186 1.8500000000000E+00 3.1933294170812E-01 3.1933373870482E-01 3.0409580871907E-02 + 187 1.8600000000000E+00 3.1762168130647E-01 3.1762575496524E-01 2.8828061062920E-02 + 188 1.8700000000000E+00 3.1587207852599E-01 3.1587833909753E-01 2.7329761843389E-02 + 189 1.8800000000000E+00 3.1408559102910E-01 3.1409322417139E-01 2.5910245307306E-02 + 190 1.8900000000000E+00 3.1226368548404E-01 3.1227210943794E-01 2.4565313925234E-02 + 191 1.9000000000000E+00 3.1040783648594E-01 3.1041666010880E-01 2.3290997270698E-02 + 192 1.9100000000000E+00 3.0851952543018E-01 3.0852850720111E-01 2.2083539499048E-02 + 193 1.9200000000000E+00 3.0660023944030E-01 3.0660924744446E-01 2.0939387534454E-02 + 194 1.9300000000000E+00 3.0465147007379E-01 3.0466044324562E-01 1.9855179923461E-02 + 195 1.9400000000000E+00 3.0267470801257E-01 3.0268362270695E-01 1.8827736316099E-02 + 196 1.9500000000000E+00 3.0067143153747E-01 3.0068027969450E-01 1.7854047537942E-02 + 197 1.9600000000000E+00 2.9864309427517E-01 2.9865187395181E-01 1.6931266218772E-02 + 198 1.9700000000000E+00 2.9659112090076E-01 2.9659983125569E-01 1.6056697945629E-02 + 199 1.9800000000000E+00 2.9451690392460E-01 2.9452554361037E-01 1.5227792909917E-02 + 200 1.9900000000000E+00 2.9242180152949E-01 2.9243036947658E-01 1.4442138020170E-02 + 201 2.0000000000000E+00 2.9030713851166E-01 2.9031563403231E-01 1.3697449453738E-02 + 202 2.0100000000000E+00 2.8817420715610E-01 2.8818262946231E-01 1.2991565622273E-02 + 203 2.0200000000000E+00 2.8602426686199E-01 2.8603261527345E-01 1.2322440527402E-02 + 204 2.0300000000000E+00 2.8385854473914E-01 2.8386681863331E-01 1.1688137484384E-02 + 205 2.0400000000000E+00 2.8167823591561E-01 2.8168643472961E-01 1.1086823192846E-02 + 206 2.0500000000000E+00 2.7948450391913E-01 2.7949262714808E-01 1.0516762134925E-02 + 207 2.0600000000000E+00 2.7727848107219E-01 2.7728652826692E-01 9.9763112823504E-03 + 208 2.0700000000000E+00 2.7506126890062E-01 2.7506923966567E-01 9.4639150949990E-03 + 209 2.0800000000000E+00 2.7283393855527E-01 2.7284183254690E-01 8.9781007945424E-03 + 210 2.0900000000000E+00 2.7059753124470E-01 2.7060534816893E-01 8.5174738977439E-03 + 211 2.1000000000000E+00 2.6835305867751E-01 2.6836079828826E-01 8.0807139947922E-03 + 212 2.1100000000000E+00 2.6610150351290E-01 2.6610916561015E-01 7.6665707590124E-03 + 213 2.1200000000000E+00 2.6384381981822E-01 2.6385140424620E-01 7.2738601749955E-03 + 214 2.1300000000000E+00 2.6158093353228E-01 2.6158844017775E-01 6.9014609729602E-03 + 215 2.1400000000000E+00 2.5931374293343E-01 2.5932117172396E-01 6.5483112578863E-03 + 216 2.1500000000000E+00 2.5704311911137E-01 2.5705047001371E-01 6.2134053225235E-03 + 217 2.1600000000000E+00 2.5476990644190E-01 2.5477717946035E-01 5.8957906341206E-03 + 218 2.1700000000000E+00 2.5249492306362E-01 2.5250211823848E-01 5.5945649852098E-03 + 219 2.1800000000000E+00 2.5021896135599E-01 2.5022607876204E-01 5.3088737993699E-03 + 220 2.1900000000000E+00 2.4794278841800E-01 2.4794982816303E-01 5.0379075833817E-03 + 221 2.2000000000000E+00 2.4566714654678E-01 2.4567410877014E-01 4.7808995176799E-03 + 222 2.2100000000000E+00 2.4339275371562E-01 2.4339963858684E-01 4.5371231774870E-03 + 223 2.2200000000000E+00 2.4112030405089E-01 2.4112711176832E-01 4.3058903774138E-03 + 224 2.2300000000000E+00 2.3885046830728E-01 2.3885719909678E-01 4.0865491327388E-03 + 225 2.2400000000000E+00 2.3658389434101E-01 2.3659054845471E-01 3.8784817309127E-03 + 226 2.2500000000000E+00 2.3432120758061E-01 2.3432778529561E-01 3.6811029072740E-03 + 227 2.2600000000000E+00 2.3206301149474E-01 2.3206951311198E-01 3.4938581192347E-03 + 228 2.2700000000000E+00 2.2980988805693E-01 2.2981631389999E-01 3.3162219135516E-03 + 229 2.2800000000000E+00 2.2756239820675E-01 2.2756874862074E-01 3.1476963815483E-03 + 230 2.2900000000000E+00 2.2532108230721E-01 2.2532735765770E-01 2.9878096975173E-03 + 231 2.3000000000000E+00 2.2308646059812E-01 2.2309266127006E-01 2.8361147357403E-03 + 232 2.3100000000000E+00 2.2085903364511E-01 2.2086516004182E-01 2.6921877618321E-03 + 233 2.3200000000000E+00 2.1863928278419E-01 2.1864533532638E-01 2.5556271943395E-03 + 234 2.3300000000000E+00 2.1642767056156E-01 2.1643364968637E-01 2.4260524327900E-03 + 235 2.3400000000000E+00 2.1422464116854E-01 2.1423054732864E-01 2.3031027485747E-03 + 236 2.3500000000000E+00 2.1203062087146E-01 2.1203645453413E-01 2.1864362352136E-03 + 237 2.3600000000000E+00 2.0984601843631E-01 2.0985178008258E-01 2.0757288148054E-03 + 238 2.3700000000000E+00 2.0767122554805E-01 2.0767691567190E-01 1.9706732976080E-03 + 239 2.3800000000000E+00 2.0550661722452E-01 2.0551223633207E-01 1.8709784918695E-03 + 240 2.3900000000000E+00 2.0335255222473E-01 2.0335810083342E-01 1.7763683611597E-03 + 241 2.4000000000000E+00 2.0120937345147E-01 2.0121485208937E-01 1.6865812266638E-03 + 242 2.4100000000000E+00 1.9907740834824E-01 1.9908281755331E-01 1.6013690120056E-03 + 243 2.4200000000000E+00 1.9695696929032E-01 1.9696230960970E-01 1.5204965282645E-03 + 244 2.4300000000000E+00 1.9484835396996E-01 1.9485362595933E-01 1.4437407970509E-03 + 245 2.4400000000000E+00 1.9275184577566E-01 1.9275704999855E-01 1.3708904095870E-03 + 246 2.4500000000000E+00 1.9066771416544E-01 1.9067285119265E-01 1.3017449198285E-03 + 247 2.4600000000000E+00 1.8859621503411E-01 1.8860128544311E-01 1.2361142698054E-03 + 248 2.4700000000000E+00 1.8653759107451E-01 1.8654259544884E-01 1.1738182454607E-03 + 249 2.4800000000000E+00 1.8449207213266E-01 1.8449701106139E-01 1.1146859613332E-03 + 250 2.4900000000000E+00 1.8245987555686E-01 1.8246474963406E-01 1.0585553725257E-03 + 251 2.5000000000000E+00 1.8044120654067E-01 1.8044601636489E-01 1.0052728125221E-03 + 252 2.5100000000000E+00 1.7843625845984E-01 1.7844100463363E-01 9.5469255544837E-04 + 253 2.5200000000000E+00 1.7644521320313E-01 1.7644989633256E-01 9.0667640145835E-04 + 254 2.5300000000000E+00 1.7446824149708E-01 1.7447286219130E-01 8.6109328403189E-04 + 255 2.5400000000000E+00 1.7250550322472E-01 1.7251006209548E-01 8.1781889799970E-04 + 256 2.5500000000000E+00 1.7055714773821E-01 1.7056164539951E-01 7.7673534717242E-04 + 257 2.5600000000000E+00 1.6862331416556E-01 1.6862775123320E-01 7.3773081055709E-04 + 258 2.5700000000000E+00 1.6670413171125E-01 1.6670850880246E-01 7.0069922614999E-04 + 259 2.5800000000000E+00 1.6479971995101E-01 1.6480403768411E-01 6.6553999136024E-04 + 260 2.5900000000000E+00 1.6291018912066E-01 1.6291444811467E-01 6.3215767920583E-04 + 261 2.6000000000000E+00 1.6103564039903E-01 1.6103984127336E-01 6.0046176941822E-04 + 262 2.6100000000000E+00 1.5917616618516E-01 1.5918030955926E-01 5.7036639366354E-04 + 263 2.6200000000000E+00 1.5733185036961E-01 1.5733593686270E-01 5.4179009415273E-04 + 264 2.6300000000000E+00 1.5550276860017E-01 1.5550679883093E-01 5.1465559489950E-04 + 265 2.6400000000000E+00 1.5368898854180E-01 1.5369296312808E-01 4.8888958496841E-04 + 266 2.6500000000000E+00 1.5189057013102E-01 1.5189448968960E-01 4.6442251309282E-04 + 267 2.6600000000000E+00 1.5010756582472E-01 1.5011143097102E-01 4.4118839302322E-04 + 268 2.6700000000000E+00 1.4834002084345E-01 1.4834383219132E-01 4.1912461907058E-04 + 269 2.6800000000000E+00 1.4658797340938E-01 1.4659173157086E-01 3.9817179129826E-04 + 270 2.6900000000000E+00 1.4485145497877E-01 1.4485516056385E-01 3.7827354983077E-04 + 271 2.7000000000000E+00 1.4313049046920E-01 1.4313414408564E-01 3.5937641783087E-04 + 272 2.7100000000000E+00 1.4142509848158E-01 1.4142870073473E-01 3.4142965266279E-04 + 273 2.7200000000000E+00 1.3973529151702E-01 1.3973884300955E-01 3.2438510481204E-04 + 274 2.7300000000000E+00 1.3806107618848E-01 1.3806457752030E-01 3.0819708417385E-04 + 275 2.7400000000000E+00 1.3640245342758E-01 1.3640590519561E-01 2.9282223328736E-04 + 276 2.7500000000000E+00 1.3475941868631E-01 1.3476282148435E-01 2.7821940717982E-04 + 277 2.7600000000000E+00 1.3313196213399E-01 1.3313531655255E-01 2.6434955946258E-04 + 278 2.7700000000000E+00 1.3152006884929E-01 1.3152337547546E-01 2.5117563433755E-04 + 279 2.7800000000000E+00 1.2992371900767E-01 1.2992697842499E-01 2.3866246423091E-04 + 280 2.7900000000000E+00 1.2834288806407E-01 1.2834610085239E-01 2.2677667272901E-04 + 281 2.8000000000000E+00 1.2677754693106E-01 1.2678071366643E-01 2.1548658255726E-04 + 282 2.8100000000000E+00 1.2522766215246E-01 1.2523078340703E-01 2.0476212833674E-04 + 283 2.8200000000000E+00 1.2369319607263E-01 1.2369627241451E-01 1.9457477385074E-04 + 284 2.8300000000000E+00 1.2217410700125E-01 1.2217713899448E-01 1.8489743361288E-04 + 285 2.8400000000000E+00 1.2067034937403E-01 1.2067333757841E-01 1.7570439848371E-04 + 286 2.8500000000000E+00 1.1918187390902E-01 1.1918481888008E-01 1.6697126514242E-04 + 287 2.8600000000000E+00 1.1770862775897E-01 1.1771153004787E-01 1.5867486920885E-04 + 288 2.8700000000000E+00 1.1625055465953E-01 1.1625341481299E-01 1.5079322181272E-04 + 289 2.8800000000000E+00 1.1480759507356E-01 1.1481041363381E-01 1.4330544945397E-04 + 290 2.8900000000000E+00 1.1337968633152E-01 1.1338246383620E-01 1.3619173695401E-04 + 291 2.9000000000000E+00 1.1196676276800E-01 1.1196949975016E-01 1.2943327336135E-04 + 292 2.9100000000000E+00 1.1056875585460E-01 1.1057145284259E-01 1.2301220064343E-04 + 293 2.9200000000000E+00 1.0918559432905E-01 1.0918825184651E-01 1.1691156502041E-04 + 294 2.9300000000000E+00 1.0781720432080E-01 1.0781982288660E-01 1.1111527081530E-04 + 295 2.9400000000000E+00 1.0646350947302E-01 1.0646608960125E-01 1.0560803666787E-04 + 296 2.9500000000000E+00 1.0512443106127E-01 1.0512697326116E-01 1.0037535401539E-04 + 297 2.9600000000000E+00 1.0379988810862E-01 1.0380239288455E-01 9.5403447698121E-05 + 298 2.9700000000000E+00 1.0248979749763E-01 1.0249226534908E-01 9.0679238597210E-05 + 299 2.9800000000000E+00 1.0119407407897E-01 1.0119650550052E-01 8.6190308190311E-05 + 300 2.9900000000000E+00 9.9912630776958E-02 9.9915026258251E-02 8.1924864925126E-05 + 301 3.0000000000000E+00 9.8645378691939E-02 9.8647738717675E-02 7.7871712325860E-05 + 302 3.0100000000000E+00 9.7392227199670E-02 9.7394552249588E-02 7.4020218726139E-05 + 303 3.0200000000000E+00 9.6153084047721E-02 9.6155374596594E-02 7.0360288565758E-05 + 304 3.0300000000000E+00 9.4927855448992E-02 9.4930111966617E-02 6.6882335147142E-05 + 305 3.0400000000000E+00 9.3716446172386E-02 9.3718669123586E-02 6.3577254797059E-05 + 306 3.0500000000000E+00 9.2518759630724E-02 9.2520949475343E-02 6.0436402344879E-05 + 307 3.0600000000000E+00 9.1334697965950E-02 9.1336855158857E-02 5.7451567859222E-05 + 308 3.0700000000000E+00 9.0164162131697E-02 9.0166287122788E-02 5.4614954574284E-05 + 309 3.0800000000000E+00 8.9007051973273E-02 8.9009145207479E-02 5.1919157942416E-05 + 310 3.0900000000000E+00 8.7863266305124E-02 8.7865328222422E-02 4.9357145762122E-05 + 311 3.1000000000000E+00 8.6732702985847E-02 8.6734734021266E-02 4.6922239314061E-05 + 312 3.1100000000000E+00 8.5615258990793E-02 8.5617259574430E-02 4.4608095469051E-05 + 313 3.1200000000000E+00 8.4510830482330E-02 8.4512801039365E-02 4.2408689699349E-05 + 314 3.1300000000000E+00 8.3419312877827E-02 8.3421253828538E-02 4.0318299966167E-05 + 315 3.1400000000000E+00 8.2340600915401E-02 8.2342512675184E-02 3.8331491420027E-05 + 316 3.1500000000000E+00 8.1274588717492E-02 8.1276471696879E-02 3.6443101888028E-05 + 317 3.1600000000000E+00 8.0221169852320E-02 8.0223024457001E-02 3.4648228094713E-05 + 318 3.1700000000000E+00 7.9180237393269E-02 7.9182064024117E-02 3.2942212588621E-05 + 319 3.1800000000000E+00 7.8151683976265E-02 7.8153483029355E-02 3.1320631331448E-05 + 320 3.1900000000000E+00 7.7135401855180E-02 7.7137173721819E-02 2.9779281919950E-05 + 321 3.2000000000000E+00 7.6131282955329E-02 7.6133028022083E-02 2.8314172406455E-05 + 322 3.2100000000000E+00 7.5139218925101E-02 7.5140937573826E-02 2.6921510686753E-05 + 323 3.2200000000000E+00 7.4159101185770E-02 7.4160793793623E-02 2.5597694428801E-05 + 324 3.2300000000000E+00 7.3190820979547E-02 7.3192487919005E-02 2.4339301510295E-05 + 325 3.2400000000000E+00 7.2234269415895E-02 7.2235911054819E-02 2.3143080944821E-05 + 326 3.2500000000000E+00 7.1289337516180E-02 7.1290954217866E-02 2.2005944264514E-05 + 327 3.2600000000000E+00 7.0355916256684E-02 7.0357508379867E-02 2.0924957344050E-05 + 328 3.2700000000000E+00 6.9433896610027E-02 6.9435464508911E-02 1.9897332634334E-05 + 329 3.2800000000000E+00 6.8523169585050E-02 6.8524713609344E-02 1.8920421794749E-05 + 330 3.2900000000000E+00 6.7623626265185E-02 6.7625146760142E-02 1.7991708693246E-05 + 331 3.3000000000000E+00 6.6735157845368E-02 6.6736655151821E-02 1.7108802766288E-05 + 332 3.3100000000000E+00 6.5857655667533E-02 6.5859130121923E-02 1.6269432709198E-05 + 333 3.3200000000000E+00 6.4991011254704E-02 6.4992463189126E-02 1.5471440491334E-05 + 334 3.3300000000000E+00 6.4135116343768E-02 6.4136546086001E-02 1.4712775668177E-05 + 335 3.3400000000000E+00 6.3289862916912E-02 6.3291270790461E-02 1.3991489986547E-05 + 336 3.3500000000000E+00 6.2455143231814E-02 6.2456529555946E-02 1.3305732256767E-05 + 337 3.3600000000000E+00 6.1630849850576E-02 6.1632214940359E-02 1.2653743489276E-05 + 338 3.3700000000000E+00 6.0816875667478E-02 6.0818219833817E-02 1.2033852271368E-05 + 339 3.3800000000000E+00 6.0013113935542E-02 6.0014437485223E-02 1.1444470382422E-05 + 340 3.3900000000000E+00 5.9219458291989E-02 5.9220761527713E-02 1.0884088625271E-05 + 341 3.4000000000000E+00 5.8435802782572E-02 5.8437086002998E-02 1.0351272872557E-05 + 342 3.4100000000000E+00 5.7662041884860E-02 5.7663305384641E-02 9.8446603077523E-06 + 343 3.4200000000000E+00 5.6898070530467E-02 5.6899314600295E-02 9.3629558599003E-06 + 344 3.4300000000000E+00 5.6143784126295E-02 5.6145009052934E-02 8.9049288138097E-06 + 345 3.4400000000000E+00 5.5399078574778E-02 5.5400284641110E-02 8.4694095946946E-06 + 346 3.4500000000000E+00 5.4663850293194E-02 5.4665037778257E-02 8.0552867111009E-06 + 347 3.4600000000000E+00 5.3937996232052E-02 5.3939165411079E-02 7.6615038548037E-06 + 348 3.4700000000000E+00 5.3221413892587E-02 5.3222565037048E-02 7.2870571436462E-06 + 349 3.4800000000000E+00 5.2514001343387E-02 5.2515134721028E-02 6.9309925055063E-06 + 350 3.4900000000000E+00 5.1815657236186E-02 5.1816773111069E-02 6.5924031914947E-06 + 351 3.5000000000000E+00 5.1126280820841E-02 5.1127379453386E-02 6.2704274159069E-06 + 352 3.5100000000000E+00 5.0445771959520E-02 5.0446853606544E-02 5.9642461131645E-06 + 353 3.5200000000000E+00 4.9774031140130E-02 4.9775096054887E-02 5.6730808084641E-06 + 354 3.5300000000000E+00 4.9110959488997E-02 4.9112007921218E-02 5.3961915944845E-06 + 355 3.5400000000000E+00 4.8456458782839E-02 4.8457490978771E-02 5.1328752099624E-06 + 356 3.5500000000000E+00 4.7810431460034E-02 4.7811447662483E-02 4.8824632145601E-06 + 357 3.5600000000000E+00 4.7172780631225E-02 4.7173781079593E-02 4.6443202548681E-06 + 358 3.5700000000000E+00 4.6543410089265E-02 4.6544395019590E-02 4.4178424179596E-06 + 359 3.5800000000000E+00 4.5922224318541E-02 4.5923193963535E-02 4.2024556663651E-06 + 360 3.5900000000000E+00 4.5309128503676E-02 4.5310083092768E-02 3.9976143527556E-06 + 361 3.6000000000000E+00 4.4704028537653E-02 4.4704968297026E-02 3.8027998072763E-06 + 362 3.6100000000000E+00 4.4106831029361E-02 4.4107756181990E-02 3.6175189975130E-06 + 363 3.6200000000000E+00 4.3517443310591E-02 4.3518354076281E-02 3.4413032532923E-06 + 364 3.6300000000000E+00 4.2935773442493E-02 4.2936670037921E-02 3.2737070575008E-06 + 365 3.6400000000000E+00 4.2361730221527E-02 4.2362612860278E-02 3.1143068951474E-06 + 366 3.6500000000000E+00 4.1795223184906E-02 4.1796092077510E-02 2.9627001618242E-06 + 367 3.6600000000000E+00 4.1236162615559E-02 4.1237017969531E-02 2.8185041251779E-06 + 368 3.6700000000000E+00 4.0684459546633E-02 4.0685301566508E-02 2.6813549392953E-06 + 369 3.6800000000000E+00 4.0140025765536E-02 4.0140854652910E-02 2.5509067076385E-06 + 370 3.6900000000000E+00 3.9602773817558E-02 3.9603589771122E-02 2.4268305929457E-06 + 371 3.7000000000000E+00 3.9072617009062E-02 3.9073420224638E-02 2.3088139717153E-06 + 372 3.7100000000000E+00 3.8549469410275E-02 3.8550260080855E-02 2.1965596302644E-06 + 373 3.7200000000000E+00 3.8033245857690E-02 3.8034024173471E-02 2.0897850017968E-06 + 374 3.7300000000000E+00 3.7523861956088E-02 3.7524628104509E-02 1.9882214402170E-06 + 375 3.7400000000000E+00 3.7021234080203E-02 3.7021988245979E-02 1.8916135316240E-06 + 376 3.7500000000000E+00 3.6525279376031E-02 3.6526021741189E-02 1.7997184385230E-06 + 377 3.7600000000000E+00 3.6035915761805E-02 3.6036646505719E-02 1.7123052780438E-06 + 378 3.7700000000000E+00 3.5553061928648E-02 3.5553781228074E-02 1.6291545300975E-06 + 379 3.7800000000000E+00 3.5076637340907E-02 3.5077345370017E-02 1.5500574755729E-06 + 380 3.7900000000000E+00 3.4606562236193E-02 3.4607259166610E-02 1.4748156622675E-06 + 381 3.8000000000000E+00 3.4142757625127E-02 3.4143443625958E-02 1.4032403971909E-06 + 382 3.8100000000000E+00 3.3685145290813E-02 3.3685820528682E-02 1.3351522646325E-06 + 383 3.8200000000000E+00 3.3233647788036E-02 3.3234312427118E-02 1.2703806673254E-06 + 384 3.8300000000000E+00 3.2788188442209E-02 3.2788842644262E-02 1.2087633914768E-06 + 385 3.8400000000000E+00 3.2348691348070E-02 3.2349335272470E-02 1.1501461922672E-06 + 386 3.8500000000000E+00 3.1915081368144E-02 3.1915715171915E-02 1.0943824008729E-06 + 387 3.8600000000000E+00 3.1487284130977E-02 3.1487907968822E-02 1.0413325503663E-06 + 388 3.8700000000000E+00 3.1065226029150E-02 3.1065840053484E-02 9.9086402043774E-07 + 389 3.8800000000000E+00 3.0648834217082E-02 3.0649438578065E-02 9.4285069982031E-07 + 390 3.8900000000000E+00 3.0238036608644E-02 3.0238631454208E-02 8.9717266504237E-07 + 391 3.9000000000000E+00 2.9832761874563E-02 2.9833347350445E-02 8.5371587577945E-07 + 392 3.9100000000000E+00 2.9432939439659E-02 2.9433515689431E-02 8.1237188448729E-07 + 393 3.9200000000000E+00 2.9038499479893E-02 2.9039066644992E-02 7.7303756118331E-07 + 394 3.9300000000000E+00 2.8649372919261E-02 2.8649931139018E-02 7.3561483128991E-07 + 395 3.9400000000000E+00 2.8265491426512E-02 2.8266040838182E-02 7.0001042674489E-07 + 396 3.9500000000000E+00 2.7886787411726E-02 2.7887328150516E-02 6.6613564944499E-07 + 397 3.9600000000000E+00 2.7513194022738E-02 2.7513726221838E-02 6.3390614608614E-07 + 398 3.9700000000000E+00 2.7144645141429E-02 2.7145168932036E-02 6.0324169468708E-07 + 399 3.9800000000000E+00 2.6781075379878E-02 2.6781590891228E-02 5.7406600101568E-07 + 400 3.9900000000000E+00 2.6422420076393E-02 2.6422927435786E-02 5.4630650566048E-07 + 401 4.0000000000000E+00 2.6068615291419E-02 2.6069114624249E-02 5.1989420026051E-07 + 402 4.0100000000000E+00 2.5719597803339E-02 2.5720089233118E-02 4.9476345293333E-07 + 403 4.0200000000000E+00 2.5375305104155E-02 2.5375788752543E-02 4.7085184246652E-07 + 404 4.0300000000000E+00 2.5035675395082E-02 2.5036151381909E-02 4.4810000034125E-07 + 405 4.0400000000000E+00 2.4700647582032E-02 2.4701116025328E-02 4.2645146103968E-07 + 406 4.0500000000000E+00 2.4370161271016E-02 2.4370622287036E-02 4.0585251925850E-07 + 407 4.0600000000000E+00 2.4044156763456E-02 2.4044610466704E-02 3.8625209450330E-07 + 408 4.0700000000000E+00 2.3722575051418E-02 2.3723021554673E-02 3.6760160225644E-07 + 409 4.0800000000000E+00 2.3405357812768E-02 2.3405797227107E-02 3.4985483136583E-07 + 410 4.0900000000000E+00 2.3092447406253E-02 2.3092879841079E-02 3.3296782780780E-07 + 411 4.1000000000000E+00 2.2783786866526E-02 2.2784212429590E-02 3.1689878375996E-07 + 412 4.1100000000000E+00 2.2479319899096E-02 2.2479738696521E-02 3.0160793250386E-07 + 413 4.1200000000000E+00 2.2178990875226E-02 2.2179403011531E-02 2.8705744830267E-07 + 414 4.1300000000000E+00 2.1882744826783E-02 2.1883150404905E-02 2.7321135121187E-07 + 415 4.1400000000000E+00 2.1590527441022E-02 2.1590926562341E-02 2.6003541676262E-07 + 416 4.1500000000000E+00 2.1302285055342E-02 2.1302677819701E-02 2.4749708979052E-07 + 417 4.1600000000000E+00 2.1017964651987E-02 2.1018351157719E-02 2.3556540280888E-07 + 418 4.1700000000000E+00 2.0737513852713E-02 2.0737894196659E-02 2.2421089819072E-07 + 419 4.1800000000000E+00 2.0460880913422E-02 2.0461255190957E-02 2.1340555422789E-07 + 420 4.1900000000000E+00 2.0188014718767E-02 2.0188383023808E-02 2.0312271494487E-07 + 421 4.2000000000000E+00 1.9918864776712E-02 1.9919227201745E-02 1.9333702313174E-07 + 422 4.2100000000000E+00 1.9653381213079E-02 1.9653737849188E-02 1.8402435691869E-07 + 423 4.2200000000000E+00 1.9391514766069E-02 1.9391865702959E-02 1.7516176928909E-07 + 424 4.2300000000000E+00 1.9133216780774E-02 1.9133562106792E-02 1.6672743060822E-07 + 425 4.2400000000000E+00 1.8878439203664E-02 1.8878779005810E-02 1.5870057407781E-07 + 426 4.2500000000000E+00 1.8627134577058E-02 1.8627468941007E-02 1.5106144367063E-07 + 427 4.2600000000000E+00 1.8379256033584E-02 1.8379585043706E-02 1.4379124482562E-07 + 428 4.2700000000000E+00 1.8134757290631E-02 1.8135081030012E-02 1.3687209743214E-07 + 429 4.2800000000000E+00 1.7893592644801E-02 1.7893911195259E-02 1.3028699112900E-07 + 430 4.2900000000000E+00 1.7655716966346E-02 1.7656030408453E-02 1.2401974291508E-07 + 431 4.3000000000000E+00 1.7421085693613E-02 1.7421394106711E-02 1.1805495665163E-07 + 432 4.3100000000000E+00 1.7189654827483E-02 1.7189958289703E-02 1.1237798471560E-07 + 433 4.3200000000000E+00 1.6961380925816E-02 1.6961679514098E-02 1.0697489145780E-07 + 434 4.3300000000000E+00 1.6736221097902E-02 1.6736514888009E-02 1.0183241841034E-07 + 435 4.3400000000000E+00 1.6514132998911E-02 1.6514422065450E-02 9.6937951342357E-08 + 436 4.3500000000000E+00 1.6295074824361E-02 1.6295359240798E-02 9.2279488750742E-08 + 437 4.3600000000000E+00 1.6079005304590E-02 1.6079285143269E-02 8.7845612017753E-08 + 438 4.3700000000000E+00 1.5865883699241E-02 1.5866159031398E-02 8.3625457011854E-08 + 439 4.3800000000000E+00 1.5655669791763E-02 1.5655940687546E-02 7.9608687003378E-08 + 440 4.3900000000000E+00 1.5448323883923E-02 1.5448590412407E-02 7.5785467027218E-08 + 441 4.4000000000000E+00 1.5243806790339E-02 1.5244069019540E-02 7.2146439393492E-08 + 442 4.4100000000000E+00 1.5042079833028E-02 1.5042337829921E-02 6.8682700431664E-08 + 443 4.4200000000000E+00 1.4843104835972E-02 1.4843358666508E-02 6.5385778426718E-08 + 444 4.4300000000000E+00 1.4646844119713E-02 1.4647093848831E-02 6.2247612525937E-08 + 445 4.4400000000000E+00 1.4453260495959E-02 1.4453506187603E-02 5.9260532774727E-08 + 446 4.4500000000000E+00 1.4262317262220E-02 1.4262558979355E-02 5.6417241088931E-08 + 447 4.4600000000000E+00 1.4073978196470E-02 1.4074216001093E-02 5.3710793124164E-08 + 448 4.4700000000000E+00 1.3888207551825E-02 1.3888441504986E-02 5.1134581117242E-08 + 449 4.4800000000000E+00 1.3704970051262E-02 1.3705200213073E-02 4.8682317473380E-08 + 450 4.4900000000000E+00 1.3524230882353E-02 1.3524457312002E-02 4.6348019198285E-08 + 451 4.5000000000000E+00 1.3345955692032E-02 1.3346178447801E-02 4.4125993119257E-08 + 452 4.5100000000000E+00 1.3170110581395E-02 1.3170329720671E-02 4.2010821752583E-08 + 453 4.5200000000000E+00 1.2996662100525E-02 1.2996877679813E-02 3.9997349931294E-08 + 454 4.5300000000000E+00 1.2825577243351E-02 1.2825789318289E-02 3.8080672057941E-08 + 455 4.5400000000000E+00 1.2656823442537E-02 1.2657032067909E-02 3.6256119953256E-08 + 456 4.5500000000000E+00 1.2490368564408E-02 1.2490573794154E-02 3.4519251359877E-08 + 457 4.5600000000000E+00 1.2326180903902E-02 1.2326382791135E-02 3.2865838945726E-08 + 458 4.5700000000000E+00 1.2164229179565E-02 1.2164427776581E-02 3.1291859862154E-08 + 459 4.5800000000000E+00 1.2004482528570E-02 1.2004677886863E-02 2.9793485848712E-08 + 460 4.5900000000000E+00 1.1846910501785E-02 1.1847102672055E-02 2.8367073753424E-08 + 461 4.6000000000000E+00 1.1691483058861E-02 1.1691672091029E-02 2.7009156564168E-08 + 462 4.6100000000000E+00 1.1538170563369E-02 1.1538356506588E-02 2.5716434872933E-08 + 463 4.6200000000000E+00 1.1386943777966E-02 1.1387126680635E-02 2.4485768721184E-08 + 464 4.6300000000000E+00 1.1237773859606E-02 1.1237953769375E-02 2.3314169887507E-08 + 465 4.6400000000000E+00 1.1090632354774E-02 1.1090809318564E-02 2.2198794524292E-08 + 466 4.6500000000000E+00 1.0945491194779E-02 1.0945665258787E-02 2.1136936143917E-08 + 467 4.6600000000000E+00 1.0802322691066E-02 1.0802493900777E-02 2.0126018985197E-08 + 468 4.6700000000000E+00 1.0661099530575E-02 1.0661267930776E-02 1.9163591660408E-08 + 469 4.6800000000000E+00 1.0521794771143E-02 1.0521960405929E-02 1.8247321124523E-08 + 470 4.6900000000000E+00 1.0384381836935E-02 1.0384544749724E-02 1.7374986965060E-08 + 471 4.7000000000000E+00 1.0248834513925E-02 1.0248994747465E-02 1.6544475922868E-08 + 472 4.7100000000000E+00 1.0115126945408E-02 1.0115284541788E-02 1.5753776709684E-08 + 473 4.7200000000000E+00 9.9832336275551E-03 9.9833886282167E-03 1.5000975082421E-08 + 474 4.7300000000000E+00 9.8531294050138E-03 9.8532818507595E-03 1.4284249127287E-08 + 475 4.7400000000000E+00 9.7247894665385E-03 9.7249393975420E-03 1.3601864801107E-08 + 476 4.7500000000000E+00 9.5981893406686E-03 9.5983367964843E-03 1.2952171682416E-08 + 477 4.7600000000000E+00 9.4733048914450E-03 9.4734499110177E-03 1.2333598912782E-08 + 478 4.7700000000000E+00 9.3501123141665E-03 9.3502549358403E-03 1.1744651360148E-08 + 479 4.7800000000000E+00 9.2285881311871E-03 9.2287283927150E-03 1.1183905953384E-08 + 480 4.7900000000000E+00 9.1087091877545E-03 9.1088471263071E-03 1.0650008189175E-08 + 481 4.8000000000000E+00 8.9904526478881E-03 8.9905883000627E-03 1.0141668830040E-08 + 482 4.8100000000000E+00 8.8737959902985E-03 8.8739293921280E-03 9.6576607420696E-09 + 483 4.8200000000000E+00 8.7587170043479E-03 8.7588481913089E-03 9.1968158884170E-09 + 484 4.8300000000000E+00 8.6451937860494E-03 8.6453227930714E-03 8.7580224869678E-09 + 485 4.8400000000000E+00 8.5332047341093E-03 8.5333315955826E-03 8.3402222821827E-09 + 486 4.8500000000000E+00 8.4227285460084E-03 8.4228532957924E-03 7.9424079571709E-09 + 487 4.8600000000000E+00 8.3137442141235E-03 8.3138668855551E-03 7.5636206865945E-09 + 488 4.8700000000000E+00 8.2062310218907E-03 8.2063516477920E-03 7.2029477828437E-09 + 489 4.8800000000000E+00 8.1001685400079E-03 8.1002871526943E-03 6.8595204693905E-09 + 490 4.8900000000000E+00 7.9955366226778E-03 7.9956532539656E-03 6.5325117711170E-09 + 491 4.9000000000000E+00 7.8923154038909E-03 7.8924300851051E-03 6.2211344860346E-09 + 492 4.9100000000000E+00 7.7904852937490E-03 7.7905980557306E-03 5.9246392680726E-09 + 493 4.9200000000000E+00 7.6900269748276E-03 7.6901378479412E-03 5.6423128080337E-09 + 494 4.9300000000000E+00 7.5909213985785E-03 7.5910304127197E-03 5.3734760861991E-09 + 495 4.9400000000000E+00 7.4931497817727E-03 7.4932569663749E-03 5.1174827210075E-09 + 496 4.9500000000000E+00 7.3966936029807E-03 7.3967989870226E-03 4.8737174007053E-09 + 497 4.9600000000000E+00 7.3015345990940E-03 7.3016382111064E-03 4.6415943777578E-09 + 498 4.9700000000000E+00 7.2076547618846E-03 7.2077566299571E-03 4.4205560462899E-09 + 499 4.9800000000000E+00 7.1150363346029E-03 7.1151364863910E-03 4.2100715899752E-09 + 500 4.9900000000000E+00 7.0236618086157E-03 7.0237602713471E-03 4.0096356846050E-09 + 501 5.0000000000000E+00 6.9335139200808E-03 6.9336107205624E-03 3.8187672723682E-09 + 502 5.0100000000000E+00 6.8445756466609E-03 6.8446708112848E-03 3.6370083962886E-09 + 503 5.0200000000000E+00 6.7568302042755E-03 6.7569237590257E-03 3.4639230819851E-09 + 504 5.0300000000000E+00 6.6702610438898E-03 6.6703530143482E-03 3.2990962813462E-09 + 505 5.0400000000000E+00 6.5848518483417E-03 6.5849422596944E-03 3.1421328679150E-09 + 506 5.0500000000000E+00 6.5005865292058E-03 6.5006754062491E-03 2.9926566729146E-09 + 507 5.0600000000000E+00 6.4174492236945E-03 6.4175365908411E-03 2.8503095747153E-09 + 508 5.0700000000000E+00 6.3354242915959E-03 6.3355101728804E-03 2.7147506330886E-09 + 509 5.0800000000000E+00 6.2544963122477E-03 6.2545807313329E-03 2.5856552580510E-09 + 510 5.0900000000000E+00 6.1746500815486E-03 6.1747330617307E-03 2.4627144248262E-09 + 511 5.1000000000000E+00 6.0958706090039E-03 6.0959521732185E-03 2.3456339279195E-09 + 512 5.1100000000000E+00 6.0181431148083E-03 6.0182232856357E-03 2.2341336643295E-09 + 513 5.1200000000000E+00 5.9414530269637E-03 5.9415318266345E-03 2.1279469565471E-09 + 514 5.1300000000000E+00 5.8657859784314E-03 5.8658634288316E-03 2.0268199100107E-09 + 515 5.1400000000000E+00 5.7911278043203E-03 5.7912039269971E-03 1.9305107948163E-09 + 516 5.1500000000000E+00 5.7174645391092E-03 5.7175393552758E-03 1.8387894617352E-09 + 517 5.1600000000000E+00 5.6447824139033E-03 5.6448559444439E-03 1.7514367888587E-09 + 518 5.1700000000000E+00 5.5730678537248E-03 5.5731401192001E-03 1.6682441481565E-09 + 519 5.1800000000000E+00 5.5023074748374E-03 5.5023784954892E-03 1.5890129015959E-09 + 520 5.1900000000000E+00 5.4324880821039E-03 5.4325578778602E-03 1.5135539247193E-09 + 521 5.2000000000000E+00 5.3635966663775E-03 5.3636652568573E-03 1.4416871462704E-09 + 522 5.2100000000000E+00 5.2956204019255E-03 5.2956878064433E-03 1.3732411135135E-09 + 523 5.2200000000000E+00 5.2285466438854E-03 5.2286128814561E-03 1.3080525817365E-09 + 524 5.2300000000000E+00 5.1623629257539E-03 5.1624280150975E-03 1.2459661172082E-09 + 525 5.2400000000000E+00 5.0970569569074E-03 5.0971209164533E-03 1.1868337222327E-09 + 526 5.2500000000000E+00 5.0326166201542E-03 5.0326794680458E-03 1.1305144808689E-09 + 527 5.2600000000000E+00 4.9690299693182E-03 4.9690917234170E-03 1.0768742171456E-09 + 528 5.2700000000000E+00 4.9062852268533E-03 4.9063459047439E-03 1.0257851712887E-09 + 529 5.2800000000000E+00 4.8443707814895E-03 4.8444304004829E-03 9.7712569389667E-10 + 530 5.2900000000000E+00 4.7832751859079E-03 4.7833337630466E-03 9.3077995186646E-10 + 531 5.3000000000000E+00 4.7229871544475E-03 4.7230447065090E-03 8.8663764871702E-10 + 532 5.3100000000000E+00 4.6634955608404E-03 4.6635521043416E-03 8.4459376048630E-10 + 533 5.3200000000000E+00 4.6047894359780E-03 4.6048449871791E-03 8.0454828283977E-10 + 534 5.3300000000000E+00 4.5468579657048E-03 4.5469125406132E-03 7.6640598940972E-10 + 535 5.3400000000000E+00 4.4896904886428E-03 4.4897441030171E-03 7.3007620362263E-10 + 536 5.3500000000000E+00 4.4332764940432E-03 4.4333291633968E-03 6.9547258133608E-10 + 537 5.3600000000000E+00 4.3776056196671E-03 4.3776573592722E-03 6.6251290197057E-10 + 538 5.3700000000000E+00 4.3226676496943E-03 4.3227184745855E-03 6.3111887129222E-10 + 539 5.3800000000000E+00 4.2684525126594E-03 4.2685024376374E-03 6.0121593467332E-10 + 540 5.3900000000000E+00 4.2149502794157E-03 4.2149993190508E-03 5.7273309650870E-10 + 541 5.4000000000000E+00 4.1621511611262E-03 4.1621993297618E-03 5.4560274979932E-10 + 542 5.4100000000000E+00 4.1100455072810E-03 4.1100928190373E-03 5.1976051554434E-10 + 543 5.4200000000000E+00 4.0586238037420E-03 4.0586702725193E-03 4.9514508674843E-10 + 544 5.4300000000000E+00 4.0078766708134E-03 4.0079223102952E-03 4.7169808140747E-10 + 545 5.4400000000000E+00 3.9577948613377E-03 3.9578396849946E-03 4.4936390359209E-10 + 546 5.4500000000000E+00 3.9083692588186E-03 3.9084132799111E-03 4.2808960952056E-10 + 547 5.4600000000000E+00 3.8595908755678E-03 3.8596341071498E-03 4.0782478032772E-10 + 548 5.4700000000000E+00 3.8114508508783E-03 3.8114933058001E-03 3.8852140189581E-10 + 549 5.4800000000000E+00 3.7639404492211E-03 3.7639821401326E-03 3.7013374997475E-10 + 550 5.4900000000000E+00 3.7170510584677E-03 3.7170919978214E-03 3.5261828003564E-10 + 551 5.5000000000000E+00 3.6707741881358E-03 3.6708143881900E-03 3.3593352325109E-10 + 552 5.5100000000000E+00 3.6251014676595E-03 3.6251409404810E-03 3.2003998802131E-10 + 553 5.5200000000000E+00 3.5800246446831E-03 3.5800634021505E-03 3.0490006457342E-10 + 554 5.5300000000000E+00 3.5355355833778E-03 3.5355736371842E-03 2.9047793502766E-10 + 555 5.5400000000000E+00 3.4916262627824E-03 3.4916636244382E-03 2.7673948870456E-10 + 556 5.5500000000000E+00 3.4482887751661E-03 3.4483254560017E-03 2.6365223975717E-10 + 557 5.5600000000000E+00 3.4055153244135E-03 3.4055513355824E-03 2.5118524951819E-10 + 558 5.5700000000000E+00 3.3632982244332E-03 3.3633335769146E-03 2.3930905310721E-10 + 559 5.5800000000000E+00 3.3216298975873E-03 3.3216646021886E-03 2.2799558890822E-10 + 560 5.5900000000000E+00 3.2805028731426E-03 3.2805369405022E-03 2.1721813124013E-10 + 561 5.6000000000000E+00 3.2399097857441E-03 3.2399432263338E-03 2.0695122674642E-10 + 562 5.6100000000000E+00 3.1998433739090E-03 3.1998761980368E-03 1.9717063407801E-10 + 563 5.6200000000000E+00 3.1602964785415E-03 3.1603286963542E-03 1.8785326548442E-10 + 564 5.6300000000000E+00 3.1212620414692E-03 3.1212936629545E-03 1.7897713174891E-10 + 565 5.6400000000000E+00 3.0827331039990E-03 3.0827641389881E-03 1.7052129041056E-10 + 566 5.6500000000000E+00 3.0447028054936E-03 3.0447332636637E-03 1.6246579526681E-10 + 567 5.6600000000000E+00 3.0071643819674E-03 3.0071942728442E-03 1.5479164883686E-10 + 568 5.6700000000000E+00 2.9701111647034E-03 2.9701404976629E-03 1.4748075740872E-10 + 569 5.6800000000000E+00 2.9335365788875E-03 2.9335653631589E-03 1.4051588791498E-10 + 570 5.6900000000000E+00 2.8974341422637E-03 2.8974623869312E-03 1.3388062664581E-10 + 571 5.7000000000000E+00 2.8617974638073E-03 2.8618251778127E-03 1.2755934022296E-10 + 572 5.7100000000000E+00 2.8266202424172E-03 2.8266474345618E-03 1.2153713881407E-10 + 573 5.7200000000000E+00 2.7918962656263E-03 2.7919229445732E-03 1.1579984023548E-10 + 574 5.7300000000000E+00 2.7576194083303E-03 2.7576455826064E-03 1.1033393625068E-10 + 575 5.7400000000000E+00 2.7237836315344E-03 2.7238093095326E-03 1.0512656078912E-10 + 576 5.7500000000000E+00 2.6903829811177E-03 2.6904081710991E-03 1.0016545914080E-10 + 577 5.7600000000000E+00 2.6574115866154E-03 2.6574362967109E-03 9.5438958740964E-11 + 578 5.7700000000000E+00 2.6248636600173E-03 2.6248878982301E-03 9.0935941532172E-11 + 579 5.7800000000000E+00 2.5927334945851E-03 2.5927572687923E-03 8.6645817745647E-11 + 580 5.7900000000000E+00 2.5610154636845E-03 2.5610387816391E-03 8.2558500465857E-11 + 581 5.8000000000000E+00 2.5297040196351E-03 2.5297268889683E-03 7.8664381683060E-11 + 582 5.8100000000000E+00 2.4987936925770E-03 2.4988161207993E-03 7.4954309800923E-11 + 583 5.8200000000000E+00 2.4682790893520E-03 2.4683010838557E-03 7.1419567665503E-11 + 584 5.8300000000000E+00 2.4381548924024E-03 2.4381764604634E-03 6.8051851865615E-11 + 585 5.8400000000000E+00 2.4084158586847E-03 2.4084370074637E-03 6.4843253132151E-11 + 586 5.8500000000000E+00 2.3790568185987E-03 2.3790775551438E-03 6.1786237683452E-11 + 587 5.8600000000000E+00 2.3500726749326E-03 2.3500930061804E-03 5.8873629174466E-11 + 588 5.8700000000000E+00 2.3214584018222E-03 2.3214783345997E-03 5.6098591682435E-11 + 589 5.8800000000000E+00 2.2932090437262E-03 2.2932285847525E-03 5.3454613760515E-11 + 590 5.8900000000000E+00 2.2653197144149E-03 2.2653388703030E-03 5.0935492801091E-11 + 591 5.9000000000000E+00 2.2377855959746E-03 2.2378043732327E-03 4.8535320344618E-11 + 592 5.9100000000000E+00 2.2106019378254E-03 2.2106203428590E-03 4.6248468155153E-11 + 593 5.9200000000000E+00 2.1837640557537E-03 2.1837820948666E-03 4.4069574981227E-11 + 594 5.9300000000000E+00 2.1572673309583E-03 2.1572850103546E-03 4.1993533718173E-11 + 595 5.9400000000000E+00 2.1311072091099E-03 2.1311245348954E-03 4.0015479323932E-11 + 596 5.9500000000000E+00 2.1052791994252E-03 2.1052961776089E-03 3.8130777489284E-11 + 597 5.9600000000000E+00 2.0797788737534E-03 2.0797955102490E-03 3.6335013540777E-11 + 598 5.9700000000000E+00 2.0546018656759E-03 2.0546181663032E-03 3.4623981991853E-11 + 599 5.9800000000000E+00 2.0297438696194E-03 2.0297598401058E-03 3.2993676630505E-11 + 600 5.9900000000000E+00 2.0052006399817E-03 2.0052162859638E-03 3.1440281154550E-11 + +# +#ONCVPSP (Optimized Norm-Conservinng Vanderbilt PSeudopotential) +#scalar-relativistic version 4.0.1 06/04/2019 +# +#While it is not required under the terms of the GNU GPL, it is +#suggested that you cite D. R. Hamann, Phys. Rev. B 88, 085117 (2013) +#in any publication utilizing these pseudopotentials. +# +# ATOM AND REFERENCE CONFIGURATION +# atsym z nc nv iexc psfile + Al 13.00 3 2 4 psp8 +# +# n l f + 1 0 2.00 + 2 0 2.00 + 2 1 6.00 + 3 0 2.00 + 3 1 1.00 +# +# PSEUDOPOTENTIAL AND OPTIMIZATION +# lmax + 2 +# +# l, rc, ep, ncon, nbas, qcut + 0 1.92000 -0.28491 4 8 5.00000 + 1 1.94000 -0.09967 4 8 6.50000 + 2 1.94000 0.05000 4 8 7.20000 +# +# LOCAL POTENTIAL +# lloc, lpopt, rc(5), dvloc0 + 4 5 1.82255 0.00000 +# +# VANDERBILT-KLEINMAN-BYLANDER PROJECTORs +# l, nproj, debl + 0 2 2.80000 + 1 2 2.80000 + 2 2 1.50000 +# +# MODEL CORE CHARGE +# icmod, fcfact, rcfact + 3 5.00000 1.30000 +# +# LOG DERIVATIVE ANALYSIS +# epsh1, epsh2, depsh + -12.00 12.00 0.02 +# +# OUTPUT GRID +# rlmax, drl + 6.0000 0.0100 +# +# TEST CONFIGURATIONS +# ncnf + 0 +# nvcnf +# n l f + + + +# *********************************************************************************************** # +# Copyright (c) 2022 Material Physics & Mechanics Group, Georgia Tech # +# Distributed under GNU General Public License 3 (GPL) (https://www.gnu.org/licenses/) # +# Mostafa Faghih Shojaei, John E. Pask, Andrew J. Medford, and Phanish Suryanarayana. # +# "Soft and transferable pseudopotentials from multi-objective optimization." # +# Computer Physics Communications 283 (2023): 108594. (https://doi.org/10.1016/j.cpc.2022.108594) # +# Acknowledgment: U.S. Department of Energy (DOE), Office of Science (SC): DE-SC0019410 # +# *********************************************************************************************** # +# Ecut (1e-3 Ha/atom accuracy): 9 Ha # +# Ecut (1e-4 Ha/atom accuracy): 14 Ha # +# Mesh size (1e-3 Ha/atom accuracy, 12th order FD): 0.51 Bohr # +# Mesh size (1e-4 Ha/atom accuracy, 12th order FD): 0.41 Bohr # +# These are estimates. Actual spacing should always be determined by refining the mesh # +# (or equivalently increasing Ecut) until desired error is achieved. # +# *********************************************************************************************** # + + diff --git a/utils/pdos/examples/Al_FCC/Al.static b/utils/pdos/examples/Al_FCC/Al.static new file mode 100644 index 00000000..d6ea65a3 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.static @@ -0,0 +1,18 @@ +*************************************************************************** + Atom positions +*************************************************************************** +Fractional coordinates of Al: + 0.0000000000 0.0000000000 0.0000000000 + 0.5000000000 0.5000000000 0.0000000000 + 0.5000000000 0.0000000000 0.5000000000 + 0.0000000000 0.5000000000 0.5000000000 +Total free energy (Ha): -9.329700308904821E+00 +Atomic forces (Ha/Bohr): + 3.1944478681E-07 -9.3160287622E-07 2.3777720867E-06 + -2.3392989418E-07 1.2290181182E-06 2.0707132314E-06 + -3.0515449244E-07 -1.5585109390E-06 -2.0245915759E-06 + 2.1963959981E-07 1.2610956970E-06 -2.4238937422E-06 +Stress (GPa): + 9.8648842122E+00 -5.0072008931E-06 -1.2687968843E-05 + -5.0072008931E-06 9.8648911750E+00 1.6516426656E-06 + -1.2687968843E-05 1.6516426656E-06 9.8648955572E+00 diff --git a/utils/pdos/examples/Al_FCC/Al.upf b/utils/pdos/examples/Al_FCC/Al.upf new file mode 100644 index 00000000..2b79fe80 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/Al.upf @@ -0,0 +1,5827 @@ + + + +# *********************************************************************************************** # +# Copyright (c) 2022 Material Physics & Mechanics Group, Georgia Tech # +# Distributed under GNU General Public License 3 (GPL) (https://www.gnu.org/licenses/) # +# Mostafa Faghih Shojaei, John E. Pask, Andrew J. Medford, and Phanish Suryanarayana. # +# "Soft and transferable pseudopotentials from multi-objective optimization." # +# Computer Physics Communications 283 (2023): 108594. (https://doi.org/10.1016/j.cpc.2022.108594) # +# Acknowledgment: U.S. Department of Energy (DOE), Office of Science (SC): DE-SC0019410 # +# *********************************************************************************************** # +# Ecut (1e-3 Ha/atom accuracy): 9 Ha # +# Ecut (1e-4 Ha/atom accuracy): 14 Ha # +# Mesh size (1e-3 Ha/atom accuracy, 12th order FD): 0.51 Bohr # +# Mesh size (1e-4 Ha/atom accuracy, 12th order FD): 0.41 Bohr # +# These are estimates. Actual spacing should always be determined by refining the mesh # +# (or equivalently increasing Ecut) until desired error is achieved. # +# *********************************************************************************************** # + + This pseudopotential file has been produced using the code + ONCVPSP (Optimized Norm-Conservinng Vanderbilt PSeudopotential) + scalar-relativistic version 4.0.1 06/04/2019 by D. R. Hamann + The code is available through a link at URL www.mat-simresearch.com. + Documentation with the package provides a full discription of the + input data below. + + + While it is not required under the terms of the GNU GPL, it is + suggested that you cite D. R. Hamann, Phys. Rev. B 88, 085117 (2013) + in any publication using these pseudopotentials. + + +# ATOM AND REFERENCE CONFIGURATION +# atsym z nc nv iexc psfile + Al 13.00 3 2 4 upf +# +# n l f energy (Ha) + 1 0 2.00 + 2 0 2.00 + 2 1 6.00 + 3 0 2.00 + 3 1 1.00 +# +# PSEUDOPOTENTIAL AND OPTIMIZATION +# lmax + 2 +# +# l, rc, ep, ncon, nbas, qcut + 0 1.92000 -0.28491 4 8 5.00000 + 1 1.94000 -0.09967 4 8 6.50000 + 2 1.94000 0.05000 4 8 7.20000 +# +# LOCAL POTENTIAL +# lloc, lpopt, rc(5), dvloc0 + 4 5 1.82255 0.00000 +# +# VANDERBILT-KLEINMAN-BYLANDER PROJECTORs +# l, nproj, debl + 0 2 2.80000 + 1 2 2.80000 + 2 2 1.50000 +# +# MODEL CORE CHARGE +# icmod, fcfact, rcfact + 3 5.00000 1.30000 +# +# LOG DERIVATIVE ANALYSIS +# epsh1, epsh2, depsh + -12.00 12.00 0.02 +# +# OUTPUT GRID +# rlmax, drl + 6.00 0.01 +# +# TEST CONFIGURATIONS +# ncnf + 0 +# nvcnf +# n l f + + + + + + + + + 0.0000 0.0100 0.0200 0.0300 0.0400 0.0500 0.0600 0.0700 + 0.0800 0.0900 0.1000 0.1100 0.1200 0.1300 0.1400 0.1500 + 0.1600 0.1700 0.1800 0.1900 0.2000 0.2100 0.2200 0.2300 + 0.2400 0.2500 0.2600 0.2700 0.2800 0.2900 0.3000 0.3100 + 0.3200 0.3300 0.3400 0.3500 0.3600 0.3700 0.3800 0.3900 + 0.4000 0.4100 0.4200 0.4300 0.4400 0.4500 0.4600 0.4700 + 0.4800 0.4900 0.5000 0.5100 0.5200 0.5300 0.5400 0.5500 + 0.5600 0.5700 0.5800 0.5900 0.6000 0.6100 0.6200 0.6300 + 0.6400 0.6500 0.6600 0.6700 0.6800 0.6900 0.7000 0.7100 + 0.7200 0.7300 0.7400 0.7500 0.7600 0.7700 0.7800 0.7900 + 0.8000 0.8100 0.8200 0.8300 0.8400 0.8500 0.8600 0.8700 + 0.8800 0.8900 0.9000 0.9100 0.9200 0.9300 0.9400 0.9500 + 0.9600 0.9700 0.9800 0.9900 1.0000 1.0100 1.0200 1.0300 + 1.0400 1.0500 1.0600 1.0700 1.0800 1.0900 1.1000 1.1100 + 1.1200 1.1300 1.1400 1.1500 1.1600 1.1700 1.1800 1.1900 + 1.2000 1.2100 1.2200 1.2300 1.2400 1.2500 1.2600 1.2700 + 1.2800 1.2900 1.3000 1.3100 1.3200 1.3300 1.3400 1.3500 + 1.3600 1.3700 1.3800 1.3900 1.4000 1.4100 1.4200 1.4300 + 1.4400 1.4500 1.4600 1.4700 1.4800 1.4900 1.5000 1.5100 + 1.5200 1.5300 1.5400 1.5500 1.5600 1.5700 1.5800 1.5900 + 1.6000 1.6100 1.6200 1.6300 1.6400 1.6500 1.6600 1.6700 + 1.6800 1.6900 1.7000 1.7100 1.7200 1.7300 1.7400 1.7500 + 1.7600 1.7700 1.7800 1.7900 1.8000 1.8100 1.8200 1.8300 + 1.8400 1.8500 1.8600 1.8700 1.8800 1.8900 1.9000 1.9100 + 1.9200 1.9300 1.9400 1.9500 1.9600 1.9700 1.9800 1.9900 + 2.0000 2.0100 2.0200 2.0300 2.0400 2.0500 2.0600 2.0700 + 2.0800 2.0900 2.1000 2.1100 2.1200 2.1300 2.1400 2.1500 + 2.1600 2.1700 2.1800 2.1900 2.2000 2.2100 2.2200 2.2300 + 2.2400 2.2500 2.2600 2.2700 2.2800 2.2900 2.3000 2.3100 + 2.3200 2.3300 2.3400 2.3500 2.3600 2.3700 2.3800 2.3900 + 2.4000 2.4100 2.4200 2.4300 2.4400 2.4500 2.4600 2.4700 + 2.4800 2.4900 2.5000 2.5100 2.5200 2.5300 2.5400 2.5500 + 2.5600 2.5700 2.5800 2.5900 2.6000 2.6100 2.6200 2.6300 + 2.6400 2.6500 2.6600 2.6700 2.6800 2.6900 2.7000 2.7100 + 2.7200 2.7300 2.7400 2.7500 2.7600 2.7700 2.7800 2.7900 + 2.8000 2.8100 2.8200 2.8300 2.8400 2.8500 2.8600 2.8700 + 2.8800 2.8900 2.9000 2.9100 2.9200 2.9300 2.9400 2.9500 + 2.9600 2.9700 2.9800 2.9900 3.0000 3.0100 3.0200 3.0300 + 3.0400 3.0500 3.0600 3.0700 3.0800 3.0900 3.1000 3.1100 + 3.1200 3.1300 3.1400 3.1500 3.1600 3.1700 3.1800 3.1900 + 3.2000 3.2100 3.2200 3.2300 3.2400 3.2500 3.2600 3.2700 + 3.2800 3.2900 3.3000 3.3100 3.3200 3.3300 3.3400 3.3500 + 3.3600 3.3700 3.3800 3.3900 3.4000 3.4100 3.4200 3.4300 + 3.4400 3.4500 3.4600 3.4700 3.4800 3.4900 3.5000 3.5100 + 3.5200 3.5300 3.5400 3.5500 3.5600 3.5700 3.5800 3.5900 + 3.6000 3.6100 3.6200 3.6300 3.6400 3.6500 3.6600 3.6700 + 3.6800 3.6900 3.7000 3.7100 3.7200 3.7300 3.7400 3.7500 + 3.7600 3.7700 3.7800 3.7900 3.8000 3.8100 3.8200 3.8300 + 3.8400 3.8500 3.8600 3.8700 3.8800 3.8900 3.9000 3.9100 + 3.9200 3.9300 3.9400 3.9500 3.9600 3.9700 3.9800 3.9900 + 4.0000 4.0100 4.0200 4.0300 4.0400 4.0500 4.0600 4.0700 + 4.0800 4.0900 4.1000 4.1100 4.1200 4.1300 4.1400 4.1500 + 4.1600 4.1700 4.1800 4.1900 4.2000 4.2100 4.2200 4.2300 + 4.2400 4.2500 4.2600 4.2700 4.2800 4.2900 4.3000 4.3100 + 4.3200 4.3300 4.3400 4.3500 4.3600 4.3700 4.3800 4.3900 + 4.4000 4.4100 4.4200 4.4300 4.4400 4.4500 4.4600 4.4700 + 4.4800 4.4900 4.5000 4.5100 4.5200 4.5300 4.5400 4.5500 + 4.5600 4.5700 4.5800 4.5900 4.6000 4.6100 4.6200 4.6300 + 4.6400 4.6500 4.6600 4.6700 4.6800 4.6900 4.7000 4.7100 + 4.7200 4.7300 4.7400 4.7500 4.7600 4.7700 4.7800 4.7900 + 4.8000 4.8100 4.8200 4.8300 4.8400 4.8500 4.8600 4.8700 + 4.8800 4.8900 4.9000 4.9100 4.9200 4.9300 4.9400 4.9500 + 4.9600 4.9700 4.9800 4.9900 5.0000 5.0100 5.0200 5.0300 + 5.0400 5.0500 5.0600 5.0700 5.0800 5.0900 5.1000 5.1100 + 5.1200 5.1300 5.1400 5.1500 5.1600 5.1700 5.1800 5.1900 + 5.2000 5.2100 5.2200 5.2300 5.2400 5.2500 5.2600 5.2700 + 5.2800 5.2900 5.3000 5.3100 5.3200 5.3300 5.3400 5.3500 + 5.3600 5.3700 5.3800 5.3900 5.4000 5.4100 5.4200 5.4300 + 5.4400 5.4500 5.4600 5.4700 5.4800 5.4900 5.5000 5.5100 + 5.5200 5.5300 5.5400 5.5500 5.5600 5.5700 5.5800 5.5900 + 5.6000 5.6100 5.6200 5.6300 5.6400 5.6500 5.6600 5.6700 + 5.6800 5.6900 5.7000 5.7100 5.7200 5.7300 5.7400 5.7500 + 5.7600 5.7700 5.7800 5.7900 5.8000 5.8100 5.8200 5.8300 + 5.8400 5.8500 5.8600 5.8700 5.8800 5.8900 5.9000 5.9100 + 5.9200 5.9300 5.9400 5.9500 5.9600 5.9700 5.9800 5.9900 + 6.0000 6.0100 6.0200 6.0300 6.0400 6.0500 6.0600 6.0700 + 6.0800 6.0900 6.1000 6.1100 6.1200 6.1300 6.1400 6.1500 + 6.1600 6.1700 6.1800 6.1900 6.2000 6.2100 6.2200 6.2300 + 6.2400 6.2500 6.2600 6.2700 6.2800 6.2900 6.3000 6.3100 + 6.3200 6.3300 6.3400 6.3500 6.3600 6.3700 6.3800 6.3900 + 6.4000 6.4100 6.4200 6.4300 6.4400 6.4500 6.4600 6.4700 + 6.4800 6.4900 6.5000 6.5100 6.5200 6.5300 6.5400 6.5500 + 6.5600 6.5700 6.5800 6.5900 6.6000 6.6100 6.6200 6.6300 + 6.6400 6.6500 6.6600 6.6700 6.6800 6.6900 6.7000 6.7100 + 6.7200 6.7300 6.7400 6.7500 6.7600 6.7700 6.7800 6.7900 + 6.8000 6.8100 6.8200 6.8300 6.8400 6.8500 6.8600 6.8700 + 6.8800 6.8900 6.9000 6.9100 6.9200 6.9300 6.9400 6.9500 + 6.9600 6.9700 6.9800 6.9900 7.0000 7.0100 7.0200 7.0300 + 7.0400 7.0500 7.0600 7.0700 7.0800 7.0900 7.1000 7.1100 + 7.1200 7.1300 7.1400 7.1500 7.1600 7.1700 7.1800 7.1900 + 7.2000 7.2100 7.2200 7.2300 7.2400 7.2500 7.2600 7.2700 + 7.2800 7.2900 7.3000 7.3100 7.3200 7.3300 7.3400 7.3500 + 7.3600 7.3700 7.3800 7.3900 7.4000 7.4100 7.4200 7.4300 + 7.4400 7.4500 7.4600 7.4700 7.4800 7.4900 7.5000 7.5100 + 7.5200 7.5300 7.5400 7.5500 7.5600 7.5700 7.5800 7.5900 + 7.6000 7.6100 7.6200 7.6300 7.6400 7.6500 7.6600 7.6700 + 7.6800 7.6900 7.7000 7.7100 7.7200 7.7300 7.7400 7.7500 + 7.7600 7.7700 7.7800 7.7900 7.8000 7.8100 7.8200 7.8300 + 7.8400 7.8500 7.8600 7.8700 7.8800 7.8900 7.9000 7.9100 + 7.9200 7.9300 7.9400 7.9500 7.9600 7.9700 7.9800 7.9900 + 8.0000 8.0100 8.0200 8.0300 8.0400 8.0500 8.0600 8.0700 + 8.0800 8.0900 8.1000 8.1100 8.1200 8.1300 8.1400 8.1500 + 8.1600 8.1700 8.1800 8.1900 8.2000 8.2100 8.2200 8.2300 + 8.2400 8.2500 8.2600 8.2700 8.2800 8.2900 8.3000 8.3100 + 8.3200 8.3300 8.3400 8.3500 8.3600 8.3700 8.3800 8.3900 + 8.4000 8.4100 8.4200 8.4300 8.4400 8.4500 8.4600 8.4700 + 8.4800 8.4900 8.5000 8.5100 8.5200 8.5300 8.5400 8.5500 + 8.5600 8.5700 8.5800 8.5900 8.6000 8.6100 8.6200 8.6300 + 8.6400 8.6500 8.6600 8.6700 8.6800 8.6900 8.7000 8.7100 + 8.7200 8.7300 8.7400 8.7500 8.7600 8.7700 8.7800 8.7900 + 8.8000 8.8100 8.8200 8.8300 8.8400 8.8500 8.8600 8.8700 + 8.8800 8.8900 8.9000 8.9100 8.9200 8.9300 8.9400 8.9500 + 8.9600 8.9700 8.9800 8.9900 9.0000 9.0100 9.0200 9.0300 + 9.0400 9.0500 9.0600 9.0700 9.0800 9.0900 9.1000 9.1100 + 9.1200 9.1300 9.1400 9.1500 9.1600 9.1700 9.1800 9.1900 + 9.2000 9.2100 9.2200 9.2300 9.2400 9.2500 9.2600 9.2700 + 9.2800 9.2900 9.3000 9.3100 9.3200 9.3300 9.3400 9.3500 + 9.3600 9.3700 9.3800 9.3900 9.4000 9.4100 9.4200 9.4300 + 9.4400 9.4500 9.4600 9.4700 9.4800 9.4900 9.5000 9.5100 + 9.5200 9.5300 9.5400 9.5500 9.5600 9.5700 9.5800 9.5900 + 9.6000 9.6100 9.6200 9.6300 9.6400 9.6500 9.6600 9.6700 + 9.6800 9.6900 9.7000 9.7100 9.7200 9.7300 9.7400 9.7500 + 9.7600 9.7700 9.7800 9.7900 9.8000 9.8100 9.8200 9.8300 + 9.8400 9.8500 9.8600 9.8700 9.8800 9.8900 9.9000 9.9100 + 9.9200 9.9300 9.9400 9.9500 9.9600 9.9700 9.9800 9.9900 + 10.0000 10.0100 10.0200 10.0300 10.0400 10.0500 10.0600 10.0700 + 10.0800 10.0900 10.1000 10.1100 10.1200 10.1300 10.1400 10.1500 + 10.1600 10.1700 10.1800 10.1900 10.2000 10.2100 10.2200 10.2300 + 10.2400 10.2500 10.2600 10.2700 10.2800 10.2900 10.3000 10.3100 + 10.3200 10.3300 10.3400 10.3500 10.3600 10.3700 10.3800 10.3900 + 10.4000 10.4100 10.4200 10.4300 10.4400 10.4500 10.4600 10.4700 + 10.4800 10.4900 10.5000 10.5100 10.5200 10.5300 10.5400 10.5500 + 10.5600 10.5700 10.5800 10.5900 10.6000 10.6100 10.6200 10.6300 + 10.6400 10.6500 10.6600 10.6700 10.6800 10.6900 10.7000 10.7100 + 10.7200 10.7300 10.7400 10.7500 10.7600 10.7700 10.7800 10.7900 + 10.8000 10.8100 10.8200 10.8300 10.8400 10.8500 10.8600 10.8700 + 10.8800 10.8900 10.9000 10.9100 10.9200 10.9300 10.9400 10.9500 + 10.9600 10.9700 10.9800 10.9900 11.0000 11.0100 11.0200 11.0300 + 11.0400 11.0500 11.0600 11.0700 11.0800 11.0900 11.1000 11.1100 + 11.1200 11.1300 11.1400 11.1500 11.1600 11.1700 11.1800 11.1900 + 11.2000 11.2100 11.2200 11.2300 11.2400 11.2500 11.2600 11.2700 + 11.2800 11.2900 11.3000 11.3100 11.3200 11.3300 11.3400 11.3500 + 11.3600 11.3700 11.3800 11.3900 11.4000 11.4100 11.4200 11.4300 + 11.4400 11.4500 11.4600 11.4700 11.4800 11.4900 11.5000 11.5100 + 11.5200 11.5300 11.5400 11.5500 11.5600 11.5700 11.5800 11.5900 + 11.6000 11.6100 11.6200 11.6300 11.6400 11.6500 11.6600 11.6700 + 11.6800 11.6900 11.7000 11.7100 11.7200 11.7300 11.7400 11.7500 + 11.7600 11.7700 11.7800 11.7900 11.8000 11.8100 11.8200 11.8300 + 11.8400 11.8500 11.8600 11.8700 11.8800 11.8900 11.9000 11.9100 + 11.9200 11.9300 11.9400 11.9500 11.9600 11.9700 11.9800 11.9900 + 12.0000 12.0100 12.0200 12.0300 12.0400 12.0500 12.0600 12.0700 + 12.0800 12.0900 12.1000 12.1100 12.1200 12.1300 12.1400 12.1500 + 12.1600 12.1700 12.1800 12.1900 12.2000 12.2100 12.2200 12.2300 + 12.2400 12.2500 12.2600 12.2700 12.2800 12.2900 12.3000 12.3100 + 12.3200 12.3300 12.3400 12.3500 12.3600 12.3700 12.3800 12.3900 + 12.4000 12.4100 12.4200 12.4300 12.4400 12.4500 12.4600 12.4700 + 12.4800 12.4900 12.5000 12.5100 12.5200 12.5300 12.5400 12.5500 + 12.5600 12.5700 12.5800 12.5900 12.6000 12.6100 12.6200 12.6300 + 12.6400 12.6500 12.6600 12.6700 12.6800 12.6900 12.7000 12.7100 + 12.7200 12.7300 12.7400 12.7500 12.7600 12.7700 12.7800 12.7900 + 12.8000 12.8100 12.8200 12.8300 12.8400 12.8500 12.8600 12.8700 + 12.8800 12.8900 12.9000 12.9100 12.9200 12.9300 12.9400 12.9500 + 12.9600 12.9700 12.9800 12.9900 13.0000 13.0100 13.0200 13.0300 + 13.0400 13.0500 13.0600 13.0700 13.0800 13.0900 13.1000 13.1100 + 13.1200 13.1300 13.1400 13.1500 13.1600 13.1700 13.1800 13.1900 + 13.2000 13.2100 13.2200 13.2300 13.2400 13.2500 13.2600 13.2700 + 13.2800 13.2900 13.3000 13.3100 13.3200 13.3300 13.3400 13.3500 + 13.3600 13.3700 13.3800 13.3900 13.4000 13.4100 13.4200 13.4300 + 13.4400 13.4500 13.4600 13.4700 13.4800 13.4900 13.5000 13.5100 + 13.5200 13.5300 13.5400 13.5500 13.5600 13.5700 13.5800 13.5900 + 13.6000 13.6100 13.6200 13.6300 13.6400 13.6500 13.6600 13.6700 + 13.6800 13.6900 13.7000 13.7100 13.7200 13.7300 13.7400 13.7500 + 13.7600 13.7700 13.7800 13.7900 13.8000 13.8100 13.8200 13.8300 + 13.8400 13.8500 13.8600 13.8700 13.8800 13.8900 13.9000 13.9100 + 13.9200 13.9300 13.9400 13.9500 13.9600 13.9700 13.9800 13.9900 + 14.0000 14.0100 14.0200 14.0300 14.0400 14.0500 14.0600 14.0700 + 14.0800 14.0900 14.1000 14.1100 14.1200 14.1300 14.1400 14.1500 + 14.1600 14.1700 14.1800 14.1900 14.2000 14.2100 14.2200 14.2300 + 14.2400 14.2500 14.2600 14.2700 14.2800 14.2900 14.3000 14.3100 + 14.3200 14.3300 14.3400 14.3500 14.3600 14.3700 14.3800 14.3900 + 14.4000 14.4100 14.4200 14.4300 14.4400 14.4500 14.4600 14.4700 + 14.4800 14.4900 14.5000 14.5100 14.5200 14.5300 14.5400 14.5500 + 14.5600 14.5700 14.5800 14.5900 14.6000 14.6100 14.6200 14.6300 + 14.6400 14.6500 14.6600 14.6700 14.6800 14.6900 14.7000 14.7100 + 14.7200 14.7300 14.7400 14.7500 14.7600 14.7700 14.7800 14.7900 + 14.8000 14.8100 14.8200 14.8300 14.8400 14.8500 14.8600 14.8700 + 14.8800 14.8900 14.9000 14.9100 14.9200 14.9300 14.9400 14.9500 + 14.9600 14.9700 14.9800 14.9900 15.0000 15.0100 15.0200 15.0300 + 15.0400 15.0500 15.0600 15.0700 15.0800 15.0900 15.1000 15.1100 + 15.1200 15.1300 15.1400 15.1500 15.1600 15.1700 15.1800 15.1900 + 15.2000 15.2100 15.2200 15.2300 15.2400 15.2500 15.2600 15.2700 + 15.2800 15.2900 15.3000 15.3100 15.3200 15.3300 15.3400 15.3500 + 15.3600 15.3700 15.3800 15.3900 15.4000 15.4100 15.4200 15.4300 + 15.4400 15.4500 15.4600 15.4700 15.4800 15.4900 15.5000 15.5100 + 15.5200 15.5300 15.5400 15.5500 15.5600 15.5700 15.5800 15.5900 + 15.6000 15.6100 15.6200 15.6300 15.6400 15.6500 15.6600 15.6700 + 15.6800 15.6900 15.7000 15.7100 15.7200 15.7300 15.7400 15.7500 + 15.7600 15.7700 15.7800 15.7900 15.8000 15.8100 15.8200 15.8300 + 15.8400 15.8500 15.8600 15.8700 15.8800 15.8900 15.9000 15.9100 + 15.9200 15.9300 15.9400 15.9500 15.9600 15.9700 15.9800 15.9900 + 16.0000 16.0100 16.0200 16.0300 16.0400 16.0500 16.0600 16.0700 + 16.0800 16.0900 16.1000 16.1100 16.1200 16.1300 16.1400 16.1500 + 16.1600 16.1700 16.1800 16.1900 16.2000 16.2100 16.2200 16.2300 + 16.2400 16.2500 16.2600 16.2700 16.2800 16.2900 16.3000 16.3100 + 16.3200 16.3300 16.3400 16.3500 16.3600 16.3700 16.3800 16.3900 + 16.4000 16.4100 16.4200 16.4300 16.4400 16.4500 16.4600 16.4700 + 16.4800 16.4900 16.5000 16.5100 16.5200 16.5300 16.5400 16.5500 + 16.5600 16.5700 16.5800 16.5900 16.6000 16.6100 16.6200 16.6300 + 16.6400 16.6500 16.6600 16.6700 16.6800 16.6900 16.7000 16.7100 + 16.7200 16.7300 16.7400 16.7500 16.7600 16.7700 16.7800 16.7900 + 16.8000 16.8100 16.8200 16.8300 16.8400 16.8500 16.8600 16.8700 + 16.8800 16.8900 16.9000 16.9100 16.9200 16.9300 16.9400 16.9500 + 16.9600 16.9700 16.9800 16.9900 17.0000 17.0100 17.0200 17.0300 + 17.0400 17.0500 17.0600 17.0700 17.0800 17.0900 17.1000 17.1100 + 17.1200 17.1300 17.1400 17.1500 17.1600 17.1700 17.1800 17.1900 + 17.2000 17.2100 17.2200 17.2300 17.2400 17.2500 17.2600 17.2700 + 17.2800 17.2900 17.3000 17.3100 17.3200 17.3300 17.3400 17.3500 + 17.3600 17.3700 17.3800 17.3900 17.4000 17.4100 17.4200 17.4300 + 17.4400 17.4500 17.4600 17.4700 17.4800 17.4900 17.5000 17.5100 + 17.5200 17.5300 17.5400 17.5500 17.5600 17.5700 17.5800 17.5900 + 17.6000 17.6100 17.6200 17.6300 17.6400 17.6500 17.6600 17.6700 + 17.6800 17.6900 17.7000 17.7100 17.7200 17.7300 17.7400 17.7500 + 17.7600 17.7700 17.7800 17.7900 17.8000 17.8100 17.8200 17.8300 + 17.8400 17.8500 17.8600 17.8700 17.8800 17.8900 17.9000 17.9100 + 17.9200 17.9300 17.9400 17.9500 17.9600 17.9700 17.9800 17.9900 + 18.0000 18.0100 18.0200 18.0300 18.0400 18.0500 18.0600 18.0700 + 18.0800 18.0900 18.1000 18.1100 18.1200 18.1300 18.1400 18.1500 + 18.1600 18.1700 18.1800 18.1900 18.2000 18.2100 18.2200 18.2300 + 18.2400 18.2500 18.2600 18.2700 18.2800 18.2900 18.3000 18.3100 + 18.3200 18.3300 18.3400 18.3500 18.3600 18.3700 18.3800 18.3900 + 18.4000 18.4100 18.4200 18.4300 18.4400 18.4500 18.4600 18.4700 + 18.4800 18.4900 18.5000 18.5100 18.5200 18.5300 18.5400 18.5500 + 18.5600 18.5700 18.5800 18.5900 18.6000 18.6100 18.6200 18.6300 + 18.6400 18.6500 18.6600 18.6700 18.6800 18.6900 18.7000 18.7100 + + + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 0.0100 + + + + -5.4785393485E+00 -5.4784430211E+00 -5.4781537078E+00 -5.4776716712E+00 + -5.4769971400E+00 -5.4761304327E+00 -5.4750719565E+00 -5.4738222063E+00 + -5.4723817620E+00 -5.4707512867E+00 -5.4689315245E+00 -5.4669232971E+00 + -5.4647275011E+00 -5.4623451047E+00 -5.4597771444E+00 -5.4570247209E+00 + -5.4540889960E+00 -5.4509711878E+00 -5.4476725674E+00 -5.4441944544E+00 + -5.4405382128E+00 -5.4367052467E+00 -5.4326969960E+00 -5.4285149324E+00 + -5.4241605549E+00 -5.4196353859E+00 -5.4149409665E+00 -5.4100788530E+00 + -5.4050506126E+00 -5.3998578197E+00 -5.3945020517E+00 -5.3889848855E+00 + -5.3833078941E+00 -5.3774726426E+00 -5.3714806852E+00 -5.3653335619E+00 + -5.3590327952E+00 -5.3525798870E+00 -5.3459763160E+00 -5.3392235348E+00 + -5.3323229671E+00 -5.3252760055E+00 -5.3180840086E+00 -5.3107482993E+00 + -5.3032701624E+00 -5.2956508424E+00 -5.2878915423E+00 -5.2799934210E+00 + -5.2719575924E+00 -5.2637851239E+00 -5.2554770348E+00 -5.2470342954E+00 + -5.2384578264E+00 -5.2297484974E+00 -5.2209071271E+00 -5.2119344825E+00 + -5.2028312786E+00 -5.1935981789E+00 -5.1842357951E+00 -5.1747446879E+00 + -5.1651253675E+00 -5.1553782944E+00 -5.1455038807E+00 -5.1355024913E+00 + -5.1253744456E+00 -5.1151200192E+00 -5.1047394459E+00 -5.0942329201E+00 + -5.0836005989E+00 -5.0728426056E+00 -5.0619590318E+00 -5.0509499407E+00 + -5.0398153710E+00 -5.0285553394E+00 -5.0171698451E+00 -5.0056588732E+00 + -4.9940223988E+00 -4.9822603910E+00 -4.9703728170E+00 -4.9583596464E+00 + -4.9462208556E+00 -4.9339564319E+00 -4.9215663783E+00 -4.9090507174E+00 + -4.8964094958E+00 -4.8836427887E+00 -4.8707507036E+00 -4.8577333849E+00 + -4.8445910176E+00 -4.8313238311E+00 -4.8179321030E+00 -4.8044161627E+00 + -4.7907763943E+00 -4.7770132401E+00 -4.7631272032E+00 -4.7491188501E+00 + -4.7349888133E+00 -4.7207377927E+00 -4.7063665581E+00 -4.6918759503E+00 + -4.6772668824E+00 -4.6625403405E+00 -4.6476973844E+00 -4.6327391481E+00 + -4.6176668393E+00 -4.6024817398E+00 -4.5871852042E+00 -4.5717786596E+00 + -4.5562636044E+00 -4.5406416068E+00 -4.5249143033E+00 -4.5090833973E+00 + -4.4931506568E+00 -4.4771179122E+00 -4.4609870547E+00 -4.4447600332E+00 + -4.4284388523E+00 -4.4120255698E+00 -4.3955222941E+00 -4.3789311813E+00 + -4.3622544332E+00 -4.3454942946E+00 -4.3286530503E+00 -4.3117330237E+00 + -4.2947365734E+00 -4.2776660920E+00 -4.2605240033E+00 -4.2433127610E+00 + -4.2260348464E+00 -4.2086927675E+00 -4.1912890570E+00 -4.1738262716E+00 + -4.1563069909E+00 -4.1387338164E+00 -4.1211093716E+00 -4.1034363009E+00 + -4.0857172700E+00 -4.0679549657E+00 -4.0501520961E+00 -4.0323113913E+00 + -4.0144356036E+00 -3.9965275087E+00 -3.9785899058E+00 -3.9606256193E+00 + -3.9426374995E+00 -3.9246284238E+00 -3.9066012976E+00 -3.8885590561E+00 + -3.8705046649E+00 -3.8524411215E+00 -3.8343714567E+00 -3.8162987352E+00 + -3.7982260572E+00 -3.7801565590E+00 -3.7620934141E+00 -3.7440398339E+00 + -3.7259990684E+00 -3.7079744067E+00 -3.6899691770E+00 -3.6719867475E+00 + -3.6540305258E+00 -3.6361039589E+00 -3.6182105331E+00 -3.6003537730E+00 + -3.5825372412E+00 -3.5647645372E+00 -3.5470392961E+00 -3.5293651878E+00 + -3.5117459147E+00 -3.4941852107E+00 -3.4766868387E+00 -3.4592545889E+00 + -3.4418922759E+00 -3.4246037368E+00 -3.4073928279E+00 -3.3902634219E+00 + -3.3732194047E+00 -3.3562646721E+00 -3.3394031263E+00 -3.3226386718E+00 + -3.3059752118E+00 -3.2894166438E+00 -3.2729668543E+00 -3.2566297208E+00 + -3.2404090596E+00 -3.2243084896E+00 -3.2083313231E+00 -3.1924805617E+00 + -3.1767588972E+00 -3.1611686988E+00 -3.1457120117E+00 -3.1303906784E+00 + -3.1152062810E+00 -3.1001567890E+00 -3.0852338008E+00 -3.0704275599E+00 + -3.0557345305E+00 -3.0411516213E+00 -3.0266761325E+00 -3.0123080871E+00 + -2.9980473356E+00 -2.9838923966E+00 -2.9698426708E+00 -2.9558972366E+00 + -2.9420551866E+00 -2.9283156041E+00 -2.9146775611E+00 -2.9011401293E+00 + -2.8877023849E+00 -2.8743634135E+00 -2.8611223141E+00 -2.8479782026E+00 + -2.8349302141E+00 -2.8219775054E+00 -2.8091192565E+00 -2.7963546718E+00 + -2.7836829808E+00 -2.7711034386E+00 -2.7586153262E+00 -2.7462179500E+00 + -2.7339106420E+00 -2.7216927589E+00 -2.7095636812E+00 -2.6975228132E+00 + -2.6855695812E+00 -2.6737034328E+00 -2.6619238362E+00 -2.6502302782E+00 + -2.6386222638E+00 -2.6270993146E+00 -2.6156609676E+00 -2.6043067738E+00 + -2.5930362975E+00 -2.5818491141E+00 -2.5707448099E+00 -2.5597229801E+00 + -2.5487832279E+00 -2.5379251634E+00 -2.5271484021E+00 -2.5164525643E+00 + -2.5058372734E+00 -2.4953021555E+00 -2.4848468376E+00 -2.4744709475E+00 + -2.4641741120E+00 -2.4539559565E+00 -2.4438161042E+00 -2.4337541749E+00 + -2.4237697845E+00 -2.4138625441E+00 -2.4040320595E+00 -2.3942779304E+00 + -2.3845997497E+00 -2.3749971034E+00 -2.3654695693E+00 -2.3560167176E+00 + -2.3466381093E+00 -2.3373332967E+00 -2.3281018229E+00 -2.3189432213E+00 + -2.3098570152E+00 -2.3008427184E+00 -2.2918998342E+00 -2.2830278558E+00 + -2.2742262660E+00 -2.2654945374E+00 -2.2568321325E+00 -2.2482385033E+00 + -2.2397130920E+00 -2.2312553309E+00 -2.2228646425E+00 -2.2145404401E+00 + -2.2062821277E+00 -2.1980891005E+00 -2.1899607454E+00 -2.1818964410E+00 + -2.1738955585E+00 -2.1659574617E+00 -2.1580815078E+00 -2.1502670477E+00 + -2.1425134267E+00 -2.1348199848E+00 -2.1271860575E+00 -2.1196109764E+00 + -2.1120940696E+00 -2.1046346624E+00 -2.0972320779E+00 -2.0898856376E+00 + -2.0825946623E+00 -2.0753584723E+00 -2.0681763883E+00 -2.0610477319E+00 + -2.0539718265E+00 -2.0469479976E+00 -2.0399755735E+00 -2.0330538860E+00 + -2.0261822710E+00 -2.0193600688E+00 -2.0125866252E+00 -2.0058612914E+00 + -1.9991834251E+00 -1.9925523904E+00 -1.9859675591E+00 -1.9794283103E+00 + -1.9729340313E+00 -1.9664841182E+00 -1.9600779756E+00 -1.9537150176E+00 + -1.9473946680E+00 -1.9411163602E+00 -1.9348795381E+00 -1.9286836557E+00 + -1.9225281780E+00 -1.9164125805E+00 -1.9103363498E+00 -1.9042989836E+00 + -1.8982999908E+00 -1.8923388916E+00 -1.8864152174E+00 -1.8805285111E+00 + -1.8746783269E+00 -1.8688642304E+00 -1.8630857980E+00 -1.8573426177E+00 + -1.8516342883E+00 -1.8459604198E+00 -1.8403206327E+00 -1.8347145581E+00 + -1.8291418378E+00 -1.8236021235E+00 -1.8180950769E+00 -1.8126203696E+00 + -1.8071776827E+00 -1.8017667063E+00 -1.7963871398E+00 -1.7910386908E+00 + -1.7857210757E+00 -1.7804340187E+00 -1.7751772519E+00 -1.7699505147E+00 + -1.7647535536E+00 -1.7595861221E+00 -1.7544479798E+00 -1.7493388928E+00 + -1.7442586327E+00 -1.7392069767E+00 -1.7341837073E+00 -1.7291886115E+00 + -1.7242214811E+00 -1.7192821120E+00 -1.7143703039E+00 -1.7094858603E+00 + -1.7046285879E+00 -1.6997982964E+00 -1.6949947984E+00 -1.6902179089E+00 + -1.6854674451E+00 -1.6807432263E+00 -1.6760450736E+00 -1.6713728097E+00 + -1.6667262585E+00 -1.6621052453E+00 -1.6575095962E+00 -1.6529391383E+00 + -1.6483936992E+00 -1.6438731072E+00 -1.6393771911E+00 -1.6349057799E+00 + -1.6304587026E+00 -1.6260357888E+00 -1.6216368679E+00 -1.6172617692E+00 + -1.6129103222E+00 -1.6085823562E+00 -1.6042777004E+00 -1.5999961839E+00 + -1.5957376358E+00 -1.5915018849E+00 -1.5872887601E+00 -1.5830980901E+00 + -1.5789297038E+00 -1.5747834299E+00 -1.5706590973E+00 -1.5665565351E+00 + -1.5624755725E+00 -1.5584160390E+00 -1.5543777646E+00 -1.5503605795E+00 + -1.5463643145E+00 -1.5423888011E+00 -1.5384338714E+00 -1.5344993583E+00 + -1.5305850955E+00 -1.5266909176E+00 -1.5228166605E+00 -1.5189621610E+00 + -1.5151272570E+00 -1.5113117881E+00 -1.5075155947E+00 -1.5037385192E+00 + -1.4999804051E+00 -1.4962410978E+00 -1.4925204440E+00 -1.4888182924E+00 + -1.4851344934E+00 -1.4814688991E+00 -1.4778213636E+00 -1.4741917428E+00 + -1.4705798945E+00 -1.4669856785E+00 -1.4634089567E+00 -1.4598495928E+00 + -1.4563074526E+00 -1.4527824038E+00 -1.4492743163E+00 -1.4457830619E+00 + -1.4423085144E+00 -1.4388505494E+00 -1.4354090448E+00 -1.4319838802E+00 + -1.4285749371E+00 -1.4251820989E+00 -1.4218052508E+00 -1.4184442799E+00 + -1.4150990748E+00 -1.4117695260E+00 -1.4084555255E+00 -1.4051569670E+00 + -1.4018737457E+00 -1.3986057582E+00 -1.3953529025E+00 -1.3921150781E+00 + -1.3888921857E+00 -1.3856841272E+00 -1.3824908057E+00 -1.3793121254E+00 + -1.3761479917E+00 -1.3729983109E+00 -1.3698629900E+00 -1.3667419373E+00 + -1.3636350617E+00 -1.3605422728E+00 -1.3574634812E+00 -1.3543985979E+00 + -1.3513475347E+00 -1.3483102039E+00 -1.3452865184E+00 -1.3422763916E+00 + -1.3392797375E+00 -1.3362964702E+00 -1.3333265045E+00 -1.3303697556E+00 + -1.3274261390E+00 -1.3244955704E+00 -1.3215779661E+00 -1.3186732426E+00 + -1.3157813166E+00 -1.3129021052E+00 -1.3100355258E+00 -1.3071814962E+00 + -1.3043399342E+00 -1.3015107582E+00 -1.2986938867E+00 -1.2958892387E+00 + -1.2930967333E+00 -1.2903162901E+00 -1.2875478290E+00 -1.2847912703E+00 + -1.2820465346E+00 -1.2793135430E+00 -1.2765922169E+00 -1.2738824782E+00 + -1.2711842495E+00 -1.2684974534E+00 -1.2658220134E+00 -1.2631578534E+00 + -1.2605048978E+00 -1.2578630718E+00 -1.2552323009E+00 -1.2526125114E+00 + -1.2500036302E+00 -1.2474055849E+00 -1.2448183037E+00 -1.2422417156E+00 + -1.2396757503E+00 -1.2371203382E+00 -1.2345754105E+00 -1.2320408990E+00 + -1.2295167365E+00 -1.2270028564E+00 -1.2244991931E+00 -1.2220056816E+00 + -1.2195222579E+00 -1.2170488585E+00 -1.2145854211E+00 -1.2121318838E+00 + -1.2096881859E+00 -1.2072542672E+00 -1.2048300685E+00 -1.2024155312E+00 + -1.2000105977E+00 -1.1976152109E+00 -1.1952293146E+00 -1.1928528535E+00 + -1.1904857726E+00 -1.1881280181E+00 -1.1857795365E+00 -1.1834402751E+00 + -1.1811101820E+00 -1.1787892056E+00 -1.1764772952E+00 -1.1741744005E+00 + -1.1718804719E+00 -1.1695954602E+00 -1.1673193168E+00 -1.1650519936E+00 + -1.1627934427E+00 -1.1605436171E+00 -1.1583024698E+00 -1.1560699543E+00 + -1.1538460246E+00 -1.1516306349E+00 -1.1494237398E+00 -1.1472252940E+00 + -1.1450352527E+00 -1.1428535714E+00 -1.1406802054E+00 -1.1385151108E+00 + -1.1363582434E+00 -1.1342095594E+00 -1.1320690154E+00 -1.1299365676E+00 + -1.1278121726E+00 -1.1256957860E+00 -1.1235873650E+00 -1.1214868701E+00 + -1.1193942589E+00 -1.1173094864E+00 -1.1152325060E+00 -1.1131632694E+00 + -1.1111017878E+00 -1.1090479189E+00 -1.1070016063E+00 -1.1049626803E+00 + -1.1029314784E+00 -1.1009083662E+00 -1.0988937405E+00 -1.0968874150E+00 + -1.0948885192E+00 -1.0928963075E+00 -1.0909100609E+00 -1.0889302760E+00 + -1.0869572367E+00 -1.0849915211E+00 -1.0830329967E+00 -1.0810816102E+00 + -1.0791372361E+00 -1.0771998216E+00 -1.0752693566E+00 -1.0733457992E+00 + -1.0714291102E+00 -1.0695192506E+00 -1.0676161851E+00 -1.0657198828E+00 + -1.0638303055E+00 -1.0619474173E+00 -1.0600711823E+00 -1.0582015654E+00 + -1.0563385317E+00 -1.0544820465E+00 -1.0526320753E+00 -1.0507885839E+00 + -1.0489515383E+00 -1.0471209047E+00 -1.0452966497E+00 -1.0434787400E+00 + -1.0416671425E+00 -1.0398618243E+00 -1.0380627530E+00 -1.0362698961E+00 + -1.0344832215E+00 -1.0327026973E+00 -1.0309282917E+00 -1.0291599733E+00 + -1.0273977108E+00 -1.0256414732E+00 -1.0238912295E+00 -1.0221469492E+00 + -1.0204086019E+00 -1.0186761573E+00 -1.0169495854E+00 -1.0152288564E+00 + -1.0135139407E+00 -1.0118048088E+00 -1.0101014317E+00 -1.0084037801E+00 + -1.0067118254E+00 -1.0050255389E+00 -1.0033448922E+00 -1.0016698570E+00 + -1.0000004052E+00 -9.9833650905E-01 -9.9667814078E-01 -9.9502527291E-01 + -9.9337787811E-01 -9.9173592926E-01 -9.9009939938E-01 -9.8846826169E-01 + -9.8684248960E-01 -9.8522205666E-01 -9.8360693662E-01 -9.8199710339E-01 + -9.8039253105E-01 -9.7879319387E-01 -9.7719906625E-01 -9.7561012278E-01 + -9.7402633823E-01 -9.7244768749E-01 -9.7087414566E-01 -9.6930568797E-01 + -9.6774228982E-01 -9.6618392677E-01 -9.6463057452E-01 -9.6308220897E-01 + -9.6153880611E-01 -9.6000034215E-01 -9.5846679340E-01 -9.5693813635E-01 + -9.5541434764E-01 -9.5389540403E-01 -9.5238128247E-01 -9.5087196001E-01 + -9.4936741389E-01 -9.4786762147E-01 -9.4637256025E-01 -9.4488220788E-01 + -9.4339654214E-01 -9.4191554097E-01 -9.4043918243E-01 -9.3896744473E-01 + -9.3750030620E-01 -9.3603774532E-01 -9.3457974070E-01 -9.3312627108E-01 + -9.3167731534E-01 -9.3023285248E-01 -9.2879286163E-01 -9.2735732206E-01 + -9.2592621316E-01 -9.2449951445E-01 -9.2307720557E-01 -9.2165926631E-01 + -9.2024567654E-01 -9.1883641629E-01 -9.1743146570E-01 -9.1603080503E-01 + -9.1463441466E-01 -9.1324227509E-01 -9.1185436694E-01 -9.1047067094E-01 + -9.0909116796E-01 -9.0771583896E-01 -9.0634466503E-01 -9.0497762736E-01 + -9.0361470726E-01 -9.0225588617E-01 -9.0090114562E-01 -8.9955046724E-01 + -8.9820383281E-01 -8.9686122419E-01 -8.9552262334E-01 -8.9418801236E-01 + -8.9285737343E-01 -8.9153068884E-01 -8.9020794100E-01 -8.8888911240E-01 + -8.8757418565E-01 -8.8626314347E-01 -8.8495596866E-01 -8.8365264414E-01 + -8.8235315293E-01 -8.8105747812E-01 -8.7976560295E-01 -8.7847751071E-01 + -8.7719318481E-01 -8.7591260877E-01 -8.7463576618E-01 -8.7336264074E-01 + -8.7209321624E-01 -8.7082747657E-01 -8.6956540570E-01 -8.6830698771E-01 + -8.6705220676E-01 -8.6580104711E-01 -8.6455349310E-01 -8.6330952917E-01 + -8.6206913984E-01 -8.6083230973E-01 -8.5959902355E-01 -8.5836926607E-01 + -8.5714302219E-01 -8.5592027685E-01 -8.5470101512E-01 -8.5348522212E-01 + -8.5227288308E-01 -8.5106398329E-01 -8.4985850814E-01 -8.4865644311E-01 + -8.4745777373E-01 -8.4626248565E-01 -8.4507056457E-01 -8.4388199629E-01 + -8.4269676669E-01 -8.4151486171E-01 -8.4033626738E-01 -8.3916096982E-01 + -8.3798895521E-01 -8.3682020982E-01 -8.3565471998E-01 -8.3449247212E-01 + -8.3333345272E-01 -8.3217764835E-01 -8.3102504565E-01 -8.2987563135E-01 + -8.2872939221E-01 -8.2758631512E-01 -8.2644638700E-01 -8.2530959485E-01 + -8.2417592576E-01 -8.2304536687E-01 -8.2191790541E-01 -8.2079352865E-01 + -8.1967222396E-01 -8.1855397876E-01 -8.1743878056E-01 -8.1632661690E-01 + -8.1521747543E-01 -8.1411134385E-01 -8.1300820991E-01 -8.1190806144E-01 + -8.1081088636E-01 -8.0971667261E-01 -8.0862540822E-01 -8.0753708129E-01 + -8.0645167997E-01 -8.0536919248E-01 -8.0428960710E-01 -8.0321291218E-01 + -8.0213909613E-01 -8.0106814740E-01 -8.0000005454E-01 -7.9893480614E-01 + -7.9787239085E-01 -7.9681279739E-01 -7.9575601453E-01 -7.9470203110E-01 + -7.9365083598E-01 -7.9260241812E-01 -7.9155676652E-01 -7.9051387021E-01 + -7.8947371837E-01 -7.8843630019E-01 -7.8740160492E-01 -7.8636962188E-01 + -7.8534034044E-01 -7.8431374995E-01 -7.8328983986E-01 -7.8226859966E-01 + -7.8125001886E-01 -7.8023408712E-01 -7.7922079414E-01 -7.7821012967E-01 + -7.7720208353E-01 -7.7619664556E-01 -7.7519380566E-01 -7.7419355374E-01 + -7.7319587981E-01 -7.7220077389E-01 -7.7120822607E-01 -7.7021822652E-01 + -7.6923076543E-01 -7.6824583305E-01 -7.6726341969E-01 -7.6628351569E-01 + -7.6530611145E-01 -7.6433119742E-01 -7.6335876409E-01 -7.6238880201E-01 + -7.6142130176E-01 -7.6045625399E-01 -7.5949364939E-01 -7.5853347868E-01 + -7.5757573265E-01 -7.5662040213E-01 -7.5566747798E-01 -7.5471695114E-01 + -7.5376881256E-01 -7.5282305325E-01 -7.5187966427E-01 -7.5093863673E-01 + -7.4999996175E-01 -7.4906363054E-01 -7.4812963433E-01 -7.4719796439E-01 + -7.4626861204E-01 -7.4534156865E-01 -7.4441682562E-01 -7.4349437440E-01 + -7.4257420648E-01 -7.4165631340E-01 -7.4074068672E-01 -7.3982731807E-01 + -7.3891619911E-01 -7.3800732152E-01 -7.3710067705E-01 -7.3619625749E-01 + -7.3529405464E-01 -7.3439406038E-01 -7.3349626660E-01 -7.3260066524E-01 + -7.3170724828E-01 -7.3081600774E-01 -7.2992693567E-01 -7.2904002417E-01 + -7.2815526538E-01 -7.2727265146E-01 -7.2639217463E-01 -7.2551382714E-01 + -7.2463760126E-01 -7.2376348933E-01 -7.2289148369E-01 -7.2202157675E-01 + -7.2115376094E-01 -7.2028802873E-01 -7.1942437262E-01 -7.1856278516E-01 + -7.1770325892E-01 -7.1684578651E-01 -7.1599036058E-01 -7.1513697381E-01 + -7.1428561893E-01 -7.1343628867E-01 -7.1258897584E-01 -7.1174367324E-01 + -7.1090037374E-01 -7.1005907022E-01 -7.0921975560E-01 -7.0838242284E-01 + -7.0754706493E-01 -7.0671367490E-01 -7.0588224578E-01 -7.0505277068E-01 + -7.0422524271E-01 -7.0339965502E-01 -7.0257600080E-01 -7.0175427327E-01 + -7.0093446567E-01 -7.0011657127E-01 -6.9930058340E-01 -6.9848649539E-01 + -6.9767430061E-01 -6.9686399247E-01 -6.9605556441E-01 -6.9524900988E-01 + -6.9444432238E-01 -6.9364149544E-01 -6.9284052261E-01 -6.9204139748E-01 + -6.9124411365E-01 -6.9044866478E-01 -6.8965504453E-01 -6.8886324661E-01 + -6.8807326474E-01 -6.8728509270E-01 -6.8649872425E-01 -6.8571415323E-01 + -6.8493137347E-01 -6.8415037885E-01 -6.8337116327E-01 -6.8259372065E-01 + -6.8181804496E-01 -6.8104413017E-01 -6.8027197029E-01 -6.7950155937E-01 + -6.7873289147E-01 -6.7796596068E-01 -6.7720076111E-01 -6.7643728692E-01 + -6.7567553227E-01 -6.7491549136E-01 -6.7415715841E-01 -6.7340052768E-01 + -6.7264559344E-01 -6.7189234998E-01 -6.7114079164E-01 -6.7039091277E-01 + -6.6964270773E-01 -6.6889617095E-01 -6.6815129684E-01 -6.6740807985E-01 + -6.6666651446E-01 -6.6592659517E-01 -6.6518831650E-01 -6.6445167302E-01 + -6.6371665928E-01 -6.6298326988E-01 -6.6225149946E-01 -6.6152134265E-01 + -6.6079279411E-01 -6.6006584856E-01 -6.5934050069E-01 -6.5861674525E-01 + -6.5789457699E-01 -6.5717399071E-01 -6.5645498122E-01 -6.5573754333E-01 + -6.5502167191E-01 -6.5430736183E-01 -6.5359460799E-01 -6.5288340530E-01 + -6.5217374871E-01 -6.5146563319E-01 -6.5075905371E-01 -6.5005400529E-01 + -6.4935048296E-01 -6.4864848176E-01 -6.4794799676E-01 -6.4724902307E-01 + -6.4655155579E-01 -6.4585559006E-01 -6.4516112104E-01 -6.4446814390E-01 + -6.4377665385E-01 -6.4308664609E-01 -6.4239811587E-01 -6.4171105845E-01 + -6.4102546911E-01 -6.4034134314E-01 -6.3965867587E-01 -6.3897746264E-01 + -6.3829769880E-01 -6.3761937973E-01 -6.3694250084E-01 -6.3626705754E-01 + -6.3559304527E-01 -6.3492045949E-01 -6.3424929567E-01 -6.3357954931E-01 + -6.3291121592E-01 -6.3224429103E-01 -6.3157877020E-01 -6.3091464901E-01 + -6.3025192303E-01 -6.2959058787E-01 -6.2893063917E-01 -6.2827207256E-01 + -6.2761488372E-01 -6.2695906831E-01 -6.2630462205E-01 -6.2565154064E-01 + -6.2499981982E-01 -6.2434945534E-01 -6.2370044299E-01 -6.2305277853E-01 + -6.2240645778E-01 -6.2176147656E-01 -6.2111783070E-01 -6.2047551608E-01 + -6.1983452856E-01 -6.1919486403E-01 -6.1855651840E-01 -6.1791948759E-01 + -6.1728376756E-01 -6.1664935425E-01 -6.1601624364E-01 -6.1538443172E-01 + -6.1475391451E-01 -6.1412468802E-01 -6.1349674830E-01 -6.1287009140E-01 + -6.1224471340E-01 -6.1162061038E-01 -6.1099777845E-01 -6.1037621373E-01 + -6.0975591237E-01 -6.0913687050E-01 -6.0851908429E-01 -6.0790254994E-01 + -6.0728726364E-01 -6.0667322160E-01 -6.0606042006E-01 -6.0544885525E-01 + -6.0483852344E-01 -6.0422942090E-01 -6.0362154393E-01 -6.0301488882E-01 + -6.0240945190E-01 -6.0180522951E-01 -6.0120221798E-01 -6.0060041368E-01 + -5.9999981300E-01 -5.9940041233E-01 -5.9880220807E-01 -5.9820519664E-01 + -5.9760937448E-01 -5.9701473804E-01 -5.9642128378E-01 -5.9582900819E-01 + -5.9523790775E-01 -5.9464797897E-01 -5.9405921837E-01 -5.9347162248E-01 + -5.9288518785E-01 -5.9229991105E-01 -5.9171578864E-01 -5.9113281721E-01 + -5.9055099337E-01 -5.8997031373E-01 -5.8939077492E-01 -5.8881237357E-01 + -5.8823510635E-01 -5.8765896992E-01 -5.8708396097E-01 -5.8651007618E-01 + -5.8593731226E-01 -5.8536566593E-01 -5.8479513393E-01 -5.8422571299E-01 + -5.8365739988E-01 -5.8309019137E-01 -5.8252408424E-01 -5.8195907528E-01 + -5.8139516130E-01 -5.8083233912E-01 -5.8027060558E-01 -5.7970995752E-01 + -5.7915039179E-01 -5.7859190527E-01 -5.7803449483E-01 -5.7747815737E-01 + -5.7692288979E-01 -5.7636868901E-01 -5.7581555196E-01 -5.7526347558E-01 + -5.7471245682E-01 -5.7416249264E-01 -5.7361358002E-01 -5.7306571595E-01 + -5.7251889743E-01 -5.7197312146E-01 -5.7142838506E-01 -5.7088468528E-01 + -5.7034201914E-01 -5.6980038372E-01 -5.6925977607E-01 -5.6872019327E-01 + -5.6818163241E-01 -5.6764409059E-01 -5.6710756491E-01 -5.6657205251E-01 + -5.6603755052E-01 -5.6550405607E-01 -5.6497156632E-01 -5.6444007843E-01 + -5.6390958959E-01 -5.6338009697E-01 -5.6285159777E-01 -5.6232408920E-01 + -5.6179756848E-01 -5.6127203283E-01 -5.6074747949E-01 -5.6022390572E-01 + -5.5970130876E-01 -5.5917968589E-01 -5.5865903439E-01 -5.5813935154E-01 + -5.5762063465E-01 -5.5710288103E-01 -5.5658608799E-01 -5.5607025286E-01 + -5.5555537299E-01 -5.5504144571E-01 -5.5452846840E-01 -5.5401643842E-01 + -5.5350535314E-01 -5.5299520996E-01 -5.5248600627E-01 -5.5197773947E-01 + -5.5147040700E-01 -5.5096400627E-01 -5.5045853471E-01 -5.4995398978E-01 + -5.4945036892E-01 -5.4894766961E-01 -5.4844588931E-01 -5.4794502550E-01 + -5.4744507569E-01 -5.4694603735E-01 -5.4644790802E-01 -5.4595068520E-01 + -5.4545436643E-01 -5.4495894923E-01 -5.4446443116E-01 -5.4397080978E-01 + -5.4347808263E-01 -5.4298624730E-01 -5.4249530137E-01 -5.4200524242E-01 + -5.4151606806E-01 -5.4102777589E-01 -5.4054036353E-01 -5.4005382860E-01 + -5.3956816873E-01 -5.3908338157E-01 -5.3859946476E-01 -5.3811641597E-01 + -5.3763423286E-01 -5.3715291311E-01 -5.3667245439E-01 -5.3619285441E-01 + -5.3571411085E-01 -5.3523622143E-01 -5.3475918387E-01 -5.3428299589E-01 + -5.3380765521E-01 -5.3333315959E-01 -5.3285950677E-01 -5.3238669450E-01 + -5.3191472056E-01 -5.3144358271E-01 -5.3097327873E-01 -5.3050380642E-01 + -5.3003516356E-01 -5.2956734797E-01 -5.2910035744E-01 -5.2863418981E-01 + -5.2816884290E-01 -5.2770431455E-01 -5.2724060259E-01 -5.2677770487E-01 + -5.2631561926E-01 -5.2585434361E-01 -5.2539387580E-01 -5.2493421371E-01 + -5.2447535523E-01 -5.2401729825E-01 -5.2356004068E-01 -5.2310358041E-01 + -5.2264791537E-01 -5.2219304349E-01 -5.2173896268E-01 -5.2128567090E-01 + -5.2083316608E-01 -5.2038144619E-01 -5.1993050917E-01 -5.1948035299E-01 + -5.1903097564E-01 -5.1858237508E-01 -5.1813454930E-01 -5.1768749631E-01 + -5.1724121410E-01 -5.1679570068E-01 -5.1635095407E-01 -5.1590697229E-01 + -5.1546375336E-01 -5.1502129532E-01 -5.1457959622E-01 -5.1413865410E-01 + -5.1369846701E-01 -5.1325903303E-01 -5.1282035022E-01 -5.1238241666E-01 + -5.1194523042E-01 -5.1150878961E-01 -5.1107309230E-01 -5.1063813660E-01 + -5.1020392063E-01 -5.0977044249E-01 -5.0933770031E-01 -5.0890569222E-01 + -5.0847441634E-01 -5.0804387082E-01 -5.0761405381E-01 -5.0718496345E-01 + -5.0675659791E-01 -5.0632895535E-01 -5.0590203394E-01 -5.0547583186E-01 + -5.0505034729E-01 -5.0462557842E-01 -5.0420152345E-01 -5.0377818059E-01 + -5.0335554803E-01 -5.0293362399E-01 -5.0251240669E-01 -5.0209189436E-01 + -5.0167208523E-01 -5.0125297753E-01 -5.0083456952E-01 -5.0041685943E-01 + -4.9999984553E-01 -4.9958352607E-01 -4.9916789933E-01 -4.9875296357E-01 + -4.9833871707E-01 -4.9792515812E-01 -4.9751228500E-01 -4.9710009602E-01 + -4.9668858947E-01 -4.9627776366E-01 -4.9586761690E-01 -4.9545814751E-01 + -4.9504935381E-01 -4.9464123414E-01 -4.9423378682E-01 -4.9382701019E-01 + -4.9342090261E-01 -4.9301546242E-01 -4.9261068798E-01 -4.9220657764E-01 + -4.9180312979E-01 -4.9140034278E-01 -4.9099821500E-01 -4.9059674483E-01 + -4.9019593065E-01 -4.8979577087E-01 -4.8939626388E-01 -4.8899740808E-01 + -4.8859920188E-01 -4.8820164370E-01 -4.8780473196E-01 -4.8740846507E-01 + -4.8701284148E-01 -4.8661785962E-01 -4.8622351792E-01 -4.8582981483E-01 + -4.8543674880E-01 -4.8504431829E-01 -4.8465252175E-01 -4.8426135765E-01 + -4.8387082446E-01 -4.8348092066E-01 -4.8309164472E-01 -4.8270299514E-01 + -4.8231497039E-01 -4.8192756897E-01 -4.8154078939E-01 -4.8115463014E-01 + -4.8076908974E-01 -4.8038416670E-01 -4.7999985953E-01 -4.7961616677E-01 + -4.7923308693E-01 -4.7885061856E-01 -4.7846876018E-01 -4.7808751034E-01 + -4.7770686759E-01 -4.7732683048E-01 -4.7694739755E-01 -4.7656856739E-01 + -4.7619033853E-01 -4.7581270957E-01 -4.7543567907E-01 -4.7505924561E-01 + -4.7468340777E-01 -4.7430816414E-01 -4.7393351331E-01 -4.7355945389E-01 + -4.7318598446E-01 -4.7281310363E-01 -4.7244081003E-01 -4.7206910224E-01 + -4.7169797891E-01 -4.7132743864E-01 -4.7095748007E-01 -4.7058810183E-01 + -4.7021930255E-01 -4.6985108088E-01 -4.6948343545E-01 -4.6911636492E-01 + -4.6874986793E-01 -4.6838394315E-01 -4.6801858923E-01 -4.6765380485E-01 + -4.6728958867E-01 -4.6692593935E-01 -4.6656285560E-01 -4.6620033607E-01 + -4.6583837946E-01 -4.6547698446E-01 -4.6511614977E-01 -4.6475587407E-01 + -4.6439615608E-01 -4.6403699449E-01 -4.6367838803E-01 -4.6332033539E-01 + -4.6296283531E-01 -4.6260588650E-01 -4.6224948769E-01 -4.6189363761E-01 + -4.6153833498E-01 -4.6118357856E-01 -4.6082936708E-01 -4.6047569928E-01 + -4.6012257392E-01 -4.5976998975E-01 -4.5941794553E-01 -4.5906644001E-01 + -4.5871547196E-01 -4.5836504014E-01 -4.5801514334E-01 -4.5766578033E-01 + -4.5731694988E-01 -4.5696865078E-01 -4.5662088182E-01 -4.5627364178E-01 + -4.5592692946E-01 -4.5558074366E-01 -4.5523508318E-01 -4.5488994683E-01 + -4.5454533341E-01 -4.5420124173E-01 -4.5385767062E-01 -4.5351461889E-01 + -4.5317208537E-01 -4.5283006888E-01 -4.5248856825E-01 -4.5214758231E-01 + -4.5180710991E-01 -4.5146714989E-01 -4.5112770108E-01 -4.5078876233E-01 + -4.5045033251E-01 -4.5011241045E-01 -4.4977499503E-01 -4.4943808510E-01 + -4.4910167952E-01 -4.4876577717E-01 -4.4843037691E-01 -4.4809547763E-01 + -4.4776107819E-01 -4.4742717749E-01 -4.4709377440E-01 -4.4676086782E-01 + -4.4642845664E-01 -4.4609653974E-01 -4.4576511604E-01 -4.4543418443E-01 + -4.4510374381E-01 -4.4477379310E-01 -4.4444433121E-01 -4.4411535704E-01 + -4.4378686953E-01 -4.4345886758E-01 -4.4313135013E-01 -4.4280431610E-01 + -4.4247776441E-01 -4.4215169402E-01 -4.4182610384E-01 -4.4150099283E-01 + -4.4117635992E-01 -4.4085220406E-01 -4.4052852420E-01 -4.4020531929E-01 + -4.3988258829E-01 -4.3956033016E-01 -4.3923854385E-01 -4.3891722834E-01 + -4.3859638258E-01 -4.3827600556E-01 -4.3795609624E-01 -4.3763665360E-01 + -4.3731767662E-01 -4.3699916428E-01 -4.3668111557E-01 -4.3636352947E-01 + -4.3604640499E-01 -4.3572974110E-01 -4.3541353682E-01 -4.3509779113E-01 + -4.3478250305E-01 -4.3446767157E-01 -4.3415329571E-01 -4.3383937448E-01 + -4.3352590690E-01 -4.3321289197E-01 -4.3290032873E-01 -4.3258821619E-01 + -4.3227655338E-01 -4.3196533932E-01 -4.3165457306E-01 -4.3134425362E-01 + -4.3103438005E-01 -4.3072495137E-01 -4.3041596664E-01 -4.3010742490E-01 + -4.2979932519E-01 -4.2949166657E-01 -4.2918444809E-01 -4.2887766881E-01 + -4.2857132779E-01 -4.2826542408E-01 -4.2795995675E-01 -4.2765492488E-01 + -4.2735032752E-01 -4.2704616375E-01 -4.2674243265E-01 -4.2643913329E-01 + -4.2613626475E-01 -4.2583382612E-01 -4.2553181648E-01 -4.2523023492E-01 + -4.2492908053E-01 -4.2462835240E-01 -4.2432804963E-01 -4.2402817131E-01 + -4.2372871655E-01 -4.2342968445E-01 -4.2313107412E-01 -4.2283288466E-01 + -4.2253511519E-01 -4.2223776481E-01 -4.2194083265E-01 -4.2164431782E-01 + -4.2134821945E-01 -4.2105253665E-01 -4.2075726855E-01 -4.2046241429E-01 + -4.2016797298E-01 -4.1987394377E-01 -4.1958032579E-01 -4.1928711818E-01 + -4.1899432007E-01 -4.1870193061E-01 -4.1840994895E-01 -4.1811837424E-01 + -4.1782720561E-01 -4.1753644223E-01 -4.1724608325E-01 -4.1695612783E-01 + -4.1666657512E-01 -4.1637742429E-01 -4.1608867451E-01 -4.1580032492E-01 + -4.1551237472E-01 -4.1522482306E-01 -4.1493766912E-01 -4.1465091208E-01 + -4.1436455111E-01 -4.1407858539E-01 -4.1379301411E-01 -4.1350783645E-01 + -4.1322305160E-01 -4.1293865874E-01 -4.1265465706E-01 -4.1237104577E-01 + -4.1208782406E-01 -4.1180499111E-01 -4.1152254614E-01 -4.1124048835E-01 + -4.1095881694E-01 -4.1067753111E-01 -4.1039663008E-01 -4.1011611306E-01 + -4.0983597926E-01 -4.0955622789E-01 -4.0927685817E-01 -4.0899786933E-01 + -4.0871926058E-01 -4.0844103115E-01 -4.0816318026E-01 -4.0788570714E-01 + -4.0760861102E-01 -4.0733189114E-01 -4.0705554672E-01 -4.0677957701E-01 + -4.0650398124E-01 -4.0622875866E-01 -4.0595390850E-01 -4.0567943001E-01 + -4.0540532244E-01 -4.0513158503E-01 -4.0485821704E-01 -4.0458521771E-01 + -4.0431258631E-01 -4.0404032210E-01 -4.0376842432E-01 -4.0349689223E-01 + -4.0322572512E-01 -4.0295492223E-01 -4.0268448283E-01 -4.0241440619E-01 + -4.0214469159E-01 -4.0187533829E-01 -4.0160634558E-01 -4.0133771272E-01 + -4.0106943899E-01 -4.0080152368E-01 -4.0053396606E-01 -4.0026676543E-01 + -3.9999992107E-01 -3.9973343226E-01 -3.9946729829E-01 -3.9920151846E-01 + -3.9893609207E-01 -3.9867101839E-01 -3.9840629675E-01 -3.9814192642E-01 + -3.9787790672E-01 -3.9761423694E-01 -3.9735091640E-01 -3.9708794439E-01 + -3.9682532023E-01 -3.9656304323E-01 -3.9630111270E-01 -3.9603952794E-01 + -3.9577828829E-01 -3.9551739305E-01 -3.9525684155E-01 -3.9499663311E-01 + -3.9473676704E-01 -3.9447724268E-01 -3.9421805935E-01 -3.9395921638E-01 + -3.9370071309E-01 -3.9344254883E-01 -3.9318472292E-01 -3.9292723470E-01 + -3.9267008351E-01 -3.9241326868E-01 -3.9215678955E-01 -3.9190064548E-01 + -3.9164483580E-01 -3.9138935985E-01 -3.9113421699E-01 -3.9087940656E-01 + -3.9062492791E-01 -3.9037078041E-01 -3.9011696339E-01 -3.8986347622E-01 + -3.8961031825E-01 -3.8935748885E-01 -3.8910498737E-01 -3.8885281318E-01 + -3.8860096563E-01 -3.8834944411E-01 -3.8809824796E-01 -3.8784737657E-01 + -3.8759682930E-01 -3.8734660553E-01 -3.8709670463E-01 -3.8684712597E-01 + -3.8659786893E-01 -3.8634893290E-01 -3.8610031724E-01 -3.8585202135E-01 + -3.8560404460E-01 -3.8535638639E-01 -3.8510904609E-01 -3.8486202310E-01 + -3.8461531680E-01 -3.8436892660E-01 -3.8412285187E-01 -3.8387709202E-01 + -3.8363164643E-01 -3.8338651452E-01 -3.8314169567E-01 -3.8289718930E-01 + -3.8265299479E-01 -3.8240911155E-01 -3.8216553900E-01 -3.8192227653E-01 + -3.8167932355E-01 -3.8143667948E-01 -3.8119434373E-01 -3.8095231570E-01 + -3.8071059481E-01 -3.8046918048E-01 -3.8022807213E-01 -3.7998726917E-01 + -3.7974677102E-01 -3.7950657711E-01 -3.7926668686E-01 -3.7902709969E-01 + -3.7878781503E-01 -3.7854883230E-01 -3.7831015094E-01 -3.7807177038E-01 + -3.7783369004E-01 -3.7759590937E-01 -3.7735842778E-01 -3.7712124473E-01 + -3.7688435965E-01 -3.7664777198E-01 -3.7641148115E-01 -3.7617548661E-01 + -3.7593978781E-01 -3.7570438418E-01 -3.7546927517E-01 -3.7523446024E-01 + -3.7499993882E-01 -3.7476571037E-01 -3.7453177434E-01 -3.7429813018E-01 + -3.7406477735E-01 -3.7383171531E-01 -3.7359894350E-01 -3.7336646139E-01 + -3.7313426843E-01 -3.7290236409E-01 -3.7267074784E-01 -3.7243941912E-01 + -3.7220837742E-01 -3.7197762218E-01 -3.7174715289E-01 -3.7151696902E-01 + -3.7128707002E-01 -3.7105745537E-01 -3.7082812455E-01 -3.7059907703E-01 + -3.7037031228E-01 -3.7014182979E-01 -3.6991362902E-01 -3.6968570946E-01 + -3.6945807059E-01 -3.6923071189E-01 -3.6900363285E-01 -3.6877683294E-01 + -3.6855031166E-01 -3.6832406849E-01 -3.6809810291E-01 -3.6787241443E-01 + -3.6764700252E-01 -3.6742186669E-01 -3.6719700641E-01 -3.6697242120E-01 + -3.6674811054E-01 -3.6652407393E-01 -3.6630031087E-01 -3.6607682086E-01 + -3.6585360340E-01 -3.6563065798E-01 -3.6540798412E-01 -3.6518558132E-01 + -3.6496344908E-01 -3.6474158691E-01 -3.6451999432E-01 -3.6429867081E-01 + -3.6407761590E-01 -3.6385682910E-01 -3.6363630992E-01 -3.6341605787E-01 + -3.6319607247E-01 -3.6297635324E-01 -3.6275689968E-01 -3.6253771133E-01 + -3.6231878770E-01 -3.6210012831E-01 -3.6188173268E-01 -3.6166360034E-01 + -3.6144573080E-01 -3.6122812361E-01 -3.6101077827E-01 -3.6079369432E-01 + -3.6057687130E-01 -3.6036030871E-01 -3.6014400611E-01 -3.5992796302E-01 + -3.5971217898E-01 -3.5949665351E-01 -3.5928138615E-01 -3.5906637645E-01 + -3.5885162394E-01 -3.5863712815E-01 -3.5842288863E-01 -3.5820890492E-01 + -3.5799517656E-01 -3.5778170309E-01 -3.5756848406E-01 -3.5735551901E-01 + -3.5714280749E-01 -3.5693034905E-01 -3.5671814324E-01 -3.5650618960E-01 + -3.5629448769E-01 -3.5608303705E-01 -3.5587183725E-01 -3.5566088783E-01 + -3.5545018835E-01 -3.5523973837E-01 -3.5502953744E-01 -3.5481958512E-01 + -3.5460988098E-01 -3.5440042456E-01 -3.5419121543E-01 -3.5398225316E-01 + -3.5377353731E-01 -3.5356506744E-01 -3.5335684311E-01 -3.5314886390E-01 + -3.5294112937E-01 -3.5273363909E-01 -3.5252639263E-01 -3.5231938956E-01 + -3.5211262946E-01 -3.5190611188E-01 -3.5169983641E-01 -3.5149380262E-01 + -3.5128801010E-01 -3.5108245840E-01 -3.5087714712E-01 -3.5067207582E-01 + -3.5046724409E-01 -3.5026265152E-01 -3.5005829767E-01 -3.4985418214E-01 + -3.4965030451E-01 -3.4944666435E-01 -3.4924326126E-01 -3.4904009483E-01 + -3.4883716463E-01 -3.4863447027E-01 -3.4843201132E-01 -3.4822978738E-01 + -3.4802779803E-01 -3.4782604288E-01 -3.4762452151E-01 -3.4742323351E-01 + -3.4722217849E-01 -3.4702135604E-01 -3.4682076575E-01 -3.4662040722E-01 + -3.4642028006E-01 -3.4622038385E-01 -3.4602071821E-01 -3.4582128272E-01 + -3.4562207701E-01 -3.4542310065E-01 -3.4522435327E-01 -3.4502583447E-01 + -3.4482754385E-01 -3.4462948102E-01 -3.4443164558E-01 -3.4423403715E-01 + -3.4403665534E-01 -3.4383949975E-01 -3.4364257000E-01 -3.4344586569E-01 + -3.4324938645E-01 -3.4305313189E-01 -3.4285710161E-01 -3.4266129524E-01 + -3.4246571240E-01 -3.4227035270E-01 -3.4207521575E-01 -3.4188030118E-01 + -3.4168560861E-01 -3.4149113766E-01 -3.4129688795E-01 -3.4110285911E-01 + -3.4090905075E-01 -3.4071546250E-01 -3.4052209399E-01 -3.4032894485E-01 + -3.4013601469E-01 -3.3994330315E-01 -3.3975080986E-01 -3.3955853444E-01 + -3.3936647653E-01 -3.3917463575E-01 -3.3898301175E-01 -3.3879160414E-01 + -3.3860041258E-01 -3.3840943668E-01 -3.3821867608E-01 -3.3802813043E-01 + -3.3783779936E-01 -3.3764768250E-01 -3.3745777950E-01 -3.3726808999E-01 + -3.3707861362E-01 -3.3688935002E-01 -3.3670029883E-01 -3.3651145971E-01 + -3.3632283229E-01 -3.3613441622E-01 -3.3594621114E-01 -3.3575821670E-01 + -3.3557043254E-01 -3.3538285831E-01 -3.3519549366E-01 -3.3500833825E-01 + -3.3482139171E-01 -3.3463465370E-01 -3.3444812387E-01 -3.3426180187E-01 + -3.3407568736E-01 -3.3388977999E-01 -3.3370407941E-01 -3.3351858528E-01 + -3.3333329725E-01 -3.3314821499E-01 -3.3296333814E-01 -3.3277866637E-01 + -3.3259419934E-01 -3.3240993670E-01 -3.3222587812E-01 -3.3204202325E-01 + -3.3185837176E-01 -3.3167492332E-01 -3.3149167758E-01 -3.3130863421E-01 + -3.3112579288E-01 -3.3094315324E-01 -3.3076071497E-01 -3.3057847774E-01 + -3.3039644121E-01 -3.3021460504E-01 -3.3003296892E-01 -3.2985153251E-01 + -3.2967029548E-01 -3.2948925749E-01 -3.2930841824E-01 -3.2912777738E-01 + -3.2894733459E-01 -3.2876708955E-01 -3.2858704193E-01 -3.2840719140E-01 + -3.2822753765E-01 -3.2804808035E-01 -3.2786881917E-01 -3.2768975380E-01 + -3.2751088392E-01 -3.2733220921E-01 -3.2715372934E-01 -3.2697544400E-01 + -3.2679735287E-01 -3.2661945563E-01 -3.2644175197E-01 -3.2626424157E-01 + -3.2608692412E-01 -3.2590979930E-01 -3.2573286680E-01 -3.2555612630E-01 + -3.2537957749E-01 -3.2520322006E-01 -3.2502705371E-01 -3.2485107811E-01 + -3.2467529297E-01 -3.2449969796E-01 -3.2432429278E-01 -3.2414907714E-01 + -3.2397405070E-01 -3.2379921318E-01 -3.2362456427E-01 -3.2345010365E-01 + -3.2327583104E-01 -3.2310174611E-01 -3.2292784857E-01 -3.2275413813E-01 + -3.2258061446E-01 -3.2240727728E-01 -3.2223412629E-01 -3.2206116118E-01 + -3.2188838165E-01 -3.2171578741E-01 -3.2154337815E-01 -3.2137115359E-01 + -3.2119911343E-01 -3.2102725736E-01 -3.2085558509E-01 -3.2068409634E-01 + + + + -4.4524667286E-10 3.6237216635E-02 7.2388363711E-02 1.0836819358E-01 + 1.4409309272E-01 1.7948187460E-01 2.1445654387E-01 2.4894302284E-01 + 2.8287183167E-01 3.1617871411E-01 3.4880520156E-01 3.8069910876E-01 + 4.1181495500E-01 4.4211430630E-01 4.7156603405E-01 5.0014648745E-01 + 5.2783957742E-01 5.5463677117E-01 5.8053699746E-01 6.0554646359E-01 + 6.2967838653E-01 6.5295264117E-01 6.7539532999E-01 6.9703827937E-01 + 7.1791846846E-01 7.3807739744E-01 7.5756040287E-01 7.7641592824E-01 + 7.9469475851E-01 8.1244922789E-01 8.2973241041E-01 8.4659730305E-01 + 8.6309601138E-01 8.7927894751E-01 8.9519405027E-01 9.1088603706E-01 + 9.2639569662E-01 9.4175923141E-01 9.5700765790E-01 9.7216627209E-01 + 9.8725418727E-01 1.0022839498E+00 1.0172612379E+00 1.0321846477E+00 + 1.0470455696E+00 1.0618281566E+00 1.0765093860E+00 1.0910592135E+00 + 1.1054408198E+00 1.1196109457E+00 1.1335203132E+00 1.1471141280E+00 + 1.1603326577E+00 1.1731118792E+00 1.1853841892E+00 1.1970791674E+00 + 1.2081243864E+00 1.2184462572E+00 1.2279709011E+00 1.2366250379E+00 + 1.2443368799E+00 1.2510370216E+00 1.2566593132E+00 1.2611417102E+00 + 1.2644270853E+00 1.2664639957E+00 1.2672073957E+00 1.2666192846E+00 + 1.2646692832E+00 1.2613351314E+00 1.2566030996E+00 1.2504683091E+00 + 1.2429349573E+00 1.2340164434E+00 1.2237353932E+00 1.2121235811E+00 + 1.1992217501E+00 1.1850793306E+00 1.1697540602E+00 1.1533115092E+00 + 1.1358245144E+00 1.1173725291E+00 1.0980408951E+00 1.0779200439E+00 + 1.0571046367E+00 1.0356926517E+00 1.0137844294E+00 9.9148168593E-01 + 9.6888650502E-01 9.4610032122E-01 9.2322290443E-01 9.0035135813E-01 + 8.7757914242E-01 8.5499513326E-01 8.3268272877E-01 8.1071901307E-01 + 7.8917398751E-01 7.6810987858E-01 7.4758053070E-01 7.2763089149E-01 + 7.0829659594E-01 6.8960365488E-01 6.7156825201E-01 6.5419665250E-01 + 6.3748522498E-01 6.2142057753E-01 6.0597980674E-01 5.9113085800E-01 + 5.7683299356E-01 5.6303736392E-01 5.4968767665E-01 5.3672095601E-01 + 5.2406838499E-01 5.1165622131E-01 4.9940677705E-01 4.8723945161E-01 + 4.7507180648E-01 4.6282067003E-01 4.5040325991E-01 4.3773831061E-01 + 4.2474719321E-01 4.1135501475E-01 3.9749168445E-01 3.8309293446E-01 + 3.6810128308E-01 3.5246692927E-01 3.3614856732E-01 3.1911411220E-01 + 3.0134132610E-01 2.8281833857E-01 2.6354405305E-01 2.4352843426E-01 + 2.2279267208E-01 2.0136921866E-01 1.7930169722E-01 1.5664468213E-01 + 1.3346335142E-01 1.0983301419E-01 8.5838516887E-02 6.1573533654E-02 + 3.7139747399E-02 1.2645929349E-02 -1.1793073860E-02 -3.6057435497E-02 + -6.0023515380E-02 -8.3565085919E-02 -1.0655460490E-01 -1.2886452169E-01 + -1.5036860320E-01 -1.7094326535E-01 -1.9046889608E-01 -2.0883115526E-01 + -2.2592223773E-01 -2.4164208534E-01 -2.5589953473E-01 -2.6861338791E-01 + -2.7971339364E-01 -2.8914112822E-01 -2.9685076551E-01 -3.0280972700E-01 + -3.0699920389E-01 -3.0941454455E-01 -3.1006550204E-01 -3.0897633779E-01 + -3.0618577909E-01 -3.0174682944E-01 -2.9572643252E-01 -2.8820499181E-01 + -2.7927574975E-01 -2.6904403149E-01 -2.5762635989E-01 -2.4514944982E-01 + -2.3174909094E-01 -2.1756892959E-01 -2.0275916126E-01 -1.8747514628E-01 + -1.7187596207E-01 -1.5612290619E-01 -1.4037796479E-01 -1.2480226155E-01 + -1.0955450050E-01 -9.4789438756E-02 -8.0656324270E-02 -6.7297505826E-02 + -5.4849084194E-02 -4.3437508047E-02 -3.3174898024E-02 -2.4161069614E-02 + -1.6482323691E-02 -1.0210609455E-02 -5.4048638973E-03 -2.0858734073E-03 + -3.6980760447E-04 4.8086079603E-05 -9.0394501399E-06 2.5296317379E-07 + 9.2402569023E-07 3.5692908072E-10 0.0000000000E+00 0.0000000000E+00 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + 1.3608919269E-09 -2.4226846873E-02 -4.8245715412E-02 -7.1851066896E-02 + -9.4842212329E-02 -1.1702566389E-01 -1.3821739927E-01 -1.5824501149E-01 + -1.7694971809E-01 -1.9418820537E-01 -2.0983428517E-01 -2.2378034411E-01 + -2.3593856741E-01 -2.4624192236E-01 -2.5464488927E-01 -2.6112393063E-01 + -2.6567769251E-01 -2.6832693540E-01 -2.6911419483E-01 -2.6810317536E-01 + -2.6537788497E-01 -2.6104151958E-01 -2.5521511090E-01 -2.4803595326E-01 + -2.3965582814E-01 -2.3023904729E-01 -2.1996033761E-01 -2.0900259319E-01 + -1.9755452110E-01 -1.8580820930E-01 -1.7395664582E-01 -1.6219121912E-01 + -1.5069922976E-01 -1.3966144373E-01 -1.2924971705E-01 -1.1962472076E-01 + -1.1093379432E-01 -1.0330895383E-01 -9.6865079917E-02 -9.1698308129E-02 + -8.7884642082E-02 -8.5478807399E-02 -8.4513361438E-02 -8.4998070942E-02 + -8.6919566583E-02 -9.0241280131E-02 -9.4903666646E-02 -1.0082471073E-01 + -1.0790071250E-01 -1.1600734555E-01 -1.2500097602E-01 -1.3472022868E-01 + -1.4498778280E-01 -1.5561237812E-01 -1.6639100823E-01 -1.7711127654E-01 + -1.8755388808E-01 -1.9749524831E-01 -2.0671013886E-01 -2.1497443910E-01 + -2.2206786154E-01 -2.2777666887E-01 -2.3189634024E-01 -2.3423415507E-01 + -2.3461166317E-01 -2.3286701119E-01 -2.2885709703E-01 -2.2245952533E-01 + -2.1357433970E-01 -2.0212550954E-01 -1.8806215202E-01 -1.7135947289E-01 + -1.5201941286E-01 -1.3007098949E-01 -1.0557032837E-01 -7.8600380486E-02 + -4.9270326617E-02 -1.7714673110E-02 1.5907952998E-02 5.1416298005E-02 + 8.8608249758E-02 1.2726286184E-01 1.6714261244E-01 2.0799587368E-01 + 2.4955956467E-01 2.9156195917E-01 3.3372561675E-01 3.7577040467E-01 + 4.1741657655E-01 4.5838787269E-01 4.9841460675E-01 5.3723670307E-01 + 5.7460664940E-01 6.1029233045E-01 6.4407970863E-01 6.7577532014E-01 + 7.0520855610E-01 7.3223370080E-01 7.5673170173E-01 7.7861164871E-01 + 7.9781194283E-01 8.1430113911E-01 8.2807845033E-01 8.3917390343E-01 + 8.4764814358E-01 8.5359188497E-01 8.5712501152E-01 8.5839533453E-01 + 8.5757701827E-01 8.5486868850E-01 8.5049124231E-01 8.4468538151E-01 + 8.3770889499E-01 8.2983371831E-01 8.2134280189E-01 8.1252682130E-01 + 8.0368076536E-01 7.9510043929E-01 7.8707892166E-01 7.7990301447E-01 + 7.7384972632E-01 7.6918282851E-01 7.6614952340E-01 7.6497726365E-01 + 7.6587075937E-01 7.6900920862E-01 7.7454378449E-01 7.8259540945E-01 + 7.9325284472E-01 8.0657111917E-01 8.2257031892E-01 8.4123475464E-01 + 8.6251251995E-01 8.8631544992E-01 9.1251948440E-01 9.4096543656E-01 + 9.7146016252E-01 1.0037781237E+00 1.0376633289E+00 1.0728316389E+00 + 1.1089734134E+00 1.1457564731E+00 1.1828293509E+00 1.2198247977E+00 + 1.2563635099E+00 1.2920580388E+00 1.3265168430E+00 1.3593484421E+00 + 1.3901656271E+00 1.4185896850E+00 1.4442545903E+00 1.4668111209E+00 + 1.4859308533E+00 1.5013099920E+00 1.5126729933E+00 1.5197759427E+00 + 1.5224096465E+00 1.5204024039E+00 1.5136224281E+00 1.5019798852E+00 + 1.4854285288E+00 1.4639669081E+00 1.4376391332E+00 1.4065351864E+00 + 1.3707907710E+00 1.3305866966E+00 1.2861478015E+00 1.2377414212E+00 + 1.1856754138E+00 1.1302957583E+00 1.0719837483E+00 1.0111528058E+00 + 9.4824494374E-01 8.8372691198E-01 8.1808606172E-01 7.5182596926E-01 + 6.8546186072E-01 6.1951588247E-01 5.5451226348E-01 4.9097241725E-01 + 4.2941002453E-01 3.7032621727E-01 3.1420462421E-01 2.6150705376E-01 + 2.1267590238E-01 1.6812240177E-01 1.2821091054E-01 9.3266495918E-02 + 6.3570970904E-02 3.9360255898E-02 2.0830072754E-02 8.0393670083E-03 + 1.4257547632E-03 -1.8554053746E-04 3.4860632221E-05 -9.7545067432E-07 + -3.5630118368E-06 -1.1274443285E-09 0.0000000000E+00 0.0000000000E+00 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + 3.5193286046E-09 2.5161059713E-04 9.9865782509E-04 2.2179236133E-03 + 3.8711612718E-03 5.9057637564E-03 8.2556855876E-03 1.0842604992E-02 + 1.3577309319E-02 1.6361283499E-02 1.9088478290E-02 2.1647232397E-02 + 2.3922320168E-02 2.5797094682E-02 2.7155694465E-02 2.7885281014E-02 + 2.7878273657E-02 2.7034548110E-02 2.5263565377E-02 2.2486398422E-02 + 1.8637625224E-02 1.3667058513E-02 7.5412845407E-03 2.4498572186E-04 + -8.2179752036E-03 -1.7823728664E-02 -2.8527845163E-02 -4.0265067674E-02 + -5.2949337744E-02 -6.6474119506E-02 -8.0713021768E-02 -9.5520714160E-02 + -1.1073412932E-01 -1.2617393900E-01 -1.4164628824E-01 -1.5694476792E-01 + -1.7185260265E-01 -1.8614502783E-01 -1.9959182684E-01 -2.1195999682E-01 + -2.2301650957E-01 -2.3253113236E-01 -2.4027927243E-01 -2.4604480801E-01 + -2.4962286892E-01 -2.5082252964E-01 -2.4946937891E-01 -2.4540793091E-01 + -2.3850384516E-01 -2.2864592401E-01 -2.1574785968E-01 -1.9974970561E-01 + -1.8061905012E-01 -1.5835187441E-01 -1.3297308051E-01 -1.0453667930E-01 + -7.3125632725E-02 -3.8851349012E-02 -1.8528340942E-03 3.7704493123E-02 + 7.9630309537E-02 1.2371120430E-01 1.6971278249E-01 2.1738203169E-01 + 2.6644992350E-01 3.1663421900E-01 3.6764244405E-01 4.1917499808E-01 + 4.7092835804E-01 5.2259833755E-01 5.7388336057E-01 6.2448770811E-01 + 6.7412469702E-01 7.2251975000E-01 7.6941331771E-01 8.1456361487E-01 + 8.5774913505E-01 8.9877091100E-01 9.3745449078E-01 9.7365160323E-01 + 1.0072414904E+00 1.0381318884E+00 1.0662596433E+00 1.0915909521E+00 + 1.1141212252E+00 1.1338745703E+00 1.1509029037E+00 1.1652846981E+00 + 1.1771233844E+00 1.1865454244E+00 1.1936980806E+00 1.1987469108E+00 + 1.2018730195E+00 1.2032701009E+00 1.2031413141E+00 1.2016960283E+00 + 1.1991464838E+00 1.1957044116E+00 1.1915776573E+00 1.1869668541E+00 + 1.1820621917E+00 1.1770403242E+00 1.1720614597E+00 1.1672666738E+00 + 1.1627754839E+00 1.1586837207E+00 1.1550617273E+00 1.1519529153E+00 + 1.1493726987E+00 1.1473078269E+00 1.1457161278E+00 1.1445266717E+00 + 1.1436403560E+00 1.1429309109E+00 1.1422463162E+00 1.1414106168E+00 + 1.1402261165E+00 1.1384759284E+00 1.1359268505E+00 1.1323325354E+00 + 1.1274369145E+00 1.1209778369E+00 1.1126908779E+00 1.1023132686E+00 + 1.0895878999E+00 1.0742673465E+00 1.0561178618E+00 1.0349232901E+00 + 1.0104888438E+00 9.8264469650E-01 9.5124934093E-01 9.1619266647E-01 + 8.7739871113E-01 8.3482804831E-01 7.8847977166E-01 7.3839304614E-01 + 6.8464819849E-01 6.2736732547E-01 5.6671440392E-01 5.0289489280E-01 + 4.3615482326E-01 3.6677937910E-01 2.9509097620E-01 2.2144685584E-01 + 1.4623621260E-01 6.9876883903E-02 -7.1883666383E-03 -8.4495934135E-02 + -1.6156578315E-01 -2.3790613716E-01 -3.1301839576E-01 -3.8640222563E-01 + -4.5756076796E-01 -5.2600590373E-01 -5.9126351631E-01 -6.5287869052E-01 + -7.1042078714E-01 -7.6348833302E-01 -8.1171366800E-01 -8.5476729243E-01 + -8.9236186195E-01 -9.2425577953E-01 -9.5025633930E-01 -9.7022238121E-01 + -9.8406642090E-01 -9.9175622500E-01 -9.9331580799E-01 -9.8882583353E-01 + -9.7842340943E-01 -9.6230127274E-01 -9.4070636810E-01 -9.1393782946E-01 + -8.8234438245E-01 -8.4632119100E-01 -8.0630617859E-01 -7.6277586054E-01 + -7.1624072971E-01 -6.6724024301E-01 -6.1633746118E-01 -5.6411339847E-01 + -5.1116114232E-01 -4.5807980612E-01 -4.0546837667E-01 -3.5391955573E-01 + -3.0401352994E-01 -2.5631187746E-01 -2.1135381625E-01 -1.6965049777E-01 + -1.3167245014E-01 -9.7849074819E-02 -6.8564234568E-02 -4.4152243892E-02 + -2.4902826619E-02 -1.0976118320E-02 -2.7485814385E-03 2.6288052841E-05 + 4.8351689568E-05 -3.9051620751E-05 9.6192017534E-06 7.8074588598E-10 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + -2.8669378260E-09 -4.6742789284E-04 -1.8622047224E-03 -4.1619227304E-03 + -7.3296100088E-03 -1.1314286431E-02 -1.6051730833E-02 -2.1465448496E-02 + -2.7467825137E-02 -3.3961450902E-02 -4.0840595444E-02 -4.7992812950E-02 + -5.5300654086E-02 -6.2643460266E-02 -6.9899214383E-02 -7.6946421253E-02 + -8.3665990554E-02 -8.9943094821E-02 -9.5668975383E-02 -1.0074266971E-01 + -1.0507263458E-01 -1.0857824100E-01 -1.1119111822E-01 -1.1285632648E-01 + -1.1353334027E-01 -1.1319682643E-01 -1.1183720436E-01 -1.0946097838E-01 + -1.0609083561E-01 -1.0176550589E-01 -9.6539383552E-02 -9.0481914240E-02 + -8.3676753217E-02 -7.6220704930E-02 -6.8222456616E-02 -5.9801121761E-02 + -5.1084611985E-02 -4.2207858442E-02 -3.3310906091E-02 -2.4536906166E-02 + -1.6030033765E-02 -7.9333587749E-03 -3.8669924287E-04 6.4755132111E-03 + 1.2526326215E-02 1.7648288280E-02 2.1735370520E-02 2.4694760818E-02 + 2.6448504278E-02 2.6934965608E-02 2.6110091302E-02 2.3948451939E-02 + 2.0444047716E-02 1.5610863355E-02 9.4831617548E-03 2.1155091740E-03 + -6.4174717519E-03 -1.6021621233E-02 -2.6584030227E-02 -3.7974089838E-02 + -5.0044791463E-02 -6.2634263498E-02 -7.5567527115E-02 -8.8658450560E-02 + -1.0171187854E-01 -1.1452591078E-01 -1.2689430149E-01 -1.3860894976E-01 + -1.4946244921E-01 -1.5925066432E-01 -1.6777529997E-01 -1.7484643071E-01 + -1.8028495633E-01 -1.8392495085E-01 -1.8561587344E-01 -1.8522461086E-01 + -1.8263732326E-01 -1.7776106726E-01 -1.7052517296E-01 -1.6088235453E-01 + -1.4880953725E-01 -1.3430838741E-01 -1.1740553519E-01 -9.8152484688E-02 + -7.6625208997E-02 -5.2923432534E-02 -2.7169606834E-02 4.9240997664E-04 + 2.9898955838E-02 6.0868431567E-02 9.3203410245E-02 1.2669296426E-01 + 1.6111518204E-01 1.9623984368E-01 2.3183122258E-01 2.6765097784E-01 + 3.0346110104E-01 3.3902687978E-01 3.7411983972E-01 4.0852062684E-01 + 4.4202179212E-01 4.7443044144E-01 5.0557071513E-01 5.3528606330E-01 + 5.6344128538E-01 5.8992430501E-01 6.1464765455E-01 6.3754964689E-01 + 6.5859521600E-01 6.7777641190E-01 6.9511253968E-01 7.1064993699E-01 + 7.2446138870E-01 7.3664518235E-01 7.4732381229E-01 7.5664234530E-01 + 7.6476646483E-01 7.7188021515E-01 7.7818347102E-01 7.8388916210E-01 + 7.8922028478E-01 7.9440673729E-01 7.9968201650E-01 8.0527981713E-01 + 8.1143057571E-01 8.1835800290E-01 8.2627564844E-01 8.3538354316E-01 + 8.4586496198E-01 8.5788335098E-01 8.7157945987E-01 8.8706871956E-01 + 9.0443890149E-01 9.2374809266E-01 9.4502301671E-01 9.6825772749E-01 + 9.9341269734E-01 1.0204143176E+00 1.0491548243E+00 1.0794926565E+00 + 1.1112532497E+00 1.1442302623E+00 1.1781872258E+00 1.2128596064E+00 + 1.2479572593E+00 1.2831672517E+00 1.3181570269E+00 1.3525778766E+00 + 1.3860686850E+00 1.4182599027E+00 1.4487777096E+00 1.4772483169E+00 + 1.5033023628E+00 1.5265793481E+00 1.5467320643E+00 1.5634309579E+00 + 1.5763683831E+00 1.5852626887E+00 1.5898620923E+00 1.5899482909E+00 + 1.5853397667E+00 1.5758947418E+00 1.5615137467E+00 1.5421417668E+00 + 1.5177699363E+00 1.4884367567E+00 1.4542288178E+00 1.4152810091E+00 + 1.3717762118E+00 1.3239444691E+00 1.2720616386E+00 1.2164475352E+00 + 1.1574635808E+00 1.0955099800E+00 1.0310224495E+00 9.6446853239E-01 + 8.9634353301E-01 8.2716611486E-01 7.5747360505E-01 6.8781705501E-01 + 6.1875610852E-01 5.5085373143E-01 4.8467085132E-01 4.2076102488E-01 + 3.5966487614E-01 3.0190461595E-01 2.4798167460E-01 1.9837131518E-01 + 1.5350792133E-01 1.1378786021E-01 7.9565667614E-02 5.1150583205E-02 + 2.8813302745E-02 1.2688635707E-02 3.1758001850E-03 -3.0443907678E-05 + -5.5848044728E-05 4.5109164742E-05 -1.1117165430E-05 -6.9328679809E-10 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + -4.4867631138E-10 1.0682717873E-05 8.5470324238E-05 2.8850934865E-04 + 6.8402372457E-04 1.3363389128E-03 2.3098888563E-03 3.6692005804E-03 + 5.4788517011E-03 7.8033966509E-03 1.0707258067E-02 1.4254580503E-02 + 1.8509044394E-02 2.3533639064E-02 2.9390394402E-02 3.6140071763E-02 + 4.3841815528E-02 5.2552767682E-02 6.2327648630E-02 7.3218308314E-02 + 8.5273252483E-02 9.8537149706E-02 1.1305032533E-01 1.2884824919E-01 + 1.4596102421E-01 1.6441288364E-01 1.8422170449E-01 2.0539854523E-01 + 2.2794721556E-01 2.5186388599E-01 2.7713674456E-01 3.0374570787E-01 + 3.3166219286E-01 3.6084895510E-01 3.9125999887E-01 4.2284056315E-01 + 4.5552718692E-01 4.8924785604E-01 5.2392223316E-01 5.5946197053E-01 + 5.9577110508E-01 6.3274653352E-01 6.7027856427E-01 7.0825154196E-01 + 7.4654453914E-01 7.8503210876E-01 8.2358509031E-01 8.6207146139E-01 + 9.0035722579E-01 9.3830732890E-01 9.7578659021E-01 1.0126606428E+00 + 1.0487968691E+00 1.0840653227E+00 1.1183396255E+00 1.1514978293E+00 + 1.1834232336E+00 1.2140051483E+00 1.2431395939E+00 1.2707299307E+00 + 1.2966874102E+00 1.3209316427E+00 1.3433909757E+00 1.3640027804E+00 + 1.3827136422E+00 1.3994794560E+00 1.4142654248E+00 1.4270459633E+00 + 1.4378045100E+00 1.4465332508E+00 1.4532327598E+00 1.4579115639E+00 + 1.4605856373E+00 1.4612778360E+00 1.4600172803E+00 1.4568386952E+00 + 1.4517817196E+00 1.4448901949E+00 1.4362114444E+00 1.4257955533E+00 + 1.4136946629E+00 1.3999622870E+00 1.3846526635E+00 1.3678201484E+00 + 1.3495186642E+00 1.3298012083E+00 1.3087194309E+00 1.2863232864E+00 + 1.2626607652E+00 1.2377777081E+00 1.2117177066E+00 1.1845220892E+00 + 1.1562299933E+00 1.1268785211E+00 1.0965029762E+00 1.0651371749E+00 + 1.0328138275E+00 9.9956498182E-01 9.6542252032E-01 9.3041870129E-01 + 8.9458673417E-01 8.5796137756E-01 8.2057954854E-01 7.8248093105E-01 + 7.4370857138E-01 7.0430944819E-01 6.6433500526E-01 6.2384163504E-01 + 5.8289110188E-01 5.4155089439E-01 4.9989449740E-01 4.5800157493E-01 + 4.1595805682E-01 3.7385612295E-01 3.3179408057E-01 2.8987613157E-01 + 2.4821202830E-01 2.0691661820E-01 1.6610927907E-01 1.2591324865E-01 + 8.6454853667E-02 4.7862645426E-02 1.0266450173E-02 -2.6203655692E-02 + -6.1418434373E-02 -9.5250626935E-02 -1.2757613152E-01 -1.5827520510E-01 + -1.8723367375E-01 -2.1434413569E-01 -2.3950714133E-01 -2.6263233434E-01 + -2.8363953785E-01 -3.0245977042E-01 -3.1903617690E-01 -3.3332486011E-01 + -3.4529560030E-01 -3.5493245057E-01 -3.6223419774E-01 -3.6721467975E-01 + -3.6990295251E-01 -3.7034330047E-01 -3.6859508778E-01 -3.6473244821E-01 + -3.5884381454E-01 -3.5103128986E-01 -3.4140986554E-01 -3.3010649239E-01 + -3.1725901361E-01 -3.0301497010E-01 -2.8753029019E-01 -2.7096787772E-01 + -2.5349611366E-01 -2.3528728788E-01 -2.1651597861E-01 -1.9735739800E-01 + -1.7798572299E-01 -1.5857243068E-01 -1.3928465798E-01 -1.2028360474E-01 + -1.0172299963E-01 -8.3747646917E-02 -6.6492071829E-02 -5.0079280892E-02 + -3.4619652236E-02 -2.0209969496E-02 -6.9326110707E-03 5.1450953026E-03 + 1.5971344781E-02 2.5510148683E-02 3.3741445270E-02 4.0661026804E-02 + 4.6280283954E-02 5.0625770946E-02 5.3738597130E-02 5.5673652858E-02 + 5.6498679684E-02 5.6293196914E-02 5.5147298400E-02 5.3160335119E-02 + 5.0439500671E-02 4.7098337919E-02 4.3255187751E-02 3.9031575642E-02 + 3.4550617926E-02 2.9935070975E-02 2.5303638086E-02 2.0770306974E-02 + 1.6449762633E-02 1.2449531227E-02 8.8686935028E-03 5.7967296302E-03 + 3.3137135872E-03 1.4781230518E-03 3.7424532395E-04 -3.6454361141E-06 + -6.6837136205E-06 5.3585663219E-06 -1.3078466278E-06 -8.7435710138E-12 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + 9.6002679786E-10 -2.2508882541E-06 -1.8106419803E-05 -6.1664892908E-05 + -1.4799837343E-04 -2.9360597307E-04 -5.1682749760E-04 -8.3820540366E-04 + -1.2807839629E-03 -1.8703357022E-03 -2.6355065486E-03 -3.6078726356E-03 + -4.8219033998E-03 -6.3148273770E-03 -8.1263989819E-03 -1.0298566474E-02 + -1.2875043258E-02 -1.5900786591E-02 -1.9421389669E-02 -2.3482394860E-02 + -2.8128537549E-02 -3.3402931636E-02 -3.9346209115E-02 -4.5995627350E-02 + -5.3384158682E-02 -6.1539577747E-02 -7.0483562376E-02 -8.0230824233E-02 + -9.0788285305E-02 -1.0215431608E-01 -1.1431805072E-01 -1.2725879362E-01 + -1.4094553089E-01 -1.5533655868E-01 -1.7037923909E-01 -1.8600989226E-01 + -2.0215383182E-01 -2.1872554841E-01 -2.3562904397E-01 -2.5275831738E-01 + -2.6999799940E-01 -2.8722413300E-01 -3.0430509235E-01 -3.2110263203E-01 + -3.3747305542E-01 -3.5326848958E-01 -3.6833825190E-01 -3.8253029207E-01 + -3.9569269174E-01 -4.0767520278E-01 -4.1833080435E-01 -4.2751725812E-01 + -4.3509864088E-01 -4.4094683358E-01 -4.4494294617E-01 -4.4697865829E-01 + -4.4695745649E-01 -4.4479575028E-01 -4.4042385037E-01 -4.3378679443E-01 + -4.2484500771E-01 -4.1357478780E-01 -3.9996860564E-01 -3.8403521685E-01 + -3.6579958067E-01 -3.4530258604E-01 -3.2260058744E-01 -2.9776475565E-01 + -2.7088025148E-01 -2.4204523291E-01 -2.1136970877E-01 -1.7897425434E-01 + -1.4498860632E-01 -1.0955015666E-01 -7.2802366073E-02 -3.4893119773E-02 + 4.0269513773E-03 4.3806160241E-02 8.4293438972E-02 1.2533997649E-01 + 1.6680079393E-01 2.0853623498E-01 2.5041334900E-01 2.9230714636E-01 + 3.3410170721E-01 3.7569112684E-01 4.1698028330E-01 4.5788541539E-01 + 4.9833450201E-01 5.3826743675E-01 5.7763599465E-01 6.1640359133E-01 + 6.5454483781E-01 6.9204489737E-01 7.2889865425E-01 7.6510970668E-01 + 8.0068919967E-01 8.3565451584E-01 8.7002784466E-01 9.0383465289E-01 + 9.3710208072E-01 9.6985728960E-01 1.0021257889E+00 1.0339297692E+00 + 1.0652864705E+00 1.0962066134E+00 1.1266929209E+00 1.1567387570E+00 + 1.1863269080E+00 1.2154285305E+00 1.2440022855E+00 1.2719936808E+00 + 1.2993346344E+00 1.3259432756E+00 1.3517239904E+00 1.3765677202E+00 + 1.4003525147E+00 1.4229443392E+00 1.4441981306E+00 1.4639590941E+00 + 1.4820642274E+00 1.4983440584E+00 1.5126245738E+00 1.5247293190E+00 + 1.5344816425E+00 1.5417070559E+00 1.5462356800E+00 1.5479047444E+00 + 1.5465611062E+00 1.5420637534E+00 1.5342862573E+00 1.5231191388E+00 + 1.5084721126E+00 1.4902761763E+00 1.4684855111E+00 1.4430791626E+00 + 1.4140624753E+00 1.3814682520E+00 1.3453576189E+00 1.3058205745E+00 + 1.2629762090E+00 1.2169725825E+00 1.1679862551E+00 1.1162214668E+00 + 1.0619089694E+00 1.0053045179E+00 9.4668703156E-01 8.8635644211E-01 + 8.2463124822E-01 7.6184580143E-01 6.9834735141E-01 6.3449288265E-01 + 5.7064577731E-01 5.0717234223E-01 4.4443823994E-01 3.8280486548E-01 + 3.2262571219E-01 2.6424277007E-01 2.0798300074E-01 1.5415493231E-01 + 1.0304541688E-01 5.4916591269E-02 1.0003080061E-02 -3.1490523032E-02 + -6.9391862356E-02 -1.0356268660E-01 -1.3390034867E-01 -1.6033891807E-01 + -1.8284988924E-01 -2.0144247441E-01 -2.1616347434E-01 -2.2709672601E-01 + -2.3436213093E-01 -2.3811427372E-01 -2.3854064530E-01 -2.3585949016E-01 + -2.3031730227E-01 -2.2218599818E-01 -2.1175980074E-01 -1.9935186995E-01 + -1.8529072155E-01 -1.6991647596E-01 -1.5357697855E-01 -1.3662385027E-01 + -1.1940828790E-01 -1.0227613467E-01 -8.5561920853E-02 -6.9586076312E-02 + -5.4656545366E-02 -4.1059344874E-02 -2.9055478663E-02 -1.8878152281E-02 + -1.0734117116E-02 -4.7654269829E-03 -1.2013010685E-03 1.1643234152E-05 + 2.1330713567E-05 -1.7150556857E-05 4.2011262729E-06 8.5396503937E-11 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + + + 7.8041854637E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 6.4458670727E-01 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 4.0505645397E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 7.5708430958E-01 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + -5.8319571503E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 -9.5149454450E-01 + + + + + 6.4779778763E-14 6.5801358592E-04 1.3184047265E-03 1.9835484482E-03 + 2.6558147254E-03 3.3375659658E-03 4.0311545092E-03 4.7389201444E-03 + 5.4631876478E-03 6.2062643492E-03 6.9704377275E-03 7.7579730415E-03 + 8.5711109987E-03 9.4120654665E-03 1.0283021229E-02 1.1186131790E-02 + 1.2123517237E-02 1.3097262143E-02 1.4109413546E-02 1.5161978973E-02 + 1.6256924533E-02 1.7396173073E-02 1.8581602397E-02 1.9815043559E-02 + 2.1098279217E-02 2.2433042060E-02 2.3821013305E-02 2.5263821265E-02 + 2.6763039989E-02 2.8320187970E-02 2.9936726926E-02 3.1614060655E-02 + 3.3353533956E-02 3.5156431622E-02 3.7023977501E-02 3.8957333627E-02 + 4.0957599418E-02 4.3025810939E-02 4.5162940230E-02 4.7369894698E-02 + 4.9647516575E-02 5.1996582432E-02 5.4417802754E-02 5.6911821576E-02 + 5.9479216174E-02 6.2120496812E-02 6.4836106547E-02 6.7626421080E-02 + 7.0491748665E-02 7.3432330070E-02 7.6448338584E-02 7.9539880076E-02 + 8.2706993101E-02 8.5949649056E-02 8.9267752383E-02 9.2661140813E-02 + 9.6129585669E-02 9.9672792202E-02 1.0329039998E-01 1.0698198333E-01 + 1.1074705180E-01 1.1458505071E-01 1.1849536171E-01 1.2247730341E-01 + 1.2653013205E-01 1.3065304219E-01 1.3484516752E-01 1.3910558166E-01 + 1.4343329900E-01 1.4782727565E-01 1.5228641040E-01 1.5680954571E-01 + 1.6139546883E-01 1.6604291287E-01 1.7075055803E-01 1.7551703278E-01 + 1.8034091519E-01 1.8522073422E-01 1.9015497114E-01 1.9514206098E-01 + 2.0018039400E-01 2.0526831725E-01 2.1040413615E-01 2.1558611619E-01 + 2.2081248457E-01 2.2608143196E-01 2.3139111432E-01 2.3673965469E-01 + 2.4212514509E-01 2.4754564845E-01 2.5299920051E-01 2.5848381187E-01 + 2.6399746995E-01 2.6953814108E-01 2.7510377253E-01 2.8069229461E-01 + 2.8630162281E-01 2.9192965987E-01 2.9757429792E-01 3.0323342064E-01 + 3.0890490535E-01 3.1458662519E-01 3.2027645119E-01 3.2597225440E-01 + 3.3167190800E-01 3.3737328931E-01 3.4307428191E-01 3.4877277758E-01 + 3.5446667831E-01 3.6015389824E-01 3.6583236553E-01 3.7150002422E-01 + 3.7715483603E-01 3.8279478205E-01 3.8841786450E-01 3.9402210829E-01 + 3.9960556256E-01 4.0516630223E-01 4.1070242934E-01 4.1621207444E-01 + 4.2169339788E-01 4.2714459092E-01 4.3256387693E-01 4.3794951242E-01 + 4.4329978794E-01 4.4861302904E-01 4.5388759705E-01 4.5912188980E-01 + 4.6431434228E-01 4.6946342722E-01 4.7456765560E-01 4.7962557710E-01 + 4.8463578041E-01 4.8959689359E-01 4.9450758426E-01 4.9936655978E-01 + 5.0417256739E-01 5.0892439420E-01 5.1362086728E-01 5.1826085352E-01 + 5.2284325964E-01 5.2736703198E-01 5.3183115636E-01 5.3623465791E-01 + 5.4057660079E-01 5.4485608797E-01 5.4907226096E-01 5.5322429947E-01 + 5.5731142119E-01 5.6133288139E-01 5.6528797264E-01 5.6917602451E-01 + 5.7299640321E-01 5.7674851128E-01 5.8043178731E-01 5.8404570561E-01 + 5.8758977593E-01 5.9106354320E-01 5.9446658725E-01 5.9779852259E-01 + 6.0105899821E-01 6.0424769732E-01 6.0736433725E-01 6.1040866922E-01 + 6.1338047829E-01 6.1627958316E-01 6.1910583615E-01 6.2185912311E-01 + 6.2453936338E-01 6.2714650974E-01 6.2968054845E-01 6.3214149919E-01 + 6.3452941515E-01 6.3684438306E-01 6.3908652319E-01 6.4125598945E-01 + 6.4335296948E-01 6.4537768465E-01 6.4733039022E-01 6.4921137534E-01 + 6.5102096318E-01 6.5275951097E-01 6.5442741007E-01 6.5602508603E-01 + 6.5755299863E-01 6.5901164194E-01 6.6040154430E-01 6.6172326839E-01 + 6.6297741111E-01 6.6416460358E-01 6.6528551105E-01 6.6634083280E-01 + 6.6733130207E-01 6.6825768571E-01 6.6912077817E-01 6.6992138630E-01 + 6.7066031390E-01 6.7133836079E-01 6.7195632618E-01 6.7251500705E-01 + 6.7301519740E-01 6.7345768854E-01 6.7384326863E-01 6.7417272259E-01 + 6.7444683186E-01 6.7466637425E-01 6.7483212377E-01 6.7494485049E-01 + 6.7500532037E-01 6.7501429517E-01 6.7497253227E-01 6.7488078459E-01 + 6.7473980046E-01 6.7455032354E-01 6.7431309268E-01 6.7402884186E-01 + 6.7369830009E-01 6.7332219133E-01 6.7290123441E-01 6.7243614295E-01 + 6.7192762531E-01 6.7137638452E-01 6.7078311818E-01 6.7014851849E-01 + 6.6947327209E-01 6.6875806011E-01 6.6800355803E-01 6.6721043573E-01 + 6.6637935738E-01 6.6551098142E-01 6.6460596057E-01 6.6366494172E-01 + 6.6268856597E-01 6.6167746857E-01 6.6063227893E-01 6.5955362053E-01 + 6.5844211100E-01 6.5729836203E-01 6.5612297937E-01 6.5491656285E-01 + 6.5367970635E-01 6.5241299778E-01 6.5111701911E-01 6.4979234633E-01 + 6.4843954951E-01 6.4705919271E-01 6.4565183407E-01 6.4421802578E-01 + 6.4275831407E-01 6.4127323925E-01 6.3976333572E-01 6.3822913195E-01 + 6.3667115053E-01 6.3508990816E-01 6.3348591570E-01 6.3185967814E-01 + 6.3021169466E-01 6.2854245863E-01 6.2685245766E-01 6.2514217357E-01 + 6.2341208247E-01 6.2166265476E-01 6.1989435516E-01 6.1810764273E-01 + 6.1630297090E-01 6.1448078754E-01 6.1264153493E-01 6.1078564981E-01 + 6.0891356344E-01 6.0702570160E-01 6.0512248466E-01 6.0320432757E-01 + 6.0127163990E-01 5.9932482594E-01 5.9736428465E-01 5.9539040975E-01 + 5.9340358974E-01 5.9140420793E-01 5.8939264250E-01 5.8736926653E-01 + 5.8533444802E-01 5.8328854997E-01 5.8123193036E-01 5.7916494224E-01 + 5.7708793378E-01 5.7500124825E-01 5.7290522410E-01 5.7080019502E-01 + 5.6868648993E-01 5.6656443307E-01 5.6443434400E-01 5.6229653768E-01 + 5.6015132448E-01 5.5799901025E-01 5.5583989632E-01 5.5367427958E-01 + 5.5150245252E-01 5.4932470326E-01 5.4714131556E-01 5.4495256894E-01 + 5.4275873865E-01 5.4056009573E-01 5.3835690707E-01 5.3614943545E-01 + 5.3393793954E-01 5.3172267401E-01 5.2950388950E-01 5.2728183271E-01 + 5.2505674642E-01 5.2282886954E-01 5.2059843714E-01 5.1836568050E-01 + 5.1613082714E-01 5.1389410086E-01 5.1165572180E-01 5.0941590646E-01 + 5.0717486774E-01 5.0493281498E-01 5.0268995401E-01 5.0044648717E-01 + 4.9820261338E-01 4.9595852812E-01 4.9371442355E-01 4.9147048847E-01 + 4.8922690840E-01 4.8698386560E-01 4.8474153914E-01 4.8250010488E-01 + 4.8025973556E-01 4.7802060080E-01 4.7578286715E-01 4.7354669814E-01 + 4.7131225429E-01 4.6907969316E-01 4.6684916937E-01 4.6462083467E-01 + 4.6239483793E-01 4.6017132521E-01 4.5795043975E-01 4.5573232208E-01 + 4.5351710996E-01 4.5130493849E-01 4.4909594009E-01 4.4689024457E-01 + 4.4468797914E-01 4.4248926845E-01 4.4029423462E-01 4.3810299728E-01 + 4.3591567359E-01 4.3373237826E-01 4.3155322362E-01 4.2937831960E-01 + 4.2720777381E-01 4.2504169155E-01 4.2288017580E-01 4.2072332732E-01 + 4.1857124464E-01 4.1642402408E-01 4.1428175981E-01 4.1214454384E-01 + 4.1001246610E-01 4.0788561441E-01 4.0576407454E-01 4.0364793025E-01 + 4.0153726329E-01 3.9943215343E-01 3.9733267850E-01 3.9523891441E-01 + 3.9315093519E-01 3.9106881298E-01 3.8899261809E-01 3.8692241901E-01 + 3.8485828247E-01 3.8280027338E-01 3.8074845495E-01 3.7870288866E-01 + 3.7666363431E-01 3.7463075003E-01 3.7260429229E-01 3.7058431595E-01 + 3.6857087430E-01 3.6656401901E-01 3.6456380025E-01 3.6257026662E-01 + 3.6058346524E-01 3.5860344176E-01 3.5663024033E-01 3.5466390371E-01 + 3.5270447321E-01 3.5075198876E-01 3.4880648892E-01 3.4686801089E-01 + 3.4493659054E-01 3.4301226243E-01 3.4109505985E-01 3.3918501478E-01 + 3.3728215799E-01 3.3538651899E-01 3.3349812611E-01 3.3161700646E-01 + 3.2974318599E-01 3.2787668951E-01 3.2601754068E-01 3.2416576205E-01 + 3.2232137507E-01 3.2048440011E-01 3.1865485650E-01 3.1683276250E-01 + 3.1501813535E-01 3.1321099130E-01 3.1141134558E-01 3.0961921248E-01 + 3.0783460530E-01 3.0605753643E-01 3.0428801731E-01 3.0252605849E-01 + 3.0077166961E-01 2.9902485946E-01 2.9728563594E-01 2.9555400613E-01 + 2.9382997627E-01 2.9211355178E-01 2.9040473729E-01 2.8870353664E-01 + 2.8700995290E-01 2.8532398838E-01 2.8364564467E-01 2.8197492259E-01 + 2.8031182229E-01 2.7865634320E-01 2.7700848405E-01 2.7536824292E-01 + 2.7373561721E-01 2.7211060369E-01 2.7049319849E-01 2.6888339711E-01 + 2.6728119445E-01 2.6568658480E-01 2.6409956187E-01 2.6252011881E-01 + 2.6094824820E-01 2.5938394206E-01 2.5782719188E-01 2.5627798863E-01 + 2.5473632274E-01 2.5320218418E-01 2.5167556237E-01 2.5015644629E-01 + 2.4864482444E-01 2.4714068483E-01 2.4564401505E-01 2.4415480223E-01 + 2.4267303308E-01 2.4119869387E-01 2.3973177049E-01 2.3827224839E-01 + 2.3682011264E-01 2.3537534794E-01 2.3393793860E-01 2.3250786857E-01 + 2.3108512143E-01 2.2966968042E-01 2.2826152845E-01 2.2686064809E-01 + 2.2546702158E-01 2.2408063085E-01 2.2270145753E-01 2.2132948294E-01 + 2.1996468811E-01 2.1860705380E-01 2.1725656047E-01 2.1591318833E-01 + 2.1457691733E-01 2.1324772715E-01 2.1192559723E-01 2.1061050679E-01 + 2.0930243478E-01 2.0800135995E-01 2.0670726083E-01 2.0542011572E-01 + 2.0413990272E-01 2.0286659975E-01 2.0160018449E-01 2.0034063449E-01 + 1.9908792706E-01 1.9784203938E-01 1.9660294844E-01 1.9537063105E-01 + 1.9414506390E-01 1.9292622348E-01 1.9171408617E-01 1.9050862818E-01 + 1.8930982561E-01 1.8811765440E-01 1.8693209037E-01 1.8575310923E-01 + 1.8458068656E-01 1.8341479783E-01 1.8225541841E-01 1.8110252354E-01 + 1.7995608839E-01 1.7881608802E-01 1.7768249741E-01 1.7655529145E-01 + 1.7543444493E-01 1.7431993259E-01 1.7321172908E-01 1.7210980899E-01 + 1.7101414683E-01 1.6992471705E-01 1.6884149407E-01 1.6776445221E-01 + 1.6669356577E-01 1.6562880900E-01 1.6457015608E-01 1.6351758119E-01 + 1.6247105845E-01 1.6143056193E-01 1.6039606571E-01 1.5936754379E-01 + 1.5834497020E-01 1.5732831891E-01 1.5631756388E-01 1.5531267906E-01 + 1.5431363839E-01 1.5332041579E-01 1.5233298517E-01 1.5135132044E-01 + 1.5037539552E-01 1.4940518431E-01 1.4844066073E-01 1.4748179868E-01 + 1.4652857210E-01 1.4558095492E-01 1.4463892108E-01 1.4370244455E-01 + 1.4277149929E-01 1.4184605931E-01 1.4092609863E-01 1.4001159127E-01 + 1.3910251131E-01 1.3819883283E-01 1.3730052996E-01 1.3640757685E-01 + 1.3551994767E-01 1.3463761664E-01 1.3376055802E-01 1.3288874609E-01 + 1.3202215519E-01 1.3116075969E-01 1.3030453399E-01 1.2945345255E-01 + 1.2860748988E-01 1.2776662052E-01 1.2693081907E-01 1.2610006019E-01 + 1.2527431856E-01 1.2445356894E-01 1.2363778614E-01 1.2282694501E-01 + 1.2202102047E-01 1.2121998750E-01 1.2042382112E-01 1.1963249643E-01 + 1.1884598859E-01 1.1806427280E-01 1.1728732436E-01 1.1651511859E-01 + 1.1574763091E-01 1.1498483680E-01 1.1422671179E-01 1.1347323149E-01 + 1.1272437158E-01 1.1198010781E-01 1.1124041599E-01 1.1050527202E-01 + 1.0977465186E-01 1.0904853153E-01 1.0832688715E-01 1.0760969491E-01 + 1.0689693105E-01 1.0618857191E-01 1.0548459390E-01 1.0478497350E-01 + 1.0408968728E-01 1.0339871189E-01 1.0271202403E-01 1.0202960052E-01 + 1.0135141823E-01 1.0067745412E-01 1.0000768523E-01 9.9342088686E-02 + 9.8680641688E-02 9.8023321524E-02 9.7370105561E-02 9.6720971251E-02 + 9.6075896129E-02 9.5434857814E-02 9.4797834007E-02 9.4164802496E-02 + 9.3535741153E-02 9.2910627934E-02 9.2289440882E-02 9.1672158124E-02 + 9.1058757874E-02 9.0449218431E-02 8.9843518182E-02 8.9241635599E-02 + 8.8643549242E-02 8.8049237757E-02 8.7458679877E-02 8.6871854424E-02 + 8.6288740306E-02 8.5709316519E-02 8.5133562147E-02 8.4561456361E-02 + 8.3992978422E-02 8.3428107677E-02 8.2866823563E-02 8.2309105604E-02 + 8.1754933412E-02 8.1204286689E-02 8.0657145225E-02 8.0113488897E-02 + 7.9573297673E-02 7.9036551608E-02 7.8503230846E-02 7.7973315619E-02 + 7.7446786249E-02 7.6923623146E-02 7.6403806807E-02 7.5887317819E-02 + 7.5374136859E-02 7.4864244689E-02 7.4357622162E-02 7.3854250219E-02 + 7.3354109889E-02 7.2857182288E-02 7.2363448622E-02 7.1872890184E-02 + 7.1385488356E-02 7.0901224606E-02 7.0420080492E-02 6.9942037659E-02 + 6.9467077837E-02 6.8995182848E-02 6.8526334598E-02 6.8060515080E-02 + 6.7597706376E-02 6.7137890654E-02 6.6681050168E-02 6.6227167259E-02 + 6.5776224356E-02 6.5328203972E-02 6.4883088706E-02 6.4440861246E-02 + 6.4001504362E-02 6.3565000911E-02 6.3131333837E-02 6.2700486166E-02 + 6.2272441012E-02 6.1847181572E-02 6.1424691127E-02 6.1004953045E-02 + 6.0587950776E-02 6.0173667855E-02 5.9762087900E-02 5.9353194613E-02 + 5.8946971778E-02 5.8543403265E-02 5.8142473024E-02 5.7744165089E-02 + 5.7348463577E-02 5.6955352684E-02 5.6564816693E-02 5.6176839964E-02 + 5.5791406941E-02 5.5408502149E-02 5.5028110192E-02 5.4650215758E-02 + 5.4274803611E-02 5.3901858601E-02 5.3531365652E-02 5.3163309771E-02 + 5.2797676045E-02 5.2434449638E-02 5.2073615793E-02 5.1715159833E-02 + 5.1359067159E-02 5.1005323250E-02 5.0653913662E-02 5.0304824029E-02 + 4.9958040063E-02 4.9613547551E-02 4.9271332360E-02 4.8931380431E-02 + 4.8593677780E-02 4.8258210502E-02 4.7924964766E-02 4.7593926816E-02 + 4.7265082971E-02 4.6938419626E-02 4.6613923249E-02 4.6291580383E-02 + 4.5971377645E-02 4.5653301724E-02 4.5337339384E-02 4.5023477462E-02 + 4.4711702867E-02 4.4402002581E-02 4.4094363656E-02 4.3788773220E-02 + 4.3485218469E-02 4.3183686672E-02 4.2884165167E-02 4.2586641366E-02 + 4.2291102748E-02 4.1997536865E-02 4.1705931336E-02 4.1416273852E-02 + 4.1128552171E-02 4.0842754121E-02 4.0558867600E-02 4.0276880571E-02 + 3.9996781068E-02 3.9718557192E-02 3.9442197111E-02 3.9167689060E-02 + 3.8895021340E-02 3.8624182322E-02 3.8355160439E-02 3.8087944192E-02 + 3.7822522148E-02 3.7558882940E-02 3.7297015263E-02 3.7036907879E-02 + 3.6778549616E-02 3.6521929363E-02 3.6267036074E-02 3.6013858768E-02 + 3.5762386526E-02 3.5512608492E-02 3.5264513873E-02 3.5018091939E-02 + 3.4773332021E-02 3.4530223512E-02 3.4288755868E-02 3.4048918606E-02 + 3.3810701302E-02 3.3574093593E-02 3.3339085180E-02 3.3105665820E-02 + 3.2873825331E-02 3.2643553592E-02 3.2414840540E-02 3.2187676170E-02 + 3.1962050538E-02 3.1737953756E-02 3.1515375997E-02 3.1294307488E-02 + 3.1074738518E-02 3.0856659430E-02 3.0640060625E-02 3.0424932560E-02 + 3.0211265750E-02 2.9999050765E-02 2.9788278232E-02 2.9578938831E-02 + 2.9371023300E-02 2.9164522431E-02 2.8959427071E-02 2.8755728120E-02 + 2.8553416536E-02 2.8352483326E-02 2.8152919555E-02 2.7954716338E-02 + 2.7757864846E-02 2.7562356300E-02 2.7368181976E-02 2.7175333202E-02 + 2.6983801356E-02 2.6793577870E-02 2.6604654226E-02 2.6417021958E-02 + 2.6230672652E-02 2.6045597943E-02 2.5861789517E-02 2.5679239111E-02 + 2.5497938509E-02 2.5317879549E-02 2.5139054116E-02 2.4961454143E-02 + 2.4785071615E-02 2.4609898563E-02 2.4435927068E-02 2.4263149257E-02 + 2.4091557308E-02 2.3921143444E-02 2.3751899937E-02 2.3583819104E-02 + 2.3416893311E-02 2.3251114971E-02 2.3086476540E-02 2.2922970524E-02 + 2.2760589473E-02 2.2599325982E-02 2.2439172693E-02 2.2280122292E-02 + 2.2122167510E-02 2.1965301123E-02 2.1809515951E-02 2.1654804859E-02 + 2.1501160756E-02 2.1348576592E-02 2.1197045364E-02 2.1046560110E-02 + 2.0897113913E-02 2.0748699895E-02 2.0601311225E-02 2.0454941112E-02 + 2.0309582806E-02 2.0165229601E-02 2.0021874832E-02 1.9879511873E-02 + 1.9738134143E-02 1.9597735100E-02 1.9458308242E-02 1.9319847108E-02 + 1.9182345278E-02 1.9045796371E-02 1.8910194046E-02 1.8775532001E-02 + 1.8641803976E-02 1.8509003746E-02 1.8377125128E-02 1.8246161977E-02 + 1.8116108185E-02 1.7986957685E-02 1.7858704445E-02 1.7731342473E-02 + 1.7604865813E-02 1.7479268549E-02 1.7354544799E-02 1.7230688720E-02 + 1.7107694505E-02 1.6985556383E-02 1.6864268622E-02 1.6743825522E-02 + 1.6624221422E-02 1.6505450697E-02 1.6387507755E-02 1.6270387040E-02 + 1.6154083034E-02 1.6038590251E-02 1.5923903240E-02 1.5810016586E-02 + 1.5696924906E-02 1.5584622853E-02 1.5473105114E-02 1.5362366408E-02 + 1.5252401490E-02 1.5143205147E-02 1.5034772198E-02 1.4927097497E-02 + 1.4820175930E-02 1.4714002416E-02 1.4608571904E-02 1.4503879380E-02 + 1.4399919857E-02 1.4296688382E-02 1.4194180036E-02 1.4092389926E-02 + 1.3991313196E-02 1.3890945017E-02 1.3791280593E-02 1.3692315158E-02 + 1.3594043977E-02 1.3496462345E-02 1.3399565588E-02 1.3303349060E-02 + 1.3207808147E-02 1.3112938264E-02 1.3018734855E-02 1.2925193393E-02 + 1.2832309383E-02 1.2740078355E-02 1.2648495870E-02 1.2557557518E-02 + 1.2467258916E-02 1.2377595711E-02 1.2288563576E-02 1.2200158214E-02 + 1.2112375355E-02 1.2025210756E-02 1.1938660202E-02 1.1852719506E-02 + 1.1767384507E-02 1.1682651073E-02 1.1598515095E-02 1.1514972495E-02 + 1.1432019218E-02 1.1349651238E-02 1.1267864553E-02 1.1186655189E-02 + 1.1106019197E-02 1.1025952653E-02 1.0946451659E-02 1.0867512343E-02 + 1.0789130859E-02 1.0711303383E-02 1.0634026119E-02 1.0557295295E-02 + 1.0481107163E-02 1.0405458000E-02 1.0330344107E-02 1.0255761810E-02 + 1.0181707459E-02 1.0108177426E-02 1.0035168108E-02 9.9626759282E-03 + 9.8906973290E-03 9.8192287786E-03 9.7482667679E-03 9.6778078108E-03 + 9.6078484442E-03 9.5383852276E-03 9.4694147433E-03 9.4009335962E-03 + 9.3329384132E-03 9.2654258438E-03 9.1983925594E-03 9.1318352534E-03 + 9.0657506410E-03 9.0001354591E-03 8.9349864660E-03 8.8703004418E-03 + 8.8060741875E-03 8.7423045254E-03 8.6789882989E-03 8.6161223722E-03 + 8.5537036303E-03 8.4917289789E-03 8.4301953440E-03 8.3690996722E-03 + 8.3084389303E-03 8.2482101052E-03 8.1884102039E-03 8.1290362532E-03 + 8.0700852996E-03 8.0115544093E-03 7.9534406682E-03 7.8957411813E-03 + 7.8384530730E-03 7.7815734868E-03 7.7250995855E-03 7.6690285504E-03 + 7.6133575819E-03 7.5580838990E-03 7.5032047391E-03 7.4487173584E-03 + 7.3946190312E-03 7.3409070499E-03 7.2875787252E-03 7.2346313859E-03 + 7.1820623783E-03 7.1298690669E-03 7.0780488334E-03 7.0265990775E-03 + 6.9755172160E-03 6.9248006831E-03 6.8744469304E-03 6.8244534262E-03 + 6.7748176563E-03 6.7255371231E-03 6.6766093456E-03 6.6280318600E-03 + 6.5798022186E-03 6.5319179904E-03 6.4843767606E-03 6.4371761309E-03 + 6.3903137189E-03 6.3437871584E-03 6.2975940991E-03 6.2517322067E-03 + 6.2061991624E-03 6.1609926631E-03 6.1161104215E-03 6.0715501655E-03 + 6.0273096383E-03 5.9833865986E-03 5.9397788201E-03 5.8964840916E-03 + 5.8535002169E-03 5.8108250145E-03 5.7684563179E-03 5.7263919751E-03 + 5.6846298488E-03 5.6431678162E-03 5.6020037688E-03 5.5611356125E-03 + 5.5205612673E-03 5.4802786675E-03 5.4402857612E-03 5.4005805107E-03 + 5.3611608919E-03 5.3220248946E-03 5.2831705224E-03 5.2445957922E-03 + 5.2062987347E-03 5.1682773936E-03 5.1305298265E-03 5.0930541037E-03 + 5.0558483090E-03 5.0189105390E-03 4.9822389036E-03 4.9458315254E-03 + 4.9096865397E-03 4.8738020949E-03 4.8381763517E-03 4.8028074835E-03 + 4.7676936762E-03 4.7328331282E-03 4.6982240500E-03 4.6638646645E-03 + 4.6297532068E-03 4.5958879239E-03 4.5622670751E-03 4.5288889313E-03 + 4.4957517755E-03 4.4628539023E-03 4.4301936182E-03 4.3977692412E-03 + 4.3655791007E-03 4.3336215379E-03 4.3018949052E-03 4.2703975663E-03 + 4.2391278961E-03 4.2080842809E-03 4.1772651179E-03 4.1466688153E-03 + 4.1162937926E-03 4.0861384796E-03 4.0562013175E-03 4.0264807579E-03 + 3.9969752630E-03 3.9676833060E-03 3.9386033702E-03 3.9097339495E-03 + 3.8810735484E-03 3.8526206815E-03 3.8243738736E-03 3.7963316599E-03 + 3.7684925856E-03 3.7408552060E-03 3.7134180863E-03 3.6861798016E-03 + 3.6591389371E-03 3.6322940876E-03 3.6056438576E-03 3.5791868612E-03 + 3.5529217224E-03 3.5268470745E-03 3.5009615603E-03 3.4752638319E-03 + 3.4497525511E-03 3.4244263885E-03 3.3992840244E-03 3.3743241478E-03 + 3.3495454572E-03 3.3249466600E-03 3.3005264724E-03 3.2762836197E-03 + 3.2522168361E-03 3.2283248645E-03 3.2046064566E-03 3.1810603726E-03 + 3.1576853817E-03 3.1344802613E-03 3.1114437975E-03 3.0885747847E-03 + 3.0658720260E-03 3.0433343326E-03 3.0209605239E-03 2.9987494278E-03 + 2.9766998802E-03 2.9548107251E-03 2.9330808147E-03 2.9115090091E-03 + 2.8900941765E-03 2.8688351927E-03 2.8477309417E-03 2.8267803151E-03 + 2.8059822123E-03 2.7853355404E-03 2.7648392141E-03 2.7444921557E-03 + 2.7242932952E-03 2.7042415698E-03 2.6843359243E-03 2.6645753109E-03 + 2.6449586892E-03 2.6254850260E-03 2.6061532952E-03 2.5869624781E-03 + 2.5679115631E-03 2.5489995457E-03 2.5302254284E-03 2.5115882208E-03 + 2.4930869392E-03 2.4747206070E-03 2.4564882546E-03 2.4383889189E-03 + 2.4204216437E-03 2.4025854796E-03 2.3848794838E-03 2.3673027201E-03 + 2.3498542589E-03 2.3325331771E-03 2.3153385583E-03 2.2982694923E-03 + 2.2813250754E-03 2.2645044103E-03 2.2478066059E-03 2.2312307776E-03 + 2.2147760467E-03 2.1984415411E-03 2.1822263945E-03 2.1661297469E-03 + 2.1501507443E-03 2.1342885387E-03 2.1185422882E-03 2.1029111567E-03 + 2.0873943140E-03 2.0719909359E-03 2.0567002039E-03 2.0415213054E-03 + 2.0264534334E-03 2.0114957866E-03 1.9966475697E-03 1.9819079924E-03 + 1.9672762707E-03 1.9527516255E-03 1.9383332837E-03 1.9240204773E-03 + 1.9098124441E-03 1.8957084270E-03 1.8817076744E-03 1.8678094400E-03 + 1.8540129828E-03 1.8403175670E-03 1.8267224620E-03 1.8132269425E-03 + 1.7998302883E-03 1.7865317842E-03 1.7733307202E-03 1.7602263913E-03 + 1.7472180974E-03 1.7343051436E-03 1.7214868397E-03 1.7087625005E-03 + 1.6961314458E-03 1.6835929999E-03 1.6711464923E-03 1.6587912569E-03 + 1.6465266326E-03 1.6343519628E-03 1.6222665958E-03 1.6102698843E-03 + 1.5983611858E-03 1.5865398622E-03 1.5748052801E-03 1.5631568105E-03 + 1.5515938289E-03 1.5401157153E-03 1.5287218541E-03 1.5174116340E-03 + 1.5061844482E-03 1.4950396940E-03 1.4839767733E-03 1.4729950920E-03 + 1.4620940605E-03 1.4512730931E-03 1.4405316084E-03 1.4298690293E-03 + 1.4192847827E-03 1.4087782995E-03 1.3983490148E-03 1.3879963677E-03 + 1.3777198012E-03 1.3675187625E-03 1.3573927026E-03 1.3473410763E-03 + 1.3373633427E-03 1.3274589643E-03 1.3176274077E-03 1.3078681433E-03 + 1.2981806452E-03 1.2885643914E-03 1.2790188635E-03 1.2695435470E-03 + 1.2601379307E-03 1.2508015075E-03 1.2415337737E-03 1.2323342292E-03 + 1.2232023776E-03 1.2141377259E-03 1.2051397849E-03 1.1962080685E-03 + 1.1873420944E-03 1.1785413837E-03 1.1698054609E-03 1.1611338539E-03 + 1.1525260941E-03 1.1439817159E-03 1.1355002576E-03 1.1270812604E-03 + 1.1187242689E-03 1.1104288309E-03 1.1021944977E-03 1.0940208236E-03 + 1.0859073661E-03 1.0778536860E-03 1.0698593471E-03 1.0619239166E-03 + 1.0540469644E-03 1.0462280639E-03 1.0384667913E-03 1.0307627261E-03 + 1.0231154505E-03 1.0155245499E-03 1.0079896127E-03 1.0005102303E-03 + 9.9308599683E-04 9.8571650953E-04 9.7840136847E-04 9.7114017662E-04 + 9.6393253981E-04 9.5677806670E-04 9.4967636877E-04 9.4262706029E-04 + 9.3562975835E-04 9.2868408275E-04 9.2178965605E-04 9.1494610355E-04 + 9.0815305324E-04 9.0141013577E-04 8.9471698448E-04 8.8807323536E-04 + 8.8147852701E-04 8.7493250064E-04 8.6843480006E-04 8.6198507165E-04 + 8.5558296433E-04 8.4922812956E-04 8.4292022133E-04 8.3665889612E-04 + 8.3044381289E-04 8.2427463306E-04 8.1815102052E-04 8.1207264156E-04 + 8.0603916490E-04 8.0005026164E-04 7.9410560528E-04 7.8820487166E-04 + 7.8234773899E-04 7.7653388777E-04 7.7076300085E-04 7.6503476335E-04 + 7.5934886268E-04 7.5370498850E-04 7.4810283274E-04 7.4254208955E-04 + 7.3702245527E-04 7.3154362847E-04 7.2610530990E-04 7.2070720246E-04 + 7.1534901122E-04 7.1003044338E-04 7.0475120826E-04 6.9951101730E-04 + 6.9430958400E-04 6.8914662398E-04 6.8402185488E-04 6.7893499643E-04 + 6.7388577035E-04 6.6887390040E-04 6.6389911236E-04 6.5896113397E-04 + 6.5405969496E-04 6.4919452702E-04 6.4436536379E-04 6.3957194084E-04 + 6.3481399565E-04 6.3009126763E-04 6.2540349806E-04 6.2075043012E-04 + 6.1613180883E-04 6.1154738109E-04 6.0699689561E-04 6.0248010295E-04 + 5.9799675548E-04 5.9354660735E-04 5.8912941452E-04 5.8474493472E-04 + 5.8039292743E-04 5.7607315388E-04 5.7178537705E-04 5.6752936164E-04 + 5.6330487406E-04 5.5911168241E-04 5.5494955648E-04 5.5081826776E-04 + 5.4671758936E-04 5.4264729609E-04 5.3860716436E-04 5.3459697222E-04 + 5.3061649935E-04 5.2666552702E-04 5.2274383809E-04 5.1885121702E-04 + 5.1498744981E-04 5.1115232405E-04 5.0734562887E-04 5.0356715492E-04 + 4.9981669440E-04 4.9609404100E-04 4.9239898994E-04 4.8873133791E-04 + 4.8509088309E-04 4.8147742514E-04 4.7789076517E-04 4.7433070576E-04 + 4.7079705090E-04 4.6728960603E-04 4.6380817800E-04 4.6035257509E-04 + 4.5692260695E-04 4.5351808464E-04 4.5013882060E-04 4.4678462862E-04 + 4.4345532386E-04 4.4015072285E-04 4.3687064342E-04 4.3361490476E-04 + 4.3038332737E-04 4.2717573307E-04 4.2399194497E-04 4.2083178748E-04 + 4.1769508630E-04 4.1458166837E-04 4.1149136195E-04 4.0842399650E-04 + 4.0537940277E-04 4.0235741271E-04 3.9935785954E-04 3.9638057767E-04 + 3.9342540272E-04 3.9049217153E-04 3.8758072212E-04 3.8469089370E-04 + 3.8182252666E-04 3.7897546256E-04 3.7614954409E-04 3.7334461514E-04 + 3.7056052070E-04 3.6779710692E-04 3.6505422106E-04 3.6233171152E-04 + 3.5962942778E-04 3.5694722046E-04 3.5428494123E-04 3.5164244288E-04 + 3.4901957927E-04 3.4641620532E-04 3.4383217703E-04 3.4126735144E-04 + 3.3872158665E-04 3.3619474178E-04 3.3368667700E-04 3.3119725351E-04 + 3.2872633351E-04 3.2627378023E-04 3.2383945787E-04 3.2142323167E-04 + 3.1902496782E-04 3.1664453351E-04 3.1428179690E-04 3.1193662712E-04 + 3.0960889426E-04 3.0729846936E-04 3.0500522440E-04 3.0272903231E-04 + 3.0046976695E-04 2.9822730311E-04 2.9600151648E-04 2.9379228369E-04 + 2.9159948226E-04 2.8942299060E-04 2.8726268803E-04 2.8511845475E-04 + 2.8299017184E-04 2.8087772125E-04 2.7878098580E-04 2.7669984918E-04 + 2.7463419591E-04 2.7258391139E-04 2.7054888183E-04 2.6852899430E-04 + 2.6652413669E-04 2.6453419771E-04 2.6255906690E-04 2.6059863461E-04 + 2.5865279198E-04 2.5672143096E-04 2.5480444431E-04 2.5290172555E-04 + 2.5101316900E-04 2.4913866976E-04 2.4727812369E-04 2.4543142743E-04 + 2.4359847836E-04 2.4177917464E-04 2.3997341516E-04 2.3818109956E-04 + 2.3640212822E-04 2.3463640225E-04 2.3288382349E-04 2.3114429450E-04 + 2.2941771856E-04 2.2770399967E-04 2.2600304251E-04 2.2431475249E-04 + 2.2263903571E-04 2.2097579894E-04 2.1932494967E-04 2.1768639606E-04 + 2.1606004692E-04 2.1444581176E-04 2.1284360076E-04 2.1125332475E-04 + 2.0967489521E-04 2.0810822428E-04 2.0655322475E-04 2.0500981005E-04 + 2.0347789425E-04 2.0195739204E-04 2.0044821877E-04 1.9895029038E-04 + 1.9746352345E-04 1.9598783517E-04 1.9452314332E-04 1.9306936633E-04 + 1.9162642320E-04 1.9019423353E-04 1.8877271751E-04 1.8736179594E-04 + 1.8596139017E-04 1.8457142218E-04 1.8319181446E-04 1.8182249014E-04 + 1.8046337286E-04 1.7911438685E-04 1.7777545691E-04 1.7644650837E-04 + 1.7512746713E-04 1.7381825962E-04 1.7251881283E-04 1.7122905428E-04 + 1.6994891202E-04 1.6867831464E-04 1.6741719126E-04 1.6616547151E-04 + 1.6492308556E-04 1.6368996407E-04 1.6246603822E-04 1.6125123972E-04 + 1.6004550076E-04 1.5884875403E-04 1.5766093274E-04 1.5648197057E-04 + 1.5531180169E-04 1.5415036079E-04 1.5299758300E-04 1.5185340394E-04 + 1.5071775973E-04 1.4959058694E-04 1.4847182260E-04 1.4736140424E-04 + 1.4625926981E-04 1.4516535775E-04 1.4407960694E-04 1.4300195673E-04 + 1.4193234688E-04 1.4087071764E-04 1.3981700967E-04 1.3877116408E-04 + 1.3773312242E-04 1.3670282667E-04 1.3568021923E-04 1.3466524294E-04 + 1.3365784105E-04 1.3265795724E-04 1.3166553560E-04 1.3068052063E-04 + 1.2970285725E-04 1.2873249079E-04 1.2776936698E-04 1.2681343193E-04 + 1.2586463219E-04 1.2492291467E-04 1.2398822670E-04 1.2306051597E-04 + 1.2213973059E-04 1.2122581903E-04 1.2031873015E-04 1.1941841319E-04 + 1.1852481776E-04 1.1763789386E-04 1.1675759182E-04 1.1588386239E-04 + 1.1501665665E-04 1.1415592605E-04 1.1330162241E-04 1.1245369788E-04 + 1.1161210500E-04 1.1077679664E-04 1.0994772602E-04 1.0912484671E-04 + 1.0830811263E-04 1.0749747802E-04 1.0669289749E-04 1.0589432596E-04 + 1.0510171870E-04 1.0431503130E-04 1.0353421969E-04 1.0275924012E-04 + 1.0199004917E-04 1.0122660372E-04 1.0046886101E-04 9.9716778561E-05 + 9.8970314224E-05 9.8229426161E-05 9.7494072843E-05 9.6764213049E-05 + 9.6039805864E-05 9.5320810677E-05 9.4607187177E-05 9.3898895352E-05 + 9.3195895488E-05 9.2498148163E-05 9.1805614250E-05 9.1118254910E-05 + 9.0436031595E-05 8.9758906039E-05 8.9086840264E-05 8.8419796570E-05 + 8.7757737539E-05 8.7100626029E-05 8.6448425176E-05 8.5801098387E-05 + 8.5158609342E-05 8.4520921989E-05 8.3888000546E-05 8.3259809494E-05 + 8.2636313578E-05 8.2017477807E-05 8.1403267448E-05 8.0793648024E-05 + 8.0188585317E-05 7.9588045361E-05 7.8991994443E-05 7.8400399101E-05 + 7.7813226120E-05 7.7230442531E-05 7.6652015613E-05 7.6077912884E-05 + 7.5508102106E-05 7.4942551279E-05 7.4381228642E-05 7.3824102668E-05 + 7.3271142065E-05 7.2722315774E-05 7.2177592966E-05 7.1636943041E-05 + 7.1100335626E-05 7.0567740575E-05 7.0039127965E-05 6.9514468095E-05 + 6.8993731485E-05 6.8476888873E-05 6.7963911217E-05 6.7454769688E-05 + 6.6949435672E-05 6.6447880770E-05 6.5950076790E-05 6.5455995753E-05 + 6.4965609886E-05 6.4478891622E-05 6.3995813601E-05 6.3516348665E-05 + 6.3040469857E-05 6.2568150423E-05 6.2099363804E-05 6.1634083643E-05 + 6.1172283775E-05 6.0713938233E-05 6.0259021239E-05 5.9807507210E-05 + 5.9359370752E-05 5.8914586660E-05 5.8473129916E-05 5.8034975689E-05 + 5.7600099332E-05 5.7168476380E-05 5.6740082553E-05 5.6314893749E-05 + 5.5892886046E-05 5.5474035701E-05 5.5058319146E-05 5.4645712988E-05 + 5.4236194011E-05 5.3829739168E-05 5.3426325586E-05 5.3025930561E-05 + 5.2628531559E-05 5.2234106212E-05 5.1842632319E-05 5.1454087846E-05 + 5.1068450920E-05 5.0685699833E-05 5.0305813037E-05 4.9928769147E-05 + 4.9554546933E-05 4.9183125327E-05 4.8814483416E-05 4.8448600441E-05 + 4.8085455801E-05 4.7725029046E-05 4.7367299880E-05 4.7012248155E-05 + 4.6659853875E-05 4.6310097195E-05 4.5962958413E-05 4.5618417978E-05 + 4.5276456482E-05 4.4937054662E-05 4.4600193399E-05 4.4265853717E-05 + 4.3934016779E-05 4.3604663889E-05 4.3277776493E-05 4.2953336172E-05 + 4.2631324646E-05 4.2311723768E-05 4.1994515531E-05 4.1679682059E-05 + 4.1367205609E-05 4.1057068572E-05 4.0749253468E-05 4.0443742950E-05 + 4.0140519797E-05 3.9839566918E-05 3.9540867350E-05 3.9244404255E-05 + 3.8950160920E-05 3.8658120760E-05 3.8368267309E-05 3.8080584227E-05 + 3.7795055294E-05 3.7511664411E-05 3.7230395600E-05 3.6951233001E-05 + 3.6674160873E-05 3.6399163592E-05 3.6126225650E-05 3.5855331656E-05 + 3.5586466331E-05 3.5319614513E-05 3.5054761151E-05 3.4791891306E-05 + 3.4530990153E-05 3.4272042974E-05 3.4015035163E-05 3.3759952222E-05 + 3.3506779762E-05 3.3255503500E-05 3.3006109260E-05 3.2758582972E-05 + 3.2512910670E-05 3.2269078495E-05 3.2027072686E-05 3.1786879591E-05 + 3.1548485654E-05 3.1311877424E-05 3.1077041548E-05 3.0843964775E-05 + 3.0612633950E-05 3.0383036018E-05 3.0155158021E-05 2.9928987098E-05 + 2.9704510482E-05 2.9481715504E-05 2.9260589588E-05 2.9041120250E-05 + 2.8823295104E-05 2.8607101852E-05 2.8392528289E-05 2.8179562301E-05 + 2.7968191866E-05 2.7758405049E-05 2.7550190007E-05 2.7343534982E-05 + 2.7138428306E-05 2.6934858397E-05 2.6732813762E-05 2.6532282989E-05 + 2.6333254756E-05 2.6135717822E-05 2.5939661032E-05 2.5745073313E-05 + 2.5551943675E-05 2.5360261211E-05 2.5170015093E-05 2.4981194577E-05 + 2.4793788996E-05 2.4607787766E-05 2.4423180378E-05 2.4239956405E-05 + 2.4058105496E-05 2.3877617378E-05 2.3698481854E-05 2.3520688803E-05 + 2.3344228181E-05 2.3169090017E-05 2.2995264417E-05 2.2822741557E-05 + 2.2651511691E-05 2.2481565142E-05 2.2312892307E-05 2.2145483655E-05 + 2.1979329725E-05 2.1814421126E-05 2.1650748540E-05 2.1488302717E-05 + 2.1327074475E-05 2.1167054702E-05 2.1008234353E-05 2.0850604451E-05 + 2.0694156087E-05 2.0538880418E-05 2.0384768666E-05 2.0231812119E-05 + 2.0080002130E-05 1.9929330119E-05 1.9779787566E-05 1.9631366017E-05 + 1.9484057081E-05 1.9337852431E-05 1.9192743798E-05 1.9048722979E-05 + 1.8905781831E-05 1.8763912271E-05 1.8623106277E-05 1.8483355887E-05 + 1.8344653199E-05 1.8206990367E-05 1.8070359609E-05 1.7934753197E-05 + 1.7800163461E-05 1.7666582790E-05 1.7534003630E-05 1.7402418481E-05 + 1.7271819901E-05 1.7142200504E-05 1.7013552957E-05 1.6885869984E-05 + 1.6759144363E-05 1.6633368924E-05 1.6508536554E-05 1.6384640189E-05 + 1.6261672822E-05 1.6139627496E-05 1.6018497306E-05 1.5898275398E-05 + 1.5778954973E-05 1.5660529277E-05 1.5542991612E-05 1.5426335325E-05 + 1.5310553818E-05 1.5195640539E-05 1.5081588984E-05 1.4968392701E-05 + 1.4856045284E-05 1.4744540375E-05 1.4633871664E-05 1.4524032888E-05 + 1.4415017831E-05 1.4306820324E-05 1.4199434243E-05 1.4092853510E-05 + 1.3987072093E-05 1.3882084004E-05 1.3777883302E-05 1.3674464089E-05 + 1.3571820509E-05 1.3469946754E-05 1.3368837057E-05 1.3268485694E-05 + 1.3168886984E-05 1.3070035289E-05 1.2971925013E-05 1.2874550602E-05 + 1.2777906543E-05 1.2681987364E-05 1.2586787636E-05 1.2492301967E-05 + 1.2398525008E-05 1.2305451451E-05 1.2213076024E-05 1.2121393497E-05 + 1.2030398679E-05 1.1940086417E-05 1.1850451598E-05 1.1761489145E-05 + 1.1673194021E-05 1.1585561225E-05 1.1498585795E-05 1.1412262806E-05 + 1.1326587368E-05 1.1241554629E-05 1.1157159774E-05 1.1073398023E-05 + 1.0990264631E-05 1.0907754890E-05 1.0825864127E-05 1.0744587703E-05 + 1.0663921014E-05 1.0583859492E-05 1.0504398600E-05 1.0425533839E-05 + 1.0347260740E-05 1.0269574870E-05 1.0192471828E-05 1.0115947245E-05 + 1.0039996786E-05 9.9646161498E-06 9.8898010643E-06 9.8155472912E-06 + 9.7418506236E-06 9.6687068861E-06 9.5961119345E-06 9.5240616555E-06 + 9.4525519668E-06 9.3815788166E-06 9.3111381832E-06 9.2412260753E-06 + 9.1718385313E-06 9.1029716194E-06 9.0346214369E-06 8.9667841107E-06 + 8.8994557965E-06 8.8326326788E-06 8.7663109705E-06 8.7004869132E-06 + 8.6351567763E-06 8.5703168574E-06 8.5059634815E-06 8.4420930014E-06 + 8.3787017970E-06 8.3157862754E-06 8.2533428707E-06 8.1913680434E-06 + + + 6.8696133851E-14 2.9825421601E-05 1.1928046580E-04 2.6830150975E-04 + 4.7678264576E-04 7.4457587704E-04 1.0714913914E-03 1.4572979129E-03 + 1.9017231311E-03 2.4044542080E-03 2.9651383612E-03 3.5833835245E-03 + 4.2587590838E-03 4.9907966883E-03 5.7789911367E-03 6.6228013363E-03 + 7.5216513352E-03 8.4749314251E-03 9.4819993151E-03 1.0542181373E-02 + 1.1654773933E-02 1.2819044669E-02 1.4034234030E-02 1.5299556735E-02 + 1.6614203327E-02 1.7977341779E-02 1.9388119152E-02 2.0845663306E-02 + 2.2349084646E-02 2.3897477918E-02 2.5489924034E-02 2.7125491935E-02 + 2.8803240478E-02 3.0522220342E-02 3.2281475963E-02 3.4080047466E-02 + 3.5916972612E-02 3.7791288750E-02 3.9702034752E-02 4.1648252947E-02 + 4.3628991030E-02 4.5643303960E-02 4.7690255810E-02 4.9768921598E-02 + 5.1878389065E-02 5.4017760411E-02 5.6186153971E-02 5.8382705831E-02 + 6.0606571383E-02 6.2856926798E-02 6.5132970427E-02 6.7433924119E-02 + 6.9759034443E-02 7.2107573823E-02 7.4478841573E-02 7.6872164830E-02 + 7.9286899378E-02 8.1722430369E-02 8.4178172921E-02 8.6653572616E-02 + 8.9148105867E-02 9.1661280178E-02 9.4192634276E-02 9.6741738132E-02 + 9.9308192860E-02 1.0189163049E-01 1.0449171364E-01 1.0710813505E-01 + 1.0974061704E-01 1.1238891080E-01 1.1505279563E-01 1.1773207805E-01 + 1.2042659082E-01 1.2313619182E-01 1.2586076296E-01 1.2860020884E-01 + 1.3135445550E-01 1.3412344894E-01 1.3690715375E-01 1.3970555148E-01 + 1.4251863915E-01 1.4534642760E-01 1.4818893983E-01 1.5104620934E-01 + 1.5391827841E-01 1.5680519636E-01 1.5970701789E-01 1.6262380128E-01 + 1.6555560673E-01 1.6850249464E-01 1.7146452392E-01 1.7444175037E-01 + 1.7743422504E-01 1.8044199265E-01 1.8346509009E-01 1.8650354491E-01 + 1.8955737393E-01 1.9262658189E-01 1.9571116009E-01 1.9881108525E-01 + 2.0192631831E-01 2.0505680334E-01 2.0820246659E-01 2.1136321550E-01 + 2.1453893791E-01 2.1772950129E-01 2.2093475200E-01 2.2415451475E-01 + 2.2738859208E-01 2.3063676384E-01 2.3389878690E-01 2.3717439483E-01 + 2.4046329768E-01 2.4376518182E-01 2.4707970989E-01 2.5040652077E-01 + 2.5374522962E-01 2.5709542802E-01 2.6045668412E-01 2.6382854283E-01 + 2.6721052613E-01 2.7060213338E-01 2.7400284164E-01 2.7741210611E-01 + 2.8082936052E-01 2.8425401762E-01 2.8768546967E-01 2.9112308893E-01 + 2.9456622826E-01 2.9801422160E-01 3.0146638463E-01 3.0492201534E-01 + 3.0838039462E-01 3.1184078691E-01 3.1530244086E-01 3.1876458994E-01 + 3.2222645312E-01 3.2568723556E-01 3.2914612927E-01 3.3260231379E-01 + 3.3605495696E-01 3.3950321554E-01 3.4294623604E-01 3.4638315539E-01 + 3.4981310172E-01 3.5323519514E-01 3.5664854854E-01 3.6005226836E-01 + 3.6344545547E-01 3.6682720601E-01 3.7019661225E-01 3.7355276351E-01 + 3.7689474708E-01 3.8022164921E-01 3.8353255605E-01 3.8682655472E-01 + 3.9010273435E-01 3.9336018712E-01 3.9659800945E-01 3.9981530312E-01 + 4.0301117644E-01 4.0618474548E-01 4.0933513533E-01 4.1246148138E-01 + 4.1556293061E-01 4.1863864294E-01 4.2168779261E-01 4.2470956952E-01 + 4.2770318070E-01 4.3066785169E-01 4.3360282798E-01 4.3650737647E-01 + 4.3938078693E-01 4.4222237342E-01 4.4503147579E-01 4.4780746108E-01 + 4.5054972497E-01 4.5325769319E-01 4.5593082292E-01 4.5856860412E-01 + 4.6117056088E-01 4.6373625271E-01 4.6626527575E-01 4.6875726400E-01 + 4.7121189040E-01 4.7362886798E-01 4.7600795079E-01 4.7834893491E-01 + 4.8065165936E-01 4.8291600680E-01 4.8514190428E-01 4.8732932376E-01 + 4.8947828269E-01 4.9158884432E-01 4.9366111810E-01 4.9569525999E-01 + 4.9769146838E-01 4.9964996925E-01 5.0157099353E-01 5.0345477139E-01 + 5.0530153589E-01 5.0711152405E-01 5.0888497437E-01 5.1062212765E-01 + 5.1232322666E-01 5.1398851606E-01 5.1561824225E-01 5.1721265329E-01 + 5.1877199877E-01 5.2029652975E-01 5.2178649862E-01 5.2324215903E-01 + 5.2466376579E-01 5.2605157482E-01 5.2740584299E-01 5.2872682812E-01 + 5.3001478885E-01 5.3126998460E-01 5.3249267546E-01 5.3368312213E-01 + 5.3484158587E-01 5.3596832840E-01 5.3706361188E-01 5.3812769876E-01 + 5.3916085183E-01 5.4016333406E-01 5.4113540858E-01 5.4207733864E-01 + 5.4298938752E-01 5.4387181848E-01 5.4472489471E-01 5.4554887930E-01 + 5.4634403514E-01 5.4711062490E-01 5.4784891098E-01 5.4855915547E-01 + 5.4924162005E-01 5.4989656603E-01 5.5052425422E-01 5.5112494497E-01 + 5.5169889804E-01 5.5224637264E-01 5.5276762732E-01 5.5326292000E-01 + 5.5373250788E-01 5.5417664741E-01 5.5459559430E-01 5.5498960343E-01 + 5.5535892884E-01 5.5570382371E-01 5.5602454031E-01 5.5632132998E-01 + 5.5659444311E-01 5.5684412909E-01 5.5707063630E-01 5.5727421208E-01 + 5.5745510272E-01 5.5761355339E-01 5.5774980819E-01 5.5786411005E-01 + 5.5795670078E-01 5.5802782100E-01 5.5807771014E-01 5.5810660643E-01 + 5.5811474685E-01 5.5810236716E-01 5.5806970185E-01 5.5801698413E-01 + 5.5794444593E-01 5.5785231787E-01 5.5774082927E-01 5.5761020809E-01 + 5.5746068099E-01 5.5729247325E-01 5.5710580879E-01 5.5690091018E-01 + 5.5667799860E-01 5.5643729383E-01 5.5617901426E-01 5.5590337690E-01 + 5.5561059732E-01 5.5530088968E-01 5.5497446673E-01 5.5463153977E-01 + 5.5427231870E-01 5.5389701195E-01 5.5350582653E-01 5.5309896800E-01 + 5.5267664046E-01 5.5223904658E-01 5.5178638756E-01 5.5131886316E-01 + 5.5083667166E-01 5.5034000990E-01 5.4982907327E-01 5.4930405567E-01 + 5.4876514956E-01 5.4821254594E-01 5.4764643435E-01 5.4706700285E-01 + 5.4647443808E-01 5.4586892517E-01 5.4525064784E-01 5.4461978832E-01 + 5.4397652742E-01 5.4332104446E-01 5.4265351735E-01 5.4197412251E-01 + 5.4128303494E-01 5.4058042820E-01 5.3986647440E-01 5.3914134422E-01 + 5.3840520689E-01 5.3765823023E-01 5.3690058063E-01 5.3613242305E-01 + 5.3535392102E-01 5.3456523667E-01 5.3376653073E-01 5.3295796248E-01 + 5.3213968985E-01 5.3131186933E-01 5.3047465603E-01 5.2962820367E-01 + 5.2877266459E-01 5.2790818974E-01 5.2703492870E-01 5.2615302968E-01 + 5.2526263951E-01 5.2436390368E-01 5.2345696632E-01 5.2254197020E-01 + 5.2161905675E-01 5.2068836607E-01 5.1975003691E-01 5.1880420671E-01 + 5.1785101157E-01 5.1689058628E-01 5.1592306433E-01 5.1494857788E-01 + 5.1396725782E-01 5.1297923373E-01 5.1198463390E-01 5.1098358534E-01 + 5.0997621380E-01 5.0896264374E-01 5.0794299838E-01 5.0691739966E-01 + 5.0588596829E-01 5.0484882371E-01 5.0380608415E-01 5.0275786661E-01 + 5.0170428683E-01 5.0064545937E-01 4.9958149757E-01 4.9851251355E-01 + 4.9743861825E-01 4.9635992141E-01 4.9527653158E-01 4.9418855615E-01 + 4.9309610132E-01 4.9199927213E-01 4.9089817248E-01 4.8979290509E-01 + 4.8868357157E-01 4.8757027237E-01 4.8645310681E-01 4.8533217311E-01 + 4.8420756835E-01 4.8307938852E-01 4.8194772850E-01 4.8081268207E-01 + 4.7967434194E-01 4.7853279973E-01 4.7738814599E-01 4.7624047021E-01 + 4.7508986081E-01 4.7393640518E-01 4.7278018964E-01 4.7162129951E-01 + 4.7045981906E-01 4.6929583152E-01 4.6812941916E-01 4.6696066319E-01 + 4.6578964386E-01 4.6461644041E-01 4.6344113110E-01 4.6226379323E-01 + 4.6108450309E-01 4.5990333607E-01 4.5872036655E-01 4.5753566800E-01 + 4.5634931294E-01 4.5516137297E-01 4.5397191874E-01 4.5278102002E-01 + 4.5158874565E-01 4.5039516357E-01 4.4920034085E-01 4.4800434364E-01 + 4.4680723724E-01 4.4560908607E-01 4.4440995370E-01 4.4320990282E-01 + 4.4200899530E-01 4.4080729215E-01 4.3960485357E-01 4.3840173892E-01 + 4.3719800674E-01 4.3599371477E-01 4.3478891995E-01 4.3358367842E-01 + 4.3237804554E-01 4.3117207589E-01 4.2996582326E-01 4.2875934070E-01 + 4.2755268050E-01 4.2634589418E-01 4.2513903255E-01 4.2393214566E-01 + 4.2272528284E-01 4.2151849271E-01 4.2031182315E-01 4.1910532137E-01 + 4.1789903386E-01 4.1669300642E-01 4.1548728418E-01 4.1428191158E-01 + 4.1307693239E-01 4.1187238972E-01 4.1066832603E-01 4.0946478313E-01 + 4.0826180219E-01 4.0705942374E-01 4.0585768768E-01 4.0465663331E-01 + 4.0345629928E-01 4.0225672367E-01 4.0105794393E-01 3.9985999695E-01 + 3.9866291900E-01 3.9746674578E-01 3.9627151244E-01 3.9507725353E-01 + 3.9388400305E-01 3.9269179447E-01 3.9150066067E-01 3.9031063402E-01 + 3.8912174635E-01 3.8793402895E-01 3.8674751261E-01 3.8556222758E-01 + 3.8437820362E-01 3.8319546997E-01 3.8201405538E-01 3.8083398811E-01 + 3.7965529595E-01 3.7847800617E-01 3.7730214560E-01 3.7612774060E-01 + 3.7495481706E-01 3.7378340041E-01 3.7261351563E-01 3.7144518727E-01 + 3.7027843943E-01 3.6911329577E-01 3.6794977953E-01 3.6678791354E-01 + 3.6562772018E-01 3.6446922145E-01 3.6331243893E-01 3.6215739380E-01 + 3.6100410683E-01 3.5985259843E-01 3.5870288860E-01 3.5755499697E-01 + 3.5640894279E-01 3.5526474493E-01 3.5412242191E-01 3.5298199188E-01 + 3.5184347264E-01 3.5070688164E-01 3.4957223596E-01 3.4843955238E-01 + 3.4730884730E-01 3.4618013682E-01 3.4505343669E-01 3.4392876234E-01 + 3.4280612890E-01 3.4168555115E-01 3.4056704359E-01 3.3945062039E-01 + 3.3833629545E-01 3.3722408234E-01 3.3611399434E-01 3.3500604446E-01 + 3.3390024542E-01 3.3279660963E-01 3.3169514925E-01 3.3059587616E-01 + 3.2949880198E-01 3.2840393804E-01 3.2731129541E-01 3.2622088494E-01 + 3.2513271717E-01 3.2404680243E-01 3.2296315078E-01 3.2188177204E-01 + 3.2080267580E-01 3.1972587140E-01 3.1865136796E-01 3.1757917435E-01 + 3.1650929922E-01 3.1544175101E-01 3.1437653792E-01 3.1331366794E-01 + 3.1225314886E-01 3.1119498824E-01 3.1013919343E-01 3.0908577159E-01 + 3.0803472967E-01 3.0698607442E-01 3.0593981241E-01 3.0489594998E-01 + 3.0385449332E-01 3.0281544841E-01 3.0177882106E-01 3.0074461687E-01 + 2.9971284130E-01 2.9868349959E-01 2.9765659686E-01 2.9663213800E-01 + 2.9561012778E-01 2.9459057078E-01 2.9357347141E-01 2.9255883393E-01 + 2.9154666246E-01 2.9053696092E-01 2.8952973312E-01 2.8852498268E-01 + 2.8752271311E-01 2.8652292774E-01 2.8552562976E-01 2.8453082225E-01 + 2.8353850810E-01 2.8254869011E-01 2.8156137090E-01 2.8057655299E-01 + 2.7959423875E-01 2.7861443043E-01 2.7763713015E-01 2.7666233989E-01 + 2.7569006153E-01 2.7472029682E-01 2.7375304737E-01 2.7278831470E-01 + 2.7182610020E-01 2.7086640515E-01 2.6990923071E-01 2.6895457793E-01 + 2.6800244776E-01 2.6705284105E-01 2.6610575851E-01 2.6516120078E-01 + 2.6421916838E-01 2.6327966173E-01 2.6234268117E-01 2.6140822692E-01 + 2.6047629911E-01 2.5954689778E-01 2.5862002287E-01 2.5769567423E-01 + 2.5677385163E-01 2.5585455474E-01 2.5493778315E-01 2.5402353636E-01 + 2.5311181378E-01 2.5220261475E-01 2.5129593853E-01 2.5039178427E-01 + 2.4949015108E-01 2.4859103797E-01 2.4769444388E-01 2.4680036767E-01 + 2.4590880812E-01 2.4501976397E-01 2.4413323384E-01 2.4324921632E-01 + 2.4236770991E-01 2.4148871305E-01 2.4061222410E-01 2.3973824137E-01 + 2.3886676310E-01 2.3799778747E-01 2.3713131259E-01 2.3626733650E-01 + 2.3540585721E-01 2.3454687263E-01 2.3369038065E-01 2.3283637908E-01 + 2.3198486568E-01 2.3113583814E-01 2.3028929413E-01 2.2944523122E-01 + 2.2860364697E-01 2.2776453886E-01 2.2692790433E-01 2.2609374077E-01 + 2.2526204552E-01 2.2443281586E-01 2.2360604905E-01 2.2278174227E-01 + 2.2195989269E-01 2.2114049739E-01 2.2032355344E-01 2.1950905786E-01 + 2.1869700762E-01 2.1788739965E-01 2.1708023085E-01 2.1627549806E-01 + 2.1547319809E-01 2.1467332771E-01 2.1387588365E-01 2.1308086261E-01 + 2.1228826124E-01 2.1149807617E-01 2.1071030397E-01 2.0992494120E-01 + 2.0914198436E-01 2.0836142995E-01 2.0758327441E-01 2.0680751415E-01 + 2.0603414555E-01 2.0526316496E-01 2.0449456871E-01 2.0372835309E-01 + 2.0296451434E-01 2.0220304871E-01 2.0144395239E-01 2.0068722156E-01 + 1.9993285236E-01 1.9918084091E-01 1.9843118331E-01 1.9768387562E-01 + 1.9693891387E-01 1.9619629409E-01 1.9545601226E-01 1.9471806436E-01 + 1.9398244631E-01 1.9324915405E-01 1.9251818347E-01 1.9178953045E-01 + 1.9106319083E-01 1.9033916044E-01 1.8961743511E-01 1.8889801061E-01 + 1.8818088272E-01 1.8746604718E-01 1.8675349973E-01 1.8604323608E-01 + 1.8533525192E-01 1.8462954292E-01 1.8392610475E-01 1.8322493304E-01 + 1.8252602341E-01 1.8182937147E-01 1.8113497282E-01 1.8044282301E-01 + 1.7975291762E-01 1.7906525219E-01 1.7837982223E-01 1.7769662327E-01 + 1.7701565081E-01 1.7633690032E-01 1.7566036729E-01 1.7498604717E-01 + 1.7431393540E-01 1.7364402742E-01 1.7297631865E-01 1.7231080449E-01 + 1.7164748035E-01 1.7098634161E-01 1.7032738363E-01 1.6967060180E-01 + 1.6901599145E-01 1.6836354792E-01 1.6771326656E-01 1.6706514268E-01 + 1.6641917160E-01 1.6577534861E-01 1.6513366902E-01 1.6449412810E-01 + 1.6385672114E-01 1.6322144340E-01 1.6258829013E-01 1.6195725661E-01 + 1.6132833806E-01 1.6070152973E-01 1.6007682684E-01 1.5945422462E-01 + 1.5883371829E-01 1.5821530305E-01 1.5759897412E-01 1.5698472667E-01 + 1.5637255592E-01 1.5576245704E-01 1.5515442521E-01 1.5454845562E-01 + 1.5394454342E-01 1.5334268379E-01 1.5274287188E-01 1.5214510286E-01 + 1.5154937186E-01 1.5095567405E-01 1.5036400456E-01 1.4977435854E-01 + 1.4918673111E-01 1.4860111742E-01 1.4801751259E-01 1.4743591174E-01 + 1.4685631001E-01 1.4627870251E-01 1.4570308436E-01 1.4512945067E-01 + 1.4455779657E-01 1.4398811715E-01 1.4342040753E-01 1.4285466282E-01 + 1.4229087812E-01 1.4172904854E-01 1.4116916917E-01 1.4061123512E-01 + 1.4005524150E-01 1.3950118339E-01 1.3894905590E-01 1.3839885413E-01 + 1.3785057316E-01 1.3730420811E-01 1.3675975406E-01 1.3621720612E-01 + 1.3567655937E-01 1.3513780891E-01 1.3460094985E-01 1.3406597727E-01 + 1.3353288628E-01 1.3300167197E-01 1.3247232944E-01 1.3194485379E-01 + 1.3141924012E-01 1.3089548353E-01 1.3037357913E-01 1.2985352201E-01 + 1.2933530728E-01 1.2881893005E-01 1.2830438542E-01 1.2779166851E-01 + 1.2728077443E-01 1.2677169828E-01 1.2626443519E-01 1.2575898027E-01 + 1.2525532864E-01 1.2475347542E-01 1.2425341574E-01 1.2375514473E-01 + 1.2325865750E-01 1.2276394920E-01 1.2227101495E-01 1.2177984990E-01 + 1.2129044918E-01 1.2080280794E-01 1.2031692132E-01 1.1983278448E-01 + 1.1935039256E-01 1.1886974072E-01 1.1839082412E-01 1.1791363793E-01 + 1.1743817730E-01 1.1696443742E-01 1.1649241344E-01 1.1602210056E-01 + 1.1555349395E-01 1.1508658880E-01 1.1462138029E-01 1.1415786363E-01 + 1.1369603400E-01 1.1323588662E-01 1.1277741668E-01 1.1232061939E-01 + 1.1186548999E-01 1.1141202367E-01 1.1096021567E-01 1.1051006122E-01 + 1.1006155555E-01 1.0961469389E-01 1.0916947150E-01 1.0872588363E-01 + 1.0828392551E-01 1.0784359242E-01 1.0740487962E-01 1.0696778237E-01 + 1.0653229595E-01 1.0609841564E-01 1.0566613673E-01 1.0523545450E-01 + 1.0480636425E-01 1.0437886129E-01 1.0395294091E-01 1.0352859844E-01 + 1.0310582919E-01 1.0268462848E-01 1.0226499165E-01 1.0184691403E-01 + 1.0143039096E-01 1.0101541779E-01 1.0060198987E-01 1.0019010257E-01 + 9.9779751251E-02 9.9370931283E-02 9.8963638048E-02 9.8557866928E-02 + 9.8153613316E-02 9.7750872609E-02 9.7349640211E-02 9.6949911533E-02 + 9.6551681992E-02 9.6154947011E-02 9.5759702021E-02 9.5365942459E-02 + 9.4973663768E-02 9.4582861398E-02 9.4193530808E-02 9.3805667460E-02 + 9.3419266826E-02 9.3034324384E-02 9.2650835619E-02 9.2268796022E-02 + 9.1888201092E-02 9.1509046335E-02 9.1131327265E-02 9.0755039401E-02 + 9.0380178271E-02 9.0006739410E-02 8.9634718359E-02 8.9264110668E-02 + 8.8894911894E-02 8.8527117600E-02 8.8160723359E-02 8.7795724748E-02 + 8.7432117354E-02 8.7069896771E-02 8.6709058602E-02 8.6349598453E-02 + 8.5991511944E-02 8.5634794697E-02 8.5279442344E-02 8.4925450527E-02 + 8.4572814891E-02 8.4221531092E-02 8.3871594795E-02 8.3523001668E-02 + 8.3175747392E-02 8.2829827653E-02 8.2485238145E-02 8.2141974572E-02 + 8.1800032644E-02 8.1459408080E-02 8.1120096605E-02 8.0782093956E-02 + 8.0445395875E-02 8.0109998112E-02 7.9775896428E-02 7.9443086589E-02 + 7.9111564371E-02 7.8781325557E-02 7.8452365941E-02 7.8124681320E-02 + 7.7798267506E-02 7.7473120314E-02 7.7149235569E-02 7.6826609105E-02 + 7.6505236765E-02 7.6185114398E-02 7.5866237864E-02 7.5548603029E-02 + 7.5232205770E-02 7.4917041970E-02 7.4603107523E-02 7.4290398330E-02 + 7.3978910300E-02 7.3668639353E-02 7.3359581415E-02 7.3051732421E-02 + 7.2745088317E-02 7.2439645054E-02 7.2135398596E-02 7.1832344911E-02 + 7.1530479979E-02 7.1229799788E-02 7.0930300334E-02 7.0631977622E-02 + 7.0334827667E-02 7.0038846490E-02 6.9744030124E-02 6.9450374608E-02 + 6.9157875993E-02 6.8866530336E-02 6.8576333703E-02 6.8287282172E-02 + 6.7999371825E-02 6.7712598757E-02 6.7426959071E-02 6.7142448877E-02 + 6.6859064296E-02 6.6576801456E-02 6.6295656497E-02 6.6015625566E-02 + 6.5736704817E-02 6.5458890418E-02 6.5182178541E-02 6.4906565369E-02 + 6.4632047096E-02 6.4358619922E-02 6.4086280057E-02 6.3815023721E-02 + 6.3544847141E-02 6.3275746556E-02 6.3007718211E-02 6.2740758363E-02 + 6.2474863275E-02 6.2210029222E-02 6.1946252486E-02 6.1683529360E-02 + 6.1421856144E-02 6.1161229149E-02 6.0901644693E-02 6.0643099106E-02 + 6.0385588725E-02 6.0129109896E-02 5.9873658976E-02 5.9619232329E-02 + 5.9365826331E-02 5.9113437363E-02 5.8862061819E-02 5.8611696101E-02 + 5.8362336619E-02 5.8113979794E-02 5.7866622054E-02 5.7620259839E-02 + 5.7374889595E-02 5.7130507781E-02 5.6887110861E-02 5.6644695312E-02 + 5.6403257617E-02 5.6162794270E-02 5.5923301775E-02 5.5684776643E-02 + 5.5447215395E-02 5.5210614563E-02 5.4974970685E-02 5.4740280311E-02 + 5.4506539999E-02 5.4273746316E-02 5.4041895839E-02 5.3810985153E-02 + 5.3581010854E-02 5.3351969546E-02 5.3123857842E-02 5.2896672364E-02 + 5.2670409745E-02 5.2445066626E-02 5.2220639656E-02 5.1997125495E-02 + 5.1774520812E-02 5.1552822285E-02 5.1332026600E-02 5.1112130454E-02 + 5.0893130552E-02 5.0675023609E-02 5.0457806348E-02 5.0241475502E-02 + 5.0026027814E-02 4.9811460034E-02 4.9597768924E-02 4.9384951252E-02 + 4.9173003797E-02 4.8961923347E-02 4.8751706700E-02 4.8542350661E-02 + 4.8333852045E-02 4.8126207678E-02 4.7919414392E-02 4.7713469031E-02 + 4.7508368445E-02 4.7304109497E-02 4.7100689055E-02 4.6898104000E-02 + 4.6696351218E-02 4.6495427608E-02 4.6295330076E-02 4.6096055536E-02 + 4.5897600915E-02 4.5699963144E-02 4.5503139167E-02 4.5307125934E-02 + 4.5111920408E-02 4.4917519557E-02 4.4723920360E-02 4.4531119804E-02 + 4.4339114887E-02 4.4147902613E-02 4.3957479998E-02 4.3767844065E-02 + 4.3578991846E-02 4.3390920383E-02 4.3203626727E-02 4.3017107936E-02 + 4.2831361079E-02 4.2646383234E-02 4.2462171485E-02 4.2278722929E-02 + 4.2096034669E-02 4.1914103817E-02 4.1732927496E-02 4.1552502835E-02 + 4.1372826975E-02 4.1193897062E-02 4.1015710255E-02 4.0838263718E-02 + 4.0661554627E-02 4.0485580164E-02 4.0310337522E-02 4.0135823901E-02 + 3.9962036512E-02 3.9788972572E-02 3.9616629308E-02 3.9445003956E-02 + 3.9274093762E-02 3.9103895977E-02 3.8934407863E-02 3.8765626692E-02 + 3.8597549742E-02 3.8430174301E-02 3.8263497666E-02 3.8097517141E-02 + 3.7932230040E-02 3.7767633686E-02 3.7603725409E-02 3.7440502548E-02 + 3.7277962452E-02 3.7116102477E-02 3.6954919987E-02 3.6794412357E-02 + 3.6634576968E-02 3.6475411210E-02 3.6316912483E-02 3.6159078194E-02 + 3.6001905758E-02 3.5845392601E-02 3.5689536153E-02 3.5534333858E-02 + 3.5379783163E-02 3.5225881526E-02 3.5072626414E-02 3.4920015302E-02 + 3.4768045671E-02 3.4616715013E-02 3.4466020827E-02 3.4315960621E-02 + 3.4166531911E-02 3.4017732221E-02 3.3869559083E-02 3.3722010038E-02 + 3.3575082634E-02 3.3428774429E-02 3.3283082987E-02 3.3138005883E-02 + 3.2993540696E-02 3.2849685017E-02 3.2706436444E-02 3.2563792582E-02 + 3.2421751045E-02 3.2280309455E-02 3.2139465441E-02 3.1999216642E-02 + 3.1859560703E-02 3.1720495278E-02 3.1582018030E-02 3.1444126628E-02 + 3.1306818749E-02 3.1170092081E-02 3.1033944315E-02 3.0898373154E-02 + 3.0763376307E-02 3.0628951491E-02 3.0495096431E-02 3.0361808861E-02 + 3.0229086520E-02 3.0096927158E-02 2.9965328531E-02 2.9834288402E-02 + 2.9703804544E-02 2.9573874736E-02 2.9444496765E-02 2.9315668426E-02 + 2.9187387521E-02 2.9059651861E-02 2.8932459264E-02 2.8805807555E-02 + 2.8679694567E-02 2.8554118141E-02 2.8429076124E-02 2.8304566374E-02 + 2.8180586752E-02 2.8057135130E-02 2.7934209387E-02 2.7811807407E-02 + 2.7689927084E-02 2.7568566319E-02 2.7447723020E-02 2.7327395102E-02 + 2.7207580488E-02 2.7088277109E-02 2.6969482902E-02 2.6851195812E-02 + 2.6733413792E-02 2.6616134800E-02 2.6499356804E-02 2.6383077778E-02 + 2.6267295703E-02 2.6152008568E-02 2.6037214368E-02 2.5922911107E-02 + 2.5809096794E-02 2.5695769448E-02 2.5582927092E-02 2.5470567758E-02 + 2.5358689485E-02 2.5247290318E-02 2.5136368310E-02 2.5025921521E-02 + 2.4915948018E-02 2.4806445875E-02 2.4697413172E-02 2.4588847998E-02 + 2.4480748448E-02 2.4373112622E-02 2.4265938630E-02 2.4159224587E-02 + 2.4052968615E-02 2.3947168845E-02 2.3841823412E-02 2.3736930458E-02 + 2.3632488134E-02 2.3528494597E-02 2.3424948009E-02 2.3321846541E-02 + 2.3219188369E-02 2.3116971677E-02 2.3015194655E-02 2.2913855501E-02 + 2.2812952416E-02 2.2712483613E-02 2.2612447307E-02 2.2512841722E-02 + 2.2413665088E-02 2.2314915642E-02 2.2216591626E-02 2.2118691290E-02 + 2.2021212890E-02 2.1924154690E-02 2.1827514958E-02 2.1731291969E-02 + 2.1635484006E-02 2.1540089357E-02 2.1445106317E-02 2.1350533187E-02 + 2.1256368274E-02 2.1162609894E-02 2.1069256365E-02 2.0976306014E-02 + 2.0883757174E-02 2.0791608185E-02 2.0699857391E-02 2.0608503145E-02 + 2.0517543803E-02 2.0426977731E-02 2.0336803297E-02 2.0247018880E-02 + 2.0157622860E-02 2.0068613626E-02 1.9979989575E-02 1.9891749105E-02 + 1.9803890624E-02 1.9716412545E-02 1.9629313287E-02 1.9542591275E-02 + 1.9456244940E-02 1.9370272718E-02 1.9284673053E-02 1.9199444394E-02 + 1.9114585195E-02 1.9030093917E-02 1.8945969026E-02 1.8862208995E-02 + 1.8778812303E-02 1.8695777433E-02 1.8613102875E-02 1.8530787125E-02 + 1.8448828685E-02 1.8367226062E-02 1.8285977768E-02 1.8205082323E-02 + 1.8124538251E-02 1.8044344082E-02 1.7964498352E-02 1.7884999602E-02 + 1.7805846380E-02 1.7727037239E-02 1.7648570735E-02 1.7570445434E-02 + 1.7492659905E-02 1.7415212723E-02 1.7338102469E-02 1.7261327728E-02 + 1.7184887092E-02 1.7108779158E-02 1.7033002528E-02 1.6957555811E-02 + 1.6882437620E-02 1.6807646573E-02 1.6733181296E-02 1.6659040416E-02 + 1.6585222569E-02 1.6511726396E-02 1.6438550541E-02 1.6365693656E-02 + 1.6293154397E-02 1.6220931425E-02 1.6149023406E-02 1.6077429013E-02 + 1.6006146923E-02 1.5935175817E-02 1.5864514384E-02 1.5794161316E-02 + 1.5724115310E-02 1.5654375070E-02 1.5584939304E-02 1.5515806724E-02 + 1.5446976049E-02 1.5378446002E-02 1.5310215311E-02 1.5242282710E-02 + 1.5174646937E-02 1.5107306735E-02 1.5040260852E-02 1.4973508042E-02 + 1.4907047063E-02 1.4840876679E-02 1.4774995656E-02 1.4709402768E-02 + 1.4644096793E-02 1.4579076513E-02 1.4514340716E-02 1.4449888194E-02 + 1.4385717745E-02 1.4321828170E-02 1.4258218275E-02 1.4194886873E-02 + 1.4131832780E-02 1.4069054816E-02 1.4006551807E-02 1.3944322584E-02 + 1.3882365982E-02 1.3820680839E-02 1.3759266001E-02 1.3698120316E-02 + 1.3637242639E-02 1.3576631826E-02 1.3516286742E-02 1.3456206253E-02 + 1.3396389231E-02 1.3336834552E-02 1.3277541098E-02 1.3218507754E-02 + 1.3159733410E-02 1.3101216960E-02 1.3042957303E-02 1.2984953342E-02 + 1.2927203985E-02 1.2869708144E-02 1.2812464736E-02 1.2755472682E-02 + 1.2698730906E-02 1.2642238338E-02 1.2585993913E-02 1.2529996568E-02 + 1.2474245247E-02 1.2418738895E-02 1.2363476464E-02 1.2308456909E-02 + 1.2253679190E-02 1.2199142271E-02 1.2144845120E-02 1.2090786709E-02 + 1.2036966013E-02 1.1983382015E-02 1.1930033698E-02 1.1876920052E-02 + 1.1824040069E-02 1.1771392746E-02 1.1718977085E-02 1.1666792091E-02 + 1.1614836773E-02 1.1563110144E-02 1.1511611222E-02 1.1460339028E-02 + 1.1409292587E-02 1.1358470929E-02 1.1307873087E-02 1.1257498099E-02 + 1.1207345005E-02 1.1157412852E-02 1.1107700686E-02 1.1058207563E-02 + 1.1008932539E-02 1.0959874673E-02 1.0911033032E-02 1.0862406683E-02 + 1.0813994699E-02 1.0765796155E-02 1.0717810132E-02 1.0670035713E-02 + 1.0622471986E-02 1.0575118041E-02 1.0527972974E-02 1.0481035883E-02 + 1.0434305871E-02 1.0387782044E-02 1.0341463511E-02 1.0295349386E-02 + 1.0249438786E-02 1.0203730832E-02 1.0158224648E-02 1.0112919362E-02 + 1.0067814105E-02 1.0022908014E-02 9.9782002257E-03 9.9336898836E-03 + 9.8893761334E-03 9.8452581244E-03 9.8013350096E-03 9.7576059455E-03 + 9.7140700919E-03 9.6707266124E-03 9.6275746738E-03 9.5846134465E-03 + 9.5418421044E-03 9.4992598248E-03 9.4568657881E-03 9.4146591787E-03 + 9.3726391839E-03 9.3308049946E-03 9.2891558051E-03 9.2476908128E-03 + 9.2064092188E-03 9.1653102273E-03 9.1243930459E-03 9.0836568854E-03 + 9.0431009601E-03 9.0027244873E-03 8.9625266878E-03 8.9225067856E-03 + 8.8826640079E-03 8.8429975852E-03 8.8035067510E-03 8.7641907423E-03 + 8.7250487991E-03 8.6860801647E-03 8.6472840855E-03 8.6086598110E-03 + 8.5702065940E-03 8.5319236903E-03 8.4938103588E-03 8.4558658617E-03 + 8.4180894641E-03 8.3804804341E-03 8.3430380433E-03 8.3057615659E-03 + 8.2686502793E-03 8.2317034641E-03 8.1949204037E-03 8.1583003846E-03 + 8.1218426963E-03 8.0855466312E-03 8.0494114850E-03 8.0134365559E-03 + 7.9776211454E-03 7.9419645578E-03 7.9064661004E-03 7.8711250833E-03 + 7.8359408196E-03 7.8009126254E-03 7.7660398194E-03 7.7313217234E-03 + 7.6967576621E-03 7.6623469628E-03 7.6280889559E-03 7.5939829745E-03 + 7.5600283546E-03 7.5262244349E-03 7.4925705569E-03 7.4590660650E-03 + 7.4257103063E-03 7.3925026307E-03 7.3594423907E-03 7.3265289418E-03 + 7.2937616420E-03 7.2611398522E-03 7.2286629359E-03 7.1963302592E-03 + 7.1641411912E-03 7.1320951033E-03 7.1001913699E-03 7.0684293678E-03 + 7.0368084767E-03 7.0053280786E-03 6.9739875583E-03 6.9427863035E-03 + 6.9117237039E-03 6.8807991523E-03 6.8500120439E-03 6.8193617764E-03 + 6.7888477502E-03 6.7584693681E-03 6.7282260356E-03 6.6981171607E-03 + 6.6681421538E-03 6.6383004279E-03 6.6085913985E-03 6.5790144837E-03 + 6.5495691038E-03 6.5202546818E-03 6.4910706430E-03 6.4620164155E-03 + 6.4330914294E-03 6.4042951174E-03 6.3756269148E-03 6.3470862590E-03 + 6.3186725900E-03 6.2903853502E-03 6.2622239843E-03 6.2341879394E-03 + 6.2062766650E-03 6.1784896129E-03 6.1508262372E-03 6.1232859946E-03 + 6.0958683438E-03 6.0685727459E-03 6.0413986644E-03 6.0143455652E-03 + 5.9874129161E-03 5.9606001876E-03 5.9339068522E-03 5.9073323847E-03 + 5.8808762624E-03 5.8545379644E-03 5.8283169725E-03 5.8022127704E-03 + 5.7762248441E-03 5.7503526818E-03 5.7245957740E-03 5.6989536133E-03 + 5.6734256944E-03 5.6480115144E-03 5.6227105723E-03 5.5975223695E-03 + 5.5724464092E-03 5.5474821972E-03 5.5226292410E-03 5.4978870505E-03 + 5.4732551376E-03 5.4487330162E-03 5.4243202025E-03 5.4000162147E-03 + 5.3758205730E-03 5.3517327997E-03 5.3277524192E-03 5.3038789580E-03 + 5.2801119445E-03 5.2564509092E-03 5.2328953846E-03 5.2094449054E-03 + 5.1860990080E-03 5.1628572310E-03 5.1397191149E-03 5.1166842023E-03 + 5.0937520376E-03 5.0709221674E-03 5.0481941400E-03 5.0255675058E-03 + 5.0030418172E-03 4.9806166283E-03 4.9582914955E-03 4.9360659767E-03 + 4.9139396319E-03 4.8919120232E-03 4.8699827142E-03 4.8481512708E-03 + 4.8264172603E-03 4.8047802524E-03 4.7832398183E-03 4.7617955311E-03 + 4.7404469659E-03 4.7191936995E-03 4.6980353106E-03 4.6769713797E-03 + 4.6560014891E-03 4.6351252230E-03 4.6143421673E-03 4.5936519098E-03 + 4.5730540399E-03 4.5525481490E-03 4.5321338301E-03 4.5118106780E-03 + 4.4915782895E-03 4.4714362628E-03 4.4513841980E-03 4.4314216969E-03 + 4.4115483631E-03 4.3917638019E-03 4.3720676203E-03 4.3524594269E-03 + 4.3329388322E-03 4.3135054483E-03 4.2941588889E-03 4.2748987695E-03 + 4.2557247072E-03 4.2366363209E-03 4.2176332309E-03 4.1987150595E-03 + 4.1798814303E-03 4.1611319686E-03 4.1424663017E-03 4.1238840580E-03 + 4.1053848678E-03 4.0869683631E-03 4.0686341772E-03 4.0503819453E-03 + 4.0322113040E-03 4.0141218915E-03 3.9961133477E-03 3.9781853139E-03 + 3.9603374331E-03 3.9425693498E-03 3.9248807100E-03 3.9072711615E-03 + 3.8897403532E-03 3.8722879358E-03 3.8549135617E-03 3.8376168843E-03 + 3.8203975591E-03 3.8032552427E-03 3.7861895933E-03 3.7692002707E-03 + 3.7522869360E-03 3.7354492519E-03 3.7186868827E-03 3.7019994939E-03 + 3.6853867525E-03 3.6688483273E-03 3.6523838880E-03 3.6359931063E-03 + 3.6196756548E-03 3.6034312080E-03 3.5872594415E-03 3.5711600326E-03 + 3.5551326596E-03 3.5391770027E-03 3.5232927432E-03 3.5074795638E-03 + 3.4917371486E-03 3.4760651832E-03 3.4604633546E-03 3.4449313509E-03 + 3.4294688618E-03 3.4140755783E-03 3.3987511928E-03 3.3834953989E-03 + 3.3683078917E-03 3.3531883676E-03 3.3381365243E-03 3.3231520608E-03 + 3.3082346775E-03 3.2933840760E-03 3.2785999594E-03 3.2638820318E-03 + 3.2492299989E-03 3.2346435676E-03 3.2201224459E-03 3.2056663434E-03 + 3.1912749706E-03 3.1769480397E-03 3.1626852639E-03 3.1484863576E-03 + 3.1343510366E-03 3.1202790179E-03 3.1062700198E-03 3.0923237617E-03 + 3.0784399643E-03 3.0646183497E-03 3.0508586409E-03 3.0371605624E-03 + 3.0235238397E-03 3.0099481997E-03 2.9964333702E-03 2.9829790806E-03 + 2.9695850613E-03 2.9562510437E-03 2.9429767606E-03 2.9297619460E-03 + 2.9166063350E-03 2.9035096638E-03 2.8904716698E-03 2.8774920917E-03 + 2.8645706691E-03 2.8517071429E-03 2.8389012552E-03 2.8261527491E-03 + 2.8134613689E-03 2.8008268600E-03 2.7882489689E-03 2.7757274432E-03 + 2.7632620318E-03 2.7508524845E-03 2.7384985522E-03 2.7261999871E-03 + 2.7139565422E-03 2.7017679718E-03 2.6896340313E-03 2.6775544770E-03 + 2.6655290665E-03 2.6535575582E-03 2.6416397118E-03 2.6297752881E-03 + 2.6179640485E-03 2.6062057561E-03 2.5945001746E-03 2.5828470689E-03 + 2.5712462048E-03 2.5596973493E-03 2.5482002705E-03 2.5367547372E-03 + 2.5253605195E-03 2.5140173884E-03 2.5027251160E-03 2.4914834752E-03 + 2.4802922402E-03 2.4691511860E-03 2.4580600886E-03 2.4470187251E-03 + 2.4360268735E-03 2.4250843126E-03 2.4141908227E-03 2.4033461844E-03 + 2.3925501799E-03 2.3818025919E-03 2.3711032043E-03 2.3604518019E-03 + 2.3498481703E-03 2.3392920964E-03 2.3287833677E-03 2.3183217728E-03 + 2.3079071012E-03 2.2975391433E-03 2.2872176905E-03 2.2769425351E-03 + 2.2667134703E-03 2.2565302902E-03 2.2463927898E-03 2.2363007651E-03 + 2.2262540130E-03 2.2162523310E-03 2.2062955180E-03 2.1963833734E-03 + 2.1865156976E-03 2.1766922919E-03 2.1669129585E-03 2.1571775005E-03 + 2.1474857217E-03 2.1378374271E-03 2.1282324221E-03 2.1186705134E-03 + 2.1091515084E-03 2.0996752151E-03 2.0902414429E-03 2.0808500014E-03 + 2.0715007016E-03 2.0621933551E-03 2.0529277742E-03 2.0437037722E-03 + 2.0345211633E-03 2.0253797624E-03 2.0162793852E-03 2.0072198483E-03 + 1.9982009690E-03 1.9892225655E-03 1.9802844569E-03 1.9713864629E-03 + 1.9625284042E-03 1.9537101020E-03 1.9449313786E-03 1.9361920570E-03 + 1.9274919609E-03 1.9188309149E-03 1.9102087443E-03 1.9016252751E-03 + 1.8930803342E-03 1.8845737493E-03 1.8761053488E-03 1.8676749618E-03 + 1.8592824182E-03 1.8509275487E-03 1.8426101848E-03 1.8343301586E-03 + 1.8260873030E-03 1.8178814517E-03 1.8097124392E-03 1.8015801004E-03 + 1.7934842713E-03 1.7854247886E-03 1.7774014894E-03 1.7694142119E-03 + 1.7614627949E-03 1.7535470778E-03 1.7456669007E-03 1.7378221047E-03 + 1.7300125313E-03 1.7222380229E-03 1.7144984224E-03 1.7067935736E-03 + 1.6991233209E-03 1.6914875093E-03 1.6838859848E-03 1.6763185937E-03 + 1.6687851832E-03 1.6612856012E-03 1.6538196962E-03 1.6463873173E-03 + 1.6389883145E-03 1.6316225382E-03 1.6242898397E-03 1.6169900707E-03 + 1.6097230839E-03 1.6024887324E-03 1.5952868700E-03 1.5881173512E-03 + 1.5809800310E-03 1.5738747654E-03 1.5668014107E-03 1.5597598239E-03 + 1.5527498627E-03 1.5457713855E-03 1.5388242511E-03 1.5319083193E-03 + 1.5250234501E-03 1.5181695044E-03 1.5113463436E-03 1.5045538299E-03 + 1.4977918258E-03 1.4910601947E-03 1.4843588004E-03 1.4776875076E-03 + 1.4710461812E-03 1.4644346870E-03 1.4578528913E-03 1.4513006610E-03 + 1.4447778635E-03 1.4382843671E-03 1.4318200403E-03 1.4253847523E-03 + 1.4189783732E-03 1.4126007732E-03 1.4062518234E-03 1.3999313953E-03 + 1.3936393611E-03 1.3873755935E-03 1.3811399658E-03 1.3749323518E-03 + 1.3687526260E-03 1.3626006632E-03 1.3564763392E-03 1.3503795299E-03 + 1.3443101119E-03 1.3382679625E-03 1.3322529594E-03 1.3262649808E-03 + 1.3203039056E-03 1.3143696132E-03 1.3084619835E-03 1.3025808968E-03 + 1.2967262342E-03 1.2908978772E-03 1.2850957078E-03 1.2793196085E-03 + 1.2735694625E-03 1.2678451533E-03 1.2621465650E-03 1.2564735824E-03 + 1.2508260905E-03 1.2452039750E-03 1.2396071221E-03 1.2340354185E-03 + 1.2284887514E-03 1.2229670085E-03 1.2174700779E-03 1.2119978484E-03 + 1.2065502091E-03 1.2011270498E-03 1.1957282606E-03 1.1903537322E-03 + 1.1850033557E-03 1.1796770228E-03 1.1743746257E-03 1.1690960569E-03 + 1.1638412095E-03 1.1586099771E-03 1.1534022537E-03 1.1482179339E-03 + 1.1430569126E-03 1.1379190853E-03 1.1328043479E-03 1.1277125968E-03 + 1.1226437289E-03 1.1175976415E-03 1.1125742323E-03 1.1075733995E-03 + 1.1025950419E-03 1.0976390587E-03 1.0927053492E-03 1.0877938137E-03 + 1.0829043526E-03 1.0780368668E-03 1.0731912577E-03 1.0683674271E-03 + 1.0635652773E-03 1.0587847109E-03 1.0540256311E-03 1.0492879413E-03 + 1.0445715457E-03 1.0398763486E-03 1.0352022549E-03 1.0305491698E-03 + 1.0259169990E-03 1.0213056486E-03 1.0167150252E-03 1.0121450358E-03 + 1.0075955876E-03 1.0030665885E-03 9.9855794668E-04 9.9406957072E-04 + 9.8960136966E-04 9.8515325290E-04 9.8072513028E-04 9.7631691203E-04 + 9.7192850877E-04 9.6755983154E-04 9.6321079177E-04 9.5888130129E-04 + 9.5457127231E-04 9.5028061745E-04 9.4600924971E-04 9.4175708249E-04 + + + + 1.3750506404E-01 1.3749200637E-01 1.3745284033E-01 1.3738758681E-01 + 1.3729628062E-01 1.3717897044E-01 1.3703571879E-01 1.3686660201E-01 + 1.3667171011E-01 1.3645114679E-01 1.3620502931E-01 1.3593348838E-01 + 1.3563666808E-01 1.3531472571E-01 1.3496783171E-01 1.3459616945E-01 + 1.3419993513E-01 1.3377933760E-01 1.3333459820E-01 1.3286595054E-01 + 1.3237364036E-01 1.3185792529E-01 1.3131907466E-01 1.3075736925E-01 + 1.3017310110E-01 1.2956657324E-01 1.2893809947E-01 1.2828800407E-01 + 1.2761662159E-01 1.2692429651E-01 1.2621138303E-01 1.2547824474E-01 + 1.2472525434E-01 1.2395279336E-01 1.2316125184E-01 1.2235102800E-01 + 1.2152252798E-01 1.2067616547E-01 1.1981236139E-01 1.1893154359E-01 + 1.1803414650E-01 1.1712061076E-01 1.1619138295E-01 1.1524691518E-01 + 1.1428766478E-01 1.1331409393E-01 1.1232666932E-01 1.1132586181E-01 + 1.1031214603E-01 1.0928600010E-01 1.0824790519E-01 1.0719834523E-01 + 1.0613780653E-01 1.0506677739E-01 1.0398574783E-01 1.0289520915E-01 + 1.0179565363E-01 1.0068757415E-01 9.9571463864E-02 9.8447815848E-02 + 9.7317122752E-02 9.6179876465E-02 9.5036567775E-02 9.3887686041E-02 + 9.2733718861E-02 9.1575151750E-02 9.0412467817E-02 8.9246147456E-02 + 8.8076668029E-02 8.6904503568E-02 8.5730124472E-02 8.4553997218E-02 + 8.3376584070E-02 8.2198342802E-02 8.1019726424E-02 7.9841182913E-02 + 7.8663154956E-02 7.7486079694E-02 7.6310388479E-02 7.5136506635E-02 + 7.3964853227E-02 7.2795840840E-02 7.1629875364E-02 7.0467355788E-02 + 6.9308674001E-02 6.8154214601E-02 6.7004354719E-02 6.5859463837E-02 + 6.4719903635E-02 6.3586027824E-02 6.2458182007E-02 6.1336703538E-02 + 6.0221921393E-02 5.9114156049E-02 5.8013719373E-02 5.6920914518E-02 + 5.5836035831E-02 5.4759368766E-02 5.3691189808E-02 5.2631766406E-02 + 5.1581356914E-02 5.0540210540E-02 4.9508567305E-02 4.8486658010E-02 + 4.7474704213E-02 4.6472918208E-02 4.5481503021E-02 4.4500652411E-02 + 4.3530550876E-02 4.2571373668E-02 4.1623286820E-02 4.0686447177E-02 + 3.9761002434E-02 3.8847091183E-02 3.7944842969E-02 3.7054378346E-02 + 3.6175808951E-02 3.5309237571E-02 3.4454758234E-02 3.3612456285E-02 + 3.2782408489E-02 3.1964683126E-02 3.1159340097E-02 3.0366431036E-02 + 2.9585999423E-02 2.8818080712E-02 2.8062702450E-02 2.7319884413E-02 + 2.6589638742E-02 2.5871970079E-02 2.5166875715E-02 2.4474345738E-02 + 2.3794363183E-02 2.3126904186E-02 2.2471938148E-02 2.1829427889E-02 + 2.1199329820E-02 2.0581594102E-02 1.9976164822E-02 1.9382980159E-02 + 1.8801972562E-02 1.8233068921E-02 1.7676190745E-02 1.7131254338E-02 + 1.6598170982E-02 1.6076847112E-02 1.5567184498E-02 1.5069080425E-02 + 1.4582427876E-02 1.4107115709E-02 1.3643028843E-02 1.3190048433E-02 + 1.2748052054E-02 1.2316913878E-02 1.1896504856E-02 1.1486692888E-02 + 1.1087343007E-02 1.0698317550E-02 1.0319476332E-02 9.9506768164E-03 + 9.5917742865E-03 9.2426220127E-03 8.9030714180E-03 8.5729722415E-03 + 8.2521726996E-03 7.9405196448E-03 7.6378587214E-03 7.3440345191E-03 + 7.0588907234E-03 6.7822702632E-03 6.5140154556E-03 6.2539681474E-03 + 6.0019698532E-03 5.7578618909E-03 5.5214855133E-03 5.2926820367E-03 + 5.0712929658E-03 4.8571601152E-03 4.6501257275E-03 4.4500325876E-03 + 4.2567241336E-03 4.0700445639E-03 3.8898389408E-03 3.7159532898E-03 + 3.5482346964E-03 3.3865313979E-03 3.2306928723E-03 3.0805699230E-03 + 2.9360147601E-03 2.7968810778E-03 2.6630241283E-03 2.5343007915E-03 + 2.4105696416E-03 2.2916910100E-03 2.1775270443E-03 2.0679417635E-03 + 1.9628011107E-03 1.8619730009E-03 1.7653273665E-03 1.6727361987E-03 + 1.5840735859E-03 1.4992157484E-03 1.4180410704E-03 1.3404301282E-03 + 1.2662657157E-03 1.1954328666E-03 1.1278188739E-03 1.0633133056E-03 + 1.0018080190E-03 9.4319717074E-04 8.8737722478E-04 8.3424695793E-04 + 7.8370746234E-04 7.3566214573E-04 6.9001672918E-04 6.4667924250E-04 + 6.0556001744E-04 5.6657167866E-04 5.2962913255E-04 4.9464955415E-04 + 4.6155237201E-04 4.3025925129E-04 4.0069407498E-04 3.7278292356E-04 + 3.4645405290E-04 3.2163787075E-04 2.9826691171E-04 2.7627581084E-04 + 2.5560127604E-04 2.3618205907E-04 2.1795892564E-04 2.0087462426E-04 + 1.8487385420E-04 1.6990323253E-04 1.5591126035E-04 1.4284828817E-04 + 1.3066648070E-04 1.1931978100E-04 1.0876387402E-04 9.8956149702E-05 + 8.9855665682E-05 8.1423109582E-05 7.3620761043E-05 6.6412453514E-05 + 5.9763535863E-05 5.3640833873E-05 4.8012611669E-05 4.2848533137E-05 + 3.8119623379E-05 3.3798230258E-05 2.9857986086E-05 2.6273769477E-05 + 2.3021667442E-05 2.0078937745E-05 1.7423971557E-05 1.5036256470E-05 + 1.2896339875E-05 1.0985792768E-05 9.2871739916E-06 7.7839949592E-06 + 6.4606848804E-06 5.3025565203E-06 4.2957725130E-06 3.4273122546E-06 + 2.6849393961E-06 2.0571699551E-06 1.5332410657E-06 1.1030803806E-06 + 7.5727614011E-07 4.8704792293E-07 2.8421808653E-07 1.4118390953E-07 + 5.0890443287E-08 6.8040784637E-09 2.8868339525E-09 3.3571370238E-08 + 9.3736730426E-08 1.7868481128E-07 2.8411756239E-07 4.0611491462E-07 + 5.4111343422E-07 6.8588569949E-07 8.3752039692E-07 9.9340312953E-07 + 1.1511979332E-06 1.3088294927E-06 1.4644660495E-06 1.6165029936E-06 + 1.7635471281E-06 1.9044015990E-06 2.0380514765E-06 2.1636499780E-06 + 2.2805053213E-06 2.3880681932E-06 2.4859198237E-06 2.5737606491E-06 + 2.6513995527E-06 2.7187436675E-06 2.7757887274E-06 2.8226099513E-06 + 2.8593534452E-06 2.8862281088E-06 2.9034980283E-06 2.9114753431E-06 + 2.9105135686E-06 2.9010013609E-06 2.8833567073E-06 2.8580215272E-06 + 2.8254566673E-06 2.7861372772E-06 2.7405485479E-06 2.6891818000E-06 + 2.6325309051E-06 2.5710890265E-06 2.5053456633E-06 2.4357839851E-06 + 2.3628784407E-06 2.2870926295E-06 2.2088774194E-06 2.1286692990E-06 + 2.0468889507E-06 1.9639400319E-06 1.8802081510E-06 1.7960600268E-06 + 1.7118428194E-06 1.6278836197E-06 1.5444890890E-06 1.4619452337E-06 + 1.3805173094E-06 1.3004498403E-06 1.2219667466E-06 1.1452715684E-06 + 1.0705477804E-06 9.9795918412E-07 9.2765037410E-07 8.5974726588E-07 + 7.9435768270E-07 7.3157198854E-07 6.7146376638E-07 6.1409052948E-07 + 5.5949446522E-07 5.0770320017E-07 4.5873058654E-07 4.1257749940E-07 + 3.6923264536E-07 3.2867337301E-07 2.9086648603E-07 2.5576905045E-07 + 2.2332919692E-07 1.9348691077E-07 1.6617481046E-07 1.4131890870E-07 + 1.1883935632E-07 9.8651164878E-08 8.0664907206E-08 6.4787393794E-08 + 5.0922323294E-08 3.8970906759E-08 2.8832463077E-08 2.0404986823E-08 + 1.3585685179E-08 8.2714866129E-09 4.3595173503E-09 1.7475492928E-09 + 3.3441553511E-10 2.0396986604E-11 7.0757752244E-10 2.3001700250E-09 + 4.7048124506E-09 7.8308350552E-09 1.1590499421E-08 1.5899209415E-08 + 2.0675695875E-08 2.5842174494E-08 3.1324479388E-08 3.7052171678E-08 + 4.2958625483E-08 4.8981091353E-08 5.5060738759E-08 6.1142678536E-08 + 6.7175966325E-08 7.3113588302E-08 7.8912430171E-08 8.4533230560E-08 + 8.9940520126E-08 9.5102547150E-08 9.9991191132E-08 1.0458186515E-07 + 1.0885340820E-07 1.1278796872E-07 1.1637087985E-07 1.1959052823E-07 + 1.2243821632E-07 1.2490802019E-07 1.2699664291E-07 1.2870326475E-07 + 1.3002939128E-07 1.3097869934E-07 1.3155688294E-07 1.3177149829E-07 + 1.3163181005E-07 1.3114863853E-07 1.3033420855E-07 1.2920200132E-07 + 1.2776660825E-07 1.2604358922E-07 1.2404933388E-07 1.2180092741E-07 + 1.1931602117E-07 1.1661270748E-07 1.1370940051E-07 1.1062472172E-07 + 1.0737739143E-07 1.0398612616E-07 1.0046954129E-07 9.6846060742E-08 + 9.3133831705E-08 8.9350646208E-08 8.5513868630E-08 8.1640369020E-08 + 7.7746463144E-08 7.3847857879E-08 6.9959603011E-08 6.6096048758E-08 + 6.2270808731E-08 5.8496728947E-08 5.4785861763E-08 5.1149445328E-08 + 4.7597888045E-08 4.4140757667E-08 4.0786775330E-08 3.7543813744E-08 + 3.4418899669E-08 3.1418220377E-08 2.8547133709E-08 2.5810181719E-08 + 2.3211107476E-08 2.0752874866E-08 1.8437691095E-08 1.6267031761E-08 + 1.4241668067E-08 1.2361696074E-08 1.0626567816E-08 9.0351237379E-09 + 7.5856266571E-09 6.2757967024E-09 5.1028470220E-09 4.0635204485E-09 + 3.1541262679E-09 2.3705774301E-09 1.7084279773E-09 1.1629100026E-09 + 7.2897072664E-10 4.0130899371E-10 1.7441104051E-10 4.2585979570E-11 + 1.8223191830E-17 4.0709864269E-11 1.5869537179E-10 3.4789048803E-10 + 6.0221337189E-10 9.1559515490E-10 1.2820069991E-09 1.6954861297E-09 + 2.1501601094E-09 2.6402694891E-09 3.1601892761E-09 3.7044483736E-09 + 4.2677475497E-09 4.8449760665E-09 5.4312262051E-09 6.0218064991E-09 + 6.6122534161E-09 7.1983411618E-09 7.7760902202E-09 8.3417743039E-09 + 8.8919256752E-09 9.4233392568E-09 9.9330752196E-09 1.0418460188E-08 + 1.0877087327E-08 1.1306815047E-08 1.1705764581E-08 1.2072316537E-08 + 1.2405106311E-08 1.2703018567E-08 1.2965180853E-08 1.3190956323E-08 + 1.3379935738E-08 1.3531928746E-08 1.3646954572E-08 1.3725232139E-08 + 1.3767169667E-08 1.3773353944E-08 1.3744539188E-08 1.3681635585E-08 + 1.3585697746E-08 1.3457912889E-08 1.3299588912E-08 1.3112142572E-08 + 1.2897087552E-08 1.2656022576E-08 1.2390619822E-08 1.2102613343E-08 + 1.1793787691E-08 1.1465966982E-08 1.1121004093E-08 1.0760770158E-08 + 1.0387144652E-08 1.0002005679E-08 9.6072206538E-09 9.2046376558E-09 + 8.7960770768E-09 8.3833236864E-09 7.9681194553E-09 7.5521567209E-09 + 7.1370717789E-09 6.7244392796E-09 6.3157670014E-09 5.9124910303E-09 + 5.5159717644E-09 5.1274903002E-09 4.7482452143E-09 4.3793501270E-09 + 4.0218316461E-09 3.6766277118E-09 3.3445866024E-09 3.0264663451E-09 + 2.7229344997E-09 2.4345684793E-09 2.1618562728E-09 1.9051975060E-09 + 1.6649049152E-09 1.4412061961E-09 1.2342461414E-09 1.0440890910E-09 + 8.7072673784E-10 7.1408512503E-10 5.7396241464E-10 4.5012492990E-10 + 3.4230731604E-10 2.5017138755E-10 1.7334414882E-10 1.1100670315E-10 + 6.3116983888E-11 2.9351462843E-11 9.2818579740E-12 5.8266827145E-13 + -1.1544228735E-12 8.8052949246E-14 5.7262274575E-13 5.9121122769E-13 + 6.8861326627E-14 2.3152393237E-14 1.2321675525E-14 2.2109321896E-16 + -2.6001540603E-14 -4.4133023940E-14 -2.6962129438E-14 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 0.0000000000E+00 + + + 0.0000000000E+00 8.6685331427E-07 3.4906098754E-06 7.9409145930E-06 + 1.4334025403E-05 2.2833086389E-05 3.3648507156E-05 4.7038445477E-05 + 6.3309389419E-05 8.2816834383E-05 1.0596604973E-04 1.3321292891E-04 + 1.6506491644E-04 2.0208200428E-04 2.4487778973E-04 2.9412058641E-04 + 3.5053457918E-04 4.1490101394E-04 4.8805941225E-04 5.7090880087E-04 + 6.6440894599E-04 7.6958158136E-04 8.8751162007E-04 1.0193483388E-03 + 1.1663065240E-03 1.3296675695E-03 1.5107805140E-03 1.7110630085E-03 + 1.9320022034E-03 2.1751555441E-03 2.4421514653E-03 2.7346899749E-03 + 3.0545431167E-03 3.4035553034E-03 3.7836435103E-03 4.1967973219E-03 + 4.6450788219E-03 5.1306223194E-03 5.6556339039E-03 6.2223908209E-03 + 6.8332406626E-03 7.4906003657E-03 8.1969550124E-03 8.9548564272E-03 + 9.7669215653E-03 1.0635830688E-02 1.1564325322E-02 1.2555205996E-02 + 1.3611329754E-02 1.4735607445E-02 1.5931000781E-02 1.7200519167E-02 + 1.8547216302E-02 1.9974186548E-02 2.1484561073E-02 2.3081503759E-02 + 2.4768206895E-02 2.6547886636E-02 2.8423778253E-02 3.0399131161E-02 + 3.2477203744E-02 3.4661257977E-02 3.6954553847E-02 3.9360343600E-02 + 4.1881865800E-02 4.4522339228E-02 4.7284956626E-02 5.0172878290E-02 + 5.3189225552E-02 5.6337074125E-02 5.9619447368E-02 6.3039309457E-02 + 6.6599558493E-02 7.0303019567E-02 7.4152437788E-02 7.8150471308E-02 + 8.2299684361E-02 8.6602540324E-02 9.1061394846E-02 9.5678489042E-02 + 1.0045594279E-01 1.0539574814E-01 1.1049976291E-01 1.1576970435E-01 + 1.2120714311E-01 1.2681349736E-01 1.3259002714E-01 1.3853782895E-01 + 1.4465783069E-01 1.5095078683E-01 1.5741727388E-01 1.6405768627E-01 + 1.7087223250E-01 1.7786093170E-01 1.8502361060E-01 1.9235990077E-01 + 1.9986923646E-01 2.0755085267E-01 2.1540378375E-01 2.2342686240E-01 + 2.3161871912E-01 2.3997778209E-01 2.4850227746E-01 2.5719023014E-01 + 2.6603946499E-01 2.7504760841E-01 2.8421209046E-01 2.9353014725E-01 + 3.0299882388E-01 3.1261497767E-01 3.2237528186E-01 3.3227622956E-01 + 3.4231413821E-01 3.5248515420E-01 3.6278525797E-01 3.7321026928E-01 + 3.8375585282E-01 3.9441752403E-01 4.0519065523E-01 4.1607048184E-01 + 4.2705210890E-01 4.3813051769E-01 4.4930057248E-01 4.6055702747E-01 + 4.7189453370E-01 4.8330764619E-01 4.9479083098E-01 5.0633847230E-01 + 5.1794487971E-01 5.2960429526E-01 5.4131090055E-01 5.5305882385E-01 + 5.6484214709E-01 5.7665491280E-01 5.8849113099E-01 6.0034478586E-01 + 6.1220984251E-01 6.2408025344E-01 6.3594996502E-01 6.4781292373E-01 + 6.5966308240E-01 6.7149440620E-01 6.8330087857E-01 6.9507650702E-01 + 7.0681532878E-01 7.1851141629E-01 7.3015888268E-01 7.4175188701E-01 + 7.5328463948E-01 7.6475140652E-01 7.7614651575E-01 7.8746436088E-01 + 7.9869940656E-01 8.0984619306E-01 8.2089934100E-01 8.3185355593E-01 + 8.4270363291E-01 8.5344446101E-01 8.6407102781E-01 8.7457842384E-01 + 8.8496184699E-01 8.9521660690E-01 9.0533812934E-01 9.1532196055E-01 + 9.2516377159E-01 9.3485936259E-01 9.4440466714E-01 9.5379575644E-01 + 9.6302884361E-01 9.7210028785E-01 9.8100659862E-01 9.8974443971E-01 + 9.9831063332E-01 1.0067021640E+00 1.0149161827E+00 1.0229500102E+00 + 1.0308011413E+00 1.0384672481E+00 1.0459461835E+00 1.0532359844E+00 + 1.0603348752E+00 1.0672412704E+00 1.0739537775E+00 1.0804711996E+00 + 1.0867925377E+00 1.0929169930E+00 1.0988439686E+00 1.1045730714E+00 + 1.1101041129E+00 1.1154371109E+00 1.1205722897E+00 1.1255100807E+00 + 1.1302511227E+00 1.1347962609E+00 1.1391465311E+00 1.1433031184E+00 + 1.1472673110E+00 1.1510404811E+00 1.1546240701E+00 1.1580195762E+00 + 1.1612285540E+00 1.1642526143E+00 1.1670934185E+00 1.1697526770E+00 + 1.1722321466E+00 1.1745336277E+00 1.1766589623E+00 1.1786100311E+00 + 1.1803887518E+00 1.1819970762E+00 1.1834369888E+00 1.1847105038E+00 + 1.1858196638E+00 1.1867665373E+00 1.1875532171E+00 1.1881818181E+00 + 1.1886544755E+00 1.1889733432E+00 1.1891405919E+00 1.1891584075E+00 + 1.1890289893E+00 1.1887545484E+00 1.1883373065E+00 1.1877794938E+00 + 1.1870833482E+00 1.1862511134E+00 1.1852850375E+00 1.1841873722E+00 + 1.1829603708E+00 1.1816062877E+00 1.1801273766E+00 1.1785258894E+00 + 1.1768040757E+00 1.1749641807E+00 1.1730084452E+00 1.1709391038E+00 + 1.1687583843E+00 1.1664685068E+00 1.1640716826E+00 1.1615701136E+00 + 1.1589659911E+00 1.1562614954E+00 1.1534587950E+00 1.1505600454E+00 + 1.1475673890E+00 1.1444829543E+00 1.1413088549E+00 1.1380471894E+00 + 1.1347000404E+00 1.1312694744E+00 1.1277575409E+00 1.1241662719E+00 + 1.1204976819E+00 1.1167537670E+00 1.1129365046E+00 1.1090478532E+00 + 1.1050897517E+00 1.1010641195E+00 1.0969728559E+00 1.0928178396E+00 + 1.0886009291E+00 1.0843239617E+00 1.0799887537E+00 1.0755971001E+00 + 1.0711507745E+00 1.0666515287E+00 1.0621010927E+00 1.0575011746E+00 + 1.0528534602E+00 1.0481596134E+00 1.0434212755E+00 1.0386400658E+00 + 1.0338175808E+00 1.0289553947E+00 1.0240550594E+00 1.0191181038E+00 + 1.0141460348E+00 1.0091403363E+00 1.0041024700E+00 9.9903387498E-01 + 9.9393596794E-01 9.8881014312E-01 9.8365777245E-01 9.7848020556E-01 + 9.7327876991E-01 9.6805477083E-01 9.6280949162E-01 9.5754419367E-01 + 9.5226011658E-01 9.4695847821E-01 9.4164047488E-01 9.3630728145E-01 + 9.3096005149E-01 9.2559991737E-01 9.2022799048E-01 9.1484536131E-01 + 9.0945309965E-01 9.0405225475E-01 8.9864385545E-01 8.9322891041E-01 + 8.8780840823E-01 8.8238331765E-01 8.7695458775E-01 8.7152314809E-01 + 8.6608990895E-01 8.6065576146E-01 8.5522157787E-01 8.4978821167E-01 + 8.4435649784E-01 8.3892725301E-01 8.3350127569E-01 8.2807934648E-01 + 8.2266222825E-01 8.1725066633E-01 8.1184538879E-01 8.0644710655E-01 + 8.0105651368E-01 7.9567428754E-01 7.9030108904E-01 7.8493756282E-01 + 7.7958433746E-01 7.7424202573E-01 7.6891122473E-01 7.6359251620E-01 + 7.5828646662E-01 7.5299362751E-01 7.4771453561E-01 7.4244971306E-01 + 7.3719966766E-01 7.3196489306E-01 7.2674586894E-01 7.2154306126E-01 + 7.1635692245E-01 7.1118789162E-01 7.0603639476E-01 7.0090284492E-01 + 6.9578764247E-01 6.9069117527E-01 6.8561381884E-01 6.8055593664E-01 + 6.7551788017E-01 6.7049998924E-01 6.6550259215E-01 6.6052600587E-01 + 6.5557053622E-01 6.5063647811E-01 6.4572411569E-01 6.4083372254E-01 + 6.3596556187E-01 6.3111988670E-01 6.2629694005E-01 6.2149695512E-01 + 6.1672015544E-01 6.1196675510E-01 6.0723695888E-01 6.0253096247E-01 + 5.9784895261E-01 5.9319110725E-01 5.8855759576E-01 5.8394857907E-01 + 5.7936420985E-01 5.7480463266E-01 5.7026998412E-01 5.6576039307E-01 + 5.6127598074E-01 5.5681686088E-01 5.5238313993E-01 5.4797491719E-01 + 5.4359228493E-01 5.3923532858E-01 5.3490412685E-01 5.3059875191E-01 + 5.2631926948E-01 5.2206573901E-01 5.1783821382E-01 5.1363674123E-01 + 5.0946136267E-01 5.0531211389E-01 5.0118902498E-01 4.9709212062E-01 + 4.9302142011E-01 4.8897693756E-01 4.8495868198E-01 4.8096665744E-01 + 4.7700086314E-01 4.7306129358E-01 4.6914793864E-01 4.6526078372E-01 + 4.6139980984E-01 4.5756499377E-01 4.5375630811E-01 4.4997372145E-01 + 4.4621719841E-01 4.4248669980E-01 4.3878218271E-01 4.3510360059E-01 + 4.3145090339E-01 4.2782403761E-01 4.2422294645E-01 4.2064756986E-01 + 4.1709784466E-01 4.1357370464E-01 4.1007508060E-01 4.0660190052E-01 + 4.0315408957E-01 3.9973157025E-01 3.9633426243E-01 3.9296208347E-01 + 3.8961494829E-01 3.8629276946E-01 3.8299545723E-01 3.7972291967E-01 + 3.7647506271E-01 3.7325179024E-01 3.7005300413E-01 3.6687860437E-01 + 3.6372848908E-01 3.6060255463E-01 3.5750069567E-01 3.5442280520E-01 + 3.5136877466E-01 3.4833849396E-01 3.4533185156E-01 3.4234873454E-01 + 3.3938902863E-01 3.3645261830E-01 3.3353938679E-01 3.3064921620E-01 + 3.2778198750E-01 3.2493758062E-01 3.2211587447E-01 3.1931674704E-01 + 3.1654007539E-01 3.1378573574E-01 3.1105360351E-01 3.0834355336E-01 + 3.0565545924E-01 3.0298919442E-01 3.0034463155E-01 2.9772164272E-01 + 2.9512009946E-01 2.9253987280E-01 2.8998083332E-01 2.8744285116E-01 + 2.8492579611E-01 2.8242953758E-01 2.7995394469E-01 2.7749888627E-01 + 2.7506423092E-01 2.7264984701E-01 2.7025560276E-01 2.6788136624E-01 + 2.6552700538E-01 2.6319238805E-01 2.6087738207E-01 2.5858185520E-01 + 2.5630567524E-01 2.5404870999E-01 2.5181082731E-01 2.4959189514E-01 + 2.4739178153E-01 2.4521035463E-01 2.4304748277E-01 2.4090303445E-01 + 2.3877687835E-01 2.3666888336E-01 2.3457891863E-01 2.3250685355E-01 + 2.3045255780E-01 2.2841590132E-01 2.2639675441E-01 2.2439498767E-01 + 2.2241047205E-01 2.2044307887E-01 2.1849267982E-01 2.1655914700E-01 + 2.1464235291E-01 2.1274217047E-01 2.1085847306E-01 2.0899113447E-01 + 2.0714002901E-01 2.0530503141E-01 2.0348601693E-01 2.0168286132E-01 + 1.9989544082E-01 1.9812363222E-01 1.9636731284E-01 1.9462636052E-01 + 1.9290065368E-01 1.9119007128E-01 1.8949449285E-01 1.8781379851E-01 + 1.8614786896E-01 1.8449658550E-01 1.8285983001E-01 1.8123748501E-01 + 1.7962943359E-01 1.7803555951E-01 1.7645574711E-01 1.7488988140E-01 + 1.7333784800E-01 1.7179953319E-01 1.7027482388E-01 1.6876360765E-01 + 1.6726577271E-01 1.6578120796E-01 1.6430980294E-01 1.6285144787E-01 + 1.6140603363E-01 1.5997345178E-01 1.5855359454E-01 1.5714635483E-01 + 1.5575162623E-01 1.5436930302E-01 1.5299928014E-01 1.5164145324E-01 + 1.5029571864E-01 1.4896197336E-01 1.4764011509E-01 1.4633004223E-01 + 1.4503165386E-01 1.4374484975E-01 1.4246953037E-01 1.4120559687E-01 + 1.3995295110E-01 1.3871149559E-01 1.3748113358E-01 1.3626176898E-01 + 1.3505330639E-01 1.3385565113E-01 1.3266870917E-01 1.3149238718E-01 + 1.3032659253E-01 1.2917123326E-01 1.2802621810E-01 1.2689145645E-01 + 1.2576685841E-01 1.2465233475E-01 1.2354779691E-01 1.2245315701E-01 + 1.2136832786E-01 1.2029322291E-01 1.1922775631E-01 1.1817184285E-01 + 1.1712539801E-01 1.1608833791E-01 1.1506057935E-01 1.1404203976E-01 + 1.1303263727E-01 1.1203229061E-01 1.1104091919E-01 1.1005844307E-01 + 1.0908478293E-01 1.0811986012E-01 1.0716359661E-01 1.0621591500E-01 + 1.0527673853E-01 1.0434599108E-01 1.0342359714E-01 1.0250948183E-01 + 1.0160357088E-01 1.0070579065E-01 9.9816068097E-02 9.8934330802E-02 + 9.8060506945E-02 9.7194525308E-02 9.6336315275E-02 9.5485806823E-02 + 9.4642930523E-02 9.3807617533E-02 9.2979799599E-02 9.2159409046E-02 + 9.1346378777E-02 9.0540642272E-02 8.9742133578E-02 8.8950787313E-02 + 8.8166538656E-02 8.7389323347E-02 8.6619077680E-02 8.5855738506E-02 + 8.5099243221E-02 8.4349529766E-02 8.3606536626E-02 8.2870202822E-02 + 8.2140467910E-02 8.1417271974E-02 8.0700555628E-02 7.9990260006E-02 + 7.9286326761E-02 7.8588698064E-02 7.7897316596E-02 7.7212125545E-02 + 7.6533068604E-02 7.5860089966E-02 7.5193134323E-02 7.4532146858E-02 + 7.3877073242E-02 7.3227859634E-02 7.2584452675E-02 7.1946799483E-02 + 7.1314847650E-02 7.0688545240E-02 7.0067840785E-02 6.9452683280E-02 + 6.8843022178E-02 6.8238807391E-02 6.7639989282E-02 6.7046518664E-02 + 6.6458346795E-02 6.5875425376E-02 6.5297706544E-02 6.4725142873E-02 + 6.4157687368E-02 6.3595293461E-02 6.3037915008E-02 6.2485506286E-02 + 6.1938021990E-02 6.1395417229E-02 6.0857647521E-02 6.0324668790E-02 + 5.9796437368E-02 5.9272909982E-02 5.8754043758E-02 5.8239796217E-02 + 5.7730125266E-02 5.7224989202E-02 5.6724346705E-02 5.6228156834E-02 + 5.5736379025E-02 5.5248973088E-02 5.4765899204E-02 5.4287117919E-02 + 5.3812590146E-02 5.3342277157E-02 5.2876140580E-02 5.2414142402E-02 + 5.1956244957E-02 5.1502410929E-02 5.1052603347E-02 5.0606785584E-02 + 5.0164921349E-02 4.9726974689E-02 4.9292909983E-02 4.8862691942E-02 + 4.8436285603E-02 4.8013656327E-02 4.7594769796E-02 4.7179592012E-02 + 4.6768089292E-02 4.6360228265E-02 4.5955975870E-02 4.5555299355E-02 + 4.5158166270E-02 4.4764544466E-02 4.4374402097E-02 4.3987707608E-02 + 4.3604429741E-02 4.3224537528E-02 4.2848000286E-02 4.2474787622E-02 + 4.2104869423E-02 4.1738215857E-02 4.1374797369E-02 4.1014584679E-02 + 4.0657548781E-02 4.0303660937E-02 3.9952892678E-02 3.9605215799E-02 + 3.9260602357E-02 3.8919024672E-02 3.8580455318E-02 3.8244867126E-02 + 3.7912233180E-02 3.7582526814E-02 3.7255721611E-02 3.6931791399E-02 + 3.6610710251E-02 3.6292452479E-02 3.5976992635E-02 3.5664305509E-02 + 3.5354366125E-02 3.5047149737E-02 3.4742631833E-02 3.4440788126E-02 + 3.4141594556E-02 3.3845027287E-02 3.3551062705E-02 3.3259677413E-02 + 3.2970848235E-02 3.2684552208E-02 3.2400766583E-02 3.2119468821E-02 + 3.1840636596E-02 3.1564247785E-02 3.1290280474E-02 3.1018712949E-02 + 3.0749523701E-02 3.0482691418E-02 3.0218194987E-02 2.9956013489E-02 + 2.9696126202E-02 2.9438512594E-02 2.9183152323E-02 2.8930025237E-02 + 2.8679111370E-02 2.8430390940E-02 2.8183844348E-02 2.7939452179E-02 + 2.7697195196E-02 2.7457054338E-02 2.7219010723E-02 2.6983045644E-02 + 2.6749140563E-02 2.6517277117E-02 2.6287437112E-02 2.6059602521E-02 + 2.5833755483E-02 2.5609878303E-02 2.5387953449E-02 2.5167963551E-02 + 2.4949891397E-02 2.4733719936E-02 2.4519432274E-02 2.4307011670E-02 + 2.4096441540E-02 2.3887705452E-02 2.3680787123E-02 2.3475670423E-02 + 2.3272339367E-02 2.3070778119E-02 2.2870970989E-02 2.2672902429E-02 + 2.2476557034E-02 2.2281919543E-02 2.2088974831E-02 2.1897707914E-02 + 2.1708103945E-02 2.1520148213E-02 2.1333826142E-02 2.1149123289E-02 + 2.0966025342E-02 2.0784518122E-02 2.0604587578E-02 2.0426219788E-02 + 2.0249400958E-02 2.0074117419E-02 1.9900355626E-02 1.9728102158E-02 + 1.9557343719E-02 1.9388067130E-02 1.9220259335E-02 1.9053907396E-02 + 1.8888998492E-02 1.8725519921E-02 1.8563459093E-02 1.8402803535E-02 + 1.8243540888E-02 1.8085658902E-02 1.7929145442E-02 1.7773988481E-02 + 1.7620176101E-02 1.7467696493E-02 1.7316537954E-02 1.7166688889E-02 + 1.7018137805E-02 1.6870873316E-02 1.6724884137E-02 1.6580159086E-02 + 1.6436687082E-02 1.6294457143E-02 1.6153458389E-02 1.6013680035E-02 + 1.5875111396E-02 1.5737741881E-02 1.5601560995E-02 1.5466558341E-02 + 1.5332723610E-02 1.5200046590E-02 1.5068517159E-02 1.4938125288E-02 + 1.4808861035E-02 1.4680714551E-02 1.4553676073E-02 1.4427735926E-02 + 1.4302884523E-02 1.4179112362E-02 1.4056410026E-02 1.3934768184E-02 + 1.3814177586E-02 1.3694629068E-02 1.3576113546E-02 1.3458622017E-02 + 1.3342145559E-02 1.3226675332E-02 1.3112202572E-02 1.2998718594E-02 + 1.2886214791E-02 1.2774682633E-02 1.2664113666E-02 1.2554499512E-02 + 1.2445831865E-02 1.2338102496E-02 1.2231303249E-02 1.2125426039E-02 + 1.2020462854E-02 1.1916405754E-02 1.1813246867E-02 1.1710978394E-02 + 1.1609592603E-02 1.1509081833E-02 1.1409438489E-02 1.1310655043E-02 + 1.1212724037E-02 1.1115638076E-02 1.1019389830E-02 1.0923972038E-02 + 1.0829377499E-02 1.0735599079E-02 1.0642629704E-02 1.0550462365E-02 + 1.0459090114E-02 1.0368506066E-02 1.0278703393E-02 1.0189675331E-02 + 1.0101415174E-02 1.0013916277E-02 9.9271720505E-03 9.8411759656E-03 + 9.7559215502E-03 9.6714023890E-03 9.5876121237E-03 9.5045444515E-03 + 9.4221931253E-03 9.3405519529E-03 9.2596147968E-03 9.1793755730E-03 + 9.0998282514E-03 9.0209668547E-03 8.9427854579E-03 8.8652781884E-03 + 8.7884392249E-03 8.7122627972E-03 8.6367431857E-03 8.5618747209E-03 + 8.4876517832E-03 8.4140688019E-03 8.3411202554E-03 8.2688006702E-03 + 8.1971046208E-03 8.1260267292E-03 8.0555616644E-03 7.9857041420E-03 + 7.9164489237E-03 7.8477908172E-03 7.7797246754E-03 7.7122453960E-03 + 7.6453479215E-03 7.5790272385E-03 7.5132783771E-03 7.4480964110E-03 + 7.3834764567E-03 7.3194136732E-03 7.2559032620E-03 7.1929404660E-03 + 7.1305205698E-03 7.0686388988E-03 7.0072908194E-03 6.9464717380E-03 + 6.8861771012E-03 6.8264023950E-03 6.7671431447E-03 6.7083949145E-03 + 6.6501533071E-03 6.5924139635E-03 6.5351725625E-03 6.4784248202E-03 + 6.4221664902E-03 6.3663933628E-03 6.3111012648E-03 6.2562860591E-03 + 6.2019436446E-03 6.1480699557E-03 6.0946609620E-03 6.0417126682E-03 + 5.9892211132E-03 5.9371823706E-03 5.8855925477E-03 5.8344477857E-03 + 5.7837442590E-03 5.7334781753E-03 5.6836457748E-03 5.6342433306E-03 + 5.5852671477E-03 5.5367135630E-03 5.4885789454E-03 5.4408596948E-03 + 5.3935522424E-03 5.3466530500E-03 5.3001586103E-03 5.2540654459E-03 + 5.2083701097E-03 5.1630691841E-03 5.1181592811E-03 5.0736370419E-03 + 5.0294991367E-03 4.9857422643E-03 4.9423631520E-03 4.8993585554E-03 + 4.8567252580E-03 4.8144600708E-03 4.7725598325E-03 4.7310214091E-03 + 4.6898416932E-03 4.6490176045E-03 4.6085460892E-03 4.5684241194E-03 + 4.5286486938E-03 4.4892168364E-03 4.4501255972E-03 4.4113720514E-03 + 4.3729532991E-03 4.3348664659E-03 4.2971087015E-03 4.2596771805E-03 + 4.2225691016E-03 4.1857816877E-03 4.1493121853E-03 4.1131578649E-03 + 4.0773160201E-03 4.0417839680E-03 4.0065590485E-03 3.9716386245E-03 + 3.9370200816E-03 3.9027008276E-03 3.8686782926E-03 3.8349499290E-03 + 3.8015132108E-03 3.7683656337E-03 3.7355047149E-03 3.7029279930E-03 + 3.6706330275E-03 3.6386173990E-03 3.6068787087E-03 3.5754145785E-03 + 3.5442226506E-03 3.5133005873E-03 3.4826460713E-03 3.4522568047E-03 + 3.4221305096E-03 3.3922649274E-03 3.3626578191E-03 3.3333069646E-03 + 3.3042101629E-03 3.2753652321E-03 3.2467700086E-03 3.2184223476E-03 + 3.1903201224E-03 3.1624612248E-03 3.1348435645E-03 3.1074650691E-03 + 3.0803236839E-03 3.0534173718E-03 3.0267441132E-03 3.0003019057E-03 + 2.9740887642E-03 2.9481027202E-03 2.9223418226E-03 2.8968041364E-03 + 2.8714877436E-03 2.8463907424E-03 2.8215112473E-03 2.7968473889E-03 + 2.7723973139E-03 2.7481591847E-03 2.7241311796E-03 2.7003114922E-03 + 2.6766983319E-03 2.6532899230E-03 2.6300845054E-03 2.6070803337E-03 + 2.5842756777E-03 2.5616688218E-03 2.5392580651E-03 2.5170417213E-03 + 2.4950181185E-03 2.4731855991E-03 2.4515425195E-03 2.4300872505E-03 + 2.4088181765E-03 2.3877336958E-03 2.3668322206E-03 2.3461121762E-03 + 2.3255720019E-03 2.3052101500E-03 2.2850250861E-03 2.2650152889E-03 + 2.2451792501E-03 2.2255154745E-03 2.2060224793E-03 2.1866987946E-03 + 2.1675429631E-03 2.1485535399E-03 2.1297290923E-03 2.1110682001E-03 + 2.0925694551E-03 2.0742314611E-03 2.0560528339E-03 2.0380322011E-03 + 2.0201682020E-03 2.0024594876E-03 1.9849047204E-03 1.9675025743E-03 + 1.9502517346E-03 1.9331508977E-03 1.9161987713E-03 1.8993940741E-03 + 1.8827355357E-03 1.8662218966E-03 1.8498519081E-03 1.8336243319E-03 + 1.8175379408E-03 1.8015915176E-03 1.7857838558E-03 1.7701137591E-03 + 1.7545800414E-03 1.7391815268E-03 1.7239170495E-03 1.7087854534E-03 + 1.6937855927E-03 1.6789163311E-03 1.6641765421E-03 1.6495651088E-03 + 1.6350809239E-03 1.6207228896E-03 1.6064899173E-03 1.5923809279E-03 + 1.5783948514E-03 1.5645306272E-03 1.5507872034E-03 1.5371635373E-03 + 1.5236585953E-03 1.5102713522E-03 1.4970007919E-03 1.4838459069E-03 + 1.4708056983E-03 1.4578791759E-03 1.4450653577E-03 1.4323632702E-03 + 1.4197719484E-03 1.4072904353E-03 1.3949177823E-03 1.3826530488E-03 + 1.3704953023E-03 1.3584436183E-03 1.3464970801E-03 1.3346547789E-03 + 1.3229158138E-03 1.3112792914E-03 1.2997443261E-03 1.2883100399E-03 + 1.2769755622E-03 1.2657400299E-03 1.2546025873E-03 1.2435623861E-03 + 1.2326185851E-03 1.2217703505E-03 1.2110168554E-03 1.2003572803E-03 + 1.1897908124E-03 1.1793166460E-03 1.1689339825E-03 1.1586420297E-03 + 1.1484400026E-03 1.1383271227E-03 1.1283026182E-03 1.1183657241E-03 + 1.1085156816E-03 1.0987517388E-03 1.0890731499E-03 1.0794791757E-03 + 1.0699690834E-03 1.0605421462E-03 1.0511976438E-03 1.0419348619E-03 + 1.0327530925E-03 1.0236516335E-03 1.0146297890E-03 1.0056868688E-03 + 9.9682218891E-04 9.8803507104E-04 9.7932484277E-04 9.7069083745E-04 + 9.6213239414E-04 9.5364885757E-04 9.4523957811E-04 9.3690391169E-04 + 9.2864121978E-04 9.2045086931E-04 9.1233223268E-04 9.0428468765E-04 + 8.9630761733E-04 8.8840041014E-04 8.8056245973E-04 8.7279316497E-04 + 8.6509192990E-04 8.5745816367E-04 8.4989128051E-04 8.4239069968E-04 + 8.3495584543E-04 8.2758614696E-04 8.2028103838E-04 8.1303995865E-04 + 8.0586235157E-04 7.9874766570E-04 7.9169535436E-04 7.8470487557E-04 + 7.7777569199E-04 7.7090727093E-04 7.6409908425E-04 7.5735060837E-04 + 7.5066132423E-04 7.4403071719E-04 7.3745827708E-04 7.3094349811E-04 + 7.2448587883E-04 7.1808492210E-04 7.1174013509E-04 7.0545102919E-04 + 6.9921711998E-04 6.9303792725E-04 6.8691297489E-04 6.8084179092E-04 + 6.7482390739E-04 6.6885886040E-04 6.6294619005E-04 6.5708544039E-04 + 6.5127615941E-04 6.4551789898E-04 6.3981021484E-04 6.3415266655E-04 + 6.2854481749E-04 6.2298623476E-04 6.1747648924E-04 6.1201515548E-04 + 6.0660181170E-04 6.0123603976E-04 5.9591742512E-04 5.9064555684E-04 + 5.8542002750E-04 5.8024043319E-04 5.7510637350E-04 5.7001745147E-04 + 5.6497327356E-04 5.5997344963E-04 5.5501759291E-04 5.5010531997E-04 + 5.4523625067E-04 5.4041000818E-04 5.3562621890E-04 5.3088451247E-04 + 5.2618452172E-04 5.2152588265E-04 5.1690823441E-04 5.1233121927E-04 + 5.0779448258E-04 5.0329767277E-04 4.9884044127E-04 4.9442244257E-04 + 4.9004333412E-04 4.8570277634E-04 4.8140043257E-04 4.7713596907E-04 + 4.7290905499E-04 4.6871936234E-04 4.6456656596E-04 4.6045034350E-04 + 4.5637037540E-04 4.5232634488E-04 4.4831793789E-04 4.4434484307E-04 + 4.4040675180E-04 4.3650335810E-04 4.3263435865E-04 4.2879945275E-04 + 4.2499834231E-04 4.2123073181E-04 4.1749632829E-04 4.1379484134E-04 + 4.1012598306E-04 4.0648946802E-04 4.0288501330E-04 3.9931233840E-04 + 3.9577116527E-04 3.9226121825E-04 3.8878222410E-04 3.8533391190E-04 + 3.8191601313E-04 3.7852826156E-04 3.7517039328E-04 3.7184214667E-04 + 3.6854326238E-04 3.6527348330E-04 3.6203255456E-04 3.5882022349E-04 + 3.5563623962E-04 3.5248035465E-04 3.4935232244E-04 3.4625189897E-04 + 3.4317884235E-04 3.4013291278E-04 3.3711387256E-04 3.3412148604E-04 + 3.3115551960E-04 3.2821574168E-04 3.2530192271E-04 3.2241383511E-04 + 3.1955125330E-04 3.1671395363E-04 3.1390171442E-04 3.1111431589E-04 + 3.0835154018E-04 3.0561317134E-04 3.0289899526E-04 3.0020879973E-04 + 2.9754237436E-04 2.9489951059E-04 2.9228000168E-04 2.8968364269E-04 + 2.8711023045E-04 2.8455956356E-04 2.8203144239E-04 2.7952566902E-04 + 2.7704204726E-04 2.7458038264E-04 2.7214048237E-04 2.6972215533E-04 + 2.6732521208E-04 2.6494946482E-04 2.6259472738E-04 2.6026081522E-04 + 2.5794754540E-04 2.5565473658E-04 2.5338220898E-04 2.5112978441E-04 + 2.4889728622E-04 2.4668453930E-04 2.4449137006E-04 2.4231760643E-04 + 2.4016307784E-04 2.3802761519E-04 2.3591105087E-04 2.3381321873E-04 + 2.3173395407E-04 2.2967309361E-04 2.2763047550E-04 2.2560593931E-04 + 2.2359932600E-04 2.2161047793E-04 2.1963923881E-04 2.1768545374E-04 + 2.1574896915E-04 2.1382963281E-04 2.1192729384E-04 2.1004180267E-04 + 2.0817301100E-04 2.0632077188E-04 2.0448493959E-04 2.0266536973E-04 + 2.0086191911E-04 1.9907444584E-04 1.9730280923E-04 1.9554686984E-04 + 1.9380648944E-04 1.9208153101E-04 1.9037185873E-04 1.8867733794E-04 + 1.8699783521E-04 1.8533321821E-04 1.8368335582E-04 1.8204811805E-04 + 1.8042737602E-04 1.7882100202E-04 1.7722886941E-04 1.7565085271E-04 + 1.7408682748E-04 1.7253667042E-04 1.7100025926E-04 1.6947747284E-04 + 1.6796819104E-04 1.6647229479E-04 1.6498966606E-04 1.6352018787E-04 + 1.6206374423E-04 1.6062022021E-04 1.5918950185E-04 1.5777147619E-04 + 1.5636603128E-04 1.5497305613E-04 1.5359244073E-04 1.5222407603E-04 + 1.5086785394E-04 1.4952366731E-04 1.4819140992E-04 1.4687097651E-04 + 1.4556226271E-04 1.4426516508E-04 1.4297958108E-04 1.4170540908E-04 + 1.4044254832E-04 1.3919089894E-04 1.3795036195E-04 1.3672083923E-04 + 1.3550223351E-04 1.3429444838E-04 1.3309738828E-04 1.3191095848E-04 + 1.3073506508E-04 1.2956961500E-04 1.2841451600E-04 1.2726967662E-04 + 1.2613500622E-04 1.2501041494E-04 1.2389581371E-04 1.2279111427E-04 + 1.2169622909E-04 1.2061107145E-04 1.1953555536E-04 1.1846959559E-04 + 1.1741310767E-04 1.1636600787E-04 1.1532821319E-04 1.1429964135E-04 + 1.1328021081E-04 1.1226984073E-04 1.1126845099E-04 1.1027596217E-04 + 1.0929229555E-04 1.0831737310E-04 1.0735111746E-04 1.0639345199E-04 + 1.0544430068E-04 1.0450358821E-04 1.0357123991E-04 1.0264718179E-04 + 1.0173134047E-04 1.0082364326E-04 9.9924018082E-05 9.9032393491E-05 + 9.8148698678E-05 9.7272863456E-05 9.6404818252E-05 9.5544494108E-05 + 9.4691822670E-05 9.3846736186E-05 9.3009167499E-05 9.2179050044E-05 + 9.1356317841E-05 9.0540905490E-05 8.9732748167E-05 8.8931781618E-05 + 8.8137942155E-05 8.7351166650E-05 8.6571392530E-05 8.5798557773E-05 + 8.5032600903E-05 8.4273460986E-05 8.3521077624E-05 8.2775390950E-05 + 8.2036341624E-05 8.1303870830E-05 8.0577920269E-05 7.9858432155E-05 + 7.9145349211E-05 7.8438614665E-05 7.7738172246E-05 7.7043966177E-05 + 7.6355941173E-05 7.5674042436E-05 7.4998215652E-05 7.4328406983E-05 + 7.3664563068E-05 7.3006631016E-05 7.2354558400E-05 7.1708293258E-05 + 7.1067784085E-05 7.0432979828E-05 6.9803829888E-05 6.9180284108E-05 + 6.8562292777E-05 6.7949806619E-05 6.7342776796E-05 6.6741154899E-05 + 6.6144892944E-05 6.5553943374E-05 6.4968259050E-05 6.4387793247E-05 + 6.3812499656E-05 6.3242332372E-05 6.2677245900E-05 6.2117195143E-05 + 6.1562135403E-05 6.1012022377E-05 6.0466812152E-05 5.9926461204E-05 + 5.9390926391E-05 5.8860164956E-05 5.8334134514E-05 5.7812793059E-05 + 5.7296098953E-05 5.6784010927E-05 5.6276488077E-05 5.5773489859E-05 + 5.5274976087E-05 5.4780906931E-05 5.4291242912E-05 5.3805944900E-05 + 5.3324974113E-05 5.2848292107E-05 5.2375860781E-05 5.1907642371E-05 + 5.1443599444E-05 5.0983694901E-05 5.0527891969E-05 5.0076154200E-05 + 4.9628445469E-05 4.9184729970E-05 4.8744972214E-05 4.8309137025E-05 + 4.7877189538E-05 4.7449095197E-05 4.7024819752E-05 4.6604329253E-05 + 4.6187590055E-05 4.5774568807E-05 4.5365232453E-05 4.4959548232E-05 + 4.4557483671E-05 4.4159006583E-05 4.3764085069E-05 4.3372687511E-05 + 4.2984782568E-05 4.2600339181E-05 4.2219326562E-05 4.1841714198E-05 + 4.1467471845E-05 4.1096569527E-05 4.0728977533E-05 4.0364666415E-05 + 4.0003606985E-05 3.9645770317E-05 3.9291127736E-05 3.8939650824E-05 + 3.8591311414E-05 3.8246081589E-05 3.7903933678E-05 3.7564840257E-05 + 3.7228774142E-05 3.6895708392E-05 3.6565616304E-05 3.6238471413E-05 + 3.5914247485E-05 3.5592918523E-05 3.5274458756E-05 3.4958842644E-05 + 3.4646044873E-05 3.4336040352E-05 3.4028804213E-05 3.3724311811E-05 + 3.3422538714E-05 3.3123460713E-05 3.2827053808E-05 3.2533294214E-05 + 3.2242158359E-05 3.1953622876E-05 3.1667664607E-05 3.1384260601E-05 + 3.1103388108E-05 3.0825024581E-05 3.0549147673E-05 3.0275735234E-05 + 3.0004765312E-05 2.9736216149E-05 2.9470066180E-05 2.9206294031E-05 + 2.8944878519E-05 2.8685798646E-05 2.8429033604E-05 2.8174562768E-05 + 2.7922365694E-05 2.7672422123E-05 2.7424711973E-05 2.7179215342E-05 + 2.6935912503E-05 2.6694783905E-05 2.6455810172E-05 2.6218972097E-05 + 2.5984250646E-05 2.5751626953E-05 2.5521082318E-05 2.5292598211E-05 + 2.5066156261E-05 2.4841738265E-05 2.4619326180E-05 2.4398902123E-05 + 2.4180448368E-05 2.3963947351E-05 2.3749381659E-05 2.3536734037E-05 + 2.3325987382E-05 2.3117124743E-05 2.2910129320E-05 2.2704984461E-05 + 2.2501673664E-05 2.2300180571E-05 2.2100488973E-05 2.1902582801E-05 + 2.1706446131E-05 2.1512063181E-05 2.1319418308E-05 2.1128496007E-05 + 2.0939280914E-05 2.0751757799E-05 2.0565911569E-05 2.0381727263E-05 + 2.0199190055E-05 2.0018285249E-05 1.9838998283E-05 1.9661314720E-05 + 1.9485220255E-05 1.9310700707E-05 1.9137742025E-05 1.8966330279E-05 + 1.8796451666E-05 1.8628092504E-05 1.8461239232E-05 1.8295878412E-05 + 1.8131996724E-05 1.7969580966E-05 1.7808618055E-05 1.7649095022E-05 + 1.7490999017E-05 1.7334317301E-05 1.7179037249E-05 1.7025146350E-05 + 1.6872632202E-05 1.6721482515E-05 1.6571685108E-05 1.6423227908E-05 + 1.6276098950E-05 1.6130286374E-05 1.5985778429E-05 1.5842563464E-05 + 1.5700629935E-05 1.5559966400E-05 1.5420561518E-05 1.5282404050E-05 + 1.5145482856E-05 1.5009786896E-05 1.4875305228E-05 1.4742027008E-05 + 1.4609941487E-05 1.4479038013E-05 1.4349306030E-05 1.4220735072E-05 + 1.4093314771E-05 1.3967034847E-05 1.3841885115E-05 1.3717855480E-05 + 1.3594935934E-05 1.3473116562E-05 1.3352387536E-05 1.3232739114E-05 + 1.3114161642E-05 1.2996645553E-05 1.2880181364E-05 1.2764759676E-05 + 1.2650371175E-05 1.2537006629E-05 1.2424656888E-05 1.2313312886E-05 + 1.2202965635E-05 1.2093606229E-05 1.1985225838E-05 1.1877815715E-05 + 1.1771367189E-05 1.1665871666E-05 1.1561320629E-05 1.1457705637E-05 + 1.1355018323E-05 1.1253250397E-05 1.1152393641E-05 1.1052439911E-05 + 1.0953381135E-05 1.0855209314E-05 1.0757916519E-05 1.0661494892E-05 + 1.0565936647E-05 1.0471234064E-05 1.0377379495E-05 1.0284365358E-05 + 1.0192184140E-05 1.0100828394E-05 1.0010290740E-05 9.9205638643E-06 + 9.8316405170E-06 9.7435135140E-06 9.6561757349E-06 9.5696201228E-06 + 9.4838396838E-06 9.3988274864E-06 9.3145766608E-06 9.2310803987E-06 + 9.1483319522E-06 9.0663246340E-06 8.9850518161E-06 8.9045069300E-06 + 8.8246834654E-06 8.7455749703E-06 8.6671750504E-06 8.5894773681E-06 + 8.5124756426E-06 8.4361636491E-06 8.3605352183E-06 8.2855842361E-06 + 8.2113046427E-06 8.1376904326E-06 8.0647356539E-06 7.9924344077E-06 + 7.9207808477E-06 7.8497691799E-06 7.7793936621E-06 7.7096486031E-06 + 7.6405283627E-06 7.5720273510E-06 7.5041400280E-06 7.4368609031E-06 + 7.3701845348E-06 7.3041055302E-06 7.2386185444E-06 7.1737182803E-06 + 7.1093994882E-06 7.0456569649E-06 6.9824855543E-06 6.9198801457E-06 + 6.8578356744E-06 6.7963471209E-06 6.7354095104E-06 6.6750179126E-06 + 6.6151674412E-06 6.5558532536E-06 6.4970705503E-06 6.4388145747E-06 + 6.3810806130E-06 6.3238639930E-06 6.2671600846E-06 6.2109642990E-06 + 6.1552720883E-06 6.1000789452E-06 6.0453804027E-06 5.9911720338E-06 + 5.9374494508E-06 5.8842083056E-06 5.8314442886E-06 5.7791531288E-06 + 5.7273305934E-06 5.6759724874E-06 5.6250746532E-06 5.5746329706E-06 + 5.5246433560E-06 5.4751017622E-06 5.4260041783E-06 5.3773466293E-06 + 5.3291251757E-06 5.2813359131E-06 5.2339749720E-06 5.1870385177E-06 + 5.1405227495E-06 5.0944239009E-06 5.0487382387E-06 5.0034620636E-06 + 4.9585917088E-06 4.9141235407E-06 4.8700539579E-06 4.8263793915E-06 + 4.7830963042E-06 4.7402011905E-06 4.6976905762E-06 4.6555610181E-06 + 4.6138091038E-06 4.5724314514E-06 4.5314247094E-06 4.4907855559E-06 + 4.4505106991E-06 4.4105968764E-06 4.3710408544E-06 4.3318394287E-06 + 4.2929894235E-06 4.2544876914E-06 4.2163311131E-06 4.1785165972E-06 + 4.1410410799E-06 4.1039015250E-06 4.0670949233E-06 4.0306182925E-06 + 3.9944686770E-06 3.9586431477E-06 3.9231388016E-06 3.8879527617E-06 + 3.8530821767E-06 3.8185242208E-06 3.7842760936E-06 3.7503350195E-06 + 3.7166982481E-06 3.6833630532E-06 3.6503267332E-06 3.6175866108E-06 + 3.5851400323E-06 3.5529843680E-06 3.5211170117E-06 3.4895353804E-06 + 3.4582369142E-06 3.4272190763E-06 3.3964793525E-06 3.3660152509E-06 + 3.3358243022E-06 3.3059040590E-06 3.2762520959E-06 3.2468660091E-06 + 3.2177434164E-06 3.1888819569E-06 3.1602792907E-06 3.1319330990E-06 + 3.1038410838E-06 3.0760009673E-06 3.0484104926E-06 3.0210674226E-06 + 2.9939695404E-06 2.9671146489E-06 2.9405005707E-06 2.9141251477E-06 + 2.8879862414E-06 2.8620817322E-06 2.8364095196E-06 2.8109675219E-06 + 2.7857536760E-06 2.7607659372E-06 2.7360022793E-06 2.7114606940E-06 + 2.6871391912E-06 2.6630357984E-06 2.6391485608E-06 2.6154755413E-06 + 2.5920148199E-06 2.5687644938E-06 2.5457226775E-06 2.5228875021E-06 + 2.5002571155E-06 2.4778296822E-06 2.4556033833E-06 2.4335764159E-06 + 2.4117469933E-06 2.3901133449E-06 2.3686737161E-06 2.3474263675E-06 + 2.3263695758E-06 2.3055016329E-06 2.2848208461E-06 2.2643255376E-06 + 2.2440140450E-06 2.2238847204E-06 2.2039359310E-06 2.1841660584E-06 + 2.1645734987E-06 2.1451566625E-06 2.1259139745E-06 2.1068438737E-06 + 2.0879448127E-06 2.0692152584E-06 2.0506536912E-06 2.0322586050E-06 + 2.0140285075E-06 1.9959619195E-06 1.9780573752E-06 1.9603134218E-06 + 1.9427286196E-06 1.9253015417E-06 1.9080307742E-06 1.8909149156E-06 + 1.8739525771E-06 1.8571423824E-06 1.8404829674E-06 1.8239729802E-06 + 1.8076110811E-06 1.7913959423E-06 1.7753262481E-06 1.7594006944E-06 + 1.7436179887E-06 1.7279768504E-06 1.7124760101E-06 1.6971142098E-06 + 1.6818902029E-06 1.6668027539E-06 1.6518506383E-06 1.6370326426E-06 + 1.6223475643E-06 1.6077942116E-06 1.5933714032E-06 1.5790779686E-06 + 1.5649127478E-06 1.5508745910E-06 1.5369623589E-06 1.5231749223E-06 + 1.5095111621E-06 1.4959699694E-06 1.4825502450E-06 1.4692508997E-06 + 1.4560708540E-06 1.4430090380E-06 1.4300643916E-06 1.4172358640E-06 + 1.4045224140E-06 1.3919230095E-06 1.3794366278E-06 1.3670622554E-06 + 1.3547988877E-06 1.3426455294E-06 1.3306011937E-06 1.3186649031E-06 + 1.3068356885E-06 1.2951125897E-06 1.2834946550E-06 1.2719809413E-06 + 1.2605705138E-06 1.2492624464E-06 1.2380558209E-06 1.2269497276E-06 + 1.2159432649E-06 1.2050355392E-06 1.1942256650E-06 1.1835127647E-06 + 1.1728959685E-06 1.1623744146E-06 1.1519472486E-06 1.1416136241E-06 + 1.1313727021E-06 1.1212236512E-06 1.1111656472E-06 1.1011978738E-06 + 1.0913195214E-06 1.0815297882E-06 1.0718278792E-06 1.0622130068E-06 + 1.0526843902E-06 1.0432412559E-06 1.0338828371E-06 1.0246083739E-06 + 1.0154171134E-06 1.0063083091E-06 9.9728122163E-07 9.8833511787E-07 + 9.7946927145E-07 9.7068296249E-07 9.6197547756E-07 9.5334610963E-07 + 9.4479415799E-07 9.3631892824E-07 9.2791973219E-07 9.1959588780E-07 + 9.1134671919E-07 9.0317155649E-07 8.9506973588E-07 8.8704059945E-07 + + + diff --git a/utils/pdos/examples/Al_FCC/PDOS_output/DOS.txt b/utils/pdos/examples/Al_FCC/PDOS_output/DOS.txt new file mode 100644 index 00000000..22770a29 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/PDOS_output/DOS.txt @@ -0,0 +1,1001 @@ +Energy(eV) DOS +-0.7740857782 0.0000000002 +-0.7555867332 0.0000000004 +-0.7370876883 0.0000000007 +-0.7185886434 0.0000000014 +-0.7000895985 0.0000000028 +-0.6815905535 0.0000000053 +-0.6630915086 0.0000000099 +-0.6445924637 0.0000000185 +-0.6260934188 0.0000000341 +-0.6075943738 0.0000000624 +-0.5890953289 0.0000001132 +-0.5705962840 0.0000002034 +-0.5520972391 0.0000003623 +-0.5335981941 0.0000006393 +-0.5150991492 0.0000011180 +-0.4966001043 0.0000019372 +-0.4781010594 0.0000033263 +-0.4596020144 0.0000056596 +-0.4411029695 0.0000095427 +-0.4226039246 0.0000159441 +-0.4041048797 0.0000263987 +-0.3856058347 0.0000433133 +-0.3671067898 0.0000704236 +-0.3486077449 0.0001134687 +-0.3301086999 0.0001811748 +-0.3116096550 0.0002866729 +-0.2931106101 0.0004495168 +-0.2746115652 0.0006985201 +-0.2561125202 0.0010756945 +-0.2376134753 0.0016416463 +-0.2191144304 0.0024828732 +-0.2006153855 0.0037214956 +-0.1821163405 0.0055280552 +-0.1636172956 0.0081381015 +-0.1451182507 0.0118733642 +-0.1266192058 0.0171683525 +-0.1081201608 0.0246032169 +-0.0896211159 0.0349436290 +-0.0711220710 0.0491882588 +-0.0526230261 0.0686241245 +-0.0341239811 0.0948896379 +-0.0156249362 0.1300445430 +0.0028741087 0.1766451394 +0.0213731536 0.2378221956 +0.0398721986 0.3173578118 +0.0583712435 0.4197562364 +0.0768702884 0.5503023461 +0.0953693333 0.7151002658 +0.1138683783 0.9210835691 +0.1323674232 1.1759878100 +0.1508664681 1.4882759586 +0.1693655130 1.8670078211 +0.1878645580 2.3216458571 +0.2063636029 2.8617920832 +0.2248626478 3.4968540175 +0.2433616927 4.2356418451 +0.2618607377 5.0859040415 +0.2803597826 6.0538143379 +0.2988588275 7.1434288115 +0.3173578725 8.3561375891 +0.3358569174 9.6901406472 +0.3543559623 11.1399809413 +0.3728550072 12.6961700595 +0.3913540522 14.3449413171 +0.4098530971 16.0681623535 +0.4283521420 17.8434337192 +0.4468511869 19.6443917026 +0.4653502319 21.4412230850 +0.4838492768 23.2013871665 +0.5023483217 24.8905270812 +0.5208473666 26.4735390538 +0.5393464116 27.9157559034 +0.5578454565 29.1841908148 +0.5763445014 30.2487801414 +0.5948435463 31.0835605261 +0.6133425913 31.6677164253 +0.6318416362 31.9864393317 +0.6503406811 32.0315494018 +0.6688397260 31.8018432052 +0.6873387710 31.3031470332 +0.7058378159 30.5480724720 +0.7243368608 29.5554884794 +0.7428359057 28.3497406749 +0.7613349507 26.9596627504 +0.7798339956 25.4174358085 +0.7983330405 23.7573583121 +0.8168320854 22.0145918173 +0.8353311304 20.2239457518 +0.8538301753 18.4187585603 +0.8723292202 16.6299232283 +0.8908282651 14.8850934157 +0.9093273101 13.2080932200 +0.9278263550 11.6185400191 +0.9463253999 10.1316769224 +0.9648244449 8.7583999633 +0.9833234898 7.5054559442 +1.0018225347 6.3757802283 +1.0203215796 5.3689399107 +1.0388206246 4.4816466352 +1.0573196695 3.7083045627 +1.0758187144 3.0415622300 +1.0943177593 2.4728417308 +1.1128168043 1.9928242509 +1.1313158492 1.5918769644 +1.1498148941 1.2604121548 +1.1683139390 0.9891747894 +1.1868129840 0.7694593591 +1.2053120289 0.5932604345 +1.2238110738 0.4533640190 +1.2423101187 0.3433884259 +1.2608091637 0.2577841663 +1.2793082086 0.1918023506 +1.2978072535 0.1414405432 +1.3163062984 0.1033740423 +1.3348053434 0.0748793489 +1.3533043883 0.0537552738 +1.3718034332 0.0382458341 +1.3903024781 0.0269678873 +1.4088015231 0.0188453945 +1.4273005680 0.0130513359 +1.4457996129 0.0089576098 +1.4642986578 0.0060927433 +1.4827977028 0.0041068933 +1.5012967477 0.0027434061 +1.5197957926 0.0018160985 +1.5382948375 0.0011914008 +1.5567938825 0.0007745371 +1.5752929274 0.0004989870 +1.5937919723 0.0003185633 +1.6122910172 0.0002015389 +1.6307900622 0.0001263501 +1.6492891071 0.0000784953 +1.6677881520 0.0000483236 +1.6862871970 0.0000294795 +1.7047862419 0.0000178207 +1.7232852868 0.0000106751 +1.7417843317 0.0000063366 +1.7602833767 0.0000037271 +1.7787824216 0.0000021723 +1.7972814665 0.0000012546 +1.8157805114 0.0000007180 +1.8342795564 0.0000004072 +1.8527786013 0.0000002288 +1.8712776462 0.0000001274 +1.8897766911 0.0000000703 +1.9082757361 0.0000000384 +1.9267747810 0.0000000208 +1.9452738259 0.0000000112 +1.9637728708 0.0000000059 +1.9822719158 0.0000000031 +2.0007709607 0.0000000016 +2.0192700056 0.0000000008 +2.0377690505 0.0000000004 +2.0562680955 0.0000000002 +2.0747671404 0.0000000001 +2.0932661853 0.0000000001 +2.1117652302 0.0000000000 +2.1302642752 0.0000000000 +2.1487633201 0.0000000000 +2.1672623650 0.0000000000 +2.1857614099 0.0000000000 +2.2042604549 0.0000000000 +2.2227594998 0.0000000000 +2.2412585447 0.0000000000 +2.2597575896 0.0000000000 +2.2782566346 0.0000000000 +2.2967556795 0.0000000000 +2.3152547244 0.0000000000 +2.3337537694 0.0000000000 +2.3522528143 0.0000000000 +2.3707518592 0.0000000000 +2.3892509041 0.0000000000 +2.4077499491 0.0000000000 +2.4262489940 0.0000000000 +2.4447480389 0.0000000000 +2.4632470838 0.0000000000 +2.4817461288 0.0000000000 +2.5002451737 0.0000000000 +2.5187442186 0.0000000000 +2.5372432635 0.0000000000 +2.5557423085 0.0000000000 +2.5742413534 0.0000000000 +2.5927403983 0.0000000000 +2.6112394432 0.0000000000 +2.6297384882 0.0000000000 +2.6482375331 0.0000000000 +2.6667365780 0.0000000000 +2.6852356229 0.0000000000 +2.7037346679 0.0000000000 +2.7222337128 0.0000000000 +2.7407327577 0.0000000000 +2.7592318026 0.0000000000 +2.7777308476 0.0000000000 +2.7962298925 0.0000000000 +2.8147289374 0.0000000000 +2.8332279823 0.0000000000 +2.8517270273 0.0000000000 +2.8702260722 0.0000000000 +2.8887251171 0.0000000000 +2.9072241620 0.0000000000 +2.9257232070 0.0000000000 +2.9442222519 0.0000000000 +2.9627212968 0.0000000000 +2.9812203418 0.0000000000 +2.9997193867 0.0000000000 +3.0182184316 0.0000000000 +3.0367174765 0.0000000000 +3.0552165215 0.0000000000 +3.0737155664 0.0000000000 +3.0922146113 0.0000000000 +3.1107136562 0.0000000000 +3.1292127012 0.0000000000 +3.1477117461 0.0000000000 +3.1662107910 0.0000000000 +3.1847098359 0.0000000000 +3.2032088809 0.0000000000 +3.2217079258 0.0000000000 +3.2402069707 0.0000000000 +3.2587060156 0.0000000000 +3.2772050606 0.0000000000 +3.2957041055 0.0000000000 +3.3142031504 0.0000000000 +3.3327021953 0.0000000000 +3.3512012403 0.0000000000 +3.3697002852 0.0000000000 +3.3881993301 0.0000000000 +3.4066983750 0.0000000000 +3.4251974200 0.0000000000 +3.4436964649 0.0000000000 +3.4621955098 0.0000000000 +3.4806945547 0.0000000000 +3.4991935997 0.0000000000 +3.5176926446 0.0000000000 +3.5361916895 0.0000000000 +3.5546907344 0.0000000000 +3.5731897794 0.0000000000 +3.5916888243 0.0000000000 +3.6101878692 0.0000000000 +3.6286869142 0.0000000000 +3.6471859591 0.0000000001 +3.6656850040 0.0000000001 +3.6841840489 0.0000000002 +3.7026830939 0.0000000005 +3.7211821388 0.0000000009 +3.7396811837 0.0000000017 +3.7581802286 0.0000000032 +3.7766792736 0.0000000059 +3.7951783185 0.0000000110 +3.8136773634 0.0000000203 +3.8321764083 0.0000000369 +3.8506754533 0.0000000668 +3.8691744982 0.0000001195 +3.8876735431 0.0000002120 +3.9061725880 0.0000003725 +3.9246716330 0.0000006487 +3.9431706779 0.0000011192 +3.9616697228 0.0000019132 +3.9801687677 0.0000032403 +3.9986678127 0.0000054375 +4.0171668576 0.0000090406 +4.0356659025 0.0000148931 +4.0541649474 0.0000243085 +4.0726639924 0.0000393113 +4.0911630373 0.0000629885 +4.1096620822 0.0000999980 +4.1281611271 0.0001572921 +4.1466601721 0.0002451366 +4.1651592170 0.0003785254 +4.1836582619 0.0005791188 +4.2021573068 0.0008778615 +4.2206563518 0.0013184692 +4.2391553967 0.0019620031 +4.2576544416 0.0028927777 +4.2761534865 0.0042258701 +4.2946525315 0.0061164990 +4.3131515764 0.0087715302 +4.3316506213 0.0124633132 +4.3501496663 0.0175459685 +4.3686487112 0.0244741079 +4.3871477561 0.0338237757 +4.4056468010 0.0463151411 +4.4241458460 0.0628361529 +4.4426448909 0.0844659895 +4.4611439358 0.1124967174 +4.4796429807 0.1484511330 +4.4981420257 0.1940943409 +4.5166410706 0.2514362667 +4.5351401155 0.3227220625 +4.5536391604 0.4104073058 +4.5721382054 0.5171150769 +4.5906372503 0.6455724780 +4.6091362952 0.7985249761 +4.6276353401 0.9786281225 +4.6461343851 1.1883177088 +4.6646334300 1.4296612193 +4.6831324749 1.7041954223 +4.7016315198 2.0127569836 +4.7201305648 2.3553149032 +4.7386296097 2.7308151785 +4.7571286546 3.1370491725 +4.7756276995 3.5705575259 +4.7941267445 4.0265809342 +4.8126257894 4.4990676277 +4.8311248343 4.9807449111 +4.8496238792 5.4632587328 +4.8681229242 5.9373811242 +4.8866219691 6.3932807537 +4.9051210140 6.8208471191 +4.9236200589 7.2100544524 +4.9421191039 7.5513476345 +4.9606181488 7.8360296997 +4.9791171937 8.0566291417 +4.9976162387 8.2072254316 +5.0161152836 8.2837129720 +5.0346143285 8.2839870671 +5.0531133734 8.2080401512 +5.0716124184 8.0579621360 +5.0901114633 7.8378448534 +5.1086105082 7.5535966924 +5.1271095531 7.2126791499 +5.1456085981 6.8237816863 +5.1641076430 6.3964546431 +5.1826066879 5.9407218050 +5.2011057328 5.4666943983 +5.2196047778 4.9842069622 +5.2381038227 4.5024928172 +5.2566028676 4.0299130882 +5.2751019125 3.5737487903 +5.2936009575 3.1400607684 +5.3121000024 2.7336176792 +5.3305990473 2.3578880764 +5.3490980922 2.0150892592 +5.3675971372 1.7062830641 +5.3860961821 1.4315072842 +5.4045952270 1.1899308784 +5.4230942719 0.9800214850 +5.4415933169 0.7997148292 +5.4600923618 0.6465772085 +5.4785914067 0.5179541589 +5.4970904516 0.4111004455 +5.5155894966 0.3232885031 +5.5340885415 0.2518942554 +5.5525875864 0.1944607500 +5.5710866313 0.1487412202 +5.5895856763 0.1127240057 +5.6080847212 0.0846422456 +5.6265837661 0.0629714408 +5.6450828111 0.0464179305 +5.6635818560 0.0339010858 +5.6820809009 0.0245316710 +5.7005799458 0.0175884005 +5.7190789908 0.0124942805 +5.7375780357 0.0087939065 +5.7560770806 0.0061325081 +5.7745761255 0.0042372111 +5.7930751705 0.0029007331 +5.8115742154 0.0019675289 +5.8300732603 0.0013222701 +5.8485723052 0.0008804504 +5.8670713502 0.0005808652 +5.8855703951 0.0003796920 +5.9040694400 0.0002459083 +5.9225684849 0.0001577977 +5.9410675299 0.0001003261 +5.9595665748 0.0000631994 +5.9780656197 0.0000394455 +5.9965646646 0.0000243931 +6.0150637096 0.0000149460 +6.0335627545 0.0000090733 +6.0520617994 0.0000054575 +6.0705608443 0.0000032524 +6.0890598893 0.0000019205 +6.1075589342 0.0000011235 +6.1260579791 0.0000006513 +6.1445570240 0.0000003740 +6.1630560690 0.0000002128 +6.1815551139 0.0000001200 +6.2000541588 0.0000000670 +6.2185532037 0.0000000371 +6.2370522487 0.0000000203 +6.2555512936 0.0000000111 +6.2740503385 0.0000000060 +6.2925493835 0.0000000032 +6.3110484284 0.0000000017 +6.3295474733 0.0000000009 +6.3480465182 0.0000000005 +6.3665455632 0.0000000002 +6.3850446081 0.0000000001 +6.4035436530 0.0000000001 +6.4220426979 0.0000000000 +6.4405417429 0.0000000000 +6.4590407878 0.0000000000 +6.4775398327 0.0000000000 +6.4960388776 0.0000000000 +6.5145379226 0.0000000000 +6.5330369675 0.0000000000 +6.5515360124 0.0000000000 +6.5700350573 0.0000000000 +6.5885341023 0.0000000000 +6.6070331472 0.0000000000 +6.6255321921 0.0000000000 +6.6440312370 0.0000000000 +6.6625302820 0.0000000000 +6.6810293269 0.0000000000 +6.6995283718 0.0000000000 +6.7180274167 0.0000000000 +6.7365264617 0.0000000000 +6.7550255066 0.0000000000 +6.7735245515 0.0000000000 +6.7920235964 0.0000000000 +6.8105226414 0.0000000000 +6.8290216863 0.0000000000 +6.8475207312 0.0000000000 +6.8660197761 0.0000000000 +6.8845188211 0.0000000000 +6.9030178660 0.0000000000 +6.9215169109 0.0000000000 +6.9400159558 0.0000000000 +6.9585150008 0.0000000000 +6.9770140457 0.0000000000 +6.9955130906 0.0000000000 +7.0140121356 0.0000000000 +7.0325111805 0.0000000000 +7.0510102254 0.0000000000 +7.0695092703 0.0000000000 +7.0880083153 0.0000000000 +7.1065073602 0.0000000000 +7.1250064051 0.0000000000 +7.1435054500 0.0000000000 +7.1620044950 0.0000000000 +7.1805035399 0.0000000000 +7.1990025848 0.0000000000 +7.2175016297 0.0000000000 +7.2360006747 0.0000000000 +7.2544997196 0.0000000000 +7.2729987645 0.0000000000 +7.2914978094 0.0000000000 +7.3099968544 0.0000000000 +7.3284958993 0.0000000000 +7.3469949442 0.0000000000 +7.3654939891 0.0000000000 +7.3839930341 0.0000000000 +7.4024920790 0.0000000000 +7.4209911239 0.0000000000 +7.4394901688 0.0000000000 +7.4579892138 0.0000000000 +7.4764882587 0.0000000000 +7.4949873036 0.0000000000 +7.5134863485 0.0000000000 +7.5319853935 0.0000000000 +7.5504844384 0.0000000000 +7.5689834833 0.0000000000 +7.5874825282 0.0000000000 +7.6059815732 0.0000000000 +7.6244806181 0.0000000000 +7.6429796630 0.0000000000 +7.6614787080 0.0000000000 +7.6799777529 0.0000000000 +7.6984767978 0.0000000000 +7.7169758427 0.0000000000 +7.7354748877 0.0000000000 +7.7539739326 0.0000000000 +7.7724729775 0.0000000000 +7.7909720224 0.0000000000 +7.8094710674 0.0000000000 +7.8279701123 0.0000000000 +7.8464691572 0.0000000000 +7.8649682021 0.0000000000 +7.8834672471 0.0000000000 +7.9019662920 0.0000000000 +7.9204653369 0.0000000000 +7.9389643818 0.0000000000 +7.9574634268 0.0000000000 +7.9759624717 0.0000000000 +7.9944615166 0.0000000000 +8.0129605615 0.0000000000 +8.0314596065 0.0000000000 +8.0499586514 0.0000000000 +8.0684576963 0.0000000000 +8.0869567412 0.0000000000 +8.1054557862 0.0000000000 +8.1239548311 0.0000000000 +8.1424538760 0.0000000000 +8.1609529209 0.0000000000 +8.1794519659 0.0000000000 +8.1979510108 0.0000000000 +8.2164500557 0.0000000000 +8.2349491006 0.0000000000 +8.2534481456 0.0000000000 +8.2719471905 0.0000000000 +8.2904462354 0.0000000000 +8.3089452804 0.0000000000 +8.3274443253 0.0000000000 +8.3459433702 0.0000000000 +8.3644424151 0.0000000000 +8.3829414601 0.0000000000 +8.4014405050 0.0000000000 +8.4199395499 0.0000000000 +8.4384385948 0.0000000000 +8.4569376398 0.0000000000 +8.4754366847 0.0000000000 +8.4939357296 0.0000000000 +8.5124347745 0.0000000000 +8.5309338195 0.0000000000 +8.5494328644 0.0000000000 +8.5679319093 0.0000000000 +8.5864309542 0.0000000000 +8.6049299992 0.0000000000 +8.6234290441 0.0000000000 +8.6419280890 0.0000000000 +8.6604271339 0.0000000000 +8.6789261789 0.0000000000 +8.6974252238 0.0000000000 +8.7159242687 0.0000000000 +8.7344233136 0.0000000000 +8.7529223586 0.0000000000 +8.7714214035 0.0000000000 +8.7899204484 0.0000000000 +8.8084194933 0.0000000000 +8.8269185383 0.0000000000 +8.8454175832 0.0000000000 +8.8639166281 0.0000000000 +8.8824156730 0.0000000000 +8.9009147180 0.0000000000 +8.9194137629 0.0000000000 +8.9379128078 0.0000000000 +8.9564118528 0.0000000000 +8.9749108977 0.0000000000 +8.9934099426 0.0000000000 +9.0119089875 0.0000000000 +9.0304080325 0.0000000000 +9.0489070774 0.0000000000 +9.0674061223 0.0000000000 +9.0859051672 0.0000000000 +9.1044042122 0.0000000000 +9.1229032571 0.0000000000 +9.1414023020 0.0000000000 +9.1599013469 0.0000000000 +9.1784003919 0.0000000000 +9.1968994368 0.0000000000 +9.2153984817 0.0000000000 +9.2338975266 0.0000000000 +9.2523965716 0.0000000000 +9.2708956165 0.0000000000 +9.2893946614 0.0000000000 +9.3078937063 0.0000000000 +9.3263927513 0.0000000000 +9.3448917962 0.0000000000 +9.3633908411 0.0000000000 +9.3818898860 0.0000000000 +9.4003889310 0.0000000000 +9.4188879759 0.0000000000 +9.4373870208 0.0000000000 +9.4558860657 0.0000000000 +9.4743851107 0.0000000000 +9.4928841556 0.0000000000 +9.5113832005 0.0000000000 +9.5298822454 0.0000000000 +9.5483812904 0.0000000000 +9.5668803353 0.0000000000 +9.5853793802 0.0000000000 +9.6038784251 0.0000000000 +9.6223774701 0.0000000000 +9.6408765150 0.0000000000 +9.6593755599 0.0000000000 +9.6778746049 0.0000000000 +9.6963736498 0.0000000000 +9.7148726947 0.0000000000 +9.7333717396 0.0000000000 +9.7518707846 0.0000000000 +9.7703698295 0.0000000000 +9.7888688744 0.0000000000 +9.8073679193 0.0000000000 +9.8258669643 0.0000000000 +9.8443660092 0.0000000000 +9.8628650541 0.0000000000 +9.8813640990 0.0000000000 +9.8998631440 0.0000000000 +9.9183621889 0.0000000000 +9.9368612338 0.0000000000 +9.9553602787 0.0000000000 +9.9738593237 0.0000000000 +9.9923583686 0.0000000000 +10.0108574135 0.0000000000 +10.0293564584 0.0000000000 +10.0478555034 0.0000000000 +10.0663545483 0.0000000000 +10.0848535932 0.0000000000 +10.1033526381 0.0000000000 +10.1218516831 0.0000000000 +10.1403507280 0.0000000000 +10.1588497729 0.0000000000 +10.1773488178 0.0000000000 +10.1958478628 0.0000000000 +10.2143469077 0.0000000000 +10.2328459526 0.0000000000 +10.2513449975 0.0000000000 +10.2698440425 0.0000000000 +10.2883430874 0.0000000000 +10.3068421323 0.0000000000 +10.3253411773 0.0000000000 +10.3438402222 0.0000000000 +10.3623392671 0.0000000000 +10.3808383120 0.0000000000 +10.3993373570 0.0000000000 +10.4178364019 0.0000000000 +10.4363354468 0.0000000000 +10.4548344917 0.0000000000 +10.4733335367 0.0000000000 +10.4918325816 0.0000000000 +10.5103316265 0.0000000000 +10.5288306714 0.0000000000 +10.5473297164 0.0000000000 +10.5658287613 0.0000000000 +10.5843278062 0.0000000000 +10.6028268511 0.0000000000 +10.6213258961 0.0000000000 +10.6398249410 0.0000000000 +10.6583239859 0.0000000000 +10.6768230308 0.0000000000 +10.6953220758 0.0000000000 +10.7138211207 0.0000000000 +10.7323201656 0.0000000000 +10.7508192105 0.0000000000 +10.7693182555 0.0000000000 +10.7878173004 0.0000000000 +10.8063163453 0.0000000000 +10.8248153902 0.0000000000 +10.8433144352 0.0000000000 +10.8618134801 0.0000000000 +10.8803125250 0.0000000000 +10.8988115699 0.0000000000 +10.9173106149 0.0000000000 +10.9358096598 0.0000000000 +10.9543087047 0.0000000000 +10.9728077497 0.0000000000 +10.9913067946 0.0000000000 +11.0098058395 0.0000000000 +11.0283048844 0.0000000000 +11.0468039294 0.0000000000 +11.0653029743 0.0000000000 +11.0838020192 0.0000000000 +11.1023010641 0.0000000000 +11.1208001091 0.0000000000 +11.1392991540 0.0000000000 +11.1577981989 0.0000000000 +11.1762972438 0.0000000000 +11.1947962888 0.0000000000 +11.2132953337 0.0000000000 +11.2317943786 0.0000000000 +11.2502934235 0.0000000000 +11.2687924685 0.0000000000 +11.2872915134 0.0000000000 +11.3057905583 0.0000000000 +11.3242896032 0.0000000000 +11.3427886482 0.0000000000 +11.3612876931 0.0000000000 +11.3797867380 0.0000000000 +11.3982857829 0.0000000000 +11.4167848279 0.0000000000 +11.4352838728 0.0000000000 +11.4537829177 0.0000000000 +11.4722819626 0.0000000000 +11.4907810076 0.0000000000 +11.5092800525 0.0000000000 +11.5277790974 0.0000000000 +11.5462781423 0.0000000000 +11.5647771873 0.0000000000 +11.5832762322 0.0000000000 +11.6017752771 0.0000000000 +11.6202743221 0.0000000000 +11.6387733670 0.0000000000 +11.6572724119 0.0000000000 +11.6757714568 0.0000000000 +11.6942705018 0.0000000000 +11.7127695467 0.0000000000 +11.7312685916 0.0000000000 +11.7497676365 0.0000000000 +11.7682666815 0.0000000000 +11.7867657264 0.0000000000 +11.8052647713 0.0000000000 +11.8237638162 0.0000000000 +11.8422628612 0.0000000000 +11.8607619061 0.0000000000 +11.8792609510 0.0000000000 +11.8977599959 0.0000000000 +11.9162590409 0.0000000000 +11.9347580858 0.0000000000 +11.9532571307 0.0000000000 +11.9717561756 0.0000000000 +11.9902552206 0.0000000000 +12.0087542655 0.0000000000 +12.0272533104 0.0000000000 +12.0457523553 0.0000000000 +12.0642514003 0.0000000000 +12.0827504452 0.0000000000 +12.1012494901 0.0000000000 +12.1197485350 0.0000000000 +12.1382475800 0.0000000000 +12.1567466249 0.0000000000 +12.1752456698 0.0000000000 +12.1937447147 0.0000000000 +12.2122437597 0.0000000000 +12.2307428046 0.0000000000 +12.2492418495 0.0000000000 +12.2677408944 0.0000000000 +12.2862399394 0.0000000000 +12.3047389843 0.0000000000 +12.3232380292 0.0000000000 +12.3417370742 0.0000000000 +12.3602361191 0.0000000000 +12.3787351640 0.0000000000 +12.3972342089 0.0000000000 +12.4157332539 0.0000000000 +12.4342322988 0.0000000000 +12.4527313437 0.0000000000 +12.4712303886 0.0000000000 +12.4897294336 0.0000000000 +12.5082284785 0.0000000000 +12.5267275234 0.0000000000 +12.5452265683 0.0000000000 +12.5637256133 0.0000000000 +12.5822246582 0.0000000000 +12.6007237031 0.0000000000 +12.6192227480 0.0000000000 +12.6377217930 0.0000000000 +12.6562208379 0.0000000000 +12.6747198828 0.0000000000 +12.6932189277 0.0000000000 +12.7117179727 0.0000000000 +12.7302170176 0.0000000000 +12.7487160625 0.0000000000 +12.7672151074 0.0000000000 +12.7857141524 0.0000000000 +12.8042131973 0.0000000000 +12.8227122422 0.0000000000 +12.8412112871 0.0000000000 +12.8597103321 0.0000000000 +12.8782093770 0.0000000000 +12.8967084219 0.0000000000 +12.9152074668 0.0000000000 +12.9337065118 0.0000000000 +12.9522055567 0.0000000000 +12.9707046016 0.0000000000 +12.9892036466 0.0000000000 +13.0077026915 0.0000000000 +13.0262017364 0.0000000000 +13.0447007813 0.0000000000 +13.0631998263 0.0000000000 +13.0816988712 0.0000000000 +13.1001979161 0.0000000000 +13.1186969610 0.0000000000 +13.1371960060 0.0000000000 +13.1556950509 0.0000000000 +13.1741940958 0.0000000000 +13.1926931407 0.0000000000 +13.2111921857 0.0000000000 +13.2296912306 0.0000000000 +13.2481902755 0.0000000000 +13.2666893204 0.0000000000 +13.2851883654 0.0000000000 +13.3036874103 0.0000000000 +13.3221864552 0.0000000000 +13.3406855001 0.0000000000 +13.3591845451 0.0000000000 +13.3776835900 0.0000000000 +13.3961826349 0.0000000000 +13.4146816798 0.0000000000 +13.4331807248 0.0000000000 +13.4516797697 0.0000000000 +13.4701788146 0.0000000000 +13.4886778595 0.0000000000 +13.5071769045 0.0000000000 +13.5256759494 0.0000000000 +13.5441749943 0.0000000000 +13.5626740392 0.0000000000 +13.5811730842 0.0000000000 +13.5996721291 0.0000000000 +13.6181711740 0.0000000000 +13.6366702190 0.0000000000 +13.6551692639 0.0000000000 +13.6736683088 0.0000000000 +13.6921673537 0.0000000000 +13.7106663987 0.0000000000 +13.7291654436 0.0000000000 +13.7476644885 0.0000000000 +13.7661635334 0.0000000000 +13.7846625784 0.0000000000 +13.8031616233 0.0000000000 +13.8216606682 0.0000000000 +13.8401597131 0.0000000000 +13.8586587581 0.0000000000 +13.8771578030 0.0000000000 +13.8956568479 0.0000000000 +13.9141558928 0.0000000000 +13.9326549378 0.0000000000 +13.9511539827 0.0000000000 +13.9696530276 0.0000000000 +13.9881520725 0.0000000000 +14.0066511175 0.0000000000 +14.0251501624 0.0000000000 +14.0436492073 0.0000000000 +14.0621482522 0.0000000000 +14.0806472972 0.0000000000 +14.0991463421 0.0000000000 +14.1176453870 0.0000000000 +14.1361444319 0.0000000000 +14.1546434769 0.0000000000 +14.1731425218 0.0000000000 +14.1916415667 0.0000000000 +14.2101406116 0.0000000000 +14.2286396566 0.0000000000 +14.2471387015 0.0000000000 +14.2656377464 0.0000000000 +14.2841367914 0.0000000000 +14.3026358363 0.0000000000 +14.3211348812 0.0000000000 +14.3396339261 0.0000000000 +14.3581329711 0.0000000000 +14.3766320160 0.0000000000 +14.3951310609 0.0000000000 +14.4136301058 0.0000000000 +14.4321291508 0.0000000000 +14.4506281957 0.0000000000 +14.4691272406 0.0000000000 +14.4876262855 0.0000000000 +14.5061253305 0.0000000000 +14.5246243754 0.0000000000 +14.5431234203 0.0000000000 +14.5616224652 0.0000000000 +14.5801215102 0.0000000000 +14.5986205551 0.0000000000 +14.6171196000 0.0000000000 +14.6356186449 0.0000000000 +14.6541176899 0.0000000000 +14.6726167348 0.0000000000 +14.6911157797 0.0000000000 +14.7096148246 0.0000000000 +14.7281138696 0.0000000000 +14.7466129145 0.0000000000 +14.7651119594 0.0000000000 +14.7836110043 0.0000000000 +14.8021100493 0.0000000000 +14.8206090942 0.0000000000 +14.8391081391 0.0000000000 +14.8576071840 0.0000000000 +14.8761062290 0.0000000000 +14.8946052739 0.0000000000 +14.9131043188 0.0000000000 +14.9316033637 0.0000000000 +14.9501024087 0.0000000000 +14.9686014536 0.0000000001 +14.9871004985 0.0000000002 +15.0055995435 0.0000000004 +15.0240985884 0.0000000007 +15.0425976333 0.0000000014 +15.0610966782 0.0000000026 +15.0795957232 0.0000000050 +15.0980947681 0.0000000092 +15.1165938130 0.0000000170 +15.1350928579 0.0000000311 +15.1535919029 0.0000000563 +15.1720909478 0.0000001010 +15.1905899927 0.0000001795 +15.2090890376 0.0000003160 +15.2275880826 0.0000005514 +15.2460871275 0.0000009531 +15.2645861724 0.0000016324 +15.2830852173 0.0000027702 +15.3015842623 0.0000046580 +15.3200833072 0.0000077603 +15.3385823521 0.0000128103 +15.3570813970 0.0000209524 +15.3755804420 0.0000339552 +15.3940794869 0.0000545225 +15.4125785318 0.0000867445 +15.4310775767 0.0001367430 +15.4495766217 0.0002135822 +15.4680756666 0.0003305384 +15.4865747115 0.0005068458 +15.5050737564 0.0007700639 +15.5235728014 0.0011592435 +15.5420718463 0.0017290981 +15.5605708912 0.0025554165 +15.5790699361 0.0037419748 +15.5975689811 0.0054292163 +15.6160680260 0.0078049583 +15.6345670709 0.0111173484 +15.6530661159 0.0156902205 +15.6715651608 0.0219408832 +15.6900642057 0.0304001983 +15.7085632506 0.0417345755 +15.7270622956 0.0567692137 +15.7455613405 0.0765115630 +15.7640603854 0.1021735789 +15.7825594303 0.1351909110 +15.8010584753 0.1772367427 +15.8195575202 0.2302276179 +15.8380565651 0.2963183136 +15.8565556100 0.3778826895 +15.8750546550 0.4774775424 +15.8935536999 0.5977868623 +15.9120527448 0.7415445759 +15.9305517897 0.9114348995 +15.9490508347 1.1099708031 +15.9675498796 1.3393527688 +15.9860489245 1.6013119375 +16.0045479694 1.8969437464 +16.0230470144 2.2265401165 +16.0415460593 2.5894299655 +16.0600451042 2.9838390820 +16.0785441491 3.4067810284 +16.0970431941 3.8539905476 +16.1155422390 4.3199098318 +16.1340412839 4.7977359109 +16.1525403288 5.2795343869 +16.1710393738 5.7564208989 +16.1895384187 6.2188073042 +16.2080374636 6.6567049013 +16.2265365085 7.0600724877 +16.2450355535 7.4191930298 +16.2635345984 7.7250596138 +16.2820336433 7.9697494783 +16.3005326883 8.1467645340 +16.3190317332 8.2513179733 +16.3375307781 8.2805493339 +16.3560298230 8.2336545320 +16.3745288680 8.1119226124 +16.3930279129 7.9186768747 +16.4115269578 7.6591241254 +16.4300260027 7.3401216013 +16.4485250477 6.9698761252 +16.4670240926 6.5575939030 +16.4855231375 6.1131017823 +16.5040221824 5.6464616133 +16.5225212274 5.1675986036 +16.5410202723 4.6859623740 +16.5595193172 4.2102360708 +16.5780183621 3.7481047204 +16.5965174071 3.3060894128 +16.6150164520 2.8894492711 +16.6335154969 2.5021488667 +16.6520145418 2.1468850727 +16.6705135868 1.8251645216 +16.6890126317 1.5374209637 +16.7075116766 1.2831609242 +16.7260107215 1.0611260748 +16.7445097665 0.8694615231 +16.7630088114 0.7058806146 +16.7815078563 0.5678186257 +16.8000069012 0.4525697163 +16.8185059462 0.3574035038 +16.8370049911 0.2796594928 +16.8555040360 0.2168192074 +16.8740030809 0.1665571759 +16.8925021259 0.1267728737 +16.9110011708 0.0956063401 +16.9295002157 0.0714404866 +16.9479992607 0.0528931518 +16.9664983056 0.0388017936 +16.9849973505 0.0282033986 +17.0034963954 0.0203117975 +17.0219954404 0.0144941422 +17.0404944853 0.0102478768 +17.0589935302 0.0071791409 +17.0774925751 0.0049831990 +17.0959916201 0.0034272133 +17.1144906650 0.0023354532 +17.1329897099 0.0015768787 +17.1514887548 0.0010549272 +17.1699877998 0.0006992682 +17.1884868447 0.0004592636 +17.2069858896 0.0002988665 +17.2254849345 0.0001927035 +17.2439839795 0.0001231115 +17.2624830244 0.0000779300 +17.2809820693 0.0000488773 +17.2994811142 0.0000303744 +17.3179801592 0.0000187027 +17.3364792041 0.0000114103 +17.3549782490 0.0000068974 +17.3734772939 0.0000041312 +17.3919763389 0.0000024516 +17.4104753838 0.0000014416 +17.4289744287 0.0000008399 +17.4474734736 0.0000004848 +17.4659725186 0.0000002773 +17.4844715635 0.0000001572 +17.5029706084 0.0000000882 +17.5214696533 0.0000000491 +17.5399686983 0.0000000271 +17.5584677432 0.0000000148 +17.5769667881 0.0000000080 +17.5954658330 0.0000000043 +17.6139648780 0.0000000023 +17.6324639229 0.0000000012 +17.6509629678 0.0000000006 +17.6694620128 0.0000000003 +17.6879610577 0.0000000002 +17.7064601026 0.0000000001 diff --git a/utils/pdos/examples/Al_FCC/PDOS_output/PDOS.txt b/utils/pdos/examples/Al_FCC/PDOS_output/PDOS.txt new file mode 100644 index 00000000..299ef036 --- /dev/null +++ b/utils/pdos/examples/Al_FCC/PDOS_output/PDOS.txt @@ -0,0 +1,4086 @@ + +:Description: +:Desc_PDOS: Projected density of states for each orbital. Unit=states/eV +:Desc_FERMI_LEVEL: Fermi level energy. Unit=eV +:Desc_BROADENING: Gaussian broadening parameter for DOS calculation. Unit=eV +:Desc_GRID_POINTS: Number of energy grid points for PDOS calculation +:Desc_MIN_E: Minimum energy for PDOS calculation. Unit=eV +:Desc_MAX_E: Maximum energy for PDOS calculation. Unit=eV +:Desc_BAND_NUM: Number of bands included in the calculation +:Desc_KPT_NUM: Number of k-points used in the calculation +:Desc_ATOM_TYPE_NUM: Number of atom types in the system +:Desc_TOT_ORBITALS: Total number of atomic orbitals +:Desc_PROJ_ORBITALS: Total number of projected orbitals +:Desc_VOLUME: Lattice unit cell volume. Unit=Bohr^3 +:Desc_CALCULATION_TIME: Total calculation time. Unit=seconds +:Desc_M_INDEX_SUMMED_OVER: Whether the m index is summed over +:Desc_ORTHOGONALIZE_ATOMIC_ORBITALS: Whether the atomic orbitals are orthogonalized +:Desc_ATOM_INDEX_FOR_PDOS: The index of the atom for which the PDOS is calculated +:Desc_PDOS_INFO: The information of the PDOS + :Desc_ATOM_TYPE: The type of the atom + :Desc_ATOMIC_NUMBER: The atomic number of the atom + :Desc_ATOM_INDEX: The index of the atom + :Desc_ATOM_POSITION_CARTESIAN: The position of the atom in Cartesian coordinates + :Desc_ATOM_POSITION_FRACTIONAL: The fractional position of the atom + :Desc_PDOS_UNIT: The unit of the PDOS value + :Desc_HEADER_FORMAT: The format of the header + + +:BASIC_INFO: +:FERMI_LEVEL: 0.696 +:BROADENING: 0.272 +:GRID_POINTS: 1000 +:MIN_E: -0.774 +:MAX_E: 17.706 +:BAND_NUM: 12 +:KPT_NUM: 1 +:ATOM_TYPE_NUM: 1 +:TOT_ORBITALS: 16 +:PROJ_ORBITALS: 16 +:VOLUME: 448.293 +:CALCULATION_TIME: 0.383 +:M_INDEX_SUMMED_OVER: False +:ORTHOGONALIZE_ATOMIC_ORBITALS: False +:ATOM_INDEX_FOR_PDOS: All + + + +:PDOS_INFO: + :ATOM_TYPE: Al + :ATOMIC_NUMBER: 13 + :ATOM_INDEX: 0 + :ATOM_POSITION_CARTESIAN: [0. 0. 0.] + :ATOM_POSITION_FRACTIONAL: [0. 0. 0.] + :PDOS_UNIT: states/eV + :HEADER_FORMAT: (nl,m) + Energy(eV) (3s, m=0) (3p, m=-1) (3p, m=0) (3p, m=1) + -0.7740857782 0.0000000000 0.0000000001 0.0000000001 0.0000000001 + -0.7555867332 0.0000000000 0.0000000001 0.0000000001 0.0000000001 + -0.7370876883 0.0000000000 0.0000000002 0.0000000002 0.0000000002 + -0.7185886434 0.0000000000 0.0000000004 0.0000000004 0.0000000004 + -0.7000895985 0.0000000000 0.0000000007 0.0000000007 0.0000000007 + -0.6815905535 0.0000000000 0.0000000014 0.0000000014 0.0000000014 + -0.6630915086 0.0000000001 0.0000000027 0.0000000027 0.0000000027 + -0.6445924637 0.0000000001 0.0000000049 0.0000000049 0.0000000049 + -0.6260934188 0.0000000002 0.0000000091 0.0000000091 0.0000000091 + -0.6075943738 0.0000000004 0.0000000166 0.0000000166 0.0000000166 + -0.5890953289 0.0000000008 0.0000000300 0.0000000300 0.0000000300 + -0.5705962840 0.0000000014 0.0000000538 0.0000000538 0.0000000538 + -0.5520972391 0.0000000027 0.0000000955 0.0000000955 0.0000000955 + -0.5335981941 0.0000000050 0.0000001679 0.0000001679 0.0000001679 + -0.5150991492 0.0000000093 0.0000002925 0.0000002925 0.0000002925 + -0.4966001043 0.0000000170 0.0000005048 0.0000005048 0.0000005048 + -0.4781010594 0.0000000307 0.0000008633 0.0000008633 0.0000008633 + -0.4596020144 0.0000000550 0.0000014628 0.0000014628 0.0000014628 + -0.4411029695 0.0000000977 0.0000024557 0.0000024557 0.0000024557 + -0.4226039246 0.0000001718 0.0000040847 0.0000040846 0.0000040846 + -0.4041048797 0.0000002994 0.0000067317 0.0000067315 0.0000067316 + -0.3856058347 0.0000005171 0.0000109920 0.0000109917 0.0000109919 + -0.3671067898 0.0000008847 0.0000177833 0.0000177829 0.0000177831 + -0.3486077449 0.0000014998 0.0000285059 0.0000285053 0.0000285057 + -0.3301086999 0.0000025190 0.0000452735 0.0000452726 0.0000452731 + -0.3116096550 0.0000041921 0.0000712424 0.0000712410 0.0000712419 + -0.2931106101 0.0000069123 0.0001110757 0.0001110734 0.0001110748 + -0.2746115652 0.0000112926 0.0001715872 0.0001715837 0.0001715858 + -0.2561125202 0.0000182790 0.0002626252 0.0002626200 0.0002626232 + -0.2376134753 0.0000293154 0.0003982663 0.0003982587 0.0003982633 + -0.2191144304 0.0000465827 0.0005984068 0.0005983956 0.0005984024 + -0.2006153855 0.0000733398 0.0008908512 0.0008908349 0.0008908448 + -0.1821163405 0.0001144037 0.0013140124 0.0013139890 0.0013140033 + -0.1636172956 0.0001768179 0.0019203460 0.0019203126 0.0019203329 + -0.1451182507 0.0002707685 0.0027806426 0.0027805955 0.0027806241 + -0.1266192058 0.0004108239 0.0039892988 0.0039892328 0.0039892729 + -0.1081201608 0.0006175881 0.0056706604 0.0056705691 0.0056706246 + -0.0896211159 0.0009198728 0.0079864984 0.0079863732 0.0079864493 + -0.0711220710 0.0013575080 0.0111446097 0.0111444398 0.0111445431 + -0.0526230261 0.0019849185 0.0154084520 0.0154082237 0.0154083626 + -0.0341239811 0.0028756013 0.0211075997 0.0211072960 0.0211074806 + -0.0156249362 0.0041276259 0.0286486641 0.0286482642 0.0286485074 + 0.0028741087 0.0058702648 0.0385261484 0.0385256272 0.0385259442 + 0.0213731536 0.0082718136 0.0513325101 0.0513318376 0.0513322466 + 0.0398721986 0.0115486038 0.0677665068 0.0677656481 0.0677661703 + 0.0583712435 0.0159751119 0.0886387019 0.0886376168 0.0886382766 + 0.0768702884 0.0218949536 0.1148728418 0.1148714849 0.1148723100 + 0.0953693333 0.0297323912 0.1475017026 0.1475000236 0.1475010446 + 0.1138683783 0.0400038084 0.1876559727 0.1876539172 0.1876551671 + 0.1323674232 0.0533283968 0.2365448189 0.2365423294 0.2365438432 + 0.1508664681 0.0704370904 0.2954269961 0.2954240138 0.2954258273 + 0.1693655130 0.0921785724 0.3655717328 0.3655681993 0.3655703479 + 0.1878645580 0.1195210054 0.4482091581 0.4482050183 0.4482075355 + 0.2063636029 0.1535480084 0.5444707267 0.5444659315 0.5444688471 + 0.2248626478 0.1954473688 0.6553209226 0.6553154325 0.6553187706 + 0.2433616927 0.2464910521 0.7814824388 0.7814762273 0.7814800039 + 0.2618607377 0.3080052924 0.9233579705 0.9233510277 0.9233552488 + 0.2803597826 0.3813299264 1.0809526530 1.0809449894 1.0809496486 + 0.2988588275 0.4677666881 1.2538019220 1.2537935712 1.2537986480 + 0.3173578725 0.5685169025 1.4409100845 1.4409011061 1.4409065642 + 0.3358569174 0.6846098796 1.6407050718 1.6406955528 1.6407013392 + 0.3543559623 0.8168242699 1.8510146262 1.8510046818 1.8510107265 + 0.3728550072 0.9656056416 2.0690685068 2.0690582793 2.0690644957 + 0.3913540522 1.1309844812 2.2915301751 2.2915198318 2.2915261181 + 0.4098530971 1.3124996228 2.5145598718 2.5145496014 2.5145558427 + 0.4283521420 1.5091326628 2.7339091024 2.7338991099 2.7339051816 + 0.4468511869 1.7192591347 2.9450444320 2.9450349321 2.9450407036 + 0.4653502319 1.9406220081 3.1432963044 3.1432875146 3.1432928536 + 0.4838492768 2.1703324017 3.3240265395 3.3240186714 3.3240234493 + 0.5023483217 2.4049012398 3.4828063961 3.4827996475 3.4828037441 + 0.5208473666 2.6403039680 3.6155958086 3.6155903550 3.6155936634 + 0.5393464116 2.8720784652 3.7189137420 3.7189097292 3.7189121609 + 0.5578454565 3.0954540604 3.7899896713 3.7899872090 3.7899886973 + 0.5763445014 3.3055072614 3.8268869916 3.8268861483 3.8268866516 + 0.5948435463 3.4973376091 3.8285906907 3.8285914908 3.8285909944 + 0.6133425913 3.6662551910 3.7950537433 3.7950561658 3.7950546825 + 0.6318416362 3.8079699605 3.7271992675 3.7272032469 3.7272008167 + 0.6503406811 3.9187722744 3.6268783062 3.6268837357 3.6268804236 + 0.6688397260 3.9956940765 3.4967859269 3.4967926630 3.4967885565 + 0.6873387710 4.0366409629 3.3403409492 3.3403488180 3.3403440228 + 0.7058378159 4.0404869307 3.1615367878 3.1615455928 3.1615402285 + 0.7243368608 4.0071258264 2.9647724876 2.9647820174 2.9647762127 + 0.7428359057 3.9374762146 2.7546738997 2.7546839370 2.7546778241 + 0.7613349507 3.8334393541 2.5359150817 2.5359254106 2.5359191209 + 0.7798339956 3.6978129649 2.3130494051 2.3130598194 2.3130534783 + 0.7983330405 3.5341662459 2.0903586300 2.0903689391 2.0903626626 + 0.8168320854 3.3466839331 1.8717264800 1.8717365145 1.8717304055 + 0.8353311304 3.1399889004 1.6605412076 1.6605508228 1.6605449694 + 0.8538301753 2.9189537727 1.4596294606 1.4596385391 1.4596330128 + 0.8723292202 2.6885121997 1.2712216291 1.2712300816 1.2712249365 + 0.8908282651 2.4534798526 1.0969469294 1.0969546940 1.0969499678 + 0.9093273101 2.2183939421 0.9378548964 0.9378619376 0.9378576519 + 0.9278263550 1.9873782628 0.7944587884 0.7944650941 0.7944612562 + 0.9463253999 1.7640386253 0.6667956949 0.6668012736 0.6667978783 + 0.9648244449 1.5513912411 0.5544978811 0.5545027583 0.5544997900 + 0.9833234898 1.3518243664 0.4568700456 0.4568742603 0.4568716952 + 1.0018225347 1.1670914714 0.3729676539 0.3729712547 0.3729690633 + 1.0203215796 0.9983325029 0.3016722363 0.3016752783 0.3016734270 + 1.0388206246 0.8461185495 0.2417604230 0.2417629647 0.2417614179 + 1.0573196695 0.7105144451 0.1919644289 0.1919665295 0.1919652512 + 1.0758187144 0.5911535438 0.1510226219 0.1510243393 0.1510232941 + 1.0943177593 0.4873190324 0.1177196440 0.1177210333 0.1177201879 + 1.1128168043 0.3980266387 0.0909162606 0.0909173726 0.0909166959 + 1.1313158492 0.3221043538 0.0695696598 0.0695705405 0.0695700046 + 1.1498148941 0.2582657056 0.0527453143 0.0527460047 0.0527455846 + 1.1683139390 0.2051741191 0.0396217433 0.0396222789 0.0396219529 + 1.1868129840 0.1614968679 0.0294896056 0.0294900169 0.0294897667 + 1.2053120289 0.1259480130 0.0217465336 0.0217468462 0.0217466560 + 1.2238110738 0.0973204766 0.0158890088 0.0158892441 0.0158891009 + 1.2423101187 0.0745079859 0.0115024210 0.0115025963 0.0115024897 + 1.2608091637 0.0565180424 0.0082502557 0.0082503849 0.0082503063 + 1.2793082086 0.0424773180 0.0058631532 0.0058632476 0.0058631901 + 1.2978072535 0.0316309878 0.0041283905 0.0041284587 0.0041284172 + 1.3163062984 0.0233374882 0.0028801558 0.0028802046 0.0028801749 + 1.3348053434 0.0170600838 0.0019908424 0.0019908770 0.0019908560 + 1.3533043883 0.0123564551 0.0013634634 0.0013634877 0.0013634729 + 1.3718034332 0.0088673188 0.0009252003 0.0009252172 0.0009252069 + 1.3903024781 0.0063048744 0.0006220335 0.0006220451 0.0006220380 + 1.4088015231 0.0044416696 0.0004143596 0.0004143675 0.0004143627 + 1.4273005680 0.0031002859 0.0002734808 0.0002734861 0.0002734828 + 1.4457996129 0.0021440896 0.0001788388 0.0001788424 0.0001788402 + 1.4642986578 0.0014691624 0.0001158731 0.0001158754 0.0001158740 + 1.4827977028 0.0009974299 0.0000743856 0.0000743872 0.0000743862 + 1.5012967477 0.0006709353 0.0000473131 0.0000473141 0.0000473135 + 1.5197957926 0.0004471617 0.0000298167 0.0000298173 0.0000298169 + 1.5382948375 0.0002952801 0.0000186175 0.0000186180 0.0000186177 + 1.5567938825 0.0001931922 0.0000115179 0.0000115181 0.0000115180 + 1.5752929274 0.0001252364 0.0000070600 0.0000070602 0.0000070601 + 1.5937919723 0.0000804373 0.0000042877 0.0000042878 0.0000042878 + 1.6122910172 0.0000511882 0.0000025801 0.0000025801 0.0000025801 + 1.6307900622 0.0000322751 0.0000015382 0.0000015383 0.0000015383 + 1.6492891071 0.0000201628 0.0000009087 0.0000009087 0.0000009087 + 1.6677881520 0.0000124802 0.0000005318 0.0000005318 0.0000005318 + 1.6862871970 0.0000076538 0.0000003084 0.0000003084 0.0000003084 + 1.7047862419 0.0000046507 0.0000001772 0.0000001772 0.0000001772 + 1.7232852868 0.0000027999 0.0000001009 0.0000001009 0.0000001009 + 1.7417843317 0.0000016702 0.0000000569 0.0000000569 0.0000000569 + 1.7602833767 0.0000009871 0.0000000318 0.0000000318 0.0000000318 + 1.7787824216 0.0000005780 0.0000000176 0.0000000176 0.0000000176 + 1.7972814665 0.0000003354 0.0000000097 0.0000000097 0.0000000097 + 1.8157805114 0.0000001928 0.0000000052 0.0000000053 0.0000000053 + 1.8342795564 0.0000001098 0.0000000028 0.0000000028 0.0000000028 + 1.8527786013 0.0000000620 0.0000000015 0.0000000015 0.0000000015 + 1.8712776462 0.0000000346 0.0000000008 0.0000000008 0.0000000008 + 1.8897766911 0.0000000192 0.0000000004 0.0000000004 0.0000000004 + 1.9082757361 0.0000000105 0.0000000002 0.0000000002 0.0000000002 + 1.9267747810 0.0000000057 0.0000000001 0.0000000001 0.0000000001 + 1.9452738259 0.0000000031 0.0000000001 0.0000000001 0.0000000001 + 1.9637728708 0.0000000016 0.0000000000 0.0000000000 0.0000000000 + 1.9822719158 0.0000000009 0.0000000000 0.0000000000 0.0000000000 + 2.0007709607 0.0000000005 0.0000000000 0.0000000000 0.0000000000 + 2.0192700056 0.0000000002 0.0000000000 0.0000000000 0.0000000000 + 2.0377690505 0.0000000001 0.0000000000 0.0000000000 0.0000000000 + 2.0562680955 0.0000000001 0.0000000000 0.0000000000 0.0000000000 + 2.0747671404 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0932661853 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1117652302 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1302642752 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1487633201 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1672623650 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1857614099 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2042604549 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2227594998 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2412585447 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2597575896 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2782566346 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2967556795 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3152547244 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3337537694 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3522528143 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3707518592 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3892509041 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4077499491 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4262489940 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4447480389 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4632470838 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4817461288 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5002451737 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5187442186 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5372432635 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5557423085 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5742413534 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5927403983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6112394432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6297384882 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6482375331 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6667365780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6852356229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7037346679 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7222337128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7407327577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7592318026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7777308476 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7962298925 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8147289374 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8332279823 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8517270273 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8702260722 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8887251171 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9072241620 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9257232070 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9442222519 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9627212968 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9812203418 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9997193867 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0182184316 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0367174765 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0552165215 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0737155664 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0922146113 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1107136562 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1292127012 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1477117461 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1662107910 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1847098359 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2032088809 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2217079258 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2402069707 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2587060156 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2772050606 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2957041055 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3142031504 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3327021953 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3512012403 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3697002852 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3881993301 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4066983750 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4251974200 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4436964649 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4621955098 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4806945547 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4991935997 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5176926446 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5361916895 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5546907344 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5731897794 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5916888243 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6101878692 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6286869142 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6471859591 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6656850040 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6841840489 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7026830939 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7211821388 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7396811837 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7581802286 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7766792736 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7951783185 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8136773634 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8321764083 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8506754533 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8691744982 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8876735431 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9061725880 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9246716330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9431706779 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9616697228 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9801687677 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9986678127 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0171668576 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0356659025 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0541649474 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0726639924 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0911630373 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1096620822 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1281611271 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1466601721 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1651592170 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1836582619 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2021573068 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2206563518 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2391553967 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2576544416 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2761534865 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2946525315 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3131515764 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3316506213 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3501496663 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3686487112 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3871477561 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4056468010 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4241458460 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4426448909 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4611439358 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4796429807 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4981420257 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5166410706 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5351401155 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5536391604 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5721382054 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5906372503 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6091362952 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6276353401 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6461343851 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6646334300 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6831324749 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7016315198 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7201305648 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7386296097 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7571286546 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7756276995 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7941267445 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8126257894 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8311248343 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8496238792 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8681229242 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8866219691 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9051210140 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9236200589 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9421191039 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9606181488 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9791171937 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9976162387 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0161152836 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0346143285 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0531133734 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0716124184 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0901114633 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1086105082 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1271095531 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1456085981 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1641076430 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1826066879 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2011057328 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2196047778 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2381038227 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2566028676 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2751019125 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2936009575 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3121000024 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3305990473 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3490980922 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3675971372 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3860961821 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4045952270 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4230942719 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4415933169 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4600923618 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4785914067 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4970904516 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5155894966 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5340885415 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5525875864 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5710866313 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5895856763 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6080847212 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6265837661 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6450828111 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6635818560 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6820809009 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7005799458 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7190789908 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7375780357 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7560770806 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7745761255 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7930751705 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8115742154 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8300732603 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8485723052 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8670713502 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8855703951 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9040694400 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9225684849 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9410675299 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9595665748 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9780656197 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9965646646 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0150637096 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0335627545 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0520617994 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0705608443 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0890598893 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1075589342 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1260579791 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1445570240 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1630560690 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1815551139 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2000541588 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2185532037 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2370522487 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2555512936 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2740503385 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2925493835 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3110484284 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3295474733 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3480465182 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3665455632 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3850446081 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4035436530 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4220426979 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4405417429 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4590407878 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4775398327 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4960388776 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5145379226 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5330369675 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5515360124 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5700350573 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5885341023 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6070331472 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6255321921 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6440312370 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6625302820 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6810293269 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6995283718 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7180274167 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7365264617 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7550255066 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7735245515 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7920235964 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8105226414 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8290216863 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8475207312 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8660197761 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8845188211 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9030178660 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9215169109 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9400159558 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9585150008 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9770140457 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9955130906 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0140121356 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0325111805 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0510102254 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0695092703 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0880083153 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1065073602 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1250064051 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1435054500 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1620044950 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1805035399 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1990025848 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2175016297 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2360006747 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2544997196 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2729987645 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2914978094 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3099968544 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3284958993 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3469949442 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3654939891 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3839930341 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4024920790 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4209911239 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4394901688 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4579892138 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4764882587 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4949873036 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5134863485 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5319853935 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5504844384 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5689834833 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5874825282 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6059815732 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6244806181 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6429796630 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6614787080 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6799777529 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6984767978 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7169758427 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7354748877 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7539739326 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7724729775 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7909720224 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8094710674 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8279701123 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8464691572 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8649682021 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8834672471 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9019662920 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9204653369 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9389643818 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9574634268 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9759624717 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9944615166 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0129605615 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0314596065 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0499586514 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0684576963 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0869567412 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1054557862 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1239548311 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1424538760 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1609529209 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1794519659 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1979510108 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2164500557 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2349491006 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2534481456 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2719471905 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2904462354 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3089452804 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3274443253 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3459433702 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3644424151 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3829414601 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4014405050 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4199395499 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4384385948 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4569376398 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4754366847 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4939357296 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5124347745 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5309338195 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5494328644 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5679319093 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5864309542 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6049299992 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6234290441 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6419280890 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6604271339 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6789261789 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6974252238 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7159242687 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7344233136 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7529223586 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7714214035 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7899204484 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8084194933 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8269185383 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8454175832 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8639166281 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8824156730 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9009147180 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9194137629 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9379128078 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9564118528 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9749108977 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9934099426 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0119089875 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0304080325 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0489070774 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0674061223 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0859051672 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1044042122 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1229032571 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1414023020 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1599013469 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1784003919 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1968994368 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2153984817 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2338975266 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2523965716 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2708956165 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2893946614 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3078937063 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3263927513 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3448917962 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3633908411 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3818898860 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4003889310 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4188879759 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4373870208 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4558860657 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4743851107 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4928841556 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5113832005 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5298822454 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5483812904 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5668803353 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5853793802 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6038784251 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6223774701 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6408765150 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6593755599 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6778746049 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6963736498 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7148726947 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7333717396 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7518707846 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7703698295 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7888688744 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8073679193 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8258669643 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8443660092 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8628650541 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8813640990 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8998631440 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9183621889 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9368612338 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9553602787 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9738593237 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9923583686 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0108574135 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0293564584 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0478555034 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0663545483 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0848535932 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1033526381 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1218516831 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1403507280 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1588497729 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1773488178 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1958478628 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2143469077 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2328459526 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2513449975 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2698440425 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2883430874 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3068421323 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3253411773 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3438402222 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3623392671 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3808383120 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3993373570 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4178364019 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4363354468 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4548344917 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4733335367 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4918325816 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5103316265 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5288306714 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5473297164 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5658287613 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5843278062 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6028268511 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6213258961 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6398249410 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6583239859 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6768230308 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6953220758 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7138211207 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7323201656 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7508192105 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7693182555 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7878173004 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8063163453 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8248153902 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8433144352 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8618134801 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8803125250 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8988115699 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9173106149 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9358096598 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9543087047 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9728077497 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9913067946 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0098058395 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0283048844 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0468039294 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0653029743 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0838020192 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1023010641 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1208001091 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1392991540 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1577981989 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1762972438 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1947962888 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2132953337 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2317943786 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2502934235 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2687924685 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2872915134 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3057905583 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3242896032 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3427886482 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3612876931 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3797867380 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3982857829 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4167848279 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4352838728 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4537829177 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4722819626 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4907810076 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5092800525 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5277790974 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5462781423 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5647771873 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5832762322 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6017752771 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6202743221 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6387733670 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6572724119 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6757714568 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6942705018 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7127695467 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7312685916 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7497676365 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7682666815 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7867657264 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8052647713 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8237638162 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8422628612 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8607619061 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8792609510 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8977599959 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9162590409 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9347580858 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9532571307 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9717561756 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9902552206 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0087542655 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0272533104 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0457523553 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0642514003 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0827504452 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1012494901 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1197485350 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1382475800 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1567466249 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1752456698 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1937447147 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2122437597 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2307428046 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2492418495 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2677408944 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2862399394 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3047389843 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3232380292 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3417370742 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3602361191 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3787351640 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3972342089 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4157332539 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4342322988 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4527313437 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4712303886 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4897294336 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5082284785 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5267275234 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5452265683 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5637256133 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5822246582 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6007237031 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6192227480 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6377217930 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6562208379 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6747198828 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6932189277 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7117179727 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7302170176 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7487160625 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7672151074 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7857141524 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8042131973 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8227122422 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8412112871 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8597103321 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8782093770 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8967084219 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9152074668 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9337065118 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9522055567 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9707046016 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9892036466 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0077026915 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0262017364 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0447007813 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0631998263 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0816988712 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1001979161 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1186969610 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1371960060 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1556950509 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1741940958 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1926931407 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2111921857 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2296912306 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2481902755 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2666893204 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2851883654 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3036874103 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3221864552 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3406855001 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3591845451 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3776835900 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3961826349 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4146816798 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4331807248 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4516797697 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4701788146 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4886778595 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5071769045 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5256759494 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5441749943 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5626740392 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5811730842 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5996721291 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6181711740 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6366702190 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6551692639 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6736683088 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6921673537 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7106663987 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7291654436 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7476644885 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7661635334 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7846625784 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8031616233 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8216606682 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8401597131 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8586587581 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8771578030 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8956568479 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9141558928 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9326549378 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9511539827 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9696530276 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9881520725 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0066511175 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0251501624 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0436492073 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0621482522 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0806472972 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0991463421 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1176453870 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1361444319 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1546434769 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1731425218 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1916415667 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2101406116 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2286396566 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2471387015 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2656377464 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2841367914 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3026358363 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3211348812 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3396339261 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3581329711 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3766320160 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3951310609 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4136301058 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4321291508 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4506281957 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4691272406 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4876262855 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5061253305 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5246243754 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5431234203 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5616224652 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5801215102 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5986205551 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6171196000 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6356186449 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6541176899 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6726167348 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6911157797 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7096148246 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7281138696 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7466129145 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7651119594 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7836110043 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8021100493 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8206090942 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8391081391 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8576071840 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8761062290 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8946052739 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9131043188 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9316033637 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9501024087 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9686014536 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9871004985 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0055995435 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0240985884 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0425976333 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0610966782 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0795957232 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0980947681 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1165938130 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1350928579 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1535919029 0.0000000000 0.0000000001 0.0000000000 0.0000000000 + 15.1720909478 0.0000000000 0.0000000001 0.0000000000 0.0000000000 + 15.1905899927 0.0000000000 0.0000000002 0.0000000001 0.0000000000 + 15.2090890376 0.0000000000 0.0000000003 0.0000000001 0.0000000001 + 15.2275880826 0.0000000000 0.0000000005 0.0000000002 0.0000000001 + 15.2460871275 0.0000000000 0.0000000009 0.0000000004 0.0000000002 + 15.2645861724 0.0000000000 0.0000000016 0.0000000006 0.0000000004 + 15.2830852173 0.0000000000 0.0000000027 0.0000000011 0.0000000006 + 15.3015842623 0.0000000000 0.0000000046 0.0000000018 0.0000000010 + 15.3200833072 0.0000000000 0.0000000077 0.0000000030 0.0000000017 + 15.3385823521 0.0000000000 0.0000000128 0.0000000049 0.0000000028 + 15.3570813970 0.0000000000 0.0000000211 0.0000000081 0.0000000046 + 15.3755804420 0.0000000000 0.0000000343 0.0000000131 0.0000000074 + 15.3940794869 0.0000000000 0.0000000554 0.0000000211 0.0000000120 + 15.4125785318 0.0000000000 0.0000000886 0.0000000337 0.0000000191 + 15.4310775767 0.0000000000 0.0000001404 0.0000000532 0.0000000302 + 15.4495766217 0.0000000000 0.0000002205 0.0000000832 0.0000000473 + 15.4680756666 0.0000000000 0.0000003430 0.0000001291 0.0000000734 + 15.4865747115 0.0000000000 0.0000005288 0.0000001983 0.0000001129 + 15.5050737564 0.0000000000 0.0000008075 0.0000003019 0.0000001720 + 15.5235728014 0.0000000000 0.0000012220 0.0000004555 0.0000002597 + 15.5420718463 0.0000000000 0.0000018321 0.0000006807 0.0000003886 + 15.5605708912 0.0000000000 0.0000027216 0.0000010081 0.0000005760 + 15.5790699361 0.0000000000 0.0000040058 0.0000014792 0.0000008460 + 15.5975689811 0.0000000000 0.0000058419 0.0000021505 0.0000012311 + 15.6160680260 0.0000000000 0.0000084411 0.0000030978 0.0000017751 + 15.6345670709 0.0000000000 0.0000120849 0.0000044215 0.0000025359 + 15.6530661159 0.0000000000 0.0000171425 0.0000062530 0.0000035897 + 15.6715651608 0.0000000000 0.0000240933 0.0000087619 0.0000050348 + 15.6900642057 0.0000000000 0.0000335513 0.0000121647 0.0000069968 + 15.7085632506 0.0000000000 0.0000462928 0.0000167342 0.0000096340 + 15.7270622956 0.0000000000 0.0000632858 0.0000228090 0.0000131436 + 15.7455613405 0.0000000000 0.0000857217 0.0000308039 0.0000177671 + 15.7640603854 0.0000000000 0.0001150442 0.0000412193 0.0000237966 + 15.7825594303 0.0000000000 0.0001529781 0.0000546503 0.0000315798 + 15.8010584753 0.0000000000 0.0002015506 0.0000717929 0.0000415240 + 15.8195575202 0.0000000000 0.0002631050 0.0000934475 0.0000540984 + 15.8380565651 0.0000000000 0.0003403018 0.0001205176 0.0000698338 + 15.8565556100 0.0000000000 0.0004361034 0.0001540035 0.0000893187 + 15.8750546550 0.0000000000 0.0005537386 0.0001949879 0.0001131916 + 15.8935536999 0.0000000000 0.0006966428 0.0002446140 0.0001421287 + 15.9120527448 0.0000000000 0.0008683714 0.0003040549 0.0001768255 + 15.9305517897 0.0000000000 0.0010724841 0.0003744722 0.0002179732 + 15.9490508347 0.0000000000 0.0013123997 0.0004569659 0.0002662298 + 15.9675498796 0.0000000000 0.0015912239 0.0005525160 0.0003221853 + 15.9860489245 0.0000000000 0.0019115530 0.0006619156 0.0003863223 + 16.0045479694 0.0000000000 0.0022752610 0.0007857006 0.0004589752 + 16.0230470144 0.0000000000 0.0026832793 0.0009240771 0.0005402860 + 16.0415460593 0.0000000000 0.0031353810 0.0010768518 0.0006301636 + 16.0600451042 0.0000000000 0.0036299820 0.0012433697 0.0007282457 + 16.0785441491 0.0000000000 0.0041639770 0.0014224636 0.0008338686 + 16.0970431941 0.0000000000 0.0047326220 0.0016124214 0.0009460460 + 16.1155422390 0.0000000000 0.0053294814 0.0018109749 0.0010634615 + 16.1340412839 0.0000000000 0.0059464485 0.0020153143 0.0011844758 + 16.1525403288 0.0000000000 0.0065738522 0.0022221303 0.0013071500 + 16.1710393738 0.0000000000 0.0072006504 0.0024276868 0.0014292870 + 16.1895384187 0.0000000000 0.0078147126 0.0026279198 0.0015484893 + 16.2080374636 0.0000000000 0.0084031816 0.0028185639 0.0016622320 + 16.2265365085 0.0000000000 0.0089529036 0.0029952971 0.0017679488 + 16.2450355535 0.0000000000 0.0094509065 0.0031539018 0.0018631265 + 16.2635345984 0.0000000000 0.0098849022 0.0032904296 0.0019454028 + 16.2820336433 0.0000000000 0.0102437889 0.0034013646 0.0020126638 + 16.3005326883 0.0000000000 0.0105181208 0.0034837733 0.0020631336 + 16.3190317332 0.0000000000 0.0107005218 0.0035354334 0.0020954528 + 16.3375307781 0.0000000000 0.0107860142 0.0035549333 0.0021087387 + 16.3560298230 0.0000000000 0.0107722450 0.0035417365 0.0021026256 + 16.3745288680 0.0000000000 0.0106595931 0.0034962057 0.0020772817 + 16.3930279129 0.0000000000 0.0104511522 0.0034195867 0.0020334010 + 16.4115269578 0.0000000000 0.0101525895 0.0033139513 0.0019721722 + 16.4300260027 0.0000000000 0.0097718898 0.0031821047 0.0018952248 + 16.4485250477 0.0000000000 0.0093190006 0.0030274611 0.0018045574 + 16.4670240926 0.0000000000 0.0088054011 0.0028538979 0.0017024513 + 16.4855231375 0.0000000000 0.0082436194 0.0026655939 0.0015913754 + 16.5040221824 0.0000000000 0.0076467288 0.0024668639 0.0014738881 + 16.5225212274 0.0000000000 0.0070278481 0.0022619969 0.0013525404 + 16.5410202723 0.0000000000 0.0063996755 0.0020551068 0.0012297867 + 16.5595193172 0.0000000000 0.0057740749 0.0018500025 0.0011079065 + 16.5780183621 0.0000000000 0.0051617351 0.0016500827 0.0009889405 + 16.5965174071 0.0000000000 0.0045719117 0.0014582586 0.0008746432 + 16.6150164520 0.0000000000 0.0040122570 0.0012769056 0.0007664525 + 16.6335154969 0.0000000000 0.0034887385 0.0011078433 0.0006654772 + 16.6520145418 0.0000000000 0.0030056390 0.0009523426 0.0005724989 + 16.6705135868 0.0000000000 0.0025656294 0.0008111541 0.0004879885 + 16.6890126317 0.0000000000 0.0021698999 0.0006845556 0.0004121335 + 16.7075116766 0.0000000000 0.0018183360 0.0005724127 0.0003448734 + 16.7260107215 0.0000000000 0.0015097228 0.0004742473 0.0002859399 + 16.7445097665 0.0000000000 0.0012419636 0.0003893100 0.0002349001 + 16.7630088114 0.0000000000 0.0010122997 0.0003166514 0.0001911986 + 16.7815078563 0.0000000000 0.0008175190 0.0002551891 0.0001541983 + 16.8000069012 0.0000000000 0.0006541467 0.0002037688 0.0001232161 + 16.8185059462 0.0000000000 0.0005186101 0.0001612161 0.0000975548 + 16.8370049911 0.0000000000 0.0004073758 0.0001263787 0.0000765284 + 16.8555040360 0.0000000000 0.0003170574 0.0000981599 0.0000594826 + 16.8740030809 0.0000000000 0.0002444944 0.0000755421 0.0000458089 + 16.8925021259 0.0000000000 0.0001868050 0.0000576021 0.0000349545 + 16.9110011708 0.0000000000 0.0001414153 0.0000435194 0.0000264270 + 16.9295002157 0.0000000000 0.0001060700 0.0000325778 0.0000197964 + 16.9479992607 0.0000000000 0.0000788274 0.0000241633 0.0000146933 + 16.9664983056 0.0000000000 0.0000580430 0.0000177576 0.0000108054 + 16.9849973505 0.0000000000 0.0000423459 0.0000129302 0.0000078733 + 17.0034963954 0.0000000000 0.0000306098 0.0000093287 0.0000056842 + 17.0219954404 0.0000000000 0.0000219229 0.0000066686 0.0000040660 + 17.0404944853 0.0000000000 0.0000155569 0.0000047232 0.0000028818 + 17.0589935302 0.0000000000 0.0000109380 0.0000033147 0.0000020237 + 17.0774925751 0.0000000000 0.0000076197 0.0000023048 0.0000014081 + 17.0959916201 0.0000000000 0.0000052593 0.0000015879 0.0000009707 + 17.1144906650 0.0000000000 0.0000035967 0.0000010839 0.0000006631 + 17.1329897099 0.0000000000 0.0000024371 0.0000007331 0.0000004488 + 17.1514887548 0.0000000000 0.0000016362 0.0000004913 0.0000003009 + 17.1699877998 0.0000000000 0.0000010884 0.0000003262 0.0000001999 + 17.1884868447 0.0000000000 0.0000007173 0.0000002146 0.0000001316 + 17.2069858896 0.0000000000 0.0000004684 0.0000001399 0.0000000859 + 17.2254849345 0.0000000000 0.0000003031 0.0000000904 0.0000000555 + 17.2439839795 0.0000000000 0.0000001943 0.0000000578 0.0000000355 + 17.2624830244 0.0000000000 0.0000001234 0.0000000367 0.0000000225 + 17.2809820693 0.0000000000 0.0000000777 0.0000000230 0.0000000142 + 17.2994811142 0.0000000000 0.0000000484 0.0000000143 0.0000000088 + 17.3179801592 0.0000000000 0.0000000299 0.0000000088 0.0000000054 + 17.3364792041 0.0000000000 0.0000000183 0.0000000054 0.0000000033 + 17.3549782490 0.0000000000 0.0000000111 0.0000000033 0.0000000020 + 17.3734772939 0.0000000000 0.0000000067 0.0000000020 0.0000000012 + 17.3919763389 0.0000000000 0.0000000040 0.0000000012 0.0000000007 + 17.4104753838 0.0000000000 0.0000000023 0.0000000007 0.0000000004 + 17.4289744287 0.0000000000 0.0000000014 0.0000000004 0.0000000002 + 17.4474734736 0.0000000000 0.0000000008 0.0000000002 0.0000000001 + 17.4659725186 0.0000000000 0.0000000005 0.0000000001 0.0000000001 + 17.4844715635 0.0000000000 0.0000000003 0.0000000001 0.0000000000 + 17.5029706084 0.0000000000 0.0000000001 0.0000000000 0.0000000000 + 17.5214696533 0.0000000000 0.0000000001 0.0000000000 0.0000000000 + 17.5399686983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5584677432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5769667881 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5954658330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6139648780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6324639229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6509629678 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6694620128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6879610577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.7064601026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + +:PDOS_INFO: + :ATOM_TYPE: Al + :ATOMIC_NUMBER: 13 + :ATOM_INDEX: 1 + :ATOM_POSITION_CARTESIAN: [3.8266955 3.8266955 0. ] + :ATOM_POSITION_FRACTIONAL: [0.5 0.5 0. ] + :PDOS_UNIT: states/eV + :HEADER_FORMAT: (nl,m) + Energy(eV) (3s, m=0) (3p, m=-1) (3p, m=0) (3p, m=1) + -0.7740857782 0.0000000000 0.0000000001 0.0000000000 0.0000000001 + -0.7555867332 0.0000000000 0.0000000001 0.0000000000 0.0000000001 + -0.7370876883 0.0000000000 0.0000000002 0.0000000001 0.0000000002 + -0.7185886434 0.0000000000 0.0000000004 0.0000000001 0.0000000004 + -0.7000895985 0.0000000000 0.0000000008 0.0000000003 0.0000000008 + -0.6815905535 0.0000000000 0.0000000014 0.0000000005 0.0000000014 + -0.6630915086 0.0000000001 0.0000000027 0.0000000009 0.0000000027 + -0.6445924637 0.0000000001 0.0000000050 0.0000000017 0.0000000050 + -0.6260934188 0.0000000003 0.0000000092 0.0000000033 0.0000000092 + -0.6075943738 0.0000000005 0.0000000167 0.0000000060 0.0000000167 + -0.5890953289 0.0000000010 0.0000000302 0.0000000111 0.0000000302 + -0.5705962840 0.0000000018 0.0000000541 0.0000000201 0.0000000541 + -0.5520972391 0.0000000034 0.0000000960 0.0000000363 0.0000000960 + -0.5335981941 0.0000000063 0.0000001688 0.0000000648 0.0000001688 + -0.5150991492 0.0000000115 0.0000002940 0.0000001146 0.0000002940 + -0.4966001043 0.0000000209 0.0000005074 0.0000002010 0.0000005074 + -0.4781010594 0.0000000377 0.0000008677 0.0000003490 0.0000008677 + -0.4596020144 0.0000000674 0.0000014702 0.0000006007 0.0000014702 + -0.4411029695 0.0000001192 0.0000024682 0.0000010243 0.0000024682 + -0.4226039246 0.0000002090 0.0000041055 0.0000017304 0.0000041055 + -0.4041048797 0.0000003632 0.0000067659 0.0000028966 0.0000067660 + -0.3856058347 0.0000006251 0.0000110479 0.0000048039 0.0000110480 + -0.3671067898 0.0000010661 0.0000178738 0.0000078940 0.0000178739 + -0.3486077449 0.0000018014 0.0000286510 0.0000128524 0.0000286512 + -0.3301086999 0.0000030159 0.0000455039 0.0000207327 0.0000455043 + -0.3116096550 0.0000050028 0.0000716050 0.0000331371 0.0000716055 + -0.2931106101 0.0000082222 0.0001116409 0.0000524755 0.0001116418 + -0.2746115652 0.0000133892 0.0001724603 0.0000823352 0.0001724617 + -0.2561125202 0.0000216027 0.0002639617 0.0001279971 0.0002639637 + -0.2376134753 0.0000345338 0.0004002932 0.0001971517 0.0004002962 + -0.2191144304 0.0000546974 0.0006014523 0.0003008751 0.0006014567 + -0.2006153855 0.0000858372 0.0008953852 0.0004549439 0.0008953916 + -0.1821163405 0.0001334656 0.0013207004 0.0006815772 0.0013207096 + -0.1636172956 0.0002056124 0.0019301203 0.0010117146 0.0019301334 + -0.1451182507 0.0003138446 0.0027947962 0.0014879441 0.0027948148 + -0.1266192058 0.0004746416 0.0040096051 0.0021682080 0.0040096311 + -0.1081201608 0.0007112179 0.0056995262 0.0031304080 0.0056995622 + -0.0896211159 0.0010559058 0.0080271540 0.0044780262 0.0080272033 + -0.0711220710 0.0015532216 0.0112013438 0.0063468468 0.0112014107 + -0.0526230261 0.0022637440 0.0154868947 0.0089128190 0.0154869846 + -0.0341239811 0.0032689398 0.0212150596 0.0124010326 0.0212151792 + -0.0156249362 0.0046770521 0.0287945209 0.0170956768 0.0287946784 + 0.0028741087 0.0066301475 0.0387223002 0.0233507289 0.0387225055 + 0.0213731536 0.0093123622 0.0515938728 0.0316009598 0.0515941377 + 0.0398721986 0.0129593201 0.0681115556 0.0423726666 0.0681118938 + 0.0583712435 0.0178685894 0.0890900413 0.0562933389 0.0890904687 + 0.0768702884 0.0244109122 0.1154577823 0.0740992669 0.1154583168 + 0.0953693333 0.0330417803 0.1482528164 0.0966399071 0.1482534779 + 0.1138683783 0.0443127353 0.1886115933 0.1248776699 0.1886124031 + 0.1323674232 0.0588815683 0.2377494415 0.1598817008 0.2377504223 + 0.1508664681 0.0775203758 0.2969315306 0.2028142298 0.2969327056 + 0.1693655130 0.1011202326 0.3674335583 0.2549081821 0.3674349505 + 0.1878645580 0.1306910781 0.4504919247 0.3174350067 0.4504935559 + 0.2063636029 0.1673553157 0.5472438535 0.3916621038 0.5472457429 + 0.2248626478 0.2123336240 0.6586587482 0.4787998171 0.6586609116 + 0.2433616927 0.2669216023 0.7854629903 0.5799386983 0.7854654380 + 0.2618607377 0.3324561447 0.9280613339 0.6959786113 0.9280640699 + 0.2803597826 0.4102708825 1.0864589486 0.8275521798 1.0864619689 + 0.2988588275 0.5016406442 1.2601889113 0.9749460205 1.2601922026 + 0.3173578725 0.6077156609 1.4482504645 1.1380240627 1.4482540035 + 0.3358569174 0.7294471468 1.6490635380 1.3161579433 1.6490672904 + 0.3543559623 0.8675068677 1.8604448137 1.5081698812 1.8604487343 + 0.3728550072 1.0222042997 2.0796099424 1.7122934994 2.0796139751 + 0.3913540522 1.1934058856 2.3032053899 1.9261577057 2.3032094688 + 0.4098530971 1.3804616220 2.5273718350 2.1467979262 2.5273758860 + 0.4283521420 1.5821446592 2.7478391366 2.3706977191 2.7478430788 + 0.4468511869 1.7966096656 2.9600507577 2.5938621191 2.9600545065 + 0.4653502319 2.0213753449 3.1593133438 2.8119220787 3.1593168137 + 0.4838492768 2.2533356449 3.3409650731 3.0202672043 3.3409681807 + 0.5023483217 2.4888028726 3.5005546268 3.2142018159 3.5005572943 + 0.5208473666 2.7235841751 3.6340213395 3.3891173554 3.6340234975 + 0.5393464116 2.9530907617 3.7378664227 3.5406725413 3.7378680138 + 0.5578454565 3.1724769690 3.8093052164 3.6649715570 3.8093061973 + 0.5763445014 3.3768039804 3.8463912294 3.7587301210 3.8463915731 + 0.5948435463 3.5612209066 3.8481042587 3.8194195792 3.8481039554 + 0.6133425913 3.7211542052 3.8143970216 3.8453802020 3.8143960795 + 0.6318416362 3.8524952425 3.7461973235 3.8358966018 3.7461957683 + 0.6503406811 3.9517753204 3.6453656252 3.7912304885 3.6453634989 + 0.6688397260 4.0163177845 3.5146107160 3.7126086699 3.5146080749 + 0.6873387710 4.0443579113 3.3573688280 3.6021670636 3.3573657404 + 0.7058378159 4.0351230788 3.1776537205 3.4628542883 3.1776502639 + 0.7243368608 3.9888681402 2.9798868532 3.2983009064 2.9798831106 + 0.7428359057 3.9068637372 2.7687176515 3.1126624094 2.7687137085 + 0.7613349507 3.7913383035 2.5488439959 2.9104454096 2.5488399375 + 0.7798339956 3.6453774515 2.3248424691 2.6963271500 2.3248383763 + 0.7983330405 3.4727870826 2.1010166602 2.4749783363 2.1010126081 + 0.8168320854 3.2779286946 1.8812700953 2.2508984862 1.8812661507 + 0.8353311304 3.0655368201 1.6690083057 2.0282715849 1.6690045255 + 0.8538301753 2.8405292233 1.4670723566 1.8108479839 1.4670687871 + 0.8723292202 2.6078203898 1.2777040168 1.6018563659 1.2777006931 + 0.8908282651 2.3721480013 1.1025408170 1.4039474074 1.1025377636 + 0.9093273101 2.1379206245 0.9426376517 1.2191686793 0.9426348827 + 0.9278263550 1.9090928990 0.7985104044 1.0489684957 0.7985079245 + 0.9463253999 1.6890722920 0.6701963618 0.8942249499 0.6701941676 + 0.9648244449 1.4806591790 0.5573259213 0.7552953504 0.5573240030 + 0.9833234898 1.2860198111 0.4592002433 0.6320806996 0.4591985855 + 1.0018225347 1.1066897937 0.3748699830 0.5240997323 0.3748685666 + 1.0203215796 0.9436041465 0.3032109727 0.4305672928 0.3032097760 + 1.0388206246 0.7971489285 0.2429936087 0.3504724020 0.2429926089 + 1.0573196695 0.6672287986 0.1929436447 0.2826521568 0.1929428184 + 1.0758187144 0.5533447440 0.1517930179 0.2258585172 0.1517923423 + 1.0943177593 0.4546764762 0.1183201749 0.1788159818 0.1183196284 + 1.1128168043 0.3701645902 0.0913800730 0.1402690581 0.0913796356 + 1.1313158492 0.2985884117 0.0699245836 0.1090192324 0.0699242371 + 1.1498148941 0.2386364146 0.0530144142 0.0839518072 0.0530141425 + 1.1683139390 0.1889670887 0.0398238950 0.0640534710 0.0398236843 + 1.1868129840 0.1482590863 0.0296400678 0.0484218054 0.0296399060 + 1.2053120289 0.1152503243 0.0218574926 0.0362681145 0.0218573696 + 1.2238110738 0.0887664156 0.0159700832 0.0269150176 0.0159699907 + 1.2423101187 0.0677393306 0.0115611146 0.0197901938 0.0115610457 + 1.2608091637 0.0512175510 0.0082923558 0.0144175384 0.0082923049 + 1.2793082086 0.0383691701 0.0058930732 0.0104068160 0.0058930361 + 1.2978072535 0.0284794563 0.0041494586 0.0074426968 0.0041494317 + 1.3163062984 0.0209443396 0.0028948544 0.0052738584 0.0028948352 + 1.3348053434 0.0152611527 0.0020010028 0.0037026469 0.0020009892 + 1.3533043883 0.0110177699 0.0013704222 0.0025756202 0.0013704126 + 1.3718034332 0.0078810802 0.0009299224 0.0017751581 0.0009299158 + 1.3903024781 0.0055855184 0.0006252084 0.0012122102 0.0006252038 + 1.4088015231 0.0039221745 0.0004164746 0.0008201712 0.0004164715 + 1.4273005680 0.0027288272 0.0002748767 0.0005498153 0.0002748746 + 1.4457996129 0.0018810955 0.0001797517 0.0003651866 0.0001797503 + 1.4642986578 0.0012847876 0.0001164646 0.0002403247 0.0001164637 + 1.4827977028 0.0008694358 0.0000747654 0.0001566996 0.0000747647 + 1.5012967477 0.0005829474 0.0000475546 0.0001012332 0.0000475542 + 1.5197957926 0.0003872639 0.0000299689 0.0000647983 0.0000299686 + 1.5382948375 0.0002549002 0.0000187126 0.0000410951 0.0000187124 + 1.5567938825 0.0001662337 0.0000115767 0.0000258227 0.0000115766 + 1.5752929274 0.0001074123 0.0000070961 0.0000160768 0.0000070960 + 1.5937919723 0.0000687661 0.0000043096 0.0000099171 0.0000043096 + 1.6122910172 0.0000436194 0.0000025933 0.0000060611 0.0000025932 + 1.6307900622 0.0000274140 0.0000015461 0.0000036703 0.0000015461 + 1.6492891071 0.0000170706 0.0000009133 0.0000022022 0.0000009133 + 1.6677881520 0.0000105320 0.0000005345 0.0000013091 0.0000005345 + 1.6862871970 0.0000064382 0.0000003100 0.0000007711 0.0000003100 + 1.7047862419 0.0000038994 0.0000001781 0.0000004500 0.0000001781 + 1.7232852868 0.0000023400 0.0000001014 0.0000002602 0.0000001014 + 1.7417843317 0.0000013913 0.0000000572 0.0000001491 0.0000000572 + 1.7602833767 0.0000008196 0.0000000320 0.0000000846 0.0000000320 + 1.7787824216 0.0000004784 0.0000000177 0.0000000476 0.0000000177 + 1.7972814665 0.0000002767 0.0000000097 0.0000000265 0.0000000097 + 1.8157805114 0.0000001585 0.0000000053 0.0000000146 0.0000000053 + 1.8342795564 0.0000000900 0.0000000028 0.0000000080 0.0000000028 + 1.8527786013 0.0000000506 0.0000000015 0.0000000043 0.0000000015 + 1.8712776462 0.0000000282 0.0000000008 0.0000000023 0.0000000008 + 1.8897766911 0.0000000156 0.0000000004 0.0000000012 0.0000000004 + 1.9082757361 0.0000000085 0.0000000002 0.0000000007 0.0000000002 + 1.9267747810 0.0000000046 0.0000000001 0.0000000003 0.0000000001 + 1.9452738259 0.0000000025 0.0000000001 0.0000000002 0.0000000001 + 1.9637728708 0.0000000013 0.0000000000 0.0000000001 0.0000000000 + 1.9822719158 0.0000000007 0.0000000000 0.0000000000 0.0000000000 + 2.0007709607 0.0000000004 0.0000000000 0.0000000000 0.0000000000 + 2.0192700056 0.0000000002 0.0000000000 0.0000000000 0.0000000000 + 2.0377690505 0.0000000001 0.0000000000 0.0000000000 0.0000000000 + 2.0562680955 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0747671404 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0932661853 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1117652302 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1302642752 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1487633201 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1672623650 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1857614099 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2042604549 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2227594998 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2412585447 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2597575896 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2782566346 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2967556795 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3152547244 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3337537694 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3522528143 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3707518592 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3892509041 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4077499491 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4262489940 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4447480389 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4632470838 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4817461288 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5002451737 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5187442186 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5372432635 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5557423085 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5742413534 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5927403983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6112394432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6297384882 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6482375331 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6667365780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6852356229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7037346679 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7222337128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7407327577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7592318026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7777308476 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7962298925 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8147289374 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8332279823 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8517270273 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8702260722 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8887251171 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9072241620 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9257232070 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9442222519 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9627212968 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9812203418 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9997193867 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0182184316 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0367174765 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0552165215 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0737155664 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0922146113 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1107136562 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1292127012 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1477117461 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1662107910 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1847098359 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2032088809 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2217079258 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2402069707 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2587060156 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2772050606 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2957041055 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3142031504 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3327021953 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3512012403 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3697002852 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3881993301 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4066983750 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4251974200 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4436964649 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4621955098 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4806945547 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4991935997 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5176926446 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5361916895 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5546907344 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5731897794 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5916888243 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6101878692 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6286869142 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6471859591 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6656850040 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6841840489 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7026830939 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7211821388 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7396811837 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7581802286 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7766792736 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7951783185 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8136773634 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8321764083 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8506754533 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8691744982 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8876735431 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9061725880 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9246716330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9431706779 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9616697228 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9801687677 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9986678127 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0171668576 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0356659025 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0541649474 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0726639924 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0911630373 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1096620822 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1281611271 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1466601721 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1651592170 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1836582619 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2021573068 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2206563518 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2391553967 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2576544416 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2761534865 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2946525315 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3131515764 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3316506213 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3501496663 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3686487112 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3871477561 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4056468010 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4241458460 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4426448909 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4611439358 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4796429807 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4981420257 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5166410706 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5351401155 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5536391604 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5721382054 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5906372503 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6091362952 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6276353401 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6461343851 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6646334300 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6831324749 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7016315198 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7201305648 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7386296097 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7571286546 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7756276995 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7941267445 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8126257894 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8311248343 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8496238792 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8681229242 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8866219691 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9051210140 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9236200589 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9421191039 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9606181488 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9791171937 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9976162387 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0161152836 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0346143285 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0531133734 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0716124184 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0901114633 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1086105082 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1271095531 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1456085981 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1641076430 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1826066879 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2011057328 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2196047778 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2381038227 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2566028676 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2751019125 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2936009575 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3121000024 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3305990473 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3490980922 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3675971372 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3860961821 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4045952270 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4230942719 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4415933169 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4600923618 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4785914067 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4970904516 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5155894966 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5340885415 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5525875864 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5710866313 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5895856763 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6080847212 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6265837661 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6450828111 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6635818560 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6820809009 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7005799458 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7190789908 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7375780357 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7560770806 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7745761255 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7930751705 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8115742154 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8300732603 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8485723052 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8670713502 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8855703951 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9040694400 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9225684849 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9410675299 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9595665748 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9780656197 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9965646646 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0150637096 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0335627545 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0520617994 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0705608443 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0890598893 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1075589342 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1260579791 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1445570240 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1630560690 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1815551139 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2000541588 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2185532037 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2370522487 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2555512936 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2740503385 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2925493835 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3110484284 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3295474733 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3480465182 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3665455632 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3850446081 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4035436530 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4220426979 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4405417429 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4590407878 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4775398327 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4960388776 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5145379226 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5330369675 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5515360124 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5700350573 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5885341023 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6070331472 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6255321921 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6440312370 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6625302820 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6810293269 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6995283718 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7180274167 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7365264617 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7550255066 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7735245515 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7920235964 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8105226414 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8290216863 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8475207312 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8660197761 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8845188211 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9030178660 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9215169109 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9400159558 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9585150008 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9770140457 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9955130906 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0140121356 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0325111805 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0510102254 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0695092703 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0880083153 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1065073602 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1250064051 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1435054500 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1620044950 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1805035399 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1990025848 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2175016297 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2360006747 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2544997196 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2729987645 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2914978094 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3099968544 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3284958993 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3469949442 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3654939891 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3839930341 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4024920790 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4209911239 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4394901688 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4579892138 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4764882587 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4949873036 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5134863485 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5319853935 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5504844384 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5689834833 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5874825282 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6059815732 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6244806181 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6429796630 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6614787080 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6799777529 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6984767978 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7169758427 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7354748877 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7539739326 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7724729775 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7909720224 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8094710674 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8279701123 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8464691572 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8649682021 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8834672471 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9019662920 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9204653369 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9389643818 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9574634268 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9759624717 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9944615166 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0129605615 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0314596065 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0499586514 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0684576963 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0869567412 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1054557862 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1239548311 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1424538760 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1609529209 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1794519659 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1979510108 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2164500557 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2349491006 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2534481456 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2719471905 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2904462354 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3089452804 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3274443253 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3459433702 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3644424151 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3829414601 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4014405050 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4199395499 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4384385948 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4569376398 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4754366847 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4939357296 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5124347745 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5309338195 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5494328644 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5679319093 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5864309542 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6049299992 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6234290441 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6419280890 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6604271339 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6789261789 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6974252238 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7159242687 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7344233136 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7529223586 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7714214035 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7899204484 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8084194933 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8269185383 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8454175832 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8639166281 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8824156730 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9009147180 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9194137629 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9379128078 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9564118528 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9749108977 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9934099426 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0119089875 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0304080325 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0489070774 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0674061223 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0859051672 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1044042122 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1229032571 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1414023020 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1599013469 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1784003919 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1968994368 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2153984817 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2338975266 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2523965716 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2708956165 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2893946614 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3078937063 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3263927513 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3448917962 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3633908411 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3818898860 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4003889310 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4188879759 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4373870208 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4558860657 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4743851107 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4928841556 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5113832005 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5298822454 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5483812904 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5668803353 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5853793802 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6038784251 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6223774701 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6408765150 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6593755599 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6778746049 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6963736498 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7148726947 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7333717396 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7518707846 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7703698295 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7888688744 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8073679193 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8258669643 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8443660092 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8628650541 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8813640990 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8998631440 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9183621889 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9368612338 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9553602787 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9738593237 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9923583686 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0108574135 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0293564584 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0478555034 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0663545483 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0848535932 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1033526381 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1218516831 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1403507280 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1588497729 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1773488178 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1958478628 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2143469077 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2328459526 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2513449975 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2698440425 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2883430874 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3068421323 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3253411773 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3438402222 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3623392671 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3808383120 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3993373570 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4178364019 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4363354468 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4548344917 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4733335367 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4918325816 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5103316265 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5288306714 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5473297164 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5658287613 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5843278062 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6028268511 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6213258961 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6398249410 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6583239859 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6768230308 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6953220758 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7138211207 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7323201656 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7508192105 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7693182555 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7878173004 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8063163453 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8248153902 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8433144352 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8618134801 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8803125250 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8988115699 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9173106149 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9358096598 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9543087047 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9728077497 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9913067946 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0098058395 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0283048844 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0468039294 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0653029743 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0838020192 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1023010641 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1208001091 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1392991540 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1577981989 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1762972438 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1947962888 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2132953337 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2317943786 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2502934235 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2687924685 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2872915134 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3057905583 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3242896032 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3427886482 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3612876931 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3797867380 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3982857829 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4167848279 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4352838728 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4537829177 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4722819626 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4907810076 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5092800525 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5277790974 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5462781423 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5647771873 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5832762322 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6017752771 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6202743221 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6387733670 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6572724119 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6757714568 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6942705018 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7127695467 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7312685916 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7497676365 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7682666815 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7867657264 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8052647713 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8237638162 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8422628612 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8607619061 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8792609510 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8977599959 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9162590409 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9347580858 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9532571307 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9717561756 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9902552206 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0087542655 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0272533104 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0457523553 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0642514003 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0827504452 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1012494901 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1197485350 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1382475800 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1567466249 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1752456698 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1937447147 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2122437597 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2307428046 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2492418495 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2677408944 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2862399394 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3047389843 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3232380292 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3417370742 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3602361191 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3787351640 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3972342089 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4157332539 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4342322988 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4527313437 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4712303886 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4897294336 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5082284785 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5267275234 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5452265683 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5637256133 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5822246582 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6007237031 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6192227480 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6377217930 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6562208379 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6747198828 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6932189277 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7117179727 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7302170176 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7487160625 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7672151074 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7857141524 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8042131973 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8227122422 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8412112871 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8597103321 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8782093770 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8967084219 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9152074668 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9337065118 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9522055567 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9707046016 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9892036466 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0077026915 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0262017364 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0447007813 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0631998263 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0816988712 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1001979161 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1186969610 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1371960060 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1556950509 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1741940958 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1926931407 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2111921857 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2296912306 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2481902755 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2666893204 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2851883654 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3036874103 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3221864552 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3406855001 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3591845451 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3776835900 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3961826349 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4146816798 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4331807248 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4516797697 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4701788146 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4886778595 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5071769045 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5256759494 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5441749943 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5626740392 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5811730842 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5996721291 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6181711740 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6366702190 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6551692639 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6736683088 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6921673537 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7106663987 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7291654436 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7476644885 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7661635334 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7846625784 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8031616233 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8216606682 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8401597131 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8586587581 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8771578030 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8956568479 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9141558928 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9326549378 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9511539827 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9696530276 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9881520725 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0066511175 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0251501624 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0436492073 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0621482522 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0806472972 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0991463421 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1176453870 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1361444319 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1546434769 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1731425218 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1916415667 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2101406116 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2286396566 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2471387015 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2656377464 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2841367914 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3026358363 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3211348812 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3396339261 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3581329711 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3766320160 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3951310609 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4136301058 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4321291508 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4506281957 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4691272406 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4876262855 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5061253305 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5246243754 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5431234203 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5616224652 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5801215102 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5986205551 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6171196000 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6356186449 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6541176899 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6726167348 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6911157797 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7096148246 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7281138696 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7466129145 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7651119594 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7836110043 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8021100493 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8206090942 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8391081391 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8576071840 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8761062290 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8946052739 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9131043188 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9316033637 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9501024087 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9686014536 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9871004985 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0055995435 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0240985884 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0425976333 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0610966782 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0795957232 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0980947681 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1165938130 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1350928579 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1535919029 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1720909478 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1905899927 0.0000000000 0.0000000000 0.0000000000 0.0000000001 + 15.2090890376 0.0000000000 0.0000000001 0.0000000000 0.0000000001 + 15.2275880826 0.0000000000 0.0000000001 0.0000000000 0.0000000002 + 15.2460871275 0.0000000000 0.0000000002 0.0000000000 0.0000000003 + 15.2645861724 0.0000000000 0.0000000004 0.0000000000 0.0000000005 + 15.2830852173 0.0000000000 0.0000000006 0.0000000000 0.0000000009 + 15.3015842623 0.0000000000 0.0000000010 0.0000000000 0.0000000014 + 15.3200833072 0.0000000000 0.0000000017 0.0000000000 0.0000000024 + 15.3385823521 0.0000000000 0.0000000028 0.0000000000 0.0000000040 + 15.3570813970 0.0000000000 0.0000000047 0.0000000000 0.0000000066 + 15.3755804420 0.0000000001 0.0000000076 0.0000000000 0.0000000107 + 15.3940794869 0.0000000001 0.0000000123 0.0000000000 0.0000000173 + 15.4125785318 0.0000000002 0.0000000197 0.0000000001 0.0000000277 + 15.4310775767 0.0000000002 0.0000000313 0.0000000001 0.0000000438 + 15.4495766217 0.0000000004 0.0000000492 0.0000000001 0.0000000688 + 15.4680756666 0.0000000006 0.0000000766 0.0000000002 0.0000001071 + 15.4865747115 0.0000000009 0.0000001182 0.0000000003 0.0000001650 + 15.5050737564 0.0000000014 0.0000001808 0.0000000005 0.0000002520 + 15.5235728014 0.0000000021 0.0000002739 0.0000000007 0.0000003813 + 15.5420718463 0.0000000032 0.0000004111 0.0000000011 0.0000005717 + 15.5605708912 0.0000000048 0.0000006114 0.0000000016 0.0000008491 + 15.5790699361 0.0000000070 0.0000009010 0.0000000023 0.0000012497 + 15.5975689811 0.0000000102 0.0000013156 0.0000000033 0.0000018224 + 15.6160680260 0.0000000147 0.0000019032 0.0000000048 0.0000026331 + 15.6345670709 0.0000000210 0.0000027280 0.0000000069 0.0000037695 + 15.6530661159 0.0000000298 0.0000038742 0.0000000098 0.0000053467 + 15.6715651608 0.0000000418 0.0000054513 0.0000000137 0.0000075142 + 15.6900642057 0.0000000582 0.0000075999 0.0000000190 0.0000104632 + 15.7085632506 0.0000000802 0.0000104979 0.0000000262 0.0000144358 + 15.7270622956 0.0000001095 0.0000143675 0.0000000358 0.0000197336 + 15.7455613405 0.0000001481 0.0000194827 0.0000000484 0.0000267278 + 15.7640603854 0.0000001986 0.0000261758 0.0000000649 0.0000358682 + 15.7825594303 0.0000002638 0.0000348447 0.0000000861 0.0000476921 + 15.8010584753 0.0000003472 0.0000459579 0.0000001133 0.0000628310 + 15.8195575202 0.0000004528 0.0000600578 0.0000001476 0.0000820147 + 15.8380565651 0.0000005850 0.0000777614 0.0000001906 0.0001060718 + 15.8565556100 0.0000007489 0.0000997574 0.0000002439 0.0001359248 + 15.8750546550 0.0000009500 0.0001267977 0.0000003092 0.0001725789 + 15.8935536999 0.0000011939 0.0001596849 0.0000003884 0.0002171036 + 15.9120527448 0.0000014867 0.0001992516 0.0000004834 0.0002706054 + 15.9305517897 0.0000018344 0.0002463348 0.0000005961 0.0003341920 + 15.9490508347 0.0000022425 0.0003017419 0.0000007283 0.0004089271 + 15.9675498796 0.0000027162 0.0003662108 0.0000008818 0.0004957763 + 15.9860489245 0.0000032598 0.0004403648 0.0000010577 0.0005955466 + 16.0045479694 0.0000038763 0.0005246622 0.0000012571 0.0007088197 + 16.0230470144 0.0000045670 0.0006193452 0.0000014803 0.0008358836 + 16.0415460593 0.0000053314 0.0007243885 0.0000017272 0.0009766654 + 16.0600451042 0.0000061666 0.0008394526 0.0000019968 0.0011306696 + 16.0785441491 0.0000070671 0.0009638437 0.0000022872 0.0012969271 + 16.0970431941 0.0000080247 0.0010964853 0.0000025958 0.0014739584 + 16.1155422390 0.0000090284 0.0012359043 0.0000029191 0.0016597579 + 16.1340412839 0.0000100643 0.0013802339 0.0000032524 0.0018517999 + 16.1525403288 0.0000111160 0.0015272365 0.0000035905 0.0020470720 + 16.1710393738 0.0000121649 0.0016743480 0.0000039274 0.0022421357 + 16.1895384187 0.0000131904 0.0018187415 0.0000042565 0.0024332143 + 16.2080374636 0.0000141710 0.0019574109 0.0000045707 0.0026163056 + 16.2265365085 0.0000150847 0.0020872709 0.0000048631 0.0027873160 + 16.2450355535 0.0000159098 0.0022052683 0.0000051267 0.0029422091 + 16.2635345984 0.0000166259 0.0023084998 0.0000053549 0.0030771623 + 16.2820336433 0.0000172147 0.0023943303 0.0000055420 0.0031887230 + 16.3005326883 0.0000176605 0.0024605039 0.0000056829 0.0032739548 + 16.3190317332 0.0000179515 0.0025052429 0.0000057739 0.0033305657 + 16.3375307781 0.0000180797 0.0025273269 0.0000058124 0.0033570109 + 16.3560298230 0.0000180415 0.0025261480 0.0000057975 0.0033525626 + 16.3745288680 0.0000178380 0.0025017387 0.0000057295 0.0033173431 + 16.3930279129 0.0000174748 0.0024547704 0.0000056104 0.0032523195 + 16.4115269578 0.0000169617 0.0023865229 0.0000054432 0.0031592596 + 16.4300260027 0.0000163124 0.0022988261 0.0000052326 0.0030406517 + 16.4485250477 0.0000155439 0.0021939788 0.0000049838 0.0028995946 + 16.4670240926 0.0000146755 0.0020746484 0.0000047034 0.0027396626 + 16.4855231375 0.0000137284 0.0019437588 0.0000043979 0.0025647559 + 16.5040221824 0.0000127243 0.0018043717 0.0000040745 0.0023789435 + 16.5225212274 0.0000116854 0.0016595694 0.0000037402 0.0021863080 + 16.5410202723 0.0000106327 0.0015123441 0.0000034019 0.0019907999 + 16.5595193172 0.0000095860 0.0013654997 0.0000030657 0.0017961101 + 16.5780183621 0.0000085629 0.0012215700 0.0000027373 0.0016055628 + 16.5965174071 0.0000075787 0.0010827567 0.0000024217 0.0014220361 + 16.6150164520 0.0000066460 0.0009508877 0.0000021228 0.0012479089 + 16.6335154969 0.0000057746 0.0008273958 0.0000018437 0.0010850359 + 16.6520145418 0.0000049713 0.0007133179 0.0000015866 0.0009347473 + 16.6705135868 0.0000042404 0.0006093107 0.0000013528 0.0007978720 + 16.6890126317 0.0000035838 0.0005156799 0.0000011428 0.0006747782 + 16.7075116766 0.0000030010 0.0004324216 0.0000009566 0.0005654284 + 16.7260107215 0.0000024899 0.0003592695 0.0000007934 0.0004694432 + 16.7445097665 0.0000020468 0.0002957461 0.0000006520 0.0003861689 + 16.7630088114 0.0000016672 0.0002412145 0.0000005308 0.0003147460 + 16.7815078563 0.0000013455 0.0001949278 0.0000004282 0.0002541744 + 16.8000069012 0.0000010758 0.0001560737 0.0000003423 0.0002033724 + 16.8185059462 0.0000008524 0.0001238145 0.0000002711 0.0001612282 + 16.8370049911 0.0000006691 0.0000973193 0.0000002127 0.0001266422 + 16.8555040360 0.0000005204 0.0000757901 0.0000001654 0.0000985609 + 16.8740030809 0.0000004010 0.0000584806 0.0000001274 0.0000760010 + 16.8925021259 0.0000003062 0.0000447091 0.0000000972 0.0000580661 + 16.9110011708 0.0000002317 0.0000338662 0.0000000735 0.0000439556 + 16.9295002157 0.0000001736 0.0000254169 0.0000000551 0.0000329682 + 16.9479992607 0.0000001290 0.0000189002 0.0000000409 0.0000244998 + 16.9664983056 0.0000000949 0.0000139249 0.0000000301 0.0000180393 + 16.9849973505 0.0000000692 0.0000101650 0.0000000219 0.0000131603 + 17.0034963954 0.0000000500 0.0000073520 0.0000000158 0.0000095126 + 17.0219954404 0.0000000358 0.0000052686 0.0000000113 0.0000068127 + 17.0404944853 0.0000000254 0.0000037408 0.0000000080 0.0000048343 + 17.0589935302 0.0000000178 0.0000026316 0.0000000056 0.0000033989 + 17.0774925751 0.0000000124 0.0000018343 0.0000000039 0.0000023677 + 17.0959916201 0.0000000086 0.0000012667 0.0000000027 0.0000016342 + 17.1144906650 0.0000000059 0.0000008668 0.0000000019 0.0000011175 + 17.1329897099 0.0000000040 0.0000005876 0.0000000013 0.0000007572 + 17.1514887548 0.0000000027 0.0000003947 0.0000000008 0.0000005083 + 17.1699877998 0.0000000018 0.0000002627 0.0000000006 0.0000003381 + 17.1884868447 0.0000000012 0.0000001732 0.0000000004 0.0000002228 + 17.2069858896 0.0000000008 0.0000001132 0.0000000002 0.0000001455 + 17.2254849345 0.0000000005 0.0000000733 0.0000000002 0.0000000941 + 17.2439839795 0.0000000003 0.0000000470 0.0000000001 0.0000000603 + 17.2624830244 0.0000000002 0.0000000299 0.0000000001 0.0000000383 + 17.2809820693 0.0000000001 0.0000000188 0.0000000000 0.0000000241 + 17.2994811142 0.0000000001 0.0000000117 0.0000000000 0.0000000150 + 17.3179801592 0.0000000000 0.0000000072 0.0000000000 0.0000000093 + 17.3364792041 0.0000000000 0.0000000044 0.0000000000 0.0000000057 + 17.3549782490 0.0000000000 0.0000000027 0.0000000000 0.0000000034 + 17.3734772939 0.0000000000 0.0000000016 0.0000000000 0.0000000021 + 17.3919763389 0.0000000000 0.0000000010 0.0000000000 0.0000000012 + 17.4104753838 0.0000000000 0.0000000006 0.0000000000 0.0000000007 + 17.4289744287 0.0000000000 0.0000000003 0.0000000000 0.0000000004 + 17.4474734736 0.0000000000 0.0000000002 0.0000000000 0.0000000002 + 17.4659725186 0.0000000000 0.0000000001 0.0000000000 0.0000000001 + 17.4844715635 0.0000000000 0.0000000001 0.0000000000 0.0000000001 + 17.5029706084 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5214696533 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5399686983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5584677432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5769667881 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5954658330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6139648780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6324639229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6509629678 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6694620128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6879610577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.7064601026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + +:PDOS_INFO: + :ATOM_TYPE: Al + :ATOMIC_NUMBER: 13 + :ATOM_INDEX: 2 + :ATOM_POSITION_CARTESIAN: [3.8266955 0. 3.8266955] + :ATOM_POSITION_FRACTIONAL: [0.5 0. 0.5] + :PDOS_UNIT: states/eV + :HEADER_FORMAT: (nl,m) + Energy(eV) (3s, m=0) (3p, m=-1) (3p, m=0) (3p, m=1) + -0.7740857782 0.0000000000 0.0000000000 0.0000000001 0.0000000001 + -0.7555867332 0.0000000000 0.0000000000 0.0000000001 0.0000000001 + -0.7370876883 0.0000000000 0.0000000001 0.0000000002 0.0000000002 + -0.7185886434 0.0000000000 0.0000000001 0.0000000004 0.0000000004 + -0.7000895985 0.0000000000 0.0000000003 0.0000000008 0.0000000008 + -0.6815905535 0.0000000000 0.0000000005 0.0000000014 0.0000000014 + -0.6630915086 0.0000000001 0.0000000009 0.0000000027 0.0000000027 + -0.6445924637 0.0000000001 0.0000000017 0.0000000050 0.0000000050 + -0.6260934188 0.0000000003 0.0000000033 0.0000000092 0.0000000092 + -0.6075943738 0.0000000005 0.0000000060 0.0000000167 0.0000000167 + -0.5890953289 0.0000000010 0.0000000111 0.0000000302 0.0000000302 + -0.5705962840 0.0000000018 0.0000000201 0.0000000541 0.0000000541 + -0.5520972391 0.0000000034 0.0000000363 0.0000000960 0.0000000960 + -0.5335981941 0.0000000063 0.0000000648 0.0000001688 0.0000001688 + -0.5150991492 0.0000000115 0.0000001146 0.0000002940 0.0000002940 + -0.4966001043 0.0000000209 0.0000002010 0.0000005074 0.0000005074 + -0.4781010594 0.0000000377 0.0000003490 0.0000008677 0.0000008677 + -0.4596020144 0.0000000674 0.0000006007 0.0000014702 0.0000014702 + -0.4411029695 0.0000001192 0.0000010243 0.0000024682 0.0000024682 + -0.4226039246 0.0000002090 0.0000017304 0.0000041055 0.0000041054 + -0.4041048797 0.0000003631 0.0000028966 0.0000067659 0.0000067658 + -0.3856058347 0.0000006251 0.0000048039 0.0000110479 0.0000110477 + -0.3671067898 0.0000010660 0.0000078940 0.0000178738 0.0000178735 + -0.3486077449 0.0000018013 0.0000128524 0.0000286510 0.0000286506 + -0.3301086999 0.0000030158 0.0000207327 0.0000455039 0.0000455033 + -0.3116096550 0.0000050026 0.0000331371 0.0000716049 0.0000716040 + -0.2931106101 0.0000082220 0.0000524755 0.0001116409 0.0001116395 + -0.2746115652 0.0000133888 0.0000823352 0.0001724603 0.0001724582 + -0.2561125202 0.0000216020 0.0001279971 0.0002639617 0.0002639585 + -0.2376134753 0.0000345327 0.0001971516 0.0004002932 0.0004002885 + -0.2191144304 0.0000546958 0.0003008751 0.0006014523 0.0006014455 + -0.2006153855 0.0000858346 0.0004549439 0.0008953851 0.0008953752 + -0.1821163405 0.0001334617 0.0006815772 0.0013207003 0.0013206860 + -0.1636172956 0.0002056064 0.0010117145 0.0019301202 0.0019300998 + -0.1451182507 0.0003138357 0.0014879441 0.0027947961 0.0027947672 + -0.1266192058 0.0004746285 0.0021682079 0.0040096050 0.0040095646 + -0.1081201608 0.0007111986 0.0031304078 0.0056995260 0.0056994701 + -0.0896211159 0.0010558779 0.0044780260 0.0080271536 0.0080270771 + -0.0711220710 0.0015531815 0.0063468465 0.0112013433 0.0112012394 + -0.0526230261 0.0022636871 0.0089128186 0.0154868940 0.0154867545 + -0.0341239811 0.0032688596 0.0124010320 0.0212150586 0.0212148730 + -0.0156249362 0.0046769403 0.0170956761 0.0287945196 0.0287942752 + 0.0028741087 0.0066299930 0.0233507279 0.0387222984 0.0387219799 + 0.0213731536 0.0093121511 0.0316009584 0.0515938704 0.0515934594 + 0.0398721986 0.0129590345 0.0423726647 0.0681115525 0.0681110277 + 0.0583712435 0.0178682066 0.0562933364 0.0890900372 0.0890893741 + 0.0768702884 0.0244104046 0.0740992636 0.1154577770 0.1154569477 + 0.0953693333 0.0330411138 0.0966399028 0.1482528097 0.1482517835 + 0.1138683783 0.0443118692 0.1248776644 0.1886115848 0.1886103285 + 0.1323674232 0.0588804543 0.1598816937 0.2377494307 0.2377479093 + 0.1508664681 0.0775189575 0.2028142208 0.2969315171 0.2969296945 + 0.1693655130 0.1011184458 0.2549081707 0.3674335416 0.3674313823 + 0.1878645580 0.1306888504 0.3174349925 0.4504919042 0.4504893744 + 0.2063636029 0.1673525676 0.3916620863 0.5472438286 0.5472408984 + 0.2248626478 0.2123302701 0.4787997957 0.6586587183 0.6586553635 + 0.2433616927 0.2669175529 0.5799386724 0.7854629545 0.7854591591 + 0.2618607377 0.3324513088 0.6959785802 0.9280612917 0.9280570495 + 0.2803597826 0.4102651711 0.8275521429 1.0864588991 1.0864542167 + 0.2988588275 0.5016339743 0.9749459770 1.2601888539 1.2601837519 + 0.3173578725 0.6077079605 1.1380240119 1.4482503986 1.4482449134 + 0.3358569174 0.7294383597 1.3161578845 1.6490634630 1.6490576479 + 0.3543559623 0.8674969596 1.5081698138 1.8604447291 1.8604386545 + 0.3728550072 1.0221932636 1.7122934229 2.0796098478 2.0796036007 + 0.3913540522 1.1933937468 1.9261576196 2.3032052851 2.3031989679 + 0.4098530971 1.3804484432 2.1467978303 2.5273717200 2.5273654481 + 0.4283521420 1.5821305438 2.3706976132 2.7478390115 2.7478329102 + 0.4468511869 1.7965947595 2.5938620033 2.9600506230 2.9600448235 + 0.4653502319 2.0213598371 2.8119219531 3.1593132000 3.1593078353 + 0.4838492768 2.2533197657 3.0202670694 3.3409649210 3.3409601204 + 0.5023483217 2.4887868894 3.2142016723 3.5005544675 3.5005503519 + 0.5208473666 2.7235683861 3.3891172040 3.6340211741 3.6340178506 + 0.5393464116 2.9530754877 3.5406723832 3.7378662526 3.7378638103 + 0.5578454565 3.1724625428 3.6649713933 3.8093050430 3.8093035490 + 0.5763445014 3.3767907353 3.7587299531 3.8463910543 3.8463905504 + 0.5948435463 3.5612091636 3.8194194087 3.8481040836 3.8481045845 + 0.6133425913 3.7211442602 3.8453800303 3.8143968480 3.8143983407 + 0.6318416362 3.8524873540 3.8358964305 3.7461971530 3.7461995974 + 0.6503406811 3.9517696981 3.7912303192 3.6453654593 3.6453687900 + 0.6688397260 4.0163145804 3.7126085041 3.5146105560 3.5146146852 + 0.6873387710 4.0443572122 3.6021669028 3.3573686752 3.3573734965 + 0.7058378159 4.0351249029 3.4628541336 3.1776535759 3.1776589690 + 0.7243368608 3.9888724361 3.2983007591 2.9798867175 2.9798925533 + 0.7428359057 3.9068703863 3.1126622704 2.7687175255 2.7687236708 + 0.7613349507 3.7913471253 2.9104452796 2.5488438799 2.5488502029 + 0.7798339956 3.6453882117 2.6963270296 2.3248423633 2.3248487378 + 0.7983330405 3.4727995036 2.4749782258 2.1010165645 2.1010228741 + 0.8168320854 3.2779424671 2.2508983857 1.8812700096 1.8812761506 + 0.8353311304 3.0655516159 2.0282714943 1.6690082297 1.6690141137 + 0.8538301753 2.8405447083 1.8108479030 1.4670722898 1.4670778451 + 0.8723292202 2.6078362358 1.6018562944 1.2777039586 1.2777091305 + 0.8908282651 2.3721638978 1.4039473447 1.1025407668 1.1025455176 + 0.9093273101 2.1379362873 1.2191686248 0.9426376088 0.9426419168 + 0.9278263550 1.9091080785 1.0489684488 0.7985103681 0.7985142259 + 0.9463253999 1.6890867776 0.8942249099 0.6701963313 0.6701997443 + 0.9648244449 1.4806728025 0.7552953166 0.5573258960 0.5573288797 + 0.9833234898 1.2860324475 0.6320806714 0.4592002224 0.4592028008 + 1.0018225347 1.1067013595 0.5240997089 0.3748699659 0.3748721687 + 1.0203215796 0.9436145977 0.4305672735 0.3032109589 0.3032128197 + 1.0388206246 0.7971582557 0.3504723863 0.2429935976 0.2429951524 + 1.0573196695 0.6672370226 0.2826521442 0.1929436359 0.1929449209 + 1.0758187144 0.5533519101 0.2258585071 0.1517930110 0.1517940615 + 1.0943177593 0.4546826486 0.1788159739 0.1183201696 0.1183210193 + 1.1128168043 0.3701698467 0.1402690518 0.0913800689 0.0913807490 + 1.1313158492 0.2985928384 0.1090192276 0.0699245804 0.0699251191 + 1.1498148941 0.2386401016 0.0839518034 0.0530144117 0.0530148340 + 1.1683139390 0.1889701264 0.0640534681 0.0398238932 0.0398242208 + 1.1868129840 0.1482615622 0.0484218033 0.0296400664 0.0296403180 + 1.2053120289 0.1152523211 0.0362681129 0.0218574917 0.0218576829 + 1.2238110738 0.0887680090 0.0269150164 0.0159700825 0.0159702264 + 1.2423101187 0.0677405889 0.0197901929 0.0115611141 0.0115612213 + 1.2608091637 0.0512185343 0.0144175378 0.0082923554 0.0082924344 + 1.2793082086 0.0383699308 0.0104068156 0.0058930729 0.0058931306 + 1.2978072535 0.0284800387 0.0074426965 0.0041494584 0.0041495001 + 1.3163062984 0.0209447810 0.0052738582 0.0028948543 0.0028948841 + 1.3348053434 0.0152614839 0.0037026467 0.0020010027 0.0020010239 + 1.3533043883 0.0110180158 0.0025756201 0.0013704221 0.0013704369 + 1.3718034332 0.0078812610 0.0017751580 0.0009299224 0.0009299327 + 1.3903024781 0.0055856500 0.0012122101 0.0006252083 0.0006252154 + 1.4088015231 0.0039222694 0.0008201712 0.0004164746 0.0004164794 + 1.4273005680 0.0027288949 0.0005498153 0.0002748767 0.0002748800 + 1.4457996129 0.0018811433 0.0003651865 0.0001797517 0.0001797539 + 1.4642986578 0.0012848211 0.0002403247 0.0001164646 0.0001164660 + 1.4827977028 0.0008694590 0.0001566996 0.0000747653 0.0000747663 + 1.5012967477 0.0005829634 0.0001012332 0.0000475546 0.0000475552 + 1.5197957926 0.0003872747 0.0000647983 0.0000299689 0.0000299693 + 1.5382948375 0.0002549075 0.0000410951 0.0000187126 0.0000187128 + 1.5567938825 0.0001662386 0.0000258227 0.0000115767 0.0000115768 + 1.5752929274 0.0001074155 0.0000160768 0.0000070961 0.0000070962 + 1.5937919723 0.0000687682 0.0000099171 0.0000043096 0.0000043097 + 1.6122910172 0.0000436208 0.0000060611 0.0000025933 0.0000025933 + 1.6307900622 0.0000274148 0.0000036703 0.0000015461 0.0000015461 + 1.6492891071 0.0000170712 0.0000022022 0.0000009133 0.0000009133 + 1.6677881520 0.0000105324 0.0000013091 0.0000005345 0.0000005345 + 1.6862871970 0.0000064384 0.0000007711 0.0000003100 0.0000003100 + 1.7047862419 0.0000038995 0.0000004500 0.0000001781 0.0000001781 + 1.7232852868 0.0000023401 0.0000002602 0.0000001014 0.0000001014 + 1.7417843317 0.0000013914 0.0000001491 0.0000000572 0.0000000572 + 1.7602833767 0.0000008197 0.0000000846 0.0000000320 0.0000000320 + 1.7787824216 0.0000004784 0.0000000476 0.0000000177 0.0000000177 + 1.7972814665 0.0000002767 0.0000000265 0.0000000097 0.0000000097 + 1.8157805114 0.0000001585 0.0000000146 0.0000000053 0.0000000053 + 1.8342795564 0.0000000900 0.0000000080 0.0000000028 0.0000000028 + 1.8527786013 0.0000000506 0.0000000043 0.0000000015 0.0000000015 + 1.8712776462 0.0000000282 0.0000000023 0.0000000008 0.0000000008 + 1.8897766911 0.0000000156 0.0000000012 0.0000000004 0.0000000004 + 1.9082757361 0.0000000085 0.0000000007 0.0000000002 0.0000000002 + 1.9267747810 0.0000000046 0.0000000003 0.0000000001 0.0000000001 + 1.9452738259 0.0000000025 0.0000000002 0.0000000001 0.0000000001 + 1.9637728708 0.0000000013 0.0000000001 0.0000000000 0.0000000000 + 1.9822719158 0.0000000007 0.0000000000 0.0000000000 0.0000000000 + 2.0007709607 0.0000000004 0.0000000000 0.0000000000 0.0000000000 + 2.0192700056 0.0000000002 0.0000000000 0.0000000000 0.0000000000 + 2.0377690505 0.0000000001 0.0000000000 0.0000000000 0.0000000000 + 2.0562680955 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0747671404 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0932661853 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1117652302 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1302642752 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1487633201 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1672623650 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1857614099 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2042604549 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2227594998 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2412585447 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2597575896 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2782566346 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2967556795 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3152547244 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3337537694 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3522528143 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3707518592 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3892509041 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4077499491 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4262489940 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4447480389 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4632470838 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4817461288 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5002451737 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5187442186 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5372432635 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5557423085 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5742413534 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5927403983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6112394432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6297384882 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6482375331 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6667365780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6852356229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7037346679 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7222337128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7407327577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7592318026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7777308476 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7962298925 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8147289374 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8332279823 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8517270273 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8702260722 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8887251171 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9072241620 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9257232070 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9442222519 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9627212968 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9812203418 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9997193867 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0182184316 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0367174765 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0552165215 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0737155664 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0922146113 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1107136562 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1292127012 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1477117461 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1662107910 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1847098359 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2032088809 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2217079258 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2402069707 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2587060156 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2772050606 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2957041055 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3142031504 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3327021953 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3512012403 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3697002852 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3881993301 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4066983750 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4251974200 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4436964649 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4621955098 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4806945547 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4991935997 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5176926446 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5361916895 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5546907344 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5731897794 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5916888243 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6101878692 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6286869142 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6471859591 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6656850040 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6841840489 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7026830939 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7211821388 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7396811837 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7581802286 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7766792736 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7951783185 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8136773634 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8321764083 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8506754533 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8691744982 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8876735431 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9061725880 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9246716330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9431706779 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9616697228 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9801687677 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9986678127 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0171668576 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0356659025 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0541649474 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0726639924 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0911630373 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1096620822 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1281611271 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1466601721 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1651592170 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1836582619 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2021573068 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2206563518 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2391553967 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2576544416 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2761534865 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2946525315 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3131515764 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3316506213 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3501496663 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3686487112 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3871477561 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4056468010 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4241458460 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4426448909 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4611439358 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4796429807 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4981420257 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5166410706 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5351401155 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5536391604 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5721382054 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5906372503 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6091362952 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6276353401 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6461343851 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6646334300 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6831324749 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7016315198 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7201305648 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7386296097 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7571286546 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7756276995 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7941267445 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8126257894 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8311248343 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8496238792 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8681229242 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8866219691 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9051210140 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9236200589 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9421191039 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9606181488 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9791171937 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9976162387 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0161152836 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0346143285 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0531133734 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0716124184 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0901114633 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1086105082 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1271095531 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1456085981 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1641076430 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1826066879 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2011057328 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2196047778 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2381038227 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2566028676 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2751019125 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2936009575 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3121000024 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3305990473 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3490980922 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3675971372 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3860961821 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4045952270 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4230942719 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4415933169 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4600923618 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4785914067 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4970904516 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5155894966 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5340885415 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5525875864 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5710866313 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5895856763 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6080847212 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6265837661 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6450828111 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6635818560 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6820809009 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7005799458 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7190789908 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7375780357 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7560770806 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7745761255 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7930751705 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8115742154 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8300732603 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8485723052 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8670713502 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8855703951 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9040694400 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9225684849 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9410675299 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9595665748 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9780656197 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9965646646 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0150637096 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0335627545 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0520617994 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0705608443 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0890598893 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1075589342 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1260579791 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1445570240 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1630560690 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1815551139 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2000541588 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2185532037 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2370522487 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2555512936 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2740503385 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2925493835 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3110484284 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3295474733 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3480465182 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3665455632 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3850446081 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4035436530 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4220426979 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4405417429 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4590407878 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4775398327 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4960388776 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5145379226 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5330369675 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5515360124 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5700350573 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5885341023 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6070331472 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6255321921 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6440312370 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6625302820 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6810293269 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6995283718 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7180274167 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7365264617 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7550255066 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7735245515 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7920235964 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8105226414 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8290216863 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8475207312 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8660197761 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8845188211 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9030178660 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9215169109 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9400159558 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9585150008 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9770140457 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9955130906 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0140121356 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0325111805 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0510102254 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0695092703 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0880083153 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1065073602 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1250064051 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1435054500 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1620044950 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1805035399 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1990025848 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2175016297 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2360006747 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2544997196 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2729987645 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2914978094 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3099968544 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3284958993 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3469949442 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3654939891 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3839930341 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4024920790 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4209911239 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4394901688 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4579892138 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4764882587 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4949873036 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5134863485 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5319853935 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5504844384 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5689834833 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5874825282 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6059815732 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6244806181 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6429796630 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6614787080 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6799777529 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6984767978 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7169758427 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7354748877 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7539739326 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7724729775 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7909720224 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8094710674 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8279701123 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8464691572 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8649682021 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8834672471 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9019662920 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9204653369 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9389643818 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9574634268 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9759624717 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9944615166 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0129605615 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0314596065 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0499586514 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0684576963 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0869567412 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1054557862 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1239548311 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1424538760 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1609529209 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1794519659 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1979510108 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2164500557 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2349491006 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2534481456 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2719471905 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2904462354 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3089452804 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3274443253 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3459433702 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3644424151 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3829414601 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4014405050 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4199395499 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4384385948 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4569376398 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4754366847 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4939357296 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5124347745 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5309338195 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5494328644 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5679319093 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5864309542 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6049299992 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6234290441 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6419280890 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6604271339 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6789261789 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6974252238 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7159242687 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7344233136 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7529223586 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7714214035 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7899204484 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8084194933 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8269185383 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8454175832 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8639166281 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8824156730 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9009147180 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9194137629 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9379128078 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9564118528 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9749108977 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9934099426 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0119089875 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0304080325 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0489070774 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0674061223 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0859051672 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1044042122 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1229032571 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1414023020 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1599013469 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1784003919 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1968994368 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2153984817 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2338975266 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2523965716 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2708956165 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2893946614 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3078937063 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3263927513 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3448917962 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3633908411 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3818898860 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4003889310 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4188879759 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4373870208 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4558860657 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4743851107 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4928841556 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5113832005 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5298822454 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5483812904 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5668803353 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5853793802 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6038784251 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6223774701 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6408765150 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6593755599 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6778746049 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6963736498 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7148726947 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7333717396 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7518707846 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7703698295 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7888688744 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8073679193 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8258669643 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8443660092 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8628650541 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8813640990 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8998631440 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9183621889 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9368612338 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9553602787 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9738593237 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9923583686 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0108574135 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0293564584 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0478555034 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0663545483 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0848535932 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1033526381 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1218516831 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1403507280 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1588497729 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1773488178 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1958478628 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2143469077 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2328459526 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2513449975 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2698440425 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2883430874 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3068421323 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3253411773 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3438402222 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3623392671 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3808383120 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3993373570 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4178364019 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4363354468 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4548344917 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4733335367 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4918325816 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5103316265 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5288306714 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5473297164 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5658287613 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5843278062 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6028268511 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6213258961 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6398249410 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6583239859 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6768230308 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6953220758 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7138211207 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7323201656 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7508192105 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7693182555 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7878173004 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8063163453 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8248153902 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8433144352 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8618134801 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8803125250 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8988115699 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9173106149 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9358096598 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9543087047 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9728077497 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9913067946 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0098058395 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0283048844 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0468039294 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0653029743 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0838020192 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1023010641 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1208001091 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1392991540 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1577981989 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1762972438 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1947962888 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2132953337 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2317943786 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2502934235 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2687924685 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2872915134 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3057905583 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3242896032 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3427886482 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3612876931 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3797867380 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3982857829 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4167848279 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4352838728 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4537829177 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4722819626 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4907810076 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5092800525 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5277790974 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5462781423 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5647771873 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5832762322 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6017752771 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6202743221 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6387733670 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6572724119 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6757714568 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6942705018 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7127695467 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7312685916 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7497676365 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7682666815 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7867657264 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8052647713 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8237638162 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8422628612 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8607619061 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8792609510 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8977599959 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9162590409 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9347580858 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9532571307 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9717561756 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9902552206 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0087542655 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0272533104 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0457523553 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0642514003 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0827504452 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1012494901 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1197485350 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1382475800 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1567466249 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1752456698 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1937447147 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2122437597 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2307428046 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2492418495 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2677408944 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2862399394 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3047389843 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3232380292 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3417370742 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3602361191 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3787351640 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3972342089 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4157332539 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4342322988 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4527313437 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4712303886 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4897294336 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5082284785 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5267275234 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5452265683 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5637256133 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5822246582 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6007237031 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6192227480 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6377217930 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6562208379 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6747198828 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6932189277 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7117179727 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7302170176 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7487160625 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7672151074 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7857141524 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8042131973 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8227122422 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8412112871 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8597103321 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8782093770 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8967084219 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9152074668 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9337065118 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9522055567 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9707046016 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9892036466 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0077026915 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0262017364 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0447007813 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0631998263 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0816988712 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1001979161 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1186969610 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1371960060 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1556950509 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1741940958 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1926931407 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2111921857 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2296912306 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2481902755 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2666893204 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2851883654 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3036874103 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3221864552 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3406855001 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3591845451 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3776835900 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3961826349 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4146816798 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4331807248 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4516797697 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4701788146 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4886778595 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5071769045 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5256759494 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5441749943 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5626740392 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5811730842 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5996721291 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6181711740 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6366702190 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6551692639 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6736683088 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6921673537 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7106663987 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7291654436 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7476644885 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7661635334 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7846625784 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8031616233 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8216606682 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8401597131 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8586587581 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8771578030 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8956568479 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9141558928 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9326549378 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9511539827 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9696530276 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9881520725 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0066511175 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0251501624 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0436492073 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0621482522 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0806472972 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0991463421 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1176453870 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1361444319 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1546434769 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1731425218 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1916415667 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2101406116 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2286396566 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2471387015 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2656377464 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2841367914 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3026358363 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3211348812 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3396339261 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3581329711 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3766320160 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3951310609 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4136301058 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4321291508 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4506281957 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4691272406 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4876262855 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5061253305 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5246243754 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5431234203 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5616224652 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5801215102 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5986205551 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6171196000 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6356186449 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6541176899 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6726167348 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6911157797 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7096148246 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7281138696 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7466129145 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7651119594 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7836110043 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8021100493 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8206090942 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8391081391 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8576071840 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8761062290 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8946052739 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9131043188 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9316033637 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9501024087 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9686014536 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9871004985 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0055995435 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0240985884 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0425976333 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0610966782 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0795957232 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0980947681 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1165938130 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1350928579 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1535919029 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1720909478 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 15.1905899927 0.0000000000 0.0000000000 0.0000000001 0.0000000001 + 15.2090890376 0.0000000000 0.0000000000 0.0000000002 0.0000000001 + 15.2275880826 0.0000000000 0.0000000000 0.0000000004 0.0000000002 + 15.2460871275 0.0000000000 0.0000000000 0.0000000007 0.0000000004 + 15.2645861724 0.0000000000 0.0000000000 0.0000000012 0.0000000007 + 15.2830852173 0.0000000000 0.0000000000 0.0000000021 0.0000000012 + 15.3015842623 0.0000000000 0.0000000001 0.0000000035 0.0000000020 + 15.3200833072 0.0000000000 0.0000000001 0.0000000059 0.0000000034 + 15.3385823521 0.0000000000 0.0000000002 0.0000000097 0.0000000056 + 15.3570813970 0.0000000000 0.0000000003 0.0000000160 0.0000000093 + 15.3755804420 0.0000000000 0.0000000004 0.0000000261 0.0000000151 + 15.3940794869 0.0000000001 0.0000000007 0.0000000421 0.0000000243 + 15.4125785318 0.0000000001 0.0000000011 0.0000000674 0.0000000389 + 15.4310775767 0.0000000001 0.0000000018 0.0000001069 0.0000000616 + 15.4495766217 0.0000000002 0.0000000028 0.0000001678 0.0000000966 + 15.4680756666 0.0000000003 0.0000000043 0.0000002612 0.0000001502 + 15.4865747115 0.0000000005 0.0000000066 0.0000004026 0.0000002313 + 15.5050737564 0.0000000007 0.0000000100 0.0000006151 0.0000003529 + 15.5235728014 0.0000000010 0.0000000151 0.0000009309 0.0000005336 + 15.5420718463 0.0000000016 0.0000000226 0.0000013961 0.0000007994 + 15.5605708912 0.0000000023 0.0000000334 0.0000020743 0.0000011866 + 15.5790699361 0.0000000033 0.0000000489 0.0000030538 0.0000017451 + 15.5975689811 0.0000000048 0.0000000711 0.0000044545 0.0000025430 + 15.6160680260 0.0000000069 0.0000001024 0.0000064378 0.0000036716 + 15.6345670709 0.0000000098 0.0000001460 0.0000092188 0.0000052524 + 15.6530661159 0.0000000138 0.0000002064 0.0000130797 0.0000074447 + 15.6715651608 0.0000000192 0.0000002890 0.0000183870 0.0000104552 + 15.6900642057 0.0000000265 0.0000004009 0.0000256103 0.0000145483 + 15.7085632506 0.0000000362 0.0000005512 0.0000353432 0.0000200578 + 15.7270622956 0.0000000490 0.0000007508 0.0000483269 0.0000273999 + 15.7455613405 0.0000000658 0.0000010132 0.0000654728 0.0000370857 + 15.7640603854 0.0000000875 0.0000013549 0.0000878865 0.0000497344 + 15.7825594303 0.0000001153 0.0000017952 0.0001168888 0.0000660846 + 15.8010584753 0.0000001505 0.0000023567 0.0001540329 0.0000870033 + 15.8195575202 0.0000001946 0.0000030656 0.0002011146 0.0001134917 + 15.8380565651 0.0000002494 0.0000039510 0.0002601734 0.0001466847 + 15.8565556100 0.0000003167 0.0000050454 0.0003334814 0.0001878443 + 15.8750546550 0.0000003984 0.0000063840 0.0004235160 0.0002383438 + 15.8935536999 0.0000004966 0.0000080035 0.0005329142 0.0002996416 + 15.9120527448 0.0000006132 0.0000099418 0.0006644069 0.0003732438 + 15.9305517897 0.0000007503 0.0000122362 0.0008207298 0.0004606547 + 15.9490508347 0.0000009097 0.0000149220 0.0010045129 0.0005633142 + 15.9675498796 0.0000010927 0.0000180303 0.0012181480 0.0006825242 + 15.9860489245 0.0000013004 0.0000215863 0.0014636383 0.0008193654 + 16.0045479694 0.0000015334 0.0000256065 0.0017424352 0.0009746065 + 16.0230470144 0.0000017916 0.0000300968 0.0020552687 0.0011486113 + 16.0415460593 0.0000020739 0.0000350499 0.0024019817 0.0013412473 + 16.0600451042 0.0000023786 0.0000404437 0.0027813768 0.0015518033 + 16.0785441491 0.0000027031 0.0000462395 0.0031910895 0.0017789200 + 16.0970431941 0.0000030435 0.0000523807 0.0036274977 0.0020205429 + 16.1155422390 0.0000033952 0.0000587932 0.0040856794 0.0022739012 + 16.1340412839 0.0000037528 0.0000653854 0.0045594279 0.0025355193 + 16.1525403288 0.0000041099 0.0000720495 0.0050413325 0.0028012638 + 16.1710393738 0.0000044595 0.0000786644 0.0055229258 0.0030664283 + 16.1895384187 0.0000047944 0.0000850987 0.0059948999 0.0033258550 + 16.2080374636 0.0000051070 0.0000912147 0.0064473833 0.0035740896 + 16.2265365085 0.0000053900 0.0000968732 0.0068702705 0.0038055651 + 16.2450355535 0.0000056363 0.0001019387 0.0072535892 0.0040148046 + 16.2635345984 0.0000058396 0.0001062850 0.0075878864 0.0041966349 + 16.2820336433 0.0000059946 0.0001097999 0.0078646137 0.0043463971 + 16.3005326883 0.0000060971 0.0001123903 0.0080764900 0.0044601457 + 16.3190317332 0.0000061444 0.0001139863 0.0082178192 0.0045348200 + 16.3375307781 0.0000061350 0.0001145442 0.0082847449 0.0045683818 + 16.3560298230 0.0000060693 0.0001140488 0.0082754249 0.0045599073 + 16.3745288680 0.0000059491 0.0001125136 0.0081901159 0.0045096297 + 16.3930279129 0.0000057776 0.0001099806 0.0080311613 0.0044189282 + 16.4115269578 0.0000055594 0.0001065183 0.0078028844 0.0042902655 + 16.4300260027 0.0000053003 0.0001022184 0.0075113932 0.0041270764 + 16.4485250477 0.0000050068 0.0000971920 0.0071643089 0.0039336157 + 16.4670240926 0.0000046860 0.0000915648 0.0067704347 0.0037147737 + 16.4855231375 0.0000043454 0.0000854719 0.0063393865 0.0034758722 + 16.5040221824 0.0000039925 0.0000790523 0.0058812049 0.0032224500 + 16.5225212274 0.0000036345 0.0000724440 0.0054059717 0.0029600529 + 16.5410202723 0.0000032782 0.0000657790 0.0049234504 0.0026940374 + 16.5595193172 0.0000029297 0.0000591791 0.0044427687 0.0024293976 + 16.5780183621 0.0000025941 0.0000527528 0.0039721545 0.0021706228 + 16.5965174071 0.0000022758 0.0000465929 0.0035187372 0.0019215906 + 16.6150164520 0.0000019782 0.0000407746 0.0030884160 0.0016854974 + 16.6335154969 0.0000017037 0.0000353555 0.0026857958 0.0014648257 + 16.6520145418 0.0000014538 0.0000303753 0.0023141867 0.0012613467 + 16.6705135868 0.0000012291 0.0000258571 0.0019756589 0.0010761518 + 16.6890126317 0.0000010296 0.0000218090 0.0016711433 0.0009097104 + 16.7075116766 0.0000008546 0.0000182258 0.0014005660 0.0007619444 + 16.7260107215 0.0000007027 0.0000150916 0.0011630050 0.0006323156 + 16.7445097665 0.0000005726 0.0000123817 0.0009568583 0.0005199181 + 16.7630088114 0.0000004622 0.0000100651 0.0007800129 0.0004235711 + 16.7815078563 0.0000003697 0.0000081069 0.0006300050 0.0003419071 + 16.8000069012 0.0000002930 0.0000064698 0.0005041668 0.0002734514 + 16.8185059462 0.0000002301 0.0000051158 0.0003997536 0.0002166918 + 16.8370049911 0.0000001790 0.0000040081 0.0003140499 0.0001701356 + 16.8555040360 0.0000001380 0.0000031114 0.0002444515 0.0001323543 + 16.8740030809 0.0000001054 0.0000023932 0.0001885276 0.0001020166 + 16.8925021259 0.0000000797 0.0000018238 0.0001440605 0.0000779101 + 16.9110011708 0.0000000598 0.0000013772 0.0001090694 0.0000589532 + 16.9295002157 0.0000000444 0.0000010304 0.0000818179 0.0000441988 + 16.9479992607 0.0000000327 0.0000007638 0.0000608110 0.0000328325 + 16.9664983056 0.0000000238 0.0000005610 0.0000447820 0.0000241650 + 16.9849973505 0.0000000172 0.0000004083 0.0000326748 0.0000176222 + 17.0034963954 0.0000000123 0.0000002944 0.0000236216 0.0000127328 + 17.0219954404 0.0000000087 0.0000002104 0.0000169198 0.0000091154 + 17.0404944853 0.0000000061 0.0000001489 0.0000120079 0.0000064657 + 17.0589935302 0.0000000043 0.0000001044 0.0000084436 0.0000045441 + 17.0774925751 0.0000000030 0.0000000726 0.0000058827 0.0000031643 + 17.0959916201 0.0000000020 0.0000000500 0.0000040608 0.0000021832 + 17.1144906650 0.0000000014 0.0000000341 0.0000027774 0.0000014924 + 17.1329897099 0.0000000009 0.0000000231 0.0000018821 0.0000010108 + 17.1514887548 0.0000000006 0.0000000154 0.0000012637 0.0000006784 + 17.1699877998 0.0000000004 0.0000000102 0.0000008407 0.0000004511 + 17.1884868447 0.0000000003 0.0000000067 0.0000005541 0.0000002972 + 17.2069858896 0.0000000002 0.0000000044 0.0000003619 0.0000001940 + 17.2254849345 0.0000000001 0.0000000028 0.0000002342 0.0000001255 + 17.2439839795 0.0000000001 0.0000000018 0.0000001501 0.0000000804 + 17.2624830244 0.0000000000 0.0000000011 0.0000000954 0.0000000510 + 17.2809820693 0.0000000000 0.0000000007 0.0000000600 0.0000000321 + 17.2994811142 0.0000000000 0.0000000004 0.0000000374 0.0000000200 + 17.3179801592 0.0000000000 0.0000000003 0.0000000231 0.0000000124 + 17.3364792041 0.0000000000 0.0000000002 0.0000000142 0.0000000076 + 17.3549782490 0.0000000000 0.0000000001 0.0000000086 0.0000000046 + 17.3734772939 0.0000000000 0.0000000001 0.0000000052 0.0000000028 + 17.3919763389 0.0000000000 0.0000000000 0.0000000031 0.0000000016 + 17.4104753838 0.0000000000 0.0000000000 0.0000000018 0.0000000010 + 17.4289744287 0.0000000000 0.0000000000 0.0000000011 0.0000000006 + 17.4474734736 0.0000000000 0.0000000000 0.0000000006 0.0000000003 + 17.4659725186 0.0000000000 0.0000000000 0.0000000004 0.0000000002 + 17.4844715635 0.0000000000 0.0000000000 0.0000000002 0.0000000001 + 17.5029706084 0.0000000000 0.0000000000 0.0000000001 0.0000000001 + 17.5214696533 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 17.5399686983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5584677432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5769667881 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5954658330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6139648780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6324639229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6509629678 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6694620128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6879610577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.7064601026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + +:PDOS_INFO: + :ATOM_TYPE: Al + :ATOMIC_NUMBER: 13 + :ATOM_INDEX: 3 + :ATOM_POSITION_CARTESIAN: [0. 3.8266955 3.8266955] + :ATOM_POSITION_FRACTIONAL: [0. 0.5 0.5] + :PDOS_UNIT: states/eV + :HEADER_FORMAT: (nl,m) + Energy(eV) (3s, m=0) (3p, m=-1) (3p, m=0) (3p, m=1) + -0.7740857782 0.0000000000 0.0000000001 0.0000000001 0.0000000000 + -0.7555867332 0.0000000000 0.0000000001 0.0000000001 0.0000000000 + -0.7370876883 0.0000000000 0.0000000002 0.0000000002 0.0000000001 + -0.7185886434 0.0000000000 0.0000000004 0.0000000004 0.0000000001 + -0.7000895985 0.0000000000 0.0000000008 0.0000000008 0.0000000003 + -0.6815905535 0.0000000000 0.0000000014 0.0000000014 0.0000000005 + -0.6630915086 0.0000000001 0.0000000027 0.0000000027 0.0000000009 + -0.6445924637 0.0000000001 0.0000000050 0.0000000050 0.0000000017 + -0.6260934188 0.0000000003 0.0000000092 0.0000000092 0.0000000033 + -0.6075943738 0.0000000005 0.0000000167 0.0000000167 0.0000000060 + -0.5890953289 0.0000000010 0.0000000302 0.0000000302 0.0000000111 + -0.5705962840 0.0000000018 0.0000000541 0.0000000541 0.0000000201 + -0.5520972391 0.0000000034 0.0000000960 0.0000000960 0.0000000363 + -0.5335981941 0.0000000063 0.0000001688 0.0000001688 0.0000000648 + -0.5150991492 0.0000000115 0.0000002940 0.0000002940 0.0000001146 + -0.4966001043 0.0000000209 0.0000005074 0.0000005074 0.0000002010 + -0.4781010594 0.0000000377 0.0000008677 0.0000008677 0.0000003490 + -0.4596020144 0.0000000674 0.0000014702 0.0000014702 0.0000006007 + -0.4411029695 0.0000001192 0.0000024682 0.0000024682 0.0000010243 + -0.4226039246 0.0000002090 0.0000041054 0.0000041055 0.0000017304 + -0.4041048797 0.0000003631 0.0000067658 0.0000067660 0.0000028966 + -0.3856058347 0.0000006251 0.0000110477 0.0000110480 0.0000048039 + -0.3671067898 0.0000010660 0.0000178735 0.0000178739 0.0000078940 + -0.3486077449 0.0000018013 0.0000286506 0.0000286512 0.0000128524 + -0.3301086999 0.0000030158 0.0000455033 0.0000455043 0.0000207327 + -0.3116096550 0.0000050026 0.0000716040 0.0000716055 0.0000331371 + -0.2931106101 0.0000082220 0.0001116395 0.0001116418 0.0000524755 + -0.2746115652 0.0000133888 0.0001724582 0.0001724617 0.0000823352 + -0.2561125202 0.0000216020 0.0002639585 0.0002639637 0.0001279971 + -0.2376134753 0.0000345328 0.0004002885 0.0004002962 0.0001971516 + -0.2191144304 0.0000546959 0.0006014455 0.0006014567 0.0003008751 + -0.2006153855 0.0000858348 0.0008953752 0.0008953916 0.0004549439 + -0.1821163405 0.0001334621 0.0013206860 0.0013207095 0.0006815772 + -0.1636172956 0.0002056070 0.0019300998 0.0019301334 0.0010117145 + -0.1451182507 0.0003138366 0.0027947673 0.0027948147 0.0014879441 + -0.1266192058 0.0004746298 0.0040095647 0.0040096310 0.0021682079 + -0.1081201608 0.0007112006 0.0056994702 0.0056995620 0.0031304079 + -0.0896211159 0.0010558807 0.0080270772 0.0080272030 0.0044780261 + -0.0711220710 0.0015531855 0.0112012395 0.0112014103 0.0063468466 + -0.0526230261 0.0022636928 0.0154867546 0.0154869841 0.0089128187 + -0.0341239811 0.0032688676 0.0212148732 0.0212151785 0.0124010321 + -0.0156249362 0.0046769515 0.0287942755 0.0287946774 0.0170956763 + 0.0028741087 0.0066300085 0.0387219803 0.0387225042 0.0233507281 + 0.0213731536 0.0093121722 0.0515934600 0.0515941358 0.0316009588 + 0.0398721986 0.0129590631 0.0681110284 0.0681118914 0.0423726652 + 0.0583712435 0.0178682450 0.0890893750 0.0890904656 0.0562933370 + 0.0768702884 0.0244104554 0.1154569490 0.1154583128 0.0740992644 + 0.0953693333 0.0330411806 0.1482517851 0.1482534726 0.0966399038 + 0.1138683783 0.0443119560 0.1886103306 0.1886123965 0.1248776656 + 0.1323674232 0.0588805659 0.2377479118 0.2377504139 0.1598816953 + 0.1508664681 0.0775190996 0.2969296977 0.2969326951 0.2028142229 + 0.1693655130 0.1011186247 0.3674313862 0.3674349376 0.2549081733 + 0.1878645580 0.1306890735 0.4504893793 0.4504935400 0.3174349958 + 0.2063636029 0.1673528428 0.5472409043 0.5472457236 0.3916620903 + 0.2248626478 0.2123306060 0.6586553706 0.6586608883 0.4787998007 + 0.2433616927 0.2669179584 0.7854591675 0.7854654103 0.5799386784 + 0.2618607377 0.3324517931 0.9280570595 0.9280640372 0.6959785874 + 0.2803597826 0.4102657430 1.0864542283 1.0864619305 0.8275521514 + 0.2988588275 0.5016346422 1.2601837654 1.2601921582 0.9749459870 + 0.3173578725 0.6077087315 1.4482449290 1.4482539524 1.1380240236 + 0.3358569174 0.7294392396 1.6490576656 1.6490672322 1.3161578982 + 0.3543559623 0.8674979516 1.8604386745 1.8604486686 1.5081698294 + 0.3728550072 1.0221943685 2.0796036231 2.0796139017 1.7122934406 + 0.3913540522 1.1933949621 2.3031989926 2.3032093876 1.9261576395 + 0.4098530971 1.3804497626 2.5273654752 2.5273757968 2.1467978525 + 0.4283521420 1.5821319568 2.7478329397 2.7478429818 2.3706976377 + 0.4468511869 1.7965962516 2.9600448553 2.9600544021 2.5938620301 + 0.4653502319 2.0213613893 3.1593078692 3.1593167023 2.8119219821 + 0.4838492768 2.2533213548 3.3409601562 3.3409680628 3.0202671007 + 0.5023483217 2.4887884887 3.5005503894 3.5005571708 3.2142017055 + 0.5208473666 2.7235699657 3.6340178896 3.6340233693 3.3891172391 + 0.5393464116 2.9530770155 3.7378638505 3.7378678819 3.5406724198 + 0.5578454565 3.1724639855 3.8093035899 3.8093060629 3.6649714312 + 0.5763445014 3.3767920594 3.8463905917 3.8463914374 3.7587299920 + 0.5948435463 3.5612103370 3.8481046258 3.8481038197 3.8194194481 + 0.6133425913 3.7211452533 3.8143983816 3.8143959449 3.8453800700 + 0.6318416362 3.8524881409 3.7461996376 3.7461956361 3.8358964701 + 0.6503406811 3.9517702578 3.6453688292 3.6453633703 3.7912303584 + 0.6688397260 4.0163148977 3.5146147229 3.5146079509 3.7126085425 + 0.6873387710 4.0443572784 3.3573735325 3.3573656220 3.6021669400 + 0.7058378159 4.0351247163 3.1776590031 3.1776501518 3.4628541694 + 0.7243368608 3.9888720019 2.9798925853 2.9798830054 3.2983007932 + 0.7428359057 3.9068697163 2.7687237005 2.7687136108 3.1126623025 + 0.7613349507 3.7913462377 2.5488502303 2.5488398475 2.9104453097 + 0.7798339956 3.6453871300 2.3248487627 2.3248382943 2.6963270574 + 0.7983330405 3.4727982556 2.1010228966 2.1010125340 2.4749782513 + 0.8168320854 3.2779410839 1.8812761708 1.8812660843 2.2508984090 + 0.8353311304 3.0655501304 1.6690141316 1.6690044666 2.0282715153 + 0.8538301753 2.8405431539 1.4670778608 1.4670687353 1.8108479217 + 0.8723292202 2.6078346455 1.2777091442 1.2777006481 1.6018563109 + 0.8908282651 2.3721623026 1.1025455295 1.1025377247 1.4039473592 + 0.9093273101 2.1379347158 0.9426419269 0.9426348494 1.2191686374 + 0.9278263550 1.9091065556 0.7985142345 0.7985078963 1.0489684597 + 0.9463253999 1.6890853245 0.6701997515 0.6701941440 0.8942249192 + 0.9648244449 1.4806714359 0.5573288857 0.5573239833 0.7552953245 + 0.9833234898 1.2860311800 0.4592028057 0.4591985693 0.6320806779 + 1.0018225347 1.1067001995 0.3748721727 0.3748685533 0.5240997143 + 1.0203215796 0.9436135495 0.3032128230 0.3032097653 0.4305672780 + 1.0388206246 0.7971573203 0.2429951550 0.2429926003 0.3504723899 + 1.0573196695 0.6672361979 0.1929449229 0.1929428116 0.2826521471 + 1.0758187144 0.5533511915 0.1517940631 0.1517923369 0.2258585095 + 1.0943177593 0.4546820297 0.1183210206 0.1183196242 0.1788159757 + 1.1128168043 0.3701693196 0.0913807500 0.0913796323 0.1402690533 + 1.1313158492 0.2985923945 0.0699251199 0.0699242346 0.1090192287 + 1.1498148941 0.2386397319 0.0530148346 0.0530141407 0.0839518043 + 1.1683139390 0.1889698218 0.0398242213 0.0398236829 0.0640534688 + 1.1868129840 0.1482613139 0.0296403183 0.0296399049 0.0484218038 + 1.2053120289 0.1152521209 0.0218576831 0.0218573689 0.0362681132 + 1.2238110738 0.0887678492 0.0159702266 0.0159699901 0.0269150167 + 1.2423101187 0.0677404627 0.0115612214 0.0115610453 0.0197901932 + 1.2608091637 0.0512184357 0.0082924345 0.0082923046 0.0144175379 + 1.2793082086 0.0383698545 0.0058931307 0.0058930359 0.0104068157 + 1.2978072535 0.0284799803 0.0041495002 0.0041494316 0.0074426966 + 1.3163062984 0.0209447367 0.0028948841 0.0028948351 0.0052738583 + 1.3348053434 0.0152614507 0.0020010239 0.0020009891 0.0037026468 + 1.3533043883 0.0110179912 0.0013704370 0.0013704126 0.0025756201 + 1.3718034332 0.0078812429 0.0009299327 0.0009299158 0.0017751580 + 1.3903024781 0.0055856368 0.0006252154 0.0006252038 0.0012122102 + 1.4088015231 0.0039222599 0.0004164794 0.0004164715 0.0008201712 + 1.4273005680 0.0027288881 0.0002748800 0.0002748746 0.0005498153 + 1.4457996129 0.0018811385 0.0001797539 0.0001797503 0.0003651865 + 1.4642986578 0.0012848177 0.0001164660 0.0001164637 0.0002403247 + 1.4827977028 0.0008694567 0.0000747663 0.0000747647 0.0001566996 + 1.5012967477 0.0005829618 0.0000475552 0.0000475542 0.0001012332 + 1.5197957926 0.0003872736 0.0000299693 0.0000299686 0.0000647983 + 1.5382948375 0.0002549068 0.0000187128 0.0000187124 0.0000410951 + 1.5567938825 0.0001662381 0.0000115768 0.0000115766 0.0000258227 + 1.5752929274 0.0001074151 0.0000070962 0.0000070960 0.0000160768 + 1.5937919723 0.0000687679 0.0000043097 0.0000043096 0.0000099171 + 1.6122910172 0.0000436207 0.0000025933 0.0000025932 0.0000060611 + 1.6307900622 0.0000274147 0.0000015461 0.0000015461 0.0000036703 + 1.6492891071 0.0000170711 0.0000009133 0.0000009133 0.0000022022 + 1.6677881520 0.0000105323 0.0000005345 0.0000005345 0.0000013091 + 1.6862871970 0.0000064383 0.0000003100 0.0000003100 0.0000007711 + 1.7047862419 0.0000038995 0.0000001781 0.0000001781 0.0000004500 + 1.7232852868 0.0000023401 0.0000001014 0.0000001014 0.0000002602 + 1.7417843317 0.0000013913 0.0000000572 0.0000000572 0.0000001491 + 1.7602833767 0.0000008196 0.0000000320 0.0000000320 0.0000000846 + 1.7787824216 0.0000004784 0.0000000177 0.0000000177 0.0000000476 + 1.7972814665 0.0000002767 0.0000000097 0.0000000097 0.0000000265 + 1.8157805114 0.0000001585 0.0000000053 0.0000000053 0.0000000146 + 1.8342795564 0.0000000900 0.0000000028 0.0000000028 0.0000000080 + 1.8527786013 0.0000000506 0.0000000015 0.0000000015 0.0000000043 + 1.8712776462 0.0000000282 0.0000000008 0.0000000008 0.0000000023 + 1.8897766911 0.0000000156 0.0000000004 0.0000000004 0.0000000012 + 1.9082757361 0.0000000085 0.0000000002 0.0000000002 0.0000000007 + 1.9267747810 0.0000000046 0.0000000001 0.0000000001 0.0000000003 + 1.9452738259 0.0000000025 0.0000000001 0.0000000001 0.0000000002 + 1.9637728708 0.0000000013 0.0000000000 0.0000000000 0.0000000001 + 1.9822719158 0.0000000007 0.0000000000 0.0000000000 0.0000000000 + 2.0007709607 0.0000000004 0.0000000000 0.0000000000 0.0000000000 + 2.0192700056 0.0000000002 0.0000000000 0.0000000000 0.0000000000 + 2.0377690505 0.0000000001 0.0000000000 0.0000000000 0.0000000000 + 2.0562680955 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0747671404 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.0932661853 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1117652302 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1302642752 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1487633201 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1672623650 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.1857614099 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2042604549 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2227594998 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2412585447 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2597575896 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2782566346 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.2967556795 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3152547244 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3337537694 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3522528143 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3707518592 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.3892509041 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4077499491 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4262489940 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4447480389 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4632470838 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.4817461288 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5002451737 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5187442186 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5372432635 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5557423085 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5742413534 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.5927403983 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6112394432 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6297384882 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6482375331 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6667365780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.6852356229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7037346679 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7222337128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7407327577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7592318026 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7777308476 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.7962298925 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8147289374 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8332279823 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8517270273 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8702260722 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.8887251171 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9072241620 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9257232070 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9442222519 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9627212968 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9812203418 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 2.9997193867 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0182184316 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0367174765 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0552165215 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0737155664 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.0922146113 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1107136562 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1292127012 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1477117461 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1662107910 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.1847098359 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2032088809 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2217079258 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2402069707 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2587060156 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2772050606 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.2957041055 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3142031504 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3327021953 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3512012403 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3697002852 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.3881993301 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4066983750 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4251974200 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4436964649 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4621955098 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4806945547 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.4991935997 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5176926446 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5361916895 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5546907344 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5731897794 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.5916888243 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6101878692 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6286869142 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6471859591 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6656850040 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.6841840489 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7026830939 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7211821388 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7396811837 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7581802286 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7766792736 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.7951783185 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8136773634 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8321764083 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8506754533 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8691744982 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.8876735431 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9061725880 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9246716330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9431706779 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9616697228 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9801687677 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 3.9986678127 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0171668576 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0356659025 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0541649474 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0726639924 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.0911630373 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1096620822 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1281611271 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1466601721 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1651592170 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.1836582619 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2021573068 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2206563518 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2391553967 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2576544416 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2761534865 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.2946525315 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3131515764 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3316506213 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3501496663 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3686487112 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.3871477561 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4056468010 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4241458460 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4426448909 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4611439358 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4796429807 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.4981420257 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5166410706 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5351401155 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5536391604 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5721382054 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.5906372503 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6091362952 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6276353401 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6461343851 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6646334300 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.6831324749 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7016315198 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7201305648 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7386296097 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7571286546 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7756276995 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.7941267445 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8126257894 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8311248343 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8496238792 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8681229242 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.8866219691 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9051210140 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9236200589 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9421191039 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9606181488 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9791171937 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 4.9976162387 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0161152836 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0346143285 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0531133734 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0716124184 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.0901114633 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1086105082 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1271095531 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1456085981 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1641076430 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.1826066879 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2011057328 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2196047778 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2381038227 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2566028676 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2751019125 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.2936009575 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3121000024 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3305990473 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3490980922 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3675971372 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.3860961821 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4045952270 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4230942719 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4415933169 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4600923618 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4785914067 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.4970904516 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5155894966 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5340885415 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5525875864 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5710866313 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.5895856763 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6080847212 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6265837661 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6450828111 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6635818560 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.6820809009 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7005799458 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7190789908 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7375780357 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7560770806 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7745761255 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.7930751705 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8115742154 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8300732603 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8485723052 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8670713502 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.8855703951 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9040694400 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9225684849 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9410675299 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9595665748 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9780656197 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 5.9965646646 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0150637096 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0335627545 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0520617994 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0705608443 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.0890598893 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1075589342 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1260579791 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1445570240 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1630560690 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.1815551139 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2000541588 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2185532037 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2370522487 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2555512936 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2740503385 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.2925493835 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3110484284 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3295474733 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3480465182 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3665455632 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.3850446081 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4035436530 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4220426979 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4405417429 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4590407878 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4775398327 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.4960388776 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5145379226 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5330369675 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5515360124 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5700350573 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.5885341023 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6070331472 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6255321921 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6440312370 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6625302820 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6810293269 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.6995283718 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7180274167 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7365264617 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7550255066 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7735245515 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.7920235964 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8105226414 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8290216863 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8475207312 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8660197761 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.8845188211 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9030178660 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9215169109 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9400159558 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9585150008 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9770140457 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 6.9955130906 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0140121356 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0325111805 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0510102254 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0695092703 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.0880083153 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1065073602 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1250064051 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1435054500 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1620044950 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1805035399 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.1990025848 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2175016297 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2360006747 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2544997196 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2729987645 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.2914978094 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3099968544 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3284958993 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3469949442 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3654939891 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.3839930341 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4024920790 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4209911239 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4394901688 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4579892138 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4764882587 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.4949873036 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5134863485 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5319853935 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5504844384 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5689834833 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.5874825282 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6059815732 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6244806181 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6429796630 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6614787080 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6799777529 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.6984767978 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7169758427 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7354748877 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7539739326 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7724729775 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.7909720224 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8094710674 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8279701123 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8464691572 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8649682021 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.8834672471 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9019662920 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9204653369 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9389643818 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9574634268 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9759624717 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 7.9944615166 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0129605615 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0314596065 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0499586514 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0684576963 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.0869567412 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1054557862 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1239548311 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1424538760 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1609529209 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1794519659 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.1979510108 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2164500557 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2349491006 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2534481456 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2719471905 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.2904462354 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3089452804 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3274443253 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3459433702 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3644424151 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.3829414601 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4014405050 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4199395499 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4384385948 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4569376398 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4754366847 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.4939357296 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5124347745 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5309338195 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5494328644 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5679319093 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.5864309542 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6049299992 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6234290441 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6419280890 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6604271339 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6789261789 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.6974252238 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7159242687 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7344233136 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7529223586 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7714214035 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.7899204484 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8084194933 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8269185383 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8454175832 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8639166281 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.8824156730 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9009147180 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9194137629 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9379128078 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9564118528 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9749108977 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 8.9934099426 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0119089875 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0304080325 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0489070774 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0674061223 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.0859051672 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1044042122 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1229032571 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1414023020 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1599013469 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1784003919 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.1968994368 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2153984817 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2338975266 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2523965716 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2708956165 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.2893946614 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3078937063 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3263927513 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3448917962 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3633908411 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.3818898860 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4003889310 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4188879759 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4373870208 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4558860657 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4743851107 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.4928841556 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5113832005 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5298822454 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5483812904 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5668803353 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.5853793802 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6038784251 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6223774701 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6408765150 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6593755599 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6778746049 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.6963736498 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7148726947 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7333717396 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7518707846 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7703698295 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.7888688744 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8073679193 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8258669643 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8443660092 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8628650541 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8813640990 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.8998631440 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9183621889 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9368612338 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9553602787 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9738593237 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 9.9923583686 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0108574135 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0293564584 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0478555034 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0663545483 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.0848535932 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1033526381 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1218516831 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1403507280 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1588497729 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1773488178 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.1958478628 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2143469077 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2328459526 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2513449975 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2698440425 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.2883430874 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3068421323 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3253411773 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3438402222 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3623392671 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3808383120 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.3993373570 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4178364019 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4363354468 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4548344917 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4733335367 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.4918325816 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5103316265 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5288306714 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5473297164 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5658287613 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.5843278062 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6028268511 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6213258961 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6398249410 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6583239859 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6768230308 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.6953220758 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7138211207 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7323201656 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7508192105 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7693182555 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.7878173004 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8063163453 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8248153902 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8433144352 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8618134801 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8803125250 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.8988115699 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9173106149 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9358096598 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9543087047 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9728077497 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 10.9913067946 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0098058395 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0283048844 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0468039294 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0653029743 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.0838020192 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1023010641 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1208001091 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1392991540 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1577981989 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1762972438 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.1947962888 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2132953337 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2317943786 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2502934235 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2687924685 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.2872915134 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3057905583 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3242896032 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3427886482 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3612876931 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3797867380 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.3982857829 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4167848279 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4352838728 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4537829177 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4722819626 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.4907810076 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5092800525 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5277790974 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5462781423 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5647771873 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.5832762322 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6017752771 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6202743221 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6387733670 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6572724119 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6757714568 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.6942705018 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7127695467 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7312685916 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7497676365 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7682666815 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.7867657264 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8052647713 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8237638162 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8422628612 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8607619061 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8792609510 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.8977599959 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9162590409 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9347580858 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9532571307 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9717561756 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 11.9902552206 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0087542655 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0272533104 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0457523553 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0642514003 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.0827504452 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1012494901 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1197485350 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1382475800 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1567466249 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1752456698 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.1937447147 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2122437597 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2307428046 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2492418495 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2677408944 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.2862399394 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3047389843 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3232380292 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3417370742 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3602361191 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3787351640 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.3972342089 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4157332539 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4342322988 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4527313437 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4712303886 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.4897294336 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5082284785 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5267275234 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5452265683 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5637256133 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.5822246582 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6007237031 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6192227480 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6377217930 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6562208379 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6747198828 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.6932189277 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7117179727 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7302170176 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7487160625 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7672151074 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.7857141524 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8042131973 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8227122422 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8412112871 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8597103321 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8782093770 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.8967084219 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9152074668 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9337065118 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9522055567 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9707046016 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 12.9892036466 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0077026915 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0262017364 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0447007813 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0631998263 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.0816988712 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1001979161 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1186969610 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1371960060 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1556950509 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1741940958 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.1926931407 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2111921857 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2296912306 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2481902755 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2666893204 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.2851883654 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3036874103 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3221864552 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3406855001 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3591845451 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3776835900 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.3961826349 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4146816798 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4331807248 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4516797697 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4701788146 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.4886778595 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5071769045 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5256759494 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5441749943 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5626740392 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5811730842 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.5996721291 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6181711740 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6366702190 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6551692639 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6736683088 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.6921673537 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7106663987 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7291654436 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7476644885 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7661635334 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.7846625784 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8031616233 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8216606682 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8401597131 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8586587581 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8771578030 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.8956568479 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9141558928 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9326549378 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9511539827 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9696530276 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 13.9881520725 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0066511175 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0251501624 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0436492073 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0621482522 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0806472972 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.0991463421 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1176453870 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1361444319 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1546434769 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1731425218 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.1916415667 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2101406116 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2286396566 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2471387015 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2656377464 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.2841367914 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3026358363 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3211348812 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3396339261 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3581329711 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3766320160 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.3951310609 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4136301058 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4321291508 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4506281957 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4691272406 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.4876262855 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5061253305 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5246243754 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5431234203 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5616224652 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5801215102 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.5986205551 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6171196000 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6356186449 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6541176899 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6726167348 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.6911157797 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7096148246 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7281138696 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7466129145 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7651119594 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.7836110043 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8021100493 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8206090942 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8391081391 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8576071840 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8761062290 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.8946052739 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9131043188 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9316033637 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9501024087 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9686014536 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 14.9871004985 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0055995435 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0240985884 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0425976333 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0610966782 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0795957232 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.0980947681 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1165938130 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 15.1350928579 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 15.1535919029 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 15.1720909478 0.0000000000 0.0000000000 0.0000000002 0.0000000000 + 15.1905899927 0.0000000000 0.0000000000 0.0000000004 0.0000000000 + 15.2090890376 0.0000000000 0.0000000000 0.0000000007 0.0000000000 + 15.2275880826 0.0000000000 0.0000000000 0.0000000012 0.0000000000 + 15.2460871275 0.0000000000 0.0000000000 0.0000000021 0.0000000000 + 15.2645861724 0.0000000000 0.0000000000 0.0000000036 0.0000000000 + 15.2830852173 0.0000000000 0.0000000001 0.0000000061 0.0000000000 + 15.3015842623 0.0000000000 0.0000000001 0.0000000104 0.0000000001 + 15.3200833072 0.0000000000 0.0000000002 0.0000000174 0.0000000001 + 15.3385823521 0.0000000000 0.0000000004 0.0000000288 0.0000000002 + 15.3570813970 0.0000000000 0.0000000006 0.0000000474 0.0000000003 + 15.3755804420 0.0000000001 0.0000000010 0.0000000772 0.0000000005 + 15.3940794869 0.0000000001 0.0000000017 0.0000001246 0.0000000008 + 15.4125785318 0.0000000002 0.0000000026 0.0000001993 0.0000000013 + 15.4310775767 0.0000000003 0.0000000042 0.0000003158 0.0000000020 + 15.4495766217 0.0000000004 0.0000000066 0.0000004958 0.0000000031 + 15.4680756666 0.0000000007 0.0000000102 0.0000007712 0.0000000049 + 15.4865747115 0.0000000011 0.0000000157 0.0000011888 0.0000000075 + 15.5050737564 0.0000000016 0.0000000240 0.0000018155 0.0000000115 + 15.5235728014 0.0000000024 0.0000000363 0.0000027471 0.0000000173 + 15.5420718463 0.0000000036 0.0000000544 0.0000041186 0.0000000259 + 15.5605708912 0.0000000052 0.0000000808 0.0000061182 0.0000000384 + 15.5790699361 0.0000000077 0.0000001188 0.0000090049 0.0000000565 + 15.5975689811 0.0000000111 0.0000001731 0.0000131319 0.0000000822 + 15.6160680260 0.0000000159 0.0000002499 0.0000189744 0.0000001186 + 15.6345670709 0.0000000226 0.0000003575 0.0000271643 0.0000001695 + 15.6530661159 0.0000000317 0.0000005067 0.0000385319 0.0000002400 + 15.6715651608 0.0000000443 0.0000007115 0.0000541542 0.0000003368 + 15.6900642057 0.0000000612 0.0000009900 0.0000754109 0.0000004682 + 15.7085632506 0.0000000837 0.0000013649 0.0001040464 0.0000006449 + 15.7270622956 0.0000001135 0.0000018644 0.0001422362 0.0000008801 + 15.7455613405 0.0000001526 0.0000025234 0.0001926565 0.0000011901 + 15.7640603854 0.0000002031 0.0000033840 0.0002585519 0.0000015946 + 15.7825594303 0.0000002680 0.0000044963 0.0003437971 0.0000021168 + 15.8010584753 0.0000003503 0.0000059194 0.0004529465 0.0000027843 + 15.8195575202 0.0000004536 0.0000077213 0.0005912645 0.0000036287 + 15.8380565651 0.0000005821 0.0000099792 0.0007647281 0.0000046858 + 15.8565556100 0.0000007401 0.0000127789 0.0009799919 0.0000059952 + 15.8750546550 0.0000009323 0.0000162138 0.0012443084 0.0000076001 + 15.8935536999 0.0000011637 0.0000203830 0.0015653943 0.0000095462 + 15.9120527448 0.0000014391 0.0000253889 0.0019512349 0.0000118806 + 15.9305517897 0.0000017634 0.0000313338 0.0024098244 0.0000146501 + 15.9490508347 0.0000021409 0.0000383155 0.0029488403 0.0000178993 + 15.9675498796 0.0000025753 0.0000464224 0.0035752556 0.0000216684 + 15.9860489245 0.0000030695 0.0000557280 0.0042948983 0.0000259904 + 16.0045479694 0.0000036248 0.0000662844 0.0051119733 0.0000308882 + 16.0230470144 0.0000042413 0.0000781162 0.0060285678 0.0000363719 + 16.0415460593 0.0000049170 0.0000912144 0.0070441655 0.0000424360 + 16.0600451042 0.0000056480 0.0001055304 0.0081552027 0.0000490566 + 16.0785441491 0.0000064281 0.0001209718 0.0093546972 0.0000561894 + 16.0970431941 0.0000072487 0.0001373986 0.0106319871 0.0000637685 + 16.1155422390 0.0000080991 0.0001546225 0.0119726102 0.0000717054 + 16.1340412839 0.0000089660 0.0001724070 0.0133583529 0.0000798898 + 16.1525403288 0.0000098346 0.0001904710 0.0147674875 0.0000881912 + 16.1710393738 0.0000106882 0.0002084945 0.0161752092 0.0000964612 + 16.1895384187 0.0000115092 0.0002261269 0.0175542696 0.0001045381 + 16.2080374636 0.0000122795 0.0002429974 0.0188757906 0.0001122510 + 16.2265365085 0.0000129809 0.0002587276 0.0201102299 0.0001194263 + 16.2450355535 0.0000135964 0.0002729452 0.0212284547 0.0001258935 + 16.2635345984 0.0000141103 0.0002852986 0.0222028721 0.0001314924 + 16.2820336433 0.0000145091 0.0002954715 0.0230085544 0.0001360792 + 16.3005326883 0.0000147821 0.0003031956 0.0236242959 0.0001395329 + 16.3190317332 0.0000149220 0.0003082632 0.0240335402 0.0001417604 + 16.3375307781 0.0000149248 0.0003105360 0.0242251193 0.0001427010 + 16.3560298230 0.0000147905 0.0003099513 0.0241937601 0.0001423287 + 16.3745288680 0.0000145228 0.0003065254 0.0239403258 0.0001406538 + 16.3930279129 0.0000141290 0.0003003521 0.0234717759 0.0001377223 + 16.4115269578 0.0000136196 0.0002915991 0.0228008491 0.0001336134 + 16.4300260027 0.0000130080 0.0002805000 0.0219454877 0.0001284368 + 16.4485250477 0.0000123098 0.0002673442 0.0209280406 0.0001223269 + 16.4670240926 0.0000115421 0.0002524641 0.0197742940 0.0001154378 + 16.4855231375 0.0000107228 0.0002362217 0.0185123887 0.0001079362 + 16.5040221824 0.0000098703 0.0002189933 0.0171716868 0.0000999953 + 16.5225212274 0.0000090020 0.0002011560 0.0157816517 0.0000917878 + 16.5410202723 0.0000081348 0.0001830737 0.0143707990 0.0000834802 + 16.5595193172 0.0000072836 0.0001650859 0.0129657700 0.0000752272 + 16.5780183621 0.0000064615 0.0001474975 0.0115905653 0.0000671675 + 16.5965174071 0.0000056797 0.0001305721 0.0102659656 0.0000594206 + 16.6150164520 0.0000049465 0.0001145267 0.0090091505 0.0000520843 + 16.6335154969 0.0000042685 0.0000995300 0.0078335153 0.0000452346 + 16.6520145418 0.0000036496 0.0000857022 0.0067486725 0.0000389248 + 16.6705135868 0.0000030917 0.0000731174 0.0057606139 0.0000331875 + 16.6890126317 0.0000025951 0.0000618073 0.0048720073 0.0000280360 + 16.7075116766 0.0000021582 0.0000517666 0.0040825903 0.0000234666 + 16.7260107215 0.0000017784 0.0000429586 0.0033896304 0.0000194615 + 16.7445097665 0.0000014520 0.0000353216 0.0027884159 0.0000159918 + 16.7630088114 0.0000011746 0.0000287754 0.0022727486 0.0000130199 + 16.7815078563 0.0000009415 0.0000232270 0.0018354131 0.0000105030 + 16.8000069012 0.0000007477 0.0000185762 0.0014686045 0.0000083948 + 16.8185059462 0.0000005884 0.0000147200 0.0011642987 0.0000066481 + 16.8370049911 0.0000004587 0.0000115572 0.0009145607 0.0000052165 + 16.8555040360 0.0000003544 0.0000089905 0.0007117854 0.0000040556 + 16.8740030809 0.0000002712 0.0000069296 0.0005488759 0.0000031241 + 16.8925021259 0.0000002057 0.0000052920 0.0004193606 0.0000023844 + 16.9110011708 0.0000001546 0.0000040043 0.0003174604 0.0000018031 + 16.9295002157 0.0000001151 0.0000030021 0.0002381113 0.0000013510 + 16.9479992607 0.0000000849 0.0000022300 0.0001769533 0.0000010030 + 16.9664983056 0.0000000620 0.0000016413 0.0001302944 0.0000007378 + 16.9849973505 0.0000000449 0.0000011969 0.0000950563 0.0000005377 + 17.0034963954 0.0000000322 0.0000008648 0.0000687108 0.0000003883 + 17.0219954404 0.0000000229 0.0000006191 0.0000492104 0.0000002778 + 17.0404944853 0.0000000161 0.0000004391 0.0000349202 0.0000001969 + 17.0589935302 0.0000000113 0.0000003086 0.0000245519 0.0000001383 + 17.0774925751 0.0000000078 0.0000002149 0.0000171034 0.0000000963 + 17.0959916201 0.0000000053 0.0000001483 0.0000118050 0.0000000664 + 17.1144906650 0.0000000036 0.0000001013 0.0000080731 0.0000000454 + 17.1329897099 0.0000000024 0.0000000686 0.0000054702 0.0000000307 + 17.1514887548 0.0000000016 0.0000000461 0.0000036724 0.0000000206 + 17.1699877998 0.0000000011 0.0000000306 0.0000024428 0.0000000137 + 17.1884868447 0.0000000007 0.0000000202 0.0000016100 0.0000000090 + 17.2069858896 0.0000000005 0.0000000132 0.0000010513 0.0000000059 + 17.2254849345 0.0000000003 0.0000000085 0.0000006802 0.0000000038 + 17.2439839795 0.0000000002 0.0000000055 0.0000004360 0.0000000024 + 17.2624830244 0.0000000001 0.0000000035 0.0000002769 0.0000000015 + 17.2809820693 0.0000000001 0.0000000022 0.0000001743 0.0000000010 + 17.2994811142 0.0000000000 0.0000000014 0.0000001087 0.0000000006 + 17.3179801592 0.0000000000 0.0000000008 0.0000000671 0.0000000004 + 17.3364792041 0.0000000000 0.0000000005 0.0000000411 0.0000000002 + 17.3549782490 0.0000000000 0.0000000003 0.0000000249 0.0000000001 + 17.3734772939 0.0000000000 0.0000000002 0.0000000150 0.0000000001 + 17.3919763389 0.0000000000 0.0000000001 0.0000000089 0.0000000000 + 17.4104753838 0.0000000000 0.0000000001 0.0000000053 0.0000000000 + 17.4289744287 0.0000000000 0.0000000000 0.0000000031 0.0000000000 + 17.4474734736 0.0000000000 0.0000000000 0.0000000018 0.0000000000 + 17.4659725186 0.0000000000 0.0000000000 0.0000000010 0.0000000000 + 17.4844715635 0.0000000000 0.0000000000 0.0000000006 0.0000000000 + 17.5029706084 0.0000000000 0.0000000000 0.0000000003 0.0000000000 + 17.5214696533 0.0000000000 0.0000000000 0.0000000002 0.0000000000 + 17.5399686983 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 17.5584677432 0.0000000000 0.0000000000 0.0000000001 0.0000000000 + 17.5769667881 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.5954658330 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6139648780 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6324639229 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6509629678 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6694620128 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.6879610577 0.0000000000 0.0000000000 0.0000000000 0.0000000000 + 17.7064601026 0.0000000000 0.0000000000 0.0000000000 0.0000000000