h2lib 0.0.3__cp39-cp39-win_amd64.whl → 13.0.705__cp39-cp39-win_amd64.whl

h2lib/h2lib_signatures.py

@@ -0,0 +1,318 @@
+# noqa
+
+from h2lib.dll_wrapper import DLLWrapper
+
+
+class H2LibSignatures():
+    def add_sensor(self, sensor_line, index_start, index_stop):
+        '''subroutine add_sensor(sensor_line, index_start, index_stop) bind(C, name="add_sensor")
+      integer*8 :: index_start, index_stop
+      character(kind=c_char, len=1), intent(in)       :: sensor_line(1024)
+    end subroutine'''
+        return self.get_lib_function('add_sensor')(sensor_line, index_start, index_stop)
+
+    def echo_version(self, ):
+        '''subroutine echo_version() BIND(C, NAME='echo_version')
+    !DEC$ ATTRIBUTES DLLEXPORT :: echo_version
+    !GCC$ ATTRIBUTES DLLEXPORT :: echo_version
+    type (tbuildinfo)   :: b
+end subroutine'''
+        return self.get_lib_function('echo_version')()
+
+    def extern_write_log(self, c_msg, n, dll_name, error, warning):
+        '''subroutine extern_write_log(c_msg, n, dll_name, error, warning) bind(C, name="extern_write_log")
+            integer, intent(in) :: n
+            character(kind=c_char, len=1), intent(in) :: c_msg(n)
+            character(kind=c_char), intent(in) :: dll_name(50)
+            logical(kind=c_bool), intent(in), optional :: error, warning
+    character(kind=c_char, len=1), intent(in) :: c_msg(n_msg)
+    integer, intent(in) :: n_msg
+    character(kind=c_char), intent(in) :: dll_name(50)
+    character(len=50) :: n
+    logical(kind=c_bool), intent(in), optional :: error, warning
+end subroutine'''
+        return self.get_lib_function('extern_write_log')(c_msg, n, dll_name, error, warning)
+
+    def fail(self, str_arr):  # pragma: no cover
+        '''subroutine fail(str_arr) bind(C, name='fail')
+    character(kind=c_char, len=1), intent(inout)       :: str_arr(255)
+  end subroutine'''
+        return self.get_lib_function('fail')(str_arr)
+
+    def finalize(self, ):
+        '''SUBROUTINE finalize() bind(C, name="finalize")
+!DEC$ ATTRIBUTES DLLEXPORT :: finalize
+  integer:: i
+  real*4:: T2
+END SUBROUTINE'''
+        return self.get_lib_function('finalize')()
+
+    def getSquare(self, val, restype):
+        '''function getSquare(val) result(valSquared) BIND(C, NAME='getSquare')
+  !DEC$ ATTRIBUTES DLLEXPORT :: getSquare
+        real(RK), intent(in) :: val
+        real(RK)             :: valSquared
+    end function'''
+        return self.get_lib_function('getSquare')(val, restype=restype)
+
+    def getState(self, restype):
+        '''function getState() result(val) BIND(C, NAME='getState')
+  !DEC$ ATTRIBUTES DLLEXPORT :: getState
+        integer             :: val
+    end function'''
+        return self.get_lib_function('getState')(restype=restype)
+
+    def get_aerosections_forces(self, rotor, Fxyz):
+        '''subroutine get_aerosections_forces(rotor, Fxyz) bind(C, name='get_aerosections_forces')
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out)::Fxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_forces')(rotor, Fxyz)
+
+    def get_aerosections_moments(self, rotor, Mxyz):
+        '''subroutine get_aerosections_moments(rotor, Mxyz) bind(C, name='get_aerosections_moments')
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out):: Mxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_moments')(rotor, Mxyz)
+
+    def get_aerosections_position(self, rotor, position):
+        '''subroutine get_aerosections_position(rotor, position) bind(C, name="get_aerosections_position")
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out)   :: position(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_position')(rotor, position)
+
+    def get_bem_grid(self, rotor, azi, rad):
+        '''subroutine get_bem_grid(rotor, azi, rad) bind(C, name="get_bem_grid")
+    integer*8, intent(in)               :: rotor
+    real(c_double), intent(out)       :: azi(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi)
+    real(c_double), intent(out)       :: rad(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_bem_grid')(rotor, azi, rad)
+
+    def get_bem_grid_dim(self, rotor, nazi, nrad):
+        '''subroutine get_bem_grid_dim(rotor, nazi, nrad) bind(C, name="get_bem_grid_dim")
+    integer*8, intent(in)               :: rotor
+    integer*8, intent(out)              :: nazi, nrad
+  end subroutine'''
+        return self.get_lib_function('get_bem_grid_dim')(rotor, nazi, nrad)
+
+    def get_diameter(self, rotor, restype):
+        '''function get_diameter(rotor) bind(C, name="get_diameter")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_diameter
+    integer*8, intent(in) :: rotor
+    Type (Taerorotor),pointer :: rotor_p
+    real(c_double)  :: get_diameter
+ end function'''
+        return self.get_lib_function('get_diameter')(rotor, restype=restype)
+
+    def get_induction_axisymmetric(self, rotor, induction):
+        '''subroutine get_induction_axisymmetric(rotor, induction) bind(C, name="get_induction_axisymmetric")
+    integer*8, intent(in)        :: rotor
+    real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_induction_axisymmetric')(rotor, induction)
+
+    def get_induction_polargrid(self, rotor, induction):
+        '''subroutine get_induction_polargrid(rotor, induction) bind(C, name="get_induction_polargrid")
+      integer*8, intent(in)        :: rotor
+      real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi, rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_induction_polargrid')(rotor, induction)
+
+    def get_induction_rotoravg(self, rotor, induction):
+        '''subroutine get_induction_rotoravg(rotor, induction) bind(C, name="get_induction_rotoravg")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_induction_rotoravg
+    integer*8, intent(in)        :: rotor
+    real(c_double), intent(out) :: induction
+  end subroutine'''
+        return self.get_lib_function('get_induction_rotoravg')(rotor, induction)
+
+    def get_nSections(self, rotor, blade, restype):
+        '''function get_nSections(rotor, blade) bind(C, name="get_nSections")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nSections
+    integer*8, intent(in) :: rotor, blade
+    integer*8             :: get_nSections
+  end function'''
+        return self.get_lib_function('get_nSections')(rotor, blade, restype=restype)
+
+    def get_nblades(self, rotor, restype):
+        '''function get_nblades(rotor) bind(C, name="get_nblades")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nblades
+    integer*8, intent(in) ::  rotor
+    integer*8             :: get_nblades
+  end function'''
+        return self.get_lib_function('get_nblades')(rotor, restype=restype)
+
+    def get_nrotors(self, restype):
+        '''function get_nrotors() bind(C, name="get_nrotors")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nrotors
+    integer*8 :: get_nrotors
+  end function'''
+        return self.get_lib_function('get_nrotors')(restype=restype)
+
+    def get_rotor_avg_wsp(self, coo, rotor, wsp):
+        '''subroutine get_rotor_avg_wsp(coo, rotor, wsp) bind(C, name="get_rotor_avg_wsp")
+    integer*8, intent(in) :: rotor
+    integer*8, intent(in) :: coo ! 1: global, 2: rotor
+    real(c_double), dimension(3):: wsp
+  end subroutine'''
+        return self.get_lib_function('get_rotor_avg_wsp')(coo, rotor, wsp)
+
+    def get_rotor_orientation(self, rotor, yaw, tilt, azi):
+        '''subroutine get_rotor_orientation(rotor, yaw, tilt, azi) bind(C, name="get_rotor_orientation")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_orientation
+    integer*8, intent(in) :: rotor
+    real(c_double), intent(out) :: yaw, tilt, azi
+  end subroutine'''
+        return self.get_lib_function('get_rotor_orientation')(rotor, yaw, tilt, azi)
+
+    def get_rotor_position(self, rotor, position):
+        '''subroutine get_rotor_position(rotor, position) bind(C, name="get_rotor_position")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_position
+    integer*8, intent(in) :: rotor
+    real(c_double), dimension(3), intent(out) ::  position
+  !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_avg_wsp
+    integer*8, intent(in) :: rotor
+    integer*8, intent(in) :: coo ! 1: global, 2: rotor
+  end subroutine'''
+        return self.get_lib_function('get_rotor_position')(rotor, position)
+
+    def get_sensor_info(self, id, name, unit, desc):
+        '''subroutine get_sensor_info(id, name, unit, desc) bind(C, name="get_sensor_info")
+      integer*8, intent(in) :: id
+      character(kind=c_char, len=1), intent(out)       :: name(30), unit(10), desc(512)
+    end subroutine'''
+        return self.get_lib_function('get_sensor_info')(id, name, unit, desc)
+
+    def get_sensor_values(self, ids, values, n):
+        '''subroutine get_sensor_values(ids, values, n) bind(C, name="get_sensor_values")
+      integer*8, intent(in) :: n
+      integer*8, intent(in) :: ids(n)
+      real(c_double), intent(out)        :: values(n)
+    end subroutine'''
+        return self.get_lib_function('get_sensor_values')(ids, values, n)
+
+    def get_time(self, time):
+        '''subroutine
+subroutine'''
+        return self.get_lib_function('get_time')(time)
+
+    def get_version(self, s):
+        '''subroutine get_version(s) BIND(C, NAME='get_version')
+                character(kind=c_char, len=1), intent(inout)  :: s(255)
+            end subroutine'''
+        return self.get_lib_function('get_version')(s)
+
+    def init(self, ):
+        '''subroutine init() bind(C, name="init")
+     !DEC$ ATTRIBUTES DLLEXPORT :: init
+    end subroutine'''
+        return self.get_lib_function('init')()
+
+    def init_windfield(self, Nxyz, dxyz, box_offset_yz, transport_speed):
+        '''subroutine init_windfield(Nxyz, dxyz, box_offset_yz, transport_speed) bind(C, name="init_windfield")
+      integer*8, dimension(3), intent(in) :: Nxyz
+      real*8              :: transport_speed
+    end subroutine'''
+        return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed)
+
+    def loop(self, N, restype):
+        '''function loop(N) bind(C, Name='loop')
+    !DEC$ ATTRIBUTES DLLEXPORT :: loop
+    integer*8, intent(in) :: N
+    real(c_double) :: loop,a
+    integer*8 :: i, j
+  end function'''
+        return self.get_lib_function('loop')(N, restype=restype)
+
+    def myfunction(self, int, dbl, restype):
+        '''function myfunction(int, dbl) bind(C, name='myfunction')
+      !DEC$ ATTRIBUTES DLLEXPORT :: myfunction
+      integer*8, intent(in) :: int
+      real(c_double), intent(in) :: dbl
+      real(c_double) :: myfunction
+    end function'''
+        return self.get_lib_function('myfunction')(int, dbl, restype=restype)
+
+    def mysubroutine(self, str_arr, dbl_arr):
+        '''subroutine mysubroutine(str_arr, dbl_arr) bind(C, name='mysubroutine')
+      character(kind=c_char, len=1), intent(inout)       :: str_arr(20)
+      real(c_double), intent(inout), dimension(2) :: dbl_arr
+    end subroutine'''
+        return self.get_lib_function('mysubroutine')(str_arr, dbl_arr)
+
+    def read_input(self, htc_path):
+        '''subroutine read_input(htc_path) bind(C, name="read_input")
+      character(kind=c_char, len=1), intent(in)       :: htc_path(1024)
+    end subroutine'''
+        return self.get_lib_function('read_input')(htc_path)
+
+    def run(self, time, restype):
+        '''function run(time) bind(C, name='run')
+      !DEC$ ATTRIBUTES DLLEXPORT :: run
+      real(c_double), intent(in) :: time
+      real(c_double) :: run, eps
+    end function'''
+        return self.get_lib_function('run')(time, restype=restype)
+
+    def setState(self, val):
+        '''subroutine setState(val) BIND(C, NAME='setState')
+  integer, intent(in) :: val
+ end subroutine'''
+        return self.get_lib_function('setState')(val)
+
+    def set_aerosections_windspeed(self, rotor, uvw):
+        '''subroutine set_aerosections_windspeed(rotor, uvw) bind(C, name="set_aerosections_windspeed")
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(in)   :: uvw(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw)
+
+    def set_variable_sensor_value(self, id, value):
+        '''subroutine set_variable_sensor_value(id, value) bind(C, name="set_variable_sensor_value")
+      integer*8, intent(in) :: id
+      real(c_double)        :: value
+    end subroutine'''
+        return self.get_lib_function('set_variable_sensor_value')(id, value)
+
+    def set_windfield(self, uvw, box_offset_x, time):
+        '''subroutine set_windfield(uvw, box_offset_x, time) bind(C, name="set_windfield")
+      real*4, intent(in) :: uvw(3, gwsd%TMOD%buffer_points_x,gwsd%TMOD%buffer_points_y,gwsd%TMOD%buffer_points_z)
+      real*8, intent(in):: box_offset_x, time
+    end subroutine'''
+        return self.get_lib_function('set_windfield')(uvw, box_offset_x, time)
+
+    def sqr2(self, val):
+        '''subroutine sqr2(val) BIND(C, NAME='sqr2')
+  integer, intent(inout) :: val
+ end subroutine'''
+        return self.get_lib_function('sqr2')(val)
+
+    def step(self, restype):
+        '''function step() bind(C, name='step')
+      !DEC$ ATTRIBUTES DLLEXPORT :: step
+      real(c_double) :: step
+    end function'''
+        return self.get_lib_function('step')(restype=restype)
+
+    def test_hdf5(self, ):
+        '''subroutine test_hdf5() BIND(C, NAME='test_hdf5')
+  !DEC$ ATTRIBUTES DLLEXPORT :: test_hdf5
+  INTEGER     ::   hdferr ! Error flag
+  CHARACTER(9) :: filename = 'test.hdf5'
+  INTEGER(HID_T) :: file_id       ! File identifier
+  INTEGER(HID_T) :: H5_Create_file,H5_Open_file      ! File identifier
+  type(c_ptr) :: x
+ end subroutine'''
+        return self.get_lib_function('test_hdf5')()
+
+    def work(self, time, restype):
+        '''function work(time) bind(C, Name='work')
+    !DEC$ ATTRIBUTES DLLEXPORT :: work
+    real(c_double), intent(in) :: time
+    real*4 :: start_time, t
+    integer*8 :: N, work
+  end function'''
+        return self.get_lib_function('work')(time, restype=restype)

h2lib-13.0.705.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: h2lib
+Version: 13.0.705
+Summary: Python interface to HAWC2 (13.0.9)
+Download-URL: 
+Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
+Author-email: mmpe@dtu.dk
+Maintainer: 
+Maintainer-email: 
+Project-URL: Documentation, https://hawc2.pages.windenergy.dtu.dk/HAWC2Lib/
+Project-URL: Source, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib
+Project-URL: Tracker, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib/-/issues
+Requires-Dist: numpy
+Requires-Dist: intel-fortran-rt ==2021.3.0
+Requires-Dist: mkl ==2021.3.0
+Provides-Extra: test
+Requires-Dist: h2lib-tests ; extra == 'test'
+

h2lib-13.0.705.dist-info/RECORD

@@ -0,0 +1,14 @@
+h2lib/HAWC2Lib.dll,sha256=GhnrcvnvBrC_KxHN2Asm1U7Ak6SW1axLhiBGPocwAvw,29301760
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=PvXyuoVW6IDbjeYWYtCHRYcpLMlZh7aCiJkfLBl88gg,14938
+h2lib/_version.py,sha256=xyyOn5ozEvCx53n7O9Ht13YA4b22VWeehuYZqCSUdEk,146
+h2lib/dll_wrapper.py,sha256=vO7IGbnPTpzrbjsvm-jRnYabXM97gCukJDTPJHDLEpA,11824
+h2lib/h2lib_signatures.py,sha256=uIcqvgVbm_L5C4jpHc9mBqz_6G5sLIk_6n2i-j1oA04,14500
+multiclass_interface/mpi_interface.py,sha256=eGftiuyQ3QkcenpEmbZjy_3VomWoXADnQsGUCFoFBvs,6274
+multiclass_interface/multi_object_list.py,sha256=5bEdwvtzQkPyBrS-W64i3EHJmuTfNGmRhGm5ToK7SXI,2072
+multiclass_interface/multiprocess_interface.py,sha256=L5G7-EL5rXQtze5-4oSTBFs0AjswbD2diNtt0ynfWOM,7271
+multiclass_interface/my_test_cls.py,sha256=7ZDsFkxrLfOY6q00U5Y-daxfuhATK-K5H04RP-VmQdE,850
+h2lib-13.0.705.dist-info/METADATA,sha256=54FEPqcr2y_3vR70shyoAVXYpWfUwFdJcDNWW-EFR3M,623
+h2lib-13.0.705.dist-info/WHEEL,sha256=GZFS91_ufm4WrNPBaFVPB9MvOXR6bMZQhPcZRRTN5YM,100
+h2lib-13.0.705.dist-info/top_level.txt,sha256=CafRr3oTgH80oaQrp2SGKlPcX7cag5ag4EGKAZAy1ow,27
+h2lib-13.0.705.dist-info/RECORD,,

{h2lib-0.0.3.dist-info → h2lib-13.0.705.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp39-cp39-win_amd64
 

h2lib-13.0.705.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+h2lib
+multiclass_interface

multiclass_interface/mpi_interface.py

@@ -0,0 +1,184 @@
+import numpy as np
+import sys
+import os
+import subprocess
+import traceback
+import inspect
+from enum import Enum
+
+if 'SLURM_NTASKS' in os.environ:
+    mpi = int(os.environ['SLURM_NTASKS']) > 1
+elif any([k in os.environ for k in ['MPI_LOCALNRANKS', 'OMPI_COMM_WORLD_SIZE']]):
+    mpi = True
+else:
+    mpi = subprocess.run("python -c 'from mpi4py import MPI'", shell=True,
+                         check=False, stderr=subprocess.PIPE).returncode == 0
+
+if mpi:
+    from mpi4py import MPI
+    comm = MPI.COMM_WORLD
+    size = MPI.COMM_WORLD.Get_size()
+    rank = MPI.COMM_WORLD.Get_rank()
+    name = MPI.Get_processor_name()
+else:
+    size = 1
+
+MPIClassInterfaceAttributes = {'close', 'use_rank', 'cls', 'work_loop', 'object', '__class__','get_input','do_task', 'run_task', 'closed'}
+
+    
+LOOP_UNTIL_CLOSE=True
+TERMINATE_ON_CLOSE=True
+
+
+class MPIClassInterface():
+    def __init__(self, cls, args_lst):
+        if len(args_lst) > size:
+            if rank == 0:
+                raise Exception(f"Not enough mpi slots. Slots: {size}, Requested: {len(args_lst)}")
+            return
+        self.cls = cls
+        if rank < len(args_lst):
+            self.object = cls(*args_lst[rank])
+        else:
+            class Dummy():
+                def close(self):
+                    pass
+            self.object = Dummy()
+        self.closed=False
+
+        if rank == 0:
+            self.use_rank = np.array([True] * size)
+            self.use_rank[len(args_lst):] = False
+        elif LOOP_UNTIL_CLOSE:
+            self.work_loop()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def work_loop(self):
+        while True:
+            method, args, kwargs = comm.scatter(None)
+            comm.gather(self.do_task(method, args, kwargs))
+            if LOOP_UNTIL_CLOSE:
+                if method == 'close':
+                    if TERMINATE_ON_CLOSE:
+                        #comm.gather(f'Exit, rank {rank}')
+                        print ("sys.exit", rank, flush=True)
+                        sys.exit(0)
+                    else:
+                        raise ChildProcessError('MPI worker done')
+            else:
+                break    
+
+                    
+    def do_task(self, method, args, kwargs):
+        try:
+            if method == 'skip':
+                res = None
+            elif method=='setattr':
+                name, value = args
+                if hasattr(value, '__call__'):  
+                    def wrap(*args, func=value, **kwargs):
+                        if inspect.getfullargspec(func).args[:1] == ['self']:
+                            args = (self.object,) + args
+                        return func(*args, **kwargs)
+                    value = wrap
+                res = setattr(self.object, name, value)
+            else:
+                res = getattr(self.object, method)
+                if hasattr(res, '__call__'):
+                    res = res(*args, **kwargs)
+        except BaseException as e:
+            res = (e, traceback.format_exc())
+        return res
+        
+    def run_task(self, input_lst):
+        comm.scatter(input_lst, root=0)
+        if rank == 0:
+            method, args, kwargs = input_lst[0]
+            res = self.do_task(method, args, kwargs) 
+        else:
+            res = None
+        use_rank = self.use_rank
+       
+        res = [res for i, res in enumerate(comm.gather(res, root=0)) if use_rank[i]]
+        if rank==0:
+            for r in res:
+                if isinstance(r, tuple) and len(r) > 1 and isinstance(r[0], BaseException):
+                    raise r[0].__class__(r[1])
+        return res
+                
+    
+    def get_input(self, name, i, args, kwargs):
+        use_rank = self.use_rank
+        N = np.sum(use_rank)
+        if use_rank[i]:
+            def get_arg(arg):
+                if isinstance(arg, list) and len(arg) == N:
+                    return arg[np.where(use_rank)[0][i]]
+                else:
+                    return arg
+            return (name, [get_arg(arg) for arg in args], {k: get_arg(v) for k, v in kwargs.items()})
+        else:
+            return ('skip', [], {})
+    
+    def __getattribute__(self, name):
+        if name in MPIClassInterfaceAttributes:
+            return object.__getattribute__(self, name)
+        elif rank > 0:
+            self.work_loop()
+            return lambda *args, **kwargs:1
+        
+        def wrap(*args, **kwargs):
+            inp = [self.get_input(name, i, args, kwargs) for i in range(size)]
+            return self.run_task(inp)
+            
+        if hasattr(getattr(self.object, name), '__call__'):
+            return wrap
+        else:
+            return wrap()
+            
+    def __setattr__(self, name, value):
+        if rank > 0 or name in MPIClassInterfaceAttributes:
+            return object.__setattr__(self, name, value)
+        else:
+            inp = [self.get_input('setattr', i, (name, value), {}) for i in range(size)]
+            return self.run_task(inp)
+            
+
+    def __getitem__(self, slice):
+        use_rank = np.full_like(self.use_rank, False)
+        use_rank[slice] = True
+        if np.all(self.use_rank == use_rank):
+            return self
+        return SubsetMPIClassInterface(self.cls, self.object, use_rank)
+
+    def close(self):
+        if not self.closed:
+            if rank==0:
+                res = self.run_task([('close', [], {}) for _ in range(size)])
+            else:
+                self.work_loop()
+                res = None
+            self.closed=True
+                    
+                
+
+
+class SubsetMPIClassInterface(MPIClassInterface):
+    def __init__(self, cls, object, use_rank):
+        self.use_rank = use_rank
+        self.cls = cls
+        self.object = object
+
+    def __getitem__(self, slice):
+        l = np.arange(np.sum(self.use_rank))
+        if np.all(l == l[slice]):
+            return self
+        raise Exception('Cannot make subset of SubsetMPIClassInterface')
+
+    def close(self):
+        raise Exception('Cannot close SubsetMPIClassInterface. Please close all instances at once')

multiclass_interface/multi_object_list.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+class MultiObjectList():
+    def __init__(self, obj_lst, subset_cls=None):
+        self.obj_lst = np.atleast_1d(obj_lst)
+        self.subset_cls = subset_cls
+
+    def __str__(self):
+        return f'{self.__class__.__name__}({self.obj_lst})'
+
+    def get_obj_args_lst(self, args, kwargs):
+        N = len(self.obj_lst)
+
+        def get_obj_args(i):
+            def get_arg(arg):
+                if isinstance(arg, list) and len(arg) == N:
+                    return arg[i]
+                else:
+                    return arg
+            obj_args = [get_arg(arg) for arg in args]
+            obj_kwargs = {k: get_arg(v) for k, v in kwargs.items()}
+            return obj_args, obj_kwargs
+        return [get_obj_args(i) for i in range(N)]
+
+    def iscallable(self, name):
+        return hasattr(getattr(self.obj_lst[0], name), '__call__')
+
+    def __getitem__(self, s):
+        obj_lst = np.atleast_1d(self.obj_lst[s])
+        if len(obj_lst) == len(self.obj_lst) and np.all(obj_lst == self.obj_lst):
+            return self
+        subset_cls = self.subset_cls or MultiObjectList
+        return subset_cls(self.obj_lst[s])
+
+    def __getattr__(self, name):
+        att_lst = [getattr(obj, name) for obj in self.obj_lst]
+        if self.iscallable(name):
+            def wrap(*args, **kwargs):
+                return [att(*o_args, **o_kwargs)
+                        for att, (o_args, o_kwargs) in zip(att_lst, self.get_obj_args_lst(args, kwargs))]
+            return wrap
+        else:
+            return att_lst
+
+    def __setattr__(self, name, value):
+        if name in {'obj_lst', 'subset_cls'}:
+            return object.__setattr__(self, name, value)
+        obj_lst = self.obj_lst
+        for obj, (o_args, _) in zip(obj_lst, self.get_obj_args_lst((value,), {})):
+            setattr(obj, name, *o_args)
+
+
+class MultiClassInterface(MultiObjectList):
+    def __init__(self, cls, args_lst):
+        self.cls = cls
+        MultiObjectList.__init__(self, [cls(*args) for args in args_lst])