def _parse_parameter_file(self): super(MaestroDataset, self)._parse_parameter_file() jobinfo_filename = os.path.join(self.output_dir, "job_info") line = "" with open(jobinfo_filename, "r") as f: while not line.startswith(" [*] indicates overridden default"): # get the code git hashes if "git hash" in line: # line format: codename git hash: the-hash fields = line.split(":") self.parameters[fields[0]] = fields[1].strip() line = next(f) # get the runtime parameters for line in f: p, v = (_.strip() for _ in line[4:].split("=", 1)) if len(v) == 0: self.parameters[p] = "" else: self.parameters[p] = _guess_pcast(v) # hydro method is set by the base class -- override it here self.parameters["HydroMethod"] = "Maestro" # set the periodicity based on the integer BC runtime parameters periodicity = [True, True, True] if not self.parameters['bcx_lo'] == -1: periodicity[0] = False if not self.parameters['bcy_lo'] == -1: periodicity[1] = False if not self.parameters['bcz_lo'] == -1: periodicity[2] = False self.periodicity = ensure_tuple(periodicity)
def _parse_parameter_file(self): xmin, xmax = self._handle.attrs["RootGridX1"][:2] ymin, ymax = self._handle.attrs["RootGridX2"][:2] zmin, zmax = self._handle.attrs["RootGridX3"][:2] self.domain_left_edge = np.array([xmin, ymin, zmin], dtype="float64") self.domain_right_edge = np.array([xmax, ymax, zmax], dtype="float64") self.geometry = geom_map[self._handle.attrs["Coordinates"].decode( "utf-8")] self.domain_width = self.domain_right_edge - self.domain_left_edge self.domain_dimensions = self._handle.attrs["RootGridSize"] self._field_map = {} k = 0 for dname, num_var in zip(self._handle.attrs["DatasetNames"], self._handle.attrs["NumVariables"]): for j in range(num_var): fname = self._handle.attrs["VariableNames"][k].decode( "ascii", "ignore") self._field_map[fname] = (dname.decode("ascii", "ignore"), j) k += 1 self.refine_by = 2 dimensionality = 3 if self.domain_dimensions[2] == 1: dimensionality = 2 if self.domain_dimensions[1] == 1: dimensionality = 1 self.dimensionality = dimensionality self.current_time = self._handle.attrs["Time"] self.unique_identifier = self.parameter_filename.__hash__() self.cosmological_simulation = False self.num_ghost_zones = 0 self.field_ordering = "fortran" self.boundary_conditions = [1] * 6 if "periodicity" in self.specified_parameters: self.periodicity = ensure_tuple( self.specified_parameters["periodicity"]) else: self.periodicity = (True, True, True) if "gamma" in self.specified_parameters: self.gamma = float(self.specified_parameters["gamma"]) else: self.gamma = 5.0 / 3.0 self.current_redshift = (self.omega_lambda) = ( self.omega_matter ) = self.hubble_constant = self.cosmological_simulation = 0.0 self.parameters[ "Time"] = self.current_time # Hardcode time conversion for now. self.parameters[ "HydroMethod"] = 0 # Hardcode for now until field staggering is supported. if "gamma" in self.specified_parameters: self.parameters["Gamma"] = self.specified_parameters["gamma"] else: self.parameters["Gamma"] = 5.0 / 3.0 self.mu = self.specified_parameters.get("mu", default_mu)
def _setup1d(self): # self._index_class = BoxlibHierarchy1D # self._fieldinfo_fallback = Orion1DFieldInfo self.domain_left_edge = \ np.concatenate([self.domain_left_edge, [0.0, 0.0]]) self.domain_right_edge = \ np.concatenate([self.domain_right_edge, [1.0, 1.0]]) tmp = self.domain_dimensions.tolist() tmp.extend((1, 1)) self.domain_dimensions = np.array(tmp) tmp = list(self.periodicity) tmp[1] = False tmp[2] = False self.periodicity = ensure_tuple(tmp)
def _setup2d(self): self.domain_left_edge = \ np.concatenate([self.domain_left_edge, [0.0]]) self.domain_right_edge = \ np.concatenate([self.domain_right_edge, [1.0]]) if self.geometry == "cylindrical": dre = self.domain_right_edge dre[2] = 2.0 * np.pi self.domain_right_edge = dre tmp = self.domain_dimensions.tolist() tmp.append(1) self.domain_dimensions = np.array(tmp) tmp = list(self.periodicity) tmp[2] = False self.periodicity = ensure_tuple(tmp)
def _parse_parameter_file(self): self._handle = h5py.File(self.parameter_filename, mode="r") if "data_software" in self._handle["gridded_data_format"].attrs: self.data_software = self._handle["gridded_data_format"].attrs[ "data_software"] else: self.data_software = "unknown" sp = self._handle["/simulation_parameters"].attrs if self.geometry is None: geometry = just_one(sp.get("geometry", 0)) try: self.geometry = GEOMETRY_TRANS[geometry] except KeyError: raise YTGDFUnknownGeometry(geometry) self.parameters.update(sp) self.domain_left_edge = sp["domain_left_edge"][:] self.domain_right_edge = sp["domain_right_edge"][:] self.domain_dimensions = sp["domain_dimensions"][:] refine_by = sp["refine_by"] if refine_by is None: refine_by = 2 self.refine_by = refine_by self.dimensionality = sp["dimensionality"] self.current_time = sp["current_time"] self.unique_identifier = sp["unique_identifier"] self.cosmological_simulation = sp["cosmological_simulation"] if sp["num_ghost_zones"] != 0: raise RuntimeError self.num_ghost_zones = sp["num_ghost_zones"] self.field_ordering = sp["field_ordering"] self.boundary_conditions = sp["boundary_conditions"][:] p = [bnd == 0 for bnd in self.boundary_conditions[::2]] self.periodicity = ensure_tuple(p) if self.cosmological_simulation: self.current_redshift = sp["current_redshift"] self.omega_lambda = sp["omega_lambda"] self.omega_matter = sp["omega_matter"] self.hubble_constant = sp["hubble_constant"] else: self.current_redshift = (self.omega_lambda) = ( self.omega_matter ) = self.hubble_constant = self.cosmological_simulation = 0.0 self.parameters["Time"] = 1.0 # Hardcode time conversion for now. # Hardcode for now until field staggering is supported. self.parameters["HydroMethod"] = 0 self._handle.close() del self._handle
def nested_dict_get(pdict, keys, default=None): """ Retrieve a value from a nested dict using a tuple of keys. If a is a dict, and a['b'] = {'c': 'd'}, then nested_dict_get(a, ('b', 'c')) returns 'd'. """ keys = ensure_tuple(keys) val = pdict for key in keys: if val is None: break val = val.get(key) if val is None: val = default return val
def _parse_parameter_file(self): self._handle = h5py.File(self.parameter_filename, "r") if 'data_software' in self._handle['gridded_data_format'].attrs: self.data_software = \ self._handle['gridded_data_format'].attrs['data_software'] else: self.data_software = "unknown" sp = self._handle["/simulation_parameters"].attrs if self.geometry is None: geometry = just_one(sp.get("geometry", 0)) try: self.geometry = GEOMETRY_TRANS[geometry] except KeyError: raise YTGDFUnknownGeometry(geometry) self.parameters.update(sp) self.domain_left_edge = sp["domain_left_edge"][:] self.domain_right_edge = sp["domain_right_edge"][:] self.domain_dimensions = sp["domain_dimensions"][:] refine_by = sp["refine_by"] if refine_by is None: refine_by = 2 self.refine_by = refine_by self.dimensionality = sp["dimensionality"] self.current_time = sp["current_time"] self.unique_identifier = sp["unique_identifier"] self.cosmological_simulation = sp["cosmological_simulation"] if sp["num_ghost_zones"] != 0: raise RuntimeError self.num_ghost_zones = sp["num_ghost_zones"] self.field_ordering = sp["field_ordering"] self.boundary_conditions = sp["boundary_conditions"][:] p = [bnd == 0 for bnd in self.boundary_conditions[::2]] self.periodicity = ensure_tuple(p) if self.cosmological_simulation: self.current_redshift = sp["current_redshift"] self.omega_lambda = sp["omega_lambda"] self.omega_matter = sp["omega_matter"] self.hubble_constant = sp["hubble_constant"] else: self.current_redshift = self.omega_lambda = self.omega_matter = \ self.hubble_constant = self.cosmological_simulation = 0.0 self.parameters['Time'] = 1.0 # Hardcode time conversion for now. # Hardcode for now until field staggering is supported. self.parameters["HydroMethod"] = 0 self._handle.close() del self._handle
def _parse_cparams(self): if self.cparam_filename is None: return for line in (line.split("#")[0].strip() for line in open(self.cparam_filename)): if "=" not in line: continue if len(line) == 0: continue param, vals = [s.strip() for s in line.split("=")] if param == "amr.n_cell": vals = self.domain_dimensions = np.array(vals.split(), dtype='int32') # For 1D and 2D simulations in BoxLib usually only the relevant dimensions # have a specified number of zones, but yt requires domain_dimensions to # have three elements, with 1 in the additional slots if we're not in 3D, # so append them as necessary. if (len(vals) == 1): vals = self.domain_dimensions = np.array([vals[0], 1, 1]) elif (len(vals) == 2): vals = self.domain_dimensions = np.array( [vals[0], vals[1], 1]) elif param == "amr.ref_ratio": vals = self.refine_by = int(vals[0]) elif param == "Prob.lo_bc": vals = self.periodicity = ensure_tuple( [i == 0 for i in vals.split()]) elif param == "castro.use_comoving": vals = self.cosmological_simulation = int(vals) else: vals = _guess_pcast(vals) self.parameters[param] = vals if getattr(self, "cosmological_simulation", 0) == 1: self.omega_lambda = self.parameters["comoving_OmL"] self.omega_matter = self.parameters["comoving_OmM"] self.hubble_constant = self.parameters["comoving_h"] a_file = open(os.path.join(self.output_dir, 'comoving_a')) line = a_file.readline().strip() a_file.close() self.current_redshift = 1 / float(line) - 1 else: self.current_redshift = self.omega_lambda = self.omega_matter = \ self.hubble_constant = self.cosmological_simulation = 0.0
def _parse_parameter_file(self): enzo = self._obtain_enzo() self.basename = "cycle%08i" % ( enzo.yt_parameter_file["NumberOfPythonCalls"]) self.parameters["CurrentTimeIdentifier"] = time.time() self.parameters.update(enzo.yt_parameter_file) self.conversion_factors.update(enzo.conversion_factors) for i in self.parameters: if isinstance(self.parameters[i], tuple): self.parameters[i] = np.array(self.parameters[i]) if i.endswith("Units") and not i.startswith("Temperature"): dataType = i[:-5] self.conversion_factors[dataType] = self.parameters[i] self.domain_left_edge = self.parameters["DomainLeftEdge"].copy() self.domain_right_edge = self.parameters["DomainRightEdge"].copy() for i in self.conversion_factors: if isinstance(self.conversion_factors[i], tuple): self.conversion_factors[i] = np.array( self.conversion_factors[i]) for p, v in self._parameter_override.items(): self.parameters[p] = v for p, v in self._conversion_override.items(): self.conversion_factors[p] = v self.refine_by = self.parameters["RefineBy"] self.periodicity = ensure_tuple( self.parameters["LeftFaceBoundaryCondition"] == 3) self.dimensionality = self.parameters["TopGridRank"] self.domain_dimensions = self.parameters["TopGridDimensions"] self.current_time = self.parameters["InitialTime"] if "CurrentTimeIdentifier" in self.parameters: self.unique_identifier = self.parameters["CurrentTimeIdentifier"] if self.parameters["ComovingCoordinates"]: self.cosmological_simulation = 1 self.current_redshift = self.parameters["CosmologyCurrentRedshift"] self.omega_lambda = self.parameters["CosmologyOmegaLambdaNow"] self.omega_matter = self.parameters["CosmologyOmegaMatterNow"] self.hubble_constant = self.parameters[ "CosmologyHubbleConstantNow"] else: self.current_redshift = (self.omega_lambda) = ( self.omega_matter ) = self.hubble_constant = self.cosmological_simulation = 0.0
def _parse_parameter_file(self): """ Parses the parameter file and establishes the various dictionaries. """ f = open(self.parameter_filename, "r") # get dimension from first block name b0, fn0 = f.readline().strip().split() level0, left0, right0 = get_block_info(b0, min_dim=0) root_blocks = get_root_blocks(b0) f.close() self.dimensionality = left0.size self.periodicity = \ ensure_tuple(np.ones(self.dimensionality, dtype=bool)) fh = h5py.File(os.path.join(self.directory, fn0), "r") self.domain_left_edge = fh.attrs["lower"] self.domain_right_edge = fh.attrs["upper"] # all blocks are the same size ablock = fh[list(fh.keys())[0]] self.current_time = ablock.attrs["time"][0] gsi = ablock.attrs["enzo_GridStartIndex"] gei = ablock.attrs["enzo_GridEndIndex"] self.ghost_zones = gsi[0] self.root_block_dimensions = root_blocks self.active_grid_dimensions = gei - gsi + 1 self.grid_dimensions = ablock.attrs["enzo_GridDimension"] self.domain_dimensions = root_blocks * self.active_grid_dimensions fh.close() self.periodicity += (False, ) * (3 - self.dimensionality) # WIP hard-coded for now self.refine_by = 2 self.cosmological_simulation = 0 self.gamma = 5. / 3. self.particle_types = () self.particle_types_raw = self.particle_types self.unique_identifier = \ str(int(os.stat(self.parameter_filename)[stat.ST_CTIME]))
def _parse_parameter_file(self): super(CastroDataset, self)._parse_parameter_file() jobinfo_filename = os.path.join(self.output_dir, "job_info") line = "" with open(jobinfo_filename, "r") as f: while not line.startswith(" Inputs File Parameters"): # boundary condition info starts with -x:, etc. bcs = ["-x:", "+x:", "-y:", "+y:", "-z:", "+z:"] if any(b in line for b in bcs): p, v = line.strip().split(":") self.parameters[p] = v.strip() if "git hash" in line: # line format: codename git hash: the-hash fields = line.split(":") self.parameters[fields[0]] = fields[1].strip() line = next(f) # runtime parameters that we overrode follow "Inputs File # Parameters" # skip the "====..." line line = next(f) for line in f: p, v = line.strip().split("=") self.parameters[p] = v.strip() # hydro method is set by the base class -- override it here self.parameters["HydroMethod"] = "Castro" # set the periodicity based on the runtime parameters periodicity = [True, True, True] if not self.parameters['-x'] == "interior": periodicity[0] = False if self.dimensionality >= 2: if not self.parameters['-y'] == "interior": periodicity[1] = False if self.dimensionality == 3: if not self.parameters['-z'] == "interior": periodicity[2] = False self.periodicity = ensure_tuple(periodicity)
def _parse_parameter_file(self): """ Parses the parameter file and establishes the various dictionaries. """ f = open(self.parameter_filename, "r") # get dimension from first block name b0, fn0 = f.readline().strip().split() level0, left0, right0 = get_block_info(b0, min_dim=0) root_blocks = get_root_blocks(b0) f.close() self.dimensionality = left0.size self.periodicity = \ ensure_tuple(np.ones(self.dimensionality, dtype=bool)) lcfn = self.parameter_filename[:-len(self._suffix)] + ".libconfig" if os.path.exists(lcfn): with io.open(lcfn, "r") as lf: self.parameters = libconf.load(lf) cosmo = nested_dict_get( self.parameters, ("Physics", "cosmology")) if cosmo is not None: self.cosmological_simulation = 1 co_pars = ["hubble_constant_now", "omega_matter_now", "omega_lambda_now", "comoving_box_size", "initial_redshift"] co_dict = \ dict((attr, nested_dict_get(self.parameters, ("Physics", "cosmology", attr))) for attr in co_pars) for attr in ["hubble_constant", "omega_matter", "omega_lambda"]: setattr(self, attr, co_dict["%s_now" % attr]) # Current redshift is not stored, so it's not possible # to set all cosmological units yet. # Get the time units and use that to figure out redshift. k = cosmology_get_units( self.hubble_constant, self.omega_matter, co_dict["comoving_box_size"], co_dict["initial_redshift"], 0) setdefaultattr( self, 'time_unit', self.quan(k['utim'], 's')) co = Cosmology(hubble_constant=self.hubble_constant, omega_matter=self.omega_matter, omega_lambda=self.omega_lambda) else: self.cosmological_simulation = 0 else: self.cosmological_simulation = 0 fh = h5py.File(os.path.join(self.directory, fn0), "r") self.domain_left_edge = fh.attrs["lower"] self.domain_right_edge = fh.attrs["upper"] # all blocks are the same size ablock = fh[list(fh.keys())[0]] self.current_time = ablock.attrs["time"][0] gsi = ablock.attrs["enzo_GridStartIndex"] gei = ablock.attrs["enzo_GridEndIndex"] self.ghost_zones = gsi[0] self.root_block_dimensions = root_blocks self.active_grid_dimensions = gei - gsi + 1 self.grid_dimensions = ablock.attrs["enzo_GridDimension"] self.domain_dimensions = root_blocks * self.active_grid_dimensions fh.close() if self.cosmological_simulation: self.current_redshift = \ co.z_from_t(self.current_time * self.time_unit) self.periodicity += (False, ) * (3 - self.dimensionality) self.gamma = nested_dict_get(self.parameters, ("Field", "gamma")) self.unique_identifier = \ str(int(os.stat(self.parameter_filename)[stat.ST_CTIME]))
def _parse_parameter_file(self): self._handle = open(self.parameter_filename, "rb") # Read the start of a grid to get simulation parameters. grid = {} grid['read_field'] = None line = self._handle.readline() while grid['read_field'] is None: parse_line(line, grid) splitup = line.strip().split() if chk23('X_COORDINATES') in splitup: grid['left_edge'] = np.zeros(3) grid['dds'] = np.zeros(3) v = np.fromfile(self._handle, dtype='>f8', count=2) grid['left_edge'][0] = v[0] - 0.5 * (v[1] - v[0]) grid['dds'][0] = v[1] - v[0] if chk23('Y_COORDINATES') in splitup: v = np.fromfile(self._handle, dtype='>f8', count=2) grid['left_edge'][1] = v[0] - 0.5 * (v[1] - v[0]) grid['dds'][1] = v[1] - v[0] if chk23('Z_COORDINATES') in splitup: v = np.fromfile(self._handle, dtype='>f8', count=2) grid['left_edge'][2] = v[0] - 0.5 * (v[1] - v[0]) grid['dds'][2] = v[1] - v[0] if check_break(line): break line = self._handle.readline() self.domain_left_edge = grid['left_edge'] mylog.info( "Temporarily setting domain_right_edge = -domain_left_edge." + " This will be corrected automatically if it is not the case.") self.domain_right_edge = -self.domain_left_edge self.domain_width = self.domain_right_edge - self.domain_left_edge self.domain_dimensions = np.round(self.domain_width / grid['dds']).astype('int32') refine_by = None if refine_by is None: refine_by = 2 self.refine_by = refine_by dimensionality = 3 if grid['dimensions'][2] == 1: dimensionality = 2 if grid['dimensions'][1] == 1: dimensionality = 1 if dimensionality <= 2: self.domain_dimensions[2] = np.int32(1) if dimensionality == 1: self.domain_dimensions[1] = np.int32(1) if dimensionality != 3 and self.nprocs > 1: raise RuntimeError( "Virtual grids are only supported for 3D outputs!") self.dimensionality = dimensionality self.current_time = grid["time"] self.unique_identifier = self.parameter_filename.__hash__() self.cosmological_simulation = False self.num_ghost_zones = 0 self.field_ordering = 'fortran' self.boundary_conditions = [1] * 6 if 'periodicity' in self.specified_parameters: self.periodicity = ensure_tuple( self.specified_parameters['periodicity']) else: self.periodicity = ( True, True, True, ) if 'gamma' in self.specified_parameters: self.gamma = float(self.specified_parameters['gamma']) else: self.gamma = 5. / 3. dataset_dir = os.path.dirname(self.parameter_filename) dname = os.path.split(self.parameter_filename)[-1] if dataset_dir.endswith("id0"): dname = "id0/" + dname dataset_dir = dataset_dir[:-3] gridlistread = glob.glob( os.path.join(dataset_dir, 'id*/%s-id*%s' % (dname[4:-9], dname[-9:]))) if 'id0' in dname: gridlistread += glob.glob( os.path.join(dataset_dir, 'id*/lev*/%s*-lev*%s' % (dname[4:-9], dname[-9:]))) else: gridlistread += glob.glob( os.path.join(dataset_dir, 'lev*/%s*-lev*%s' % (dname[:-9], dname[-9:]))) ndots = dname.count(".") gridlistread = [ fn for fn in gridlistread if os.path.basename(fn).count(".") == ndots ] self.nvtk = len(gridlistread) + 1 self.current_redshift = self.omega_lambda = self.omega_matter = \ self.hubble_constant = self.cosmological_simulation = 0.0 self.parameters[ 'Time'] = self.current_time # Hardcode time conversion for now. self.parameters[ "HydroMethod"] = 0 # Hardcode for now until field staggering is supported. if "gamma" in self.specified_parameters: self.parameters["Gamma"] = self.specified_parameters["gamma"] else: self.parameters["Gamma"] = 5. / 3. self.geometry = self.specified_parameters.get("geometry", "cartesian") self._handle.close()
def _parse_enzo2_parameter_file(self, f): for line in (l.strip() for l in f): if len(line) < 2: continue param, vals = (i.strip() for i in line.split("=", 1)) # First we try to decipher what type of value it is. vals = vals.split() # Special case approaching. if "(do" in vals: vals = vals[:1] if len(vals) == 0: pcast = str # Assume NULL output else: v = vals[0] # Figure out if it's castable to floating point: try: float(v) except ValueError: pcast = str else: if any("." in v or "e+" in v or "e-" in v for v in vals): pcast = float elif v == "inf": pcast = str else: pcast = int # Now we figure out what to do with it. if len(vals) == 0: vals = "" elif len(vals) == 1: vals = pcast(vals[0]) else: vals = np.array([pcast(i) for i in vals if i != "-99999"]) if param.startswith("Append"): if param not in self.parameters: self.parameters[param] = [] self.parameters[param].append(vals) else: self.parameters[param] = vals self.refine_by = self.parameters["RefineBy"] self.periodicity = ensure_tuple( self.parameters["LeftFaceBoundaryCondition"] == 3) self.dimensionality = self.parameters["TopGridRank"] if "MetaDataDatasetUUID" in self.parameters: self.unique_identifier = self.parameters["MetaDataDatasetUUID"] elif "CurrentTimeIdentifier" in self.parameters: self.unique_identifier = self.parameters["CurrentTimeIdentifier"] else: self.unique_identifier = \ str(int(os.stat(self.parameter_filename)[stat.ST_CTIME])) if self.dimensionality > 1: self.domain_dimensions = self.parameters["TopGridDimensions"] if len(self.domain_dimensions) < 3: tmp = self.domain_dimensions.tolist() tmp.append(1) self.domain_dimensions = np.array(tmp) self.periodicity += (False, ) self.domain_left_edge = np.array(self.parameters["DomainLeftEdge"], "float64").copy() self.domain_right_edge = np.array( self.parameters["DomainRightEdge"], "float64").copy() else: self.domain_left_edge = np.array(self.parameters["DomainLeftEdge"], "float64") self.domain_right_edge = np.array( self.parameters["DomainRightEdge"], "float64") self.domain_dimensions = np.array( [self.parameters["TopGridDimensions"], 1, 1]) self.periodicity += (False, False) self.gamma = self.parameters["Gamma"] if self.parameters["ComovingCoordinates"]: self.cosmological_simulation = 1 self.current_redshift = self.parameters["CosmologyCurrentRedshift"] self.omega_lambda = self.parameters["CosmologyOmegaLambdaNow"] self.omega_matter = self.parameters["CosmologyOmegaMatterNow"] self.hubble_constant = self.parameters[ "CosmologyHubbleConstantNow"] else: self.current_redshift = self.omega_lambda = self.omega_matter = \ self.hubble_constant = self.cosmological_simulation = 0.0 self.particle_types = [] self.current_time = self.parameters["InitialTime"] if self.parameters["NumberOfParticles"] > 0 and \ "AppendActiveParticleType" in self.parameters.keys(): # If this is the case, then we know we should have a DarkMatter # particle type, and we don't need the "io" type. self.parameters["AppendActiveParticleType"].append("DarkMatter") else: # We do not have an "io" type for Enzo particles if the # ActiveParticle machinery is on, as we simply will ignore any of # the non-DarkMatter particles in that case. However, for older # datasets, we call this particle type "io". self.particle_types = ["io"] for ptype in self.parameters.get("AppendActiveParticleType", []): self.particle_types.append(ptype) self.particle_types = tuple(self.particle_types) self.particle_types_raw = self.particle_types if self.dimensionality == 1: self._setup_1d() elif self.dimensionality == 2: self._setup_2d()