diff --git a/astropy_helpers b/astropy_helpers index d51f7266735..bbbf2800231 160000 --- a/astropy_helpers +++ b/astropy_helpers @@ -1 +1 @@ -Subproject commit d51f726673510586d4b3bd04fa4799fdab389aab +Subproject commit bbbf280023162d3ec496524824584cd94705b586 diff --git a/tardis/plasma/base.py b/tardis/plasma/base.py index da41aef6cc8..5b58846c46b 100644 --- a/tardis/plasma/base.py +++ b/tardis/plasma/base.py @@ -10,24 +10,24 @@ class BasePlasma(object): - - def __init__(self, plasma_modules, **kwargs): - self.module_dict = {} - self.input_modules = [] - self._init_modules(plasma_modules, **kwargs) + outputs_dict = {} + def __init__(self, plasma_properties, **kwargs): + self.outputs_dict = {} + self.input_properties = [] + self.plasma_properties = self._init_properties(plasma_properties, + **kwargs) + self._build_graph() self.update(**kwargs) - def __getattr__(self, item): - if item in self.module_dict: + if item in self.outputs_dict: return self.get_value(item) else: super(BasePlasma, self).__getattribute__(item) - def __setattr__(self, key, value): - if key != 'module_dict' and key in self.module_dict: + if key != 'module_dict' and key in self.outputs_dict: raise AttributeError('Plasma inputs can only be updated using ' 'the \'update\' method') else: @@ -42,8 +42,12 @@ def __dir__(self): return attrs + @property + def plasma_properties_dict(self): + return {item.name:item for item in self.plasma_properties} + def get_value(self, item): - return self.module_dict[item].value + return getattr(self.outputs_dict[item], item) def _build_graph(self): """ @@ -56,62 +60,80 @@ def _build_graph(self): self.graph = nx.DiGraph() ## Adding all nodes - self.graph.add_nodes_from([(key, {}) - for key, value in self.module_dict.items()]) + self.graph.add_nodes_from([(plasma_property.name, {}) + for plasma_property + in self.plasma_properties]) #Flagging all input modules - self.input_modules = [key for key, item in self.module_dict.items() - if not hasattr(item, 'inputs')] + self.input_properties = [item for item in self.plasma_properties + if not hasattr(item, 'inputs')] - for plasma_module in self.module_dict.values(): + for plasma_property in self.plasma_properties: #Skipping any module that is an input module - if plasma_module.name in self.input_modules: + if plasma_property in self.input_properties: continue - for input in plasma_module.inputs: - if input not in self.graph: + for input in plasma_property.inputs: + if input not in self.outputs_dict: raise PlasmaMissingModule('Module {0} requires input ' '{1} which has not been added' ' to this plasma'.format( - plasma_module.name, input)) - self.graph.add_edge(input, plasma_module.name) + plasma_property.name, input)) + self.graph.add_edge(self.outputs_dict[input].name, + plasma_property.name, label=input) - def _init_modules(self, plasma_modules, **kwargs): + def _init_properties(self, plasma_properties, **kwargs): """ Builds a dictionary with the plasma module names as keys - :param plasma_modules: - :return: - """ - self.module_dict = {} - for module in plasma_modules: - if hasattr(module, 'set_value'): - if module.name not in kwargs: + Parameters + ---------- + + plasma_modules: ~list + list of Plasma properties + kwargs: dictionary + input values for input properties. For example, t_rad=[5000, 6000,], + j_blues=[..] + + """ + plasma_property_objects = [] + self.outputs_dict = {} + for plasma_property in plasma_properties: + + if hasattr(plasma_property, 'set_value'): + #duck-typing for PlasmaInputProperty + #that means if it is an input property from model + if not set(kwargs.keys()).issuperset(plasma_property.outputs): + missing_input_values = (set(plasma_property.outputs) - + set(kwargs.keys())) raise NotInitializedModule('Input {0} required for ' 'plasma but not given when ' 'instantiating the ' - 'plasma'.format(module.name)) - current_module_object = module() + 'plasma'.format( + missing_input_values)) + current_property_object = plasma_property() else: - current_module_object = module(self) - - self.module_dict[module.name] = current_module_object + current_property_object = plasma_property(self) + for output in plasma_property.outputs: + self.outputs_dict[output] = current_property_object + plasma_property_objects.append(current_property_object) + return plasma_property_objects def update(self, **kwargs): for key in kwargs: - if key not in self.module_dict: + if key not in self.outputs_dict: raise PlasmaMissingModule('Trying to update property {0}' ' that is unavailable'.format(key)) - self.module_dict[key].set_value(kwargs[key]) + self.outputs_dict[key].set_value(kwargs[key]) for module_name in self._resolve_update_list(kwargs.keys()): - self.module_dict[module_name].update() + self.plasma_properties_dict[module_name].update() def _update_module_type_str(self): for node in self.graph: - self.module_dict[node]._update_type_str() + self.outputs_dict[node]._update_type_str() - def _resolve_update_list(self, changed_modules): + def _resolve_update_list(self, changed_properties): """ Returns a list of all plasma models which are affected by the changed_modules due to there dependency in the @@ -120,8 +142,6 @@ def _resolve_update_list(self, changed_modules): Parameters ---------- - graph: ~networkx.Graph - the plasma graph as changed_modules: ~list all modules changed in the plasma @@ -134,8 +154,9 @@ def _resolve_update_list(self, changed_modules): descendants_ob = [] - for module in changed_modules: - descendants_ob += nx.descendants(self.graph, module) + for plasma_property in changed_properties: + node_name = self.outputs_dict[plasma_property].name + descendants_ob += nx.descendants(self.graph, node_name) descendants_ob = list(set(descendants_ob)) sort_order = nx.topological_sort(self.graph) @@ -147,7 +168,7 @@ def _resolve_update_list(self, changed_modules): return descendants_ob - def write_to_dot(self, fname): + def write_to_dot(self, fname, latex_label=True): self._update_module_type_str() try: @@ -187,4 +208,3 @@ def __init__(self, number_densities, atom_data, time_explosion, link_t_rad_t_electron=0.9): pass - diff --git a/tardis/plasma/properties/atomic.py b/tardis/plasma/properties/atomic.py index 38c323fc28f..9dd8498c35c 100644 --- a/tardis/plasma/properties/atomic.py +++ b/tardis/plasma/properties/atomic.py @@ -18,8 +18,10 @@ class BaseAtomicDataProperty(ProcessingPlasmaProperty): inputs = ['atomic_data', 'selected_atoms'] def __init__(self, plasma_parent): + super(BaseAtomicDataProperty, self).__init__(plasma_parent) self.value = None + assert len(self.outputs) == 1 @abstractmethod def _set_index(self, raw_atomic_property, atomic_data): @@ -31,31 +33,33 @@ def _filter_atomic_property(self, raw_atomic_property): def calculate(self, atomic_data, selected_atoms): - if self.value is not None: - return self.value + + if getattr(self, self.outputs[0]) is not None: + return getattr(self, self.outputs[0]) else: try: - raw_atomic_property = getattr(atomic_data, '_' + self.name) - return self._set_index(self._filter_atomic_property( - raw_atomic_property, selected_atoms), atomic_data) - except: - raw_atomic_property = getattr(atomic_data, self.name) + raw_atomic_property = getattr(atomic_data, '_' + self.outputs[0]) + except AttributeError: + raw_atomic_property = getattr(atomic_data, self.outputs[0]) + finally: return self._set_index(self._filter_atomic_property( raw_atomic_property, selected_atoms), atomic_data) class Levels(BaseAtomicDataProperty): - name = 'levels' + outputs = ('levels',) def _filter_atomic_property(self, levels, selected_atoms): - return levels[levels.atomic_number.isin(selected_atoms)] + return levels[levels.atomic_number.isin([selected_atoms] + if np.isscalar(selected_atoms) + else selected_atoms)] def _set_index(self, levels, atomic_data): return levels.set_index(['atomic_number', 'ion_number', 'level_number']) class Lines(BaseAtomicDataProperty): - name = 'lines' + outputs = ('lines',) def _filter_atomic_property(self, lines, selected_atoms): return lines[lines.atomic_number.isin(selected_atoms)] @@ -68,7 +72,7 @@ def _set_index(self, lines, atomic_data): return reindexed class LinesLowerLevelIndex(ProcessingPlasmaProperty): - name = 'lines_lower_level_index' + outputs = ('lines_lower_level_index',) def calculate(self, levels, lines): levels_index = pd.Series(np.arange(len(levels), dtype=np.int64), @@ -79,7 +83,7 @@ def calculate(self, levels, lines): return np.array(levels_index.ix[lines_index]) class LinesUpperLevelIndex(ProcessingPlasmaProperty): - name = 'lines_upper_level_index' + outputs = ('lines_upper_level_index',) def calculate(self, levels, lines): levels_index = pd.Series(np.arange(len(levels), dtype=np.int64), @@ -91,7 +95,7 @@ def calculate(self, levels, lines): class IonCXData(BaseAtomicDataProperty): - name = 'ion_cx_data' + outputs = ('ion_cx_data',) def _filter_atomic_property(self, ion_cx_data, selected_atoms): return filtered_ion_cx_data @@ -102,16 +106,16 @@ def _set_index(self, ion_cx_data, atomic_data): class AtomicMass(ProcessingPlasmaProperty): - name = 'atomic_mass' + outputs = ('atomic_mass',) def calculate(self, atomic_data, selected_atoms): - if self.value is not None: - return self.value + if getattr(self, self.outputs[0]) is not None: + return (getattr(self, self.outputs[0]),) else: return atomic_data.atom_data.ix[selected_atoms].mass class IonizationData(BaseAtomicDataProperty): - name = 'ionization_data' + outputs = ('ionization_data',) def _filter_atomic_property(self, ionization_data, selected_atoms): ionization_data['atomic_number'] = ionization_data.index.labels[0]+1 @@ -132,7 +136,7 @@ def _set_index(self, ionization_data, atomic_data): return ionization_data.set_index(['atomic_number', 'ion_number']) class ZetaData(BaseAtomicDataProperty): - name = 'zeta_data' + outputs = ('zeta_data',) def _filter_atomic_property(self, zeta_data, selected_atoms): zeta_data['atomic_number'] = zeta_data.index.labels[0]+1 @@ -144,27 +148,27 @@ def _filter_atomic_property(self, zeta_data, selected_atoms): if np.alltrue(keys+1==values): return zeta_data else: - raise IncompleteAtomicData('zeta data') -# logger.warn('Zeta_data missing - replaced with 1s') -# updated_index = [] -# for atom in selected_atoms: -# for ion in range(1, atom+2): -# updated_index.append([atom,ion]) -# updated_index = np.array(updated_index) -# updated_dataframe = pd.DataFrame(index=pd.MultiIndex.from_arrays( -# updated_index.transpose().astype(int)), -# columns = zeta_data.columns) -# for value in range(len(zeta_data)): -# updated_dataframe.ix[zeta_data.atomic_number.values[value]].ix[ -# zeta_data.ion_number.values[value]] = \ -# zeta_data.ix[zeta_data.atomic_number.values[value]].ix[ -# zeta_data.ion_number.values[value]] -# updated_dataframe = updated_dataframe.astype(float) -# updated_index = pd.DataFrame(updated_index) -# updated_dataframe['atomic_number'] = np.array(updated_index[0]) -# updated_dataframe['ion_number'] = np.array(updated_index[1]) -# updated_dataframe.fillna(1.0, inplace=True) -# return updated_dataframe +# raise IncompleteAtomicData('zeta data') + logger.warn('Zeta_data missing - replaced with 1s') + updated_index = [] + for atom in selected_atoms: + for ion in range(1, atom+2): + updated_index.append([atom,ion]) + updated_index = np.array(updated_index) + updated_dataframe = pd.DataFrame(index=pd.MultiIndex.from_arrays( + updated_index.transpose().astype(int)), + columns = zeta_data.columns) + for value in range(len(zeta_data)): + updated_dataframe.ix[zeta_data.atomic_number.values[value]].ix[ + zeta_data.ion_number.values[value]] = \ + zeta_data.ix[zeta_data.atomic_number.values[value]].ix[ + zeta_data.ion_number.values[value]] + updated_dataframe = updated_dataframe.astype(float) + updated_index = pd.DataFrame(updated_index) + updated_dataframe['atomic_number'] = np.array(updated_index[0]) + updated_dataframe['ion_number'] = np.array(updated_index[1]) + updated_dataframe.fillna(1.0, inplace=True) + return updated_dataframe def _set_index(self, zeta_data, atomic_data): return zeta_data.set_index(['atomic_number', 'ion_number']) diff --git a/tardis/plasma/properties/base.py b/tardis/plasma/properties/base.py index 52dbf4a3588..afef552450b 100644 --- a/tardis/plasma/properties/base.py +++ b/tardis/plasma/properties/base.py @@ -7,11 +7,16 @@ class BasePlasmaProperty(object): __metaclass__ = ABCMeta @abstractproperty - def name(self): + def outputs(self): pass + @property + def name(self): + return self.__class__.__name__ + def __init__(self): - self.value = None + for output in self.outputs: + setattr(self, output, None) def _update_type_str(self): """ @@ -30,7 +35,7 @@ def get_latex_label(self): \textbf{{Formula}} {formula} {description} """ - name = self.name.replace('_', r'\_') + outputs = self.outputs.replace('_', r'\_') latex_name = getattr(self, 'latex_name', '') if latex_name != '': complete_name = '{0} [{1}]'.format(name, self.latex_name) @@ -66,7 +71,7 @@ def _update_inputs(self): def _get_input_values(self): - return [self.plasma_parent.get_value(item) for item in self.inputs] + return (self.plasma_parent.get_value(item) for item in self.inputs) def update(self): """ @@ -75,14 +80,17 @@ def update(self): :return: """ - self.value = self.calculate(*self._get_input_values()) + + if len(self.outputs) == 1: + setattr(self, self.outputs[0], self.calculate( + *self._get_input_values())) + else: + new_values = self.calculate(*self._get_input_values()) + for i, output in enumerate(self.outputs): + setattr(self, output, new_values[i]) + @abstractmethod def calculate(self, *args, **kwargs): raise NotImplementedError('This method needs to be implemented by ' 'processing plasma modules') - - - - - diff --git a/tardis/plasma/properties/general.py b/tardis/plasma/properties/general.py index 148644dca52..ff0a14b5307 100644 --- a/tardis/plasma/properties/general.py +++ b/tardis/plasma/properties/general.py @@ -11,7 +11,7 @@ 'ElectronTemperature', 'BetaElectron'] class BetaRadiation(ProcessingPlasmaProperty): - name = 'beta_rad' + outputs = ('beta_rad',) latex_name = r'$\beta_\textrm{rad}$' latex_formula = r'$\frac{1}{K_B T_\textrm{rad}}$' @@ -25,7 +25,7 @@ def calculate(self, t_rad): class GElectron(ProcessingPlasmaProperty): - name = 'g_electron' + outputs = ('g_electron',) latex_name = r'$g_\textrm{electron}$' latex_formula = (r'$\left(\frac{2\pi m_\textrm{e} ' @@ -38,26 +38,26 @@ def calculate(beta_rad): class NumberDensity(ProcessingPlasmaProperty): - name = 'number_density' + outputs = ('number_density',) def calculate(self, atomic_mass, abundance, density): number_densities = (abundance * density) return number_densities.div(atomic_mass.ix[abundance.index], axis=0) class SelectedAtoms(ProcessingPlasmaProperty): - name = 'selected_atoms' + outputs = ('selected_atoms',) def calculate(self, abundance): return abundance.index class ElectronTemperature(ProcessingPlasmaProperty): - name = 't_electron' + outputs = ('t_electron',) def calculate(self, t_rad, link_t_rad_t_electron): return t_rad * link_t_rad_t_electron class BetaElectron(ProcessingPlasmaProperty): - name = 'beta_electron' + outputs = ('beta_electron',) def __init__(self, plasma_parent): super(BetaElectron, self).__init__(plasma_parent) diff --git a/tardis/plasma/properties/ion_population.py b/tardis/plasma/properties/ion_population.py index 92fe12a380a..5c113c801ab 100644 --- a/tardis/plasma/properties/ion_population.py +++ b/tardis/plasma/properties/ion_population.py @@ -14,7 +14,7 @@ class PhiGeneral(ProcessingPlasmaProperty): - name = 'general_phi' + outputs = ('general_phi',) latex_formula = (r'$\Phi_{i,j} = \frac{N_{i, j+1} n_e}{N_{i, j}} \\' r' \Phi_{i, j} = g_e \times \frac{Z_{i, j+1}}{Z_{i, j}} ' @@ -60,7 +60,7 @@ class PhiSahaNebular(ProcessingPlasmaProperty): """ - name = 'phi' + outputs = ('phi',) @staticmethod def calculate(general_phi, t_rad, w, zeta_data, t_electron, delta): @@ -82,7 +82,7 @@ def calculate(general_phi, t_rad, w, zeta_data, t_electron, delta): class PhiSahaLTE(ProcessingPlasmaProperty): - name = 'phi' + outputs = ('phi',) @staticmethod def calculate(general_phi): @@ -90,7 +90,7 @@ def calculate(general_phi): class RadiationFieldCorrection(ProcessingPlasmaProperty): - name = 'delta' + outputs = ('delta',) """ Calculating radiation field correction factors according to Mazzali & Lucy 1993 (:cite:`1993A&A...279..447M`; henceforth ML93) @@ -192,7 +192,7 @@ class IonNumberDensity(ProcessingPlasmaProperty): r'N(X) = N_1(1+ \Phi_{i,j}/N_e + \Phi_{i, j}/N_e ' r'\times \Phi_{i, j+1}/N_e + \dots)$') - name = 'ion_number_density' + outputs = ('ion_number_density',) def __init__(self, plasma_parent, ion_zero_threshold=1e-20): super(IonNumberDensity, self).__init__(plasma_parent) @@ -248,7 +248,7 @@ class ElectronDensity(ProcessingPlasmaProperty): """ latex_formula = r'$n_e = \frac{N_{i,j}}{N_{i,j+1}} \times \Phi_{i,j}$' - name = 'electron_densities' + outputs = ('electron_densities',) def calculate(self, ion_number_density, phi): # Could check electron density for any element/ions in each zone, but diff --git a/tardis/plasma/properties/level_population.py b/tardis/plasma/properties/level_population.py index 3bbc8571a6a..e31b056b2e6 100644 --- a/tardis/plasma/properties/level_population.py +++ b/tardis/plasma/properties/level_population.py @@ -11,7 +11,7 @@ class LevelPopulation(ProcessingPlasmaProperty): - name = 'level_population_fraction' + outputs = ('level_population_fraction',) latexformula = (r'$N_{i, j, k} = \frac{g_{i, j, k} ' r'e^{-\beta_\textrm{rad} E_{i, j, k}}}{Z_{i, j}}$') @@ -24,7 +24,7 @@ def calculate(levels, partition_function, level_boltzmann_factor): return level_boltzmann_factor / partition_function_broadcast class LevelNumberDensity(ProcessingPlasmaProperty): - name = 'level_number_density' + outputs = ('level_number_density',) @staticmethod def calculate(level_population_fraction, ion_number_density): diff --git a/tardis/plasma/properties/partition_function.py b/tardis/plasma/properties/partition_function.py index 96714414912..a14789893a8 100644 --- a/tardis/plasma/properties/partition_function.py +++ b/tardis/plasma/properties/partition_function.py @@ -19,7 +19,7 @@ class LevelBoltzmannFactorLTE(ProcessingPlasmaProperty): """ - name = 'level_boltzmann_factor' + outputs = ('level_boltzmann_factor',) latex_formula = r'$g_{i, j, k} e^{E_{i, j, k} \times \beta_\textrm{rad}}$' @staticmethod @@ -36,7 +36,7 @@ def calculate(levels, beta_rad): class LevelBoltzmannFactorDiluteLTE(ProcessingPlasmaProperty): - name = 'level_boltzmann_factor' + outputs = ('level_boltzmann_factor',) @staticmethod def calculate(levels, beta_rad, w): @@ -52,8 +52,8 @@ def calculate(levels, beta_rad, w): return level_boltzmann_factor class PartitionFunction(ProcessingPlasmaProperty): - name = 'partition_function' - latex_name = '$Z_{i, j}$' + outputs = ('partition_function',) + latex_outputs = '$Z_{i, j}$' latex_formula = (r'$Z_{i, j} = \sum_{k=1}^n g_{i, j, k} ' r'e^{E_{i, j, k} \times \beta_\textrm{rad}}$') diff --git a/tardis/plasma/properties/plasma_input.py b/tardis/plasma/properties/plasma_input.py index 0a0fc505ea6..b9fb4792fa8 100644 --- a/tardis/plasma/properties/plasma_input.py +++ b/tardis/plasma/properties/plasma_input.py @@ -9,8 +9,12 @@ class Input(BasePlasmaProperty): + def _set_output_value(self, output, value): + setattr(self, output, value) + def set_value(self, value): - self.value = value + assert len(self.outputs) == 1 + self._set_output_value(self.outputs[0], value) class StaticInput(Input): @@ -21,42 +25,43 @@ class DynamicInput(Input): class ArrayInput(DynamicInput): - def set_value(self, value): - self.value = np.array(value, copy=False) + def _set_output_value(self, output, value): + setattr(self, output, np.array(value, copy=False)) + class DataFrameInput(DynamicInput): - def set_value(self, value): - self.value = pd.DataFrame(value) + def _set_output_value(self, output, value): + setattr(self, output, np.array(pd.DataFrame(value), copy=False)) class TRadiative(ArrayInput): - name = 't_rad' + outputs = ('t_rad',) latex_name = r'$T_\textrm{rad}$' class DilutionFactor(ArrayInput): - name = 'w' + outputs = ('w',) latex_name = r'$W$' class AtomicData(StaticInput): - name = 'atomic_data' + outputs = ('atomic_data',) class Abundance(DynamicInput): - name = 'abundance' + outputs = ('abundance',) class RadiationFieldCorrectionInput(StaticInput): - name = 'delta_input' + outputs = ('delta_input',) class Density(ArrayInput): - name = 'density' + outputs = ('density',) latex_name = r'$\rho$' class TimeExplosion(DynamicInput): - name = 'time_explosion' + outputs = ('time_explosion',) class JBlues(DataFrameInput): - name = 'j_blues' + outputs = ('j_blues',) class LinkTRadTElectron(StaticInput): - name = 'link_t_rad_t_electron' \ No newline at end of file + outputs = ('link_t_rad_t_electron',) diff --git a/tardis/plasma/properties/radiative_properties.py b/tardis/plasma/properties/radiative_properties.py index 3787b9f2f34..d27dd406517 100644 --- a/tardis/plasma/properties/radiative_properties.py +++ b/tardis/plasma/properties/radiative_properties.py @@ -14,7 +14,7 @@ class StimulatedEmissionFactor(ProcessingPlasmaProperty): - name = 'stimulated_emission_factor' + outputs = ('stimulated_emission_factor',) def __init__(self, plasma_parent): super(StimulatedEmissionFactor, self).__init__(plasma_parent) @@ -79,7 +79,7 @@ class TauSobolev(ProcessingPlasmaProperty): """ - name = 'tau_sobolevs' + outputs = ('tau_sobolevs',) def __init__(self, plasma_parent): @@ -111,22 +111,25 @@ def calculate(self, lines, level_number_density, lines_lower_level_index, columns=np.array(level_number_density.columns)) class BetaSobolev(ProcessingPlasmaProperty): - name = 'beta_sobolev' + outputs = ('beta_sobolev',) def calculate(self, tau_sobolevs): - if not hasattr(self, 'beta_sobolev'): + if getattr(self, 'beta_sobolev', None) is None: beta_sobolev = np.zeros_like(tau_sobolevs.values) + else: + beta_sobolev = self.beta_sobolev + macro_atom.calculate_beta_sobolev( tau_sobolevs.values.ravel(order='F'), beta_sobolev.ravel(order='F')) return beta_sobolev class TransitionProbabilities(ProcessingPlasmaProperty): - name = 'transition_probabilities' + outputs = ('transition_probabilities',) def calculate(self, atomic_data, beta_sobolev, j_blues, stimulated_emission_factor, tau_sobolevs): - if j_blues.empty: + if len(j_blues) == 0: transition_probabilities = None else: try: @@ -141,7 +144,7 @@ def calculate(self, atomic_data, beta_sobolev, j_blues, (macro_atom_data.transition_type == 1).values macro_atom_transition_up_filter = \ macro_atom_data.lines_idx.values[transition_up_filter] - j_blues = j_blues.values.take(macro_atom_transition_up_filter, + j_blues = j_blues.take(macro_atom_transition_up_filter, axis=0, mode='raise') macro_stimulated_emission = stimulated_emission_factor.take( macro_atom_transition_up_filter, axis=0, mode='raise') diff --git a/tardis/plasma/standard_plasmas.py b/tardis/plasma/standard_plasmas.py index 4e4202a88b5..603ce0a5108 100644 --- a/tardis/plasma/standard_plasmas.py +++ b/tardis/plasma/standard_plasmas.py @@ -17,7 +17,7 @@ def __init__(self, t_rad, abundance, density, time_explosion, atomic_data, plasma_modules = basic_inputs + basic_properties + \ lte_excitation_properties + lte_ionization_properties - super(LTEPlasma, self).__init__(plasma_modules=plasma_modules, + super(LTEPlasma, self).__init__(plasma_properties=plasma_modules, t_rad=t_rad, abundance=abundance, atomic_data=atomic_data, density=density, time_explosion=time_explosion, j_blues=j_blues, w=None, link_t_rad_t_electron=link_t_rad_t_electron, @@ -58,8 +58,8 @@ def __init__(self, number_densities, atomic_data, time_explosion, elif excitation_mode == 'dilute-lte': plasma_modules += dilute_lte_excitation_properties else: - raise NotImplementedError('Sorry ' + excitation_mode + - ' not implemented yet.') + raise NotImplementedError('Sorry {0} not implemented yet.'.format( + excitation_mode)) if ionization_mode == 'lte': plasma_modules += lte_ionization_properties @@ -83,7 +83,7 @@ def __init__(self, number_densities, atomic_data, time_explosion, abundance, density = self.from_number_densities(number_densities, atomic_data) - super(LegacyPlasmaArray, self).__init__(plasma_modules=plasma_modules, + super(LegacyPlasmaArray, self).__init__(plasma_properties=plasma_modules, t_rad=t_rad, abundance=abundance, density=density, atomic_data=atomic_data, time_explosion=time_explosion, j_blues=None, w=w, link_t_rad_t_electron=link_t_rad_t_electron,