Quellcode für qiskit.utils.algorithm_globals

# This code is part of Qiskit.
# (C) Copyright IBM 2019, 2021.
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

"""Algorithm Globals"""

from typing import Optional
import logging

import numpy as np

from qiskit.tools import parallel
from ..user_config import get_config
from ..exceptions import QiskitError

logger = logging.getLogger(__name__)

class QiskitAlgorithmGlobals:
    """Class for global properties."""

    CPU_COUNT = parallel.local_hardware_info()["cpus"]

    def __init__(self) -> None:
        self._random_seed = None  # type: Optional[int]
        self._num_processes = QiskitAlgorithmGlobals.CPU_COUNT
        self._random = None
        self._massive = False
            settings = get_config()
            self.num_processes = settings.get("num_processes", QiskitAlgorithmGlobals.CPU_COUNT)
        except Exception as ex:  # pylint: disable=broad-except
            logger.debug("User Config read error %s", str(ex))

    def random_seed(self) -> Optional[int]:
        """Return random seed."""
        return self._random_seed

    def random_seed(self, seed: Optional[int]) -> None:
        """Set random seed."""
        self._random_seed = seed
        self._random = None

    def num_processes(self) -> int:
        """Return num processes."""
        return self._num_processes

    def num_processes(self, num_processes: Optional[int]) -> None:
        """Set num processes.
        If 'None' is passed, it resets to QiskitAlgorithmGlobals.CPU_COUNT
        if num_processes is None:
            num_processes = QiskitAlgorithmGlobals.CPU_COUNT
        elif num_processes < 1:
            raise QiskitError(f"Invalid Number of Processes {num_processes}.")
        elif num_processes > QiskitAlgorithmGlobals.CPU_COUNT:
            raise QiskitError(
                "Number of Processes {} cannot be greater than cpu count {}.".format(
                    num_processes, QiskitAlgorithmGlobals.CPU_COUNT
        self._num_processes = num_processes
        # TODO: change Terra CPU_COUNT until issue
        # gets resolved: https://github.com/Qiskit/qiskit-terra/issues/1963
            parallel.CPU_COUNT = self.num_processes
        except Exception as ex:  # pylint: disable=broad-except
                "Failed to set qiskit.tools.parallel.CPU_COUNT to value: '%s': Error: '%s'",

    def random(self) -> np.random.Generator:
        """Return a numpy np.random.Generator (default_rng)."""
        if self._random is None:
            self._random = np.random.default_rng(self._random_seed)
        return self._random

    def massive(self) -> bool:
        """Return massive to allow processing of large matrices or vectors."""
        return self._massive

    def massive(self, massive: bool) -> None:
        """Set massive to allow processing of large matrices or  vectors."""
        self._massive = massive

# Global instance to be used as the entry point for globals.
algorithm_globals = QiskitAlgorithmGlobals()