def __repr__(self):
d = {
"01. Name": self.name,
"02. Type": self.type,
"03. Number of regions": self.number_of_regions,
"04. Excitability (x0) disease indices":
self.x0_disease_indices, # x0_indices,
"05. Excitability (x0) disease values":
self.x0_disease_values, # x0_values,
"06. Epileptogenicity (E) disease indices":
self.e_disease_indices, # e_indices,
"07. Epileptogenicity (E) disease values":
self.e_disease_values, # e_values,
"08. Connectivity (W) disease indices": self.w_indices,
"09. Connectivity (W) disease values": self.w_values,
"10. Propagation indices": self.lsa_propagation_indices,
}
if len(self.lsa_propagation_indices):
d.update({
"11. Propagation strengths of indices":
self.lsa_propagation_strengths[self.lsa_propagation_indices]
})
else:
d.update({
"11. Propagation strengths of indices":
self.lsa_propagation_strengths
})
# d.update({"11. Connectivity": str(self.connectivity)})
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"00. number of regions": self.number_of_regions,
"01. Excitability": self.x0_values,
"02. Epileptor Model Excitability": self.x0,
"03. x1eq": self.x1eq,
"04. zeq": self.zeq,
"05. Ceq": self.Ceq,
"06. Epileptogenicity": self.e_values,
"07. yc": self.yc,
"08. Iext1": self.Iext1,
"09. Iext2": self.Iext2,
"10. K": self.K,
"11. a": self.a,
"12. b": self.b,
"13. d": self.d,
"14. s": self.s,
"15. slope": self.slope,
"16. gamma": self.gamma,
"17. tau1": self.tau1,
"18. tau0": self.tau0,
"19. zmode": self.zmode,
"20. Model connectivity": self.model_connectivity
}
return formal_repr(self, d)
def __repr__(self):
d = {
"1. name": self.name,
"2. low": self.low,
"3. high": self.high,
"4. shape": self.p_shape
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"1. type": self.name,
"2. number of regions": self.number_of_regions,
"3. number of parameters": self.n_parameters,
"4. parameters": self.parameters
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {"01. Sampling module": self.sampling_module,
"02. Sampler": self.sampler,
"03. Number of samples": self.n_samples,
"04. Samples' p_shape": self.shape,
"05. Random seed": self.random_seed,
}
return formal_repr(self, d) + "\n06. Resulting statistics: " + dict_str(self.stats)
def __repr__(self):
d = {
"01. Task": self.task,
"02. Main PSE object": self.simulator,
"03. Number of computation loops": self.n_loops,
"04. Parameters":
numpy.array(["%s" % l for l in self.params_names]),
}
return formal_repr(self, d)
def __repr__(self):
d = {"01. LSA method": self.lsa_method,
"02. Eigenvectors' number selection mode": self.eigen_vectors_number_selection,
"03. Eigenvectors' number": self.eigen_vectors_number_selection,
"04. Eigen values": self.eigen_values,
"05. Eigenvectors": self.eigen_vectors,
"06. Eigenvectors' number": self.eigen_vectors_number,
"07. Weighted eigenvector's sum flag": str(self.weighted_eigenvector_sum)
}
return formal_repr(self, d)
def __repr__(self):
d = {
"00. surface subtype": self.surface_subtype,
"01. vertices": self.vertices,
"02. triangles": self.triangles,
"03. vertex_normals": self.vertex_normals,
"04. triangle_normals": self.triangle_normals,
"05. voxel to ras matrix": self.vox2ras
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {"f. normalized weights": reg_dict(self.normalized_weights, self.region_labels),
"g. weights": reg_dict(self.weights, self.region_labels),
"h. tract_lengths": reg_dict(self.tract_lengths, self.region_labels),
"a. region_labels": reg_dict(self.region_labels),
"b. centres": reg_dict(self.centres, self.region_labels),
"c. hemispheres": reg_dict(self.hemispheres, self.region_labels),
"d. orientations": reg_dict(self.orientations, self.region_labels),
"e. areas": reg_dict(self.areas, self.region_labels)}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"1. sensors' type": self.s_type,
"2. number of sensors": self.number_of_sensors,
"3. labels": reg_dict(self.labels),
"4. locations": reg_dict(self.locations, self.labels),
"5. orientations": reg_dict(self.orientations, self.labels),
"6. gain_matrix": self.gain_matrix
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {"01. integration_step": self.integration_step,
"02. simulated_period": self.simulated_period,
"03. integrator_type": self.integrator_type,
"04. noise_type": self.noise_type,
"05. noise_ntau": self.noise_ntau,
"06. noise_seed": self.noise_seed,
"07. noise_intensity": self.noise_intensity,
"08. monitor_type": self.monitor_type,
"09. monitor_sampling_period": self.monitor_sampling_period,
"10. variables_names": self.variables_names,
"11. initial_conditions": self.initial_conditions,
}
return formal_repr(self, d)
def __repr__(self):
d = {
"1. name": self.name,
"2. connectivity": self.connectivity,
"3. RM": reg_dict(self.region_mapping,
self.connectivity.region_labels),
"4. VM": reg_dict(self.volume_mapping,
self.connectivity.region_labels),
"5. surface": self.cortical_surface,
"6. T1": self.t1_background,
"7. SEEG": self.sensorsSEEG,
"8. EEG": self.sensorsEEG,
"9. MEG": self.sensorsMEG
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
form_repr = super(ODEStatisticalModel, self).__repr__()
d = {
"6. active regions": self.active_regions,
"7. initial condition std": self.sig_init,
"8. number of active regions": self.n_active_regions,
"9. number of nonactive regions": self.n_nonactive_regions,
"10. number of observation signals": self.n_signals,
"11. number of time points": self.n_times,
"12. time step": self.dt,
"13. observation_expression": self.observation_expression,
"14. observation_model": self.observation_model
}
# "13. euler_method": self.euler_method,
return form_repr + "\n" + formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"01. Method": self.method,
"02. Second order calculation flag": self.calc_second_order,
"03. Confidence level": self.conf_level,
"05. Number of inputs": self.n_inputs,
"06. Number of outputs": self.n_outputs,
"07. Input names": self.input_names,
"08. Output names": self.output_names,
"09. Input bounds": self.input_bounds,
"10. Problem": dict_str(self.problem),
"11. Other parameters": dict_str(self.other_parameters),
}
return formal_repr(self, d)
def _repr(self):
d = {
"01. type": self.type,
"02. pdf_params": self.pdf_params(),
"03. n_params": self.n_params,
"04. constraint": self.constraint_string,
"05. shape": self.__p_shape,
"05. mean": self.__mean,
"06. median": self.__median,
"07. mode": self.__mode,
"08. var": self.__var,
"09. std": self.__std,
"10. skew": self.__skew,
"11. kurt": self.__kurt,
"12. scipy_name": self.scipy_name,
"13. numpy_name": self.numpy_name
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {"01. Number of regions": self.number_of_regions,
"02. x0_values": self.x0_values,
"03. e_values": self.e_values,
"04. K_unscaled": self.K_unscaled,
"05. K": self.K,
"06. yc": self.yc,
"07. Iext1": self.Iext1,
"08. Iext2": self.Iext2,
"09. K": self.K,
"10. a": self.a,
"11. b": self.b,
"12. d": self.d,
"13. s": self.s,
"14. slope": self.slope,
"15. gamma": self.gamma,
"16. zmode": self.zmode,
"07. x1eq_mode": self.x1eq_mode
}
return formal_repr(self, d)
def __repr__(self):
d = {"01. Task": self.task,
"02. Main PSE object": self.hypothesis,
"03. Parameters": numpy.array(["%s" % l for l in self.params_names]),
}
return formal_repr(self, d)
def __repr__(self, d=OrderedDict()):
return formal_repr(self, self._repr(d))
