bond_order_processing.calculations_for_atoms_lists

  1"""Calculations in this module are made for PairOfAtoms
  2objects lists. This module is added in version: 1.1.0.
  3
  4
  5Example:
  6
  7    >>> from bond_order_processing.input_data import LoadedData
  8    >>> from bond_order_processing.calculations_for_atoms_lists import CoordinationNumbers
  9    >>> from bond_order_processing.input_data import InputDataFromCPMD
 10    >>> from bond_order_processing.calculations import PairOfAtoms
 11    >>> 
 12    >>> path_to_input_file = r'./egzamples_instructions/cpmd_out1.txt'
 13    >>> 
 14    >>> input_data = InputDataFromCPMD()
 15    >>> input_data.load_input_data(path_to_input_file, LoadedData.MayerBondOrders)
 16    >>> mayer_bond_orders = input_data.return_data(LoadedData.MayerBondOrders)
 17    >>> 
 18    >>> pairs_of_atoms = [PairOfAtoms("P", "O", 0.2, 2.0, "P-O"), PairOfAtoms("Fe", "O", 0.2, 2.0, "Fe-O")]
 19    >>> # Calculate percentage of coordination numbers of P
 20    >>> coordinations_numbers_stats = CoordinationNumbersFromPairOfAtoms.calculate(pairs_of_atoms, mayer_bond_orders).calculate_statistics()
 21    >>> coordinations_numbers_stats.coordination_numbers['P-O'].statistics
 22    {4: 100.0}
 23    
 24"""
 25__docformat__ = "google"
 26from .calculations import Calculations
 27from .calculations import Statistics
 28from .calculations import PairOfAtoms
 29from .calculations import Histogram
 30from .input_data import MayerBondOrders
 31from .input_data import CoordinatesOfAtoms
 32from .calculations import CoordinationNumbers
 33from .calculations import Connections
 34from .calculations import BondLength
 35from .calculations import Covalence
 36from .calculations import QiUnits
 37
 38
 39class _FromPairOfAtoms:
 40    @ staticmethod
 41    def _get_unique_atom_symbols(pair_of_atoms: list[PairOfAtoms])\
 42            -> list[str]:
 43        unique_symbols = []
 44        for item in pair_of_atoms:
 45            if item.atom_1 not in unique_symbols:
 46                unique_symbols.append(item.atom_1)
 47            if item.atom_2 not in unique_symbols:
 48                unique_symbols.append(item.atom_2)
 49
 50        return unique_symbols
 51
 52
 53class HistogramsFromPairOfAtoms(Calculations):
 54    """Calculate histograms for list of pairs of atoms."""
 55    _Histogram: type = Histogram
 56    histograms: dict[str, Histogram]
 57    """**key** - bond_id, **value** - Histogram object"""
 58    _atoms_names: dict[str, (str, str)]
 59
 60    @classmethod
 61    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
 62                  mayer_bond_orders: MayerBondOrders,
 63                  bins: int):
 64        """Calculate HistogramsFromPairOfAtoms object.
 65
 66        Args:
 67            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
 68            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
 69            bins (int): Number of bins in histogram.
 70
 71        Returns:
 72            **HistogramsFromPairOfAtoms**: HistogramsFromPairOfAtoms object
 73
 74        """
 75        self = cls()
 76        self.histograms = {}
 77        self._atoms_names = {}
 78        for item in pair_of_atoms:
 79            mbos = mayer_bond_orders\
 80                .get_mayer_bond_orders_list_between_two_atoms(
 81                    item.atom_1, item.atom_2)
 82
 83            if type(item.MBO_max) is str:
 84                if item.MBO_max == 'INF':
 85                    mbos = [mbo for mbo in mbos if item.MBO_min < mbo]
 86                else:
 87                    raise ValueError("Wrong type of max_mayer_bond_order!!!!")
 88            else:
 89                mbos = [mbo for mbo in mbos if item.MBO_max > mbo
 90                        and item.MBO_min < mbo]
 91
 92            self._atoms_names.update({item.id: (item.atom_1, item.atom_2)})
 93            histogram = cls._Histogram.calculate(mbos, bins)
 94            self.histograms.update({item.id: histogram})
 95        return self
 96
 97    def remove_duplicates(self):
 98        """Removes duplicates, which have the same atoms symbols.
 99            Use when you perform calculations for list[PairOfAtoms]
100            when ids are different for the same atoms pairs.
101        """
102
103        temp = []
104        for key in list(self._atoms_names.keys()):
105            if self._atoms_names[key] in temp:
106                del self._atoms_names[key]
107                del self.histograms[key]
108            else:
109                temp.append(self._atoms_names[key])
110
111        return self
112
113    def to_string(self) -> str:
114        """Make string from HistogramsFromPairOfAtoms object
115
116        Returns:
117            **str**: String
118
119        """
120        string = ""
121        for key, histogram in self.histograms.items():
122            atom_id_1, atom_id_2 = self._atoms_names[key]
123            string += histogram.to_string(key, atom_id_1, atom_id_2)
124
125        return string
126
127
128class CoordinationNumbersFromPairOfAtoms(Calculations, Statistics):
129    """Calculate coordination numbers for list of pairs of atoms."""
130    _CoordinationNumbers: type = CoordinationNumbers
131    coordination_numbers: list[str, CoordinationNumbers]
132    """**key** - bond_id, **value** - CoordinationNumbers object"""
133    _atoms_names: dict[str, (str, str)]
134
135    @classmethod
136    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
137                  mayer_bond_orders: MayerBondOrders):
138        """Calculate CoordinationNumbersFromPairOfAtoms object.
139
140        Args:
141            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
142            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
143
144        Returns:
145            **CoordinationNumbersFromPairOfAtoms**: CoordinationNumbersFromPairOfAtoms object.
146
147        """
148        self = cls()
149        self.coordination_numbers = {}
150        self._atoms_names = {}
151        for item in pair_of_atoms:
152            self._atoms_names.update({item.id: (item.atom_1, item.atom_2)})
153            coordination = cls._CoordinationNumbers\
154                .calculate(mayer_bond_orders,
155                           item.atom_1, item.atom_2,
156                           item.MBO_max, item.MBO_min,
157                           item.id)
158            self.coordination_numbers.update({item.id: coordination})
159        return self
160
161    def calculate_statistics(self):
162        """Calculate statistic in **CoordinationNumbers** objects."""
163
164        for keys in self.coordination_numbers.keys():
165            self.coordination_numbers[keys].calculate_statistics()
166        return self
167
168    def to_string(self) -> str:
169        """Make string from CoordinationNumbersFromPairOfAtoms object
170
171        Returns:
172            **str**: String
173
174        """
175        string = ""
176        for coordination_numbers in self.coordination_numbers.values():
177            string += coordination_numbers\
178                .to_string()
179
180        return string
181
182
183class ConnectionsFromPairOfAtoms(Calculations):
184    """Calculate connections for list of pairs of atoms."""
185    _Connections: type = Connections
186    connections: dict[str, Histogram]
187    """**key** - bond_id, **value** - Connections object"""
188    _atoms_names: dict[str, (str, str)]
189
190    @classmethod
191    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
192                  mayer_bond_orders: MayerBondOrders):
193        """Calculate ConnectionsFromPairOfAtoms object.
194
195        Args:
196            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
197            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
198
199        Returns:
200            **ConnectionsFromPairOfAtoms**: ConnectionsFromPairOfAtoms object.
201
202        """
203        self = cls()
204        self.connections = {}
205        self._atoms_names = {}
206        for item in pair_of_atoms:
207            self._atoms_names.update({item.id: (item.atom_1, item.atom_2)})
208            connections = cls._Connections\
209                .calculate(mayer_bond_orders,
210                           item.atom_1, pair_of_atoms)
211            self.connections.update({item.id: connections})
212        return self
213
214    def to_string(self) -> str:
215        """Make string from ConnectionsFromPairOfAtoms object
216
217        Returns:
218            **str**: String
219
220        """
221        string = ""
222        for connections in self.connections.values():
223            string += connections\
224                .to_string()
225
226        return string
227
228
229class BondLengthFromPairOfAtoms(Calculations):
230    """Calculate bonds lengths for list of pairs of atoms."""
231    _BondLength: type = BondLength
232    bond_lengths: dict[str, BondLength]
233    """**key** - bond_id, **value** - BondLength object"""
234    _atoms_names: dict[str, (str, str)]
235
236    @classmethod
237    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
238                  mayer_bond_orders: MayerBondOrders,
239                  coordinates_of_atoms: CoordinatesOfAtoms) -> type:
240        """Calculate BondLengthFromPairOfAtoms object.
241
242        Args:
243            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
244            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
245            coordinates_of_atoms (CoordinatesOfAtoms): CoordinatesOfAtoms.
246
247        Returns:
248            **BondLengthFromPairOfAtoms**: BondLengthFromPairOfAtoms object.
249
250        """
251        self = cls()
252        self.bond_lengths = {}
253        self._atoms_names = {}
254        for item in pair_of_atoms:
255            self._atoms_names.update({item.id: (item.atom_1, item.atom_2)})
256            bond_lengths = cls._BondLength\
257                .calculate(mayer_bond_orders,
258                           coordinates_of_atoms,
259                           item.atom_1, item.atom_2,
260                           item.MBO_max, item.MBO_min,
261                           item.id)
262            self.bond_lengths.update({item.id: bond_lengths})
263        return self
264
265    def to_string(self) -> str:
266        """Make string from BondLengthFromPairOfAtoms object
267
268        Returns:
269            **str**: String
270
271        """
272        string = ""
273        for bond_length in self.bond_lengths.values():
274            string += bond_length.to_string()
275
276        return string
277
278
279class CovalenceFromPairOfAtoms(Calculations, _FromPairOfAtoms):
280    """Covalence for list of pairs of atoms."""
281    _Covalence: type = Covalence
282    covalence: dict[str, Covalence]
283    """**key** - atom_name, **value** - Covalence object"""
284    _atoms_names: list[str]
285
286    @classmethod
287    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
288                  mayer_bond_orders: MayerBondOrders):
289        """Calculate CovalenceFromPairOfAtoms object.
290
291        Args:
292            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
293            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
294
295        Returns:
296            **CovalenceFromPairOfAtoms**: CovalenceFromPairOfAtoms object.
297
298        """
299        self = cls()
300        self.covalence = {}
301        self._atoms_names = []
302
303        unique_atom_symbols = super()\
304            ._get_unique_atom_symbols(pair_of_atoms)
305
306        for item in unique_atom_symbols:
307            self._atoms_names.append(item)
308            covalence = cls._Covalence\
309                .calculate(mayer_bond_orders, item)
310            self.covalence.update({item: covalence})
311        return self
312
313    def to_string(self) -> str:
314        """Make string from CovalenceFromPairOfAtoms object
315
316        Returns:
317            **str**: String
318
319        """
320        string = ""
321        for connections in self.covalence.values():
322            string += connections\
323                .to_string()
324
325        return string
326
327
328class QiUnitsFromPairOfAtoms(Calculations, Statistics):
329    """Calculate Qⁱ for list of pairs of atoms."""
330    _QiUnits: type = QiUnits
331    qi_units: dict[str, QiUnits]
332    """**key** - bond_id, **value** - QiUnits object"""
333    _atoms_names: list[str]
334
335    @classmethod
336    def calculate(cls, pair_of_atoms: list[PairOfAtoms],
337                  mayer_bond_orders: MayerBondOrders):
338        """Calculate QiUnitsFromPairOfAtoms object.
339
340        Args:
341            pair_of_atoms (list[PairOfAtoms]): list of PairOfAtoms objects.
342            mayer_bond_orders (MayerBondOrders): MayerBondOrders object.
343
344        Returns:
345            **QiUnitsFromPairOfAtoms**: QiUnitsFromPairOfAtoms object.
346
347        """
348        self = cls()
349        self.qi_units = {}
350        self._atoms_names = {}
351        for item in pair_of_atoms:
352            self._atoms_names.update({item.id: (item.atom_1, item.atom_2)})
353            qi_units = cls._QiUnits\
354                .calculate(mayer_bond_orders,
355                           item.atom_1, item.atom_2,
356                           item.MBO_max, item.MBO_min,
357                           item.id)
358
359            self.qi_units.update({item.id: qi_units})
360        return self
361
362    def calculate_statistics(self):
363        """Calculate statistic in **QiUnits** objects."""
364
365        for keys in self.qi_units.keys():
366            self.qi_units[keys].calculate_statistics()
367        return self
368
369    def to_string(self) -> str:
370        """Make string from **QiUnitsFromPairOfAtoms** object
371
372        Returns:
373            **str**: String
374
375        """
376        string = ""
377        for qi_units in self.qi_units.values():
378            string += qi_units\
379                .to_string()
380
381        return string