def calculate_matrix(
self,
dataset_model: DatasetModel,
indices: dict[str, int],
**kwargs,
):
compartments = []
for compartment in self.shape:
if compartment in compartments:
raise ModelError(
f"More then one shape defined for compartment '{compartment}'"
)
compartments.append(compartment)
model_axis = dataset_model.get_model_axis()
if dataset_model.spectral_axis_inverted:
model_axis = dataset_model.spectral_axis_scale / model_axis
elif dataset_model.spectral_axis_scale != 1:
model_axis = model_axis * dataset_model.spectral_axis_scale
dim1 = model_axis.size
dim2 = len(self.shape)
matrix = np.zeros((dim1, dim2))
for i, shape in enumerate(self.shape.values()):
matrix[:, i] += shape.calculate(model_axis)
return compartments, matrix
def calculate_matrix(
self,
dataset_model: DatasetModel,
indices: dict[str, int],
**kwargs,
):
if not 1 <= self.order <= 3:
raise ModelError(
"Coherent artifact order must be between in [1,3]")
if dataset_model.irf is None:
raise ModelError(f'No irf in dataset "{dataset_model.label}"')
if not isinstance(dataset_model.irf, IrfMultiGaussian):
raise ModelError(
f'Irf in dataset "{dataset_model.label} is not a gaussian irf."'
)
global_dimension = dataset_model.get_global_dimension()
global_index = indices.get(global_dimension)
global_axis = dataset_model.get_global_axis()
model_axis = dataset_model.get_model_axis()
irf = dataset_model.irf
center, width, _, shift, _, _ = irf.parameter(global_index,
global_axis)
center = center[0] - shift
width = self.width.value if self.width is not None else width[0]
matrix = _calculate_coherent_artifact_matrix(center, width, model_axis,
self.order)
return self.compartments(), matrix
def calculate_matrix(
self,
dataset_model: DatasetModel,
indices: dict[str, int],
**kwargs,
):
model_axis = dataset_model.get_model_axis()
clp_label = [f"{dataset_model.label}_baseline"]
matrix = np.ones((model_axis.size, 1), dtype=np.float64)
return clp_label, matrix
def calculate_matrix(
self,
dataset_model: DatasetModel,
indices: dict[str, int],
**kwargs,
):
clp_label = [f"{label}_cos" for label in self.labels] + [
f"{label}_sin" for label in self.labels
]
model_axis = dataset_model.get_model_axis()
delta = np.abs(model_axis[1:] - model_axis[:-1])
delta_min = delta[np.argmin(delta)]
# c multiply by 0.03 to convert wavenumber (cm-1) to frequency (THz)
# where 0.03 is the product of speed of light 3*10**10 cm/s and time-unit ps (10^-12)
frequency_max = 1 / (2 * 0.03 * delta_min)
frequencies = np.array(self.frequencies) * 0.03 * 2 * np.pi
frequencies[frequencies >= frequency_max] = np.mod(
frequencies[frequencies >= frequency_max], frequency_max
)
rates = np.array(self.rates)
matrix = np.ones((model_axis.size, len(clp_label)), dtype=np.float64)
if dataset_model.irf is None:
calculate_damped_oscillation_matrix_no_irf(matrix, frequencies, rates, model_axis)
elif isinstance(dataset_model.irf, IrfMultiGaussian):
global_dimension = dataset_model.get_global_dimension()
global_axis = dataset_model.get_global_axis()
global_index = indices.get(global_dimension)
centers, widths, scales, shift, _, _ = dataset_model.irf.parameter(
global_index, global_axis
)
for center, width, scale in zip(centers, widths, scales):
matrix += calculate_damped_oscillation_matrix_gaussian_irf(
frequencies,
rates,
model_axis,
center,
width,
shift,
scale,
)
matrix /= np.sum(scales)
return clp_label, matrix
def calculate_matrix(
megacomplex: Megacomplex,
dataset_model: DatasetModel,
indices: dict[str, int],
**kwargs,
):
compartments = megacomplex.get_compartments(dataset_model)
initial_concentration = megacomplex.get_initial_concentration(
dataset_model)
k_matrix = megacomplex.get_k_matrix()
# the rates are the eigenvalues of the k matrix
rates = k_matrix.rates(compartments, initial_concentration)
global_dimension = dataset_model.get_global_dimension()
global_index = indices.get(global_dimension)
global_axis = dataset_model.get_global_axis()
model_axis = dataset_model.get_model_axis()
# init the matrix
size = (model_axis.size, rates.size)
matrix = np.zeros(size, dtype=np.float64)
decay_matrix_implementation(matrix, rates, global_index, global_axis,
model_axis, dataset_model)
if not np.all(np.isfinite(matrix)):
raise ValueError(
f"Non-finite concentrations for K-Matrix '{k_matrix.label}':\n"
f"{k_matrix.matrix_as_markdown(fill_parameters=True)}")
# apply A matrix
matrix = matrix @ megacomplex.get_a_matrix(dataset_model)
# done
return compartments, matrix