Ejemplo n.º 1
0
    def merge_files(self, i_iteration):

        _dir = self.data_directory
        _n_ranks = self.mpi_size

        datafile = None
        # filename of old kde file
        _filename_kde = os.path.join(_dir,
                                     'pyposmat.kde.{}.out'.format(i_iteration))

        print('Looking for previous kde file')
        print('    {}'.format(_filename_kde))

        datafile_fns = []
        if os.path.exists(_filename_kde):
            if os.path.isfile(_filename_kde):
                datafile_fns.append(_filename_kde)
        for i_rank in range(_n_ranks):
            rank_fn = os.path.join('rank_{}'.format(i_rank),
                                   'pyposmat.results.out')
            datafile_fns.append(rank_fn)

        names = ['sim_id']\
                + self.parameter_names\
                + self.qoi_names\
                + self.error_names
        types = ['sim_id']\
                + ['param']*len(self.parameter_names)\
                + ['qoi']*len(self.qoi_names)\
                + ['err']*len(self.error_names)

        dataframes = OrderedDict()
        for fn in datafile_fns:
            datafile = PyposmatDataFile()
            datafile.read(fn)
            #if fn.startswith('rank')
            #datafile.df['sim_id'] = datafile.df.apply(
            #    lambda x:"{}_{}_{}".format(
            #        i_iteration,i_rank,str(x['sim_id'])))
            dataframes[fn] = datafile.df[names]

        df = pd.concat(dataframes).reset_index(drop=True)
        datafile = PyposmatDataFile()
        datafile.df = df
        datafile.parameter_names = self.parameter_names
        datafile.error_names = self.error_names
        datafile.qoi_names = self.qoi_names
        datafile.names = names
        datafile.types = types
        try:
            fn_out = os.path.join(
                _dir, 'pyposmat.results.{}.out'.format(i_iteration))
            datafile.write(filename=fn_out)
        except FileNotFoundError as e:
            if not os.path.exists(self.data_directory):
                os.mkdir(self.data_directory)
                datafile.write(filename_fn_out)
            else:
                raise
_fn_results_in = os.path.join("resources", "pyposmat.results.0.out")
_fn_results_out = os.path.join("resources", "pyposmat.results.0a.out")

config = PyposmatConfigurationFile()
config.read(_fn_config)
qoi_targets = config.qoi_targets
print(config.qoi_targets)
print(list(config.qois))
data_in = PyposmatDataFile()
data_in.read(_fn_results_in)
data_out = PyposmatDataFile()
data_out.parameter_names = data_in.parameter_names
data_out.qoi_names = list(config.qois)
data_out.error_names = ['{}.err'.format(q) for q in data_out.qoi_names]
data_out.names = ["sim_id"]\
        +data_out.parameter_names\
        +data_out.qoi_names\
        +data_out.error_names
data_out.types = ["sim_id"]\
        +len(data_out.parameter_names)*['param']\
        +len(data_out.qoi_names)*['qoi']\
        +len(data_out.error_names)*['err']


def calculate_bulk_modulus(c11, c12, c44):
    return (c11 + 2 * c12) / 3


def calculate_shear_modulus(c11, c12, c44):
    return (c11 - c12) / 2

Ejemplo n.º 3
0
import os, copy, argparse
from collections import OrderedDict
from pypospack.pyposmat.data import PyposmatDataFile
from pypospack.pyposmat.data import PyposmatConfigurationFile
from pypospack.pyposmat.data import PyposmatDataAnalyzer

if __name__ == "__main__":
    _fn_config = os.path.join("resources", "pyposmat.config.in")
    _fn_data = os.path.join("resources", "pyposmat.results.0.out")
    _fn_pareto_out = os.path.join("pyposmat.pareto.out")

    pda = PyposmatDataAnalyzer(fn_config=_fn_config, fn_data=_fn_data)
    pareto_df = pda.calculate_pareto_set()

    datafile = PyposmatDataFile()
    datafile.df = pareto_df
    datafile.parameter_names = pda.parameter_names
    datafile.qoi_names = pda.qoi_names
    datafile.error_names = pda.error_names
    datafile.names = ['sim_id'] \
            +datafile.parameter_names\
            +datafile.qoi_names\
            +datafile.error_names
    datafile.types = ['sim_id']\
            +len(datafile.parameter_names)*['param']\
            +len(datafile.qoi_names)*['qoi_names']\
            +len(datafile.error_names)*['error_names']
    datafile.write(_fn_pareto_out)
    datafile.read(_fn_pareto_out)