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))