From 932595f75c3c2a6f7ff9a68e70389fad374c2210 Mon Sep 17 00:00:00 2001 From: Zhisong Qu Date: Fri, 17 Jul 2020 09:45:47 +1000 Subject: [PATCH 1/6] namelist reader --- Utilities/pythontools/py_spec/SPECNamelist.py | 427 ++++++++++++++++++ 1 file changed, 427 insertions(+) create mode 100644 Utilities/pythontools/py_spec/SPECNamelist.py diff --git a/Utilities/pythontools/py_spec/SPECNamelist.py b/Utilities/pythontools/py_spec/SPECNamelist.py new file mode 100644 index 00000000..c993c92a --- /dev/null +++ b/Utilities/pythontools/py_spec/SPECNamelist.py @@ -0,0 +1,427 @@ +""" +SPECNamelist.py: contains the object that reads and writes the SPEC namelist +SPECNamelist extends the f90nml.Namelist object +Requires: + numpy + f90nml, install it using "pip install f90nml" +@author: Zhisong Qu (zhisong.qu@anu.edu.au) +""" +import f90nml +from f90nml import Namelist + +import numpy as np + +class SPECNamelist(Namelist): + '''The SPEC namelist class + To get a content within the namelist, use: + somevariable = spec_nml['whichlist']['whichitem'], e.g. spec_nml['physicslist']['Ntor'] = 4 sets Ntor in physicslist list to 4 + + To change (or add) an item on the namelist, use: + spec_nml['whichlist']['whichitem'] = somevalue + + Please do not change Mpol, Ntor and Nvol directly. To change them, please use + spec_nml.update_resolution(new_Mpol, new_Ntor) + spec_nml.insert_volume(ivol, tflux) + spec_nml.remove_volume(ivol) + + The guess of the interface Fourier harmonics, if exists, can be obtained by + spec_nml.get_interface_guess(m_number, n_number, ivol, 'Rbc') + and changed by + spec_nml.set_interface_guess(m_number, n_number, ivol, 'Rbc') + spec_nml.remove_interface_guess(m_number, n_number) + Alternatively, one can directly modify spec_nml.interface_guess + + member functions: + read, write, run, update_resolution, insert_volume, remove_volume, + get_interface_guess, set_interface_guess, remove_interface_guess + ''' + + def __init__(self, *args, **kwargs): + '''Initialization + use one of the following + 1) spec_nml = SPECNamelist(filename), e.g. spec_nml=SPECNamelist("namelist.sp") or spec_nml=SPECNamelist("/path/to/namelist.sp") + 2) spec_nml = SPECNamelist(spec_output_object), where spec_output_object + ''' + + from py_spec import SPEC + + if isinstance(args[0], str): + # the first argument is a string, read from this namelist + # first create the namelist using __init__ of the namelist object + + file_object = open(args[0], 'r') + + super().__init__(f90nml.read(file_object)) + + # now we should mind some variables that are important: we include them in the object itself and need to monitor them + self._Mpol = self['physicslist']['mpol'] + self._Ntor = self['physicslist']['ntor'] + self._Nvol = self['physicslist']['nvol'] + + # then read the part that specifies the guess of the interface geometry + self._read_interface_guess(file_object) + + file_object.close() + + # we don't know the verson of SPEC from its namelist, so leave it as 'unknown + self._spec_version = 'unknown' + + elif isinstance(args[0], SPEC): + # the first argumetn is a SPEC object, generate the quantities from the SPEC object + # first initialize an empty namelist + super().__init__() + + # then generate the namelist from the SPEC object + self._generate_namelist_from_output(args[0]) + + version_str = '{:5.2f}' + self._spec_version = version_str.format(args[0].version) + + else: + # the input is of unknown type, abort + raise ValueError('The first argument should contain either a path to the SPEC namelist, or a SPEC object generated from reading SPEC hdf5 output') + + def read(self, *args, **kwargs): + raise NotImplementedError("SPECNamelist does not support 'read' directly. Please call the constructor __init__.") + + def write(self, filename, force=False): + '''Write to a namelist file + parameters: + filename -- the filename to write + force -- force to overwrite or not + ''' + + import os + + if not isinstance(filename, str): + raise ValueError('The first argument should contain the path of the namelist to write to') + + # check if some important quantities has changed. If yes, prompt an error + if not self._Mpol == self['physicslist']['mpol']: + raise RuntimeError('Inconsistent Mpol. If one wishes to change Mpol or Ntor, please call member function update_resolution') + if not self._Ntor == self['physicslist']['ntor']: + raise RuntimeError('Inconsistent Ntor. If one wishes to change Mpol or Ntor, please call member function update_resolution') + if not self._Nvol == self['physicslist']['nvol']: + raise RuntimeError('Inconsistent Nvol. If one wishes to change Nvol, please call member function update_Nvol') + + if os.path.exists(filename): + if not force: + raise Exception(filename + ' already exists! Pleaes set force to True if you would like to force overwrite.') + + file_object = open(filename, 'w') + from datetime import datetime + + intro_str = "! auto generated by SPECNamelist.py " + file_object.write(intro_str) + + # write the time for generating the namelist + file_object.write(datetime.now().strftime("%Y-%m-%d %H:%M:%S ")) + + # write the version of SPEC if known + if not self._spec_version == 'unknown': + file_object.write('SPEC version ' + self._spec_version) + + # conclude the first line + file_object.write('\n') + + # write the main content of the namelist + super().write(file_object) + + # write the interface guess + self._write_interface_guess(file_object) + + def run(self, spec_command='./xspec', filename='spec.sp', force=False): + '''Run SPEC on the current namelist and obtain its output + parameters: + spec_command -- the command to call SPEC, usually it looks like '/path/to/spec/xspec' + or 'mpirun -np (ncpus) /path/to/spec/xspec', with (ncpus) replaced the number of cpus + filename -- write this namelist to the temporary file 'filename' in current folder + force -- if file exists, force overwrite or not + + Returns: + result -- after running SPEC, read the output hdf5 with py_spec and return the SPEC object + ''' + import os + import subprocess + import py_spec + + self.write(filename, force=force) + run_result = subprocess.run(spec_command + ' ' + filename, shell=True) + + if run_result.returncode == 0: # the run is successful + print('SPEC runs successfully') + return py_spec.SPEC(filename + '.h5') + else: + print('SPEC runs unsuccessfully') + + def update_resolution(self, new_Mpol, new_Ntor): + '''Change the Fourier resolution of the SPEC namelist + parameters: + new_Mpol, new_Ntor -- the new Mpol and Ntor + ''' + if new_Mpol == self._Mpol and new_Ntor == self._Ntor: + # nothing needs to be done + return None + if new_Mpol < 0 or new_Ntor < 0: + raise ValueError('Mpol or Ntor >= 0') + + # We will need to update the size of Rbc, etc and their indexing + changelist = ['Rbc','Rbs','Zbc','Zbs','Vns','Vnc','Bns','Bnc','Rwc','Rws','Zwc','Zws'] + + for key in changelist: + # convert the list into numpy.ndarray + data = np.array(self['physicslist'][key], dtype=np.float64) + orgmlen, orgnlen = data.shape + orgnmin = self['physicslist'].start_index[key.lower()][0] + orgnmax = orgnmin + orgnlen - 1 + + # the new data array with the new shape + newnlen = new_Ntor * 2 + 1 + newmlen = new_Mpol + 1 + newnmin = -new_Ntor + newdata = np.zeros([newmlen, newnlen]) + + # copy the data over + for ii in range(newnlen): + newnid = newnmin + ii + + # if data is provided for this n number + if newnid >= orgnmin and newnid <= orgnmax: + newdata[:min(orgmlen,newmlen), ii] = data[:min(orgmlen,newmlen), newnid - orgnmin] + + self['physicslist'][key] = newdata.tolist() + self['physicslist'].start_index[key.lower()][0] = -new_Ntor + + # We will need to update the size of Rac, etc and their indexing + changelist = ['Rac', 'Ras', 'Zac', 'Zas'] + + for key in changelist: + data = np.array(self['physicslist'][key], dtype=np.float64) + + newnlen = new_Ntor + 1 + orgnlen = len(data) + newdata = np.zeros([newnlen]) + + newdata[:min(orgnlen,newnlen)] = data[:min(orgnlen,newnlen)] + self['physicslist'][key.lower()] = newdata.tolist() + + # update start index and self + self._Ntor = new_Ntor + self._Mpol = new_Mpol + self['physicslist']['mpol'] = new_Mpol + self['physicslist']['ntor'] = new_Ntor + + + def get_interface_guess(self, m, n, ivol, key='Rbc'): + '''Get the guess of the interface Fourier harmonic + parameters: + m,n -- the m and n number of the guess, must be within the allowed Mpol and Ntor range + the n number is the one without multiplying by Nfp + ivol -- which volume, Python convention, starting from 0 + key -- which item, can be 'Rbc', 'Zbs', 'Rbs', 'Zbc' + Returns: + guess -- the initial guess of the interface harmonic used in SPEC + ''' + if ivol >= self._Nvol or ivol < 0: + raise ValueError('ivol must be between 0 and Nvol-1') + if (m,n) not in self.interface_guess.keys(): + raise ValueError('unknown m or n') + if key not in ['Rbc', 'Rbs', 'Zbc', 'Zbs']: + raise ValueError("key must be in ['Rbc', 'Rbs', 'Zbc', 'Zbs']") + + return self.interface_guess[(m,n)][key][ivol] + + def set_interface_guess(self, value, m, n, ivol, key='Rbc'): + '''Set the guess of the interface Fourier harmonic + parameters: + value -- the value that one wants to set + m,n -- the m and n number of the guess, must be within the allowed Mpol and Ntor range + the n number is the one without multiplying by Nfp + ivol -- which volume, Python convention, starting from 0 + key -- which guess, can be 'Rbc', 'Zbs', 'Rbs', 'Zbc' + ''' + if ivol >= self._Nvol or ivol < 0: + raise ValueError('ivol must be between 0 and Nvol-1') + if m > self._Mpol or m < 0: + raise ValueError('0 <= m <= Mpol') + if n > self._Ntor or n < -self._Ntor: + raise ValueError('-Ntor <= n <= Ntor') + if key not in ['Rbc', 'Rbs', 'Zbc', 'Zbs']: + raise ValueError("key must be in ['Rbc', 'Rbs', 'Zbc', 'Zbs']") + + if (m,n) not in self.interface_guess.keys(): + # add a new item + self.interface_guess[(m,n)] = dict() + self.interface_guess[(m,n)]['Rbc'] = np.zeros([self._Nvol]) + self.interface_guess[(m,n)]['Zbs'] = np.zeros([self._Nvol]) + self.interface_guess[(m,n)]['Rbs'] = np.zeros([self._Nvol]) + self.interface_guess[(m,n)]['Zbc'] = np.zeros([self._Nvol]) + + self.interface_guess[(m,n)][key][ivol] = value + + def remove_interface_guess(self, m, n): + '''Remove the guess of the interface Fourier harmonic with some m,n + parameters: + m,n -- the m and n number of the guess, must be within the allowed Mpol and Ntor range + the n number is the one without multiplying by Nfp + ''' + + if (m,n) not in self.interface_guess.keys(): + raise ValueError('unknown m or n') + else: + del self.interface_guess[(m,n)] + + def _dump_to_namelist(self, spec_hdf5_subgroup, target_namelist): + '''dump the properties in the SPEC hdf5 group to the namelist + parameters: + spec_hdf5_subgroup -- the SPEC property generated from hdf5 group + target_namelist -- the target namelist object + ''' + + for key in dir(spec_hdf5_subgroup): + # add to the namelist if it is not starting with '_' (internal python functions) + if not key.startswith('_') and not key.startswith('inventory'): + if key in ['Rbc','Rbs','Zbc','Zbs','Vns','Vnc','Bns','Bnc','Rwc','Rws','Zwc','Zws']: + # take care of all the boundary inputs + data = getattr(spec_hdf5_subgroup, key) + # we only need half of the mpol, since the data is -mpol:mpol + mdim = data.shape[0] + ndim = data.shape[1] + mdim = int((mdim - 1)/2) + ndim = int((ndim - 1)/2) + + target_namelist[key] = data[mdim:,:].tolist() + target_namelist.start_index[key.lower()] = [-ndim,0] + + elif key in ['LreadGF','Ltiming','LHevalues','LHevectors','LHmatrix']: + # take care of all the bool inputs + target_namelist[key] = getattr(spec_hdf5_subgroup, key).item() == 1 + else: + if isinstance(getattr(spec_hdf5_subgroup, key),np.ndarray): + target_namelist[key] = getattr(spec_hdf5_subgroup, key).tolist() + else: + target_namelist[key] = getattr(spec_hdf5_subgroup, key) + + def _write_interface_guess(self, file_object): + '''Write the initialization of the interface to filename + ''' + + for harmonics, data in self.interface_guess.items(): + # write m,n + output_str = '{:6d} {:6d} ' + output_str = output_str.format(harmonics[0], harmonics[1]) + file_object.write(output_str) + + # write the data + for ii in range(self._Nvol): + output_str = '{:23.15e} {:23.15e} {:23.15e} {:23.15e}' + output_str = output_str.format(data['Rbc'][ii], data['Zbs'][ii], data['Rbs'][ii], data['Zbc'][ii]) + file_object.write(output_str) + + # end the line + file_object.write('\n') + + + def _read_interface_guess(self, file_object): + '''Read the initial guess of the interface + parameters: + file_object -- the file object, created using open(filename,'r') + ''' + + # we can read all lines into the memory since the namelist file is usually not that big + file_object.seek(0) + lines = file_object.readlines() + + # first pass, we go through the file to locate the last '/' symbol, which indicates the end of the namelist + slash_counter = 0 + for line_counter, line in enumerate(lines): + if '/' in line: + slash_counter = line_counter + + self.interface_guess = dict() + + # now go back and start from the next line exactly at the location of the last '/' + for ii in range(slash_counter+1, len(lines)): + + # split the line into objects + line_split = lines[ii].split() + + # ignore empty lines + if len(line_split) == 0: + break + + # check if this line meet our expectation + valid_line = True + # first, the number of items should be equal or greater than nvol * 4 + 2 + if not len(line_split) == self._Nvol*4 + 2: + valid_line = False + else: + # the first item should be m, check if this is correct + m = int(line_split[0]) + if m < 0: + valid_line = False + + # if something wrong is detected, report a warning message, jump this line + if not valid_line: + print('Initial guess of the interface geometry ignored: line ', ii+1) + break + + # extract the n number + n = int(line_split[1]) + + # now parse the line, put the data in a dictionary + self.interface_guess[(m,n)]=dict() + self.interface_guess[(m,n)]['Rbc'] = [float(line_split[2+lvol*4]) for lvol in range(self._Nvol)] + self.interface_guess[(m,n)]['Zbs'] = [float(line_split[2+lvol*4+1]) for lvol in range(self._Nvol)] + self.interface_guess[(m,n)]['Rbs'] = [float(line_split[2+lvol*4+2]) for lvol in range(self._Nvol)] + self.interface_guess[(m,n)]['Zbc'] = [float(line_split[2+lvol*4+2]) for lvol in range(self._Nvol)] + + def _generate_namelist_from_output(self, spec_hdf5): + '''initialize the namelist from SPEC output: + parameter: + spec_hdf5 -- A SPEC object generated by reading SPEC hdf5 output + ''' + + # create the namelists + self['physicslist'] = Namelist() + self['numericlist'] = Namelist() + self['locallist'] = Namelist() + self['globallist'] = Namelist() + self['diagnosticslist'] = Namelist() + self['screenlist'] = Namelist() + + self._dump_to_namelist(spec_hdf5.input.physics, self['physicslist']) + self._dump_to_namelist(spec_hdf5.input.numerics, self['numericlist']) + self._dump_to_namelist(spec_hdf5.input.local, self['locallist']) + self._dump_to_namelist(spec_hdf5.input.global1, self['globallist']) + self._dump_to_namelist(spec_hdf5.input.diagnostics, self['diagnosticslist']) + + # we don't dump screenlist since it is not saved in the hdf5 + #self._dump_to_namelist(spec_hdf5.input.screen, self['screenlist']) + + + # now we should mind some variables that are important: we include them in the object itself and need to monitor them + self._Mpol = self['physicslist']['mpol'] + self._Ntor = self['physicslist']['ntor'] + self._Nvol = self['physicslist']['nvol'] + + # replace some namelist objects by those from the output + self['physicslist']['Rac'] = spec_hdf5.output.Rbc[0,:self._Mpol+1].tolist() + self['physicslist']['Zas'] = spec_hdf5.output.Zbs[0,:self._Mpol+1].tolist() + self['physicslist']['Ras'] = spec_hdf5.output.Rbs[0,:self._Mpol+1].tolist() + self['physicslist']['Zac'] = spec_hdf5.output.Zbc[0,:self._Mpol+1].tolist() + self['physicslist']['mu'] = spec_hdf5.output.mu.tolist() + self['physicslist']['pflux'] = spec_hdf5.output.pflux.tolist() + self['physicslist']['helicity'] = spec_hdf5.output.helicity.tolist() + self['physicslist']['adiabatic'] = spec_hdf5.output.adiabatic.tolist() + + # generate the guess of the interface + self.interface_guess = dict() + for ii in range(spec_hdf5.output.mn): + m = spec_hdf5.output.im[ii] + n = int(spec_hdf5.output.in1[ii] / spec_hdf5.input.physics.Nfp) + self.interface_guess[(m,n)] = dict() + self.interface_guess[(m,n)]['Rbc'] = spec_hdf5.output.Rbc[1:,ii] + self.interface_guess[(m,n)]['Zbs'] = spec_hdf5.output.Zbs[1:,ii] + self.interface_guess[(m,n)]['Rbs'] = spec_hdf5.output.Rbs[1:,ii] + self.interface_guess[(m,n)]['Zbc'] = spec_hdf5.output.Zbc[1:,ii] From f1bb03c5e0be96d87fd4e8d2456984abe6860c0a Mon Sep 17 00:00:00 2001 From: Zhisong Qu Date: Fri, 17 Jul 2020 09:52:12 +1000 Subject: [PATCH 2/6] added change to read_spec.py --- Utilities/pythontools/py_spec/SPECNamelist.py | 5 +++-- Utilities/pythontools/py_spec/read_spec.py | 5 ++++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/Utilities/pythontools/py_spec/SPECNamelist.py b/Utilities/pythontools/py_spec/SPECNamelist.py index c993c92a..78a42c0c 100644 --- a/Utilities/pythontools/py_spec/SPECNamelist.py +++ b/Utilities/pythontools/py_spec/SPECNamelist.py @@ -149,10 +149,11 @@ def run(self, spec_command='./xspec', filename='spec.sp', force=False): run_result = subprocess.run(spec_command + ' ' + filename, shell=True) if run_result.returncode == 0: # the run is successful - print('SPEC runs successfully') + print('SPEC runs successfully.') return py_spec.SPEC(filename + '.h5') else: - print('SPEC runs unsuccessfully') + print('SPEC runs unsuccessfully, check terminal output.') + return None def update_resolution(self, new_Mpol, new_Ntor): '''Change the Fourier resolution of the SPEC namelist diff --git a/Utilities/pythontools/py_spec/read_spec.py b/Utilities/pythontools/py_spec/read_spec.py index 6a99feab..64ddcb6c 100644 --- a/Utilities/pythontools/py_spec/read_spec.py +++ b/Utilities/pythontools/py_spec/read_spec.py @@ -43,7 +43,10 @@ def __init__(self, *args, **kwargs): for key in _content: if isinstance(_content[key], h5py.Group): # recurse into group - setattr(self, key, SPEC(content=_content[key])) + if key in keyword.kwlist: # avoid assign python keywords + setattr(self, key + '1', SPEC(content=_content[key])) + else: + setattr(self, key, SPEC(content=_content[key])) elif isinstance(_content[key], h5py.Dataset): # read dataset if key in keyword.kwlist: # avoid assign python keywords setattr(self, key + '1', _content[key][()]) From d4d62f478c49fbf22453ff1abae1a29ce2df63cb Mon Sep 17 00:00:00 2001 From: Zhisong Qu Date: Mon, 20 Jul 2020 16:09:31 +1000 Subject: [PATCH 3/6] add and removing interface is now working --- Utilities/pythontools/py_spec/SPECNamelist.py | 273 +++++++- Utilities/pythontools/py_spec/compare_spec.py | 32 + .../py_spec/jupyter_files/SPEC_namelist.ipynb | 649 ++++++++++++++++++ 3 files changed, 947 insertions(+), 7 deletions(-) create mode 100755 Utilities/pythontools/py_spec/compare_spec.py create mode 100644 Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb diff --git a/Utilities/pythontools/py_spec/SPECNamelist.py b/Utilities/pythontools/py_spec/SPECNamelist.py index 78a42c0c..e92bc701 100644 --- a/Utilities/pythontools/py_spec/SPECNamelist.py +++ b/Utilities/pythontools/py_spec/SPECNamelist.py @@ -14,7 +14,7 @@ class SPECNamelist(Namelist): '''The SPEC namelist class To get a content within the namelist, use: - somevariable = spec_nml['whichlist']['whichitem'], e.g. spec_nml['physicslist']['Ntor'] = 4 sets Ntor in physicslist list to 4 + somevariable = spec_nml['whichlist']['whichitem'], e.g. spec_nml['physicslist']['Lconstraint'] = 1 sets Lconstraint in physicslist list to 4 To change (or add) an item on the namelist, use: spec_nml['whichlist']['whichitem'] = somevalue @@ -102,7 +102,7 @@ def write(self, filename, force=False): if not self._Ntor == self['physicslist']['ntor']: raise RuntimeError('Inconsistent Ntor. If one wishes to change Mpol or Ntor, please call member function update_resolution') if not self._Nvol == self['physicslist']['nvol']: - raise RuntimeError('Inconsistent Nvol. If one wishes to change Nvol, please call member function update_Nvol') + raise RuntimeError('Inconsistent Nvol. If one wishes to change Nvol, please call member function insert_volume, remove_volume') if os.path.exists(filename): if not force: @@ -124,6 +124,12 @@ def write(self, filename, force=False): # conclude the first line file_object.write('\n') + # convert all np.ndarray to list + for key1 in self: + for key2 in self[key1]: + if isinstance(self[key1][key2], np.ndarray): + self[key1][key2] = self[key1][key2].tolist() + # write the main content of the namelist super().write(file_object) @@ -146,6 +152,9 @@ def run(self, spec_command='./xspec', filename='spec.sp', force=False): import py_spec self.write(filename, force=force) + + print('SPEC is running...') + run_result = subprocess.run(spec_command + ' ' + filename, shell=True) if run_result.returncode == 0: # the run is successful @@ -154,6 +163,91 @@ def run(self, spec_command='./xspec', filename='spec.sp', force=False): else: print('SPEC runs unsuccessfully, check terminal output.') return None + + def insert_volume(self, ivol=0, tflux=None): + '''Insert a volume + parameters: + ivol - insert volume inside the ivol-th volume (Python index starts from 0) + if ivol == Nvol, insert a volume outside the plasma boundary + tflux - the tflux of the volume inserted, default is the middle point of the volume + ''' + assert ivol>=0 and ivol<=self._Nvol + Nvol = self._Nvol + + # set default tflux + if tflux is None: + if ivol == 0: + tflux = self['physicslist']['tflux'][0] / 2.0 + elif ivol == Nvol and self['physicslist']['Lfreebound'] == 0: + tflux = self['physicslist']['tflux'][ivol-1] * 1.1 + else: + tflux = (self['physicslist']['tflux'][ivol-1] + self['physicslist']['tflux'][ivol]) / 2.0 + + # we interpolate the initial guess first + self._interpolate_guess(ivol, tflux) + + zero_index_keys = ['pflux', 'mu', 'helicity', 'pressure', 'adiabatic', 'Lrad', 'nPtrj', 'Ivolume', 'Isurf'] + for key in zero_index_keys: + if key.lower() in self['physicslist'].keys(): + # make it a list if there is only a single item, and convert it to float + if isinstance(self['physicslist'][key], int) or isinstance(self['physicslist'][key], float): + self['physicslist'][key] = [float(self['physicslist'][key])] + self['physicslist'][key].insert(ivol, self['physicslist'][key][min(ivol, Nvol-1)]) + + if key.lower() in self['diagnosticslist'].keys(): + self['diagnosticslist'][key].insert(ivol, self['diagnosticslist'][key][min(ivol, Nvol-1)]) + + one_index_keys = ['iota', 'oita', 'qr', 'pr', 'ql', 'pl', 'rq', 'rp', 'lq', 'lp'] + for key in one_index_keys: + if key.lower() in self['physicslist'].keys(): + self['physicslist'][key].insert(ivol+1, self['physicslist'][key][min(ivol+1, Nvol-1)]) + + self['physicslist']['tflux'].insert(ivol, tflux) + + # interpolate to get quantities in the new volume + if ivol == Nvol: + # add a new volume outside the plasma boundary, we can extrapolate so don't do anything + pass + else: + interpolate_list = ['pflux', 'mu', 'helicity', 'Ivolume', 'Isurf'] + + # update Nvol + self._Nvol = self._Nvol + 1 + self['physicslist']['nvol'] = self['physicslist']['nvol'] + 1 + + def remove_volume(self, ivol=0): + '''Remove a volume + parameters: + ivol - Remove the ivol-th interface (Python index starts from 0) + ''' + assert ivol>=0 and ivol= 2: + Lslab = False + if ivol == 0 or ivol == self._Nvol: + Lcoordinatesingularity = True + else: + Lslab = True + + if ivol == self._Nvol: + if self['physicslist']['Lfreebound'] == 0: + Lextrapolate = True + else: + Lextrapolate = False + else: + Lextrapolate = False + + # if the inserted volume is outside the last volume, we need to extrapolate + if Lextrapolate: + raise RuntimeError['Extrapolating outside the plasma boundary is not supported'] + else: + if Lcoordinatesingularity: + + r_left = 0.0 + r_right = np.sqrt(self['physicslist']['tflux'][0]) + r_int = np.sqrt(tflux) + + self._interpolate_guess_singular_each('Rbc',ivol,r_left,r_right,r_int) + self._interpolate_guess_singular_each('Zbs',ivol,r_left,r_right,r_int) + self._interpolate_guess_singular_each('Rbs',ivol,r_left,r_right,r_int) + self._interpolate_guess_singular_each('Zbc',ivol,r_left,r_right,r_int) + else: + if ivol == 0: + tflux_left = 0.0 + else: + tflux_left = self['physicslist']['tflux'][ivol-1] + + tflux_right = self['physicslist']['tflux'][ivol] + + if Lslab: # for a slab, radius is the same as tflux + r_left = tflux_left + r_right = tflux_right + r_int = tflux + else: # for cylinder or toroidal, radius is the same as sqrt(tflux) + r_left = np.sqrt(tflux_left) + r_right = np.sqrt(tflux_right) + r_int = np.sqrt(tflux) + + # interpolate + self._interpolate_guess_normal_each('Rbc',ivol,r_left,r_right,r_int) + self._interpolate_guess_normal_each('Zbs',ivol,r_left,r_right,r_int) + self._interpolate_guess_normal_each('Rbs',ivol,r_left,r_right,r_int) + self._interpolate_guess_normal_each('Zbc',ivol,r_left,r_right,r_int) + + def _interpolate_guess_normal_each(self, key, ivol, r_left, r_right, r_int): + '''Interpolate the interface harmonic guess, normal way + parameters: + key -- which item? 'Rbc', etc + ivol -- which volume? + r_left, r_right -- the left and right "radius" + r_int -- the interpolate "radius" + ''' + for mnkey, item in self.interface_guess.items(): + value_int = self._interpolate_normal(item[key], ivol, r_left, r_right, r_int) + item[key] = np.insert(item[key], ivol, value_int) + + def _interpolate_guess_singular_each(self, key, ivol, r_left, r_right, r_int): + '''Interpolate the interface harmonic guess, normal way + parameters: + key -- which item? 'Rbc', etc + ivol -- which volume? + r_left -- dummy, not used + r_right -- the right "radius" + r_int -- the interpolate "radius" + ''' + # replacing 'b' by 'a' we will get the keys for Rac and so on + key_axis = key.replace('b', 'a') + + for mnkey, item in self.interface_guess.items(): + m = mnkey[0] + n = mnkey[1] + if m == 0: + value_axis = self['physicslist'][key_axis][n] + else: + value_axis = 0.0 + value_int = self._interpolate_singular(item[key], ivol, m, r_right, r_int, value_axis) + item[key] = np.insert(item[key], ivol, value_int) + + def _extrapolate_guess_singular_each(self, key, ivol, r_left, r_right, r_int): + '''Interpolate the interface harmonic guess, normal way + parameters: + key -- which item? 'Rbc', etc + ivol -- which volume? + r_left -- dummy, not used + r_right -- the right "radius" + r_int -- the interpolate "radius" + ''' + # replacing 'b' by 'a' we will get the keys for Rac and so on + key_axis = key.replace('b', 'a') + + for mnkey, item in self.interface_guess.items(): + m = mnkey[0] + n = mnkey[1] + if m == 0: + value_axis = self['physicslist'][key_axis][n] + else: + value_axis = 0.0 + value_int = self._interpolate_singular(item[key], ivol-1, m, r_right, r_int, value_axis) + item[key] = np.insert(item[key], ivol, value_int) + + @staticmethod + def _interpolate_normal(data, ivol, r_left, r_right, r_int): + '''Linear interpolation''' + if ivol == 0: + value_left = 0.0 + else: + value_left = data[ivol-1] + value_right = data[ivol] + # linear interpolate + value_int = (value_right - value_left) / (r_right - r_left) * (r_int - r_left) + value_left + + return value_int + + @staticmethod + def _interpolate_singular(data, ivol, m, r_right, r_int, value_left): + '''Singular interpolation''' + value_right = data[ivol] + + # interpolate + s = float(r_int)/float(r_right) + if m == 0: # for m==0, we need to interpolate between axis value and boundary value + value_int = value_right * s**2 + value_left * (1.0 - s**2) + else: # otherwise, we don't need the axis value + value_int = value_right * s**m + + return value_int + + + + + diff --git a/Utilities/pythontools/py_spec/compare_spec.py b/Utilities/pythontools/py_spec/compare_spec.py new file mode 100755 index 00000000..baad7dad --- /dev/null +++ b/Utilities/pythontools/py_spec/compare_spec.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +@author: Caoxiang Zhu (czhu@ppp.gov) +For any help, type ./compare_spec.py -h +""" +import numpy as np +from py_spec import SPEC + + +def compare_spec(data, reference, tol=1e-12): + match = True + for key, value in vars(data).items(): + if isinstance(value, SPEC): # recurse data + print('------------------') + print('Elements in '+key) + compare_spec(value, reference.__dict__[key]) + else: + if key in ['filename', 'version']: # not compare filename and version + continue + elif key == 'iterations': # skip iteration data (might be revised) + continue + else: + # print(key) + diff = np.linalg.norm(np.abs(np.array(value) - np.array(reference.__dict__[key]))) + unmatch = diff > tol + if unmatch: + match = False + print('UNMATCHED: '+key, ', diff={:12.5E}'.format(diff)) + else : + print('ok: '+key) + return match \ No newline at end of file diff --git a/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb b/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb new file mode 100644 index 00000000..af82836c --- /dev/null +++ b/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb @@ -0,0 +1,649 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Examples of SPECNamelist\n", + "\n", + "@author: Zhisong Qu (zhisong.qu@anu.edu.au)\n", + "\n", + "To use this utility, the f90nml package is needed.\n", + "One can install\n", + "\n", + "## 1. Import SPEC hdf5 reader and SPECNamelist" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import py_spec\n", + "from py_spec import SPEC\n", + "from py_spec.SPECNamelist import SPECNamelist\n", + "from py_spec import compare_spec" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Generate SPECNamelist. There are two ways to generate it:\n", + "Here, we assume that one ran SPEC on `G3V02L1Fi.001.sp`. SPEC generated two output files, `G3V02L1Fi.001.sp.end` and `G3V02L1Fi.001.sp.h5`\n", + "\n", + "### 1) It can be initialized from a .sp or .sp.end file -- the ordinary SPEC namelists" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "namelist_end = SPECNamelist('G3V02L1Fi.001.sp.end')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2) It can be generated from the SPEC class reading the SPEC hdf5 output file" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "spec_hdf5 = SPEC('G3V02L1Fi.001.sp.h5')\n", + "namelist_h5 = SPECNamelist(spec_hdf5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Writing the namelist into file\n", + "Here we write the two namelist objects into two different namelist intput files. One can run them and compare their outputs using compare_spec. They should be identical.\n", + "\n", + "If the file exists, one needs to put `force=True` to force overwriting." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "namelist_h5.write('test_h5.sp',force=True)\n", + "namelist_end.write('test_end.sp',force=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Running SPEC directly using SPECNamelist (Optional)\n", + "If we set up properly, one can directly run SPEC using SPECNamelist.run(). This only works if one can run SPEC directly, for example on a personal PC or when an interactive job is running for this Notebook. If you need to submit a job to run SPEC, you cannot use it.\n", + "\n", + "### 1) We will need to set up the command to run SPEC.\n", + "We let \n", + "`SPEC_command = '/path/to/xspec'`, or `'mpirun -np 2 /path/to/spec'`\n", + "\n", + "### 2) We set up the filename the namelist is going to output into and SPEC is going to run with\n", + "Something like `filename = 'test.sp'`, meaning that the file we are going to run is 'test.sp'.\n", + "\n", + "### 3) Finally, we run SPEC\n", + "The command looks like \n", + "\n", + "`new_output = SPECNamelist.run(SPEC_command, filename).`\n", + "\n", + "If SPEC runs successfully, the hdf5 file will be read and return as new_output.\n", + "\n", + "To check the output of SPEC, one needs to check the terminal in which Jupyter Notebook is launched.\n", + "\n", + "In this section, we run SPEC with both the namelist generated from the .end file and .h5 file, they should be identical." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEC is running...\n", + "SPEC runs successfully.\n", + "SPEC is running...\n", + "SPEC runs successfully.\n" + ] + } + ], + "source": [ + "SPEC_command = '/Users/zhisong/Codes/SPEC_hdf5master/SPEC/xspec'\n", + "\n", + "filename = 'test_end.sp'\n", + "output_end = namelist_end.run(SPEC_command, filename, force=True)\n", + "\n", + "filename = 'test_h5.sp'\n", + "output_h5 = namelist_h5.run(SPEC_command, filename, force=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Now we test if the two outputs obtained by running the two namelists above are identical\n", + "\n", + "If you have can run part 4, `output_end` and `output_h5` will be loaded already. We reload them just in case you cannot run part 4." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------\n", + "Elements in grid\n", + "ok: BR\n", + "ok: BZ\n", + "ok: Bp\n", + "ok: Nt\n", + "ok: Ntz\n", + "ok: Nz\n", + "ok: Rij\n", + "ok: Zij\n", + "ok: pi2nfp\n", + "ok: sg\n", + "------------------\n", + "Elements in input\n", + "------------------\n", + "Elements in diagnostics\n", + "ok: LHevalues\n", + "ok: LHevectors\n", + "ok: LHmatrix\n", + "ok: Lcheck\n", + "ok: Lperturbed\n", + "ok: Ltiming\n", + "ok: Ppts\n", + "ok: absacc\n", + "ok: absreq\n", + "ok: dpp\n", + "ok: dqq\n", + "ok: epsr\n", + "ok: fudge\n", + "ok: nPpts\n", + "ok: nPtrj\n", + "ok: odetol\n", + "ok: relreq\n", + "ok: scaling\n", + "------------------\n", + "Elements in global1\n", + "ok: Lfindzero\n", + "ok: LreadGF\n", + "ok: bnsblend\n", + "ok: bnstol\n", + "ok: c05factor\n", + "ok: c05xmax\n", + "ok: c05xtol\n", + "ok: epsilon\n", + "ok: escale\n", + "ok: forcetol\n", + "ok: gBnbld\n", + "ok: gBntol\n", + "ok: mcasingcal\n", + "ok: mfreeits\n", + "ok: opsilon\n", + "ok: pcondense\n", + "ok: upsilon\n", + "ok: vcasingeps\n", + "ok: vcasingits\n", + "ok: vcasingper\n", + "ok: vcasingtol\n", + "ok: wpoloidal\n", + "------------------\n", + "Elements in local\n", + "ok: LBeltrami\n", + "ok: Linitgues\n", + "ok: Lposdef\n", + "ok: maxrndgues\n", + "------------------\n", + "Elements in numerics\n", + "ok: Lextrap\n", + "ok: Linitialize\n", + "ok: Lsparse\n", + "ok: Lsvdiota\n", + "ok: Lzerovac\n", + "ok: Mregular\n", + "ok: Ndiscrete\n", + "ok: Nquad\n", + "ok: iMpol\n", + "ok: iNtor\n", + "ok: imethod\n", + "ok: iorder\n", + "ok: iotatol\n", + "ok: iprecon\n", + "------------------\n", + "Elements in physics\n", + "ok: Bnc\n", + "ok: Bns\n", + "ok: Igeometry\n", + "ok: Istellsym\n", + "ok: Isurf\n", + "UNMATCHED: Ivolume , diff= 9.40672E-03\n", + "ok: Ladiabatic\n", + "ok: Lconstraint\n", + "ok: Lfreebound\n", + "ok: Lrad\n", + "ok: Mpol\n", + "ok: Nfp\n", + "ok: Ntor\n", + "ok: Nvol\n", + "ok: Rac\n", + "ok: Ras\n", + "ok: Rbc\n", + "ok: Rbs\n", + "ok: Rwc\n", + "ok: Rws\n", + "ok: Vnc\n", + "ok: Vns\n", + "ok: Zac\n", + "ok: Zas\n", + "ok: Zbc\n", + "ok: Zbs\n", + "ok: Zwc\n", + "ok: Zws\n", + "ok: adiabatic\n", + "ok: curpol\n", + "ok: curtor\n", + "ok: gamma\n", + "ok: helicity\n", + "ok: iota\n", + "ok: lp\n", + "ok: lq\n", + "ok: mu\n", + "ok: mupfits\n", + "ok: mupftol\n", + "ok: oita\n", + "ok: pflux\n", + "ok: phiedge\n", + "ok: pl\n", + "ok: pr\n", + "ok: pressure\n", + "ok: pscale\n", + "ok: ql\n", + "ok: qr\n", + "ok: rp\n", + "ok: rq\n", + "ok: tflux\n", + "------------------\n", + "Elements in output\n", + "ok: Bnc\n", + "ok: Bns\n", + "ok: Btemn\n", + "ok: Btomn\n", + "ok: Bzemn\n", + "ok: Bzomn\n", + "ok: ForceErr\n", + "ok: IPDt\n", + "ok: Ivolume\n", + "ok: Mrad\n", + "ok: Mvol\n", + "ok: Rbc\n", + "ok: Rbs\n", + "ok: TT\n", + "ok: Vnc\n", + "ok: Vns\n", + "ok: Zbc\n", + "ok: Zbs\n", + "ok: adiabatic\n", + "ok: helicity\n", + "ok: im\n", + "ok: in1\n", + "ok: lmns\n", + "ok: mn\n", + "ok: mu\n", + "ok: pflux\n", + "ok: tflux\n", + "ok: volume\n", + "------------------\n", + "Elements in vector_potential\n", + "ok: Ate\n", + "ok: Ato\n", + "ok: Aze\n", + "ok: Azo\n", + "------------------\n", + "All test matches!\n" + ] + } + ], + "source": [ + "from py_spec.compare_spec import compare_spec\n", + "output_end = SPEC('test_end.sp.h5')\n", + "output_h5 = SPEC('test_h5.sp.h5')\n", + "ismatch = compare_spec(output_end, output_h5)\n", + "print('------------------')\n", + "if ismatch:\n", + " print('All test matches!')\n", + "else:\n", + " print('Something is not matching')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Changing the namelist\n", + "\n", + "### 1). Changing individual items\n", + "In this example, we change tflux of the inner most volume from 0.3 to 0.4 and see what happens. We do it based on `namelist_h5`.\n", + "\n", + "To do so, we can run\n", + "\n", + "`namelist_h5['physicslist']['tflux'][0]=0.4`\n", + "\n", + "We will plot the result before and after the change." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEC is running...\n", + "SPEC runs successfully.\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAEUCAYAAABpmDIHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUVfrHP2daMuk9kJBC70WaFAUEe+/dta3oqj/buoq6KoK69rJiX0VdRVFWsYtUpUpvAaQmEEJ6T2Yy7fz+uCECZpJMMiUTzud57hO8c88934mZ+d5zznveV0gpUSgUCoUiUOgCLUChUCgUxzfKiBQKhUIRUJQRKRQKhSKgKCNSKBQKRUBRRqRQKBSKgGIItIBgIyEhQWZmZgZahkKhUAQV69atK5ZSJjb2mjIiD8nMzGTt2rWBlqFQKBRBhRAix91rampOoVAoFAFFGZFCoVAoAooyIoVCoVAEFGVECoVCoQgoyogUCoVCEVCC1oiEEGlCiDlCiAohRKUQ4kshRHoL26YLIT4UQuwXQliEEDuFEE8KIcJ9rVuhUCgURxOU4dtCiDBgEVAHXA9I4ElgsRBikJSypom24cACwAg8CuwHRgBPAD2BK3yrXqFQKBRHEpRGBNwCdAN6Syl3AwghNgO7gFuBl5poOxbNcM6QUv5cf26xECIOuF8IESalrPWddIVCoVAcSbBOzZ0PrDpsQgBSyn3AcuCCZtqa6n9WHnO+HO33IbwlUqFQKBTNE6xG1B/Y2sj5LKBfM20XoI2cnhVC9BNCRAghJgJ3A281Na2nUCgUCu8TrEYUB5Q1cr4UiG2qoZTSCpyE9t6zgCpgIfAdcGdjbYQQk4UQa4UQa4uKitqiW6FQKBTHEKxG1GqEEKHAbCAJuA4YD/wDLUjh9cbaSCnfkVIOl1IOT0xsNGefQqFQKFpJsAYrlNH4yMfdSOlIbgYmAD2klHvqz/0qhKgA3hFCvCWl3OQ1pQqFQqFokmAdEWWhrRMdSz9gWzNtBwJlR5jQYVbX/+zbRm0KhUKh8IBgHRF9A7wghOgmpdwLIITIRAvNntJM23wgVgjR48ioO+DE+p8HvaxVoWgT0lqLq6wQl7UG6qxImxXpsCHr6sBuRdpsSLsNdDqE3gAGPcJgAr0RYTAgjCbQGxAR0eii49FFxmnnFIp2gpBSBlqDx9RvSt0EWIB/om1onQ5EAoOklNX112UAe4BpUspp9ecygc1ohvQU2obW4WibW3cCI6WULnd9Dx8+XKp6RApPkXYbzry9OPKycRYcwFmYh6O4EGdJMc6ychyV1bhq63BZ7bjqnLhsTlw2icsO0uX9HQVCL9EZQWcU6Iw6RIgefZgJfUQY+uhI9DHRGGLj0CckoY9PRp/cBUNGL/Qp3RG6YJ1IUQQSIcQ6KeXwxl4LyhGRlLKmPuT6ZeC/aHt/FgL3HDahegSg54gpSCllthBiFDAVLRtDAnAAeAd4qikTUijc4SzIwbZ9LY7sXdhzc7AfysNRWIK9pAp7hQ1HrQTpqaHUXy8kOgMIAwidQOhA6AXohPbfeu0ngHRJpEuC1P7N4f92gctZb2wOgXQKnE5wWgFc9YcdqAHcR4YKncQQITBGh2KIjcCQGIexU2cMqemYeg7ANGAUutgkj39/iuOboBwRBRI1Ijp+cZUXY9u6EtuOjdh2/45tfy62/DJspXU4rc2bjD5UojfrMUSY0EeEoo+OQB8bgyEuXht5xMSji4pBFx2nTaFFJ6CLTUSER3t1FCIdDmR1Oa7KUlwVxbiqyrWjpABHcQHO0hKcZaU4KypxVtbgrLbgrLZhr3bisrXgfZolpvhQTMlxmNJSMHXvhanPEEwnjEcXEe2196EILpoaESkj8hBlRB0f6XBgz1qJdd1S6rZuwro3h7qDFdir3LcReokpxoAxLgxDQgzG5CSMXdIxpHfH2LUvhu4D0YVF+u9N+AhXeTH2vVk4sndgz92HIy8Xe0ERjuIybMU12Cuc7qcShcQUoyMkJYaQbhmE9BtE6NCTMPYfjTAE5eSMwgOUEXkRZUQdC+lwYFu3EMvy+Vg2b6IupwBrkQ3paOTLVCcxReswJUViSk3GlNkVU++BmAaciKFrf7V2grYW5ti9Cdv2ddh2bcOWk40trxBbQSW2clej05NCLwlNMhHavQvmIUMIHXMGpkFjlTl1MJQReRFlRMGNY/9OLL98g2XdKiw79mI9WIvL/ucvR0M4hHSKILRbGiH9BhA6dCymwScjQsMCoLpj4KquwLZ+MdaNq6jbsY26nDzq8mtwNJJUS2eSmFPDCe3dFfPQkZhPvQxDSlf/i1Z4DWVEXkQZUXBh35dF7U+zqV25gtrf87BV/Pnv3RAB5ow4zP37EDp0FCHDJ2Lo0j0Aao9PnIeysS7/Ecva5Vi278Z6oBxH7Z8fDkLidYT1SSNs1BjCzrgSQ3ov/4tVtBplRF5EGVH7xrF/J7U/zqJm1Qpqt+diKz/671sYJOYUM+beXTEPG0no+PMwdm1sb7QikNh3b8Ky9Aes69dg2bEPS54F6TzanEyxgrDeqYSPPZnw869Hn5wRILWKlqCMyIsoI2pfSIcD6+I5VP/4FdXrtmEtcBz1ujBIwjIiCB8ygLBTzib05PMRIaEBUqtoLa7aKqyL/kftr/Op3byD2gM1RxuTkJhTQokY1p/wsy8m9KQL1BpTO0MZkRdRRhR4nAU5VH/1HjW//EL19oKjQqeFXhKWHk7YkH6ETzib0PEXqHWdDoi01GD59Wtql/xIzbqt1B6wHBUIoQ+VRPRNJnz8eCIuvQ19QkoA1SpAGZFXUUYUGBy5u6iaNYOqRcuoyak56kvHGAkRgzKImHQGYef8BV10fACVKgKBsziPmm8/pGbJIqq35h4VACF0kvDuUUROmkDkFbej75wZMJ3HM8qIvIgyIv/hyNlB1awZVC5ZQe3+2j/MR0jC0sxEjBpKxHlXYRo2UYVOKxqQLhe2tQup/u4zqlasw5Jr5cgsFeGZ4UROGEvklbdjyOgTUK3HE8qIvIgyIt/iLM6j6sMXqZi36OjpFp0kvFskUZMmEHnlHeqpVtFiHPu2UTX7TaqWrDh6NC0k4d0iiD73bCKvvluNpH2MMiIvoozI+0i7jZqv36Xii9lUbS1sWIRumFI5bSKRV/xNRUUp2owjbx/Vs9+gatEvVO+phPosEDqjJHJQCtGXXUXYuTeqQAcf0CGNSAiRhpb09DS0cfcCtKSn+1vYvi8wDTgFCEfLwv2GlPLVptopI/IedesXU/HBa1Qs337UnH5YWijRZ00i8rp70SemBk6gokPjyN1D5UcvUTF/KdZD9obzhgiIPqk/sbc+iLHviAAq7Fh0OCMSQoShlYGo448yEE8CYWhlIBrZq31U++HAImAJ8D5QAfQEIqSULzXVVhlR25B1Vqo+eYmy2XOozbE0nDdGQvT4wURffxemgWMCqFBxPFK3fjEVH71O5bIs7Ifz9wtJRI8oYq+6ivDL7lA1nNpIRzSiu4GXgN6Hi9sJIboCu4AHmjITIYQO2Ar8LqW8yNO+lRG1DkfODspfn07ZwvUNox+hl0QNSSHmyuswn3Wdmg5RBBzpcFD7/QeUf/IhlVuLGqbujJEQc9oIYm77p8ro0Eo6ohEtBEKllGOPOf8LgJRyfBNtJ6LVLhonpVzqad/KiDzDsvBzSt95jcotf3yoTTGC2LNPJvq2f6JPSguwQoWicRz7d1L+1pOUz1/zR+Z1nSR6SCfi/m8KoaPPDKi+YKMpIwrWmNf+aKOaY8kC+jXT9qT6n6FCiFVCCLsQolAI8W8hhNmrKo9TpMtF9ezXyDn9BLLveJzKTcUgIaJ3NGlP3km3ZZuJe+xtZUKKdo0hvRcJT39E9xWbSHtsMhG9okBCxfoC9t14L/vPHUHN1/9BulQtzbYSrCMiG/CSlHLKMeefBKZIKd3O8Qgh3gJuBcqAGWhrRcPRAhfmNTZdJ4SYDEwGSE9PH5aTk+Ott9KhkHVWKt9/mpJZX1JX5AS0aKTY8X2IveMRtfCrCHpsm5dT+up0yldlN0R3hiYbiL/mUiKvf1Clj2qCDlcqvI0cHgV+LKV8rP7fS4QQeuAZIURfKeX2IxtIKd9BKyXO8OHDg8+5fYy01FD+6hRK/regYQpDb5bEnX0isfc8rSLfFB0G06CxdHrvJxJy91D2yiOULdiItcDBwZc+w/jebBKvu5CoW6eqwAYPCdapuTIgtpHzcfWvNUVJ/c/5x5z/uf7nCW3QdVwh66yUv/wP9pw8nPwPNBMyRgs63XQ6PZb+RsJTHyoTUnRIDF26k/jCZ/T4ZTmdrp+EMQrsFZK8GV+xd9wQKt+einQ4mr+RAgheI8pCWyc6ln7Atha0bQo14dsM0uGg8u2p7B0/lENvf4e9GkyxOlLvvYLuyzYS+8Cr6CKiAy1TofA5uuh4Yh+aQfelG+h867kYI8FWJjn48mz2jR9M5ftPqzWkFhCsRvQNMEoI0e3wCSFEJjC2/rWm+BFt/9EZx5w/HAKjQuLcIF0uqj55iX0ThnDw5dnYyiXGKEi540K6/bpBTUkojltESCgx9z5P91/X0umm0zGEQ12Ji4PP/ZfsCYOp+ea9QEts1wRrsEI42oZWC39saJ0ORKJtaK2uvy4D2ANMk1JOO6L948CjwHP8EazwODBbSnlDU30fr+HbdavnUzD1IWr2apuADOGQcMXpxNz1L1VmQaE4BldtFeWvTKFkzsKGarORfWNIeuIFTIPGNtO6Y9Lh9hEBCCHSOTrFz0K0FD/ZR1yTCewDnpBSTj3ivADuBW4H0oFDwIfAdCnlH7k+GuF4MyLnoWyKHr2dsuV7QQp0JknCRScR+48X1fSbQtEMrooSSp68k5IfNiCdAqGTxE7oRcITbx5366cd0ogCxfFiRLLOStmLf6d49kKcdQKEJGZUBonT38DQpXug5SkUQYV99yaKHrubivUFgFa4L/GaM4m594XjJqNIR9zQqvAhlkVz2DdpOAUfLcJZJwjLMNP1vZfoPHOeMiGFohUYewwmZdYSMt96EnOXEJxWQf5788g5Yzh1q48N4D3+UEakaMBVXkzB384n+45/UlfsxBgJXaZcT/qPawkdc3ag5SkUQY95wiVk/Lye1HuvQG+WWA7WsfeG/6Pw3stwVVcEWl7AUEakAKB6zuvsPe1kShfvAiBuYk+6zV9K5A1TVPVThcKLCJ2OqFun0n3efGJGdQGXoOTHreybNJqaL98OtLyAoNaIPKSjrRE5Cw9QcM91DXPXIQl6Oj/5BOYJlwRYmaK1SCmpsldRbCmmxFJCsaWYMmsZ1fZqqm3VDT+tTit2l107nHYcLm0Dpk7oGg690GM2mAkzhhFuDCfcGK792xBOpCmSeHO8doRqh1FvDPC7Dz5qv/+QQ089h61U228UMzqd5FdmdbiKsSpYwYt0JCOq/XYmB594Dke1Vg014cKRxD/2lgrHDgLsTjv7q/azt2IvB6oOcLDqIAerD5JbnUt+TT51zrqA6IoLjSMlPIWUiD+O9Mh0ukV3o1N4J7SAVcWxSEsNxY/fQvF368ElMMUIUp6ehnnipYGW5jWUEXmRjmBE0lpL0ZS/UDJvK0hBaCcjKS+9RshQt9UzFAGk1FpKVnEWWSVZ7Czbyd7yveRU5uCQ7lPIhBnCSDAnkGBOIN4cT2xILJGmSCJMEUQYI4gwRWA2mDHqjA2HQadFb0kkTpcTl3ThkA6sDis19hpq7bXUOGoa/l1RV0GJtYQSSwkl1hLKrGU4pdOtJrPBTNfornSL7kbv2N70je9L3/i+RJmivP47C1asv87l4JRHtNGRkCSeN4z46e91iGSqyoi8SLAbkW3TUg7edQfWAjsgiT9zAInPfKRGQe0Ep8vJzrKdrC1Yy4bCDWQVZ5FXk/en6wSC1IhUusd0Jy0yjS6RXUiNSG04woz+///pdDkpsZaQV53HweqDDT+zK7PZV7GPUmtpo+26RHShb3xfBicOZmjSUPrE98GoO36n+FxVZRT+/VrKft0LgDnFRMprb2PqPyrAytqGMiIvEsxGVPHWYxya8TnSITBEQOrjDxB23o2BlnVcI6VkX8U+lh5cyur81Wwo2EBVQxU2DbPBTN+4vvRP6E/fuL50j+lO1+iumA3BVT6r3FrO3oq97KnYw++lv7O9ZDu/l/3+p2nEUH0oAxMHMjRpKKNTRjMocdBxaUzVc17n0NOv4ajVNpKnPvQ3Iq66O9CyWo0yIi8SjEYk66wU3n0ZpUt2AxA1MJ5Or3+qCtMFiDpnHavyVvFr7q8sO7jsTyOe1IhUhiUPY1jyMAYlDKJrdFf0On2A1PoWu8vOvop9ZBVnsaFwAxsKN5BdmX3UNWGGMEZ2GsnolNGcnHoyaVHHz9+t81A2eZMvp3pXFSBJOGcwCc9+EpSbYJUReZFgMyJH7i4O3nQ5tfutICTJ100idsprKiTbz1gdVpYfXM7POT/zS+4v1NhrGl6LC41jTMoYxqSMYXjycDpHdA6g0sBTYilhY9FG1uSvYWXeSvZW7D3q9R4xPZiYPpGJaRPpF9+vwwdASIeDkkeup+jrdYAgvHsEqf/5An3nzEBL8whlRF4kmIzIsvBzch94HEeNVqiuy5MPEXbO9YGWddzgki7WFaxj7u65zM+Zj8VhaXitb1xfTkk7hZO7nEy/+H7ohH8eDKx2JyU1NsprbVRY7FTU2im32Kmy2rE7JXanC7vThcMpsTu17waTQYfJoCPEoMOoF4QY9ESGGogNMxEdZiQ2zERsmJGoUCM6nfdNIb8mn5V5K1mRt4JlB5dRba9ueC05LJmzup7F2V3Ppk9cnw5tStWfzyDvqRk464S22fzVF4Nqo3mHNCIhRBpHJz1dgJb0dL+H95kC/AtYLqU8qbnrg8WIKt+eSt6rnyFdAnOKidR3P8bYfWCgZR0X5Nfk8+WuL/lmzzccrD7YcL5/fH9Ozzyd09JP89n0ksslOVhuYVdhFXsKazhYbiGv3EJehYW8ciulNTaf9Aug1wk6RYWSGmumS4yZlBgzqbFmMuLD6JUcSXy4qc1GYXfaWZO/hkUHFrF4/2IKLYUNr3WL7sbZXc/mvO7nkRKR0ta30y6xb19D7m03YS1woDNKUh//PyIuvSPQslpEhzMiIUQYWhmIOv4oA/EkEIZWBqKmieZH3qcbsBmoAXZ1BCOSLhclj95I0f9WAxBzYhc6vTUXYQ4PsLKOjZSStQVrmbV9FosOLMIltc2JncI7cX738zm/+/lkRGV4tU+bw0VWXgUb9peTlVfJrsIqdhdWU2tzH0Jt1AsSIkKINhsbjpgwI5GhRkwGHUadwKjXYdBrox+AOocLm8OFzenC7nBR53BRYdFGUuW1Nspr7ZTV2qiyNl2RNDbMSM/kSHolR9ArOZJBXWLo2zmSEEPr1r9c0sXmos18v/d75mXPo6xOK84sEIxJHcNlPS9jXNq4Dhfo4Kqu4NAN51C5tQSEpPMt5xJz3wuBltUsHdGI7gZeAnpLKXfXn+sK7AIekFK+1ML7zAOygd6AIdiNSNZZyb/tfMpXHgAg6fIxxE19V60H+RC7y86P+37kg6wP2FWmpUcyCAOnZpzKJb0uYWSnkV6bdquw2Fm5p5g12WVs2F/G1rxKbI4/V/9MiAihV3IEPZIiSIsNIyXGTEpMKKkxZhIiQnwyfQbatN+hCit55RYOllnIrf+5t7ia3QXVVNX92ahMeh39U6MYkhbDCemxDM+IJSXG82hAu8vOqrxVfLv3WxbmLMTm0kZ+CeYELupxEVf2uZKksKQ2v8f2gnQ4KLrnMkoW7AAg/qwBJL44u11/1juiES0EQqWUY485/wuAlLLZnZlCiKuBV9FM6EuC3IhctVXkXXM6VdvLETpJyn3XEPXXRwMtq8NidViZu3suM7fObIh6iw+N5/Lel3Npr0u98qXndEk25Zbz684ilu4qZuOBcpyuoz+vPZIiOCEthkFpMfROjqRnUgSx4e2vSq6UkvxKKzsLqtlVUMX2Q1Vsyi1nd2H1n67tlhjOST0SOKlHAqO6xxMV6tmIptxazrd7v2XOzjkNgQ4GnYGzu57Ndf2uo09cH6+8p/ZA2bN3kf/BzyAF0Sck0/mDn9rt5teOaET5wNdSyluPOf8GcJmUMrGZ9rHADmCKlHKmEGIJQWxErvJicq8+k5q9NeiMkrTnHiHsrOsCLatDYnfambNrDu9sfodiSzEAmVGZ3DzwZs7pek6bc605nC5W7S3l+y2HmJeVf9SajkEnGJoRy+hu8QzNiGVIWgzR5uCedqqw2NmcW87G/eWs31/G2uyyo0ZOep1gcJdoTu/fiTP7dyIzoeVTzFJK1heu55Ptn7Bw/8KG6dITO53IrYNvZUSnEV5/P4GgetbL5D79NtIhiOwTTcqs+ejCIgMt6090RCOyAS9JKaccc/5JNHNpMsheCPEftJHQOCmlbM6IhBCTgckA6enpw3JycrzwLryDsziPA1ecjeVgHfpQSfprzxF68vmBltXhcEkXP+37idc2vEZudS6gRb7dMugWJqZNbNM+Hyklq/eV8vWmPH7aerT5pMeFMb5XIuN6JTKqWxyRHo4Ogg2H08Wm3HKW7Sph+e5i1u8vw3HEKLBPp0jOHNCJMwd0ondyZIuDHw5UHWDW9ll8uetLah21AAxLHsbfBv+NkZ1GBn20nWX+Z+z/+1RcNkF493C6fDYfXWRsoGUdhTKio685Ga2s+FAp5db6c0sIwhGRszSfA5eegSXPhiEc0t99S+WL8wGbijbx9G9Ps61kG6CNgO4eejeT0ie16QusrMbG/9bn8unq/ewp+iO+pltCOOcM6sw5gzp79GXbEamuc7BsVxHzsgpYsL3gqICI3smRXDa8CxeekEpCREiL7ldpq2TW9ll8tO0jqmxaBouhSUO5d9i9DEka4pP34C+sy75l/53/wGnVilmmzVnYrsyoIxpRATC3NVNzQohtwC/AQ0ec/g7QA2cBFiml29TF7cWIXGWF7L/sdCy5dRjCIeOjmUGfi6q9UWIp4ZX1rzB391wAksxJ3D7kdi7ocUFDgtDWsOlAOe8v38ePW/KxObXpoqTIEC4d1oVzB6XQt/PxbT7usDlcrNhTzLysfOZlFTSMHA06wSl9krhsWBdO6ZOEUd/8gn2VrarBkCptlQCcnnE69wy9J6gzN9StWUDO5DtxWupHRl8sbjfTdB3RiBYBpmNHMPUjG9FUsIIQork3fK+U8hV3L7YHI3JVV3Dg4gnU7rdqJjTzP5gGjW2+oaJFSCn5avdXvLDmBarsVRh1Rm7ofwN/HfjXVicTlVKyfHcJb/6ym+W7SwAQAsb1TOTqE9OZ2MIvUIWGzeFi0Y5C5qw7wOLfixqCODpHh3L9mEyuGpFOdFjz05jVtmre3/o+/932X6xOKwadgav6XMXtg28nwhTh67fhE+pWzydn8v/htAoiekfTZfaidpHUuCMa0T3AC0AvKeXe+nOZaOHbU6SULzbRdkIjp19BGxH9H7BbSpnrrn2gjUjabRy8YgJV28rQmyWZM9/BNGRcwPR0NA5VH2LqyqmsyFsBwEmpJzFl5JRW7wGSUvLztgJeX7ybzblaKeiIEAPXnJjOtaMySIsL/BdEsFNYZWXuhoN8tvoAe4u1Kc4wk57LhnXhxrFdWxTgkF+Tz4wNM/hmzzdIJInmRB4Y8QBnZJ4RlKNT67Jvybn9H7hsgugTkuj8yeKAh3Z3RCMKR9vQauGPDa3TgUi0Da3V9ddlAHuAaVLKaU3cbwlBsEYkXS7ybz6T8pUH0BklGW+9SOjYcwKipaMhpWTu7rk8u+ZZauw1RIdE8/DIhzmr61mt/iJatbeEZ3/awYb95QAkRJi4cWxXrh2VEfTRbu0Rl0vyy84i3lu2j2W7tYhGIeDsgZ25e1JPeiU3P0W1vWQ7T/72JJuLNgMwJmUMj5z4COlR6T7V7gssCz4n557HkA5B/Ol9Sfr3lwHV0+GMCEAIkc7RKX4WoqX4yT7imkxgH/CElHJqE/daQhAYUfFD11H01VqETpL+7IOqhIOXqLHXMG3lNH7Y9wMAk9In8c9R/yTBnNCq+2UX1zDtu20s2qGln0mIMHHnKT24cmQ6ocaOmUW7vbEjv5L3l+1j7oY8bE4XQsA59YbUsxlDckkX/9v1P15Z9wqVtkrMBjP3DbuPK3pfEXSjo+pPX+XAtDdBCpL/MpG4h18PmJYOaUSBIlBGVDnzXxx89iNAkvrAX4i66WG/a+iIbC/Zzv2/3M/+qv2YDWYePvFhLuh+Qau+cCw2J68v3s07v+7F5nQREWJg8rhu3HxSV8JDgi9tf0fgUIWFN5fs4bPVB7A5XegEXDEijXtP60VSZNMbP0ssJTy35rmGB5TRnUczbew0OoV38od0r1H+8j849PZ3ICRp0wOXm04ZkRcJhBFZl35D9m0PIJ2CxItHkPD0R37tv6Py474feXT5o9Q56+gV24vnxz9Pt+hurbrXit3FPPC/zeSWaRm2Lx3WhQfP7ENiZMvCihW+5VCFhdcX7+bT1QdwuiRhJj23je/O5HHdmh2l/pz9M9NXTae8rpxIYyTTxk7j1IxT/aTcOxTecyklP2WhM0m6/vddTINP9rsGZURexN9G5DyUzb7zzsJeTbtZdAx2XNLFjA0zeHfLuwBc1OMiHhn1CCF6z02jus7Bv37Yzie/aUnf+3aO4skL+zMsI86rmhXeYU9RNf/6YQcLthcA2obh6RcOYHyvJpOxUGwp5okVT7AkdwkA1/a9lvuG3dfmTBr+Qjoc5F4ylurfKzHF6sj8dj76BP9mKFdG5EX8aUTS4SD3ojFU76oiNNlAxvfL0EVE+6XvjorNaWPK0inMz5mPTuh4YMQDXN3n6lZNxW3JreDOT9eTU1KLUS+4a2JPbpvQXYVhBwEr9hTzxDfb+L1A29R67qDOPHZevyan66SUfLz9Y15a+xIO6WBQ4iBeHP9i0EzVOYvzyD7/NGylLqIGxpMy+1e/PtQ2ZUTqE9OOKXn8Zqp3VWn16t94V5lQG6m2VXP7gtuZnzOfSGMkb576Jtf0vcZjE5JSMnP5Pi5+czk5JbX07RzFN3eexP9N6rhNlGUAACAASURBVKlMKEgY0z2B7+46iSln9SHUqOO7zYc44+Vf+WHLIbdthBBc1+86Zp45k+SwZDYXbebq768mqzjLj8pbjz4hhS4zZiAMksotJZS/dH+gJTWgPjXtFMuCzyn68jcAUv7xV5U1oY2UWku5ad5N/Jb/GwnmBGaeOZMxKWM8vo/F5uT/Pt3AE99uw+6UXD86g69uH0PfzlE+UK3wJUa9jtvGd2f+veM5uWcCZbV2bv9kPfd8toGKWrvbdkOShvDFeV8wPHk4RZYibvjpBhbkLPCj8tYTMvQUOt92MQAFM3/AuvKnACvSUFNzHuKPqTlXRQn7zjgZW7kkbnx3kt/+zqf9dXTKreXc/PPN7CzbSVpkGm+f9jZpkZ6ncTlUYWHyR+vYcrCCiBADz186iLMGdvaBYoW/kVLy8aocnvphO1a7iy6xZt64ZiiDusS4bWN32nli5RN8vedrAO4ffj/X97/eX5LbRN61E6lYe4iQRD1df/7NL4Uz1dRckFF43zXYyiWmOB2JL34SaDlBTUVdBZPnT2Zn2U4yozL58MwPW2VC2w9VcsGM5Ww5WEF6XBhf3j5GmVAHQgjBdaMz+eGukxnUJZrcMguXvrmSj1fl4O5h3ag3Mn3sdO4eejcAL6x9gTc2vuH2+vZEp9c+wxgJdUVOih+5KdBylBG1N2q/+4Cy5Tmgk6Q+85RaF2oDFoeF2xfczvbS7aRHpvPeGe+RGNZ0dFRjrM0u5Yq3V1JYVceJXeP4+o6xLdqlrwg+uiVG8MVto7luVAY2p4t/zt3KA3M2N1oJFzQD++vAvzJ97HR0Qsebm97khbUvtHsz0sUm0flRbY2o+MdNWJb8L7B6Atq74iikpYZDTz0PQMKZgwkdd2GAFQUvTpeTB399kM3Fm0mNSOW9M95rVdXUZbuKufa936i0Oji9XzIf3jSyXVZAVXiPEIOe6RcO4NUrhxBq1PHFulz+8v5vlNfa3La5sMeFPD/ueQw6Ax9t+4jn1jzX7s0o/PybiR3XDaQg//GpSLv79+drlBG1I0qmTsZW5sIULYif9k6g5QQ1z699nsUHFhNliuKNU99oVYjtqr0l/PWjNVjtLi4b1oU3rhmqUvQcR1wwJJUvbh1DUmQIq/aWcvEbKzhQWuv2+tMzT+fVU17FoDPw8faPeWvzW35U2zqSnp2JIRysBQ7KX7gvYDqUEbUT7DvXU/zdOgA6PXi3mpJrA3N2zuGT7Z9g1Bl59ZRXW5UtYf3+Mm76QDOhK4an8ewlgzCo0OzjjoFdopl7x1j6dIpkb3ENl7+9kr1F1W6vH9dlHM+New6d0PHGxjf4ZHv7XuPVxSaRfMd1ABTOWoBj/87A6AhIr4o/UfjYvUinIHJAHOEX39p8A0WjZBVn8fRvTwMwdcxUhndqNEinSbKLa7j5gzXU2pxcfEIqT188EJ0uuJJdKrxHSoyZL24bzYjMWA5VWLn87VXsyK90e/1pGacxdfRUAJ5Z/QwLcxb6SWnriLxhCuHdw3HZBcVT/y8gGoLWiIQQaUKIOUKICiFEpRDiy/qM3M21Gy6EeEcIsUMIUSuE2C+E+EQI0dUfuhvDsmgOlRsLETpJ0hNuSykpmqGiroL7ltyH3WXnit5XcH738z2+R2mNjRtmrqas1s4pvRN57tJB6JUJHfdEhhr58KaRnNQjgeLqOq559zf2NDEyuqjnRQ3RdA8te4jfS3/3l1SPETodyY89BUJStjIH28Zf/a4hKI1ICBEGLAL6ANcD1wE9gcX1tYqa4kqgP/BvtNLgU4ChwFohREBqBBc9/y8AYif0UhtX28BTq54iryaPAfEDeGDEAx63dzhd3PHJerJLaunXOYoZVw9V03GKBsJMBv5z/XDG9UqkpMbGdf/5jYPlFrfX3zzgZs7rdh4Wh4W7Ft1FiaXEj2o9I+TEM4gelgJSUDh9it/7D9ZP2S1AN+BCKeVcKeXXwPlABtDcvNazUsqxUso3pJS/SClnAWcCsfX39Su182ZRs68WnVGS8Oi//d19h2Fe9jx+zP4Rs8HMc+Oew6T3PLLt5QU7Wbm3hISIEN6/YYQq3aD4E6FGPW9dO5RhGbHkVVi57j330XRCCB4f8zgDEwaSV5PHw8sexiUbDwNvDyQ+9hJCL6nKKsO64ge/9h2sRnQ+sEpKufvwCSnlPmA5cEFTDaWURY2cywGKgFQv62yW4n+/BEDsxP7oO2f6u/sOQYmlhCdXPQnA34f9nbQozwe2S34v5PXFe9AJeO2qE+gU3XStGsXxS5jJwPvXj9ACGIpquHPWBhzOxg0mRB/CyxNeJiYkhhV5K/h428d+VttyjL2GEDNaW6EoeeVffu27yUc+IcRfvNDHRinlZi/c50j6A183cj4LuMzTmwkh+gJJwPY26vII669zqdlTg84giXvwBX923aF4ed3LlNeVM6rzKC7vfbnH7ctrbTwwR/sT/fvpvRndPd7bEhUdjOgwI+/dMIILZixj2e5invphO4+f17/Ra5PDk3lizBPcvfhuXln/CiM7j6RPXB8/K24Z8fc/Sdnya6jcUkTixl8xDRnnl36bm3v4AGjtrixR3/YJwNtGFAeUNXK+FG2KrcUIIQzAW2gjovfcXDMZmAyQnu692vWlb70CQMzYHhhSAhYrEdRsKtrE13u+xqgz8uioR1tVzuHxb7IorKpjeEYst43v7gOVio5IaoyZt64dxlXvrmLm8mxOSI/l/MGN1/iZmD6Ry3tdzuc7P+eRZY8w+9zZGHTtb+rX2GcY0cNSqFh7iNIZ/6LTf9qHEYE28mhs9NEcAni/Fe38zQxgDHCOlLIxc0NK+Q7wDmhJT73RqSNnB5Ub8wGIveMhb9zyuMMlXTzz2zMAXN//etKjPH9IWPJ7IV9vzMNs1PPCZYNVhJzCI4ZnxvHYef15dO5WHvlqC0PTY+gSG9botfePuJ/lecvZWbaTWdtn8Zf+3phw8j5xf/s7FTffT8Vv+0gszUcf5/t6Sy1ZI9oopfywFccHPtRdRuMjH3cjpUYRQjyDNtK5SUr5s5e0tYjyN59EugQRvaIxDRrrz647DIv2L2JryVYSzYncMtDzOBObw8W0b7cBcM+pPclM8H0GYkXH49oT0zmtXzJVVgf3zd6E09X4s6rZYObhEx8GYMbGGeTX5PtTZosJHXsO5i4huOyCynee8kufzRnR90Bbttq2tb07stDWiY6lH7CtJTcQQjwCPAjcJaX8rxe1NYt0uahYsh6A2Cuv9GfXHQaXdPHGpjcAuGXQLYQZG38KbYoPVuxjb3EN3RLDuXGsmhpVtA4hBM9eMoikyBBWZ5cy67cct9eO6zKO0zJOw+Kw8PK6l/2o0jNiL9X24JX/sMQv/TVpRFLK86SUn7X25m1t3wTfAKOEEA25W4QQmcDY+teaRAhxF/Ak8IiUcoYP9DWJdf5sbOUSvVkSfsnf/N19h2Dh/oXsKttFclgyl/S8xOP2VVY7byzZA8Cj5/bDZAjWAFJFeyAu3MS0CwYA8NxPv1NYZXV77f3D78eoM/Ljvh/ZVbbLXxI9IvLav6MzSqyFDurWLvJ5f8H66XsXyAa+FkJcIIQ4H20d6wDw9uGLhBAZQgiHEOKxI85dCbwC/AQsEkKMOuLo5w/xFbM/ACB6VC9EiAoTbg0fZX0EwM0Db27VnqEPlmdTXmtnRGYsE3p5XhpCoTiWM/onM6lPElV1Dp7+3n0AbkpECpf2uhSJZMYGvz8HtwhdRDSR9YEXFZ+86fv+fN6DD5BS1gAT0ab9/gt8AuwDJkopj8y7IQA9R7/PM+vPnwmsPOZ4w+faHQ6qNmpD96jL2udiZXtnW8k2NhZtJNIYyQXdm9w21ii1Ngf/WbYPgHtP69WqSDuF4liEEEw9vz8mg465G/PYluc+H93kQZMJ1Yey6MAidpTu8KPKlhN98RUAVK3I8nlfrTIiIcR5QohHhRBvCyHeb+RoNAzam0gp90spL5FSRkkpI6WUF0ops4+5JltKKaSUU484d0P9ucaOCb7Wbf3lSxy1AkM4hE642NfddUg+26HN9l7Q44JWrQ3N3ZBHhcXOkLQYxnRP8LY8xXFMWlwY15yoRW++NN/98niCOYFLe10KwKzts/yizVPCzrsRfYjEViGpW/+LT/vyyIjqp7o2A3PR9gfdAtzg5lA0QtW3nwMQeUImQheUA9KAYnFYmJc9D4Arel/hcXspJR+s0EZDN47N9KY0hQKA2yf0wGzUs2B7AVtyK9xed2UfLVDp+73fU2ZtcbCv3xBGE+F9tGnr6q99G8/l6Tfhv4EBwExgAlqi0a6NHJ4XgDlOqNmkPSVFTDozwEqCk6W5S6l11DIgfgCZ0Zket9+UW8HOgmoSIkI4a0Bn7wtUHPckRoZwdf2oaGb9Q09jZERlcHLqydhcNr7a/ZW/5HlExIRTAKj5bYNP+/HUiCYC86SUf5VS/iql3COlzGns8IXYYMdVVog13wZCYj7D86d5BfyU/RMAZ3ZtnZF/vfEgAOcPTlGRcgqfcf3oTISA7zYdori6zu11l/XSMpL9uO9Hf0nziPBzrgWg9kAN0uq+Om1b8fSTaAe2+ELI8UDtz7NBCkI7mfyyW7mjYXfaWXZwGQCnZ5zucXuXS/Ld5kMAXDCk8VQsCoU3SI8PY2LvJGxOF1+uz3V73djUsUQYI9hRuoPsimz/CWwhhvRemGIE0imwLv/OZ/14akTL0abmFK3AsmY5AGG9MwKsJDjZVLQJi8NCt+hudI7wfFpta14FRVV1pMaYGdRFlWJX+JbLhncB4Pv6h5/GMOlNTEyfCNCw9tneMPfQHpprl873WR+eGtFjwLj6vTgKD7HuygYgdODgwAoJUlYdWgXA6JTRrWr/y+9aBZDxvRNVyLbC50zonUSYSc+m3AoOlLqf1pqUPgmAFXkr/CXNI8wDtbFH3e++SJKj4VH6VynlBiHEJOB7IcStwHqgsbAQKaWc7g2BHYm6g9qvKnTE+AArCU42FGoLpiM7jWxV+2W7iwEY11NtYFX4nlCjnol9kvhu8yEWbC9wm0ZqeKfhCARbirdgdVgJNbSvTe4hg0YC87Hm+q7CrKfh29HA02jJRccD9wJT3RyKI3CVFWKvBqGTmAafHGg5QYeUku2l2m71AQmezw47XZIt9Q8CwzM9qhSiULSak3tq+9R+21vq9pooUxS943pjd9nZXOTtijltJ2SENnVoK3Eg69ynLmoLnhbEeBk4BViAltEgD3B4W1RHxLZ9LQDGaJ1K69MKDlYfpMpWRVxoHIlmz0c0uwurqbU5SY0xkxAR4gOFCsWfObGrVmRxdXYpLpdE56bMyLDkYewo3cGmok2M7Ny6Eb+v0CekYAgHR43AvmcTpn4ner0PT43oXGCFlNLzkKXjHPsuLdjQGK9KDbSG3eVaVfjesb1btb6zI19LtzIgNcqruhSKpsiIDyMxMoSiqjoOlNWS4ebz3yOmBwD7KtzvOwokxmgTjhobjj3bfGJEngYrmIH2uaLWzrHv1/7ATElxAVYSnORV5wGQGpnaqvY5JdpicdeECK9pUiiaQwhB7+RIAPYUVbu9rlu0lgNgb8Vev+jyFGOc9h7sOb7JFu6pEW2gnWRNEEKkCSHmCCEqhBCVQogvhRAtKtEphAgVQjwvhDgkhLAIIVYKIXxaE9dZqs0R62NjfNlNh+VQjRYCmxLeuv0/h40oI97z3HQKRVvonqiNgnYXujeirtFaIEN2ZbY/JHmMIUFbV3UcyvPJ/T01ounAeUKIk3whpqUIIcKARUAf4HrgOrR0Q4uFEC2Z+3oPLU/eY2jTjYeAeUKIIb5RDM5KbWpIH6tGRK2hoLYAgE7hrdsIXFS/u71TtFqfU/iX9PrpuNwyi9trYkJiMAgDNfYa6pzuMzEECl2UNiJyVlf55P6erhF1Br5Dq+MzC1hH4+HbSCk/aqO2prgFbWTWW0q5G6A+Gesu4FbgJXcNhRCDgavRyoPPrD/3C1rV12nA+b4Q7KyqAUAfoyK2WkOtXRvRRBhbN7VWUWsDIMZs9JqmDsvmz2HhNKjIpdbciefsV/Bh9UhSYsz844zeXHhC66ZHj1fiwrW/ufJau9trhBBEh0RTYi2hsq6SxLD2tcVAH6mtrbqqa3xyf0+N6ANAotXz+Uv9cWyBdlF/zpdGdD6w6rAJAUgp9wkhlgMX0IQR1be1A7OPaOsQQnwGTBFChEgpvf5IIu1acKEINXv71scFNXbtA9Casg8AFRbtSyBaGVHTbP4cvr0L7NrTe5jlEA/INyjV2fim/CQe+lILulFm1HJizFrhxnKLeyMCGoyovK683RmR7rAR1baP8O0bfaLCc/qjVWQ9lizgsha03SelPHarcxZgAnrU/9urSJcLAGFQX4StwerQPgCt3ezncGnPS0a9SnTaJAunNZjQYcKEjQcMn/ON7SQsdifPz/tdGZEHZJdoD1G/7ixq8rrDgQqr81fTM7anz3V5QvVSLcdjxYYCfJGl0dPMCh/6QENriAMaK+BRCjQ399VU28OvH4UQYjIwGSA9vUXxEH+m/osQvaferwDQ1ddukvLYAbjCq1Q0nqAzRfyxqz6v3P1ah+LPWO2uQEtoM9Lm2+2i6vGwBUgp35FSDpdSDk9MbOWQuf5JXNptXlR2/GDSadMbNmfrfn+6+r1HTpcysiaJ7tLo6TwZ3/DvlBg1vewJh6PmhqY3HTEbF6o9A4/oNMLnmjwlfLSmKbK/b4KtgtWIymh85ONutNPStvDHyMir6EK0L1JZ45uok46OUadNabY2oijKrI1EK61Nz9Mf90x6DIxHG02tNPGc43IAzEY9/zijdyCUBS02pzYiSo5qelr58N94pDHS55paiz7KN/vwmjQiIcQ2IcTtrb15W9s3QRbaWs+x9AO2taBt1/oQ8GPb2oDdf27SdnShWloZV437vQQK98SEak+TZXWtK6ncsGDcROSSAhh0OZz3b4hOAwS15s48Z7ydb10nkRpj5l8XD1TrQx5SVKU9PMWGm9xeI6WkyqY9pLY2IMeXyBptnUtn9k16rOYWLPoACW24f1vbu+Mb4AUhRDcp5V4AIUQmMBaY0kzbb4En0IIaPqxvawCuAH72RcQcgD5Se5JwlvlkwNXhOZxfrthS3Kr28RHal0BBpW+ifjoUgy7XDiAMlcW4rRwo1dbU0uPcG0x5XTm1jloijBFEmdpfGipHibZGaIiPb+bK1tGSlfMJbajd4qsJ+XeBO4GvhRD/rO9nOnAAePvwRUKIDGAPME1KOQ0aSlnMBl4RQhiBfcDfgK7ANT7SiyE5GdiBo6h1X6THO4eNqKi26cgjdxz+EtjfRF0YhcIXHP6bS4t1b0QHq7US9qkRqe2yVpajTNsuqk9I8sn9W2RE9Ue7QUpZI4SYiJYN/L9oe5cWAvdIKY+c+xKAnj9PQd4IPAU8CcQAm4AzpZTrfaXZ0FmbzrCXNrr/V9EMaZFpAOyrbF1SyMPJJrNLlBEp/EtWnvaZ75Xsfn1lf+V+QDOi9oijXPtaNST7Rl9zRnSKF/rI9sI9/oSUcj9wSTPXZKOZ0bHnLcB99YdfMGZo+wLsJWqNqDV0j+kOwJ7yPa1qf/hL4PCXgkLhD/IrrByqsBIZYqB7onsj2lqyFYA+8X38Jc0jbMXa9KKpj2+yoDVpRFLKX3zS63GIaYhWDM9W6kDabQij+4VLxZ9Ji0zDpDORX5NPpa3S43n0Pp2iMOl17C2qodJqJypUbSxW+J71+7XgmsFpMW5rEQENBfEGJQzyiy5PcFWV4agBhMTYZ7hP+gjW8O2gQ5+YiiFMIp0C+461gZYTdOh1+oanxdZUsTQZdPRN0cxrw/5yr2pTKNyxaEchAKO7u1/ktzltbC9pffVhX2PbpGVVMEXpEKG+iehTRuRHQpK0dYq69UsDrCQ4GZY8DIC1+a0z8jH1XwZLm0m1olB4A6dLNhjR6f2S3V63On81NpeN3rG9iQ6J9pe8FmNd8ysAIV18l7BZGZEfCe2VAYBl3W8BVhKcDE/WpgXWFKxpVfvxvbTIu1+UESn8wG97SyitsZEeF0aPJPfrQ0sOLAFgQtoE/wjzEOsWbQbC3Md3+e+UEfkR8/BRAFh2tM9ywO2dYcnDMOqMbCna0qr9REPTY4kMMbCrsLrJapkKhTf4bM0BQMtU7i4k2yVdLD6wGIBT0rwRG+Z9LHu0YnihI8b6rA9lRH7EPOFCACwHLUiLb+p6dGTCjeGM6jwKiWx4ivQEk0HHmQO0wnrfbPRNpUmFAqC0xsZPW/MRAi4f3nj+PoA1+WsorC2kU3gn+sX386PCluEsPIC10A46iXn8BT7rRxmRHzGk9yIkXod0CmrnzQq0nKDk1IxTAViQs6BV7S8You2DmLvxIC6VAFXhIz5ZlYPN6WJcz0S6NLGRdc7OOQBc1OOidrmRtfaHT0AKzCmh6GJ9s5kVlBH5nfBB2n6YmgU/BFhJcHJK2ikYdAZWHlpJfk2+x+1Hd48nJTqUnJJaft2l1ooU3qe6zsF7y7Xp91vHdXN7XZm1jIX7FyIQXNTjIn/J84iaX7Vpw/AT+vq0n2aNSAjxvhDi3pbeUAhxvRBiUdtkdVwiJp0FQPWGnQFWEpzEhsYyKX0SLuniq91fedxerxNcO1oLGvlgRbaX1SkU8N+VOZTX2hmWEdtk2PanOz7F7rJzUupJdI7o7EeFLUM6HFRt0jI+RJzuu2k5aNmI6Aa0BKOfCSFaUh4zExjfFlEdGfPZ16IzSupKXNStVX7dGi7pqSXU+HLXlzhcnhfsunJEOiEGHUt+L2L7oUpvy1McxxRX1/HGYi2B/12Terqdbqu2VfPx9o8BuGnATX7T5wnWhV/gqAFDOISecqlP+2rp1JwLuBxYKoRof9YdROjCIokcpP0KKz97J8BqgpMTO59IZlQm+TX5/JT9k8ft48JNXH2iVmn3lQVqZKrwHi/M+52qOgfjeyUyrqf7wgOf7viUKlsVw5KHMbyTb7IVtJXKrz8FIHJYN4TBt5WlW2pELwJzgGHAGiFEQH9zQgidEOIhIUS2EMIqhNgkhGgy71x9uyghxGNCiBVCiBIhRHn9vy/0h+7DRJ2nzQdXLt+MdAV/GWF/oxO6hqfI97a8h0t6/jv824TuhBp1zMsqYEuuyj+naDsb9pcxe+0BDDrBo+f2czsaKrOWMTNrJgCTB032p8QWI+usVK7SHtKiLrrS5/211IhqpZSXo2WsTgF+EUL4Xp17pqOVSJkBnAWsAr4QQpzdTLt04HbgF+BatBpEO4GvhBB3+EztMYRf+Ff0ZomtTGKZ94m/uu1QnNvtXJLDktldvptF+z2f4kyKDOX60ZkAPPFtFlKqCDpF67HYnPz9801ICTef3LXJDayvbXiNKlsVozuPZnTn0X5U2XKqv3gdR63AFCMwn+Gz6jgNeBQ1J6V8FK1mjwA+EUJM94mqJhBCJAH3A89IKV+QUi6WUt4KLAaeaab5PqCblPIhKeWPUsp5UsobgEXAgz4VfgQiNIyYk7U9A+Uf/cdf3XYojHojNw+8GYBX17+K3eV55dU7JvYgISKEtTllzN140NsSFccRz83bwd7iGnokRXDvqb3cXre9ZDtzds7BIAxMGTmlXYZsA5TP+QKA6EkjEDrfB1d73IOU8lO0+kQFwMNCiDlCCHPTrbzKGYAJ+PiY8x8DA4UQXd01lFLWSCkbK0izFm2k5zdibn0AgMpNBTjyVKaF1nBpr0vJjMokuzKbz3//3OP2UaFGHjyzNwBPfb+dkmqfFOdVdHDmbytg5vJs9DrBS5cPJtSob/Q6u8vOEyufQCK5qu9VdItxH9odSGzbfqP693IQkui/PuCXPltldVLK1cBIYCNwMbBcCOF++7B36Q/UAbuPOZ9V/7M125PHATvaIspTTP1HEd49AukSlL38sD+77jAYdUbuG6aVlHpz05uUWj0vw37J0C6M7hZPcbWNx77Oar6BQnEE+4pruG/2RgD+fnovBnWJcXvtf7b8h6ySLDqHd+b2wbf7S6LHlL06HaQganAyxq79/dJnq8dcUspc4CTgf8AQYLUQYpS3hDVBHFAu/zypX3rE6y1GCDEZGAX8q6lrhBBrhRBri4q8twky/hZtobJs/gZcFSVeu+/xxIS0CYzuPJqKugqeXf2sx+11OsFzlw4i3KTn+y2HmLtBTdEpWkaV1c5t/11HVZ2DM/on87fx3d1eu61kG+9s0qJknxz7JBEm92tIgcRZdJDyFdozfvztLd4+2mbaNPknpbRIKS9DK7ndCW2d5ixP7iGEOFUIIVtwLGmLVjd9TwD+DXwkpXQbNSClfEdKOVxKOTwxMdFr/YedfzOhyUacVkH5a4967b7HE0IIHh39KGaDmR/2/cAvBzyv5ZgWF8aj52oD6Ye/2sKugipvy1R0MGwOF7d9vI7fC6rolhjOC5cNdrveU2mr5IFfH8AhHVzT9xpGdh7pZ7Utp/S5+3HZBWHpoYSO818wsVdWoaSUjwFXAxIY4WHzFUDfFhx/qb++DIgRf/6/fngk1KL5GSHECOAbtECFv3qo2SsInY74G64CoOTLRWpU1ErSItO4c8idAExbOa1VU3RXjEjjwiEp1Nqc/O2T9VTXeb5RVnF84HJJ/jFnE8t3l5AQEcIHN4wk0k3FX5d08cjSR8ipzKF3bG/uHnq3n9W2HGdBDqU/bQAg4Q6/BREDLTOiHKDZkpZSys/4I4ihxUgpa6WUO1pw7K9vkgWEAMeOgw+vDW1rrk8hxEBgHtoa1yVSSs9DrrxE5PUPEppkwFErKH3uvkDJCHqu6XsNQ5OGUmgp5J/L/unx3iIhBE9dNJCeSRHsLqzmrk834HCqPV6Ko3G5JI/M3crXG/MIN+n54MYRpMe7T2r67uZ3WZK7hChTFC+f8jJmgz/jujyj5Jn60VCGmfAL/Pts3qwRSSm7Sin/3ZKb1QcxHpay2AAAIABJREFU9AJ8GQ7yE2BHCyM/kmuBrVLKJkPQhBA9gfnAXuBcKaXFJypbiNDpSLzzVgBKvv0NZ0FOIOUELXqdnmfHPUt0SDRLDy7lo6yPPL5HeIiBd/4ynNgwI4t2FPLEt9vU/iJFA5oJbeHT1fsJMeh45y/DGZDqvqLqD3t/YMbGGQgEz5z8DGmRaX5U6xn23Zso/XkLAIn3+P+B2OsB4lLKaimlz75NpZSFwEvAQ0KI+4T4//buOz6KMn/g+OfZkk0P6SGkAIaOgJKzAQInHuKdd4d69t67cqKnZ+/ceZ76s51iPfQ8FTwLNhQERUCUIr0IKUBI79lsnef3xywxhCSkbDK7m+f9eu1rk8nM7HeYZb/7dDFFCPEC8Gvgzub7CiEWCyF+bvZ7CnoSCgPuA0YKIY5r9rD1VNztiTrzOiKzwtFcgrK7rjEihJCQFpXGQyfoQ9ueWvsUK4tWdvocg5KimHtRLmEWE/NWFfB/i1t2zlT6IrdX4/YFG3h79R5sFhOvXPwrJuS0PYXPqv2ruOu7uwD48/g/MyljUm+F2iWld9+E9ApiRsYTOeOCXn/9YF0G4i70DhI3o1exTQDOklIubLGfGWg+SdJIIBuIBxYCK1s8DJlHT5hMpN73MAhJ1Xd5OL77xIgwQsLUrKlcPvpyvNLLrctuJa+m82O0cgcm8ORZ4zAJePKrHfxr2a4eiFQJFg1OD1e88SPz1+wl3Gri1Ut+xcR25pHbUrGFW76+BY/m4cKRF3LxqIt7MdrOa/zibWrXlyJMkpSH/mlIDEJVPXRObm6u/PHHH3vk3MVXnkrVt3lEZNjI/vzHHp9oMFRpUmPW17NYsmcJWTFZzDt1HgnhnerVD8CCNXuZPV+ftuWOGcO5pp3uuUpoKq11cPkbP7JxXw0JUWG8cnEuR2XFt7n/5orNXLXoKmpdtcwYOIM5J87BJAL3+7502MmbdgzOci+J00eS8vSCHnstIcQaKWWr85QG7r9QH5T8yIuYwyWNe51UP36L0eEELZMw8dikxxieMJzCukKu+fIa6lyd75J9xvgMHp15JABzPtvGY59tVW1Gfciagkp+98xyNu6rITsxkgXXntBuEtpUvokrF11JrauWqZlTeWTiIwGdhAAqHrgaZ7kXaywkPWjcagCB/a/Ux5hTMkm7Qe+DUfrWV7i3/mBwRMEr0hrJ8yc9T2ZMJlsrt3LD4hto9HS+X8q5x2Tx1NnjsJgELy7bzW3zN+DyqN50oUxKybxVBZzz0ipK65wcOyiBBdeewKCkqDaPWVuylqsWXUWdq46Tsk7iiclPYDW33qU7UDjXfk35h/pnTP/bb8IU1/Yifj1NJaIAE3vFPcSMikfzCPbPugbpUeNZuio5Mpm5v5lLSmQKa0vXcuOSG7G7W5tqsH1/PGoAcy/KJdxqYv6avVzw8vdqXroQVW13cf1/1nLPB5tweyWXTRjEm1ccS1J02/2Yvsj/gisXXUmdu46Ts0/m8cmPB3wSkg47RbNuRmqCuKNTiTrzWkPjUYkoAKX981XMNklDvp3KB682OpygNiB6AHN/M5fE8ES+3/89V395NbWuzq/KOnV4Cu9efTypsTZW51fyh+e+Y9M+tY5RKFm5q4IZT3/LpxuLibZZePqccdx72kis5rY/Jv+9+d/ctuw2XJqLs4edzeMnPo7VFNhJCKDszotxlLixREPqU/OMDkclokBkyR5O/9n6gLLS+d/RuGS+wREFt8Fxg3n9lNdJi0pjfdl6rvjiCsobyzt9njEZ/fjohomMzYhjb1Ujpz+/gn+vzFftRkGu3unh3g83cd7Lq9hf4+DorH58etMk/jBuQJvHOL1O7l9xP4//+DgSyazxs7jr2Lswm1qfeTuQ2Be+TsXnGwFJ+r2zMacYP75J9ZrrpJ7sNddS8RWnUrU8D2ssDFq4KCDeMMGsqL6IKxddSWFdIelR6Tx70rMMiR/S6fM43F4e/mQLb67SJ/uYPiqVR2ceSWI71TdKYFqyrYS7/reJ/TUOLCbB9VNzuPHXOVjaKQUVNxQz6+tZbKrYhM1s48ETHuTUwYdbkzMwePK2kHfG6XjsgsSTR5DyzPu99trt9ZpTiaiTejMRafU15M+YgLPMS/SQGDL+t0J16e6m8sZyblpyExvLNxJljeKJyU8wYcCELp1r4YYi7lywkTqnh8SoMB7642hOPdKQoWhKJxVUNPDIJ1tZtEWfkWxsRhxzzhjDiP6x7R63Yt8K7vj2DqqcVQyIHsCTU55kROKI3gi526TDTuFpE7DvcehDRBauQIS3PT2Rv6lE5Ee9mYgAXJtXkX/eJXidgqRTx5D8z3d67bVDlcPj4K7ld7GoYBEmYeKmo27i0tGXdqmr7Z5KO7fP38DK3fqEtaeMSuOe00YyoF/gzinWl9U7PTz39c+88m0eLq9GZJiZP588lEsnDMJsanu1VKfXyVNrnuLNrfp6nBPSJzRNKRUsSq7+HZXLdmGJlAxa8D6WQV1Zuq3rVCLyo95ORAD1859jzz3PgBQMmH0esVeoJSO6S5Maz61/jpc26GMnpmRM4eGJD3fpg0XTJG+tLuSxT7did3kJt5q4bkoOV504uM3VOpXe5XB7eXNVAc8v3UVlgwvQF0W8/ZRhpMaGt3vsjqod3PHtHeys2olFWLhu3HVcNvqyoGgPOqDq8VsofuULEJLsf9xJ5G97f7YHlYj8yIhEBFBxz2WUvrcSYZZk/fNeIqef1+sxhKJle5Zx5/I7qXPVMSB6AI9NeoyjUo7q0rmKqht55NOtfLJhPwCZCRH8dcYIThmd1uZaNUrPcnq8vPfjXp5d8jPFtQ4AxmfHc8/vRjIus+3VVAFcXhdzN87l5Y0v49E8ZMdmM2fSHEYnje6N0P2mYf4LFN7zNEhB/ytPpd+tTxgSh0pEfmRUIpKaRvFl06letRdzuGTgG3MJGxvYEykGi711e7l12a1sqdiCQHDp6Eu5ftz1hJnDunS+lbsquP+jzWz3LbA3Kj2WWdOGctKIFJWQekmtw81/vi/kleV5lNXpY75G9o/ltunDmDIs+bD3YU3JGh5Y+UDTXIV/GvonZufOJtLae20q/uBY+TkFV92C5hYkThtOyrP/MywWlYj8yKhEBCCdDvacPomGXfVYYyH77XexHnGkIbGEGrfXzQs/vcArm15BkxpD4ofw0ISHGJU4qkvn83g13l5dyDNLfqbU90E4JiOOW6YNYeowlZB6Sn55A/9ZXcjb3xdS51vccET/WG6YmsOM0WmY2mkHAr0zy9Nrn+aDnz8AYGDsQO47/j5y01r9/Axoro0rKLj4Mjx2fVbtAe9+Y2hnp5BLREIIE/AX4Gr0Jcq3Aw9KKTs1Y58QYjCwCYgAhkgpDzvnv5GJCMBbWUzhzJNxlHgISzCR/e5HWDLUZJz+sr50PXctv4vCukJMwsQ5w87hhqNuICYspkvnc7i9vPV9IS8s3UW5bzaGI5KjuGTCIM44egCRYaoXZHd5vBqLt5Xy5qoCvt35y/iw4wYncM3kI5g89PAlIKfXybwt85i7YS52jx2LycLloy/nyjFXYjMHX7d8d95mCs4+E3ctRGaFk/n+UkzRxnasCMVE9AgwG305iDXAOcCV6AvdfdqJ83wOjEVPZkGRiAA8RXkUnvk7nJUa4SkWshZ8jjm57cF3SufY3XZe+OkF5m2Zh1d6SY5IZnbubGYMmtHlkkyjS28sf2V5XlNbRWy4hXOOyeL8Y7PITmx7HjOldT+X1vHh+iLmr9nL/hr939RmMXHa2HQuOC77sG1AAF7Ny2f5n/HsumfZV78PgCmZU5idO5vs2Owejb+neAp3UHjOTP3zIdVC1v++xJyQZnRYoZWIfIvb7QHmSCnva7Z9MZAspRzTwfOcBzwJPOZ7DppEBAd/4wlPs5L1zseYU4PzP06g2l65nYdWPcRPZT8BcGTSkdyaeyvjU8d3+Zxur8Znm4p57bs81hVWN23PzY7n9KMz+O2Y/sRFBP4UMUbZV93Ixz8V8eH6Irbu/2WqpsFJUZx3bBZnjs+gX+Th2/Y0qbG4cDHPrXuOXTX6elM5/XK47Ve3cUL6CT0Wf0/zFGyj4NwzcFVqAVdjEmqJ6ELg38BQKeXOZtsvBV4FBndgufB4YCtwG/riea8RZIkIwL31Bwouugh3HYSnWMj870dY0gcZHVZI0aTGBz9/wDPrnmmaFuikrJO4YdwN5MTndOvc6/dU8+8V+Xy2qZhGtxeAMIuJaSNSmDG6P5OHJRMb3reTkpSSLftr+XpbKYu3lR6UvGPDLZx6ZH/+MG4Axw1O6FBp1at5WVy4mJc3vszWyq0ApEelc83YazjtiNOwmIK3qrR5ErIlmMh6ewGW7OFGh9Uk1BLRHOAWIEI2C14IcQzwPXr1XLtLnAoh5qInnilCiEsI0kQE4N6xloILL8BdI7Elmcma926vD1TrC+xuO29sfoPXNr9Go6cRgeDk7JO5euzVDI0f2q1zNzg9fL6pmPfX7WXFrgoOvKstJsFxgxOZNiKFaSNTyYgPrh5bXVVjd7Mqr4Kl20v5eltZU1UmQLjVxLQRqfx+bDqThyVjs3RsLI/D4+CjXR/x+ubX2VO3B4CUiBSuGnMVpw85PeBnyz4c15bvKbz0Uv1zINFE1tv/w5LVvfelv4VaInoJ+L2UMq3F9hxgJ3CRlLLN6WSFEJOAr4CjpJRbOpKIhBBXAVcBZGVljS8oKPDLtfiLe9dGCi84G1eVxBoDmS8+j+3oqUaHFZLK7GW8tOElFuxcgFtzAzAtaxoXj7qYcSnjun3+oupGPtmwn6+2lvBDfiVas/+eWQmRHDc4gWMHJXLs4ISQSUyldQ5+yKtidV4F3+dVsr2kjuYfSykxNn49PIWpw1OYmJNElK3jpZbihmLm75jPezveo9JRCegzsl8y6hL+mPNHwi3tD2YNBo6Vn7Pn+lvw2AW2ZLOehDI6P4diTwvoRCSEmAZ82YFdl/lKMF1OREKIMGA98JGU8g7ftksI4hLRAZ69O9lzwRk4it2YbZKMOXcROeNCo8MKWSUNJby2+TXe2/4eLk0fqT8maQwXjryQadnT/FLFU9XgYumOUr7aUso3O8qauiMfMKBfBGMz4xiVHsfoAXGMSo9td90co0kp2V/jYHNRLZuLathSVMvmolr2VR+8YGGY2cTYzDgmDUnm18NTGJUe26lOIprUWLV/Fe9se4ele5eiSX0hwxEJI7hs9GV+uz+BwP7ZPPb85RE0lyAyM5yMtz/BnJRudFitCvREFAlkdWBXu5SyUAjxN+BmulA1J4S4HZgFjAcOrJB2HvAccDTws5Sy3TWlAzURAWjV5ey78FTqd9YhzJL02RcTe+mdRocV0srsZfxn2394b8d71Dj19YlSIlOYmTOTmUNmMiDaP70ZvZpkS1Et3+dVsGp3BavzKql1HLpoYmqsjSEpMQxMimRgYpT+SIokIz6yV6Yb0jRJpd3FvqpG8isayC+3688VDeSVN1Btdx9yTGSYmfHZ8RwzMIFjBiUwNrNfl2ItrC3k490f8/Guj5t6wFmEhWnZ0zhr2FnkpuaG1PitmufvYf+z7yE1QfSwOAa89YXhXbTbE9CJqLOEEBcBb9CiBNOsZNNmZwUhxOtAe5Ms/SSlbLd+JZATEeiDXouvPo3qVXsBSco5k0i490WESS091ZMaPY18vOtj5m2ZR35tPgACwfHpxzMzZyaTMycTYfHfRKheTbKjpI7NRbVs2negdFFDg8vb5jEx4RaSY2wkRdtIjrGRHG0j2mYh0mYm0mom0mYhMsyMzWJuWmNJgq+aTOJwazS4PDQ4PTQ4vTQ4PdQ7PZTVOSmtc1JW56S83olHa/szpV+klVHpsYxKj/M9xzIoKbrdCUfbU95YzpLCJXy862PWl61v2p4WlcaZQ87kjKFnkBSR1KVzByqpaZT/5XzKP9avN35CNqnPf4CwBXY1Y6glohRgL/CIlPKBZtu/AlKllG1ONSCEGI4+Zqi5U9AHx14AbJdStptlAj0Rgf5GrbjzQso+XAtA7Nhk+r/0P0PXpO8rNKmxpmQN83fM56uCr5qq7SIsEUzNnMqMQTOYkD6hRxrHNU1SUGknr7y+WUnETn55A0XVje0mCH/qF2klLTbcVxqLYlBSJNmJUQxKiiIlxtbtUklJQwlfFX7FlwVfsq50XVPVW4QlgpOzT+b3R/ye3NTcoJqUtKO8lcXsv+oM6jZVgpCknjeFhHv+ZXRYHRJSiQgO6jn3V2AtcDb6LAu/l1IubLbfYiBbStlmP9tQaSNqTe1LD1D0f28jPXojZsa/XiZs1HFGh9Vn1DhrWLh7IZ/s/oSN5RubtsdYY5g4YCKTMyczccDEXllKQNMkNY1uyuv1kktZvZPyepdeunF5aHR5aXB6aXR7cLo19FyhJwwh9J9sVjPRNjNRYRYibRaibWaibVaSosNIjrGREhtOUnRYh3uydZRH87CxfCPf7v2W5fuWN3W7BrCarByffjzTB05nWta0oJsLrjOcPy5h74034qrSMFkl6X+5kpgLbjU6rA4LxURkBu5En02h+RQ/81vstxQYKKUc2M65LiFEExHoPWr23vJn3DUSs02Sfs+NRJ95vdFh9Tl76vbwRf4XfJb3GTuqdjRtNwsz41LGMSF9Asf0P4ZRiaNCpiG9qzSpsat6F2tK1vBD8Q+s3L+SOtcvTbfh5nAmDJjAtOxpTM6Y3OXpl4JJ7csPsf+pt9A8grAEExnPPht0PWNDLhEZKdgSEYC3dA9Fl59B/c46EJKk344j6ZHXA75OOVQV1haydM9Slu1dxtqStXjkL50OoqxRjE8dT25qLmOSxzAycaRf25YCkd1tZ2vlVjaVb2Jd6TrWlKyh2ll90D7ZsdlMHDCRiQMmkpuaGxLdrjtCOuyUzjqHyq/1sfuxoxPpP/d9TPEpBkfWeSoR+VEwJiIA6fHoDZyf/AQIItLDSH/mRVVVZ7BaVy0ri1ayev9qVhevburocIBZmBkaP5Qjk45kWMIwhsYPZUj8EKKswTk3XaWjkp+rfmZn9U62V25nU8UmdlXvamrnOSAlMoXc1FzGp47n+P7HkxmbaVDExnGuXUbRrBtxlLj19qBzJxN/9wtB2/FIJSI/CtZEdEDD+y9S9MhTeBrAZJWkXX06cTc8anRYik9xQzE/FP/AutJ1bCzfyI6qHYd8SANkRGeQ0y+HrNgssmKyyIzNJCsmi9SoVKwmY2cJqHPVsa9+H3vq9jQ9CmsL+bn656ZBpc2ZhZkh8UMYnTSaMUljyE3NJSMmI6S6WneG1DSq/34zJfO+RHoFligY8OAdhqyq6k8qEflRsCci0GfvLr7+POq26tUfsWOTSHvmP5hT+t63zkBnd9vZXLGZTeWb2Fm1kx1VO9hVswuPdugYItC7jCeEJ5ASmUJqZCopkSnE2eJ+eYTFERMWg81sI8wc1vSwmW1NCcyjefBKL17Ni0d68GgeXF4Xda46/eGua/q51lVLRWMFZY1llNnLKLWXYvfYW40N9KrHnH455PTLYUj8EEYljmJ4wvA+U9V2OJ6Cbey/4SK9Gh29x2vaM2+FxP9NlYj8KBQSEejfumqeup3iVxciPQJLpCTtpkuIueQOo0NTDsOtucmvySevJo/CukIKawsprCtkT+0eyhrLkBj7fzrcHE56dDqZMZlkxmSSEZNBVkwWOf1ySItSy6a3Rmoada8+QvGzb+F1CExhkv7Xn0Ps1fcbHZrfqETkR6GSiA5wrf+Golk30LhfH/EeMyqetH+8rCZODVJuzU1FYwWl9tKmR42rhlpnLTXOGmpcNdS56nB5Xbg0l/7c7IHQu0SbhRmzyYxZmLGYLFhNVmLCYn55WH/5OTEikeSIZFIiU0iOTCbGGqOSTSe4t62h+LZrm0pBkdkRpD/zKtah3Z+7MJCoRORHoZaIAKTbRdXfbqHsv0vQPPq3sdSLf0vcrMeDtmFUUQKddLuoevQGSt/7BukRmKyS5HNPIv72pw1d0runtJeI1KeMgrCGkXD38wye/xZROdFoLsH+uZ9SeMp4HCs/Nzo8RQk5jm8+IP+k8ZS8/S3SI4gZFc/gD94j4a/PhWQSOhyViJQm1uHjyfzoe9Jv/hPmcIm90EHeZbdQfNl0PEXtrjWoKEoHeAq2sf+iaeRdfQeOUg+WKMi4+woyFqzAekSbs5OFPFU110mhWDXXGu/+fMruuY6q73aD1Kvrkv80hfjb/okID91pVBSlJ2j1NVQ+eiMVH69GcwsQkoQTc0ie82pQDk7tClU1p3Sauf9A0l7+lMGvP03UoEg0l6DkrWXsnvor6t9+GqkdOrZFUZSDSU2j9qUH2D31OMre/wHNLYgeEsPgt14g9cWFfSYJHY4qEXVSXykRNSc1jfo3/0HJs6/hrtW3RWTYSLn5ZiJPu9TY4BQlAElNw/7BS5Q9+wKNRfoM7LZEM6mzrifqzGsNjs4YIVciEkKYhBB3CiHyhRAOIcRPQogzOnF8hBDifiHETiGEUwhRIoRY6FvBVWlBmEzEXHQ7g5euJuWsEzDbJI17nRTc9ncKZ4yn8at3jQ5RUQKGfeHrFE4fT+Ffn6axyIU5XJJ22W8YtHRtn01ChxOUJSIhxCPAbOAuYA1wDvpM3L+TUn56mGOt6EuTDwIeA7YAycDJwCwpZWM7h/fJElFL3vIiKv92K5Wfr9Pru4HoYbEk33Y34RNPMzg6RTGG/Yv/UP7kEzTk6zNLmMIkiafmEn/7PzAntFwGre8JqXFEvoXx9gBzpJT3Ndu+GEiWUo45zPF3oK9jNEpKuaezr68S0S88RXlUPvpnKr/eivTqCSkqJ5qkq68j4rcXqzFISsiTmob9o1eoeOlFGnY3APocjgnTx5HwlycwJ/tnqfhQEGqJ6ELg38BQKeXOZtsvBV6lnaXCffsVAl9KKS/vyuurRHQoT94Wyh+dTfWK3U0JKaK/lcRLzif6/Fv75LgIJbRJp4O61+dQ8dYCHKX6vH8miyR+2mgS73wCc2q2wREGnlBrIxoFOIGWi9ht9j23OTeNECILyAR2CyHmCiFqfW1Mi4UQoTWfRi+yDBpJ2txPyfniY5JOHaO3Ie13s/ex19k9aSzVT96GVl9jdJiK0m1adTmVD1/HrolHse/Jd3CUejCHS5JOG8cRn39CylPzVRLqgmAsEb2EviR4WovtOcBO4CIp5bw2jj0OWAnUAT8ATwA24AEgCxgjpSxs5birgKsAsrKyxhcUFPjvgkKQVlVK9TP3UPHhN3j02grM4ZJ+E0fQ77o7CBt5rLEBKkonuTZ8R9WLf6dm+Xa8Tr3Ub42FxNOnEXf9g5hi4g2OMPAFdNWcEGIaeueBw1kmpZzSzUR0AvAdUIJehWf3bc9EL2E9JaX8S3tBqKq5jpMOOzUvPUjV/E+aqi9AEj00jvjzzifqzOtUtZ0SsKTTQf3bT1H17vym9h+A8P5WEi84i5iLbkdYVUfbjmovEQXCp8AKYEQH9juwyEkV0E8IIeTBWTTB93zoylu/qPA9f3cgCQFIKfcIIbYBR3UwZqUDRHgk/W6aQ9wNj+L48h0qX32Buo2l1O+opf7+F7A++S/if3MssZfNxjpolNHhKgoA7l0bqf7Xo1QvWd9UohdmSezYNOIvvYbwk85SHXH8zPBE5EsI2zpxyGb06rQjOLid6EDb0JZ2jt0NtNc9W00X0AOEyUTE9HMZMP1cPIU7qH7+Qaq+XIO7RlL63ipK559B1OAY+v3+t0SfPwtTdJzRISt9jFZdTt2b/6Tm00U05NWD1KvfwuIE/U45gX7X3I25/0BjgwxhhlfNdZav+/Ze4BEp5QPNtn8FpEop2505UAjxHnAietVcg29bFnq13t+llPe0d7yqmvMP6XRQ/87/UfP++9TtqAZN/49vskpij84k7rxLiTj5HPXNU+kx0u3C/vGr1Lz3X2o3FiM9vjWUTJKY4QnEn3chkX+8UlUf+0lAtxF1hRBiDnAL+nigtcDZwNXobUcLm+23GMiWUuY02zYSWA38iN5ZIRy4D31Q6xgpZUl7r60Skf959u6i9vV/ULNoebO2JLDGQMyvhhB7+gWE//pMlZSUbpMeD42L36Xug/9Su3pnU9UbQER6GHEnTyLm4luxpA8yLsgQFYqJyAzciT6bQhqwHXhQSjm/xX5LgYFSyoEtth8D/A04FnADXwOzpZQtu4QfQiWinuVY+Tk1856ndtUOPPZfVvm0RENsbg4xM88l4qSz1LdUpcOk04H98zep+3gBdevyD0o+1hiImzSGuIuuJ2zcicYF2QeEXCIykkpEvUN6PDR+8Ra1H75L3ZrdB314WKIgekwW0dOmE/W7izHFJRoXqBKQtJoKGha+Qf0Xn1K3YS9eR4svNeOPIOaPZxMx/XxV0u4lKhH5kUpEvU96PDR++V+9OuXHXQclJWGWRA6MIfr4XxH9hwsIO/IE4wJVDCM1DdeaJdR/8g4N36/FXtCA1H5JPtY4QeyvhhEz81zCp6pqXiOoRORHKhEZS3o8OJa9T/2nC6j/cSuOEvdBfw/rJ4gaPZDICZOIOuVc1dMphHmK8rB/8V8avvmaho17cNc3/6skPDWM6NwRxJx+EbbjZ6jkYzCViPxIJaLA4inYRv0Hr1H/7XIatlc0zQauk9iSLESNGkjkhBOJPOVczCmZhsWqdI+ncAf2Re9gX7UC+9Y9OCu8B/3dHC6JGpZC9IknEvWHi7FkDDEoUqU1KhH5kUpEgUs6HTR++V8aln6OfcN2Gvc2HlQ9AxJbsoWInHQixh1FxITphI07UXV8CEDS48G1bimNK76kcf067Nv24ao6eJifMEkiBkQQOW440afMJHzy6epeBjCViPxIJaLgodVV0bh4PvZvvqJhw3YaixxN45UOMIVJIjKiiRg2mPDc4wg/YTqW7BGqGqcXSU3D8/MGGpd/imPNuhdsAAAOkklEQVTtDzTuyMexv7FF6VZvD4zIjCRyzHCiJp1M+NTT1eDnIKISkR+pRBS8tJoKHN98ROPqb2jctI3GwuqDOj4cYA6X2NIiCc9OxzZyFOFHHU/Y0VPVh54faNXlOH9cgvOn73Hu2I6joAhnsf2gXm0HWKIgIjue8BFDiJx4MhFTZiIiogyIWvEHlYj8SCWi0OLesZ7GbxfSuPYHHDsKcRQf+k0cACEJ62cmLDUGW0Ya1oGDsQ07krDRx2LOHq5KUM1IjwdP/mZcW37EvXMLrvw8nHuKcBbV4K6VwKH/vgdKpuFDBxJx9DGET/qtmn8wxKhE5EcqEYU2qWl4dqzD8eNSnBvX4tiVj3NfFa5qrWn+sZZMVklYvBVrcizWlESs/ftjycjGOnAo1iNGYx6QE1JtF9LtwlO4HU/eVtyFP+PZV4h7fxHuolJcZXW4qr1NCyQeQkhsCWZsAxKwHTEQ26hxhI8/Ecuw8SqZh7hAn31bUQKGMJmwDh+Pdfh4Yppt12oqcK77Bvf2n3Dt2olrz16cxVW4KlxoLoGj1IOjtBI2V6JPW9j8nBJLtMASa8MSHY45LgZzv1gsCYmYk1IwJ6dhScvAlJiGKS4ZU0IKpsgYeot02NFqyvCW7sNbshdv2X685cV4KyvwVFXiranFW1OPp7oBd40Lj122mZR9V4w5XBKWYCMstR/WzAGEDc7BNvYEbOMmqeo15RAqESlKB5jiEomYMpOIKTMP+ZunKA/XT9/h3r0N975CPMUluMurcVc14Kn14HUK3LXgrnWiLy7cgdVqTRKTBUxhAnOYCZPNjLCYEWYTmE0IiwlhMiHMZrCY9Wck0quBpiE1DbwaUpNNv0uXF83pQXN70VwSzS3RPBzSgePw9ERjibFgjY/CktgPa0oS1kFHEDZ8LGEjj1Hd5JVOUYlIUbrJkj6o3Ukytepy3Ls34tm7G29pEd6yEjyVFXirqvFW1+Gps+Otd+F1HkgQgCbQXKC5wIOGvkKJu83X6BpfAhJ60jOHC8wRFszRNswxEZhjYzDH98PcLx5LYjKWAQOxDBqOZdCoXi2xKaEvKBOREMIE/AV9xu3mk54u6MCxZuAm4HJgEFALrALuk1Ju6LGglT7L1C8J29FTsR09tcPHaPY6tMpStJoytJpKtJpKpLMR6XIi3S7wuJFuF9KtP+N2g8kEZjPCbNHbpMxmMFsQFivCbEZERmOKicMUE48pNgERm4CpXxIiPEq1zyiGCspEBDwEzAbuAtYA5wDvCSF+J6X8tAPH/gV4DFgCJPnO87UQYqyUcm/Pha0oHWOKjNFLHRlHGB2KovS4oEtEvoXxZgNzpJT/8G3+WgiRA8wBDpeILgHekVLe3eycG4CtwG+BF/0etKIoitKmYCyPTwfCgDdbbH8TOFIIcbgVrcLQq+Oaq/Y9B+O/h6IoSlALxg/eUehdj1ouYrfZ9zzyMMc/D1wghPiDECJWCDHYt20v8K5fI1UURVEOK+iq5oAEoFoeOhK3stnf2ySlvFcI4QLe55dEvAOYIqWsaO0YIcRVwFUAWVlZXY1bURRFaYXhJSIhxDQhhOzAY6mfXu9a9M4JDwNTgT8BdcAiIUR6a8dIKV+SUuZKKXOTk5P9EYaiKIriEwglohXAiA7sZ/c9VwH9hBCiRanoQEmokjYIIRKAJ4HHpZT3Ndu+BMgHbgNmdTx0RVEUpbsMT0RSSjuwrROHbAZswBEc3E50oG1oSzvHDvUd+0OLGCqFELvoWEJUFEVR/Mjwqrku+Bx9iPn5LbZfAGySUua1c2yx7/mY5ht9JaUcYJ+/glQURVE6xvASUWdJKUuFEP8E7hRC1AFrgbOBXwO/b76vEGIxkC2lzPEdmy+EWAjcJoTQgGVAInA7eknphd67EkVRFAWCMBH53AXUAzfzyxQ/Z0kpF7bYz8yh13g2cCtwru+5Fj2ZTZRSqvUdFEVReplaj6iT1HpEiqIondfeekTB2EakKIqihBCViBRFURRDqUSkKIqiGEolIkVRFMVQqrNCJwkhyoACo+PogiSg3Oggellfu+a+dr2grjmYZEspW50jTSWiPkII8WNbPVZCVV+75r52vaCuOVSoqjlFURTFUCoRKYqiKIZSiajveMnoAAzQ1665r10vqGsOCaqNSFEURTGUKhEpiqIohlKJSFEURTGUSkRBTAgxVQixXAjRKISoFELME0KkdvDYcCHE40KI/b7jVwohTuzpmLurm9fc1jL043o67o4QQmQIIZ7x3Qu7L7aBrezXrXsnhLhSCLFNCOEUQmwXQlzjz+vojN64ZiHE0jbu+y3+vp4OxtPRa35UCLFICFHh2+eSTr7OH4UQ64QQDiFEgRDibiGE2U+X4VcqEQUpIcQkYBFQDZyBviTGicBiIYStA6d4BbgSuBf4HbAf+CJQPpRb44drBngdOL7FY4ffg+2aHOAsoAr4tp39unzvhBBXAi8CC4BTgPeA54UQ13Yv9C7r8Wv22cCh9/2/XYy5uzp6zTcCEUDL5W0OSwgxHf0e/wDMAJ4G7gYe7ey5eoWUUj2C8AF8hb5UuqXZtlxAAtcd5tixvv0ubbbNgr6u00dGX1tPXLNvXwk8bPR1tBOfqdnPV/jiHeive+fbrxR4o8X2V9FH6ltD7Zp9+y4Flht9fztzzc33Q09cErikE6+xDljWYtu9gAtIM/rfoOVDlYiC13HAl1JKz4ENUl/YrwKYeZhjf4++3Po7zY71oH9DnN6J0kVv6841BzwppdaB3bpz744HkoE3W2yfh75S8cROBewHvXDNAaeD19zh/VoSQmQC42j9PlvRS0gBRSWi4OVF/3bTkhMYfZhjRwF5Ukp7i+2bgTD0b2CBqDvXfMC1vrYRuxBiia+6L5h0596N8j1vauVYgJHdD69H+OP9epQQokYI4RZCbBBCXO73KANHq/dZSpkH2AnA+xysS4UrerXEcc03CCGygf7o3x7bk4BeP91SZbO/B6LuXDPo3xAXAkVANnAbsEQIcbKUcql/Q+0x3bl3B/7W8vhAv+/dfb9+A7yF3hbYD7gIeFkI0V9K+bDfogwcbd3nA9sC7j6rRBS8ngbeFEI8DPwf+pvrJUDzPUJRt65ZSnlhs1+/FUJ8iP6t8WEMqJZSeoeU8t4Wmz4UQvwPuEsI8ZSUst6IuJRfqKq5ICWlfAv9A/RWoATYAuwDPkXvUdSeKiC+le0HvilVtvI3w3Xzmls7Xx3wCfArP4bZ07pz7w58Q255fEDfd3rm/fo2EA4c2dWgAlhb9/nAtoC7zyoRBTEp5T3oa5OMAfpLKc8FhgDLD3PoZmCQECKyxfaR6G0wP/s7Vn/pxjW3e1p/xNZLunPvDrQFjWqx/UCbwZbuh9cjevL9Gkz3vqNavc++sUqRBOB9VokoyEkpG6SUG6WUJUKIU4DhwL8Oc9jH6L1n/nRggxDCApwNLJJSOnssYD/o4jUfQggRiz4mZbW/Y+xB3bl3K9G7aZ/fYvsF6N+Sv/NvqH7TE+/X84FGYKNfIgwgUspC4Cdav89u4LNeD+owVBtRkBJCHIXeDXOtb9NE9Mb3v0spVzTbLxvYBTwopXwQQEq5TgjxDvCUEMIK5AHXAoM49M0bMLpzzUKI2cAw4Gt+6awwG0gjgK5ZCHGm78fxvucZQl8VuExKuawz904I8TNQIKU8CUBK6RZC3IM+gHUf+risXwOXATdKKVvrkdjjevKafb0i7wDeB/KBOOBi9C7hd0gpG3r04tpwuGv27TMZvbt9mm+fXCFEPYCUcn6zcy1GX/20ee/BvwILhRAvoldDHoU+oPVpKWVxD11W1xk9kEk9uvZAL3YvR59loBH9w/nSVvYbiF79cH+L7RHAP4FiwAF8D0wx+rp66pqB09C/8ZejfyusAD4CjjH6ulrELtt4LO3svUP/4F3ayvar0XuQOYGddGAwcLBeM3rX7s/Q2xKdQD2wAjg3CK55aVv7tTjXUiC/ldc4Hb1k5AQK0Qe0mo1+j7f2UMtAKIqiKIZSbUSKoiiKoVQiUhRFUQylEpGiKIpiKJWIFEVRFEOpRKQoiqIYSiUiRVEUxVAqESlKEGpl2eu0wx/V5dea3eK1Xu+p11L6JjWzgqL0AiFEywF7GlCDvoT16+irpnZ2UF+B71jQB2r2lBXAA+hLKNzcg6+j9FFqQKui9IJmiegB37MVfdT/TN/Pz0kpb+jk+ZZJKaf4M87DvOZA9Ol13pBSXtJbr6uEPlUiUpReJKW8v/nvQogJ6Au3XSeEeELqq2gqSp+i2ogUxUBSyu+AbYDglwkwu0UIMfBAW44Q4gghxHwhRIUQok4IsUgIMdq3X7IQ4iUhxH4hhEMI8YMQYqo/YlCUzlCJSFECR0eWO++MgeiTg6aityUtAqYBS4UQQ4BV6IsCvgO8C4wFPhNCZPk5DkVpl0pEimIgIcSJ6OspufD/ukiTgSellJOklLdKKc8A7gMS0RPUl8B4KeUtUsqLgMsBGzDLz3EoSrtUG5Gi9CIhxP2+H5t3VhDAbCllp5c7P4x8YE6LbW8AD6InnNuklFqzv/0HeBUY5+c4FKVdKhEpSu+6r8XvErhcSvlaD7zWeimlt8W2It/zDill3UGBSOkVQpQAGT0Qi6K0SVXNKUovklIKKaUAooGTgT3Av4QQv+6Bl6tp5fU9bf3Nx4NeWlOUXqMSkaIYQErZIKX8Cn3lWDPwhhAi0uCwFMUQKhEpioGklBuAuejVYaqTgNInqUSkKMZ7GHACs4UQ8UYHoyi9TSUiRTGYlHIf8C/0udxuNzgcRel1KhEpSmB4DLADNwkhUo0ORlF6k+q+rSi9wNdTrr2/lwBRfnqtfPSxSZ2ORUo50B8xKEpnqBKRogSvyb25HhH6zNuK4neqRKQowemBFr/3xnpEB6zvwddS+iC1HpGiKIpiKFU1pyiKohhKJSJFURTFUCoRKYqiKIZSiUhRFEUxlEpEiqIoiqFUIlIURVEM9f9ug/HUpTNuqwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Read namelist\n", + "spec_hdf5 = SPEC('G3V02L1Fi.001.sp.h5')\n", + "namelist_h5 = SPECNamelist(spec_hdf5)\n", + "\n", + "# plot the KAM surfaces of this output\n", + "py_spec.plot.plot_kam_surface(spec_hdf5)\n", + "\n", + "# modify tflux\n", + "namelist_h5['physicslist']['tflux'][0]=0.4\n", + "\n", + "# run the new namelist (or you can write it and run it manually)\n", + "SPEC_command = '/Users/zhisong/Codes/SPEC_hdf5master/SPEC/xspec'\n", + "filename = 'test_h5.sp'\n", + "output_h5 = namelist_h5.run(SPEC_command, filename, force=True)\n", + "\n", + "# plot the new KAM surfaces\n", + "py_spec.plot.plot_kam_surface(output_h5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2). Changing resolution\n", + "We change SPEC resolution from Mpol=4, Ntor=4 to Mpol=5, Ntor=5.\n", + "To do so, we can run\n", + "\n", + "`namelist_h5.update_resolution(new_Mpol=5, new_Ntor=5)`\n", + "\n", + "We will plot the result before and after the change." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEC is running...\n", + "SPEC runs successfully.\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Read namelist\n", + "spec_hdf5 = SPEC('G3V02L1Fi.001.sp.h5')\n", + "namelist_h5 = SPECNamelist(spec_hdf5)\n", + "\n", + "# plot the KAM surfaces of this output\n", + "py_spec.plot.plot_kam_surface(spec_hdf5)\n", + "\n", + "# modify resolution\n", + "namelist_h5.update_resolution(new_Mpol=5, new_Ntor=5)\n", + "\n", + "# run the new namelist (or you can write it and run it manually)\n", + "SPEC_command = '/Users/zhisong/Codes/SPEC_hdf5master/SPEC/xspec'\n", + "filename = 'test_h5.sp'\n", + "output_h5 = namelist_h5.run(SPEC_command, filename, force=True)\n", + "\n", + "# plot the new KAM surfaces\n", + "py_spec.plot.plot_kam_surface(output_h5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3). Add interface\n", + "We can add an interface to existing equilibrium. The initial guess of the interface geometry will be automatically generated, while one needs to take case of things like iota, oita, pressure and so on. \n", + "\n", + "As an example, we add between the 0th and 1st interface a new interface, with tflux = 0.9\n", + "To do so, we can run\n", + "\n", + "`namelist_h5.insert_volume(ivol=1,tflux=0.9)`\n", + "\n", + "We will plot the result before and after the change." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEC is running...\n", + "SPEC runs successfully.\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Read namelist\n", + "spec_hdf5 = SPEC('G3V02L1Fi.001.sp.h5')\n", + "namelist_h5 = SPECNamelist(spec_hdf5)\n", + "\n", + "# add an interface\n", + "namelist_h5.insert_volume(ivol=1,tflux=0.9)\n", + "\n", + "# adjust iota and oita\n", + "namelist_h5['physicslist']['iota'][2] = 0.314\n", + "namelist_h5['physicslist']['oita'][2] = 0.314\n", + "\n", + "# run the new namelist (or you can write it and run it manually)\n", + "SPEC_command = '/Users/zhisong/Codes/SPEC_hdf5master/SPEC/xspec'\n", + "filename = 'test_h5.sp'\n", + "output_h5 = namelist_h5.run(SPEC_command, filename, force=True)\n", + "\n", + "# plot the new KAM surfaces\n", + "py_spec.plot.plot_kam_surface(output_h5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3). Remove interface\n", + "We can remove an interface from existing equilibrium.\n", + "\n", + "As an example, we remove the 1st interface. The equilibrium should now become single volume\n", + "To do so, we can run\n", + "\n", + "`namelist_h5.remove_volume(ivol=0)`\n", + "\n", + "We will plot the result before and after the change." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEC is running...\n", + "SPEC runs successfully.\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Read namelist\n", + "spec_hdf5 = SPEC('G3V02L1Fi.001.sp.h5')\n", + "namelist_h5 = SPECNamelist(spec_hdf5)\n", + "\n", + "# add an interface\n", + "namelist_h5.remove_volume(ivol=0)\n", + "\n", + "\n", + "# run the new namelist (or you can write it and run it manually)\n", + "SPEC_command = '/Users/zhisong/Codes/SPEC_hdf5master/SPEC/xspec'\n", + "filename = 'test_h5.sp'\n", + "output_h5 = namelist_h5.run(SPEC_command, filename, force=True)\n", + "\n", + "# plot the new KAM surfaces\n", + "py_spec.plot.plot_kam_surface(output_h5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 4be2cc8a2e1a84540e86b3daa0df187055db6ed2 Mon Sep 17 00:00:00 2001 From: Jonathan Schilling Date: Mon, 20 Jul 2020 11:00:03 +0200 Subject: [PATCH 4/6] added __enter__ and __exit__ to SPEC python object --- Utilities/pythontools/py_spec/read_spec.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Utilities/pythontools/py_spec/read_spec.py b/Utilities/pythontools/py_spec/read_spec.py index 64ddcb6c..23fe42b3 100644 --- a/Utilities/pythontools/py_spec/read_spec.py +++ b/Utilities/pythontools/py_spec/read_spec.py @@ -128,6 +128,13 @@ def __iter__(self): def __next__(self): return next(self.__dict__) + # needed for using SPEC with 'with' statement + def __enter__(self): + return self + + def __exit__(self, t, v, tb): + return + # print a list of items contained in this object def inventory(self, prefix=""): _prefix = "" From ce221e399df3f88e8e04fb16970a0b4f04678196 Mon Sep 17 00:00:00 2001 From: Zhisong Qu Date: Mon, 20 Jul 2020 20:29:00 +1000 Subject: [PATCH 5/6] using with clause --- Utilities/pythontools/py_spec/SPECNamelist.py | 135 ++++++++---------- .../py_spec/jupyter_files/SPEC_namelist.ipynb | 38 ++--- 2 files changed, 83 insertions(+), 90 deletions(-) diff --git a/Utilities/pythontools/py_spec/SPECNamelist.py b/Utilities/pythontools/py_spec/SPECNamelist.py index e92bc701..b46b80a3 100644 --- a/Utilities/pythontools/py_spec/SPECNamelist.py +++ b/Utilities/pythontools/py_spec/SPECNamelist.py @@ -14,10 +14,11 @@ class SPECNamelist(Namelist): '''The SPEC namelist class To get a content within the namelist, use: - somevariable = spec_nml['whichlist']['whichitem'], e.g. spec_nml['physicslist']['Lconstraint'] = 1 sets Lconstraint in physicslist list to 4 + somevariable = spec_nml['whichlist']['whichitem'] To change (or add) an item on the namelist, use: spec_nml['whichlist']['whichitem'] = somevalue + e.g. spec_nml['physicslist']['Lconstraint'] = 1 sets Lconstraint in physicslist list to 1 Please do not change Mpol, Ntor and Nvol directly. To change them, please use spec_nml.update_resolution(new_Mpol, new_Ntor) @@ -32,7 +33,7 @@ class SPECNamelist(Namelist): Alternatively, one can directly modify spec_nml.interface_guess member functions: - read, write, run, update_resolution, insert_volume, remove_volume, + write, run, update_resolution, insert_volume, remove_volume, get_interface_guess, set_interface_guess, remove_interface_guess ''' @@ -49,19 +50,17 @@ def __init__(self, *args, **kwargs): # the first argument is a string, read from this namelist # first create the namelist using __init__ of the namelist object - file_object = open(args[0], 'r') + with open(args[0], 'r') as file_object: - super().__init__(f90nml.read(file_object)) + super().__init__(f90nml.read(file_object)) - # now we should mind some variables that are important: we include them in the object itself and need to monitor them - self._Mpol = self['physicslist']['mpol'] - self._Ntor = self['physicslist']['ntor'] - self._Nvol = self['physicslist']['nvol'] - - # then read the part that specifies the guess of the interface geometry - self._read_interface_guess(file_object) - - file_object.close() + # now we should mind some variables that are important: we include them in the object itself and need to monitor them + self._Mpol = self['physicslist']['mpol'] + self._Ntor = self['physicslist']['ntor'] + self._Nvol = self['physicslist']['nvol'] + + # then read the part that specifies the guess of the interface geometry + self._read_interface_guess(file_object) # we don't know the verson of SPEC from its namelist, so leave it as 'unknown self._spec_version = 'unknown' @@ -136,6 +135,8 @@ def write(self, filename, force=False): # write the interface guess self._write_interface_guess(file_object) + file_object.close() + def run(self, spec_command='./xspec', filename='spec.sp', force=False): '''Run SPEC on the current namelist and obtain its output parameters: @@ -347,10 +348,8 @@ def set_interface_guess(self, value, m, n, ivol, key='Rbc'): if (m,n) not in self.interface_guess.keys(): # add a new item self.interface_guess[(m,n)] = dict() - self.interface_guess[(m,n)]['Rbc'] = np.zeros([self._Nvol]) - self.interface_guess[(m,n)]['Zbs'] = np.zeros([self._Nvol]) - self.interface_guess[(m,n)]['Rbs'] = np.zeros([self._Nvol]) - self.interface_guess[(m,n)]['Zbc'] = np.zeros([self._Nvol]) + for key in ['Rbc', 'Rbs', 'Zbc', 'Zbs']: + self.interface_guess[(m,n)][key] = np.zeros([self._Nvol]) self.interface_guess[(m,n)][key][ivol] = value @@ -478,63 +477,58 @@ def _generate_namelist_from_output(self, spec_hdf5): ''' # create the namelists - self['physicslist'] = Namelist() - self['numericlist'] = Namelist() - self['locallist'] = Namelist() - self['globallist'] = Namelist() - self['diagnosticslist'] = Namelist() - self['screenlist'] = Namelist() + for key in ['physicslist', 'numericlist', 'locallist', 'globallist', 'diagnosticslist', 'screenlist']: + self[key] = Namelist() - self._dump_to_namelist(spec_hdf5.input.physics, self['physicslist']) - self._dump_to_namelist(spec_hdf5.input.numerics, self['numericlist']) - self._dump_to_namelist(spec_hdf5.input.local, self['locallist']) - self._dump_to_namelist(spec_hdf5.input.global1, self['globallist']) - self._dump_to_namelist(spec_hdf5.input.diagnostics, self['diagnosticslist']) + with spec_hdf5.input as i: + self._dump_to_namelist(i.physics, self['physicslist']) + self._dump_to_namelist(i.numerics, self['numericlist']) + self._dump_to_namelist(i.local, self['locallist']) + self._dump_to_namelist(i.global1, self['globallist']) + self._dump_to_namelist(i.diagnostics, self['diagnosticslist']) - # we don't dump screenlist since it is not saved in the hdf5 - #self._dump_to_namelist(spec_hdf5.input.screen, self['screenlist']) + # we don't dump screenlist since it is not saved in the hdf5 + # self._dump_to_namelist(i.screen, self['screenlist']) - # now we should mind some variables that are important: we include them in the object itself and need to monitor them + # now we should mind some variables that are important: we include them in the object itself and need to monitor them self._Mpol = self['physicslist']['mpol'] self._Ntor = self['physicslist']['ntor'] self._Nvol = self['physicslist']['nvol'] # replace some namelist objects by those from the output - # 1. replace guess of the geometry axis - self['physicslist']['Rac'] = spec_hdf5.output.Rbc[0,:self._Mpol+1].tolist() - self['physicslist']['Zas'] = spec_hdf5.output.Zbs[0,:self._Mpol+1].tolist() - self['physicslist']['Ras'] = spec_hdf5.output.Rbs[0,:self._Mpol+1].tolist() - self['physicslist']['Zac'] = spec_hdf5.output.Zbc[0,:self._Mpol+1].tolist() - - # 2. replace the boundary - Nvol = spec_hdf5.input.physics.Nvol - Ntor = spec_hdf5.input.physics.Ntor - Nfp = spec_hdf5.input.physics.Nfp - for ii in range(spec_hdf5.output.mn): - mm = spec_hdf5.output.im[ii] - nn = int((spec_hdf5.output.in1[ii])/Nfp)+self._Ntor - self['physicslist']['Rbc'][mm][nn] = spec_hdf5.output.Rbc[Nvol,ii] - self['physicslist']['Zbs'][mm][nn] = spec_hdf5.output.Zbs[Nvol,ii] - self['physicslist']['Rbs'][mm][nn] = spec_hdf5.output.Rbs[Nvol,ii] - self['physicslist']['Zbc'][mm][nn] = spec_hdf5.output.Zbc[Nvol,ii] + with spec_hdf5.output as o, spec_hdf5.input.physics as p: + # 1. replace guess of the geometry axis + self['physicslist']['Rac'] = o.Rbc[0,:p.Mpol+1].tolist() + self['physicslist']['Zas'] = o.Zbs[0,:p.Mpol+1].tolist() + self['physicslist']['Ras'] = o.Rbs[0,:p.Mpol+1].tolist() + self['physicslist']['Zac'] = o.Zbc[0,:p.Mpol+1].tolist() + + # 2. replace the boundary + for ii in range(spec_hdf5.output.mn): + mm = o.im[ii] + nn = int((o.in1[ii])/p.Nfp)+self._Ntor + self['physicslist']['Rbc'][mm][nn] = o.Rbc[p.Nvol,ii] + self['physicslist']['Zbs'][mm][nn] = o.Zbs[p.Nvol,ii] + self['physicslist']['Rbs'][mm][nn] = o.Rbs[p.Nvol,ii] + self['physicslist']['Zbc'][mm][nn] = o.Zbc[p.Nvol,ii] - # 3. replace some physics quantities - output_list = ['mu', 'pflux', 'helicity', 'adabatic', 'iota', 'oita'] - for key in output_list: - if key in dir(spec_hdf5.output): - self['physicslist'][key] = getattr(spec_hdf5.output, key).tolist() - - # 4. generate the guess of the interface - self.interface_guess = dict() - for ii in range(spec_hdf5.output.mn): - m = spec_hdf5.output.im[ii] - n = int(spec_hdf5.output.in1[ii] / spec_hdf5.input.physics.Nfp) - self.interface_guess[(m,n)] = dict() - self.interface_guess[(m,n)]['Rbc'] = spec_hdf5.output.Rbc[1:,ii] - self.interface_guess[(m,n)]['Zbs'] = spec_hdf5.output.Zbs[1:,ii] - self.interface_guess[(m,n)]['Rbs'] = spec_hdf5.output.Rbs[1:,ii] - self.interface_guess[(m,n)]['Zbc'] = spec_hdf5.output.Zbc[1:,ii] + # 3. replace some physics quantities + output_list = ['mu', 'pflux', 'helicity', 'adabatic', 'iota', 'oita', 'Isurf', 'Ivolume'] + for key in output_list: + if key in dir(o): + self['physicslist'][key] = getattr(o, key).tolist() + + # 4. generate the guess of the interface + self.interface_guess = dict() + for ii in range(o.mn): + m = o.im[ii] + n = int(o.in1[ii] / p.Nfp) + self.interface_guess[(m,n)] = dict() + self.interface_guess[(m,n)]['Rbc'] = o.Rbc[1:,ii] + self.interface_guess[(m,n)]['Zbs'] = o.Zbs[1:,ii] + self.interface_guess[(m,n)]['Rbs'] = o.Rbs[1:,ii] + self.interface_guess[(m,n)]['Zbc'] = o.Zbc[1:,ii] def _interpolate_guess(self, ivol, tflux): '''Interpolated interface harmonics guess @@ -571,10 +565,9 @@ def _interpolate_guess(self, ivol, tflux): r_right = np.sqrt(self['physicslist']['tflux'][0]) r_int = np.sqrt(tflux) - self._interpolate_guess_singular_each('Rbc',ivol,r_left,r_right,r_int) - self._interpolate_guess_singular_each('Zbs',ivol,r_left,r_right,r_int) - self._interpolate_guess_singular_each('Rbs',ivol,r_left,r_right,r_int) - self._interpolate_guess_singular_each('Zbc',ivol,r_left,r_right,r_int) + for key in ['Rbc', 'Zbs', 'Rbs', 'Zbc']: + self._interpolate_guess_singular_each(key,ivol,r_left,r_right,r_int) + else: if ivol == 0: tflux_left = 0.0 @@ -593,10 +586,8 @@ def _interpolate_guess(self, ivol, tflux): r_int = np.sqrt(tflux) # interpolate - self._interpolate_guess_normal_each('Rbc',ivol,r_left,r_right,r_int) - self._interpolate_guess_normal_each('Zbs',ivol,r_left,r_right,r_int) - self._interpolate_guess_normal_each('Rbs',ivol,r_left,r_right,r_int) - self._interpolate_guess_normal_each('Zbc',ivol,r_left,r_right,r_int) + for key in ['Rbc', 'Zbs', 'Rbs', 'Zbc']: + self._interpolate_guess_normal_each(key,ivol,r_left,r_right,r_int) def _interpolate_guess_normal_each(self, key, ivol, r_left, r_right, r_int): '''Interpolate the interface harmonic guess, normal way diff --git a/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb b/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb index af82836c..a834509b 100644 --- a/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb +++ b/Utilities/pythontools/py_spec/jupyter_files/SPEC_namelist.ipynb @@ -9,7 +9,9 @@ "@author: Zhisong Qu (zhisong.qu@anu.edu.au)\n", "\n", "To use this utility, the f90nml package is needed.\n", - "One can install\n", + "One can install it by\n", + "\n", + "`pip install f90nml`\n", "\n", "## 1. Import SPEC hdf5 reader and SPECNamelist" ] @@ -74,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -110,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -140,12 +142,12 @@ "source": [ "## 5. Now we test if the two outputs obtained by running the two namelists above are identical\n", "\n", - "If you have can run part 4, `output_end` and `output_h5` will be loaded already. We reload them just in case you cannot run part 4." + "If you can run part 4, `output_end` and `output_h5` will be loaded already. We reload them just in case you cannot run part 4." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -239,7 +241,7 @@ "ok: Igeometry\n", "ok: Istellsym\n", "ok: Isurf\n", - "UNMATCHED: Ivolume , diff= 9.40672E-03\n", + "ok: Ivolume\n", "ok: Ladiabatic\n", "ok: Lconstraint\n", "ok: Lfreebound\n", @@ -356,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -371,10 +373,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 17, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, @@ -426,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -441,10 +443,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 20, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -498,7 +500,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -513,10 +515,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 22, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -571,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -586,10 +588,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 23, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, From 7a27acbcf3cb7f845c5d4484b8f36a19781dea3e Mon Sep 17 00:00:00 2001 From: Zhisong Qu Date: Mon, 20 Jul 2020 20:47:44 +1000 Subject: [PATCH 6/6] minor changes --- Utilities/pythontools/py_spec/SPECNamelist.py | 62 +++++++------------ 1 file changed, 24 insertions(+), 38 deletions(-) diff --git a/Utilities/pythontools/py_spec/SPECNamelist.py b/Utilities/pythontools/py_spec/SPECNamelist.py index b46b80a3..86102a2a 100644 --- a/Utilities/pythontools/py_spec/SPECNamelist.py +++ b/Utilities/pythontools/py_spec/SPECNamelist.py @@ -105,43 +105,41 @@ def write(self, filename, force=False): if os.path.exists(filename): if not force: - raise Exception(filename + ' already exists! Pleaes set force to True if you would like to force overwrite.') + raise Exception(filename + ' already exists! Please set force to True if you would like to force overwrite.') - file_object = open(filename, 'w') - from datetime import datetime + with open(filename, 'w') as file_object: + from datetime import datetime - intro_str = "! auto generated by SPECNamelist.py " - file_object.write(intro_str) + intro_str = "! auto generated by SPECNamelist.py " + file_object.write(intro_str) - # write the time for generating the namelist - file_object.write(datetime.now().strftime("%Y-%m-%d %H:%M:%S ")) + # write the time for generating the namelist + file_object.write(datetime.now().strftime("%Y-%m-%d %H:%M:%S ")) - # write the version of SPEC if known - if not self._spec_version == 'unknown': - file_object.write('SPEC version ' + self._spec_version) + # write the version of SPEC if known + if not self._spec_version == 'unknown': + file_object.write('SPEC version ' + self._spec_version) - # conclude the first line - file_object.write('\n') - - # convert all np.ndarray to list - for key1 in self: - for key2 in self[key1]: - if isinstance(self[key1][key2], np.ndarray): - self[key1][key2] = self[key1][key2].tolist() + # conclude the first line + file_object.write('\n') - # write the main content of the namelist - super().write(file_object) + # convert all np.ndarray to list + for key1 in self: + for key2 in self[key1]: + if isinstance(self[key1][key2], np.ndarray): + self[key1][key2] = self[key1][key2].tolist() - # write the interface guess - self._write_interface_guess(file_object) + # write the main content of the namelist + super().write(file_object) - file_object.close() + # write the interface guess + self._write_interface_guess(file_object) def run(self, spec_command='./xspec', filename='spec.sp', force=False): '''Run SPEC on the current namelist and obtain its output parameters: spec_command -- the command to call SPEC, usually it looks like '/path/to/spec/xspec' - or 'mpirun -np (ncpus) /path/to/spec/xspec', with (ncpus) replaced the number of cpus + or 'mpirun -np (ncpus) /path/to/spec/xspec', with (ncpus) replaced by the number of cpus filename -- write this namelist to the temporary file 'filename' in current folder force -- if file exists, force overwrite or not @@ -205,13 +203,6 @@ def insert_volume(self, ivol=0, tflux=None): self['physicslist']['tflux'].insert(ivol, tflux) - # interpolate to get quantities in the new volume - if ivol == Nvol: - # add a new volume outside the plasma boundary, we can extrapolate so don't do anything - pass - else: - interpolate_list = ['pflux', 'mu', 'helicity', 'Ivolume', 'Isurf'] - # update Nvol self._Nvol = self._Nvol + 1 self['physicslist']['nvol'] = self['physicslist']['nvol'] + 1 @@ -226,7 +217,7 @@ def remove_volume(self, ivol=0): if self._Nvol == 1: raise RuntimeError('At least one volume should remain') if ivol==self._Nvol-1 and self['physicslist']['Lfreebound'] == 0: - raise RuntimeError('You can remove the last interface (plasma boundary).') + raise RuntimeError('You cannot remove the last interface (plasma boundary).') zero_index_keys = ['tflux', 'pflux', 'mu', 'helicity', 'pressure', 'adiabatic', 'Lrad', 'nPtrj', 'Ivolume', 'Isurf'] for key in zero_index_keys: @@ -670,9 +661,4 @@ def _interpolate_singular(data, ivol, m, r_right, r_int, value_left): else: # otherwise, we don't need the axis value value_int = value_right * s**m - return value_int - - - - - + return value_int \ No newline at end of file