def _compute_dressed_specdata_sweep( self, bare_specdata_list: List[SpectrumData]) -> SpectrumData: """ Calculates and returns all dressed spectral data. """ self._bare_hamiltonian_constant = self._compute_bare_hamiltonian_constant( bare_specdata_list) param_indices = range(self.param_count) func = functools.partial(self._compute_dressed_eigensystem, bare_specdata_list=bare_specdata_list) target_map = cpu_switch.get_map_method(self.num_cpus) with utils.InfoBar( "Parallel compute dressed eigensys [num_cpus={}]".format( self.num_cpus), self.num_cpus, ): dressed_eigendata = list( target_map( func, tqdm( param_indices, desc="Dressed spectrum", leave=False, disable=self.tqdm_disabled, ), )) dressed_specdata = self._recast_dressed_eigendata(dressed_eigendata) del dressed_eigendata return dressed_specdata
def _compute_bare_specdata_sweep(self) -> List[SpectrumData]: """ Pre-calculates all bare spectral data needed for the interactive explorer display. """ bare_eigendata_constant = [self._compute_bare_spectrum_constant() ] * self.param_count target_map = cpu_switch.get_map_method(self.num_cpus) with utils.InfoBar( "Parallel compute bare eigensys [num_cpus={}]".format( self.num_cpus), self.num_cpus, ): bare_eigendata_varying = list( target_map( self._compute_bare_spectrum_varying, tqdm( self.param_vals, desc="Bare spectra", leave=False, disable=self.tqdm_disabled, ), )) bare_specdata_list = self._recast_bare_eigendata( bare_eigendata_constant, bare_eigendata_varying) del bare_eigendata_constant del bare_eigendata_varying return bare_specdata_list
def get_spectrum_vs_paramvals(self, param_vals, update_hilbertspace, evals_count=10, get_eigenstates=False, param_name="external_parameter", num_cpus=settings.NUM_CPUS): """Return eigenvalues (and optionally eigenstates) of the full Hamiltonian as a function of a parameter. Parameter values are specified as a list or array in `param_vals`. The Hamiltonian `hamiltonian_func` must be a function of that particular parameter, and is expected to internally set subsystem parameters. If a `filename` string is provided, then eigenvalue data is written to that file. Parameters ---------- param_vals: ndarray of floats array of parameter values update_hilbertspace: function update_hilbertspace(param_val) specifies how a change in the external parameter affects the Hilbert space components evals_count: int, optional number of desired energy levels (default value = 10) get_eigenstates: bool, optional set to true if eigenstates should be returned as well (default value = False) param_name: str, optional name for the parameter that is varied in `param_vals` (default value = "external_parameter") num_cpus: int, optional number of cores to be used for computation (default value: settings.NUM_CPUS) Returns ------- SpectrumData object """ target_map = cpu_switch.get_map_method(num_cpus) if get_eigenstates: func = functools.partial(self._esys_for_paramval, update_hilbertspace=update_hilbertspace, evals_count=evals_count) with utils.InfoBar("Parallel computation of eigenvalues [num_cpus={}]".format(num_cpus), num_cpus): eigensystem_mapdata = list(target_map(func, tqdm(param_vals, desc='Spectral data', leave=False, disable=(num_cpus > 1)))) eigenvalue_table, eigenstate_table = spec_utils.recast_esys_mapdata(eigensystem_mapdata) else: func = functools.partial(self._evals_for_paramval, update_hilbertspace=update_hilbertspace, evals_count=evals_count) with utils.InfoBar("Parallel computation of eigensystems [num_cpus={}]".format(num_cpus), num_cpus): eigenvalue_table = list(target_map(func, tqdm(param_vals, desc='Spectral data', leave=False, disable=(num_cpus > 1)))) eigenvalue_table = np.asarray(eigenvalue_table) eigenstate_table = None return storage.SpectrumData(eigenvalue_table, self.get_initdata(), param_name, param_vals, state_table=eigenstate_table)
def _subsys_bare_spectrum_sweep(self, subsystem) -> ndarray: """ Parameters ---------- subsystem: subsystem for which the bare spectrum sweep is to be computed Returns ------- multidimensional array of the format array[p1, p2, p3, ..., pN] = np.asarray[[evals, evecs]] """ fixed_paramnames = self._paramnames_no_subsys_update(subsystem) reduced_parameters = self._parameters.create_reduced(fixed_paramnames) total_count = np.prod( [len(param_vals) for param_vals in reduced_parameters]) multi_cpu = self._num_cpus > 1 target_map = cpu_switch.get_map_method(self._num_cpus) with utils.InfoBar( "Parallel compute bare eigensys [num_cpus={}]".format( self._num_cpus), self._num_cpus, ) as p: bare_eigendata = tqdm( target_map( functools.partial( self._update_subsys_compute_esys, self._update_hilbertspace, subsystem, ), itertools.product(*reduced_parameters.paramvals_list), ), total=total_count, desc="Bare spectra", leave=False, disable=multi_cpu, ) bare_eigendata = np.asarray(list(bare_eigendata), dtype=object) bare_eigendata = bare_eigendata.reshape( (*reduced_parameters.counts, 2)) # Bare spectral data was only computed once for each parameter that has no # update effect on the subsystems. Now extend the array to reflect this # for the full parameter array by repeating for name in fixed_paramnames: index = self._parameters.index_by_name[name] param_count = self._parameters.counts[index] bare_eigendata = np.repeat(bare_eigendata, param_count, axis=index) return bare_eigendata
def _dressed_spectrum_sweep( self, ) -> Tuple[NamedSlotsNdarray, NamedSlotsNdarray]: """ Returns ------- NamedSlotsNdarray[<paramname1>, <paramname2>, ...] of eigenvalues, likewise for eigenvectors """ multi_cpu = self._num_cpus > 1 target_map = cpu_switch.get_map_method(self._num_cpus) total_count = np.prod(self._parameters.counts) with utils.InfoBar( "Parallel compute dressed eigensys [num_cpus={}]".format( self._num_cpus), self._num_cpus, ) as p: spectrum_data = list( tqdm( target_map( functools.partial( self._update_and_compute_dressed_esys, self._hilbertspace, self._evals_count, self._update_hilbertspace, ), itertools.product(*self._parameters.ranges), ), total=total_count, desc="Dressed spectrum", leave=False, disable=multi_cpu, )) spectrum_data = np.asarray(spectrum_data, dtype=object) spectrum_data = spectrum_data.reshape((*self._parameters.counts, 2)) slotparamvals_by_name = OrderedDict( self._parameters.ordered_dict.copy()) evals = np.asarray(spectrum_data[..., 0].tolist()) evecs = spectrum_data[..., 1] return NamedSlotsNdarray(evals, slotparamvals_by_name), NamedSlotsNdarray( evecs, slotparamvals_by_name)