chore(release): 1.3.0

CHANGELOG.md

@@ -2,6 +2,64 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.3.0](https://gitea.deepak.science:2222/physics/deepdog/compare/1.2.1...1.3.0) (2024-05-20)
+
+
+### Features
+
+* add multi run to wrap multi model and repeat runs ([92b49fc](https://gitea.deepak.science:2222/physics/deepdog/commit/92b49fce7c86f14484deb1c4aaaa810a6f69c08a))
+* adds a filter that works with cost functions ([8845b28](https://gitea.deepak.science:2222/physics/deepdog/commit/8845b2875f2c91c91dd3988fabda26400c59b2d7))
+* improve initial cost calculation to allow multiprocessing, adds ability to specify a number of levels to do with direct mc instead of subset simulation ([09fad2e](https://gitea.deepak.science:2222/physics/deepdog/commit/09fad2e1024d9237a6a4f7931f51cb4c84b83bf8))
+
+
+### Bug Fixes
+
+* Adds ugly hack for stdevs for this uniform range to multiply by root3, proper fix would be in pdme ([b1c01b2](https://gitea.deepak.science:2222/physics/deepdog/commit/b1c01b25c8f2c3947be23f5b2c656c37437dab17))
+* fix seeding to avoid recreating seed combinations across multi runs ([24ac65b](https://gitea.deepak.science:2222/physics/deepdog/commit/24ac65bf9c74c454fec826ca9de640fe095f5a17))
+
+### [1.2.1](https://gitea.deepak.science:2222/physics/deepdog/compare/1.2.0...1.2.1) (2024-05-12)
+
+## [1.2.0](https://gitea.deepak.science:2222/physics/deepdog/compare/1.1.0...1.2.0) (2024-05-09)
+
+
+### Features
+
+* adds additional matching regexes ([dc1d2d4](https://gitea.deepak.science:2222/physics/deepdog/commit/dc1d2d45a3e631c5efccce80f8a24fa87c6089e0))
+* adds magnitude enabled parsing option ([f0e2fa3](https://gitea.deepak.science:2222/physics/deepdog/commit/f0e2fa3da9f5a5136908d691137a904fda4e3a9a))
+
+## [1.1.0](https://gitea.deepak.science:2222/physics/deepdog/compare/1.0.1...1.1.0) (2024-05-03)
+
+
+### Features
+
+* allows disabling timestamps in directmc bayesrun files ([fb018ab](https://gitea.deepak.science:2222/physics/deepdog/commit/fb018abeae2adf4438a030140a6c905f11bb6bc1))
+* removes legacy bayes run, technically breaking but just don't use them ([5361dad](https://gitea.deepak.science:2222/physics/deepdog/commit/5361dada8be4950b5157862f6a92254b543889c3))
+
+### [1.0.1](https://gitea.deepak.science:2222/physics/deepdog/compare/1.0.0...1.0.1) (2024-05-02)
+
+
+### Bug Fixes
+
+* fixes issue of zero division error with no successes for anything ([e25db1e](https://gitea.deepak.science:2222/physics/deepdog/commit/e25db1e0f677e8d9a657fa1631305cc8f05ff9ff))
+
+## [1.0.0](https://gitea.deepak.science:2222/physics/deepdog/compare/0.8.1...1.0.0) (2024-05-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* allows new seed spec instead of cli arg, removes old cli arg
+
+### Features
+
+* adds additional file slug parsing ([2105754](https://gitea.deepak.science:2222/physics/deepdog/commit/2105754911c89bde9dcbea9866462225604a3524))
+* Adds more powerful direct mc runs to sub for old real spectrum run ([f2b1a1d](https://gitea.deepak.science:2222/physics/deepdog/commit/f2b1a1dd3b3436e37d84f7843b9b2a202be4b51c))
+* allows new seed spec instead of cli arg, removes old cli arg ([7108dd0](https://gitea.deepak.science:2222/physics/deepdog/commit/7108dd0111c7dfd6ec204df1d0058530cd3dcab9))
+
+
+### Bug Fixes
+
+* no longer throws error for overlapping keys, the warning should hopefully be enough? ([f3ba4cb](https://gitea.deepak.science:2222/physics/deepdog/commit/f3ba4cbfd36a9f08cdc4d8774a7f745f8c98bac3))
+
 ### [0.8.1](https://gitea.deepak.science:2222/physics/deepdog/compare/0.8.0...0.8.1) (2024-04-28)
 
 ### [0.8.1](https://gitea.deepak.science:2222/physics/deepdog/compare/0.8.0...0.8.1) (2024-04-28)

deepdog/__init__.py

@@ -1,10 +1,7 @@
 import logging
 from deepdog.meta import __version__
-from deepdog.bayes_run import BayesRun
-from deepdog.bayes_run_simulpairs import BayesRunSimulPairs
 from deepdog.real_spectrum_run import RealSpectrumRun
 from deepdog.temp_aware_real_spectrum_run import TempAwareRealSpectrumRun
-from deepdog.bayes_run_with_ss import BayesRunWithSubspaceSimulation
 
 
 def get_version():
@@ -13,11 +10,8 @@ def get_version():
 
 __all__ = [
 	"get_version",
-	"BayesRun",
-	"BayesRunSimulPairs",
 	"RealSpectrumRun",
 	"TempAwareRealSpectrumRun",
-	"BayesRunWithSubspaceSimulation",
 ]
 
 

deepdog/bayes_run.py

@@ -1,281 +0,0 @@
-import pdme.inputs
-import pdme.model
-import pdme.measurement.input_types
-import pdme.measurement.oscillating_dipole
-import pdme.util.fast_v_calc
-import pdme.util.fast_nonlocal_spectrum
-from typing import Sequence, Tuple, List
-import datetime
-import csv
-import multiprocessing
-import logging
-import numpy
-
-
-# TODO: remove hardcode
-CHUNKSIZE = 50
-
-# TODO: It's garbage to have this here duplicated from pdme.
-DotInput = Tuple[numpy.typing.ArrayLike, float]
-
-
-_logger = logging.getLogger(__name__)
-
-
-def get_a_result(input) -> int:
-	model, dot_inputs, lows, highs, monte_carlo_count, max_frequency, seed = input
-
-	rng = numpy.random.default_rng(seed)
-	sample_dipoles = model.get_monte_carlo_dipole_inputs(
-		monte_carlo_count, max_frequency, rng_to_use=rng
-	)
-	vals = pdme.util.fast_v_calc.fast_vs_for_dipoleses(dot_inputs, sample_dipoles)
-	return numpy.count_nonzero(pdme.util.fast_v_calc.between(vals, lows, highs))
-
-
-def get_a_result_using_pairs(input) -> int:
-	(
-		model,
-		dot_inputs,
-		pair_inputs,
-		local_lows,
-		local_highs,
-		nonlocal_lows,
-		nonlocal_highs,
-		monte_carlo_count,
-		max_frequency,
-	) = input
-	sample_dipoles = model.get_n_single_dipoles(monte_carlo_count, max_frequency)
-	local_vals = pdme.util.fast_v_calc.fast_vs_for_dipoles(dot_inputs, sample_dipoles)
-	local_matches = pdme.util.fast_v_calc.between(local_vals, local_lows, local_highs)
-	nonlocal_vals = pdme.util.fast_nonlocal_spectrum.fast_s_nonlocal(
-		pair_inputs, sample_dipoles
-	)
-	nonlocal_matches = pdme.util.fast_v_calc.between(
-		nonlocal_vals, nonlocal_lows, nonlocal_highs
-	)
-	combined_matches = numpy.logical_and(local_matches, nonlocal_matches)
-	return numpy.count_nonzero(combined_matches)
-
-
-class BayesRun:
-	"""
-	A single Bayes run for a given set of dots.
-
-	Parameters
-	----------
-	dot_inputs : Sequence[DotInput]
-	The dot inputs for this bayes run.
-
-	models_with_names : Sequence[Tuple(str, pdme.model.DipoleModel)]
-	The models to evaluate.
-
-	actual_model : pdme.model.DipoleModel
-	The model which is actually correct.
-
-	filename_slug : str
-	The filename slug to include.
-
-	run_count: int
-	The number of runs to do.
-	"""
-
-	def __init__(
-		self,
-		dot_positions: Sequence[numpy.typing.ArrayLike],
-		frequency_range: Sequence[float],
-		models_with_names: Sequence[Tuple[str, pdme.model.DipoleModel]],
-		actual_model: pdme.model.DipoleModel,
-		filename_slug: str,
-		run_count: int = 100,
-		low_error: float = 0.9,
-		high_error: float = 1.1,
-		monte_carlo_count: int = 10000,
-		monte_carlo_cycles: int = 10,
-		target_success: int = 100,
-		max_monte_carlo_cycles_steps: int = 10,
-		max_frequency: float = 20,
-		end_threshold: float = None,
-		chunksize: int = CHUNKSIZE,
-	) -> None:
-		self.dot_inputs = pdme.inputs.inputs_with_frequency_range(
-			dot_positions, frequency_range
-		)
-		self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
-			self.dot_inputs
-		)
-
-		self.models = [model for (_, model) in models_with_names]
-		self.model_names = [name for (name, _) in models_with_names]
-		self.actual_model = actual_model
-
-		self.n: int
-		try:
-			self.n = self.actual_model.n  # type: ignore
-		except AttributeError:
-			self.n = 1
-
-		self.model_count = len(self.models)
-		self.monte_carlo_count = monte_carlo_count
-		self.monte_carlo_cycles = monte_carlo_cycles
-		self.target_success = target_success
-		self.max_monte_carlo_cycles_steps = max_monte_carlo_cycles_steps
-		self.run_count = run_count
-		self.low_error = low_error
-		self.high_error = high_error
-
-		self.csv_fields = []
-		for i in range(self.n):
-			self.csv_fields.extend(
-				[
-					f"dipole_moment_{i+1}",
-					f"dipole_location_{i+1}",
-					f"dipole_frequency_{i+1}",
-				]
-			)
-		self.compensate_zeros = True
-		self.chunksize = chunksize
-		for name in self.model_names:
-			self.csv_fields.extend([f"{name}_success", f"{name}_count", f"{name}_prob"])
-
-		self.probabilities = [1 / self.model_count] * self.model_count
-
-		timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-		self.filename = f"{timestamp}-{filename_slug}.bayesrun.csv"
-		self.max_frequency = max_frequency
-
-		if end_threshold is not None:
-			if 0 < end_threshold < 1:
-				self.end_threshold: float = end_threshold
-				self.use_end_threshold = True
-				_logger.info(f"Will abort early, at {self.end_threshold}.")
-			else:
-				raise ValueError(
-					f"end_threshold should be between 0 and 1, but is actually {end_threshold}"
-				)
-
-	def go(self) -> None:
-		with open(self.filename, "a", newline="") as outfile:
-			writer = csv.DictWriter(outfile, fieldnames=self.csv_fields, dialect="unix")
-			writer.writeheader()
-
-		for run in range(1, self.run_count + 1):
-
-			# Generate the actual dipoles
-			actual_dipoles = self.actual_model.get_dipoles(self.max_frequency)
-
-			dots = actual_dipoles.get_percent_range_dot_measurements(
-				self.dot_inputs, self.low_error, self.high_error
-			)
-			(
-				lows,
-				highs,
-			) = pdme.measurement.input_types.dot_range_measurements_low_high_arrays(
-				dots
-			)
-
-			_logger.info(f"Going to work on dipole at {actual_dipoles.dipoles}")
-
-			# define a new seed sequence for each run
-			seed_sequence = numpy.random.SeedSequence(run)
-
-			results = []
-			_logger.debug("Going to iterate over models now")
-			for model_count, model in enumerate(self.models):
-				_logger.debug(f"Doing model #{model_count}")
-				core_count = multiprocessing.cpu_count() - 1 or 1
-				with multiprocessing.Pool(core_count) as pool:
-					cycle_count = 0
-					cycle_success = 0
-					cycles = 0
-					while (cycles < self.max_monte_carlo_cycles_steps) and (
-						cycle_success <= self.target_success
-					):
-						_logger.debug(f"Starting cycle {cycles}")
-						cycles += 1
-						current_success = 0
-						cycle_count += self.monte_carlo_count * self.monte_carlo_cycles
-
-						# generate a seed from the sequence for each core.
-						# note this needs to be inside the loop for monte carlo cycle steps!
-						# that way we get more stuff.
-						seeds = seed_sequence.spawn(self.monte_carlo_cycles)
-
-						current_success = sum(
-							pool.imap_unordered(
-								get_a_result,
-								[
-									(
-										model,
-										self.dot_inputs_array,
-										lows,
-										highs,
-										self.monte_carlo_count,
-										self.max_frequency,
-										seed,
-									)
-									for seed in seeds
-								],
-								self.chunksize,
-							)
-						)
-
-						cycle_success += current_success
-						_logger.debug(f"current running successes: {cycle_success}")
-					results.append((cycle_count, cycle_success))
-
-			_logger.debug("Done, constructing output now")
-			row = {
-				"dipole_moment_1": actual_dipoles.dipoles[0].p,
-				"dipole_location_1": actual_dipoles.dipoles[0].s,
-				"dipole_frequency_1": actual_dipoles.dipoles[0].w,
-			}
-			for i in range(1, self.n):
-				try:
-					current_dipoles = actual_dipoles.dipoles[i]
-					row[f"dipole_moment_{i+1}"] = current_dipoles.p
-					row[f"dipole_location_{i+1}"] = current_dipoles.s
-					row[f"dipole_frequency_{i+1}"] = current_dipoles.w
-				except IndexError:
-					_logger.info(f"Not writing anymore, saw end after {i}")
-					break
-
-			successes: List[float] = []
-			counts: List[int] = []
-			for model_index, (name, (count, result)) in enumerate(
-				zip(self.model_names, results)
-			):
-
-				row[f"{name}_success"] = result
-				row[f"{name}_count"] = count
-				successes.append(max(result, 0.5))
-				counts.append(count)
-
-			success_weight = sum(
-				[
-					(succ / count) * prob
-					for succ, count, prob in zip(successes, counts, self.probabilities)
-				]
-			)
-			new_probabilities = [
-				(succ / count) * old_prob / success_weight
-				for succ, count, old_prob in zip(successes, counts, self.probabilities)
-			]
-			self.probabilities = new_probabilities
-			for name, probability in zip(self.model_names, self.probabilities):
-				row[f"{name}_prob"] = probability
-			_logger.info(row)
-
-			with open(self.filename, "a", newline="") as outfile:
-				writer = csv.DictWriter(
-					outfile, fieldnames=self.csv_fields, dialect="unix"
-				)
-				writer.writerow(row)
-
-			if self.use_end_threshold:
-				max_prob = max(self.probabilities)
-				if max_prob > self.end_threshold:
-					_logger.info(
-						f"Aborting early, because {max_prob} is greater than {self.end_threshold}"
-					)
-					break

deepdog/bayes_run_simulpairs.py

@@ -1,382 +0,0 @@
-import pdme.inputs
-import pdme.model
-import pdme.measurement.input_types
-import pdme.measurement.oscillating_dipole
-import pdme.util.fast_v_calc
-import pdme.util.fast_nonlocal_spectrum
-from typing import Sequence, Tuple, List
-import datetime
-import csv
-import multiprocessing
-import logging
-import numpy
-import numpy.random
-
-
-# TODO: remove hardcode
-CHUNKSIZE = 50
-
-# TODO: It's garbage to have this here duplicated from pdme.
-DotInput = Tuple[numpy.typing.ArrayLike, float]
-
-
-_logger = logging.getLogger(__name__)
-
-
-def get_a_simul_result_using_pairs(input) -> numpy.ndarray:
-	(
-		model,
-		dot_inputs,
-		pair_inputs,
-		local_lows,
-		local_highs,
-		nonlocal_lows,
-		nonlocal_highs,
-		monte_carlo_count,
-		monte_carlo_cycles,
-		max_frequency,
-		seed,
-	) = input
-
-	rng = numpy.random.default_rng(seed)
-	local_total = 0
-	combined_total = 0
-
-	sample_dipoles = model.get_monte_carlo_dipole_inputs(
-		monte_carlo_count, max_frequency, rng_to_use=rng
-	)
-	local_vals = pdme.util.fast_v_calc.fast_vs_for_dipoleses(dot_inputs, sample_dipoles)
-	local_matches = pdme.util.fast_v_calc.between(local_vals, local_lows, local_highs)
-	nonlocal_vals = pdme.util.fast_nonlocal_spectrum.fast_s_nonlocal_dipoleses(
-		pair_inputs, sample_dipoles
-	)
-	nonlocal_matches = pdme.util.fast_v_calc.between(
-		nonlocal_vals, nonlocal_lows, nonlocal_highs
-	)
-	combined_matches = numpy.logical_and(local_matches, nonlocal_matches)
-
-	local_total += numpy.count_nonzero(local_matches)
-	combined_total += numpy.count_nonzero(combined_matches)
-	return numpy.array([local_total, combined_total])
-
-
-class BayesRunSimulPairs:
-	"""
-	A dual pairs-nonpairs Bayes run for a given set of dots.
-
-	Parameters
-	----------
-	dot_inputs : Sequence[DotInput]
-	The dot inputs for this bayes run.
-
-	models_with_names : Sequence[Tuple(str, pdme.model.DipoleModel)]
-	The models to evaluate.
-
-	actual_model : pdme.model.DipoleModel
-	The modoel for the model which is actually correct.
-
-	filename_slug : str
-	The filename slug to include.
-
-	run_count: int
-	The number of runs to do.
-	"""
-
-	def __init__(
-		self,
-		dot_positions: Sequence[numpy.typing.ArrayLike],
-		frequency_range: Sequence[float],
-		models_with_names: Sequence[Tuple[str, pdme.model.DipoleModel]],
-		actual_model: pdme.model.DipoleModel,
-		filename_slug: str,
-		run_count: int = 100,
-		low_error: float = 0.9,
-		high_error: float = 1.1,
-		pairs_high_error=None,
-		pairs_low_error=None,
-		monte_carlo_count: int = 10000,
-		monte_carlo_cycles: int = 10,
-		target_success: int = 100,
-		max_monte_carlo_cycles_steps: int = 10,
-		max_frequency: float = 20,
-		end_threshold: float = None,
-		chunksize: int = CHUNKSIZE,
-	) -> None:
-		self.dot_inputs = pdme.inputs.inputs_with_frequency_range(
-			dot_positions, frequency_range
-		)
-		self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
-			self.dot_inputs
-		)
-
-		self.dot_pair_inputs = pdme.inputs.input_pairs_with_frequency_range(
-			dot_positions, frequency_range
-		)
-		self.dot_pair_inputs_array = (
-			pdme.measurement.input_types.dot_pair_inputs_to_array(self.dot_pair_inputs)
-		)
-
-		self.models = [mod for (_, mod) in models_with_names]
-		self.model_names = [name for (name, _) in models_with_names]
-		self.actual_model = actual_model
-
-		self.n: int
-		try:
-			self.n = self.actual_model.n  # type: ignore
-		except AttributeError:
-			self.n = 1
-
-		self.model_count = len(self.models)
-		self.monte_carlo_count = monte_carlo_count
-		self.monte_carlo_cycles = monte_carlo_cycles
-		self.target_success = target_success
-		self.max_monte_carlo_cycles_steps = max_monte_carlo_cycles_steps
-		self.run_count = run_count
-		self.low_error = low_error
-		self.high_error = high_error
-		if pairs_low_error is None:
-			self.pairs_low_error = self.low_error
-		else:
-			self.pairs_low_error = pairs_low_error
-		if pairs_high_error is None:
-			self.pairs_high_error = self.high_error
-		else:
-			self.pairs_high_error = pairs_high_error
-
-		self.csv_fields = []
-		for i in range(self.n):
-			self.csv_fields.extend(
-				[
-					f"dipole_moment_{i+1}",
-					f"dipole_location_{i+1}",
-					f"dipole_frequency_{i+1}",
-				]
-			)
-		self.compensate_zeros = True
-		self.chunksize = chunksize
-		for name in self.model_names:
-			self.csv_fields.extend([f"{name}_success", f"{name}_count", f"{name}_prob"])
-
-		self.probabilities_no_pairs = [1 / self.model_count] * self.model_count
-		self.probabilities_pairs = [1 / self.model_count] * self.model_count
-
-		timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-		self.filename_pairs = f"{timestamp}-{filename_slug}.simulpairs.yespairs.csv"
-		self.filename_no_pairs = f"{timestamp}-{filename_slug}.simulpairs.noopairs.csv"
-
-		self.max_frequency = max_frequency
-
-		if end_threshold is not None:
-			if 0 < end_threshold < 1:
-				self.end_threshold: float = end_threshold
-				self.use_end_threshold = True
-				_logger.info(f"Will abort early, at {self.end_threshold}.")
-			else:
-				raise ValueError(
-					f"end_threshold should be between 0 and 1, but is actually {end_threshold}"
-				)
-
-	def go(self) -> None:
-		with open(self.filename_pairs, "a", newline="") as outfile:
-			writer = csv.DictWriter(outfile, fieldnames=self.csv_fields, dialect="unix")
-			writer.writeheader()
-		with open(self.filename_no_pairs, "a", newline="") as outfile:
-			writer = csv.DictWriter(outfile, fieldnames=self.csv_fields, dialect="unix")
-			writer.writeheader()
-
-		for run in range(1, self.run_count + 1):
-
-			# Generate the actual dipoles
-			actual_dipoles = self.actual_model.get_dipoles(self.max_frequency)
-
-			dots = actual_dipoles.get_percent_range_dot_measurements(
-				self.dot_inputs, self.low_error, self.high_error
-			)
-			(
-				lows,
-				highs,
-			) = pdme.measurement.input_types.dot_range_measurements_low_high_arrays(
-				dots
-			)
-
-			pair_lows, pair_highs = (None, None)
-			pair_measurements = actual_dipoles.get_percent_range_dot_pair_measurements(
-				self.dot_pair_inputs, self.pairs_low_error, self.pairs_high_error
-			)
-			(
-				pair_lows,
-				pair_highs,
-			) = pdme.measurement.input_types.dot_range_measurements_low_high_arrays(
-				pair_measurements
-			)
-
-			_logger.info(f"Going to work on dipole at {actual_dipoles.dipoles}")
-
-			# define a new seed sequence for each run
-			seed_sequence = numpy.random.SeedSequence(run)
-
-			results_pairs = []
-			results_no_pairs = []
-			_logger.debug("Going to iterate over models now")
-			for model_count, model in enumerate(self.models):
-				_logger.debug(f"Doing model #{model_count}")
-
-				core_count = multiprocessing.cpu_count() - 1 or 1
-				with multiprocessing.Pool(core_count) as pool:
-					cycle_count = 0
-					cycle_success_pairs = 0
-					cycle_success_no_pairs = 0
-					cycles = 0
-					while (cycles < self.max_monte_carlo_cycles_steps) and (
-						min(cycle_success_pairs, cycle_success_no_pairs)
-						<= self.target_success
-					):
-						_logger.debug(f"Starting cycle {cycles}")
-
-						cycles += 1
-						current_success_pairs = 0
-						current_success_no_pairs = 0
-						cycle_count += self.monte_carlo_count * self.monte_carlo_cycles
-
-						# generate a seed from the sequence for each core.
-						# note this needs to be inside the loop for monte carlo cycle steps!
-						# that way we get more stuff.
-
-						seeds = seed_sequence.spawn(self.monte_carlo_cycles)
-						_logger.debug(f"Creating {self.monte_carlo_cycles} seeds")
-						current_success_both = numpy.array(
-							sum(
-								pool.imap_unordered(
-									get_a_simul_result_using_pairs,
-									[
-										(
-											model,
-											self.dot_inputs_array,
-											self.dot_pair_inputs_array,
-											lows,
-											highs,
-											pair_lows,
-											pair_highs,
-											self.monte_carlo_count,
-											self.monte_carlo_cycles,
-											self.max_frequency,
-											seed,
-										)
-										for seed in seeds
-									],
-									self.chunksize,
-								)
-							)
-						)
-						current_success_no_pairs = current_success_both[0]
-						current_success_pairs = current_success_both[1]
-
-						cycle_success_no_pairs += current_success_no_pairs
-						cycle_success_pairs += current_success_pairs
-						_logger.debug(
-							f"(pair, no_pair) successes are {(cycle_success_pairs, cycle_success_no_pairs)}"
-						)
-					results_pairs.append((cycle_count, cycle_success_pairs))
-					results_no_pairs.append((cycle_count, cycle_success_no_pairs))
-
-			_logger.debug("Done, constructing output now")
-			row_pairs = {
-				"dipole_moment_1": actual_dipoles.dipoles[0].p,
-				"dipole_location_1": actual_dipoles.dipoles[0].s,
-				"dipole_frequency_1": actual_dipoles.dipoles[0].w,
-			}
-			row_no_pairs = {
-				"dipole_moment_1": actual_dipoles.dipoles[0].p,
-				"dipole_location_1": actual_dipoles.dipoles[0].s,
-				"dipole_frequency_1": actual_dipoles.dipoles[0].w,
-			}
-			for i in range(1, self.n):
-				try:
-					current_dipoles = actual_dipoles.dipoles[i]
-					row_pairs[f"dipole_moment_{i+1}"] = current_dipoles.p
-					row_pairs[f"dipole_location_{i+1}"] = current_dipoles.s
-					row_pairs[f"dipole_frequency_{i+1}"] = current_dipoles.w
-					row_no_pairs[f"dipole_moment_{i+1}"] = current_dipoles.p
-					row_no_pairs[f"dipole_location_{i+1}"] = current_dipoles.s
-					row_no_pairs[f"dipole_frequency_{i+1}"] = current_dipoles.w
-				except IndexError:
-					_logger.info(f"Not writing anymore, saw end after {i}")
-					break
-
-			successes_pairs: List[float] = []
-			successes_no_pairs: List[float] = []
-			counts: List[int] = []
-			for model_index, (
-				name,
-				(count_pair, result_pair),
-				(count_no_pair, result_no_pair),
-			) in enumerate(zip(self.model_names, results_pairs, results_no_pairs)):
-
-				row_pairs[f"{name}_success"] = result_pair
-				row_pairs[f"{name}_count"] = count_pair
-				successes_pairs.append(max(result_pair, 0.5))
-
-				row_no_pairs[f"{name}_success"] = result_no_pair
-				row_no_pairs[f"{name}_count"] = count_no_pair
-				successes_no_pairs.append(max(result_no_pair, 0.5))
-
-				counts.append(count_pair)
-
-			success_weight_pair = sum(
-				[
-					(succ / count) * prob
-					for succ, count, prob in zip(
-						successes_pairs, counts, self.probabilities_pairs
-					)
-				]
-			)
-			success_weight_no_pair = sum(
-				[
-					(succ / count) * prob
-					for succ, count, prob in zip(
-						successes_no_pairs, counts, self.probabilities_no_pairs
-					)
-				]
-			)
-			new_probabilities_pair = [
-				(succ / count) * old_prob / success_weight_pair
-				for succ, count, old_prob in zip(
-					successes_pairs, counts, self.probabilities_pairs
-				)
-			]
-			new_probabilities_no_pair = [
-				(succ / count) * old_prob / success_weight_no_pair
-				for succ, count, old_prob in zip(
-					successes_no_pairs, counts, self.probabilities_no_pairs
-				)
-			]
-			self.probabilities_pairs = new_probabilities_pair
-			self.probabilities_no_pairs = new_probabilities_no_pair
-			for name, probability_pair, probability_no_pair in zip(
-				self.model_names, self.probabilities_pairs, self.probabilities_no_pairs
-			):
-				row_pairs[f"{name}_prob"] = probability_pair
-				row_no_pairs[f"{name}_prob"] = probability_no_pair
-			_logger.debug(row_pairs)
-			_logger.debug(row_no_pairs)
-
-			with open(self.filename_pairs, "a", newline="") as outfile:
-				writer = csv.DictWriter(
-					outfile, fieldnames=self.csv_fields, dialect="unix"
-				)
-				writer.writerow(row_pairs)
-			with open(self.filename_no_pairs, "a", newline="") as outfile:
-				writer = csv.DictWriter(
-					outfile, fieldnames=self.csv_fields, dialect="unix"
-				)
-				writer.writerow(row_no_pairs)
-
-			if self.use_end_threshold:
-				max_prob = min(
-					max(self.probabilities_pairs), max(self.probabilities_no_pairs)
-				)
-				if max_prob > self.end_threshold:
-					_logger.info(
-						f"Aborting early, because {max_prob} is greater than {self.end_threshold}"
-					)
-					break

deepdog/bayes_run_with_ss.py

@@ -1,261 +0,0 @@
-import deepdog.subset_simulation
-import pdme.inputs
-import pdme.model
-import pdme.measurement.input_types
-import pdme.measurement.oscillating_dipole
-import pdme.util.fast_v_calc
-import pdme.util.fast_nonlocal_spectrum
-from typing import Sequence, Tuple, List, Optional
-import datetime
-import csv
-import logging
-import numpy
-import numpy.typing
-
-
-# TODO: remove hardcode
-CHUNKSIZE = 50
-
-# TODO: It's garbage to have this here duplicated from pdme.
-DotInput = Tuple[numpy.typing.ArrayLike, float]
-
-
-CLAMPING_FACTOR = 10
-
-_logger = logging.getLogger(__name__)
-
-
-class BayesRunWithSubspaceSimulation:
-	"""
-	A single Bayes run for a given set of dots.
-
-	Parameters
-	----------
-	dot_inputs : Sequence[DotInput]
-	The dot inputs for this bayes run.
-
-	models_with_names : Sequence[Tuple(str, pdme.model.DipoleModel)]
-	The models to evaluate.
-
-	actual_model : pdme.model.DipoleModel
-	The model which is actually correct.
-
-	filename_slug : str
-	The filename slug to include.
-
-	run_count: int
-	The number of runs to do.
-	"""
-
-	def __init__(
-		self,
-		dot_positions: Sequence[numpy.typing.ArrayLike],
-		frequency_range: Sequence[float],
-		models_with_names: Sequence[Tuple[str, pdme.model.DipoleModel]],
-		actual_model: pdme.model.DipoleModel,
-		filename_slug: str,
-		max_frequency: float = 20,
-		end_threshold: float = None,
-		run_count=100,
-		chunksize: int = CHUNKSIZE,
-		ss_n_c: int = 500,
-		ss_n_s: int = 100,
-		ss_m_max: int = 15,
-		ss_target_cost: Optional[float] = None,
-		ss_level_0_seed: int = 200,
-		ss_mcmc_seed: int = 20,
-		ss_use_adaptive_steps=True,
-		ss_default_phi_step=0.01,
-		ss_default_theta_step=0.01,
-		ss_default_r_step=0.01,
-		ss_default_w_log_step=0.01,
-		ss_default_upper_w_log_step=4,
-		ss_dump_last_generation=False,
-		ss_initial_costs_chunk_size=100,
-		write_output_to_bayesruncsv=True,
-		use_timestamp_for_output=True,
-	) -> None:
-		self.dot_inputs = pdme.inputs.inputs_with_frequency_range(
-			dot_positions, frequency_range
-		)
-		self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
-			self.dot_inputs
-		)
-
-		self.models_with_names = models_with_names
-		self.models = [model for (_, model) in models_with_names]
-		self.model_names = [name for (name, _) in models_with_names]
-		self.actual_model = actual_model
-
-		self.n: int
-		try:
-			self.n = self.actual_model.n  # type: ignore
-		except AttributeError:
-			self.n = 1
-
-		self.model_count = len(self.models)
-
-		self.csv_fields = []
-		for i in range(self.n):
-			self.csv_fields.extend(
-				[
-					f"dipole_moment_{i+1}",
-					f"dipole_location_{i+1}",
-					f"dipole_frequency_{i+1}",
-				]
-			)
-		self.compensate_zeros = True
-		self.chunksize = chunksize
-		for name in self.model_names:
-			self.csv_fields.extend([f"{name}_likelihood", f"{name}_prob"])
-
-		self.probabilities = [1 / self.model_count] * self.model_count
-
-		if use_timestamp_for_output:
-			timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-			self.filename = f"{timestamp}-{filename_slug}.bayesrunwithss.csv"
-		else:
-			self.filename = f"{filename_slug}.bayesrunwithss.csv"
-		self.max_frequency = max_frequency
-
-		if end_threshold is not None:
-			if 0 < end_threshold < 1:
-				self.end_threshold: float = end_threshold
-				self.use_end_threshold = True
-				_logger.info(f"Will abort early, at {self.end_threshold}.")
-			else:
-				raise ValueError(
-					f"end_threshold should be between 0 and 1, but is actually {end_threshold}"
-				)
-
-		self.ss_n_c = ss_n_c
-		self.ss_n_s = ss_n_s
-		self.ss_m_max = ss_m_max
-		self.ss_target_cost = ss_target_cost
-		self.ss_level_0_seed = ss_level_0_seed
-		self.ss_mcmc_seed = ss_mcmc_seed
-		self.ss_use_adaptive_steps = ss_use_adaptive_steps
-		self.ss_default_phi_step = ss_default_phi_step
-		self.ss_default_theta_step = ss_default_theta_step
-		self.ss_default_r_step = ss_default_r_step
-		self.ss_default_w_log_step = ss_default_w_log_step
-		self.ss_default_upper_w_log_step = ss_default_upper_w_log_step
-		self.ss_dump_last_generation = ss_dump_last_generation
-		self.ss_initial_costs_chunk_size = ss_initial_costs_chunk_size
-		self.run_count = run_count
-
-		self.write_output_to_csv = write_output_to_bayesruncsv
-
-	def go(self) -> Sequence:
-
-		if self.write_output_to_csv:
-			with open(self.filename, "a", newline="") as outfile:
-				writer = csv.DictWriter(
-					outfile, fieldnames=self.csv_fields, dialect="unix"
-				)
-				writer.writeheader()
-
-		return_result = []
-
-		for run in range(1, self.run_count + 1):
-
-			# Generate the actual dipoles
-			actual_dipoles = self.actual_model.get_dipoles(self.max_frequency)
-
-			measurements = actual_dipoles.get_dot_measurements(self.dot_inputs)
-
-			_logger.info(f"Going to work on dipole at {actual_dipoles.dipoles}")
-
-			# define a new seed sequence for each run
-
-			results = []
-			_logger.debug("Going to iterate over models now")
-			for model_count, model in enumerate(self.models_with_names):
-				_logger.debug(f"Doing model #{model_count}, {model[0]}")
-				subset_run = deepdog.subset_simulation.SubsetSimulation(
-					model,
-					self.dot_inputs,
-					measurements,
-					self.ss_n_c,
-					self.ss_n_s,
-					self.ss_m_max,
-					self.ss_target_cost,
-					self.ss_level_0_seed,
-					self.ss_mcmc_seed,
-					self.ss_use_adaptive_steps,
-					self.ss_default_phi_step,
-					self.ss_default_theta_step,
-					self.ss_default_r_step,
-					self.ss_default_w_log_step,
-					self.ss_default_upper_w_log_step,
-					initial_cost_chunk_size=self.ss_initial_costs_chunk_size,
-					keep_probs_list=False,
-					dump_last_generation_to_file=self.ss_dump_last_generation,
-				)
-				results.append(subset_run.execute())
-
-			_logger.debug("Done, constructing output now")
-			row = {
-				"dipole_moment_1": actual_dipoles.dipoles[0].p,
-				"dipole_location_1": actual_dipoles.dipoles[0].s,
-				"dipole_frequency_1": actual_dipoles.dipoles[0].w,
-			}
-			for i in range(1, self.n):
-				try:
-					current_dipoles = actual_dipoles.dipoles[i]
-					row[f"dipole_moment_{i+1}"] = current_dipoles.p
-					row[f"dipole_location_{i+1}"] = current_dipoles.s
-					row[f"dipole_frequency_{i+1}"] = current_dipoles.w
-				except IndexError:
-					_logger.info(f"Not writing anymore, saw end after {i}")
-					break
-
-			likelihoods: List[float] = []
-
-			for (name, result) in zip(self.model_names, results):
-				if result.over_target_likelihood is None:
-					if result.lowest_likelihood is None:
-						_logger.error(f"result {result} looks bad")
-						clamped_likelihood = 10**-15
-					else:
-						clamped_likelihood = result.lowest_likelihood / CLAMPING_FACTOR
-					_logger.warning(
-						f"got a none result, clamping to {clamped_likelihood}"
-					)
-				else:
-					clamped_likelihood = result.over_target_likelihood
-				likelihoods.append(clamped_likelihood)
-				row[f"{name}_likelihood"] = clamped_likelihood
-
-			success_weight = sum(
-				[
-					likelihood * prob
-					for likelihood, prob in zip(likelihoods, self.probabilities)
-				]
-			)
-			new_probabilities = [
-				likelihood * old_prob / success_weight
-				for likelihood, old_prob in zip(likelihoods, self.probabilities)
-			]
-			self.probabilities = new_probabilities
-			for name, probability in zip(self.model_names, self.probabilities):
-				row[f"{name}_prob"] = probability
-			_logger.info(row)
-			return_result.append(row)
-
-			if self.write_output_to_csv:
-				with open(self.filename, "a", newline="") as outfile:
-					writer = csv.DictWriter(
-						outfile, fieldnames=self.csv_fields, dialect="unix"
-					)
-					writer.writerow(row)
-
-			if self.use_end_threshold:
-				max_prob = max(self.probabilities)
-				if max_prob > self.end_threshold:
-					_logger.info(
-						f"Aborting early, because {max_prob} is greater than {self.end_threshold}"
-					)
-					break
-
-		return return_result

deepdog/cli/probs/args.py

@@ -30,18 +30,6 @@ def parse_args() -> argparse.Namespace:
 		help="A json file with the indexify config for parsing job indexes. Will skip if not present",
 		default="",
 	)
-	parser.add_argument(
-		"--seed-index",
-		type=int,
-		help='take an integer to append as a "seed" key with range at end of indexify dict. Skip if <= 0',
-		default=0,
-	)
-	parser.add_argument(
-		"--seed-fieldname",
-		type=str,
-		help='if --seed-index is set, the fieldname to append to the indexifier. "seed" by default',
-		default="seed",
-	)
 	parser.add_argument(
 		"--coalesced-keys",
 		type=str,

deepdog/cli/probs/dicts.py

@@ -61,7 +61,7 @@ def write_uncoalesced_dict(
 	if not (set(model_field_names).isdisjoint(calculation_field_names)):
 		_logger.info(f"Detected model field names {model_field_names}")
 		_logger.info(f"Detected calculation field names {calculation_field_names}")
-		raise ValueError(
+		_logger.warning(
 			f"model field names {model_field_names} and calculation {calculation_field_names} have an overlap, which is possibly a problem"
 		)
 	collected_fieldnames = list(model_field_names)

deepdog/cli/probs/main.py

@@ -51,9 +51,13 @@ def main(args: argparse.Namespace):
 		indexifier = None
 		if args.indexify_json:
 			with open(args.indexify_json, "r") as indexify_json_file:
-				indexify_data = json.load(indexify_json_file)
+				indexify_spec = json.load(indexify_json_file)
-				if args.seed_index > 0:
+				indexify_data = indexify_spec["indexes"]
-					indexify_data[args.seed_fieldname] = list(range(args.seed_index))
+				if "seed_spec" in indexify_spec:
+					seed_spec = indexify_spec["seed_spec"]
+					indexify_data[seed_spec["field_name"]] = list(
+						range(seed_spec["num_seeds"])
+					)
 				# _logger.debug(f"Indexifier data looks like {indexify_data}")
 				indexifier = deepdog.indexify.Indexifier(indexify_data)
 
@@ -68,6 +72,7 @@ def main(args: argparse.Namespace):
 			for f in tqdm.tqdm(out_files, desc="reading files", leave=False)
 		]
 
+		# Refactor here to allow for arbitrary likelihood file sources
 		_logger.info("building uncoalesced dict")
 		uncoalesced_dict = deepdog.cli.probs.dicts.build_model_dict(parsed_output_files)
 

deepdog/direct_monte_carlo/cost_function_filter.py

@@ -0,0 +1,24 @@
+from deepdog.direct_monte_carlo.direct_mc import DirectMonteCarloFilter
+from typing import Callable
+import numpy
+
+
+class CostFunctionTargetFilter(DirectMonteCarloFilter):
+	def __init__(
+		self,
+		cost_function: Callable[[numpy.ndarray], numpy.ndarray],
+		target_cost: float,
+	):
+		"""
+		Filters dipoles by cost, only leaving dipoles with cost below target_cost
+		"""
+		self.cost_function = cost_function
+		self.target_cost = target_cost
+
+	def filter_samples(self, samples: numpy.ndarray) -> numpy.ndarray:
+		current_sample = samples
+
+		costs = self.cost_function(current_sample)
+
+		current_sample = current_sample[costs < self.target_cost]
+		return current_sample

deepdog/direct_monte_carlo/direct_mc.py

@@ -1,22 +1,28 @@
+import csv
 import pdme.model
 import pdme.measurement
 import pdme.measurement.input_types
 import pdme.subspace_simulation
-from typing import Tuple, Dict, NewType, Any
+import datetime
+from typing import Tuple, Dict, NewType, Any, Sequence
 from dataclasses import dataclass
 import logging
 import numpy
 import numpy.random
 import pdme.util.fast_v_calc
+import multiprocessing
 
 _logger = logging.getLogger(__name__)
 
+ANTI_ZERO_SUCCESS_THRES = 0.1
+
 
 @dataclass
 class DirectMonteCarloResult:
 	successes: int
 	monte_carlo_count: int
 	likelihood: float
+	model_name: str
 
 
 @dataclass
@@ -28,6 +34,11 @@ class DirectMonteCarloConfig:
 	monte_carlo_seed: int = 1234
 	write_successes_to_file: bool = False
 	tag: str = ""
+	cap_core_count: int = 0  # 0 means cap at num cores - 1
+	chunk_size: int = 50
+	write_bayesrun_file = True
+	bayesrun_file_timestamp = True
+	# chunk size of some kind
 
 
 # Aliasing dict as a generic data container
@@ -51,8 +62,8 @@ class DirectMonteCarloRun:
 
 	Parameters
 	----------
-	model_name_pair : Sequence[Tuple(str, pdme.model.DipoleModel)]
+	model_name_pairs : Sequence[Tuple(str, pdme.model.DipoleModel)]
-	The model to evaluate, with name.
+	The models to evaluate, with names
 
 	measurements: Sequence[pdme.measurement.DotRangeMeasurement]
 	The measurements as dot ranges to use as the bounds for the Monte Carlo calculation.
@@ -78,11 +89,11 @@ class DirectMonteCarloRun:
 
 	def __init__(
 		self,
-		model_name_pair: Tuple[str, pdme.model.DipoleModel],
+		model_name_pairs: Sequence[Tuple[str, pdme.model.DipoleModel]],
 		filter: DirectMonteCarloFilter,
 		config: DirectMonteCarloConfig,
 	):
-		self.model_name, self.model = model_name_pair
+		self.model_name_pairs = model_name_pairs
 
 		# self.measurements = measurements
 		# self.dot_inputs = [(measure.r, measure.f) for measure in self.measurements]
@@ -100,10 +111,16 @@ class DirectMonteCarloRun:
 		# 	self.measurements
 		# )
 
-	def _single_run(self, seed) -> numpy.ndarray:
+	def _single_run(
+		self, model_name_pair: Tuple[str, pdme.model.DipoleModel], seed
+	) -> numpy.ndarray:
 		rng = numpy.random.default_rng(seed)
 
-		sample_dipoles = self.model.get_monte_carlo_dipole_inputs(
+		_, model = model_name_pair
+		# don't log here it's madness
+		# _logger.info(f"Executing for model {model_name}")
+
+		sample_dipoles = model.get_monte_carlo_dipole_inputs(
 			self.config.monte_carlo_count_per_cycle, -1, rng
 		)
 
@@ -123,15 +140,38 @@ class DirectMonteCarloRun:
 		# 	]
 		# return current_sample
 
-	def execute(self) -> DirectMonteCarloResult:
+	def _wrapped_single_run(self, args: Tuple):
-		step_count = 0
+		"""
-		total_success = 0
+		single run wrapped up for multiprocessing call.
-		total_count = 0
+
+		takes in a tuple of arguments corresponding to
+		(model_name_pair, seed)
+		"""
+		# here's where we do our work
+
+		model_name_pair, seed = args
+		cycle_success_configs = self._single_run(model_name_pair, seed)
+		cycle_success_count = len(cycle_success_configs)
+
+		return cycle_success_count
+
+	def execute_no_multiprocessing(self) -> Sequence[DirectMonteCarloResult]:
 
 		count_per_step = (
 			self.config.monte_carlo_count_per_cycle * self.config.monte_carlo_cycles
 		)
 		seed_sequence = numpy.random.SeedSequence(self.config.monte_carlo_seed)
+
+		# core count etc. logic here
+
+		results = []
+		for model_name_pair in self.model_name_pairs:
+			step_count = 0
+			total_success = 0
+			total_count = 0
+
+			_logger.info(f"Working on model {model_name_pair[0]}")
+			# This is probably where multiprocessing logic should go
 			while (step_count < self.config.max_monte_carlo_cycles_steps) and (
 				total_success < self.config.target_success
 			):
@@ -139,13 +179,14 @@ class DirectMonteCarloRun:
 				for cycle_i, seed in enumerate(
 					seed_sequence.spawn(self.config.monte_carlo_cycles)
 				):
-				cycle_success_configs = self._single_run(seed)
+					# here's where we do our work
+					cycle_success_configs = self._single_run(model_name_pair, seed)
 					cycle_success_count = len(cycle_success_configs)
 					if cycle_success_count > 0:
 						_logger.debug(
 							f"For cycle {cycle_i} received {cycle_success_count} successes"
 						)
-					_logger.debug(cycle_success_configs)
+						# _logger.debug(cycle_success_configs)
 						if self.config.write_successes_to_file:
 							sorted_by_freq = numpy.array(
 								[
@@ -163,12 +204,129 @@ class DirectMonteCarloRun:
 									delimiter=",",
 								)
 					total_success += cycle_success_count
-			_logger.debug(f"At end of step {step_count} have {total_success} successes")
+				_logger.debug(
+					f"At end of step {step_count} have {total_success} successes"
+				)
 				step_count += 1
 				total_count += count_per_step
 
-		return DirectMonteCarloResult(
+			results.append(
+				DirectMonteCarloResult(
 					successes=total_success,
 					monte_carlo_count=total_count,
 					likelihood=total_success / total_count,
+					model_name=model_name_pair[0],
 				)
+			)
+		return results
+
+	def execute(self) -> Sequence[DirectMonteCarloResult]:
+
+		# set starting execution timestamp
+		timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+
+		count_per_step = (
+			self.config.monte_carlo_count_per_cycle * self.config.monte_carlo_cycles
+		)
+		seed_sequence = numpy.random.SeedSequence(self.config.monte_carlo_seed)
+
+		# core count etc. logic here
+		core_count = multiprocessing.cpu_count() - 1 or 1
+		if (self.config.cap_core_count >= 1) and (
+			self.config.cap_core_count < core_count
+		):
+			core_count = self.config.cap_core_count
+		_logger.info(f"Using {core_count} cores")
+
+		results = []
+		with multiprocessing.Pool(core_count) as pool:
+
+			for model_name_pair in self.model_name_pairs:
+				_logger.info(f"Working on model {model_name_pair[0]}")
+				# This is probably where multiprocessing logic should go
+
+				step_count = 0
+				total_success = 0
+				total_count = 0
+
+				while (step_count < self.config.max_monte_carlo_cycles_steps) and (
+					total_success < self.config.target_success
+				):
+
+					step_count += 1
+
+					_logger.debug(f"Executing step {step_count}")
+
+					seeds = seed_sequence.spawn(self.config.monte_carlo_cycles)
+
+					pool_results = sum(
+						pool.imap_unordered(
+							self._wrapped_single_run,
+							[(model_name_pair, seed) for seed in seeds],
+							self.config.chunk_size,
+						)
+					)
+					_logger.debug(f"Pool results: {pool_results}")
+
+					total_success += pool_results
+					total_count += count_per_step
+					_logger.debug(
+						f"At end of step {step_count} have {total_success} successes"
+					)
+
+				results.append(
+					DirectMonteCarloResult(
+						successes=total_success,
+						monte_carlo_count=total_count,
+						likelihood=total_success / total_count,
+						model_name=model_name_pair[0],
+					)
+				)
+
+		if self.config.write_bayesrun_file:
+
+			if self.config.bayesrun_file_timestamp:
+				timestamp_str = f"{timestamp}-"
+			else:
+				timestamp_str = ""
+			filename = (
+				f"{timestamp_str}{self.config.tag}.realdata.fast_filter.bayesrun.csv"
+			)
+
+			_logger.info(f"Going to write to file [{filename}]")
+			# row: Dict[str, Union[int, float, str]] = {}
+			row = {}
+
+			num_models = len(self.model_name_pairs)
+			success_weight = sum(
+				[
+					(
+						max(ANTI_ZERO_SUCCESS_THRES, res.successes)
+						/ res.monte_carlo_count
+					)
+					/ num_models
+					for res in results
+				]
+			)
+
+			for res in results:
+				row.update(
+					{
+						f"{res.model_name}_success": res.successes,
+						f"{res.model_name}_count": res.monte_carlo_count,
+						f"{res.model_name}_prob": (
+							max(ANTI_ZERO_SUCCESS_THRES, res.successes)
+							/ res.monte_carlo_count
+						)
+						/ (num_models * success_weight),
+					}
+				)
+			_logger.info(f"Writing row {row}")
+			fieldnames = list(row.keys())
+
+			with open(filename, "w", newline="") as outfile:
+				writer = csv.DictWriter(outfile, fieldnames=fieldnames, dialect="unix")
+				writer.writeheader()
+				writer.writerow(row)
+
+		return results

deepdog/direct_monte_carlo/dmc_filters.py

@@ -39,6 +39,39 @@ class SingleDotPotentialFilter(DirectMonteCarloFilter):
 		return current_sample
 
 
+class SingleDotSpinQubitFrequencyFilter(DirectMonteCarloFilter):
+	def __init__(self, measurements: Sequence[pdme.measurement.DotRangeMeasurement]):
+		self.measurements = measurements
+		self.dot_inputs = [(measure.r, measure.f) for measure in self.measurements]
+
+		self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
+			self.dot_inputs
+		)
+		(
+			self.lows,
+			self.highs,
+		) = pdme.measurement.input_types.dot_range_measurements_low_high_arrays(
+			self.measurements
+		)
+
+	def filter_samples(self, samples: ndarray) -> ndarray:
+		current_sample = samples
+		for di, low, high in zip(self.dot_inputs_array, self.lows, self.highs):
+
+			if len(current_sample) < 1:
+				break
+			vals = pdme.util.fast_v_calc.fast_efieldxs_for_dipoleses(
+				numpy.array([di]), current_sample
+			)
+			# _logger.info(vals)
+
+			current_sample = current_sample[
+				numpy.all((vals > low) & (vals < high), axis=1)
+			]
+		# _logger.info(f"leaving with {len(current_sample)}")
+		return current_sample
+
+
 class DoubleDotSpinQubitFrequencyFilter(DirectMonteCarloFilter):
 	def __init__(
 		self,
@@ -59,59 +92,6 @@ class DoubleDotSpinQubitFrequencyFilter(DirectMonteCarloFilter):
 			self.pair_phase_measurements
 		)
 
-	def fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
-		self, dot_pair_inputs: numpy.ndarray, dipoleses: numpy.ndarray
-	) -> numpy.ndarray:
-		"""
-		No error correction here baby.
-		"""
-		ps = dipoleses[:, :, 0:3]
-		ss = dipoleses[:, :, 3:6]
-		ws = dipoleses[:, :, 6]
-
-		r1s = dot_pair_inputs[:, 0, 0:3]
-		r2s = dot_pair_inputs[:, 1, 0:3]
-		f1s = dot_pair_inputs[:, 0, 3]
-		# Don't actually need this
-		# f2s = dot_pair_inputs[:, 1, 3]
-
-		diffses1 = r1s[:, None] - ss[:, None, :]
-		diffses2 = r2s[:, None] - ss[:, None, :]
-
-		norms1 = numpy.linalg.norm(diffses1, axis=3)
-		norms2 = numpy.linalg.norm(diffses2, axis=3)
-
-		alphses1 = (
-			(
-				3
-				* numpy.transpose(
-					numpy.transpose(
-						numpy.einsum("abcd,acd->abc", diffses1, ps) / (norms1**2)
-					)
-					* numpy.transpose(diffses1)
-				)[:, :, :, 0]
-			)
-			- ps[:, :, 0, numpy.newaxis]
-		) / (norms1**3)
-		alphses2 = (
-			(
-				3
-				* numpy.transpose(
-					numpy.transpose(
-						numpy.einsum("abcd,acd->abc", diffses2, ps) / (norms2**2)
-					)
-					* numpy.transpose(diffses2)
-				)[:, :, :, 0]
-			)
-			- ps[:, :, 0, numpy.newaxis]
-		) / (norms2**3)
-
-		bses = (1 / numpy.pi) * (
-			ws[:, None, :] / (f1s[:, None] ** 2 + ws[:, None, :] ** 2)
-		)
-
-		return numpy.einsum("...j->...", alphses1 * alphses2 * bses)
-
 	def filter_samples(self, samples: ndarray) -> ndarray:
 		current_sample = samples
 
@@ -121,16 +101,8 @@ class DoubleDotSpinQubitFrequencyFilter(DirectMonteCarloFilter):
 			if len(current_sample) < 1:
 				break
 
-			###
-			# This should be  abstracted out, but we're going to dump it here for time pressure's sake
-			###
-			# vals = pdme.util.fast_nonlocal_spectrum.signarg(
-			# 	pdme.util.fast_nonlocal_spectrum.fast_s_nonlocal_dipoleses(
-			# 		numpy.array([pi]), current_sample
-			# 	)
-			#
 			vals = pdme.util.fast_nonlocal_spectrum.signarg(
-				self.fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
+				pdme.util.fast_nonlocal_spectrum.fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
 					numpy.array([pi]), current_sample
 				)
 			)

deepdog/indexify/__init__.py

@@ -31,10 +31,10 @@ class Indexifier:
 
 	def __init__(self, list_dict: typing.Dict[str, typing.Sequence]):
 		self.dict = list_dict
+		self.product_dict = _dict_product(self.dict)
 
 	def indexify(self, n: int) -> typing.Dict[str, typing.Any]:
-		product_dict = _dict_product(self.dict)
+		return self.product_dict[n]
-		return product_dict[n]
 
 	def _indexify_indices(self, n: int) -> typing.Sequence[int]:
 		"""

deepdog/real_spectrum_run.py

@@ -112,59 +112,6 @@ def get_a_result_fast_filter_tarucha_spin_qubit_pair_phase_only(input) -> int:
 		seed,
 	) = input
 
-	def fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
-		dot_pair_inputs: numpy.ndarray, dipoleses: numpy.ndarray
-	) -> numpy.ndarray:
-		"""
-		No error correction here baby.
-		"""
-		ps = dipoleses[:, :, 0:3]
-		ss = dipoleses[:, :, 3:6]
-		ws = dipoleses[:, :, 6]
-
-		r1s = dot_pair_inputs[:, 0, 0:3]
-		r2s = dot_pair_inputs[:, 1, 0:3]
-		f1s = dot_pair_inputs[:, 0, 3]
-		# don't actually need, because we're assuming they're the same frequencies across the pair
-		# f2s = dot_pair_inputs[:, 1, 3]
-
-		diffses1 = r1s[:, None] - ss[:, None, :]
-		diffses2 = r2s[:, None] - ss[:, None, :]
-
-		norms1 = numpy.linalg.norm(diffses1, axis=3)
-		norms2 = numpy.linalg.norm(diffses2, axis=3)
-
-		alphses1 = (
-			(
-				3
-				* numpy.transpose(
-					numpy.transpose(
-						numpy.einsum("abcd,acd->abc", diffses1, ps) / (norms1**2)
-					)
-					* numpy.transpose(diffses1)
-				)[:, :, :, 0]
-			)
-			- ps[:, numpy.newaxis, :, 0]
-		) / (norms1**3)
-		alphses2 = (
-			(
-				3
-				* numpy.transpose(
-					numpy.transpose(
-						numpy.einsum("abcd,acd->abc", diffses2, ps) / (norms2**2)
-					)
-					* numpy.transpose(diffses2)
-				)[:, :, :, 0]
-			)
-			- ps[:, numpy.newaxis, :, 0]
-		) / (norms2**3)
-
-		bses = (1 / numpy.pi) * (
-			ws[:, None, :] / (f1s[:, None] ** 2 + ws[:, None, :] ** 2)
-		)
-
-		return numpy.einsum("...j->...", alphses1 * alphses2 * bses)
-
 	rng = numpy.random.default_rng(seed)
 	# TODO: A long term refactor is to pull the frequency stuff out from here. The None stands for max_frequency, which is unneeded in the actually useful models.
 	sample_dipoles = model.get_monte_carlo_dipole_inputs(
@@ -186,7 +133,7 @@ def get_a_result_fast_filter_tarucha_spin_qubit_pair_phase_only(input) -> int:
 		# 	)
 		#
 		vals = pdme.util.fast_nonlocal_spectrum.signarg(
-			fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
+			pdme.util.fast_nonlocal_spectrum.fast_s_spin_qubit_tarucha_nonlocal_dipoleses(
 				numpy.array([pi]), current_sample
 			)
 		)

deepdog/results/__init__.py

@@ -8,16 +8,30 @@ import csv
 
 _logger = logging.getLogger(__name__)
 
-FILENAME_REGEX = r"(?P<timestamp>\d{8}-\d{6})-(?P<filename_slug>.*)\.realdata\.fast_filter\.bayesrun\.csv"
+FILENAME_REGEX = re.compile(
+	r"(?P<timestamp>\d{8}-\d{6})-(?P<filename_slug>.*)\.realdata\.fast_filter\.bayesrun\.csv"
+)
 
 MODEL_REGEXES = [
-	r"geom_(?P<xmin>-?\d+)_(?P<xmax>-?\d+)_(?P<ymin>-?\d+)_(?P<ymax>-?\d+)_(?P<zmin>-?\d+)_(?P<zmax>-?\d+)-orientation_(?P<orientation>free|fixedxy|fixedz)-dipole_count_(?P<avg_filled>\d+)_(?P<field_name>\w*)"
+	re.compile(pattern)
+	for pattern in [
+		r"geom_(?P<xmin>-?\d+)_(?P<xmax>-?\d+)_(?P<ymin>-?\d+)_(?P<ymax>-?\d+)_(?P<zmin>-?\d+)_(?P<zmax>-?\d+)-orientation_(?P<orientation>free|fixedxy|fixedz)-dipole_count_(?P<avg_filled>\d+)_(?P<field_name>\w*)",
+		r"geom_(?P<xmin>-?\d+)_(?P<xmax>-?\d+)_(?P<ymin>-?\d+)_(?P<ymax>-?\d+)_(?P<zmin>-?\d+)_(?P<zmax>-?\d+)-magnitude_(?P<log_magnitude>\d*\.?\d+)-orientation_(?P<orientation>free|fixedxy|fixedz)-dipole_count_(?P<avg_filled>\d+)_(?P<field_name>\w*)",
+		r"geom_(?P<xmin>-?\d*\.?\d+)_(?P<xmax>-?\d*\.?\d+)_(?P<ymin>-?\d*\.?\d+)_(?P<ymax>-?\d*\.?\d+)_(?P<zmin>-?\d*\.?\d+)_(?P<zmax>-?\d*\.?\d+)-magnitude_(?P<log_magnitude>\d*\.?\d+)-orientation_(?P<orientation>free|fixedxy|fixedz)-dipole_count_(?P<avg_filled>\d+)_(?P<field_name>\w*)",
+	]
 ]
 
 FILE_SLUG_REGEXES = [
+	re.compile(pattern)
+	for pattern in [
+		r"(?P<tag>\w+)-(?P<job_index>\d+)",
 		r"mock_tarucha-(?P<job_index>\d+)",
+		r"(?:(?P<mock>mock)_)?tarucha(?:_(?P<tarucha_run_id>\d+))?-(?P<job_index>\d+)",
+	]
 ]
 
+SIMPLE_TAG_REGEX = re.compile(r"\w+-\d+")
+
 
 @dataclasses.dataclass
 class BayesrunOutputFilename:
@@ -26,7 +40,6 @@ class BayesrunOutputFilename:
 	path: pathlib.Path
 
 
-@dataclasses.dataclass
 class BayesrunColumnParsed:
 	"""
 	class for parsing a bayesrun while pulling certain special fields out
@@ -37,10 +50,21 @@ class BayesrunColumnParsed:
 		self.model_field_dict = {
 			k: v for k, v in groupdict.items() if k != "field_name"
 		}
+		self._groupdict_str = repr(groupdict)
 
 	def __str__(self):
 		return f"BayesrunColumnParsed[{self.column_field}: {self.model_field_dict}]"
 
+	def __repr__(self):
+		return f"BayesrunColumnParsed({self._groupdict_str})"
+
+	def __eq__(self, other):
+		if isinstance(other, BayesrunColumnParsed):
+			return (self.column_field == other.column_field) and (
+				self.model_field_dict == other.model_field_dict
+			)
+		return NotImplemented
+
 
 @dataclasses.dataclass
 class BayesrunModelResult:
@@ -72,7 +96,7 @@ def _parse_bayesrun_column(
 	Returns the groupdict for the first match, or None if no match found.
 	"""
 	for pattern in MODEL_REGEXES:
-		match = re.match(pattern, column)
+		match = pattern.match(column)
 		if match:
 			return BayesrunColumnParsed(match.groupdict())
 	else:
@@ -111,7 +135,7 @@ def _parse_bayesrun_row(
 
 def _parse_output_filename(file: pathlib.Path) -> BayesrunOutputFilename:
 	filename = file.name
-	match = re.match(FILENAME_REGEX, filename)
+	match = FILENAME_REGEX.match(filename)
 	if not match:
 		raise ValueError(f"{filename} was not a valid bayesrun output")
 	groups = match.groupdict()
@@ -122,7 +146,7 @@ def _parse_output_filename(file: pathlib.Path) -> BayesrunOutputFilename:
 
 def _parse_file_slug(slug: str) -> typing.Optional[typing.Dict[str, str]]:
 	for pattern in FILE_SLUG_REGEXES:
-		match = re.match(pattern, slug)
+		match = pattern.match(slug)
 		if match:
 			return match.groupdict()
 	else:

deepdog/subset_simulation/subset_simulation_impl.py

@@ -1,9 +1,11 @@
 import logging
+import multiprocessing
 import numpy
 import pdme.measurement
 import pdme.measurement.input_types
+import pdme.model
 import pdme.subspace_simulation
-from typing import Sequence, Tuple, Optional
+from typing import Sequence, Tuple, Optional, Callable, Union, List
 
 from dataclasses import dataclass
 
@@ -18,47 +20,63 @@ class SubsetSimulationResult:
 	under_target_cost: Optional[float]
 	under_target_likelihood: Optional[float]
 	lowest_likelihood: Optional[float]
+	messages: Sequence[str]
+
+
+@dataclass
+class MultiSubsetSimulationResult:
+	child_results: Sequence[SubsetSimulationResult]
+	model_name: str
+	estimated_likelihood: float
+	arithmetic_mean_estimated_likelihood: float
+	num_children: int
+	num_finished_children: int
+	clean_estimate: bool
 
 
 class SubsetSimulation:
 	def __init__(
 		self,
 		model_name_pair,
-		dot_inputs,
+		# actual_measurements: Sequence[pdme.measurement.DotMeasurement],
-		actual_measurements: Sequence[pdme.measurement.DotMeasurement],
+		cost_function: Callable[[numpy.ndarray], numpy.ndarray],
 		n_c: int,
 		n_s: int,
 		m_max: int,
 		target_cost: Optional[float] = None,
-		level_0_seed: int = 200,
+		level_0_seed: Union[int, Sequence[int]] = 200,
-		mcmc_seed: int = 20,
+		mcmc_seed: Union[int, Sequence[int]] = 20,
 		use_adaptive_steps=True,
 		default_phi_step=0.01,
 		default_theta_step=0.01,
 		default_r_step=0.01,
 		default_w_log_step=0.01,
 		default_upper_w_log_step=4,
+		num_initial_dmc_gens=1,
 		keep_probs_list=True,
 		dump_last_generation_to_file=False,
 		initial_cost_chunk_size=100,
+		initial_cost_multiprocess=True,
+		cap_core_count: int = 0,  # 0 means cap at num cores - 1
 	):
 		name, model = model_name_pair
 		self.model_name = name
 		self.model = model
 		_logger.info(f"got model {self.model_name}")
 
-		self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
+		# dot_inputs = [(meas.r, meas.f) for meas in actual_measurements]
-			dot_inputs
+		# self.dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(
-		)
+		# 	dot_inputs
+		# )
 		# _logger.debug(f"actual measurements: {actual_measurements}")
-		self.actual_measurement_array = numpy.array([m.v for m in actual_measurements])
+		# self.actual_measurement_array = numpy.array([m.v for m in actual_measurements])
 
-		def cost_function_to_use(dipoles_to_test):
+		# def cost_function_to_use(dipoles_to_test):
-			return pdme.subspace_simulation.proportional_costs_vs_actual_measurement(
+		# 	return pdme.subspace_simulation.proportional_costs_vs_actual_measurement(
-				self.dot_inputs_array, self.actual_measurement_array, dipoles_to_test
+		# 		self.dot_inputs_array, self.actual_measurement_array, dipoles_to_test
-			)
+		# 	)
 
-		self.cost_function_to_use = cost_function_to_use
+		self.cost_function_to_use = cost_function
 
 		self.n_c = n_c
 		self.n_s = n_s
@@ -68,16 +86,25 @@ class SubsetSimulation:
 		self.mcmc_seed = mcmc_seed
 
 		self.use_adaptive_steps = use_adaptive_steps
-		self.default_phi_step = default_phi_step
+		self.default_phi_step = (
+			default_phi_step * 1.73
+		)  # this is a hack to fix a missing sqrt 3 in the proposal function code.
 		self.default_theta_step = default_theta_step
-		self.default_r_step = default_r_step
+		self.default_r_step = (
-		self.default_w_log_step = default_w_log_step
+			default_r_step * 1.73
+		)  # this is a hack to fix a missing sqrt 3 in the proposal function code.
+		self.default_w_log_step = (
+			default_w_log_step * 1.73
+		)  # this is a hack to fix a missing sqrt 3 in the proposal function code.
 		self.default_upper_w_log_step = default_upper_w_log_step
 
 		_logger.info("using params:")
 		_logger.info(f"\tn_c: {self.n_c}")
 		_logger.info(f"\tn_s: {self.n_s}")
 		_logger.info(f"\tm: {self.m_max}")
+		_logger.info(f"\t{num_initial_dmc_gens=}")
+		_logger.info(f"\t{mcmc_seed=}")
+		_logger.info(f"\t{level_0_seed=}")
 		_logger.info("let's do level 0...")
 
 		self.target_cost = target_cost
@@ -87,44 +114,91 @@ class SubsetSimulation:
 		self.dump_last_generations = dump_last_generation_to_file
 
 		self.initial_cost_chunk_size = initial_cost_chunk_size
+		self.initial_cost_multiprocess = initial_cost_multiprocess
+
+		self.cap_core_count = cap_core_count
+
+		self.num_dmc_gens = num_initial_dmc_gens
+
+	def _single_chain_gen(self, args: Tuple):
+		threshold_cost, stdevs, rng_seed, (c, s) = args
+		rng = numpy.random.default_rng(rng_seed)
+		return self.model.get_repeat_counting_mcmc_chain(
+			s,
+			self.cost_function_to_use,
+			self.n_s,
+			threshold_cost,
+			stdevs,
+			initial_cost=c,
+			rng_arg=rng,
+		)
 
 	def execute(self) -> SubsetSimulationResult:
 
 		probs_list = []
 
+		output_messages = []
+
+		# If we have n_s = 10 and n_c = 100, then our big N = 1000 and p = 1/10
+		# The DMC stage would normally generate 1000, then pick the best 100 and start counting prob = p/10.
+		# Let's say we want our DMC stage to go down to level 2.
+		# Then we need to filter out p^2, so our initial has to be N_0 = N / p = n_c * n_s^2
+		initial_dmc_n = self.n_c * (self.n_s**self.num_dmc_gens)
+		initial_level = (
+			self.num_dmc_gens - 1
+		)  # This is perfunctory but let's label it here really explicitly
+		_logger.info(f"Generating {initial_dmc_n} for DMC stage")
 		sample_dipoles = self.model.get_monte_carlo_dipole_inputs(
-			self.n_c * self.n_s,
+			initial_dmc_n,
 			-1,
 			rng_to_use=numpy.random.default_rng(self.level_0_seed),
 		)
 		# _logger.debug(sample_dipoles)
 		# _logger.debug(sample_dipoles.shape)
 
-		raw_costs = []
+		_logger.debug("Finished dipole generation")
 		_logger.debug(
-			f"Using iterated cost function thing with chunk size {self.initial_cost_chunk_size}"
+			f"Using iterated multiprocessing cost function thing with chunk size {self.initial_cost_chunk_size}"
 		)
 
-		for x in range(0, len(sample_dipoles), self.initial_cost_chunk_size):
+		# core count etc. logic here
-			_logger.debug(f"doing chunk {x}")
+		core_count = multiprocessing.cpu_count() - 1 or 1
-			raw_costs.extend(
+		if (self.cap_core_count >= 1) and (self.cap_core_count < core_count):
-				self.cost_function_to_use(
+			core_count = self.cap_core_count
-					sample_dipoles[x : x + self.initial_cost_chunk_size]
+		_logger.info(f"Using {core_count} cores")
-				)
-			)
-		costs = numpy.array(raw_costs)
 
-		_logger.debug(f"costs: {costs}")
+		with multiprocessing.Pool(core_count) as pool:
+
+			# Do the initial DMC calculation in a multiprocessing
+
+			chunks = numpy.array_split(
+				sample_dipoles,
+				range(
+					self.initial_cost_chunk_size,
+					len(sample_dipoles),
+					self.initial_cost_chunk_size,
+				),
+			)
+			if self.initial_cost_multiprocess:
+				_logger.debug("Multiprocessing initial costs")
+				raw_costs = pool.map(self.cost_function_to_use, chunks)
+			else:
+				_logger.debug("Single process initial costs")
+				raw_costs = []
+				for chunk_idx, chunk in enumerate(chunks):
+					_logger.debug(f"doing chunk #{chunk_idx}")
+					raw_costs.append(self.cost_function_to_use(chunk))
+			costs = numpy.concatenate(raw_costs)
+			_logger.debug("finished initial dmc cost calculation")
+			# _logger.debug(f"costs: {costs}")
 			sorted_indexes = costs.argsort()[::-1]
 
-		_logger.debug(costs[sorted_indexes])
+			# _logger.debug(costs[sorted_indexes])
-		_logger.debug(sample_dipoles[sorted_indexes])
+			# _logger.debug(sample_dipoles[sorted_indexes])
 
 			sorted_costs = costs[sorted_indexes]
 			sorted_dipoles = sample_dipoles[sorted_indexes]
 
-		threshold_cost = sorted_costs[-self.n_c]
-
 			all_dipoles = numpy.array(
 				[
 					pdme.subspace_simulation.sort_array_of_dipoles_by_frequency(samp)
@@ -132,10 +206,36 @@ class SubsetSimulation:
 				]
 			)
 			all_chains = list(zip(sorted_costs, all_dipoles))
+			for dmc_level in range(initial_level):
+				# if initial level is 1, we want to print out what the level 0 threshold would have been?
+				_logger.debug(f"Get the pseudo statistics for level {dmc_level}")
+				_logger.debug(f"Whole chain has length {len(all_chains)}")
+				pseudo_threshold_index = -(
+					self.n_c * (self.n_s ** (self.num_dmc_gens - dmc_level - 1))
+				)
+				_logger.debug(
+					f"Have a pseudo_threshold_index of {pseudo_threshold_index}, or {len(all_chains) + pseudo_threshold_index}"
+				)
+				pseudo_threshold_cost = all_chains[-pseudo_threshold_index][0]
+				_logger.info(
+					f"Pseudo-level {dmc_level} threshold cost {pseudo_threshold_cost}, at P = (1 / {self.n_s})^{dmc_level + 1}"
+				)
+				all_chains = all_chains[pseudo_threshold_index:]
 
-		mcmc_rng = numpy.random.default_rng(self.mcmc_seed)
+			long_mcmc_rng = numpy.random.default_rng(self.mcmc_seed)
+			mcmc_rng_seed_sequence = numpy.random.SeedSequence(self.mcmc_seed)
 
-		for i in range(self.m_max):
+			threshold_cost = all_chains[-self.n_c][0]
+			_logger.info(
+				f"Finishing DMC threshold cost {threshold_cost} at level {initial_level}, at P = (1 / {self.n_s})^{initial_level + 1}"
+			)
+			_logger.debug(f"Executing the MCMC with chains of length {len(all_chains)}")
+
+			# Now we move on to the MCMC part of the algorithm
+
+			# This is important, we want to allow some extra initial levels so we need to account for that here!
+			for i in range(self.num_dmc_gens, self.m_max):
+				_logger.info(f"Starting level {i}")
 				next_seeds = all_chains[-self.n_c :]
 
 				if self.dump_last_generations:
@@ -158,7 +258,9 @@ class SubsetSimulation:
 					):
 						# chain = mcmc(s, threshold_cost, n_s, model, dot_inputs_array, actual_measurement_array, mcmc_rng, curr_cost=c, stdevs=stdevs)
 						# until new version gotta do
-					_logger.debug(f"\t{seed_index}: doing long chain on the next seed")
+						_logger.debug(
+							f"\t{seed_index}: doing long chain on the next seed"
+						)
 
 						long_chain = self.model.get_mcmc_chain(
 							s,
@@ -167,7 +269,7 @@ class SubsetSimulation:
 							threshold_cost,
 							stdevs,
 							initial_cost=c,
-						rng_arg=mcmc_rng,
+							rng_arg=long_mcmc_rng,
 						)
 						for _, chained in long_chain:
 							all_long_chains.append(chained)
@@ -184,7 +286,10 @@ class SubsetSimulation:
 					for cost_index, cost_chain in enumerate(all_chains[: -self.n_c]):
 						probs_list.append(
 							(
-							((self.n_c * self.n_s - cost_index) / (self.n_c * self.n_s))
+								(
+									(self.n_c * self.n_s - cost_index)
+									/ (self.n_c * self.n_s)
+								)
 								/ (self.n_s ** (i)),
 								cost_chain[0],
 								i + 1,
@@ -194,31 +299,42 @@ class SubsetSimulation:
 				next_seeds_as_array = numpy.array([s for _, s in next_seeds])
 
 				stdevs = self.get_stdevs_from_arrays(next_seeds_as_array)
-			_logger.info(f"got stdevs: {stdevs.stdevs}")
+				_logger.debug(f"got stdevs, begin: {stdevs.stdevs[:10]}")
 				_logger.debug("Starting the MCMC")
 				all_chains = []
-			for seed_index, (c, s) in enumerate(next_seeds):
+
-				# chain = mcmc(s, threshold_cost, n_s, model, dot_inputs_array, actual_measurement_array, mcmc_rng, curr_cost=c, stdevs=stdevs)
+				seeds = mcmc_rng_seed_sequence.spawn(len(next_seeds))
-				# until new version gotta do
+				pool_results = pool.imap_unordered(
-				_logger.debug(
+					self._single_chain_gen,
-					f"\t{seed_index}: getting another chain from the next seed"
+					[
-				)
+						(threshold_cost, stdevs, rng_seed, test_seed)
-				chain = self.model.get_mcmc_chain(
+						for rng_seed, test_seed in zip(seeds, next_seeds)
-					s,
+					],
-					self.cost_function_to_use,
+					chunksize=50,
-					self.n_s,
-					threshold_cost,
-					stdevs,
-					initial_cost=c,
-					rng_arg=mcmc_rng,
 				)
+
+				# count for ergodicity analysis
+				samples_generated = 0
+				samples_rejected = 0
+
+				for rejected_count, chain in pool_results:
 					for cost, chained in chain:
 						try:
 							filtered_cost = cost[0]
 						except (IndexError, TypeError):
 							filtered_cost = cost
 						all_chains.append((filtered_cost, chained))
+
+					samples_generated += self.n_s
+					samples_rejected += rejected_count
+
 				_logger.debug("finished mcmc")
+				_logger.debug(f"{samples_rejected=} out of {samples_generated=}")
+				if samples_rejected * 2 > samples_generated:
+					reject_ratio = samples_rejected / samples_generated
+					rejectionmessage = f"On level {i}, rejected {samples_rejected} out of {samples_generated}, {reject_ratio=} is too high and may indicate ergodicity problems"
+					output_messages.append(rejectionmessage)
+					_logger.warning(rejectionmessage)
 				# _logger.debug(all_chains)
 
 				all_chains.sort(key=lambda c: c[0], reverse=True)
@@ -228,7 +344,9 @@ class SubsetSimulation:
 				_logger.info(
 					f"current threshold cost: {threshold_cost}, at P = (1 / {self.n_s})^{i + 1}"
 				)
-			if (self.target_cost is not None) and (threshold_cost < self.target_cost):
+				if (self.target_cost is not None) and (
+					threshold_cost < self.target_cost
+				):
 					_logger.info(
 						f"got a threshold cost {threshold_cost}, less than {self.target_cost}. will leave early"
 					)
@@ -236,6 +354,8 @@ class SubsetSimulation:
 					cost_list = [c[0] for c in all_chains]
 					over_index = reverse_bisect_right(cost_list, self.target_cost)
 
+					winner = all_chains[over_index][1]
+					_logger.info(f"Winner obtained: {winner}")
 					shorter_probs_list = []
 					for cost_index, cost_chain in enumerate(all_chains):
 						if self.keep_probs_list:
@@ -253,7 +373,10 @@ class SubsetSimulation:
 						shorter_probs_list.append(
 							(
 								cost_chain[0],
-							((self.n_c * self.n_s - cost_index) / (self.n_c * self.n_s))
+								(
+									(self.n_c * self.n_s - cost_index)
+									/ (self.n_c * self.n_s)
+								)
 								/ (self.n_s ** (i)),
 							)
 						)
@@ -265,6 +388,7 @@ class SubsetSimulation:
 						under_target_cost=shorter_probs_list[over_index][0],
 						under_target_likelihood=shorter_probs_list[over_index][1],
 						lowest_likelihood=shorter_probs_list[-1][1],
+						messages=output_messages,
 					)
 					return result
 
@@ -285,8 +409,8 @@ class SubsetSimulation:
 		_logger.info(
 			f"final threshold cost: {threshold_cost}, at P = (1 / {self.n_s})^{self.m_max + 1}"
 		)
-		for a in all_chains[-10:]:
+		# for a in all_chains[-10:]:
-			_logger.info(a)
+		# 	_logger.info(a)
 		# for prob, prob_cost in probs_list:
 		# 	_logger.info(f"\t{prob}: {prob_cost}")
 		probs_list.sort(key=lambda c: c[0], reverse=True)
@@ -300,6 +424,7 @@ class SubsetSimulation:
 			under_target_cost=None,
 			under_target_likelihood=None,
 			lowest_likelihood=min_likelihood,
+			messages=output_messages,
 		)
 		return result
 
@@ -358,6 +483,116 @@ class SubsetSimulation:
 		return stdevs
 
 
+class MultiSubsetSimulations:
+	def __init__(
+		self,
+		model_name_pairs: Sequence[Tuple[str, pdme.model.DipoleModel]],
+		# actual_measurements: Sequence[pdme.measurement.DotMeasurement],
+		cost_function: Callable[[numpy.ndarray], numpy.ndarray],
+		num_runs: int,
+		n_c: int,
+		n_s: int,
+		m_max: int,
+		target_cost: float,
+		num_initial_dmc_gens: int = 1,
+		level_0_seed_seed: int = 200,
+		mcmc_seed_seed: int = 20,
+		use_adaptive_steps=True,
+		default_phi_step=0.01,
+		default_theta_step=0.01,
+		default_r_step=0.01,
+		default_w_log_step=0.01,
+		default_upper_w_log_step=4,
+		initial_cost_chunk_size=100,
+		cap_core_count: int = 0,  # 0 means cap at num cores - 1
+	):
+		self.model_name_pairs = model_name_pairs
+		self.cost_function = cost_function
+		self.num_runs = num_runs
+		self.n_c = n_c
+		self.n_s = n_s
+		self.m_max = m_max
+		self.target_cost = target_cost  # This is not optional here!
+
+		self.num_dmc_gens = num_initial_dmc_gens
+
+		self.level_0_seed_seed = level_0_seed_seed
+		self.mcmc_seed_seed = mcmc_seed_seed
+
+		self.use_adaptive_steps = use_adaptive_steps
+		self.default_phi_step = default_phi_step
+		self.default_theta_step = default_theta_step
+		self.default_r_step = default_r_step
+		self.default_w_log_step = default_w_log_step
+		self.default_upper_w_log_step = default_upper_w_log_step
+		self.initial_cost_chunk_size = initial_cost_chunk_size
+		self.cap_core_count = cap_core_count
+
+	def execute(self) -> Sequence[MultiSubsetSimulationResult]:
+		output: List[MultiSubsetSimulationResult] = []
+		for model_index, model_name_pair in enumerate(self.model_name_pairs):
+			ss_results = [
+				SubsetSimulation(
+					model_name_pair,
+					self.cost_function,
+					self.n_c,
+					self.n_s,
+					self.m_max,
+					self.target_cost,
+					num_initial_dmc_gens=self.num_dmc_gens,
+					level_0_seed=[model_index, run_index, self.level_0_seed_seed],
+					mcmc_seed=[model_index, run_index, self.mcmc_seed_seed],
+					use_adaptive_steps=self.use_adaptive_steps,
+					default_phi_step=self.default_phi_step,
+					default_theta_step=self.default_theta_step,
+					default_r_step=self.default_r_step,
+					default_w_log_step=self.default_w_log_step,
+					default_upper_w_log_step=self.default_upper_w_log_step,
+					keep_probs_list=False,
+					dump_last_generation_to_file=False,
+					initial_cost_chunk_size=self.initial_cost_chunk_size,
+					cap_core_count=self.cap_core_count,
+				).execute()
+				for run_index in range(self.num_runs)
+			]
+			output.append(coalesce_ss_results(model_name_pair[0], ss_results))
+		return output
+
+
+def coalesce_ss_results(
+	model_name: str, results: Sequence[SubsetSimulationResult]
+) -> MultiSubsetSimulationResult:
+
+	num_finished = sum(1 for res in results if res.under_target_likelihood is not None)
+
+	estimated_likelihoods = numpy.array(
+		[
+			res.under_target_likelihood
+			if res.under_target_likelihood is not None
+			else res.lowest_likelihood
+			for res in results
+		]
+	)
+
+	_logger.info(estimated_likelihoods)
+	geometric_mean_estimated_likelihoods = numpy.exp(
+		numpy.log(estimated_likelihoods).mean()
+	)
+	_logger.info(geometric_mean_estimated_likelihoods)
+	arithmetic_mean_estimated_likelihoods = estimated_likelihoods.mean()
+
+	result = MultiSubsetSimulationResult(
+		child_results=results,
+		model_name=model_name,
+		estimated_likelihood=geometric_mean_estimated_likelihoods,
+		arithmetic_mean_estimated_likelihood=arithmetic_mean_estimated_likelihoods,
+		num_children=len(results),
+		num_finished_children=num_finished,
+		clean_estimate=num_finished == len(results),
+	)
+	return result
+
+
 def reverse_bisect_right(a, x, lo=0, hi=None):
 	"""Return the index where to insert item x in list a, assuming a is sorted in descending order.
 

flake.nix

@@ -36,6 +36,7 @@
 	    self.packages.${system}.deepdogEnv
 	    self.packages.${system}.deepdogApp
 	    pkgs.just
+	    pkgs.nodejs
 	  ];
 	  shellHook = ''
 	    export DO_NIX_CUSTOM=1

justfile

@@ -46,9 +46,15 @@ fmt:
 	find deepdog -type f -name "*.py" -exec sed -i -e 's/    /\t/g' {} \;
 	find tests -type f -name "*.py" -exec sed -i -e 's/    /\t/g' {} \;
 
-# release the app, checking that our working tree is clean and ready for release
+# release the app, checking that our working tree is clean and ready for release, optionally takes target version
-release:
+release version="":
+	#!/usr/bin/env bash
+	set -euxo pipefail
+	if [[ -n "{{version}}" ]]; then
+		./scripts/release.sh {{version}}
+	else
 		./scripts/release.sh
+	fi
 
 htmlcov:
 	poetry run pytest --cov-report=html

poetry.lock

@@ -1,5 +1,20 @@
 # This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand.
 
+[[package]]
+name = "backports-tarfile"
+version = "1.1.1"
+description = "Backport of CPython tarfile module"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "backports.tarfile-1.1.1-py3-none-any.whl", hash = "sha256:73e0179647803d3726d82e76089d01d8549ceca9bace469953fcb4d97cf2d417"},
+    {file = "backports_tarfile-1.1.1.tar.gz", hash = "sha256:9c2ef9696cb73374f7164e17fc761389393ca76777036f5aad42e8b93fcd8009"},
+]
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["jaraco.test", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)"]
+
 [[package]]
 name = "black"
 version = "22.12.0"
@@ -250,63 +265,63 @@ files = [
 
 [[package]]
 name = "coverage"
-version = "7.4.3"
+version = "7.5.0"
 description = "Code coverage measurement for Python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "coverage-7.4.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8580b827d4746d47294c0e0b92854c85a92c2227927433998f0d3320ae8a71b6"},
+    {file = "coverage-7.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:432949a32c3e3f820af808db1833d6d1631664d53dd3ce487aa25d574e18ad1c"},
-    {file = "coverage-7.4.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:718187eeb9849fc6cc23e0d9b092bc2348821c5e1a901c9f8975df0bc785bfd4"},
+    {file = "coverage-7.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2bd7065249703cbeb6d4ce679c734bef0ee69baa7bff9724361ada04a15b7e3b"},
-    {file = "coverage-7.4.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:767b35c3a246bcb55b8044fd3a43b8cd553dd1f9f2c1eeb87a302b1f8daa0524"},
+    {file = "coverage-7.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbfe6389c5522b99768a93d89aca52ef92310a96b99782973b9d11e80511f932"},
-    {file = "coverage-7.4.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae7f19afe0cce50039e2c782bff379c7e347cba335429678450b8fe81c4ef96d"},
+    {file = "coverage-7.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:39793731182c4be939b4be0cdecde074b833f6171313cf53481f869937129ed3"},
-    {file = "coverage-7.4.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba3a8aaed13770e970b3df46980cb068d1c24af1a1968b7818b69af8c4347efb"},
+    {file = "coverage-7.5.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85a5dbe1ba1bf38d6c63b6d2c42132d45cbee6d9f0c51b52c59aa4afba057517"},
-    {file = "coverage-7.4.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ee866acc0861caebb4f2ab79f0b94dbfbdbfadc19f82e6e9c93930f74e11d7a0"},
+    {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:357754dcdfd811462a725e7501a9b4556388e8ecf66e79df6f4b988fa3d0b39a"},
-    {file = "coverage-7.4.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:506edb1dd49e13a2d4cac6a5173317b82a23c9d6e8df63efb4f0380de0fbccbc"},
+    {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a81eb64feded34f40c8986869a2f764f0fe2db58c0530d3a4afbcde50f314880"},
-    {file = "coverage-7.4.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd6545d97c98a192c5ac995d21c894b581f1fd14cf389be90724d21808b657e2"},
+    {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:51431d0abbed3a868e967f8257c5faf283d41ec882f58413cf295a389bb22e58"},
-    {file = "coverage-7.4.3-cp310-cp310-win32.whl", hash = "sha256:f6a09b360d67e589236a44f0c39218a8efba2593b6abdccc300a8862cffc2f94"},
+    {file = "coverage-7.5.0-cp310-cp310-win32.whl", hash = "sha256:f609ebcb0242d84b7adeee2b06c11a2ddaec5464d21888b2c8255f5fd6a98ae4"},
-    {file = "coverage-7.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:18d90523ce7553dd0b7e23cbb28865db23cddfd683a38fb224115f7826de78d0"},
+    {file = "coverage-7.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:6782cd6216fab5a83216cc39f13ebe30adfac2fa72688c5a4d8d180cd52e8f6a"},
-    {file = "coverage-7.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbbe5e739d45a52f3200a771c6d2c7acf89eb2524890a4a3aa1a7fa0695d2a47"},
+    {file = "coverage-7.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e768d870801f68c74c2b669fc909839660180c366501d4cc4b87efd6b0eee375"},
-    {file = "coverage-7.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:489763b2d037b164846ebac0cbd368b8a4ca56385c4090807ff9fad817de4113"},
+    {file = "coverage-7.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:84921b10aeb2dd453247fd10de22907984eaf80901b578a5cf0bb1e279a587cb"},
-    {file = "coverage-7.4.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:451f433ad901b3bb00184d83fd83d135fb682d780b38af7944c9faeecb1e0bfe"},
+    {file = "coverage-7.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:710c62b6e35a9a766b99b15cdc56d5aeda0914edae8bb467e9c355f75d14ee95"},
-    {file = "coverage-7.4.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fcc66e222cf4c719fe7722a403888b1f5e1682d1679bd780e2b26c18bb648cdc"},
+    {file = "coverage-7.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c379cdd3efc0658e652a14112d51a7668f6bfca7445c5a10dee7eabecabba19d"},
-    {file = "coverage-7.4.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3ec74cfef2d985e145baae90d9b1b32f85e1741b04cd967aaf9cfa84c1334f3"},
+    {file = "coverage-7.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fea9d3ca80bcf17edb2c08a4704259dadac196fe5e9274067e7a20511fad1743"},
-    {file = "coverage-7.4.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:abbbd8093c5229c72d4c2926afaee0e6e3140de69d5dcd918b2921f2f0c8baba"},
+    {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:41327143c5b1d715f5f98a397608f90ab9ebba606ae4e6f3389c2145410c52b1"},
-    {file = "coverage-7.4.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:35eb581efdacf7b7422af677b92170da4ef34500467381e805944a3201df2079"},
+    {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:565b2e82d0968c977e0b0f7cbf25fd06d78d4856289abc79694c8edcce6eb2de"},
-    {file = "coverage-7.4.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8249b1c7334be8f8c3abcaaa996e1e4927b0e5a23b65f5bf6cfe3180d8ca7840"},
+    {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cf3539007202ebfe03923128fedfdd245db5860a36810136ad95a564a2fdffff"},
-    {file = "coverage-7.4.3-cp311-cp311-win32.whl", hash = "sha256:cf30900aa1ba595312ae41978b95e256e419d8a823af79ce670835409fc02ad3"},
+    {file = "coverage-7.5.0-cp311-cp311-win32.whl", hash = "sha256:bf0b4b8d9caa8d64df838e0f8dcf68fb570c5733b726d1494b87f3da85db3a2d"},
-    {file = "coverage-7.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:18c7320695c949de11a351742ee001849912fd57e62a706d83dfc1581897fa2e"},
+    {file = "coverage-7.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:9c6384cc90e37cfb60435bbbe0488444e54b98700f727f16f64d8bfda0b84656"},
-    {file = "coverage-7.4.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b51bfc348925e92a9bd9b2e48dad13431b57011fd1038f08316e6bf1df107d10"},
+    {file = "coverage-7.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fed7a72d54bd52f4aeb6c6e951f363903bd7d70bc1cad64dd1f087980d309ab9"},
-    {file = "coverage-7.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d6cdecaedea1ea9e033d8adf6a0ab11107b49571bbb9737175444cea6eb72328"},
+    {file = "coverage-7.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cbe6581fcff7c8e262eb574244f81f5faaea539e712a058e6707a9d272fe5b64"},
-    {file = "coverage-7.4.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b2eccb883368f9e972e216c7b4c7c06cabda925b5f06dde0650281cb7666a30"},
+    {file = "coverage-7.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad97ec0da94b378e593ef532b980c15e377df9b9608c7c6da3506953182398af"},
-    {file = "coverage-7.4.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c00cdc8fa4e50e1cc1f941a7f2e3e0f26cb2a1233c9696f26963ff58445bac7"},
+    {file = "coverage-7.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd4bacd62aa2f1a1627352fe68885d6ee694bdaebb16038b6e680f2924a9b2cc"},
-    {file = "coverage-7.4.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b9a4a8dd3dcf4cbd3165737358e4d7dfbd9d59902ad11e3b15eebb6393b0446e"},
+    {file = "coverage-7.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:adf032b6c105881f9d77fa17d9eebe0ad1f9bfb2ad25777811f97c5362aa07f2"},
-    {file = "coverage-7.4.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:062b0a75d9261e2f9c6d071753f7eef0fc9caf3a2c82d36d76667ba7b6470003"},
+    {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4ba01d9ba112b55bfa4b24808ec431197bb34f09f66f7cb4fd0258ff9d3711b1"},
-    {file = "coverage-7.4.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:ebe7c9e67a2d15fa97b77ea6571ce5e1e1f6b0db71d1d5e96f8d2bf134303c1d"},
+    {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:f0bfe42523893c188e9616d853c47685e1c575fe25f737adf473d0405dcfa7eb"},
-    {file = "coverage-7.4.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c0a120238dd71c68484f02562f6d446d736adcc6ca0993712289b102705a9a3a"},
+    {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a9a7ef30a1b02547c1b23fa9a5564f03c9982fc71eb2ecb7f98c96d7a0db5cf2"},
-    {file = "coverage-7.4.3-cp312-cp312-win32.whl", hash = "sha256:37389611ba54fd6d278fde86eb2c013c8e50232e38f5c68235d09d0a3f8aa352"},
+    {file = "coverage-7.5.0-cp312-cp312-win32.whl", hash = "sha256:3c2b77f295edb9fcdb6a250f83e6481c679335ca7e6e4a955e4290350f2d22a4"},
-    {file = "coverage-7.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:d25b937a5d9ffa857d41be042b4238dd61db888533b53bc76dc082cb5a15e914"},
+    {file = "coverage-7.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:427e1e627b0963ac02d7c8730ca6d935df10280d230508c0ba059505e9233475"},
-    {file = "coverage-7.4.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:28ca2098939eabab044ad68850aac8f8db6bf0b29bc7f2887d05889b17346454"},
+    {file = "coverage-7.5.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9dd88fce54abbdbf4c42fb1fea0e498973d07816f24c0e27a1ecaf91883ce69e"},
-    {file = "coverage-7.4.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:280459f0a03cecbe8800786cdc23067a8fc64c0bd51dc614008d9c36e1659d7e"},
+    {file = "coverage-7.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a898c11dca8f8c97b467138004a30133974aacd572818c383596f8d5b2eb04a9"},
-    {file = "coverage-7.4.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c0cdedd3500e0511eac1517bf560149764b7d8e65cb800d8bf1c63ebf39edd2"},
+    {file = "coverage-7.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07dfdd492d645eea1bd70fb1d6febdcf47db178b0d99161d8e4eed18e7f62fe7"},
-    {file = "coverage-7.4.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a9babb9466fe1da12417a4aed923e90124a534736de6201794a3aea9d98484e"},
+    {file = "coverage-7.5.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3d117890b6eee85887b1eed41eefe2e598ad6e40523d9f94c4c4b213258e4a4"},
-    {file = "coverage-7.4.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dec9de46a33cf2dd87a5254af095a409ea3bf952d85ad339751e7de6d962cde6"},
+    {file = "coverage-7.5.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6afd2e84e7da40fe23ca588379f815fb6dbbb1b757c883935ed11647205111cb"},
-    {file = "coverage-7.4.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:16bae383a9cc5abab9bb05c10a3e5a52e0a788325dc9ba8499e821885928968c"},
+    {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a9960dd1891b2ddf13a7fe45339cd59ecee3abb6b8326d8b932d0c5da208104f"},
-    {file = "coverage-7.4.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:2c854ce44e1ee31bda4e318af1dbcfc929026d12c5ed030095ad98197eeeaed0"},
+    {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ced268e82af993d7801a9db2dbc1d2322e786c5dc76295d8e89473d46c6b84d4"},
-    {file = "coverage-7.4.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:ce8c50520f57ec57aa21a63ea4f325c7b657386b3f02ccaedeccf9ebe27686e1"},
+    {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e7c211f25777746d468d76f11719e64acb40eed410d81c26cefac641975beb88"},
-    {file = "coverage-7.4.3-cp38-cp38-win32.whl", hash = "sha256:708a3369dcf055c00ddeeaa2b20f0dd1ce664eeabde6623e516c5228b753654f"},
+    {file = "coverage-7.5.0-cp38-cp38-win32.whl", hash = "sha256:262fffc1f6c1a26125d5d573e1ec379285a3723363f3bd9c83923c9593a2ac25"},
-    {file = "coverage-7.4.3-cp38-cp38-win_amd64.whl", hash = "sha256:1bf25fbca0c8d121a3e92a2a0555c7e5bc981aee5c3fdaf4bb7809f410f696b9"},
+    {file = "coverage-7.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:eed462b4541c540d63ab57b3fc69e7d8c84d5957668854ee4e408b50e92ce26a"},
-    {file = "coverage-7.4.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3b253094dbe1b431d3a4ac2f053b6d7ede2664ac559705a704f621742e034f1f"},
+    {file = "coverage-7.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d0194d654e360b3e6cc9b774e83235bae6b9b2cac3be09040880bb0e8a88f4a1"},
-    {file = "coverage-7.4.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:77fbfc5720cceac9c200054b9fab50cb2a7d79660609200ab83f5db96162d20c"},
+    {file = "coverage-7.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:33c020d3322662e74bc507fb11488773a96894aa82a622c35a5a28673c0c26f5"},
-    {file = "coverage-7.4.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6679060424faa9c11808598504c3ab472de4531c571ab2befa32f4971835788e"},
+    {file = "coverage-7.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbdf2cae14a06827bec50bd58e49249452d211d9caddd8bd80e35b53cb04631"},
-    {file = "coverage-7.4.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4af154d617c875b52651dd8dd17a31270c495082f3d55f6128e7629658d63765"},
+    {file = "coverage-7.5.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3235d7c781232e525b0761730e052388a01548bd7f67d0067a253887c6e8df46"},
-    {file = "coverage-7.4.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8640f1fde5e1b8e3439fe482cdc2b0bb6c329f4bb161927c28d2e8879c6029ee"},
+    {file = "coverage-7.5.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2de4e546f0ec4b2787d625e0b16b78e99c3e21bc1722b4977c0dddf11ca84e"},
-    {file = "coverage-7.4.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:69b9f6f66c0af29642e73a520b6fed25ff9fd69a25975ebe6acb297234eda501"},
+    {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:4d0e206259b73af35c4ec1319fd04003776e11e859936658cb6ceffdeba0f5be"},
-    {file = "coverage-7.4.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:0842571634f39016a6c03e9d4aba502be652a6e4455fadb73cd3a3a49173e38f"},
+    {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:2055c4fb9a6ff624253d432aa471a37202cd8f458c033d6d989be4499aed037b"},
-    {file = "coverage-7.4.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a78ed23b08e8ab524551f52953a8a05d61c3a760781762aac49f8de6eede8c45"},
+    {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:075299460948cd12722a970c7eae43d25d37989da682997687b34ae6b87c0ef0"},
-    {file = "coverage-7.4.3-cp39-cp39-win32.whl", hash = "sha256:c0524de3ff096e15fcbfe8f056fdb4ea0bf497d584454f344d59fce069d3e6e9"},
+    {file = "coverage-7.5.0-cp39-cp39-win32.whl", hash = "sha256:280132aada3bc2f0fac939a5771db4fbb84f245cb35b94fae4994d4c1f80dae7"},
-    {file = "coverage-7.4.3-cp39-cp39-win_amd64.whl", hash = "sha256:0209a6369ccce576b43bb227dc8322d8ef9e323d089c6f3f26a597b09cb4d2aa"},
+    {file = "coverage-7.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:c58536f6892559e030e6924896a44098bc1290663ea12532c78cef71d0df8493"},
-    {file = "coverage-7.4.3-pp38.pp39.pp310-none-any.whl", hash = "sha256:7cbde573904625509a3f37b6fecea974e363460b556a627c60dc2f47e2fffa51"},
+    {file = "coverage-7.5.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:2b57780b51084d5223eee7b59f0d4911c31c16ee5aa12737c7a02455829ff067"},
-    {file = "coverage-7.4.3.tar.gz", hash = "sha256:276f6077a5c61447a48d133ed13e759c09e62aff0dc84274a68dc18660104d52"},
+    {file = "coverage-7.5.0.tar.gz", hash = "sha256:cf62d17310f34084c59c01e027259076479128d11e4661bb6c9acb38c5e19bb8"},
 ]
 
 [package.dependencies]
@@ -393,13 +408,13 @@ files = [
 
 [[package]]
 name = "exceptiongroup"
-version = "1.2.0"
+version = "1.2.1"
 description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"},
+    {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"},
-    {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"},
+    {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"},
 ]
 
 [package.extras]
@@ -437,60 +452,61 @@ smmap = ">=3.0.1,<6"
 
 [[package]]
 name = "gitpython"
-version = "3.1.42"
+version = "3.1.43"
 description = "GitPython is a Python library used to interact with Git repositories"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "GitPython-3.1.42-py3-none-any.whl", hash = "sha256:1bf9cd7c9e7255f77778ea54359e54ac22a72a5b51288c457c881057b7bb9ecd"},
+    {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"},
-    {file = "GitPython-3.1.42.tar.gz", hash = "sha256:2d99869e0fef71a73cbd242528105af1d6c1b108c60dfabd994bf292f76c3ceb"},
+    {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"},
 ]
 
 [package.dependencies]
 gitdb = ">=4.0.1,<5"
 
 [package.extras]
-test = ["black", "coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar"]
+doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"]
+test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"]
 
 [[package]]
 name = "idna"
-version = "3.6"
+version = "3.7"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.5"
 files = [
-    {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"},
+    {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"},
-    {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"},
+    {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"},
 ]
 
 [[package]]
 name = "importlib-metadata"
-version = "7.0.1"
+version = "7.1.0"
 description = "Read metadata from Python packages"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "importlib_metadata-7.0.1-py3-none-any.whl", hash = "sha256:4805911c3a4ec7c3966410053e9ec6a1fecd629117df5adee56dfc9432a1081e"},
+    {file = "importlib_metadata-7.1.0-py3-none-any.whl", hash = "sha256:30962b96c0c223483ed6cc7280e7f0199feb01a0e40cfae4d4450fc6fab1f570"},
-    {file = "importlib_metadata-7.0.1.tar.gz", hash = "sha256:f238736bb06590ae52ac1fab06a3a9ef1d8dce2b7a35b5ab329371d6c8f5d2cc"},
+    {file = "importlib_metadata-7.1.0.tar.gz", hash = "sha256:b78938b926ee8d5f020fc4772d487045805a55ddbad2ecf21c6d60938dc7fcd2"},
 ]
 
 [package.dependencies]
 zipp = ">=0.5"
 
 [package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 perf = ["ipython"]
-testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"]
+testing = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
 
 [[package]]
 name = "importlib-resources"
-version = "6.1.2"
+version = "6.4.0"
 description = "Read resources from Python packages"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "importlib_resources-6.1.2-py3-none-any.whl", hash = "sha256:9a0a862501dc38b68adebc82970140c9e4209fc99601782925178f8386339938"},
+    {file = "importlib_resources-6.4.0-py3-none-any.whl", hash = "sha256:50d10f043df931902d4194ea07ec57960f66a80449ff867bfe782b4c486ba78c"},
-    {file = "importlib_resources-6.1.2.tar.gz", hash = "sha256:308abf8474e2dba5f867d279237cd4076482c3de7104a40b41426370e891549b"},
+    {file = "importlib_resources-6.4.0.tar.gz", hash = "sha256:cdb2b453b8046ca4e3798eb1d84f3cce1446a0e8e7b5ef4efb600f19fc398145"},
 ]
 
 [package.dependencies]
@@ -498,7 +514,7 @@ zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""}
 
 [package.extras]
 docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)", "zipp (>=3.17)"]
+testing = ["jaraco.test (>=5.4)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)", "zipp (>=3.17)"]
 
 [[package]]
 name = "iniconfig"
@@ -523,14 +539,50 @@ files = [
 ]
 
 [[package]]
-name = "jaraco.classes"
+name = "jaraco-classes"
-version = "3.3.1"
+version = "3.4.0"
 description = "Utility functions for Python class constructs"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "jaraco.classes-3.3.1-py3-none-any.whl", hash = "sha256:86b534de565381f6b3c1c830d13f931d7be1a75f0081c57dff615578676e2206"},
+    {file = "jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790"},
-    {file = "jaraco.classes-3.3.1.tar.gz", hash = "sha256:cb28a5ebda8bc47d8c8015307d93163464f9f2b91ab4006e09ff0ce07e8bfb30"},
+    {file = "jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd"},
+]
+
+[package.dependencies]
+more-itertools = "*"
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+
+[[package]]
+name = "jaraco-context"
+version = "5.3.0"
+description = "Useful decorators and context managers"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "jaraco.context-5.3.0-py3-none-any.whl", hash = "sha256:3e16388f7da43d384a1a7cd3452e72e14732ac9fe459678773a3608a812bf266"},
+    {file = "jaraco.context-5.3.0.tar.gz", hash = "sha256:c2f67165ce1f9be20f32f650f25d8edfc1646a8aeee48ae06fb35f90763576d2"},
+]
+
+[package.dependencies]
+"backports.tarfile" = {version = "*", markers = "python_version < \"3.12\""}
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["portend", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+
+[[package]]
+name = "jaraco-functools"
+version = "4.0.1"
+description = "Functools like those found in stdlib"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "jaraco.functools-4.0.1-py3-none-any.whl", hash = "sha256:3b24ccb921d6b593bdceb56ce14799204f473976e2a9d4b15b04d0f2c2326664"},
+    {file = "jaraco_functools-4.0.1.tar.gz", hash = "sha256:d33fa765374c0611b52f8b3a795f8900869aa88c84769d4d1746cd68fb28c3e8"},
 ]
 
 [package.dependencies]
@@ -538,7 +590,7 @@ more-itertools = "*"
 
 [package.extras]
 docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+testing = ["jaraco.classes", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
 
 [[package]]
 name = "jeepney"
@@ -557,27 +609,29 @@ trio = ["async_generator", "trio"]
 
 [[package]]
 name = "keyring"
-version = "24.3.1"
+version = "25.2.0"
 description = "Store and access your passwords safely."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "keyring-24.3.1-py3-none-any.whl", hash = "sha256:df38a4d7419a6a60fea5cef1e45a948a3e8430dd12ad88b0f423c5c143906218"},
+    {file = "keyring-25.2.0-py3-none-any.whl", hash = "sha256:19f17d40335444aab84b19a0d16a77ec0758a9c384e3446ae2ed8bd6d53b67a5"},
-    {file = "keyring-24.3.1.tar.gz", hash = "sha256:c3327b6ffafc0e8befbdb597cacdb4928ffe5c1212f7645f186e6d9957a898db"},
+    {file = "keyring-25.2.0.tar.gz", hash = "sha256:7045f367268ce42dba44745050164b431e46f6e92f99ef2937dfadaef368d8cf"},
 ]
 
 [package.dependencies]
 importlib-metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""}
 importlib-resources = {version = "*", markers = "python_version < \"3.9\""}
 "jaraco.classes" = "*"
+"jaraco.context" = "*"
+"jaraco.functools" = "*"
 jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""}
 pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""}
 SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""}
 
 [package.extras]
 completion = ["shtab (>=1.1.0)"]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+testing = ["pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
 
 [[package]]
 name = "mccabe"
@@ -656,27 +710,27 @@ files = [
 
 [[package]]
 name = "nh3"
-version = "0.2.15"
+version = "0.2.17"
 description = "Python bindings to the ammonia HTML sanitization library."
 optional = false
 python-versions = "*"
 files = [
-    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9c0d415f6b7f2338f93035bba5c0d8c1b464e538bfbb1d598acd47d7969284f0"},
+    {file = "nh3-0.2.17-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:551672fd71d06cd828e282abdb810d1be24e1abb7ae2543a8fa36a71c1006fe9"},
-    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6f42f99f0cf6312e470b6c09e04da31f9abaadcd3eb591d7d1a88ea931dca7f3"},
+    {file = "nh3-0.2.17-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c551eb2a3876e8ff2ac63dff1585236ed5dfec5ffd82216a7a174f7c5082a78a"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac19c0d68cd42ecd7ead91a3a032fdfff23d29302dbb1311e641a130dfefba97"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:66f17d78826096291bd264f260213d2b3905e3c7fae6dfc5337d49429f1dc9f3"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f0d77272ce6d34db6c87b4f894f037d55183d9518f948bba236fe81e2bb4e28"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0316c25b76289cf23be6b66c77d3608a4fdf537b35426280032f432f14291b9a"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8d595df02413aa38586c24811237e95937ef18304e108b7e92c890a06793e3bf"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:22c26e20acbb253a5bdd33d432a326d18508a910e4dcf9a3316179860d53345a"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86e447a63ca0b16318deb62498db4f76fc60699ce0a1231262880b38b6cff911"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:85cdbcca8ef10733bd31f931956f7fbb85145a4d11ab9e6742bbf44d88b7e351"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3277481293b868b2715907310c7be0f1b9d10491d5adf9fce11756a97e97eddf"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:40015514022af31975c0b3bca4014634fa13cb5dc4dbcbc00570acc781316dcc"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60684857cfa8fdbb74daa867e5cad3f0c9789415aba660614fe16cd66cbb9ec7"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba73a2f8d3a1b966e9cdba7b211779ad8a2561d2dba9674b8a19ed817923f65f"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3b803a5875e7234907f7d64777dfde2b93db992376f3d6d7af7f3bc347deb305"},
+    {file = "nh3-0.2.17-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c21bac1a7245cbd88c0b0e4a420221b7bfa838a2814ee5bb924e9c2f10a1120b"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0d02d0ff79dfd8208ed25a39c12cbda092388fff7f1662466e27d97ad011b770"},
+    {file = "nh3-0.2.17-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d7a25fd8c86657f5d9d576268e3b3767c5cd4f42867c9383618be8517f0f022a"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f3b53ba93bb7725acab1e030bc2ecd012a817040fd7851b332f86e2f9bb98dc6"},
+    {file = "nh3-0.2.17-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c790769152308421283679a142dbdb3d1c46c79c823008ecea8e8141db1a2062"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:b1e97221cedaf15a54f5243f2c5894bb12ca951ae4ddfd02a9d4ea9df9e1a29d"},
+    {file = "nh3-0.2.17-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:b4427ef0d2dfdec10b641ed0bdaf17957eb625b2ec0ea9329b3d28806c153d71"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5167a6403d19c515217b6bcaaa9be420974a6ac30e0da9e84d4fc67a5d474c5"},
+    {file = "nh3-0.2.17-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a3f55fabe29164ba6026b5ad5c3151c314d136fd67415a17660b4aaddacf1b10"},
-    {file = "nh3-0.2.15-cp37-abi3-win32.whl", hash = "sha256:427fecbb1031db085eaac9931362adf4a796428ef0163070c484b5a768e71601"},
+    {file = "nh3-0.2.17-cp37-abi3-win32.whl", hash = "sha256:1a814dd7bba1cb0aba5bcb9bebcc88fd801b63e21e2450ae6c52d3b3336bc911"},
-    {file = "nh3-0.2.15-cp37-abi3-win_amd64.whl", hash = "sha256:bc2d086fb540d0fa52ce35afaded4ea526b8fc4d3339f783db55c95de40ef02e"},
+    {file = "nh3-0.2.17-cp37-abi3-win_amd64.whl", hash = "sha256:1aa52a7def528297f256de0844e8dd680ee279e79583c76d6fa73a978186ddfb"},
-    {file = "nh3-0.2.15.tar.gz", hash = "sha256:d1e30ff2d8d58fb2a14961f7aac1bbb1c51f9bdd7da727be35c63826060b0bf3"},
+    {file = "nh3-0.2.17.tar.gz", hash = "sha256:40d0741a19c3d645e54efba71cb0d8c475b59135c1e3c580f879ad5514cbf028"},
 ]
 
 [[package]]
@@ -710,13 +764,13 @@ files = [
 
 [[package]]
 name = "packaging"
-version = "23.2"
+version = "24.0"
 description = "Core utilities for Python packages"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
+    {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"},
-    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+    {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"},
 ]
 
 [[package]]
@@ -732,13 +786,13 @@ files = [
 
 [[package]]
 name = "pdme"
-version = "0.9.3"
+version = "1.5.0"
 description = "Python dipole model evaluator"
 optional = false
-python-versions = ">=3.8.1,<3.10"
+python-versions = "<3.10,>=3.8.1"
 files = [
-    {file = "pdme-0.9.3-py3-none-any.whl", hash = "sha256:0a11caa8ce18829695fa0457bbfc4d15210945fcb58be05ffb96eda8fdd7e9c8"},
+    {file = "pdme-1.5.0-py3-none-any.whl", hash = "sha256:1b4fa30ba98a336957b3029563552d73286a3a5f932809ac1330e65a1f61c363"},
-    {file = "pdme-0.9.3.tar.gz", hash = "sha256:0de948e301780e79bbe78887be8ac4165899cbca32fa845a1ace8c08e72e300b"},
+    {file = "pdme-1.5.0.tar.gz", hash = "sha256:cc0ac4ffab2994e08b4efde2991c6d9dccb2942c7e33c4be3b52e068366526d1"},
 ]
 
 [package.dependencies]
@@ -747,42 +801,43 @@ scipy = ">=1.10,<1.11"
 
 [[package]]
 name = "pkginfo"
-version = "1.9.6"
+version = "1.10.0"
 description = "Query metadata from sdists / bdists / installed packages."
 optional = false
 python-versions = ">=3.6"
 files = [
-    {file = "pkginfo-1.9.6-py3-none-any.whl", hash = "sha256:4b7a555a6d5a22169fcc9cf7bfd78d296b0361adad412a346c1226849af5e546"},
+    {file = "pkginfo-1.10.0-py3-none-any.whl", hash = "sha256:889a6da2ed7ffc58ab5b900d888ddce90bce912f2d2de1dc1c26f4cb9fe65097"},
-    {file = "pkginfo-1.9.6.tar.gz", hash = "sha256:8fd5896e8718a4372f0ea9cc9d96f6417c9b986e23a4d116dda26b62cc29d046"},
+    {file = "pkginfo-1.10.0.tar.gz", hash = "sha256:5df73835398d10db79f8eecd5cd86b1f6d29317589ea70796994d49399af6297"},
 ]
 
 [package.extras]
-testing = ["pytest", "pytest-cov"]
+testing = ["pytest", "pytest-cov", "wheel"]
 
 [[package]]
 name = "platformdirs"
-version = "4.2.0"
+version = "4.2.1"
-description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"},
+    {file = "platformdirs-4.2.1-py3-none-any.whl", hash = "sha256:17d5a1161b3fd67b390023cb2d3b026bbd40abde6fdb052dfbd3a29c3ba22ee1"},
-    {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"},
+    {file = "platformdirs-4.2.1.tar.gz", hash = "sha256:031cd18d4ec63ec53e82dceaac0417d218a6863f7745dfcc9efe7793b7039bdf"},
 ]
 
 [package.extras]
 docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
 test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
+type = ["mypy (>=1.8)"]
 
 [[package]]
 name = "pluggy"
-version = "1.4.0"
+version = "1.5.0"
 description = "plugin and hook calling mechanisms for python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"},
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
-    {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
 ]
 
 [package.extras]
@@ -802,13 +857,13 @@ files = [
 
 [[package]]
 name = "pycparser"
-version = "2.21"
+version = "2.22"
 description = "C parser in Python"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+python-versions = ">=3.8"
 files = [
-    {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"},
+    {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"},
-    {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"},
+    {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"},
 ]
 
 [[package]]
@@ -839,13 +894,13 @@ windows-terminal = ["colorama (>=0.4.6)"]
 
 [[package]]
 name = "pytest"
-version = "8.0.2"
+version = "8.2.0"
 description = "pytest: simple powerful testing with Python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pytest-8.0.2-py3-none-any.whl", hash = "sha256:edfaaef32ce5172d5466b5127b42e0d6d35ebbe4453f0e3505d96afd93f6b096"},
+    {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"},
-    {file = "pytest-8.0.2.tar.gz", hash = "sha256:d4051d623a2e0b7e51960ba963193b09ce6daeb9759a451844a21e4ddedfc1bd"},
+    {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"},
 ]
 
 [package.dependencies]
@@ -853,11 +908,11 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""}
 exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
 iniconfig = "*"
 packaging = "*"
-pluggy = ">=1.3.0,<2.0"
+pluggy = ">=1.5,<2.0"
-tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
+tomli = {version = ">=1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
 [[package]]
 name = "pytest-cov"
@@ -1162,13 +1217,13 @@ urllib3 = ">=1.26.0"
 
 [[package]]
 name = "typing-extensions"
-version = "4.10.0"
+version = "4.11.0"
 description = "Backported and Experimental Type Hints for Python 3.8+"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "typing_extensions-4.10.0-py3-none-any.whl", hash = "sha256:69b1a937c3a517342112fb4c6df7e72fc39a38e7891a5730ed4985b5214b5475"},
+    {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"},
-    {file = "typing_extensions-4.10.0.tar.gz", hash = "sha256:b0abd7c89e8fb96f98db18d86106ff1d90ab692004eb746cf6eda2682f91b3cb"},
+    {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"},
 ]
 
 [[package]]
@@ -1204,20 +1259,20 @@ test = ["pytest (>=6.0.0)", "setuptools (>=65)"]
 
 [[package]]
 name = "zipp"
-version = "3.17.0"
+version = "3.18.1"
 description = "Backport of pathlib-compatible object wrapper for zip files"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "zipp-3.17.0-py3-none-any.whl", hash = "sha256:0e923e726174922dce09c53c59ad483ff7bbb8e572e00c7f7c46b88556409f31"},
+    {file = "zipp-3.18.1-py3-none-any.whl", hash = "sha256:206f5a15f2af3dbaee80769fb7dc6f249695e940acca08dfb2a4769fe61e538b"},
-    {file = "zipp-3.17.0.tar.gz", hash = "sha256:84e64a1c28cf7e91ed2078bb8cc8c259cb19b76942096c8d7b84947690cabaf0"},
+    {file = "zipp-3.18.1.tar.gz", hash = "sha256:2884ed22e7d8961de1c9a05142eb69a247f120291bc0206a00a7642f09b5b715"},
 ]
 
 [package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"]
+testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
 
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.8.1,<3.10"
-content-hash = "828610d9447294e707a6df2affb6ee7947e2be3b567371217265a8b94a9768f6"
+content-hash = "85114054176aa164964acea6fdc085581ee7fc2f94c1cd03ad77611b82e52c79"

pyproject.toml

@@ -1,19 +1,19 @@
 [tool.poetry]
 name = "deepdog"
-version = "0.8.1"
+version = "1.3.0"
 description = ""
 authors = ["Deepak Mallubhotla <dmallubhotla+github@gmail.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.8.1,<3.10"
-pdme = "^0.9.3"
+pdme = "^1.5.0"
 numpy = "1.22.3"
 scipy = "1.10"
 tqdm = "^4.66.2"
 
 [tool.poetry.dev-dependencies]
 pytest = ">=6"
-flake8 = "^7.0.0"
+flake8 = "^4.0.1"
 pytest-cov = "^4.1.0"
 mypy = "^0.971"
 python-semantic-release = "^7.24.0"

scripts/release.sh

@@ -25,15 +25,22 @@ if [ -z "$(git status --porcelain)" ]; then
 		exit 0
 	fi
 
+	std_version_args=()
+	if [[ -n "${1:-}" ]]; then
+		std_version_args+=( "--release-as" "$1" )
+		echo "Parameter $1 was supplied, so we should use release-as"
+	else
+		echo "No release-as parameter specifed."
+	fi
 	# Working directory clean
 	echo "Doing a dry run..."
-	npx standard-version --dry-run
+	npx standard-version --dry-run "${std_version_args[@]}"
 	read -p "Does that look good? [y/N] " -n 1 -r
 	echo    # (optional) move to a new line
 	if [[ $REPLY =~ ^[Yy]$ ]]
 	then
 		# do dangerous stuff
-		npx standard-version
+		npx standard-version "${std_version_args[@]}"
 		git push --follow-tags origin master
 	else
 		echo "okay, never mind then..."

tests/direct_monte_carlo/test_cost_function_filter.py

@@ -0,0 +1,42 @@
+import deepdog.direct_monte_carlo.cost_function_filter
+import numpy
+
+
+def test_px_cost_function_filter_example():
+
+	dipoles_1 = [
+		[1, 2, 3, 4, 5, 6, 7],
+		[2, 3, 2, 5, 4, 7, 6],
+	]
+
+	dipoles_2 = [
+		[15, 9, 8, 7, 6, 5, 3],
+		[30, 4, 4, 7, 3, 1, 4],
+	]
+
+	dipoleses = numpy.array([dipoles_1, dipoles_2])
+
+	def cost_function(dipoleses: numpy.ndarray) -> numpy.ndarray:
+		return dipoleses[:, :, 0].max(axis=-1)
+
+	expected_costs = numpy.array([2, 30])
+
+	numpy.testing.assert_array_equal(cost_function(dipoleses), expected_costs)
+
+	filter = deepdog.direct_monte_carlo.cost_function_filter.CostFunctionTargetFilter(
+		cost_function, 5
+	)
+
+	actual_filtered = filter.filter_samples(dipoleses)
+	expected_filtered = numpy.array([dipoles_1])
+	assert actual_filtered.size != 0
+	numpy.testing.assert_array_equal(actual_filtered, expected_filtered)
+
+	filter_stricter = (
+		deepdog.direct_monte_carlo.cost_function_filter.CostFunctionTargetFilter(
+			cost_function, 0.5
+		)
+	)
+
+	actual_filtered_stricter = filter_stricter.filter_samples(dipoleses)
+	assert actual_filtered_stricter.size == 0

tests/direct_monte_carlo/test_eletric_field_x_dmc_filter.py

@@ -0,0 +1,137 @@
+import pdme.measurement
+import pdme.measurement.input_types
+from pdme.model import (
+	LogSpacedRandomCountMultipleDipoleFixedMagnitudeModel,
+	LogSpacedRandomCountMultipleDipoleFixedMagnitudeXYModel,
+	LogSpacedRandomCountMultipleDipoleFixedMagnitudeFixedOrientationModel,
+)
+import deepdog.direct_monte_carlo.dmc_filters
+import numpy.random
+import numpy.testing
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+def fixed_z_model_func(
+	xmin,
+	xmax,
+	ymin,
+	ymax,
+	zmin,
+	zmax,
+	wexp_min,
+	wexp_max,
+	pfixed,
+	n_max,
+	prob_occupancy,
+):
+	return LogSpacedRandomCountMultipleDipoleFixedMagnitudeFixedOrientationModel(
+		xmin,
+		xmax,
+		ymin,
+		ymax,
+		zmin,
+		zmax,
+		wexp_min,
+		wexp_max,
+		pfixed,
+		0,
+		0,
+		n_max,
+		prob_occupancy,
+	)
+
+
+def get_model(orientation):
+	model_funcs = {
+		"fixedz": fixed_z_model_func,
+		"free": LogSpacedRandomCountMultipleDipoleFixedMagnitudeModel,
+		"fixedxy": LogSpacedRandomCountMultipleDipoleFixedMagnitudeXYModel,
+	}
+	model = model_funcs[orientation](
+		-10,
+		10,
+		-17.5,
+		17.5,
+		5,
+		7.5,
+		-5,
+		6.5,
+		10**3,
+		2,
+		0.99999999,
+	)
+	model.n = 2
+	model.rng = numpy.random.default_rng(1234)
+
+	return (
+		f"connors_geom-5height-orientation_{orientation}-pfixexp_{3}-dipole_count_{2}",
+		model,
+	)
+
+
+def test_electric_field_x_dmc_filter():
+
+	dipoles_raw = [
+		[(1, 2, 3), (4, 5, 6), 1],
+		[(-1, 5, 2), (6, 5, 4), 10],
+	]
+	dipoles = [
+		pdme.measurement.OscillatingDipole(numpy.array(d[0]), numpy.array(d[1]), d[2])
+		for d in dipoles_raw
+	]
+
+	_logger.debug(f"dipoles: {dipoles}")
+	dot_inputs_raw = [
+		([-1, -1, 0], 1),
+		([-1, -1, 0], 2),
+		([-1, -1, 0], 3),
+		([-1, -1, 0], 4),
+	]
+	dot_inputs_array = pdme.measurement.input_types.dot_inputs_to_array(dot_inputs_raw)
+	_logger.debug(f"dot_inputs_array: {dot_inputs_array}")
+
+	arrangement = pdme.measurement.OscillatingDipoleArrangement(dipoles)
+	measurements = []
+	for input in dot_inputs_raw:
+		ex = sum(
+			[
+				dipole.s_electric_fieldx_at_position(*input)
+				for dipole in arrangement.dipoles
+			]
+		)
+		ex_low = ex * 0.5
+		ex_high = ex * 1.5
+		meas = pdme.measurement.DotRangeMeasurement(ex_low, ex_high, input[0], input[1])
+		measurements.append(meas)
+
+	filter = deepdog.direct_monte_carlo.dmc_filters.SingleDotSpinQubitFrequencyFilter(
+		measurements
+	)
+
+	samples = numpy.array(
+		[
+			[
+				[1, 2, 3, 4, 5, 6, 1],
+				[-1, 5, 2, 6, 5, 4, 10],
+			],
+			[
+				[10, 20, 30, 40, 50, 60, 1],
+				[-1, 5, 2, 6, 5, 4, 1],
+			],
+			[
+				[1, 1, 1, 1, 1, 1, 1],
+				[2, 2, 2, 2, 2, 2, 1],
+			],
+		]
+	)
+
+	expected = samples[
+		0:1
+	]  # only expect to see the first guy, because that's what generated our thing
+	filtered = filter.filter_samples(samples)
+	assert len(filtered) != len(samples), "Should have filtered some out!"
+	numpy.testing.assert_array_equal(
+		filtered, expected, "The filter should have only returned the first one"
+	)

tests/results/test_column_results.py

@@ -7,6 +7,7 @@ def test_parse_groupdict():
 	)
 
 	parsed = deepdog.results._parse_bayesrun_column(example_column_name)
+	assert parsed is not None
 	expected = deepdog.results.BayesrunColumnParsed(
 		{
 			"xmin": "-20",
@@ -23,6 +24,30 @@ def test_parse_groupdict():
 	assert parsed == expected
 
 
+def test_parse_groupdict_with_magnitude():
+	example_column_name = (
+		"geom_-20_20_-10_10_0_5-magnitude_3.5-orientation_free-dipole_count_100_success"
+	)
+
+	parsed = deepdog.results._parse_bayesrun_column(example_column_name)
+	assert parsed is not None
+	expected = deepdog.results.BayesrunColumnParsed(
+		{
+			"xmin": "-20",
+			"xmax": "20",
+			"ymin": "-10",
+			"ymax": "10",
+			"zmin": "0",
+			"zmax": "5",
+			"orientation": "free",
+			"avg_filled": "100",
+			"log_magnitude": "3.5",
+			"field_name": "success",
+		}
+	)
+	assert parsed == expected
+
+
 # def test_parse_no_match_column_name():
 # 	parsed = deepdog.results.parse_bayesrun_column("There's nothing here")
 # 	assert parsed is None

tests/subset_simulation/__snapshots__/test_subset_simulation_coalescing.ambr

@@ -0,0 +1,10 @@
+# serializer version: 1
+# name: test_subset_simulation_multi_result_coalescing_easy_arithmetic
+  MultiSubsetSimulationResult(child_results=[SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.8, lowest_likelihood=0.5, messages=[]), SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.6, lowest_likelihood=0.01, messages=[])], model_name='test', estimated_likelihood=0.6928203230275509, arithmetic_mean_estimated_likelihood=0.7, num_children=2, num_finished_children=2, clean_estimate=True)
+# ---
+# name: test_subset_simulation_multi_result_coalescing_easy_geometric
+  MultiSubsetSimulationResult(child_results=[SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.1, lowest_likelihood=0.5, messages=[]), SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.001, lowest_likelihood=0.01, messages=[])], model_name='test', estimated_likelihood=0.010000000000000004, arithmetic_mean_estimated_likelihood=0.0505, num_children=2, num_finished_children=2, clean_estimate=True)
+# ---
+# name: test_subset_simulation_multi_result_coalescing_include_dirty
+  MultiSubsetSimulationResult(child_results=[SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.8, lowest_likelihood=0.5, messages=[]), SubsetSimulationResult(probs_list=(), over_target_cost=1, over_target_likelihood=1, under_target_cost=0.99, under_target_likelihood=0.08, lowest_likelihood=0.01, messages=[]), SubsetSimulationResult(probs_list=(), over_target_cost=None, over_target_likelihood=None, under_target_cost=None, under_target_likelihood=None, lowest_likelihood=0.0001, messages=[])], model_name='test', estimated_likelihood=0.01856635533445112, arithmetic_mean_estimated_likelihood=0.29336666666666666, num_children=3, num_finished_children=2, clean_estimate=False)
+# ---

tests/subset_simulation/test_subset_simulation_coalescing.py

@@ -0,0 +1,92 @@
+import deepdog.subset_simulation.subset_simulation_impl as impl
+import numpy
+
+
+def test_subset_simulation_multi_result_coalescing_include_dirty(snapshot):
+	res1 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.8,
+		lowest_likelihood=0.5,
+		messages=[],
+	)
+
+	res2 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.08,
+		lowest_likelihood=0.01,
+		messages=[],
+	)
+
+	res3 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=None,
+		over_target_likelihood=None,
+		under_target_cost=None,
+		under_target_likelihood=None,
+		lowest_likelihood=0.0001,
+		messages=[],
+	)
+
+	combined = impl.coalesce_ss_results("test", [res1, res2, res3])
+
+	assert combined == snapshot
+
+
+def test_subset_simulation_multi_result_coalescing_easy_arithmetic(snapshot):
+	res1 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.8,
+		lowest_likelihood=0.5,
+		messages=[],
+	)
+
+	res2 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.6,
+		lowest_likelihood=0.01,
+		messages=[],
+	)
+
+	combined = impl.coalesce_ss_results("test", [res1, res2])
+
+	assert combined.arithmetic_mean_estimated_likelihood == 0.7
+	assert combined == snapshot
+
+
+def test_subset_simulation_multi_result_coalescing_easy_geometric(snapshot):
+	res1 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.1,
+		lowest_likelihood=0.5,
+		messages=[],
+	)
+
+	res2 = impl.SubsetSimulationResult(
+		probs_list=(),
+		over_target_cost=1,
+		over_target_likelihood=1,
+		under_target_cost=0.99,
+		under_target_likelihood=0.001,
+		lowest_likelihood=0.01,
+		messages=[],
+	)
+
+	combined = impl.coalesce_ss_results("test", [res1, res2])
+
+	numpy.testing.assert_allclose(combined.estimated_likelihood, 0.01)
+	assert combined == snapshot

tests/test_bayes_run_with_ss.py

@@ -1,158 +0,0 @@
-import deepdog
-import logging
-import logging.config
-
-import numpy.random
-
-from pdme.model import (
-	LogSpacedRandomCountMultipleDipoleFixedMagnitudeModel,
-	LogSpacedRandomCountMultipleDipoleFixedMagnitudeXYModel,
-	LogSpacedRandomCountMultipleDipoleFixedMagnitudeFixedOrientationModel,
-)
-
-
-_logger = logging.getLogger(__name__)
-
-
-def fixed_z_model_func(
-	xmin,
-	xmax,
-	ymin,
-	ymax,
-	zmin,
-	zmax,
-	wexp_min,
-	wexp_max,
-	pfixed,
-	n_max,
-	prob_occupancy,
-):
-	return LogSpacedRandomCountMultipleDipoleFixedMagnitudeFixedOrientationModel(
-		xmin,
-		xmax,
-		ymin,
-		ymax,
-		zmin,
-		zmax,
-		wexp_min,
-		wexp_max,
-		pfixed,
-		0,
-		0,
-		n_max,
-		prob_occupancy,
-	)
-
-
-def get_model(orientation):
-	model_funcs = {
-		"fixedz": fixed_z_model_func,
-		"free": LogSpacedRandomCountMultipleDipoleFixedMagnitudeModel,
-		"fixedxy": LogSpacedRandomCountMultipleDipoleFixedMagnitudeXYModel,
-	}
-	model = model_funcs[orientation](
-		-10,
-		10,
-		-17.5,
-		17.5,
-		5,
-		7.5,
-		-5,
-		6.5,
-		10**3,
-		2,
-		0.99999999,
-	)
-	model.n = 2
-	model.rng = numpy.random.default_rng(1234)
-
-	return (
-		f"connors_geom-5height-orientation_{orientation}-pfixexp_{3}-dipole_count_{2}",
-		model,
-	)
-
-
-def test_basic_analysis(snapshot):
-
-	dot_positions = [[0, 0, 0], [0, 1, 0]]
-
-	freqs = [1, 10, 100]
-	models = []
-
-	orientations = ["free", "fixedxy", "fixedz"]
-	for orientation in orientations:
-		models.append(get_model(orientation))
-
-	_logger.info(f"have {len(models)} models to look at")
-	if len(models) == 1:
-		_logger.info(f"only one model, name: {models[0][0]}")
-
-	square_run = deepdog.BayesRunWithSubspaceSimulation(
-		dot_positions,
-		freqs,
-		models,
-		models[0][1],
-		filename_slug="test",
-		end_threshold=0.9,
-		ss_n_c=5,
-		ss_n_s=2,
-		ss_m_max=10,
-		ss_target_cost=150,
-		ss_level_0_seed=200,
-		ss_mcmc_seed=20,
-		ss_use_adaptive_steps=True,
-		ss_default_phi_step=0.01,
-		ss_default_theta_step=0.01,
-		ss_default_r_step=0.01,
-		ss_default_w_log_step=0.01,
-		ss_default_upper_w_log_step=4,
-		ss_dump_last_generation=False,
-		write_output_to_bayesruncsv=False,
-		ss_initial_costs_chunk_size=1000,
-	)
-	result = square_run.go()
-
-	assert result == snapshot
-
-
-def test_bayesss_with_tighter_cost(snapshot):
-
-	dot_positions = [[0, 0, 0], [0, 1, 0]]
-
-	freqs = [1, 10, 100]
-	models = []
-
-	orientations = ["free", "fixedxy", "fixedz"]
-	for orientation in orientations:
-		models.append(get_model(orientation))
-
-	_logger.info(f"have {len(models)} models to look at")
-	if len(models) == 1:
-		_logger.info(f"only one model, name: {models[0][0]}")
-
-	square_run = deepdog.BayesRunWithSubspaceSimulation(
-		dot_positions,
-		freqs,
-		models,
-		models[0][1],
-		filename_slug="test",
-		end_threshold=0.9,
-		ss_n_c=5,
-		ss_n_s=2,
-		ss_m_max=10,
-		ss_target_cost=1.5,
-		ss_level_0_seed=200,
-		ss_mcmc_seed=20,
-		ss_use_adaptive_steps=True,
-		ss_default_phi_step=0.01,
-		ss_default_theta_step=0.01,
-		ss_default_r_step=0.01,
-		ss_default_w_log_step=0.01,
-		ss_default_upper_w_log_step=4,
-		ss_dump_last_generation=False,
-		write_output_to_bayesruncsv=False,
-		ss_initial_costs_chunk_size=1,
-	)
-	result = square_run.go()
-
-	assert result == snapshot