def molMass(self, molMass_tuple : Tuple[float, str]):
     self._molMass = molMass_to_kgPerMol(*molMass_tuple)
     self._Rs = self.R/self.molMass
     self.molMass_unit = validate_unit('kg/mol', 'molMass')
     self.Rs_unit = validate_unit('m^2/s^2_kelvin', 'specific_gas_constant')
 def R_unit(self):
     return validate_unit('kg_m2/s2_mol_k', 'universal_gas_constant')
 def T(self, T_tuple : Tuple[float, str]):
     self._T = temperature_to_kelvin(*T_tuple)
     self.T_unit = validate_unit('K', 'temperature')
 def pc(self, pc_tuple : Tuple[float, str]):
     self._pc = pressure_to_bar(*pc_tuple)
     self.pc_unit = validate_unit('bar', 'pressure')
 def rho_0(self, rho_0_tuple : Tuple[float, str]):
     self._rho_0 = density_to_kilogramm_per_m_cube(*rho_0_tuple)
     self.rho_0_unit = validate_unit('kg/m^3', 'density')
def _generate_csv(csv_path: str,
                  net: network_dae,
                  timeTable: data_array_t,
                  solution: data_array_t,
                  write_pressures: bool = True,
                  write_inner_flows: bool = True,
                  write_boundary_flows: bool = True,
                  write_left_right_flows_for_pipes: bool = True):
    with open(csv_path, 'w', newline='') as result_csv:
        fieldnames = ['Time', 'Alias', 'Object', 'Parameter', 'Value', 'Unit']

        writer = csv.DictWriter(result_csv,
                                fieldnames=fieldnames,
                                delimiter=';')

        writer.writeheader()

        for ti, solRow in zip(timeTable, solution):
            for element in net.components:
                if 'hidden' in element.type:
                    continue

                if 'node' in element.type:
                    csvRow = {
                        'Time': ti,
                        'Alias': element.name,
                        'Object': element.name,
                        'Parameter': 'P',
                        'Value': solRow[element.p_press_id],
                        'Unit': validate_unit('bar', 'pressure')
                    }

                    if write_pressures: writer.writerow(csvRow)

                    Q = element.qBoundFunc(ti)

                    csvRow = {
                        'Time': ti,
                        'Alias': element.name,
                        'Object': element.name,
                        'Parameter': 'Q',
                        'Value': Q,
                        'Unit': validate_unit('kg_per_s', 'flow')
                    }

                    if write_boundary_flows: writer.writerow(csvRow)

                elif 'pipe' in element.type:
                    if write_left_right_flows_for_pipes:
                        csvRow = {
                            'Time': ti,
                            'Alias': element.name,
                            'Object': element.name,
                            'Parameter': 'ML',
                            'Value': solRow[element.qL_leftFlow_id],
                            'Unit': validate_unit('kg_per_s', 'flow')
                        }

                        if write_inner_flows: writer.writerow(csvRow)

                        csvRow = {
                            'Time': ti,
                            'Alias': element.name,
                            'Object': element.name,
                            'Parameter': 'MR',
                            'Value': solRow[element.qR_rightFlow_id],
                            'Unit': validate_unit('kg_per_s', 'flow')
                        }

                        if write_inner_flows: writer.writerow(csvRow)
                    else:
                        csvRow = {
                            'Time':
                            ti,
                            'Alias':
                            element.name,
                            'Object':
                            element.name,
                            'Parameter':
                            'M',
                            'Value':
                            0.5 * (solRow[element.qL_leftFlow_id] +
                                   solRow[element.qR_rightFlow_id]),
                            'Unit':
                            validate_unit('kg_per_s', 'flow')
                        }

                        if write_inner_flows: writer.writerow(csvRow)
                else:
                    csvRow = {
                        'Time': ti,
                        'Alias': element.name,
                        'Object': element.name,
                        'Parameter': 'M',
                        'Value': solRow[element.q_flowThrough_id],
                        'Unit': validate_unit('kg_per_s', 'flow')
                    }

                    if write_inner_flows: writer.writerow(csvRow)