diff --git a/src/nomad_simulations/atoms_state.py b/src/nomad_simulations/atoms_state.py index 392f4edd..6b32f43e 100644 --- a/src/nomad_simulations/atoms_state.py +++ b/src/nomad_simulations/atoms_state.py @@ -28,7 +28,7 @@ from nomad.datamodel.metainfo.basesections import Entity from nomad.datamodel.metainfo.annotations import ELNAnnotation -from .utils import RussellSaundersState +from nomad_simulations.utils import RussellSaundersState class OrbitalsState(Entity): @@ -280,7 +280,7 @@ def resolve_degeneracy(self) -> Optional[int]: for jj in self.j_quantum_number: if self.mj_quantum_number is not None: mjs = RussellSaundersState.generate_MJs( - self.j_quantum_number[0], rising=True + J=self.j_quantum_number[0], rising=True ) degeneracy += len( [mj for mj in mjs if mj in self.mj_quantum_number] @@ -293,7 +293,7 @@ def normalize(self, archive, logger) -> None: super().normalize(archive, logger) # General checks for physical quantum numbers and symbols - if not self.validate_quantum_numbers(logger): + if not self.validate_quantum_numbers(logger=logger): logger.error('The quantum numbers are not physical.') return @@ -301,7 +301,7 @@ def normalize(self, archive, logger) -> None: for quantum_name in ['l', 'ml', 'ms']: for quantum_type in ['number', 'symbol']: quantity = self.resolve_number_and_symbol( - quantum_name, quantum_type, logger + quantum_name=quantum_name, quantum_type=quantum_type, logger=logger ) if getattr(self, f'{quantum_name}_quantum_{quantum_type}') is None: setattr(self, f'{quantum_name}_quantum_{quantum_type}', quantity) @@ -383,7 +383,7 @@ def normalize(self, archive, logger) -> None: self.n_excited_electrons = None self.orbital_ref.degeneracy = 1 if self.orbital_ref.occupation is None: - self.orbital_ref.occupation = self.resolve_occupation(logger) + self.orbital_ref.occupation = self.resolve_occupation(logger=logger) class HubbardInteractions(ArchiveSection): @@ -552,11 +552,11 @@ def normalize(self, archive, logger) -> None: self.u_interaction, self.u_interorbital_interaction, self.j_hunds_coupling, - ) = self.resolve_u_interactions(logger) + ) = self.resolve_u_interactions(logger=logger) # If u_effective is not available, calculate it if self.u_effective is None: - self.u_effective = self.resolve_u_effective(logger) + self.u_effective = self.resolve_u_effective(logger=logger) # Check if length of `orbitals_ref` is the same as the length of `umn`: if self.u_matrix is not None and self.orbitals_ref is not None: @@ -652,6 +652,6 @@ def normalize(self, archive, logger) -> None: # Get chemical_symbol from atomic_number and viceversa if self.chemical_symbol is None: - self.chemical_symbol = self.resolve_chemical_symbol(logger) + self.chemical_symbol = self.resolve_chemical_symbol(logger=logger) if self.atomic_number is None: - self.atomic_number = self.resolve_atomic_number(logger) + self.atomic_number = self.resolve_atomic_number(logger=logger) diff --git a/tests/test_atoms_state.py b/tests/test_atoms_state.py index 4482d1ea..d088c144 100644 --- a/tests/test_atoms_state.py +++ b/tests/test_atoms_state.py @@ -69,13 +69,18 @@ def test_validate_quantum_numbers( ): """ Test the `validate_quantum_numbers` method. + + Args: + number_label (str): The quantum number string to be tested. + values (List[int]): The values stored in `OrbitalState`. + results (List[bool]): The expected results after validation. """ orbital_state = OrbitalsState(n_quantum_number=2) for val, res in zip(values, results): if number_label == 'ml_quantum_number': orbital_state.l_quantum_number = 2 setattr(orbital_state, number_label, val) - assert orbital_state.validate_quantum_numbers(logger) == res + assert orbital_state.validate_quantum_numbers(logger=logger) == res @pytest.mark.parametrize( 'quantum_name, value, expected_result', @@ -103,6 +108,11 @@ def test_number_and_symbol( ): """ Test the number and symbol resolution for each of the quantum numbers defined in the parametrization. + + Args: + quantum_name (str): The quantum number string to be tested. + value (Union[int, float]): The value stored in `OrbitalState`. + expected_result (Optional[str]): The expected result after resolving the counter-type. """ # Adding quantum numbers to the `OrbitalsState` section orbital_state = OrbitalsState(n_quantum_number=2) @@ -112,13 +122,13 @@ def test_number_and_symbol( # Making sure that the `'number'` is assigned resolved_type = orbital_state.resolve_number_and_symbol( - quantum_name, 'number', logger + quantum_name=quantum_name, quantum_type='number', logger=logger ) assert resolved_type == value # Resolving if the counter-type is assigned resolved_countertype = orbital_state.resolve_number_and_symbol( - quantum_name, 'symbol', logger + quantum_name=quantum_name, quantum_type='symbol', logger=logger ) assert resolved_countertype == expected_result @@ -146,6 +156,14 @@ def test_degeneracy( ): """ Test the degeneracy of each orbital states defined in the parametrization. + + Args: + l_quantum_number (int): The angular momentum quantum number. + ml_quantum_number (Optional[int]): The magnetic quantum number. + j_quantum_number (Optional[List[float]]): The total angular momentum quantum number. + mj_quantum_number (Optional[List[float]]): The magnetic quantum number for the total angular momentum. + ms_quantum_number (Optional[float]): The spin quantum number. + degeneracy (int): The expected degeneracy of the orbital state. """ orbital_state = OrbitalsState(n_quantum_number=2) self.add_state( @@ -195,13 +213,19 @@ def test_occupation( ): """ Test the occupation of a core hole for a given set of orbital reference and degeneracy. + + Args: + orbital_ref (Optional[OrbitalsState]): The orbital reference of the core hole. + degeneracy (Optional[int]): The degeneracy of the orbital reference. + n_excited_electrons (float): The number of excited electrons. + occupation (Optional[float]): The expected occupation of the core hole. """ core_hole = CoreHole( orbital_ref=orbital_ref, n_excited_electrons=n_excited_electrons ) if orbital_ref is not None: assert orbital_ref.resolve_degeneracy() == degeneracy - resolved_occupation = core_hole.resolve_occupation(logger) + resolved_occupation = core_hole.resolve_occupation(logger=logger) if resolved_occupation is not None: assert np.isclose(resolved_occupation, occupation) else: @@ -232,6 +256,12 @@ def test_normalize( ): """ Test the normalization of the `CoreHole`. Inputs are defined as the quantities of the `CoreHole` section. + + Args: + orbital_ref (Optional[OrbitalsState]): The orbital reference of the core hole. + n_excited_electrons (Optional[float]): The number of excited electrons. + dscf_state (Optional[str]): The DSCF state of the core hole. + results (Tuple[Optional[float], Optional[float], Optional[float]]): The expected results after normalization. """ core_hole = CoreHole( orbital_ref=orbital_ref, @@ -265,6 +295,10 @@ def test_u_interactions( ): """ Test the Hubbard interactions `U`, `U'`, and `J` for a given set of Slater integrals. + + Args: + slater_integrals (Optional[List[float]]): The Slater integrals of the Hubbard interactions. + results (Tuple[Optional[float], Optional[float], Optional[float]]): The expected results of the Hubbard interactions. """ # Adding `slater_integrals` to the `HubbardInteractions` section hubbard_interactions = HubbardInteractions() @@ -276,7 +310,7 @@ def test_u_interactions( u_interaction, u_interorbital_interaction, j_hunds_coupling, - ) = hubbard_interactions.resolve_u_interactions(logger) + ) = hubbard_interactions.resolve_u_interactions(logger=logger) if None not in (u_interaction, u_interorbital_interaction, j_hunds_coupling): assert np.isclose(u_interaction.to('eV').magnitude, results[0]) @@ -306,6 +340,11 @@ def test_u_effective( ): """ Test the effective Hubbard interaction `U_eff` for a given set of Hubbard interactions `U` and `J`. + + Args: + u_interaction (Optional[float]): The Hubbard interaction `U`. + j_local_exchange_interaction (Optional[float]): The Hubbard interaction `J`. + u_effective (Optional[float]): The expected effective Hubbard interaction `U_eff`. """ # Adding `u_interaction` and `j_local_exchange_interaction` to the `HubbardInteractions` section hubbard_interactions = HubbardInteractions() @@ -317,7 +356,7 @@ def test_u_effective( ) # Resolving Ueff from class method - resolved_u_effective = hubbard_interactions.resolve_u_effective(logger) + resolved_u_effective = hubbard_interactions.resolve_u_effective(logger=logger) if resolved_u_effective is not None: assert np.isclose(resolved_u_effective.to('eV').magnitude, u_effective) else: @@ -358,10 +397,14 @@ def test_chemical_symbol_and_atomic_number( ): """ Test the `chemical_symbol` and `atomic_number` resolution for the `AtomsState` section. + + Args: + chemical_symbol (str): The chemical symbol of the atom. + atomic_number (int): The atomic number of the atom. """ # Testing `chemical_symbol` atom_state = AtomsState(chemical_symbol=chemical_symbol) - assert atom_state.resolve_atomic_number(logger) == atomic_number + assert atom_state.resolve_atomic_number(logger=logger) == atomic_number # Testing `atomic_number` atom_state.atomic_number = atomic_number - assert atom_state.resolve_chemical_symbol(logger) == chemical_symbol + assert atom_state.resolve_chemical_symbol(logger=logger) == chemical_symbol