Python cbook.flatten方法代码示例

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def normalize_constraint_factor(self, keys):
        if keys in self._cached_normalizations.keys():
            return self._cached_normalizations[keys]
        else:
            min_accept = 1000
            sampling_chunk = 5000
            samples = self.sample_subset(keys=keys, size=sampling_chunk)
            keep = np.atleast_1d(self.evaluate_constraints(samples))
            if len(keep) == 1:
                return 1
            all_samples = {key: np.array([]) for key in keys}
            while np.count_nonzero(keep) < min_accept:
                samples = self.sample_subset(keys=keys, size=sampling_chunk)
                for key in samples:
                    all_samples[key] = np.hstack(
                        [all_samples[key], samples[key].flatten()])
                keep = np.array(self.evaluate_constraints(all_samples), dtype=bool)
            factor = len(keep) / np.count_nonzero(keep)
            self._cached_normalizations[keys] = factor
            return factor 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def get_children(self):
        return list(cbook.flatten(self)) 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def _update(self):
        if self.x is not None and self.y is not None:
            self.X,self.Y = num.meshgridt(self.x, self.y)
            self.xx = self.X.flatten()
            self.yy = self.Y.flatten()
            self.XY = np.array([self.xx, self.yy]).T
        elif self.X is not None and self.Y is not None:
            self.x = self.X[:,0]
            self.xx = self.X.flatten()
            self.y = self.Y[0,:]
            self.yy = self.Y.flatten()
            self.XY = np.array([self.xx, self.yy]).T
        elif self.xx is not None and self.yy is not None:
            self.x = self._unique(self.xx)
            self.y = self._unique(self.yy)
            self.X,self.Y = num.meshgridt(self.x, self.y)
            self.XY = np.array([self.xx, self.yy]).T
        elif self.XY is not None:
            self.xx = self.XY[:,0]
            self.yy = self.XY[:,1]
            self.x = self._unique(self.xx)
            self.y = self._unique(self.yy)
            self.X,self.Y = num.meshgridt(self.x, self.y)
        else:
            raise Exception("cannot determine x and y from input")
        # by now, we have all forms of x and y: x,y; xx,yy; X,Y; XY
        self.nx = len(self.x)
        self.ny = len(self.y)
        # Z is optional
        if self.Z is None:
            if self.zz is not None:
                self.Z = self.zz.reshape(len(self.x), len(self.y))
        else:
            self.zz = self.Z.flatten() 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def remove(self):
        for c in cbook.flatten(
                self, scalarp=lambda x: isinstance(x, martist.Artist)):
            if c is not None:
                c.remove()

        if self._remove_method:
            self._remove_method(self) 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def get_children(self):
        return [child for child in cbook.flatten(self) if child is not None] 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def __init__(self, line, bands):
        """
        :param line: Line2D
            A line of the x,y nominal values

        :param bands: list of PolyCollections
            The fill_between and/or fill_betweenx PollyCollections spanning the std_devs of the x,y data

        """
        from matplotlib.cbook import flatten
        self.line = line  # matplotlib.lines.Line2D
        self.bands = list(flatten([bands]))  # matplotlib.collections.PolyCollection(s) 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def sample_subset_constrained(self, keys=iter([]), size=None):
        if size is None or size == 1:
            while True:
                sample = self.sample_subset(keys=keys, size=size)
                if self.evaluate_constraints(sample):
                    return sample
        else:
            needed = np.prod(size)
            constraint_keys = list()
            for ii, key in enumerate(keys[-1::-1]):
                if isinstance(self[key], Constraint):
                    constraint_keys.append(-ii - 1)
            for ii in constraint_keys[-1::-1]:
                del keys[ii]
            all_samples = {key: np.array([]) for key in keys}
            _first_key = list(all_samples.keys())[0]
            while len(all_samples[_first_key]) < needed:
                samples = self.sample_subset(keys=keys, size=needed)
                keep = np.array(self.evaluate_constraints(samples), dtype=bool)
                for key in samples:
                    all_samples[key] = np.hstack(
                        [all_samples[key], samples[key][keep].flatten()])
            all_samples = {key: np.reshape(all_samples[key][:needed], size)
                           for key in all_samples
                           if not isinstance(self[key], Constraint)}
            return all_samples 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def rescale(self, keys, theta):
        """Rescale samples from unit cube to prior

        Parameters
        ----------
        keys: list
            List of prior keys to be rescaled
        theta: list
            List of randomly drawn values on a unit cube associated with the prior keys

        Returns
        -------
        list: List of floats containing the rescaled sample
        """
        return list(flatten([self[key].rescale(sample) for key, sample in zip(keys, theta)])) 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import flatten [as 别名]
def _makeplot(self, ax, fig, data, ymin=None, ymax=None, height=6,
                  width=6, dos=None, color=None):
        """Utility method to tidy phonon band structure diagrams. """
        # Define colours
        if color is None:
            color = 'C0'  # Default to first colour in matplotlib series

        # set x and y limits
        tymax = ymax if (ymax is not None) else max(flatten(data['frequency']))
        tymin = ymin if (ymin is not None) else min(flatten(data['frequency']))
        pad = (tymax - tymin) * 0.05

        if ymin is None:
            ymin = 0 if tymin >= self.imag_tol else tymin - pad
        ymax = ymax if ymax else tymax + pad

        ax.set_ylim(ymin, ymax)
        ax.set_xlim(0, data['distances'][-1][-1])

        if ymin < 0:
            dashline = True
            ax.axhline(0, color=rcParams['grid.color'], linestyle='--',
                       dashes=dashes,
                       zorder=0,
                       linewidth=rcParams['ytick.major.width'])
        else:
            dashline = False

        if dos is not None:
            self._plot_phonon_dos(dos, ax=fig.axes[1], color=color,
                                  dashline=dashline)
        else:

            # keep correct aspect ratio; match axis to canvas
            x0, x1 = ax.get_xlim()
            y0, y1 = ax.get_ylim()

            if width is None:
                width = rcParams['figure.figsize'][0]
            if height is None:
                height = rcParams['figure.figsize'][1]
            ax.set_aspect((height/width) * ((x1-x0)/(y1-y0)))