def __init__(self, ds, min_level=None, max_level=None, data_source=None): ParallelAnalysisInterface.__init__(self) self.ds = ds self.current_vcds = [] self.current_saved_grids = [] self.bricks = [] self.brick_dimensions = [] self.sdx = ds.index.get_smallest_dx() self._initialized = False try: self._id_offset = ds.index.grids[0]._id_offset except AttributeError: self._id_offset = 0 if data_source is None: data_source = self.ds.all_data() self.data_source = data_source mylog.debug('Building AMRKDTree') self.tree = Tree(ds, self.comm.rank, self.comm.size, min_level=min_level, max_level=max_level, data_source=data_source)
def __init__(self, ts, num_readers = 1, num_writers = None, outbase="rockstar_halos", particle_type="all", force_res=None, total_particles=None, dm_only=False, particle_mass=None, min_halo_size=25): if is_root(): mylog.info("The citation for the Rockstar halo finder can be found at") mylog.info("http://adsabs.harvard.edu/abs/2013ApJ...762..109B") ParallelAnalysisInterface.__init__(self) # Decide how we're working. if ytcfg.getboolean("yt", "inline") == True: self.runner = InlineRunner() else: self.runner = StandardRunner(num_readers, num_writers) self.num_readers = self.runner.num_readers self.num_writers = self.runner.num_writers mylog.info("Rockstar is using %d readers and %d writers", self.num_readers, self.num_writers) # Note that Rockstar does not support subvolumes. # We assume that all of the snapshots in the time series # use the same domain info as the first snapshots. if not isinstance(ts, DatasetSeries): ts = DatasetSeries([ts]) self.ts = ts self.particle_type = particle_type self.outbase = outbase self.min_halo_size = min_halo_size if force_res is None: tds = ts[-1] # Cache a reference self.force_res = tds.index.get_smallest_dx().in_units("Mpc/h") # We have to delete now to wipe the index del tds else: self.force_res = force_res self.total_particles = total_particles self.dm_only = dm_only self.particle_mass = particle_mass # Setup pool and workgroups. self.pool, self.workgroup = self.runner.setup_pool() p = self._setup_parameters(ts) params = self.comm.mpi_bcast(p, root = self.pool['readers'].ranks[0]) self.__dict__.update(params) self.handler = rockstar_interface.RockstarInterface(self.ts)
def __init__(self, ds, dataset_type): ParallelAnalysisInterface.__init__(self) self.dataset = weakref.proxy(ds) self.ds = self.dataset self._initialize_state_variables() mylog.debug("Initializing data storage.") self._initialize_data_storage() mylog.debug("Setting up domain geometry.") self._setup_geometry() mylog.debug("Initializing data grid data IO") self._setup_data_io() # Note that this falls under the "geometry" object since it's # potentially quite expensive, and should be done with the indexing. mylog.debug("Detecting fields.") self._detect_output_fields()
def __init__(self, halos_ds=None, data_ds=None, data_source=None, finder_method=None, finder_kwargs=None, output_dir="halo_catalogs/catalog"): ParallelAnalysisInterface.__init__(self) self.halos_ds = halos_ds self.data_ds = data_ds self.output_dir = ensure_dir(output_dir) if os.path.basename(self.output_dir) != ".": self.output_prefix = os.path.basename(self.output_dir) else: self.output_prefix = "catalog" if halos_ds is None: if data_ds is None: raise RuntimeError("Must specify a halos_ds, data_ds, or both.") if finder_method is None: raise RuntimeError("Must specify a halos_ds or a finder_method.") if data_source is None: if halos_ds is not None: halos_ds.index data_source = halos_ds.all_data() else: data_source = data_ds.all_data() self.data_source = data_source if finder_kwargs is None: finder_kwargs = {} if finder_method is not None: finder_method = finding_method_registry.find(finder_method, **finder_kwargs) self.finder_method = finder_method # all of the analysis actions to be performed: callbacks, filters, and quantities self.actions = [] # fields to be written to the halo catalog self.quantities = [] if not self.halos_ds is None: self.add_default_quantities()
def __init__(self, ds, positions, xfield='velocity_x', yfield='velocity_x', zfield='velocity_x', volume=None, dx=None, length=None, direction=1, get_magnitude=False): ParallelAnalysisInterface.__init__(self) self.ds = ds self.start_positions = sanitize_length(positions, ds) self.N = self.start_positions.shape[0] # I need a data object to resolve the field names to field tuples # via _determine_fields() ad = self.ds.all_data() self.xfield = ad._determine_fields(xfield)[0] self.yfield = ad._determine_fields(yfield)[0] self.zfield = ad._determine_fields(zfield)[0] self.get_magnitude=get_magnitude self.direction = np.sign(direction) if volume is None: volume = AMRKDTree(self.ds) volume.set_fields([self.xfield,self.yfield,self.zfield], [False,False,False], False) volume.join_parallel_trees() self.volume = volume if dx is None: dx = self.ds.index.get_smallest_dx() self.dx = sanitize_length(dx, ds) if length is None: length = np.max(self.ds.domain_right_edge-self.ds.domain_left_edge) self.length = sanitize_length(length, ds) self.steps = int(length/dx)+1 # Fix up the dx. self.dx = 1.0*self.length/self.steps self.streamlines = np.zeros((self.N,self.steps,3), dtype='float64') self.magnitudes = None if self.get_magnitude: self.magnitudes = np.zeros((self.N,self.steps), dtype='float64')
def __init__(self, ds, fields, left_edge=None, right_edge=None, total_values=1000000, comm_size=10000, length_type="lin", length_number=10, length_range=None, vol_ratio = 1, salt=0, theta=None, phi=None): ParallelAnalysisInterface.__init__(self) try: fKD except NameError: raise ImportError("You need to install the Forthon kD-Tree") self._fsets = [] self.fields = fields self.constant_theta = theta self.constant_phi = phi # MPI stuff. self.size = self.comm.size self.mine = self.comm.rank self.vol_ratio = vol_ratio if self.vol_ratio == -1: self.vol_ratio = self.size self.total_values = int(total_values / self.size) # For communication. self.recv_hooks = [] self.send_hooks = [] self.done_hooks = [] self.comm_size = min(int(comm_size), self.total_values) self.ds = ds self.nlevels = ds.index.max_level self.period = self.ds.domain_right_edge - self.ds.domain_left_edge self.min_edge = min(self.period) self.index = ds.index self.center = (ds.domain_right_edge + ds.domain_left_edge)/2.0 # Figure out the range of ruler lengths. if length_range == None: length_range = [math.sqrt(3) * self.ds.index.get_smallest_dx(), self.min_edge/2.] else: if len(length_range) != 2: raise ValueError("length_range must have two values.") if length_range[1] <= length_range[0]: raise ValueError("length_range[1] must be larger than length_range[0]") if length_range[1] > self.min_edge/2.: length_range[1] = self.min_edge/2. mylog.info("Automatically adjusting length_range[1] to half the shortest box edge.") if length_range[0] == -1 or length_range[0] == -1.: mylog.info("Automatically adjusting length_range[0] to %1.5e." % \ (math.sqrt(3) * self.ds.index.get_smallest_dx())) length_range[0] = math.sqrt(3) * self.ds.index.get_smallest_dx() # Make the list of ruler lengths. if length_type == "lin": self.lengths = np.linspace(length_range[0], length_range[1], length_number) elif length_type == "log": self.lengths = np.logspace(math.log10(length_range[0]), math.log10(length_range[1]), length_number) else: # Something went wrong. raise SyntaxError("length_type is either \"lin\" or \"log\".") # Subdivide the volume. if not left_edge or not right_edge: self.left_edge = self.ds.domain_left_edge self.right_edge = self.ds.domain_right_edge # This ds business below has to do with changes made for halo # finding on subvolumes and serves no purpose here except # compatibility. This is not the best policy, if I'm honest. ds = ds.region([0.]*3, self.left_edge, self.right_edge) padded, self.LE, self.RE, self.ds = \ self.partition_index_3d(ds = ds, padding=0., rank_ratio = self.vol_ratio) else: self.left_edge = left_edge self.right_edge = right_edge # We do this twice, first with no 'buffer' to get the unbuffered # self.LE/RE, and then second to get a buffered self.ds. padded, self.LE, self.RE, temp = \ self.partition_region_3d(left_edge, right_edge, rank_ratio=self.vol_ratio) padded, temp, temp, self.ds = \ self.partition_region_3d(left_edge - self.lengths[-1], \ right_edge + self.lengths[-1], rank_ratio=self.vol_ratio) mylog.info("LE %s RE %s %s" % (str(self.LE), str(self.RE), str(self.ds))) self.width = self.ds.right_edge - self.ds.left_edge self.mt = np.random.mtrand.RandomState(seed = 1234 * self.mine + salt)
def __init__(self, ts, num_readers=1, num_writers=None, outbase="rockstar_halos", particle_type="all", star_types=None, force_res=None, initial_metric_scaling=1.0, non_dm_metric_scaling=10.0, suppress_galaxies=1, total_particles=None, dm_only=False, particle_mass=None, min_halo_size=25): if is_root(): mylog.info( "The citation for the Rockstar halo finder can be found at") mylog.info("http://adsabs.harvard.edu/abs/2013ApJ...762..109B") ParallelAnalysisInterface.__init__(self) # Decide how we're working. if ytcfg.getboolean("yt", "inline"): self.runner = InlineRunner() else: self.runner = StandardRunner(num_readers, num_writers) self.num_readers = self.runner.num_readers self.num_writers = self.runner.num_writers mylog.info("Rockstar is using %d readers and %d writers", self.num_readers, self.num_writers) # Note that Rockstar does not support subvolumes. # We assume that all of the snapshots in the time series # use the same domain info as the first snapshots. if not isinstance(ts, DatasetSeries): ts = DatasetSeries([ts]) self.ts = ts self.particle_type = particle_type if star_types is None: star_types = [] self.star_types = star_types self.outbase = outbase self.min_halo_size = min_halo_size if force_res is None: tds = ts[-1] # Cache a reference self.force_res = tds.index.get_smallest_dx().to("Mpccm/h") # We have to delete now to wipe the index del tds else: self.force_res = force_res self.initial_metric_scaling = initial_metric_scaling self.non_dm_metric_scaling = non_dm_metric_scaling self.suppress_galaxies = suppress_galaxies self.total_particles = total_particles self.dm_only = dm_only self.particle_mass = particle_mass # Setup pool and workgroups. self.pool, self.workgroup = self.runner.setup_pool() p = self._setup_parameters(ts) params = self.comm.mpi_bcast(p, root=self.pool['readers'].ranks[0]) self.__dict__.update(params) self.handler = rockstar_interface.RockstarInterface(self.ts)
def __init__(self, ds, fields, left_edge=None, right_edge=None, total_values=1000000, comm_size=10000, length_type="lin", length_number=10, length_range=None, vol_ratio = 1, salt=0, theta=None, phi=None): ParallelAnalysisInterface.__init__(self) try: fKD except NameError: raise ImportError("You need to install the Forthon kD-Tree") self._fsets = [] self.fields = fields self.constant_theta = theta self.constant_phi = phi # MPI stuff. self.size = self.comm.size self.mine = self.comm.rank self.vol_ratio = vol_ratio if self.vol_ratio == -1: self.vol_ratio = self.size self.total_values = int(total_values / self.size) # For communication. self.recv_hooks = [] self.send_hooks = [] self.done_hooks = [] self.comm_size = min(int(comm_size), self.total_values) self.ds = ds self.nlevels = ds.index.max_level self.period = self.ds.domain_right_edge - self.ds.domain_left_edge self.min_edge = min(self.period) self.index = ds.index self.center = (ds.domain_right_edge + ds.domain_left_edge)/2.0 # Figure out the range of ruler lengths. if length_range is None: length_range = [math.sqrt(3) * self.ds.index.get_smallest_dx(), self.min_edge/2.] else: if len(length_range) != 2: raise ValueError("length_range must have two values.") if length_range[1] <= length_range[0]: raise ValueError("length_range[1] must be larger than length_range[0]") if length_range[1] > self.min_edge/2.: length_range[1] = self.min_edge/2. mylog.info("Automatically adjusting length_range[1] to half the shortest box edge.") if length_range[0] == -1 or length_range[0] == -1.: mylog.info("Automatically adjusting length_range[0] to %1.5e." % \ (math.sqrt(3) * self.ds.index.get_smallest_dx())) length_range[0] = math.sqrt(3) * self.ds.index.get_smallest_dx() # Make the list of ruler lengths. if length_type == "lin": self.lengths = np.linspace(length_range[0], length_range[1], length_number) elif length_type == "log": self.lengths = np.logspace(math.log10(length_range[0]), math.log10(length_range[1]), length_number) else: # Something went wrong. raise SyntaxError("length_type is either \"lin\" or \"log\".") # Subdivide the volume. if not left_edge or not right_edge: self.left_edge = self.ds.domain_left_edge self.right_edge = self.ds.domain_right_edge # This ds business below has to do with changes made for halo # finding on subvolumes and serves no purpose here except # compatibility. This is not the best policy, if I'm honest. ds = ds.region([0.]*3, self.left_edge, self.right_edge) padded, self.LE, self.RE, self.ds = \ self.partition_index_3d(ds = ds, padding=0., rank_ratio = self.vol_ratio) else: self.left_edge = left_edge self.right_edge = right_edge # We do this twice, first with no 'buffer' to get the unbuffered # self.LE/RE, and then second to get a buffered self.ds. padded, self.LE, self.RE, temp = \ self.partition_region_3d(left_edge, right_edge, rank_ratio=self.vol_ratio) padded, temp, temp, self.ds = \ self.partition_region_3d(left_edge - self.lengths[-1], \ right_edge + self.lengths[-1], rank_ratio=self.vol_ratio) mylog.info("LE %s RE %s %s" % (str(self.LE), str(self.RE), str(self.ds))) self.width = self.ds.right_edge - self.ds.left_edge self.mt = np.random.mtrand.RandomState(seed = 1234 * self.mine + salt)