From dd06010382056ba6d4d7b6641641a023675ca0af Mon Sep 17 00:00:00 2001 From: Axel Huebl Date: Thu, 31 Aug 2023 11:34:57 -0700 Subject: [PATCH 1/6] Create Stub Files: Scripts & CI --- .github/update_stub.sh | 17 ++++++++ .github/workflows/ci.yml | 34 ++++++++++++++++ .github/workflows/codeql.yml | 2 +- .github/workflows/hip.yml | 2 +- .github/workflows/intel.yml | 2 +- .github/workflows/macos.yml | 2 +- .github/workflows/stubs.yml | 73 +++++++++++++++++++++++++++++++++++ .github/workflows/ubuntu.yml | 2 +- .github/workflows/windows.yml | 2 +- 9 files changed, 130 insertions(+), 6 deletions(-) create mode 100755 .github/update_stub.sh create mode 100644 .github/workflows/ci.yml create mode 100644 .github/workflows/stubs.yml diff --git a/.github/update_stub.sh b/.github/update_stub.sh new file mode 100755 index 00000000..3c296e25 --- /dev/null +++ b/.github/update_stub.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +# +# Copyright 2021-2023 The AMReX Community +# +# This script updates the .pyi stub files for documentation and interactive use. +# To run this script, pyAMReX needs to be installed (all dimensions) and importable. +# +# Authors: Axel Huebl +# License: BSD-3-Clause-LBNL +# + +# we are in the source directory, .github/ +this_dir=$(cd $(dirname $0) && pwd) + +pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space1d +pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space2d +pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space3d diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..37a1485e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,34 @@ +name: 👑 CI + +# This workflow updates the .pyi stub files for documentation and interactive use. + +on: [push, pull_request] + +concurrency: + group: ${{ github.ref }}-${{ github.head_ref }}-ci + cancel-in-progress: true + +jobs: + stubs: + name: 🔄 Update Stub Files + uses: ./.github/workflows/stubs.yml + ubuntu: + name: 🐧 Ubuntu + needs: stubs + uses: ./.github/workflows/ubuntu.yml + intel: + name: 🐧 Intel + needs: stubs + uses: ./.github/workflows/intel.yml + hip: + name: 🐧 HIP + needs: stubs + uses: ./.github/workflows/hip.yml + macos: + name: 🍏 macOS + needs: stubs + uses: ./.github/workflows/macos.yml + windows: + name: 🪟 Windows + needs: stubs + uses: ./.github/workflows/windows.yml diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 7bca3441..f747a3fe 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -1,4 +1,4 @@ -name: "CodeQL" +name: 🔎 CodeQL on: push: diff --git a/.github/workflows/hip.yml b/.github/workflows/hip.yml index 90907917..260a7691 100644 --- a/.github/workflows/hip.yml +++ b/.github/workflows/hip.yml @@ -1,6 +1,6 @@ name: 🐧 HIP -on: [push, pull_request] +on: [workflow_call] concurrency: group: ${{ github.ref }}-${{ github.head_ref }}-hip diff --git a/.github/workflows/intel.yml b/.github/workflows/intel.yml index 49c8afbf..f86ef79f 100644 --- a/.github/workflows/intel.yml +++ b/.github/workflows/intel.yml @@ -1,6 +1,6 @@ name: 🐧 Intel -on: [push, pull_request] +on: [workflow_call] concurrency: group: ${{ github.ref }}-${{ github.head_ref }}-intel diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml index fbcd76dc..9398f04b 100644 --- a/.github/workflows/macos.yml +++ b/.github/workflows/macos.yml @@ -1,6 +1,6 @@ name: 🍏 macOS -on: [push, pull_request] +on: [workflow_call] concurrency: group: ${{ github.ref }}-${{ github.head_ref }}-macos diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml new file mode 100644 index 00000000..da1608d3 --- /dev/null +++ b/.github/workflows/stubs.yml @@ -0,0 +1,73 @@ +name: 🔄 Update Stub Files + +# This workflow updates the .pyi stub files for documentation and interactive use. + +on: [workflow_call] + +concurrency: + group: ${{ github.ref }}-${{ github.head_ref }}-stubs + cancel-in-progress: true + +jobs: + # Build and install libamrex as AMReX CMake project + stubs: + name: Stubs + runs-on: ubuntu-22.04 + env: + CC: gcc + CXX: g++ + CXXFLAGS: "-O1" + OMP_NUM_THREAD: 2 + + if: github.event.pull_request.draft == false + permissions: + # Give the default GITHUB_TOKEN write permission to commit and push the + # changed files back to the repository. + contents: write + + steps: + - uses: actions/checkout@v3 + with: + repository: ${{ github.event.pull_request.head.repo.full_name }} + ref: ${{ github.head_ref }} + + - name: Pull Remote Changes + run: git pull + + - uses: actions/setup-python@v4 + name: Install Python + with: + python-version: '3.9' + + - name: Dependencies + run: .github/workflows/dependencies/dependencies_gcc10.sh + + - name: Build & Install + run: | + python3 -m pip install -U pip setuptools wheel + python3 -m pip install -U pip mpi4py pytest pybind11-stubgen pre-commit + cmake -S . -B build -DAMReX_SPACEDIM="1;2;3" -DpyAMReX_IPO=OFF + cmake --build build -j 2 --target pip_install + + - name: Update Stubs + run: | + .github/update_stub.sh + + - name: Run pre-commit cleanup + run: | + git add . + pre-commit run -a + git add . + + - name: Update Install + run: | + cmake --build build -j 2 --target pip_install + + - name: Unit tests + run: | + mpiexec -np 1 python3 -m pytest tests/ + + - uses: stefanzweifel/git-auto-commit-action@v4 + name: Commit Updated Stub Files + with: + commit_message: Update Stub Files diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index 5448724c..f0304093 100644 --- a/.github/workflows/ubuntu.yml +++ b/.github/workflows/ubuntu.yml @@ -1,6 +1,6 @@ name: 🐧 Ubuntu -on: [push, pull_request] +on: [workflow_call] concurrency: group: ${{ github.ref }}-${{ github.head_ref }}-linux diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index 78dc5679..6682c9dd 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -1,6 +1,6 @@ name: 🪟 Windows -on: [push, pull_request] +on: [workflow_call] concurrency: group: ${{ github.ref }}-${{ github.head_ref }}-windows From 4515577086fd49b8e6b836656350b8b3abdc28ab Mon Sep 17 00:00:00 2001 From: Axel Huebl Date: Fri, 1 Sep 2023 00:47:32 -0700 Subject: [PATCH 2/6] Fixes to Unbound C++ Types --- .github/update_stub.sh | 7 +- .github/workflows/stubs.yml | 2 +- .pre-commit-config.yaml | 1 + src/Base/Array4.cpp | 51 +++++++++++---- src/Base/BoxArray.cpp | 4 ++ src/Base/CoordSys.cpp | 19 ++++-- src/Base/DistributionMapping.cpp | 4 ++ src/Base/FArrayBox.cpp | 4 +- src/Base/Geometry.cpp | 4 ++ src/Base/IndexType.cpp | 14 ++-- src/Base/IntVect.cpp | 4 ++ src/Base/MultiFab.cpp | 88 +++++++++++++------------ src/Base/Vector.H | 106 +++++++++++++++++++++++++++++++ src/Base/Vector.cpp | 95 +-------------------------- src/Particle/Particle.cpp | 2 + src/Particle/ParticleContainer.H | 14 ++-- src/Particle/ParticleTile.cpp | 27 ++++++-- src/pyAMReX.cpp | 17 ++--- 18 files changed, 276 insertions(+), 187 deletions(-) create mode 100644 src/Base/Vector.H diff --git a/.github/update_stub.sh b/.github/update_stub.sh index 3c296e25..c1fd4572 100755 --- a/.github/update_stub.sh +++ b/.github/update_stub.sh @@ -8,10 +8,11 @@ # Authors: Axel Huebl # License: BSD-3-Clause-LBNL # +set -eu -o pipefail # we are in the source directory, .github/ this_dir=$(cd $(dirname $0) && pwd) -pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space1d -pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space2d -pybind11-stubgen --ignore-all-errors -o ${this_dir}/../src/amrex/ amrex.space3d +pybind11-stubgen --exit-code -o ${this_dir}/../src/amrex/ amrex.space1d +pybind11-stubgen --exit-code -o ${this_dir}/../src/amrex/ amrex.space2d +pybind11-stubgen --exit-code -o ${this_dir}/../src/amrex/ amrex.space3d diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml index da1608d3..0b3e412a 100644 --- a/.github/workflows/stubs.yml +++ b/.github/workflows/stubs.yml @@ -56,7 +56,7 @@ jobs: - name: Run pre-commit cleanup run: | git add . - pre-commit run -a + pre-commit run -a || true git add . - name: Update Install diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ca035f31..f0b0a86b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -30,6 +30,7 @@ repos: args: [--allow-multiple-documents] - id: check-added-large-files args: ['--maxkb=40'] + exclude: ^.*\.pyi$ - id: requirements-txt-fixer # - id: fix-encoding-pragma # exclude: ^noxfile.py$ diff --git a/src/Base/Array4.cpp b/src/Base/Array4.cpp index 96af32be..44280c0e 100644 --- a/src/Base/Array4.cpp +++ b/src/Base/Array4.cpp @@ -76,9 +76,12 @@ void make_Array4(py::module &m, std::string typestr) { using namespace amrex; + constexpr bool is_not_const = std::is_same_v, T>; + // dispatch simpler via: py::format_descriptor::format() naming auto const array_name = std::string("Array4_").append(typestr); - py::class_< Array4 >(m, array_name.c_str()) + py::class_< Array4 > py_array4(m, array_name.c_str()); + py_array4 .def("__repr__", [typestr](Array4 const & a4) { std::stringstream s; @@ -193,15 +196,7 @@ void make_Array4(py::module &m, std::string typestr) .def("contains", &Array4::contains) //.def("__contains__", &Array4::contains) - // setter & getter - .def("__setitem__", [](Array4 & a4, IntVect const & v, T const value){ a4(v) = value; }) - .def("__setitem__", [](Array4 & a4, std::array const key, T const value){ - a4(key[0], key[1], key[2], key[3]) = value; - }) - .def("__setitem__", [](Array4 & a4, std::array const key, T const value){ - a4(key[0], key[1], key[2]) = value; - }) - + // getter .def("__getitem__", [](Array4 & a4, IntVect const & v){ return a4(v); }) .def("__getitem__", [](Array4 & a4, std::array const key){ return a4(key[0], key[1], key[2], key[3]); @@ -211,11 +206,25 @@ void make_Array4(py::module &m, std::string typestr) }) ; + // setter + if constexpr (is_not_const) + { + py_array4 + .def("__setitem__", [](Array4 & a4, IntVect const & v, T const value){ a4(v) = value; }) + .def("__setitem__", [](Array4 & a4, std::array const key, T const value){ + a4(key[0], key[1], key[2], key[3]) = value; + }) + .def("__setitem__", [](Array4 & a4, std::array const key, T const value){ + a4(key[0], key[1], key[2]) = value; + }) + ; + } + // free standing C++ functions: - m.def("lbound", &lbound< Array4 >); - m.def("ubound", &ubound< Array4 >); - m.def("length", &length< Array4 >); - m.def("makePolymorphic", &makePolymorphic< Array4 >); + m.def("lbound", &lbound< T >); + m.def("ubound", &ubound< T >); + m.def("length", &length< T >); + //m.def("makePolymorphic", &makePolymorphic< T >); } void init_Array4(py::module &m) { @@ -233,6 +242,20 @@ void init_Array4(py::module &m) { make_Array4< unsigned long >(m, "ulong"); make_Array4< unsigned long long >(m, "ulonglong"); + make_Array4< float const >(m, "float_const"); + make_Array4< double const >(m, "double_const"); + make_Array4< long double const >(m, "longdouble_const"); + + make_Array4< short const >(m, "short_const"); + make_Array4< int const >(m, "int_const"); + make_Array4< long const >(m, "long_const"); + make_Array4< long long const >(m, "longlong_const"); + + make_Array4< unsigned short const >(m, "ushort_const"); + make_Array4< unsigned int const >(m, "uint_const"); + make_Array4< unsigned long const >(m, "ulong_const"); + make_Array4< unsigned long long const >(m, "ulonglong_const"); + // std::complex< float|double|long double> ? /* diff --git a/src/Base/BoxArray.cpp b/src/Base/BoxArray.cpp index 07bec405..f79e1b3a 100644 --- a/src/Base/BoxArray.cpp +++ b/src/Base/BoxArray.cpp @@ -5,6 +5,8 @@ */ #include "pyAMReX.H" +#include "Base/Vector.H" + #include #include @@ -281,4 +283,6 @@ void init_BoxArray(py::module &m) { */ ; + + make_Vector (m, "BoxArray"); } diff --git a/src/Base/CoordSys.cpp b/src/Base/CoordSys.cpp index e7739c2d..4c626669 100644 --- a/src/Base/CoordSys.cpp +++ b/src/Base/CoordSys.cpp @@ -1,3 +1,8 @@ +/* Copyright 2021-2023 The AMReX Community + * + * Authors: Axel Huebl, Ryan Sandberg + * License: BSD-3-Clause-LBNL + */ #include "pyAMReX.H" #include @@ -8,6 +13,14 @@ void init_CoordSys(py::module& m) using namespace amrex; py::class_ coord_sys(m, "CoordSys"); + + py::enum_(coord_sys, "CoordType") + .value("undef", CoordSys::CoordType::undef) + .value("cartesian", CoordSys::CoordType::cartesian) + .value("RZ", CoordSys::CoordType::RZ) + .value("SPHERICAL", CoordSys::CoordType::SPHERICAL) + .export_values(); + coord_sys.def("__repr__", [](const CoordSys&) { return ""; @@ -27,10 +40,4 @@ void init_CoordSys(py::module& m) // ... ; - py::enum_(coord_sys, "CoordType") - .value("undef", CoordSys::CoordType::undef) - .value("cartesian", CoordSys::CoordType::cartesian) - .value("RZ", CoordSys::CoordType::RZ) - .value("SPHERICAL", CoordSys::CoordType::SPHERICAL) - .export_values(); } diff --git a/src/Base/DistributionMapping.cpp b/src/Base/DistributionMapping.cpp index ffeb9ac2..ddc5af27 100644 --- a/src/Base/DistributionMapping.cpp +++ b/src/Base/DistributionMapping.cpp @@ -5,6 +5,8 @@ */ #include "pyAMReX.H" +#include "Base/Vector.H" + #include #include #include @@ -73,4 +75,6 @@ void init_DistributionMapping(py::module &m) { return dm[index]; }) ; + + make_Vector (m, "DistributionMapping"); } diff --git a/src/Base/FArrayBox.cpp b/src/Base/FArrayBox.cpp index 68b2197d..f7c249a8 100644 --- a/src/Base/FArrayBox.cpp +++ b/src/Base/FArrayBox.cpp @@ -27,7 +27,7 @@ void init_FArrayBox(py::module &m) { .def(py::init< Arena* >()) .def(py::init< Box const &, int, Arena* >()) .def(py::init< Box const &, int, bool, bool, Arena* >()) - .def(py::init< FArrayBox const &, MakeType, int, int >()) + //.def(py::init< FArrayBox const &, MakeType, int, int >()) .def(py::init< Box const &, int, Real const* >()) .def(py::init< Box const &, int, Real* >()) .def(py::init< Array4 const& >()) @@ -35,6 +35,7 @@ void init_FArrayBox(py::module &m) { .def(py::init< Array4 const& >()) .def(py::init< Array4 const&, IndexType >()) + /* .def("read_from", py::overload_cast(&FArrayBox::readFrom), py::arg("is") @@ -51,5 +52,6 @@ void init_FArrayBox(py::module &m) { py::overload_cast(&FArrayBox::writeOn, py::const_), py::arg("of"), py::arg("comp"), py::arg("num_comp") ) + */ ; } diff --git a/src/Base/Geometry.cpp b/src/Base/Geometry.cpp index 2cb1bc2c..1f0d42f2 100644 --- a/src/Base/Geometry.cpp +++ b/src/Base/Geometry.cpp @@ -1,5 +1,7 @@ #include "pyAMReX.H" +#include "Base/Vector.H" + #include #include #include @@ -205,4 +207,6 @@ void init_Geometry(py::module& m) // .def("computeRoundoffDomain") ; + + make_Vector (m, "Geometry"); } diff --git a/src/Base/IndexType.cpp b/src/Base/IndexType.cpp index 60037797..93241e59 100644 --- a/src/Base/IndexType.cpp +++ b/src/Base/IndexType.cpp @@ -1,6 +1,6 @@ /* Copyright 2021-2022 The AMReX Community * - * Authors: David Grote + * Authors: David Grote, Axel Huebl * License: BSD-3-Clause-LBNL */ #include "pyAMReX.H" @@ -28,6 +28,12 @@ void init_IndexType(py::module &m) { using namespace amrex; py::class_< IndexType > index_type(m, "IndexType"); + + py::enum_(index_type, "CellIndex") + .value("CELL", IndexType::CellIndex::CELL) + .value("NODE", IndexType::CellIndex::NODE) + .export_values(); + index_type.def("__repr__", [](py::object& obj) { py::str py_name = obj.attr("__class__").attr("__name__"); @@ -111,10 +117,4 @@ void init_IndexType(py::module &m) { .def_static("node_type", &IndexType::TheNodeType) ; - - py::enum_(index_type, "CellIndex") - .value("CELL", IndexType::CellIndex::CELL) - .value("NODE", IndexType::CellIndex::NODE) - .export_values(); - } diff --git a/src/Base/IntVect.cpp b/src/Base/IntVect.cpp index 6922e3ac..e69347c1 100644 --- a/src/Base/IntVect.cpp +++ b/src/Base/IntVect.cpp @@ -5,6 +5,8 @@ */ #include "pyAMReX.H" +#include "Base/Vector.H" + #include #include @@ -153,4 +155,6 @@ void init_IntVect(py::module &m) py::overload_cast(&coarsen)); m.def("refine", py::overload_cast(&refine)); + + make_Vector (m, "IntVect"); } diff --git a/src/Base/MultiFab.cpp b/src/Base/MultiFab.cpp index 865b4ec4..fac7f370 100644 --- a/src/Base/MultiFab.cpp +++ b/src/Base/MultiFab.cpp @@ -34,6 +34,10 @@ void init_MultiFab(py::module &m) { using namespace amrex; + py::class_< FabArrayBase > py_FabArrayBase(m, "FabArrayBase"); + py::class_< FabArray, FabArrayBase > py_FabArray_FArrayBox(m, "FabArray_FArrayBox"); + py::class_< MultiFab, FabArray > py_MultiFab(m, "MultiFab"); + py::class_< MFInfo >(m, "MFInfo") .def_readwrite("alloc", &MFInfo::alloc) .def_readwrite("arena", &MFInfo::arena) @@ -47,30 +51,6 @@ void init_MultiFab(py::module &m) .def("set_tag", [](MFInfo & info, std::string tag) { info.SetTag(std::move(tag)); }) ; - py::class_< FabArrayBase >(m, "FabArrayBase") - .def_property_readonly("is_all_cell_centered", &FabArrayBase::is_cell_centered) - .def_property_readonly("is_all_nodal", - py::overload_cast< >(&FabArrayBase::is_nodal, py::const_)) - .def("is_nodal", - py::overload_cast< int >(&FabArrayBase::is_nodal, py::const_)) - - .def_property_readonly("nComp", &FabArrayBase::nComp) - .def_property_readonly("num_comp", &FabArrayBase::nComp) - .def_property_readonly("size", &FabArrayBase::size) - - .def_property_readonly("nGrowVect", &FabArrayBase::nGrowVect) - - /* data access in Box index space */ - .def("__iter__", - [](FabArrayBase& fab) { - return MFIter(fab); - }, - // while the returned iterator (argument 0) exists, - // keep the FabArrayBase (argument 1; usually a MultiFab) alive - py::keep_alive<0, 1>() - ) - ; - py::class_< MFIter >(m, "MFIter", py::dynamic_attr()) .def("__repr__", [](MFIter const & mfi) { @@ -81,10 +61,10 @@ void init_MultiFab(py::module &m) } ) .def(py::init< FabArrayBase const & >()) - .def(py::init< FabArrayBase const &, MFItInfo const & >()) + //.def(py::init< FabArrayBase const &, MFItInfo const & >()) .def(py::init< MultiFab const & >()) - .def(py::init< MultiFab const &, MFItInfo const & >()) + //.def(py::init< MultiFab const &, MFItInfo const & >()) //.def(py::init< iMultiFab const & >()) //.def(py::init< iMultiFab const &, MFItInfo const & >()) @@ -122,7 +102,31 @@ void init_MultiFab(py::module &m) .def_property_readonly("length", &MFIter::length) ; - py::class_< FabArray, FabArrayBase >(m, "FabArray_FArrayBox") + py_FabArrayBase + .def_property_readonly("is_all_cell_centered", &FabArrayBase::is_cell_centered) + .def_property_readonly("is_all_nodal", + py::overload_cast< >(&FabArrayBase::is_nodal, py::const_)) + .def("is_nodal", + py::overload_cast< int >(&FabArrayBase::is_nodal, py::const_)) + + .def_property_readonly("nComp", &FabArrayBase::nComp) + .def_property_readonly("num_comp", &FabArrayBase::nComp) + .def_property_readonly("size", &FabArrayBase::size) + + .def_property_readonly("nGrowVect", &FabArrayBase::nGrowVect) + + /* data access in Box index space */ + .def("__iter__", + [](FabArrayBase& fab) { + return MFIter(fab); + }, + // while the returned iterator (argument 0) exists, + // keep the FabArrayBase (argument 1; usually a MultiFab) alive + py::keep_alive<0, 1>() + ) + ; + + py_FabArray_FArrayBox //.def("array", py::overload_cast< const MFIter& >(&FabArray::array)) //.def("const_array", &FabArray::const_array) .def("array", [](FabArray & fa, MFIter const & mfi) @@ -175,7 +179,7 @@ void init_MultiFab(py::module &m) py::arg("dest"), py::arg("src"), py::arg("scomp"), py::arg("dcomp"), py::arg("ncomp") ); - py::class_< MultiFab, FabArray >(m, "MultiFab") + py_MultiFab .def("__repr__", [](MultiFab const & mf) { return "()) .def(py::init< const BoxArray&, const DistributionMapping&, int, int, MFInfo const & >()) - .def(py::init< const BoxArray&, const DistributionMapping&, int, int, - MFInfo const &, FabFactory const & >()) + //.def(py::init< const BoxArray&, const DistributionMapping&, int, int, + // MFInfo const &, FabFactory const & >()) .def(py::init< const BoxArray&, const DistributionMapping&, int, IntVect const& >()) .def(py::init< const BoxArray&, const DistributionMapping&, int, IntVect const&, MFInfo const& >()) - .def(py::init< const BoxArray&, const DistributionMapping&, int, - IntVect const&, - MFInfo const&, FabFactory const & >()) + //.def(py::init< const BoxArray&, const DistributionMapping&, int, + // IntVect const&, + // MFInfo const&, FabFactory const & >()) - .def(py::init< MultiFab const&, MakeType, int, int >()) + //.def(py::init< MultiFab const&, MakeType, int, int >()) /* delayed defines */ - .def("define", - py::overload_cast< const BoxArray&, const DistributionMapping&, int, int, - MFInfo const &, FabFactory const & - >(&MultiFab::define)) - .def("define", - py::overload_cast< const BoxArray&, const DistributionMapping&, int, - IntVect const&, MFInfo const &, FabFactory const & - >(&MultiFab::define)) + //.def("define", + // py::overload_cast< const BoxArray&, const DistributionMapping&, int, int, + // MFInfo const &, FabFactory const & + //>(&MultiFab::define)) + //.def("define", + // py::overload_cast< const BoxArray&, const DistributionMapping&, int, + // IntVect const&, MFInfo const &, FabFactory const & + //>(&MultiFab::define)) /* setters */ //.def("set_val", diff --git a/src/Base/Vector.H b/src/Base/Vector.H new file mode 100644 index 00000000..043b433b --- /dev/null +++ b/src/Base/Vector.H @@ -0,0 +1,106 @@ +/* Copyright 2022-2023 The AMReX Community + * + * Authors: Ryan Sandberg, Axel Huebl + * License: BSD-3-Clause-LBNL + */ +#pragma once + +#include "pyAMReX.H" + +#include + +#include +#include +#include +#include +#include + + +namespace +{ + using namespace amrex; + + /** CPU: __array_interface__ v3 + * + * https://numpy.org/doc/stable/reference/arrays.interface.html + */ + template > + py::dict + array_interface(Vector const & vector) + { + auto d = py::dict(); + bool const read_only = false; + d["data"] = py::make_tuple(std::intptr_t(vector.dataPtr()), read_only); + d["shape"] = py::make_tuple(vector.size()); + d["strides"] = py::none(); + d["typestr"] = py::format_descriptor::format(); + d["version"] = 3; + return d; + } +} + +template > +void make_Vector(py::module &m, std::string typestr) +{ + using namespace amrex; + + using Vector_type = Vector; + auto const v_name = std::string("Vector_").append(typestr); + + auto py_vect = py::bind_vector(m, v_name.c_str()); + py_vect + .def("__repr__", + [typestr](Vector_type const & v) { + std::stringstream s, rs; + s << v.size(); + rs << "\n"; + rs << "[ "; + for (int ii = 0; ii < int(v.size()); ii++) { + rs << v[ii] << " "; + } + rs << "]\n"; + return rs.str(); + } + ) + .def(py::init<>()) + .def(py::init()) + + .def("size", &Vector_type::size) + ; + + if constexpr(std::is_fundamental_v) + { + py_vect + .def_property_readonly("__array_interface__", [](Vector_type const & vector) { + return array_interface(vector); + }) + .def_property_readonly("__cuda_array_interface__", [](Vector_type const & vector) { + // Nvidia GPUs: __cuda_array_interface__ v3 + // https://numba.readthedocs.io/en/latest/cuda/cuda_array_interface.html + auto d = array_interface(vector); + + // data: + // Because the user of the interface may or may not be in the same context, the most common case is to use cuPointerGetAttribute with CU_POINTER_ATTRIBUTE_DEVICE_POINTER in the CUDA driver API (or the equivalent CUDA Runtime API) to retrieve a device pointer that is usable in the currently active context. + // TODO For zero-size arrays, use 0 here. + + // None or integer + // An optional stream upon which synchronization must take place at the point of consumption, either by synchronizing on the stream or enqueuing operations on the data on the given stream. Integer values in this entry are as follows: + // 0: This is disallowed as it would be ambiguous between None and the default stream, and also between the legacy and per-thread default streams. Any use case where 0 might be given should either use None, 1, or 2 instead for clarity. + // 1: The legacy default stream. + // 2: The per-thread default stream. + // Any other integer: a cudaStream_t represented as a Python integer. + // When None, no synchronization is required. + d["stream"] = py::none(); + + d["version"] = 3; + return d; + }); + } + + py_vect + // setter & getter + .def("__setitem__", [](Vector_type & vector, int const idx, T const value){ vector[idx] = value; }) + .def("__getitem__", [](Vector_type & v, int const idx){ return v[idx]; }) + ; +} diff --git a/src/Base/Vector.cpp b/src/Base/Vector.cpp index de170172..04337848 100644 --- a/src/Base/Vector.cpp +++ b/src/Base/Vector.cpp @@ -5,104 +5,13 @@ */ #include "pyAMReX.H" +#include "Base/Vector.H" + #include -#include -#include -#include #include #include -#include - - -namespace -{ - using namespace amrex; - - /** CPU: __array_interface__ v3 - * - * https://numpy.org/doc/stable/reference/arrays.interface.html - */ - template > - py::dict - array_interface(Vector const & vector) - { - auto d = py::dict(); - bool const read_only = false; - d["data"] = py::make_tuple(std::intptr_t(vector.dataPtr()), read_only); - d["shape"] = py::make_tuple(vector.size()); - d["strides"] = py::none(); - d["typestr"] = py::format_descriptor::format(); - d["version"] = 3; - return d; - } -} - -template > -void make_Vector(py::module &m, std::string typestr) -{ - using namespace amrex; - - using Vector_type = Vector; - auto const v_name = std::string("Vector_").append(typestr); - - auto py_vect = py::bind_vector(m, v_name.c_str()); - py_vect - .def("__repr__", - [typestr](Vector_type const & v) { - std::stringstream s, rs; - s << v.size(); - rs << "\n"; - rs << "[ "; - for (int ii = 0; ii < int(v.size()); ii++) { - rs << v[ii] << " "; - } - rs << "]\n"; - return rs.str(); - } - ) - .def(py::init<>()) - .def(py::init()) - - .def("size", &Vector_type::size) - ; - - if constexpr(!std::is_same_v) - { - py_vect - .def_property_readonly("__array_interface__", [](Vector_type const & vector) { - return array_interface(vector); - }) - .def_property_readonly("__cuda_array_interface__", [](Vector_type const & vector) { - // Nvidia GPUs: __cuda_array_interface__ v3 - // https://numba.readthedocs.io/en/latest/cuda/cuda_array_interface.html - auto d = array_interface(vector); - // data: - // Because the user of the interface may or may not be in the same context, the most common case is to use cuPointerGetAttribute with CU_POINTER_ATTRIBUTE_DEVICE_POINTER in the CUDA driver API (or the equivalent CUDA Runtime API) to retrieve a device pointer that is usable in the currently active context. - // TODO For zero-size arrays, use 0 here. - - // None or integer - // An optional stream upon which synchronization must take place at the point of consumption, either by synchronizing on the stream or enqueuing operations on the data on the given stream. Integer values in this entry are as follows: - // 0: This is disallowed as it would be ambiguous between None and the default stream, and also between the legacy and per-thread default streams. Any use case where 0 might be given should either use None, 1, or 2 instead for clarity. - // 1: The legacy default stream. - // 2: The per-thread default stream. - // Any other integer: a cudaStream_t represented as a Python integer. - // When None, no synchronization is required. - d["stream"] = py::none(); - - d["version"] = 3; - return d; - }); - } - - py_vect - // setter & getter - .def("__setitem__", [](Vector_type & vector, int const idx, T const value){ vector[idx] = value; }) - .def("__getitem__", [](Vector_type & v, int const idx){ return v[idx]; }) - ; -} void init_Vector(py::module& m) { diff --git a/src/Particle/Particle.cpp b/src/Particle/Particle.cpp index deff1aa7..a2b35165 100644 --- a/src/Particle/Particle.cpp +++ b/src/Particle/Particle.cpp @@ -321,10 +321,12 @@ void init_Particle(py::module& m) { py::enum_(pidx, "IntValues") ; make_Particle< PIdx::nRealAttribs, PIdx::nIntAttribs > (m); + make_Particle< 0, 0 > (m); make_Particle< 1, 1 > (m); make_Particle< 2, 1 > (m); make_Particle< 3, 2 > (m); make_Particle< 4, 0 > (m); // HiPACE++ 22.07 make_Particle< 5, 0 > (m); // ImpactX 22.07 + make_Particle< 8, 2 > (m); // ImpactX 23.09+ make_Particle< 37, 1> (m); // HiPACE++ 22.07 } diff --git a/src/Particle/ParticleContainer.H b/src/Particle/ParticleContainer.H index a4eb0d26..d9efdeb4 100644 --- a/src/Particle/ParticleContainer.H +++ b/src/Particle/ParticleContainer.H @@ -59,8 +59,8 @@ void make_Base_Iterators (py::module &m, std::string allocstr) auto py_it_base = py::class_(m, particle_it_base_name.c_str()) .def(py::init(), py::arg("particle_container"), py::arg("level")) - .def(py::init(), - py::arg("particle_container"), py::arg("level"), py::arg("info")) + //.def(py::init(), + // py::arg("particle_container"), py::arg("level"), py::arg("info")) .def("particle_tile", &iterator_base::GetParticleTile, py::return_value_policy::reference_internal) @@ -124,8 +124,8 @@ void make_Iterators (py::module &m, std::string allocstr) ) .def(py::init(), py::arg("particle_container"), py::arg("level")) - .def(py::init(), - py::arg("particle_container"), py::arg("level"), py::arg("info")) + //.def(py::init(), + // py::arg("particle_container"), py::arg("level"), py::arg("info")) .def_property_readonly_static("is_soa_particle", [](const py::object&){ return ParticleType::is_soa_particle;}) ; } @@ -316,8 +316,8 @@ void make_ParticleContainer_and_Iterators (py::module &m, std::string allocstr) // void WritePlotFilePre (); // void WritePlotFilePost (); - .def("GetParticles", py::overload_cast<>(&ParticleContainerType::GetParticles), py::return_value_policy::reference_internal) - .def("GetParticles", py::overload_cast(&ParticleContainerType::GetParticles), py::return_value_policy::reference_internal) + //.def("GetParticles", py::overload_cast<>(&ParticleContainerType::GetParticles), py::return_value_policy::reference_internal) + .def("GetParticles", py::overload_cast(&ParticleContainerType::GetParticles), py::return_value_policy::reference_internal, py::arg("level")) // .def("ParticlesAt", py::overload_cast(&ParticleContainerType::ParticlesAt), // py::return_value_policy::reference_internal) // .def("ParticlesAt", py::overload_cast(&ParticleContainerType::ParticlesAt,py::const_)) @@ -346,6 +346,7 @@ void make_ParticleContainer_and_Iterators (py::module &m, std::string allocstr) // { return ParticlesAt(lev, iter.index(), iter.LocalTileIndex()); } // .def("DefineAndReturnParticleTile", py::overload_cast(&ParticleContainerType::DefineAndReturnParticleTile)) // .def("DefineAndReturnParticleTile", py::overload_cast(&ParticleContainerType::DefineAndReturnParticleTile, py::const_)) + /* .def("DefineAndReturnParticleTile", [](ParticleContainerType& pc, int lev, @@ -353,6 +354,7 @@ void make_ParticleContainer_and_Iterators (py::module &m, std::string allocstr) int tile) { return pc.DefineAndReturnParticleTile(lev,grid,tile); }) + */ // ParticleTileType& DefineAndReturnParticleTile (int lev, int grid, int tile) // { // m_particles[lev][std::make_pair(grid, tile)].define(NumRuntimeRealComps(), NumRuntimeIntComps()); diff --git a/src/Particle/ParticleTile.cpp b/src/Particle/ParticleTile.cpp index 4885713b..275c889d 100644 --- a/src/Particle/ParticleTile.cpp +++ b/src/Particle/ParticleTile.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -81,12 +82,20 @@ void make_ParticleTile(py::module &m, std::string allocstr) .def("setNumNeighbors", &ParticleTileType::setNumNeighbors) .def("getNumNeighbors", &ParticleTileType::getNumNeighbors) .def("resize", &ParticleTileType::resize) + ; - .def("push_back", [](ParticleTileType& ptile, const ParticleType &p){ ptile.push_back(p);}) - // .def("push_back", py::overload_cast(&ParticleTileType::push_back), "Add one particle to this tile.") - // .def("push_back", py::overload_cast(&ParticleTileType::push_back), "Add one particle to this tile.") + if constexpr (!T_ParticleType::is_soa_particle) { + py_particle_tile + .def("push_back", + [](ParticleTileType& ptile, const ParticleType &p) { ptile.push_back(p); }, + "Add one particle to this tile.") + ; + } - .def("push_back", [](ParticleTileType& ptile, const SuperParticleType &p) {ptile.push_back(p);}) + py_particle_tile + .def("push_back", + [](ParticleTileType& ptile, const SuperParticleType &p) {ptile.push_back(p);}, + "Add one particle to this tile.") .def("push_back_real", [](ParticleTileType& ptile, int comp, ParticleReal v) {ptile.push_back_real(comp, v);}) .def("push_back_real", [](ParticleTileType& ptile, const std::array& v) {ptile.push_back_real(v);}) @@ -127,7 +136,12 @@ void make_ParticleTile(py::module &m, std::string allocstr) template void make_ParticleTile(py::module &m) { - make_ParticleTileData(m); + if constexpr (T_ParticleType::is_soa_particle) { + make_ParticleTileData(m); + } + else { + make_ParticleTileData(m); + } // see Src/Base/AMReX_GpuContainers.H // !AMREX_USE_GPU: DefaultAllocator = std::allocator @@ -168,12 +182,13 @@ void init_ParticleTile(py::module& m) { // AMReX legacy AoS position + id/cpu particle ype using ParticleType_0_0 = Particle<0, 0>; using ParticleType_1_1 = Particle<1, 1>; + using SoAParticleType_8_2 = SoAParticle<8, 2>; // TODO: we might need to move all or most of the defines in here into a // test/example submodule, so they do not collide with downstream projects make_ParticleTile (m); make_ParticleTile (m); // HiPACE++ 22.07 make_ParticleTile (m); // ImpactX 22.07 - make_ParticleTile (m); + make_ParticleTile (m); // ImpactX 23.09+ make_ParticleTile (m); // HiPACE++ 22.07 } diff --git a/src/pyAMReX.cpp b/src/pyAMReX.cpp index 4da66589..c30dc65e 100644 --- a/src/pyAMReX.cpp +++ b/src/pyAMReX.cpp @@ -86,32 +86,33 @@ PYBIND11_MODULE(amrex_3d_pybind, m) { Vector )pbdoc"; - // note: order from parent to child classes + // note: order from parent to child classes and argument usage init_AMReX(m); init_Arena(m); init_Dim3(m); init_IntVect(m); init_IndexType(m); init_RealVect(m); + init_Box(m); init_Periodicity(m); init_Array4(m); - init_Box(m); init_BoxArray(m); init_ParmParse(m); + init_CoordSys(m); + init_RealBox(m); + init_Vector(m); + init_Geometry(m); + init_DistributionMapping(m); init_BaseFab(m); init_FArrayBox(m); init_MultiFab(m); - init_DistributionMapping(m); - init_RealBox(m); - init_CoordSys(m); - init_Geometry(m); init_ParallelDescriptor(m); init_Particle(m); + init_PODVector(m); init_StructOfArrays(m); init_ArrayOfStructs(m); init_ParticleTile(m); - init_PODVector(m); - init_Vector(m); + init_ParticleContainer(m); init_AmrMesh(m); From 391d2df2ea4af770fdca1e3a762227267ab9d6d3 Mon Sep 17 00:00:00 2001 From: ax3l Date: Fri, 1 Sep 2023 08:14:16 +0000 Subject: [PATCH 3/6] Update Stub Files --- src/amrex/space1d/__init__.pyi | 474 + .../amrex_1d_pybind/ParallelDescriptor.pyi | 8 + .../space1d/amrex_1d_pybind/__init__.pyi | 7767 ++++++++++++++++ src/amrex/space2d/__init__.pyi | 474 + .../amrex_2d_pybind/ParallelDescriptor.pyi | 8 + .../space2d/amrex_2d_pybind/__init__.pyi | 7784 ++++++++++++++++ src/amrex/space3d/__init__.pyi | 474 + .../amrex_3d_pybind/ParallelDescriptor.pyi | 8 + .../space3d/amrex_3d_pybind/__init__.pyi | 7808 +++++++++++++++++ 9 files changed, 24805 insertions(+) create mode 100644 src/amrex/space1d/__init__.pyi create mode 100644 src/amrex/space1d/amrex_1d_pybind/ParallelDescriptor.pyi create mode 100644 src/amrex/space1d/amrex_1d_pybind/__init__.pyi create mode 100644 src/amrex/space2d/__init__.pyi create mode 100644 src/amrex/space2d/amrex_2d_pybind/ParallelDescriptor.pyi create mode 100644 src/amrex/space2d/amrex_2d_pybind/__init__.pyi create mode 100644 src/amrex/space3d/__init__.pyi create mode 100644 src/amrex/space3d/amrex_3d_pybind/ParallelDescriptor.pyi create mode 100644 src/amrex/space3d/amrex_3d_pybind/__init__.pyi diff --git a/src/amrex/space1d/__init__.pyi b/src/amrex/space1d/__init__.pyi new file mode 100644 index 00000000..e155fa3d --- /dev/null +++ b/src/amrex/space1d/__init__.pyi @@ -0,0 +1,474 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import os as os + +from amrex.space1d.amrex_1d_pybind import ( + AlmostEqual, + AMReX, + AmrInfo, + AmrMesh, + Arena, + Array4_double, + Array4_double_const, + Array4_float, + Array4_float_const, + Array4_int, + Array4_int_const, + Array4_long, + Array4_long_const, + Array4_longdouble, + Array4_longdouble_const, + Array4_longlong, + Array4_longlong_const, + Array4_short, + Array4_short_const, + Array4_uint, + Array4_uint_const, + Array4_ulong, + Array4_ulong_const, + Array4_ulonglong, + Array4_ulonglong_const, + Array4_ushort, + Array4_ushort_const, + ArrayOfStructs_0_0_arena, + ArrayOfStructs_0_0_default, + ArrayOfStructs_0_0_pinned, + ArrayOfStructs_1_1_arena, + ArrayOfStructs_1_1_default, + ArrayOfStructs_1_1_pinned, + ArrayOfStructs_2_1_arena, + ArrayOfStructs_2_1_default, + ArrayOfStructs_2_1_pinned, + BaseFab_Real, + Box, + BoxArray, + Config, + CoordSys, + Dim3, + Direction, + DistributionMapping, + FabArray_FArrayBox, + FabArrayBase, + FArrayBox, + Geometry, + GeometryData, + IndexType, + IntVect, + MFInfo, + MFIter, + MultiFab, + ParallelDescriptor, + ParConstIter_0_0_4_0_arena, + ParConstIter_0_0_4_0_default, + ParConstIter_0_0_4_0_pinned, + ParConstIter_0_0_5_0_arena, + ParConstIter_0_0_5_0_default, + ParConstIter_0_0_5_0_pinned, + ParConstIter_1_1_2_1_arena, + ParConstIter_1_1_2_1_default, + ParConstIter_1_1_2_1_pinned, + ParConstIter_pureSoA_8_2_arena, + ParConstIter_pureSoA_8_2_default, + ParConstIter_pureSoA_8_2_pinned, + ParConstIterBase_0_0_4_0_arena, + ParConstIterBase_0_0_4_0_default, + ParConstIterBase_0_0_4_0_pinned, + ParConstIterBase_0_0_5_0_arena, + ParConstIterBase_0_0_5_0_default, + ParConstIterBase_0_0_5_0_pinned, + ParConstIterBase_1_1_2_1_arena, + ParConstIterBase_1_1_2_1_default, + ParConstIterBase_1_1_2_1_pinned, + ParConstIterBase_pureSoA_8_2_arena, + ParConstIterBase_pureSoA_8_2_default, + ParConstIterBase_pureSoA_8_2_pinned, + ParIter_0_0_4_0_arena, + ParIter_0_0_4_0_default, + ParIter_0_0_4_0_pinned, + ParIter_0_0_5_0_arena, + ParIter_0_0_5_0_default, + ParIter_0_0_5_0_pinned, + ParIter_1_1_2_1_arena, + ParIter_1_1_2_1_default, + ParIter_1_1_2_1_pinned, + ParIter_pureSoA_8_2_arena, + ParIter_pureSoA_8_2_default, + ParIter_pureSoA_8_2_pinned, + ParIterBase_0_0_4_0_arena, + ParIterBase_0_0_4_0_default, + ParIterBase_0_0_4_0_pinned, + ParIterBase_0_0_5_0_arena, + ParIterBase_0_0_5_0_default, + ParIterBase_0_0_5_0_pinned, + ParIterBase_1_1_2_1_arena, + ParIterBase_1_1_2_1_default, + ParIterBase_1_1_2_1_pinned, + ParIterBase_pureSoA_8_2_arena, + ParIterBase_pureSoA_8_2_default, + ParIterBase_pureSoA_8_2_pinned, + ParmParse, + Particle_0_0, + Particle_1_1, + Particle_2_1, + Particle_3_2, + Particle_4_0, + Particle_5_0, + Particle_7_0, + Particle_8_2, + Particle_37_1, + ParticleContainer_0_0_4_0_arena, + ParticleContainer_0_0_4_0_default, + ParticleContainer_0_0_4_0_pinned, + ParticleContainer_0_0_5_0_arena, + ParticleContainer_0_0_5_0_default, + ParticleContainer_0_0_5_0_pinned, + ParticleContainer_1_1_2_1_arena, + ParticleContainer_1_1_2_1_default, + ParticleContainer_1_1_2_1_pinned, + ParticleContainer_pureSoA_8_2_arena, + ParticleContainer_pureSoA_8_2_default, + ParticleContainer_pureSoA_8_2_pinned, + ParticleInitType_0_0_4_0, + ParticleInitType_0_0_5_0, + ParticleInitType_1_1_2_1, + ParticleTile_0_0_4_0_arena, + ParticleTile_0_0_4_0_default, + ParticleTile_0_0_4_0_pinned, + ParticleTile_0_0_5_0_arena, + ParticleTile_0_0_5_0_default, + ParticleTile_0_0_5_0_pinned, + ParticleTile_0_0_8_2_arena, + ParticleTile_0_0_8_2_default, + ParticleTile_0_0_8_2_pinned, + ParticleTile_0_0_37_1_arena, + ParticleTile_0_0_37_1_default, + ParticleTile_0_0_37_1_pinned, + ParticleTile_1_1_2_1_arena, + ParticleTile_1_1_2_1_default, + ParticleTile_1_1_2_1_pinned, + ParticleTileData_0_0_4_0, + ParticleTileData_0_0_5_0, + ParticleTileData_0_0_8_2, + ParticleTileData_0_0_37_1, + ParticleTileData_1_1_2_1, + Periodicity, + PIdx, + PODVector_int_arena, + PODVector_int_pinned, + PODVector_int_std, + PODVector_real_arena, + PODVector_real_pinned, + PODVector_real_std, + RealBox, + RealVect, + StructOfArrays_2_1_arena, + StructOfArrays_2_1_default, + StructOfArrays_2_1_pinned, + StructOfArrays_4_0_arena, + StructOfArrays_4_0_default, + StructOfArrays_4_0_pinned, + StructOfArrays_5_0_arena, + StructOfArrays_5_0_default, + StructOfArrays_5_0_pinned, + StructOfArrays_8_2_arena, + StructOfArrays_8_2_default, + StructOfArrays_8_2_pinned, + StructOfArrays_37_1_arena, + StructOfArrays_37_1_default, + StructOfArrays_37_1_pinned, + The_Arena, + The_Async_Arena, + The_Cpu_Arena, + The_Device_Arena, + The_Managed_Arena, + The_Pinned_Arena, + Vector_BoxArray, + Vector_DistributionMapping, + Vector_Geometry, + Vector_int, + Vector_IntVect, + Vector_Long, + Vector_Real, + Vector_string, + XDim3, + begin, + coarsen, + concatenate, + dtoh_memcpy, + end, + finalize, + htod_memcpy, + initialize, + initialized, + lbound, + length, + max, + min, + refine, + size, + ubound, + unpack_cpus, + unpack_ids, + write_single_level_plotfile, +) + +from . import amrex_1d_pybind + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "Print", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "amrex_1d_pybind", + "begin", + "coarsen", + "concatenate", + "d_decl", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "os", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +def Print(*args, **kwargs): + """ + Wrap amrex::Print() - only the IO processor writes + """ + +def d_decl(x, y, z): ... + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" diff --git a/src/amrex/space1d/amrex_1d_pybind/ParallelDescriptor.pyi b/src/amrex/space1d/amrex_1d_pybind/ParallelDescriptor.pyi new file mode 100644 index 00000000..70fb4af4 --- /dev/null +++ b/src/amrex/space1d/amrex_1d_pybind/ParallelDescriptor.pyi @@ -0,0 +1,8 @@ +from __future__ import annotations + +__all__ = ["IOProcessor", "IOProcessorNumber", "MyProc", "NProcs"] + +def IOProcessor() -> bool: ... +def IOProcessorNumber() -> int: ... +def MyProc() -> int: ... +def NProcs() -> int: ... diff --git a/src/amrex/space1d/amrex_1d_pybind/__init__.pyi b/src/amrex/space1d/amrex_1d_pybind/__init__.pyi new file mode 100644 index 00000000..9a2f1363 --- /dev/null +++ b/src/amrex/space1d/amrex_1d_pybind/__init__.pyi @@ -0,0 +1,7767 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import typing + +import numpy + +from . import ParallelDescriptor + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "begin", + "coarsen", + "concatenate", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +class AMReX: + @staticmethod + def empty() -> bool: ... + @staticmethod + def erase(arg0: AMReX) -> None: ... + @staticmethod + def size() -> int: ... + @staticmethod + def top() -> AMReX: ... + +class AmrInfo: + check_input: bool + grid_eff: float + iterate_on_new_grids: bool + max_level: int + n_proper: int + refine_grid_layout: bool + refine_grid_layout_dims: IntVect + use_fixed_coarse_grids: bool + use_fixed_upto_level: int + use_new_chop: bool + verbose: int + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + def blocking_factor(self, arg0: int) -> IntVect: ... + def max_grid_size(self, arg0: int) -> IntVect: ... + def n_error_buf(self, arg0: int) -> IntVect: ... + def ref_ratio(self, arg0: int) -> IntVect: ... + +class AmrMesh: + def Verbose(self) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, + rb: RealBox, + max_level_in: int, + n_cell_in: Vector_int, + coord: int, + ref_ratios: Vector_IntVect, + is_per: list[int[1]], + ) -> None: ... + def __repr__(self) -> str: ... + def finest_level(self) -> int: ... + def max_level(self) -> int: ... + @typing.overload + def ref_ratio(self) -> Vector_IntVect: ... + @typing.overload + def ref_ratio(self, arg0: int) -> IntVect: ... + +class Arena: + pass + +class Array4_double: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_double_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class ArrayOfStructs_0_0_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class BaseFab_Real: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + def big_end(self) -> IntVect: ... + def box(self) -> Box: ... + def clear(self) -> None: ... + def hi_vect(self) -> int: ... + def is_allocated(self) -> bool: ... + def length(self) -> IntVect: ... + def lo_vect(self) -> int: ... + @typing.overload + def n_bytes(self) -> int: ... + @typing.overload + def n_bytes(self, arg0: Box, arg1: int) -> int: ... + def n_bytes_owned(self) -> int: ... + def n_comp(self) -> int: ... + def num_pts(self) -> int: ... + def resize(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + def size(self) -> int: ... + def small_end(self) -> IntVect: ... + +class Box: + def __add__(self, arg0: IntVect) -> Box: ... + def __iadd__(self, arg0: IntVect) -> Box: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, typ: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, t: IndexType) -> None: ... + @typing.overload + def __init__(self, small: list[int[1]], big: list[int[1]]) -> None: ... + @typing.overload + def __init__( + self, small: list[int[1]], big: list[int[1]], t: IndexType + ) -> None: ... + def __isub__(self, arg0: IntVect) -> Box: ... + def __iter__(self) -> typing.Iterator: ... + def __repr__(self) -> str: ... + def __sub__(self, arg0: IntVect) -> Box: ... + def begin(self, arg0: Box) -> Dim3: ... + def contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def convert(self, arg0: IndexType) -> Box: ... + @typing.overload + def convert(self, arg0: IntVect) -> Box: ... + @typing.overload + def enclosed_cells(self) -> Box: ... + @typing.overload + def enclosed_cells(self, dir: int) -> Box: ... + @typing.overload + def enclosed_cells(self, d: Direction) -> Box: ... + def end(self, arg0: Box) -> Dim3: ... + @typing.overload + def grow(self, n_cell: int) -> Box: ... + @typing.overload + def grow(self, n_cells: IntVect) -> Box: ... + @typing.overload + def grow(self, idir: int, n_cell: int) -> Box: ... + @typing.overload + def grow(self, d: Direction, n_cell: int) -> Box: ... + def intersects(self, arg0: Box) -> bool: ... + def lbound(self, arg0: Box) -> Dim3: ... + @typing.overload + def length(self) -> IntVect: + """ + Return IntVect of lengths of the Box + """ + @typing.overload + def length(self, arg0: int) -> int: + """ + Return the length of the Box in given direction. + """ + def make_slab(self, direction: int, slab_index: int) -> Box: ... + def normalize(self) -> None: ... + def numPts(self) -> int: + """ + Return the number of points in the Box. + """ + def same_size(self, arg0: Box) -> bool: ... + def same_type(self, arg0: Box) -> bool: ... + def shift(self, arg0: IntVect) -> Box: ... + def strictly_contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def surrounding_nodes(self) -> Box: ... + @typing.overload + def surrounding_nodes(self, dir: int) -> Box: ... + @typing.overload + def surrounding_nodes(self, d: Direction) -> Box: ... + def ubound(self, arg0: Box) -> Dim3: ... + @property + def big_end(self) -> IntVect: ... + @property + def cell_centered(self) -> bool: ... + @property + def d_num_pts(self) -> float: ... + @property + def hi_vect(self) -> IntVect: ... + @property + def is_empty(self) -> bool: ... + @property + def is_square(self) -> bool: ... + @property + def ix_type(self) -> IndexType: ... + @property + def lo_vect(self) -> IntVect: ... + @property + def num_pts(self) -> int: ... + @property + def ok(self) -> bool: ... + @property + def size(self) -> IntVect: ... + @property + def small_end(self) -> IntVect: ... + @property + def the_unit_box() -> Box: ... + @property + def type(self) -> IntVect: ... + @type.setter + def type(self, arg1: IndexType) -> Box: ... + @property + def volume(self) -> int: ... + +class BoxArray: + def __getitem__(self, arg0: int) -> Box: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Box) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int) -> None: ... + def __repr__(self) -> str: ... + def cell_equal(self, arg0: BoxArray) -> bool: ... + def clear(self) -> None: ... + @typing.overload + def coarsen(self, arg0: IntVect) -> BoxArray: ... + @typing.overload + def coarsen(self, arg0: int) -> BoxArray: ... + @typing.overload + def coarsenable(self, arg0: int, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: IntVect) -> bool: ... + def define(self, arg0: Box) -> None: ... + def get(self, arg0: int) -> Box: ... + def ix_type(self) -> IndexType: ... + @typing.overload + def max_size(self, arg0: int) -> BoxArray: ... + @typing.overload + def max_size(self, arg0: IntVect) -> BoxArray: ... + def minimal_box(self) -> Box: ... + @typing.overload + def refine(self, arg0: int) -> BoxArray: ... + @typing.overload + def refine(self, arg0: IntVect) -> BoxArray: ... + def resize(self, arg0: int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def d_numPts(self) -> float: ... + @property + def empty(self) -> bool: ... + @property + def numPts(self) -> int: ... + @property + def size(self) -> int: ... + +class Config: + amrex_version: typing.ClassVar[str] = "23.08" + gpu_backend = None + have_gpu: typing.ClassVar[bool] # value = False + have_mpi: typing.ClassVar[bool] # value = True + have_omp: typing.ClassVar[bool] # value = False + spacedim: typing.ClassVar[int] = 1 + verbose: typing.ClassVar[int] = 1 + +class CoordSys: + class CoordType: + """ + Members: + + undef + + cartesian + + RZ + + SPHERICAL + """ + + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[ + CoordSys.CoordType + ] # value = + __members__: typing.ClassVar[ + dict[str, CoordSys.CoordType] + ] # value = {'undef': , 'cartesian': , 'RZ': , 'SPHERICAL': } + cartesian: typing.ClassVar[ + CoordSys.CoordType + ] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[CoordSys.CoordType] # value = + cartesian: typing.ClassVar[CoordSys.CoordType] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def Coord(self) -> CoordSys.CoordType: ... + def CoordInt(self) -> int: ... + def IsCartesian(self) -> bool: ... + def IsRZ(self) -> bool: ... + def IsSPHERICAL(self) -> bool: ... + def SetCoord(self, arg0: CoordSys.CoordType) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: CoordSys) -> None: ... + def __repr__(self) -> str: ... + def ok(self) -> bool: ... + +class Dim3: + x: int + y: int + z: int + def __init__(self, arg0: int, arg1: int, arg2: int) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + +class Direction: + pass + +class DistributionMapping: + def ProcessorMap(self) -> Vector_int: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: DistributionMapping) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray, nprocs: int) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def define(self, boxes: BoxArray) -> None: ... + @typing.overload + def define(self, boxes: BoxArray, nprocs: int) -> None: ... + @typing.overload + def define(self, arg0: Vector_int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def empty(self) -> bool: ... + @property + def link_count(self) -> int: ... + @property + def size(self) -> int: ... + +class FArrayBox(BaseFab_Real): + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__( + self, arg0: Box, arg1: int, arg2: bool, arg3: bool, arg4: Arena + ) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + +class FabArrayBase: + def __iter__(self) -> MFIter: ... + def is_nodal(self, arg0: int) -> bool: ... + @property + def is_all_cell_centered(self) -> bool: ... + @property + def is_all_nodal(self) -> bool: ... + @property + def nComp(self) -> int: ... + @property + def nGrowVect(self) -> IntVect: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class FabArray_FArrayBox(FabArrayBase): + @staticmethod + def lin_comb( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: float, + arg5: FabArray_FArrayBox, + arg6: int, + arg7: int, + arg8: int, + arg9: IntVect, + ) -> None: ... + @staticmethod + def saxpy( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + @staticmethod + def xpay( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + def array(self, arg0: MFIter) -> Array4_double: ... + def const_array(self, arg0: MFIter) -> Array4_double_const: ... + @typing.overload + def fill_boundary(self, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary(self, period: Periodicity, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, nghost: IntVect, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary(self, scomp: int, ncomp: int, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, scomp: int, ncomp: int, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary( + self, + scomp: int, + ncomp: int, + nghost: IntVect, + period: Periodicity, + cross: bool = ..., + ) -> None: ... + def override_sync(self, arg0: Periodicity) -> None: ... + def sum(self, arg0: int, arg1: IntVect, arg2: bool) -> float: ... + @typing.overload + def sum_boundary(self, arg0: Periodicity) -> None: ... + @typing.overload + def sum_boundary(self, arg0: int, arg1: int, arg2: Periodicity) -> None: ... + @typing.overload + def sum_boundary( + self, arg0: int, arg1: int, arg2: IntVect, arg3: Periodicity + ) -> None: ... + +class Geometry(CoordSys): + @typing.overload + def Domain(self) -> Box: + """ + Return rectangular domain + """ + @typing.overload + def Domain(self, arg0: Box) -> None: ... + @typing.overload + def ProbDomain(self) -> RealBox: + """ + Return problem domain + """ + @typing.overload + def ProbDomain(self, arg0: RealBox) -> None: ... + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Get the hi end of the problem domain in specified direction + """ + @typing.overload + def ProbHi(self) -> list[float[1]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbLength(self, arg0: int) -> float: + """ + length of problem domain in specified dimension + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Get the lo end of the problem domain in specified direction + """ + @typing.overload + def ProbLo(self) -> list[float[1]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbSize(self) -> float: + """ + the overall size of the domain + """ + def ResetDefaultCoord(self) -> None: + """ + Reset default coord of Geometry class with an Array of `int` + """ + def ResetDefaultPeriodicity(self) -> None: + """ + Reset default periodicity of Geometry class with an Array of `int` + """ + def ResetDefaultProbDomain(self) -> None: + """ + Reset default problem domain of Geometry class with a `RealBox` + """ + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, dom: Box, rb: RealBox, coord: int, is_per: list[int[1]] + ) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def coarsen(self, arg0: IntVect) -> None: ... + def data(self) -> GeometryData: + """ + Returns non-static copy of geometry's stored data + """ + def define(self, arg0: Box, arg1: RealBox, arg2: int, arg3: list[int[1]]) -> None: + """ + Set geometry + """ + @typing.overload + def growNonPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growNonPeriodicDomain(self, arg0: int) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: int) -> Box: ... + def insideRoundOffDomain(self, arg0: float) -> bool: + """ + Returns true if a point is inside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def isAllPeriodic(self) -> bool: + """ + Is domain periodic in all directions? + """ + def isAnyPeriodic(self) -> bool: + """ + Is domain periodic in any direction? + """ + @typing.overload + def isPeriodic(self, arg0: int) -> bool: + """ + Is the domain periodic in the specified direction? + """ + @typing.overload + def isPeriodic(self) -> list[int[1]]: + """ + Return list indicating whether domain is periodic in each direction + """ + def outsideRoundOffDomain(self, arg0: float) -> bool: + """ + Returns true if a point is outside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def period(self, arg0: int) -> int: + """ + Return the period in the specified direction + """ + @typing.overload + def periodicity(self) -> Periodicity: ... + @typing.overload + def periodicity(self, arg0: Box) -> Periodicity: + """ + Return Periodicity object with lengths determined by input Box + """ + def refine(self, arg0: IntVect) -> None: ... + def setPeriodicity(self, arg0: list[int[1]]) -> list[int[1]]: ... + +class GeometryData: + @typing.overload + def CellSize(self) -> list[float[1]]: + """ + Returns the cellsize for each coordinate direction. + """ + @typing.overload + def CellSize(self, arg0: int) -> float: + """ + Returns the cellsize for specified coordinate direction. + """ + def Coord(self) -> int: + """ + return integer coordinate type + """ + def Domain(self) -> Box: + """ + Returns our rectangular domain + """ + @typing.overload + def ProbHi(self) -> list[float[1]]: + """ + Returns the hi end for each coordinate direction. + """ + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Returns the hi end of the problem domain in specified dimension. + """ + @typing.overload + def ProbLo(self) -> list[float[1]]: + """ + Returns the lo end for each coordinate direction. + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Returns the lo end of the problem domain in specified dimension. + """ + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def isPeriodic(self) -> list[int[1]]: + """ + Returns whether the domain is periodic in each direction. + """ + @typing.overload + def isPeriodic(self, arg0: int) -> int: + """ + Returns whether the domain is periodic in the given direction. + """ + @property + def coord(self) -> int: ... + @property + def domain(self) -> Box: ... + @property + def dx(self) -> list[float[1]]: ... + @property + def is_periodic(self) -> list[int[1]]: ... + @property + def prob_domain(self) -> RealBox: ... + +class IndexType: + class CellIndex: + """ + Members: + + CELL + + NODE + """ + + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __members__: typing.ClassVar[ + dict[str, IndexType.CellIndex] + ] # value = {'CELL': , 'NODE': } + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_type() -> IndexType: ... + @staticmethod + def node_type() -> IndexType: ... + def __eq__(self, arg0: IndexType) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IndexType) -> None: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IndexType) -> bool: ... + def __ne__(self, arg0: IndexType) -> bool: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + def any(self) -> bool: ... + @typing.overload + def cell_centered(self) -> bool: ... + @typing.overload + def cell_centered(self, arg0: int) -> bool: ... + def clear(self) -> None: ... + def flip(self, arg0: int) -> None: ... + @typing.overload + def ix_type(self) -> IntVect: ... + @typing.overload + def ix_type(self, arg0: int) -> IndexType.CellIndex: ... + @typing.overload + def node_centered(self) -> bool: ... + @typing.overload + def node_centered(self, arg0: int) -> bool: ... + def ok(self) -> bool: ... + def set(self, arg0: int) -> None: ... + def set_type(self, arg0: int, arg1: IndexType.CellIndex) -> None: ... + def setall(self) -> None: ... + def test(self, arg0: int) -> bool: ... + def to_IntVect(self) -> IntVect: ... + def unset(self, arg0: int) -> None: ... + +class IntVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_vector() -> IntVect: ... + @staticmethod + def max_vector() -> IntVect: ... + @staticmethod + def min_vector() -> IntVect: ... + @staticmethod + def node_vector() -> IntVect: ... + @staticmethod + def unit_vector() -> IntVect: ... + @staticmethod + def zero_vector() -> IntVect: ... + @typing.overload + def __add__(self, arg0: int) -> IntVect: ... + @typing.overload + def __add__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __eq__(self, arg0: int) -> bool: ... + @typing.overload + def __eq__(self, arg0: IntVect) -> bool: ... + def __ge__(self, arg0: IntVect) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + def __gt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: int) -> IntVect: ... + @typing.overload + def __iadd__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: int) -> None: ... + @typing.overload + def __init__(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def __isub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __isub__(self, arg0: IntVect) -> IntVect: ... + def __iter__(self) -> typing.Iterator: ... + @typing.overload + def __itruediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __itruediv__(self, arg0: IntVect) -> IntVect: ... + def __le__(self, arg0: IntVect) -> bool: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __mul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __ne__(self, arg0: int) -> bool: ... + @typing.overload + def __ne__(self, arg0: IntVect) -> bool: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> int: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __sub__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: IntVect) -> IntVect: ... + def dim3(self) -> Dim3: ... + def numpy(self) -> numpy.ndarray: ... + @property + def max(self) -> int: ... + @property + def min(self) -> int: ... + @property + def sum(self) -> int: ... + +class MFInfo: + alloc: bool + arena: Arena + tags: Vector_string + def __init__(self) -> None: ... + def set_alloc(self, arg0: bool) -> MFInfo: ... + def set_arena(self, arg0: Arena) -> MFInfo: ... + def set_tag(self, arg0: str) -> None: ... + +class MFIter: + @typing.overload + def __init__(self, arg0: FabArrayBase) -> None: ... + @typing.overload + def __init__(self, arg0: MultiFab) -> None: ... + def __next__(self) -> MFIter: ... + def __repr__(self) -> str: ... + def fabbox(self) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int = ..., ng: int = ...) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int, ng: IntVect) -> Box: ... + def growntilebox(self, ng: IntVect = ...) -> Box: ... + def nodaltilebox(self, dir: int = ...) -> Box: ... + @typing.overload + def tilebox(self) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect, arg1: IntVect) -> Box: ... + def validbox(self) -> Box: ... + @property + def index(self) -> int: ... + @property + def is_valid(self) -> bool: ... + @property + def length(self) -> int: ... + +class MultiFab(FabArray_FArrayBox): + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: int, + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: int, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def dot( + arg0: MultiFab, + arg1: int, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: bool, + ) -> float: ... + @staticmethod + @typing.overload + def dot(arg0: MultiFab, arg1: int, arg2: int, arg3: int, arg4: bool) -> float: ... + @staticmethod + def finalize() -> None: ... + @staticmethod + def initialize() -> None: ... + @staticmethod + def lin_comb( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: float, + arg5: MultiFab, + arg6: int, + arg7: int, + arg8: int, + arg9: int, + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def saxpy( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def xpay( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: int + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: int, + arg4: MFInfo, + ) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: IntVect + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: IntVect, + arg4: MFInfo, + ) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def abs(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def abs(self, arg0: int, arg1: int, arg2: int) -> None: ... + def average_sync(self, arg0: Periodicity) -> None: ... + def box_array(self) -> BoxArray: ... + @typing.overload + def contains_inf(self, arg0: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + def divi(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + def dm(self) -> DistributionMapping: ... + @typing.overload + def invert(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def invert( + self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int + ) -> None: ... + @typing.overload + def max(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab. + """ + @typing.overload + def max( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab over the region. + """ + def maxIndex(self, arg0: int, arg1: int) -> IntVect: ... + @typing.overload + def min(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab. + """ + @typing.overload + def min( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab over the region. + """ + def minIndex(self, arg0: int, arg1: int) -> IntVect: ... + def minus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + def n_comp(self) -> int: ... + def n_grow_vect(self) -> IntVect: ... + @typing.overload + def negate(self, arg0: int) -> None: ... + @typing.overload + def negate(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int, arg2: int, arg3: int) -> None: ... + def norm0(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: Periodicity, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: int, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: Vector_int, arg1: int, arg2: bool) -> Vector_Real: ... + @typing.overload + def norm2(self, arg0: int) -> float: ... + @typing.overload + def norm2(self, arg0: int, arg1: Periodicity) -> float: ... + @typing.overload + def norm2(self, arg0: Vector_int) -> Vector_Real: ... + def norminf(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def plus(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + @typing.overload + def plus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: IntVect) -> None: ... + def sum(self, comp: int = ..., local: bool = ...) -> float: + """ + Returns the sum of component 'comp' over the MultiFab -- no ghost cells are included. + """ + def sum_unique( + self, comp: int = ..., local: bool = ..., period: Periodicity = ... + ) -> float: + """ + Same as sum with local=false, but for non-cell-centered data, thisskips non-unique points that are owned by multiple boxes. + """ + def weighted_sync(self, arg0: MultiFab, arg1: Periodicity) -> None: ... + +class PIdx: + class IntValues: + """ + Members: + """ + + __members__: typing.ClassVar[dict] = {} + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + + class RealValues: + """ + Members: + + w + + vx + + vy + + vz + + Ex + + Ey + + Ez + """ + + Ex: typing.ClassVar[PIdx.RealValues] # value = + Ey: typing.ClassVar[PIdx.RealValues] # value = + Ez: typing.ClassVar[PIdx.RealValues] # value = + __members__: typing.ClassVar[ + dict[str, PIdx.RealValues] + ] # value = {'w': , 'vx': , 'vy': , 'vz': , 'Ex': , 'Ey': , 'Ez': } + vx: typing.ClassVar[PIdx.RealValues] # value = + vy: typing.ClassVar[PIdx.RealValues] # value = + vz: typing.ClassVar[PIdx.RealValues] # value = + w: typing.ClassVar[PIdx.RealValues] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class PODVector_int_arena: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_pinned: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_std: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_arena: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_pinned: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_std: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ParConstIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_default: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_default: ... + def __next__(self) -> ParIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_default: ... + def __next__(self) -> ParIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_default: ... + def __next__(self) -> ParIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParmParse: + @staticmethod + def addfile(arg0: str) -> None: ... + def __init__(self, prefix: str = ...) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def add(self, arg0: str, arg1: bool) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: str) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: IntVect) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: Box) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[str]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[IntVect]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[Box]) -> None: ... + def get_bool(self, name: str, ival: int = ...) -> bool: + """ + parses input values + """ + def get_int(self, name: str, ival: int = ...) -> int: + """ + parses input values + """ + def get_real(self, name: str, ival: int = ...) -> float: + """ + parses input values + """ + def query_int(self, name: str, ival: int = ...) -> tuple[bool, int]: + """ + queries input values + """ + def remove(self, arg0: str) -> int: ... + +class ParticleContainer_0_0_4_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_arena: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_default: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_pinned: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_arena: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_default: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_pinned: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleInitType_0_0_4_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[4]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_0_0_5_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[5]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_1_1_2_1: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[1]] + int_struct_data: list[int[1]] + real_array_data: list[float[2]] + real_struct_data: list[float[1]] + def __init__(self) -> None: ... + +class ParticleTileData_0_0_37_1: + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_37_1: ... + def setSuperParticle(self, arg0: Particle_37_1, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_4_0: + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_4_0: ... + def setSuperParticle(self, arg0: Particle_4_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_5_0: + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_5_0: ... + def setSuperParticle(self, arg0: Particle_5_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_8_2: + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_8_2: ... + def setSuperParticle(self, arg0: Particle_8_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_1_1_2_1: + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_3_2: ... + def setSuperParticle(self, arg0: Particle_3_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTile_0_0_37_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_arena) -> None: ... + +class ParticleTile_0_0_37_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_default) -> None: ... + +class ParticleTile_0_0_37_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_pinned) -> None: ... + +class ParticleTile_0_0_4_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_arena) -> None: ... + +class ParticleTile_0_0_4_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_default) -> None: ... + +class ParticleTile_0_0_4_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_pinned) -> None: ... + +class ParticleTile_0_0_5_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_arena) -> None: ... + +class ParticleTile_0_0_5_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_default) -> None: ... + +class ParticleTile_0_0_5_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_pinned) -> None: ... + +class ParticleTile_0_0_8_2_arena: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_arena) -> None: ... + +class ParticleTile_0_0_8_2_default: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_default) -> None: ... + +class ParticleTile_0_0_8_2_pinned: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_pinned) -> None: ... + +class ParticleTile_1_1_2_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_arena) -> None: ... + +class ParticleTile_1_1_2_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_default: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_default) -> None: ... + +class ParticleTile_1_1_2_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_pinned) -> None: ... + +class Particle_0_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 0 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> None: ... + @typing.overload + def get_rdata(self) -> None: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[0]]) -> None: ... + +class Particle_1_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 1 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[1]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[1]]) -> None: ... + +class Particle_2_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 2 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[2]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[2]]) -> None: ... + +class Particle_37_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 37 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[37]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[37]]) -> None: ... + +class Particle_3_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 3 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[3]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[3]]) -> None: ... + +class Particle_4_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 4 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[4]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[4]]) -> None: ... + +class Particle_5_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 5 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[5]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[5]]) -> None: ... + +class Particle_7_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 7 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[7]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[7]]) -> None: ... + +class Particle_8_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 8 + x: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[8]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[1]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[8]]) -> None: ... + +class Periodicity: + __hash__: typing.ClassVar[None] = None + @staticmethod + def non_periodic() -> Periodicity: + """ + Return the Periodicity object that is not periodic in any direction + """ + def __eq__(self, arg0: Periodicity) -> bool: ... + def __getitem__(self, dir: int) -> bool: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + def __repr__(self) -> str: ... + def is_periodic(self, dir: int) -> bool: ... + @property + def domain(self) -> Box: + """ + Cell-centered domain Box "infinitely" long in non-periodic directions. + """ + @property + def is_all_periodic(self) -> bool: ... + @property + def is_any_periodic(self) -> bool: ... + @property + def shift_IntVect(self) -> list[IntVect]: ... + +class RealBox: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, x_lo: float, x_hi: float) -> None: ... + @typing.overload + def __init__(self, a_lo: list[float[1]], a_hi: list[float[1]]) -> None: ... + @typing.overload + def __init__(self, bx: Box, dx: list[float[1]], base: list[float[1]]) -> None: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + @typing.overload + def contains(self, rb: XDim3, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealVect, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealBox, eps: float = ...) -> bool: + """ + Determine if RealBox contains another RealBox, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: list[float], eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def hi(self, arg0: int) -> float: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def hi(self) -> list[float[1]]: + """ + Get all components of ``xhi`` + """ + def intersects(self, arg0: RealBox) -> bool: + """ + determine if box intersects with a box + """ + def length(self, arg0: int) -> float: ... + @typing.overload + def lo(self, arg0: int) -> float: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def lo(self) -> list[float[1]]: + """ + Get all components of ``xlo`` + """ + def ok(self) -> bool: + """ + Determine if RealBox satisfies ``xlo[i] None: + """ + Get all components of ``xlo`` + """ + @typing.overload + def setHi(self, arg0: int, arg1: float) -> None: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def setLo(self, arg0: list[float]) -> None: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def setLo(self, arg0: int, arg1: float) -> None: + """ + Get all components of ``xlo`` + """ + def volume(self) -> float: ... + @property + def xhi(self) -> list[float[1]]: ... + @property + def xlo(self) -> list[float[1]]: ... + +class RealVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def unit_vector() -> RealVect: ... + @staticmethod + def zero_vector() -> RealVect: ... + def BASISREALV(self) -> RealVect: + """ + return basis vector in given coordinate direction + """ + @typing.overload + def __add__(self, arg0: float) -> RealVect: ... + @typing.overload + def __add__(self, arg0: RealVect) -> RealVect: ... + def __eq__(self, arg0: RealVect) -> bool: ... + def __ge__(self, arg0: RealVect) -> bool: ... + def __getitem__(self, arg0: int) -> float: ... + def __gt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: float) -> RealVect: ... + @typing.overload + def __iadd__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: float) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + @typing.overload + def __init__(self, arg0: list[float]) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __isub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __isub__(self, arg0: RealVect) -> RealVect: ... + def __itruediv__(self, arg0: float) -> RealVect: ... + def __le__(self, arg0: RealVect) -> bool: ... + def __lt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __mul__(self, arg0: float) -> RealVect: ... + def __ne__(self, arg0: RealVect) -> bool: ... + def __neg__(self) -> RealVect: ... + def __pos__(self) -> RealVect: ... + def __radd__(self, arg0: float) -> RealVect: ... + def __repr__(self) -> str: ... + def __rmul__(self, arg0: float) -> RealVect: ... + def __rsub__(self, arg0: float) -> RealVect: ... + def __rtruediv__(self, arg0: float) -> RealVect: ... + def __setitem__(self, arg0: int, arg1: float) -> float: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __sub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: RealVect) -> RealVect: ... + def ceil(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::ceil of the vector components + """ + def dotProduct(self, arg0: RealVect) -> float: + """ + Return dot product of this vector with another + """ + def floor(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::floor of the vector components + """ + def max(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise maxima of this vector and another + """ + def maxDir(self, arg0: bool) -> int: + """ + direction or index of maximum value of this vector + """ + def min(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise minima of this vector and another + """ + def minDir(self, arg0: bool) -> int: + """ + direction or index of minimum value of this vector + """ + def round(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::round of the vector components + """ + def scale(self, arg0: float) -> RealVect: + """ + Multiplify each component of this vector by a scalar + """ + @property + def product(self) -> float: + """ + Product of entries of this vector + """ + @property + def radSquared(self) -> float: + """ + Length squared of this vector + """ + @property + def sum(self) -> float: + """ + Sum of the components of this vector + """ + @property + def vectorLength(self) -> float: + """ + Length or 2-Norm of this vector + """ + +class StructOfArrays_2_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class Vector_BoxArray: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: BoxArray) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_BoxArray: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_BoxArray) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + def append(self, x: BoxArray) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: BoxArray) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_BoxArray) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: BoxArray) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> BoxArray: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> BoxArray: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: BoxArray) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_DistributionMapping: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: DistributionMapping) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_DistributionMapping: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_DistributionMapping) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + def append(self, x: DistributionMapping) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: DistributionMapping) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_DistributionMapping) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: DistributionMapping) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> DistributionMapping: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> DistributionMapping: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: DistributionMapping) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Geometry: + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + @typing.overload + def __getitem__(self, s: slice) -> Vector_Geometry: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Geometry) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + def append(self, x: Geometry) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + @typing.overload + def extend(self, L: Vector_Geometry) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: Geometry) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> Geometry: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> Geometry: + """ + Remove and return the item at index ``i`` + """ + def size(self) -> int: ... + +class Vector_IntVect: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: IntVect) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_IntVect: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_IntVect) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + def append(self, x: IntVect) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: IntVect) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_IntVect) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: IntVect) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> IntVect: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> IntVect: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: IntVect) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Long: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Long: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Long) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Long) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_Real: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: float) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Real: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Real) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def append(self, x: float) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: float) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Real) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: float) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> float: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> float: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: float) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_int: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_int: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_int) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_int) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_string: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: str) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_string: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_string) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + def append(self, x: str) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: str) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_string) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: str) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> str: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> str: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: str) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class XDim3: + x: float + y: float + z: float + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + +def AlmostEqual(rb1: RealBox, rb2: RealBox, eps: float = ...) -> bool: + """ + Determine if two boxes are equal to within a tolerance + """ + +def The_Arena() -> Arena: ... +def The_Async_Arena() -> Arena: ... +def The_Cpu_Arena() -> Arena: ... +def The_Device_Arena() -> Arena: ... +def The_Managed_Arena() -> Arena: ... +def The_Pinned_Arena() -> Arena: ... +def begin(arg0: Box) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: IntVect) -> IntVect: ... +@typing.overload +def coarsen(arg0: Dim3, arg1: IntVect) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: int) -> IntVect: ... +def concatenate(root: str, num: int, mindigits: int = ...) -> str: + """ + Builds plotfile name + """ + +@typing.overload +def dtoh_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def dtoh_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def end(arg0: Box) -> Dim3: ... +@typing.overload +def finalize() -> None: ... +@typing.overload +def finalize(arg0: AMReX) -> None: ... +@typing.overload +def htod_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def htod_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def initialize(arg0: list) -> AMReX: + """ + Initialize AMReX library + """ + +def initialized() -> bool: + """ + Returns true if there are any currently-active and initialized AMReX instances (i.e. one for which amrex::Initialize has been called, and amrex::Finalize has not). Otherwise false. + """ + +@typing.overload +def lbound(arg0: Box) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong_const) -> Dim3: ... +@typing.overload +def length(arg0: Box) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong_const) -> Dim3: ... +def max(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def min(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def refine(arg0: Dim3, arg1: IntVect) -> Dim3: ... +def size() -> int: + """ + The amr stack size, the number of amr instances pushed. + """ + +@typing.overload +def ubound(arg0: Box) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong_const) -> Dim3: ... +def unpack_cpus(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def unpack_ids(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def write_single_level_plotfile( + plotfilename: str, + mf: MultiFab, + varnames: Vector_string, + geom: Geometry, + time: float, + level_step: int, + versionName: str = ..., + levelPrefix: str = ..., + mfPrefix: str = ..., + extra_dirs: Vector_string = ..., +) -> None: + """ + Writes single level plotfile + """ + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" diff --git a/src/amrex/space2d/__init__.pyi b/src/amrex/space2d/__init__.pyi new file mode 100644 index 00000000..7c33b372 --- /dev/null +++ b/src/amrex/space2d/__init__.pyi @@ -0,0 +1,474 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import os as os + +from amrex.space2d.amrex_2d_pybind import ( + AlmostEqual, + AMReX, + AmrInfo, + AmrMesh, + Arena, + Array4_double, + Array4_double_const, + Array4_float, + Array4_float_const, + Array4_int, + Array4_int_const, + Array4_long, + Array4_long_const, + Array4_longdouble, + Array4_longdouble_const, + Array4_longlong, + Array4_longlong_const, + Array4_short, + Array4_short_const, + Array4_uint, + Array4_uint_const, + Array4_ulong, + Array4_ulong_const, + Array4_ulonglong, + Array4_ulonglong_const, + Array4_ushort, + Array4_ushort_const, + ArrayOfStructs_0_0_arena, + ArrayOfStructs_0_0_default, + ArrayOfStructs_0_0_pinned, + ArrayOfStructs_1_1_arena, + ArrayOfStructs_1_1_default, + ArrayOfStructs_1_1_pinned, + ArrayOfStructs_2_1_arena, + ArrayOfStructs_2_1_default, + ArrayOfStructs_2_1_pinned, + BaseFab_Real, + Box, + BoxArray, + Config, + CoordSys, + Dim3, + Direction, + DistributionMapping, + FabArray_FArrayBox, + FabArrayBase, + FArrayBox, + Geometry, + GeometryData, + IndexType, + IntVect, + MFInfo, + MFIter, + MultiFab, + ParallelDescriptor, + ParConstIter_0_0_4_0_arena, + ParConstIter_0_0_4_0_default, + ParConstIter_0_0_4_0_pinned, + ParConstIter_0_0_5_0_arena, + ParConstIter_0_0_5_0_default, + ParConstIter_0_0_5_0_pinned, + ParConstIter_1_1_2_1_arena, + ParConstIter_1_1_2_1_default, + ParConstIter_1_1_2_1_pinned, + ParConstIter_pureSoA_8_2_arena, + ParConstIter_pureSoA_8_2_default, + ParConstIter_pureSoA_8_2_pinned, + ParConstIterBase_0_0_4_0_arena, + ParConstIterBase_0_0_4_0_default, + ParConstIterBase_0_0_4_0_pinned, + ParConstIterBase_0_0_5_0_arena, + ParConstIterBase_0_0_5_0_default, + ParConstIterBase_0_0_5_0_pinned, + ParConstIterBase_1_1_2_1_arena, + ParConstIterBase_1_1_2_1_default, + ParConstIterBase_1_1_2_1_pinned, + ParConstIterBase_pureSoA_8_2_arena, + ParConstIterBase_pureSoA_8_2_default, + ParConstIterBase_pureSoA_8_2_pinned, + ParIter_0_0_4_0_arena, + ParIter_0_0_4_0_default, + ParIter_0_0_4_0_pinned, + ParIter_0_0_5_0_arena, + ParIter_0_0_5_0_default, + ParIter_0_0_5_0_pinned, + ParIter_1_1_2_1_arena, + ParIter_1_1_2_1_default, + ParIter_1_1_2_1_pinned, + ParIter_pureSoA_8_2_arena, + ParIter_pureSoA_8_2_default, + ParIter_pureSoA_8_2_pinned, + ParIterBase_0_0_4_0_arena, + ParIterBase_0_0_4_0_default, + ParIterBase_0_0_4_0_pinned, + ParIterBase_0_0_5_0_arena, + ParIterBase_0_0_5_0_default, + ParIterBase_0_0_5_0_pinned, + ParIterBase_1_1_2_1_arena, + ParIterBase_1_1_2_1_default, + ParIterBase_1_1_2_1_pinned, + ParIterBase_pureSoA_8_2_arena, + ParIterBase_pureSoA_8_2_default, + ParIterBase_pureSoA_8_2_pinned, + ParmParse, + Particle_0_0, + Particle_1_1, + Particle_2_1, + Particle_3_2, + Particle_4_0, + Particle_5_0, + Particle_7_0, + Particle_8_2, + Particle_37_1, + ParticleContainer_0_0_4_0_arena, + ParticleContainer_0_0_4_0_default, + ParticleContainer_0_0_4_0_pinned, + ParticleContainer_0_0_5_0_arena, + ParticleContainer_0_0_5_0_default, + ParticleContainer_0_0_5_0_pinned, + ParticleContainer_1_1_2_1_arena, + ParticleContainer_1_1_2_1_default, + ParticleContainer_1_1_2_1_pinned, + ParticleContainer_pureSoA_8_2_arena, + ParticleContainer_pureSoA_8_2_default, + ParticleContainer_pureSoA_8_2_pinned, + ParticleInitType_0_0_4_0, + ParticleInitType_0_0_5_0, + ParticleInitType_1_1_2_1, + ParticleTile_0_0_4_0_arena, + ParticleTile_0_0_4_0_default, + ParticleTile_0_0_4_0_pinned, + ParticleTile_0_0_5_0_arena, + ParticleTile_0_0_5_0_default, + ParticleTile_0_0_5_0_pinned, + ParticleTile_0_0_8_2_arena, + ParticleTile_0_0_8_2_default, + ParticleTile_0_0_8_2_pinned, + ParticleTile_0_0_37_1_arena, + ParticleTile_0_0_37_1_default, + ParticleTile_0_0_37_1_pinned, + ParticleTile_1_1_2_1_arena, + ParticleTile_1_1_2_1_default, + ParticleTile_1_1_2_1_pinned, + ParticleTileData_0_0_4_0, + ParticleTileData_0_0_5_0, + ParticleTileData_0_0_8_2, + ParticleTileData_0_0_37_1, + ParticleTileData_1_1_2_1, + Periodicity, + PIdx, + PODVector_int_arena, + PODVector_int_pinned, + PODVector_int_std, + PODVector_real_arena, + PODVector_real_pinned, + PODVector_real_std, + RealBox, + RealVect, + StructOfArrays_2_1_arena, + StructOfArrays_2_1_default, + StructOfArrays_2_1_pinned, + StructOfArrays_4_0_arena, + StructOfArrays_4_0_default, + StructOfArrays_4_0_pinned, + StructOfArrays_5_0_arena, + StructOfArrays_5_0_default, + StructOfArrays_5_0_pinned, + StructOfArrays_8_2_arena, + StructOfArrays_8_2_default, + StructOfArrays_8_2_pinned, + StructOfArrays_37_1_arena, + StructOfArrays_37_1_default, + StructOfArrays_37_1_pinned, + The_Arena, + The_Async_Arena, + The_Cpu_Arena, + The_Device_Arena, + The_Managed_Arena, + The_Pinned_Arena, + Vector_BoxArray, + Vector_DistributionMapping, + Vector_Geometry, + Vector_int, + Vector_IntVect, + Vector_Long, + Vector_Real, + Vector_string, + XDim3, + begin, + coarsen, + concatenate, + dtoh_memcpy, + end, + finalize, + htod_memcpy, + initialize, + initialized, + lbound, + length, + max, + min, + refine, + size, + ubound, + unpack_cpus, + unpack_ids, + write_single_level_plotfile, +) + +from . import amrex_2d_pybind + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "Print", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "amrex_2d_pybind", + "begin", + "coarsen", + "concatenate", + "d_decl", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "os", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +def Print(*args, **kwargs): + """ + Wrap amrex::Print() - only the IO processor writes + """ + +def d_decl(x, y, z): ... + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" diff --git a/src/amrex/space2d/amrex_2d_pybind/ParallelDescriptor.pyi b/src/amrex/space2d/amrex_2d_pybind/ParallelDescriptor.pyi new file mode 100644 index 00000000..70fb4af4 --- /dev/null +++ b/src/amrex/space2d/amrex_2d_pybind/ParallelDescriptor.pyi @@ -0,0 +1,8 @@ +from __future__ import annotations + +__all__ = ["IOProcessor", "IOProcessorNumber", "MyProc", "NProcs"] + +def IOProcessor() -> bool: ... +def IOProcessorNumber() -> int: ... +def MyProc() -> int: ... +def NProcs() -> int: ... diff --git a/src/amrex/space2d/amrex_2d_pybind/__init__.pyi b/src/amrex/space2d/amrex_2d_pybind/__init__.pyi new file mode 100644 index 00000000..ce738715 --- /dev/null +++ b/src/amrex/space2d/amrex_2d_pybind/__init__.pyi @@ -0,0 +1,7784 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import typing + +import numpy + +from . import ParallelDescriptor + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "begin", + "coarsen", + "concatenate", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +class AMReX: + @staticmethod + def empty() -> bool: ... + @staticmethod + def erase(arg0: AMReX) -> None: ... + @staticmethod + def size() -> int: ... + @staticmethod + def top() -> AMReX: ... + +class AmrInfo: + check_input: bool + grid_eff: float + iterate_on_new_grids: bool + max_level: int + n_proper: int + refine_grid_layout: bool + refine_grid_layout_dims: IntVect + use_fixed_coarse_grids: bool + use_fixed_upto_level: int + use_new_chop: bool + verbose: int + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + def blocking_factor(self, arg0: int) -> IntVect: ... + def max_grid_size(self, arg0: int) -> IntVect: ... + def n_error_buf(self, arg0: int) -> IntVect: ... + def ref_ratio(self, arg0: int) -> IntVect: ... + +class AmrMesh: + def Verbose(self) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, + rb: RealBox, + max_level_in: int, + n_cell_in: Vector_int, + coord: int, + ref_ratios: Vector_IntVect, + is_per: list[int[2]], + ) -> None: ... + def __repr__(self) -> str: ... + def finest_level(self) -> int: ... + def max_level(self) -> int: ... + @typing.overload + def ref_ratio(self) -> Vector_IntVect: ... + @typing.overload + def ref_ratio(self, arg0: int) -> IntVect: ... + +class Arena: + pass + +class Array4_double: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_double_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class ArrayOfStructs_0_0_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class BaseFab_Real: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + def big_end(self) -> IntVect: ... + def box(self) -> Box: ... + def clear(self) -> None: ... + def hi_vect(self) -> int: ... + def is_allocated(self) -> bool: ... + def length(self) -> IntVect: ... + def lo_vect(self) -> int: ... + @typing.overload + def n_bytes(self) -> int: ... + @typing.overload + def n_bytes(self, arg0: Box, arg1: int) -> int: ... + def n_bytes_owned(self) -> int: ... + def n_comp(self) -> int: ... + def num_pts(self) -> int: ... + def resize(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + def size(self) -> int: ... + def small_end(self) -> IntVect: ... + +class Box: + def __add__(self, arg0: IntVect) -> Box: ... + def __iadd__(self, arg0: IntVect) -> Box: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, typ: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, t: IndexType) -> None: ... + @typing.overload + def __init__(self, small: list[int[2]], big: list[int[2]]) -> None: ... + @typing.overload + def __init__( + self, small: list[int[2]], big: list[int[2]], t: IndexType + ) -> None: ... + def __isub__(self, arg0: IntVect) -> Box: ... + def __iter__(self) -> typing.Iterator: ... + def __repr__(self) -> str: ... + def __sub__(self, arg0: IntVect) -> Box: ... + def begin(self, arg0: Box) -> Dim3: ... + def contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def convert(self, arg0: IndexType) -> Box: ... + @typing.overload + def convert(self, arg0: IntVect) -> Box: ... + @typing.overload + def enclosed_cells(self) -> Box: ... + @typing.overload + def enclosed_cells(self, dir: int) -> Box: ... + @typing.overload + def enclosed_cells(self, d: Direction) -> Box: ... + def end(self, arg0: Box) -> Dim3: ... + @typing.overload + def grow(self, n_cell: int) -> Box: ... + @typing.overload + def grow(self, n_cells: IntVect) -> Box: ... + @typing.overload + def grow(self, idir: int, n_cell: int) -> Box: ... + @typing.overload + def grow(self, d: Direction, n_cell: int) -> Box: ... + def intersects(self, arg0: Box) -> bool: ... + def lbound(self, arg0: Box) -> Dim3: ... + @typing.overload + def length(self) -> IntVect: + """ + Return IntVect of lengths of the Box + """ + @typing.overload + def length(self, arg0: int) -> int: + """ + Return the length of the Box in given direction. + """ + def make_slab(self, direction: int, slab_index: int) -> Box: ... + def normalize(self) -> None: ... + def numPts(self) -> int: + """ + Return the number of points in the Box. + """ + def same_size(self, arg0: Box) -> bool: ... + def same_type(self, arg0: Box) -> bool: ... + def shift(self, arg0: IntVect) -> Box: ... + def strictly_contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def surrounding_nodes(self) -> Box: ... + @typing.overload + def surrounding_nodes(self, dir: int) -> Box: ... + @typing.overload + def surrounding_nodes(self, d: Direction) -> Box: ... + def ubound(self, arg0: Box) -> Dim3: ... + @property + def big_end(self) -> IntVect: ... + @property + def cell_centered(self) -> bool: ... + @property + def d_num_pts(self) -> float: ... + @property + def hi_vect(self) -> IntVect: ... + @property + def is_empty(self) -> bool: ... + @property + def is_square(self) -> bool: ... + @property + def ix_type(self) -> IndexType: ... + @property + def lo_vect(self) -> IntVect: ... + @property + def num_pts(self) -> int: ... + @property + def ok(self) -> bool: ... + @property + def size(self) -> IntVect: ... + @property + def small_end(self) -> IntVect: ... + @property + def the_unit_box() -> Box: ... + @property + def type(self) -> IntVect: ... + @type.setter + def type(self, arg1: IndexType) -> Box: ... + @property + def volume(self) -> int: ... + +class BoxArray: + def __getitem__(self, arg0: int) -> Box: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Box) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int) -> None: ... + def __repr__(self) -> str: ... + def cell_equal(self, arg0: BoxArray) -> bool: ... + def clear(self) -> None: ... + @typing.overload + def coarsen(self, arg0: IntVect) -> BoxArray: ... + @typing.overload + def coarsen(self, arg0: int) -> BoxArray: ... + @typing.overload + def coarsenable(self, arg0: int, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: IntVect) -> bool: ... + def define(self, arg0: Box) -> None: ... + def get(self, arg0: int) -> Box: ... + def ix_type(self) -> IndexType: ... + @typing.overload + def max_size(self, arg0: int) -> BoxArray: ... + @typing.overload + def max_size(self, arg0: IntVect) -> BoxArray: ... + def minimal_box(self) -> Box: ... + @typing.overload + def refine(self, arg0: int) -> BoxArray: ... + @typing.overload + def refine(self, arg0: IntVect) -> BoxArray: ... + def resize(self, arg0: int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def d_numPts(self) -> float: ... + @property + def empty(self) -> bool: ... + @property + def numPts(self) -> int: ... + @property + def size(self) -> int: ... + +class Config: + amrex_version: typing.ClassVar[str] = "23.08" + gpu_backend = None + have_gpu: typing.ClassVar[bool] # value = False + have_mpi: typing.ClassVar[bool] # value = True + have_omp: typing.ClassVar[bool] # value = False + spacedim: typing.ClassVar[int] = 2 + verbose: typing.ClassVar[int] = 1 + +class CoordSys: + class CoordType: + """ + Members: + + undef + + cartesian + + RZ + + SPHERICAL + """ + + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[ + CoordSys.CoordType + ] # value = + __members__: typing.ClassVar[ + dict[str, CoordSys.CoordType] + ] # value = {'undef': , 'cartesian': , 'RZ': , 'SPHERICAL': } + cartesian: typing.ClassVar[ + CoordSys.CoordType + ] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[CoordSys.CoordType] # value = + cartesian: typing.ClassVar[CoordSys.CoordType] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def Coord(self) -> CoordSys.CoordType: ... + def CoordInt(self) -> int: ... + def IsCartesian(self) -> bool: ... + def IsRZ(self) -> bool: ... + def IsSPHERICAL(self) -> bool: ... + def SetCoord(self, arg0: CoordSys.CoordType) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: CoordSys) -> None: ... + def __repr__(self) -> str: ... + def ok(self) -> bool: ... + +class Dim3: + x: int + y: int + z: int + def __init__(self, arg0: int, arg1: int, arg2: int) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + +class Direction: + pass + +class DistributionMapping: + def ProcessorMap(self) -> Vector_int: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: DistributionMapping) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray, nprocs: int) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def define(self, boxes: BoxArray) -> None: ... + @typing.overload + def define(self, boxes: BoxArray, nprocs: int) -> None: ... + @typing.overload + def define(self, arg0: Vector_int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def empty(self) -> bool: ... + @property + def link_count(self) -> int: ... + @property + def size(self) -> int: ... + +class FArrayBox(BaseFab_Real): + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__( + self, arg0: Box, arg1: int, arg2: bool, arg3: bool, arg4: Arena + ) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + +class FabArrayBase: + def __iter__(self) -> MFIter: ... + def is_nodal(self, arg0: int) -> bool: ... + @property + def is_all_cell_centered(self) -> bool: ... + @property + def is_all_nodal(self) -> bool: ... + @property + def nComp(self) -> int: ... + @property + def nGrowVect(self) -> IntVect: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class FabArray_FArrayBox(FabArrayBase): + @staticmethod + def lin_comb( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: float, + arg5: FabArray_FArrayBox, + arg6: int, + arg7: int, + arg8: int, + arg9: IntVect, + ) -> None: ... + @staticmethod + def saxpy( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + @staticmethod + def xpay( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + def array(self, arg0: MFIter) -> Array4_double: ... + def const_array(self, arg0: MFIter) -> Array4_double_const: ... + @typing.overload + def fill_boundary(self, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary(self, period: Periodicity, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, nghost: IntVect, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary(self, scomp: int, ncomp: int, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, scomp: int, ncomp: int, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary( + self, + scomp: int, + ncomp: int, + nghost: IntVect, + period: Periodicity, + cross: bool = ..., + ) -> None: ... + def override_sync(self, arg0: Periodicity) -> None: ... + def sum(self, arg0: int, arg1: IntVect, arg2: bool) -> float: ... + @typing.overload + def sum_boundary(self, arg0: Periodicity) -> None: ... + @typing.overload + def sum_boundary(self, arg0: int, arg1: int, arg2: Periodicity) -> None: ... + @typing.overload + def sum_boundary( + self, arg0: int, arg1: int, arg2: IntVect, arg3: Periodicity + ) -> None: ... + +class Geometry(CoordSys): + @typing.overload + def Domain(self) -> Box: + """ + Return rectangular domain + """ + @typing.overload + def Domain(self, arg0: Box) -> None: ... + @typing.overload + def ProbDomain(self) -> RealBox: + """ + Return problem domain + """ + @typing.overload + def ProbDomain(self, arg0: RealBox) -> None: ... + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Get the hi end of the problem domain in specified direction + """ + @typing.overload + def ProbHi(self) -> list[float[2]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbLength(self, arg0: int) -> float: + """ + length of problem domain in specified dimension + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Get the lo end of the problem domain in specified direction + """ + @typing.overload + def ProbLo(self) -> list[float[2]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbSize(self) -> float: + """ + the overall size of the domain + """ + def ResetDefaultCoord(self) -> None: + """ + Reset default coord of Geometry class with an Array of `int` + """ + def ResetDefaultPeriodicity(self) -> None: + """ + Reset default periodicity of Geometry class with an Array of `int` + """ + def ResetDefaultProbDomain(self) -> None: + """ + Reset default problem domain of Geometry class with a `RealBox` + """ + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, dom: Box, rb: RealBox, coord: int, is_per: list[int[2]] + ) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def coarsen(self, arg0: IntVect) -> None: ... + def data(self) -> GeometryData: + """ + Returns non-static copy of geometry's stored data + """ + def define(self, arg0: Box, arg1: RealBox, arg2: int, arg3: list[int[2]]) -> None: + """ + Set geometry + """ + @typing.overload + def growNonPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growNonPeriodicDomain(self, arg0: int) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: int) -> Box: ... + def insideRoundOffDomain(self, arg0: float, arg1: float) -> bool: + """ + Returns true if a point is inside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def isAllPeriodic(self) -> bool: + """ + Is domain periodic in all directions? + """ + def isAnyPeriodic(self) -> bool: + """ + Is domain periodic in any direction? + """ + @typing.overload + def isPeriodic(self, arg0: int) -> bool: + """ + Is the domain periodic in the specified direction? + """ + @typing.overload + def isPeriodic(self) -> list[int[2]]: + """ + Return list indicating whether domain is periodic in each direction + """ + def outsideRoundOffDomain(self, arg0: float, arg1: float) -> bool: + """ + Returns true if a point is outside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def period(self, arg0: int) -> int: + """ + Return the period in the specified direction + """ + @typing.overload + def periodicity(self) -> Periodicity: ... + @typing.overload + def periodicity(self, arg0: Box) -> Periodicity: + """ + Return Periodicity object with lengths determined by input Box + """ + def refine(self, arg0: IntVect) -> None: ... + def setPeriodicity(self, arg0: list[int[2]]) -> list[int[2]]: ... + +class GeometryData: + @typing.overload + def CellSize(self) -> list[float[2]]: + """ + Returns the cellsize for each coordinate direction. + """ + @typing.overload + def CellSize(self, arg0: int) -> float: + """ + Returns the cellsize for specified coordinate direction. + """ + def Coord(self) -> int: + """ + return integer coordinate type + """ + def Domain(self) -> Box: + """ + Returns our rectangular domain + """ + @typing.overload + def ProbHi(self) -> list[float[2]]: + """ + Returns the hi end for each coordinate direction. + """ + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Returns the hi end of the problem domain in specified dimension. + """ + @typing.overload + def ProbLo(self) -> list[float[2]]: + """ + Returns the lo end for each coordinate direction. + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Returns the lo end of the problem domain in specified dimension. + """ + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def isPeriodic(self) -> list[int[2]]: + """ + Returns whether the domain is periodic in each direction. + """ + @typing.overload + def isPeriodic(self, arg0: int) -> int: + """ + Returns whether the domain is periodic in the given direction. + """ + @property + def coord(self) -> int: ... + @property + def domain(self) -> Box: ... + @property + def dx(self) -> list[float[2]]: ... + @property + def is_periodic(self) -> list[int[2]]: ... + @property + def prob_domain(self) -> RealBox: ... + +class IndexType: + class CellIndex: + """ + Members: + + CELL + + NODE + """ + + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __members__: typing.ClassVar[ + dict[str, IndexType.CellIndex] + ] # value = {'CELL': , 'NODE': } + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_type() -> IndexType: ... + @staticmethod + def node_type() -> IndexType: ... + def __eq__(self, arg0: IndexType) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IndexType) -> None: ... + @typing.overload + def __init__( + self, arg0: IndexType.CellIndex, arg1: IndexType.CellIndex + ) -> None: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IndexType) -> bool: ... + def __ne__(self, arg0: IndexType) -> bool: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + def any(self) -> bool: ... + @typing.overload + def cell_centered(self) -> bool: ... + @typing.overload + def cell_centered(self, arg0: int) -> bool: ... + def clear(self) -> None: ... + def flip(self, arg0: int) -> None: ... + @typing.overload + def ix_type(self) -> IntVect: ... + @typing.overload + def ix_type(self, arg0: int) -> IndexType.CellIndex: ... + @typing.overload + def node_centered(self) -> bool: ... + @typing.overload + def node_centered(self, arg0: int) -> bool: ... + def ok(self) -> bool: ... + def set(self, arg0: int) -> None: ... + def set_type(self, arg0: int, arg1: IndexType.CellIndex) -> None: ... + def setall(self) -> None: ... + def test(self, arg0: int) -> bool: ... + def to_IntVect(self) -> IntVect: ... + def unset(self, arg0: int) -> None: ... + +class IntVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_vector() -> IntVect: ... + @staticmethod + def max_vector() -> IntVect: ... + @staticmethod + def min_vector() -> IntVect: ... + @staticmethod + def node_vector() -> IntVect: ... + @staticmethod + def unit_vector() -> IntVect: ... + @staticmethod + def zero_vector() -> IntVect: ... + @typing.overload + def __add__(self, arg0: int) -> IntVect: ... + @typing.overload + def __add__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __eq__(self, arg0: int) -> bool: ... + @typing.overload + def __eq__(self, arg0: IntVect) -> bool: ... + def __ge__(self, arg0: IntVect) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + def __gt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: int) -> IntVect: ... + @typing.overload + def __iadd__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: int) -> None: ... + @typing.overload + def __init__(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def __isub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __isub__(self, arg0: IntVect) -> IntVect: ... + def __iter__(self) -> typing.Iterator: ... + @typing.overload + def __itruediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __itruediv__(self, arg0: IntVect) -> IntVect: ... + def __le__(self, arg0: IntVect) -> bool: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __mul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __ne__(self, arg0: int) -> bool: ... + @typing.overload + def __ne__(self, arg0: IntVect) -> bool: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> int: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __sub__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: IntVect) -> IntVect: ... + def dim3(self) -> Dim3: ... + def numpy(self) -> numpy.ndarray: ... + @property + def max(self) -> int: ... + @property + def min(self) -> int: ... + @property + def sum(self) -> int: ... + +class MFInfo: + alloc: bool + arena: Arena + tags: Vector_string + def __init__(self) -> None: ... + def set_alloc(self, arg0: bool) -> MFInfo: ... + def set_arena(self, arg0: Arena) -> MFInfo: ... + def set_tag(self, arg0: str) -> None: ... + +class MFIter: + @typing.overload + def __init__(self, arg0: FabArrayBase) -> None: ... + @typing.overload + def __init__(self, arg0: MultiFab) -> None: ... + def __next__(self) -> MFIter: ... + def __repr__(self) -> str: ... + def fabbox(self) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int = ..., ng: int = ...) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int, ng: IntVect) -> Box: ... + def growntilebox(self, ng: IntVect = ...) -> Box: ... + def nodaltilebox(self, dir: int = ...) -> Box: ... + @typing.overload + def tilebox(self) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect, arg1: IntVect) -> Box: ... + def validbox(self) -> Box: ... + @property + def index(self) -> int: ... + @property + def is_valid(self) -> bool: ... + @property + def length(self) -> int: ... + +class MultiFab(FabArray_FArrayBox): + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: int, + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: int, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def dot( + arg0: MultiFab, + arg1: int, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: bool, + ) -> float: ... + @staticmethod + @typing.overload + def dot(arg0: MultiFab, arg1: int, arg2: int, arg3: int, arg4: bool) -> float: ... + @staticmethod + def finalize() -> None: ... + @staticmethod + def initialize() -> None: ... + @staticmethod + def lin_comb( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: float, + arg5: MultiFab, + arg6: int, + arg7: int, + arg8: int, + arg9: int, + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def saxpy( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def xpay( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: int + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: int, + arg4: MFInfo, + ) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: IntVect + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: IntVect, + arg4: MFInfo, + ) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def abs(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def abs(self, arg0: int, arg1: int, arg2: int) -> None: ... + def average_sync(self, arg0: Periodicity) -> None: ... + def box_array(self) -> BoxArray: ... + @typing.overload + def contains_inf(self, arg0: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + def divi(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + def dm(self) -> DistributionMapping: ... + @typing.overload + def invert(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def invert( + self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int + ) -> None: ... + @typing.overload + def max(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab. + """ + @typing.overload + def max( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab over the region. + """ + def maxIndex(self, arg0: int, arg1: int) -> IntVect: ... + @typing.overload + def min(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab. + """ + @typing.overload + def min( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab over the region. + """ + def minIndex(self, arg0: int, arg1: int) -> IntVect: ... + def minus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + def n_comp(self) -> int: ... + def n_grow_vect(self) -> IntVect: ... + @typing.overload + def negate(self, arg0: int) -> None: ... + @typing.overload + def negate(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int, arg2: int, arg3: int) -> None: ... + def norm0(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: Periodicity, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: int, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: Vector_int, arg1: int, arg2: bool) -> Vector_Real: ... + @typing.overload + def norm2(self, arg0: int) -> float: ... + @typing.overload + def norm2(self, arg0: int, arg1: Periodicity) -> float: ... + @typing.overload + def norm2(self, arg0: Vector_int) -> Vector_Real: ... + def norminf(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def plus(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + @typing.overload + def plus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: IntVect) -> None: ... + def sum(self, comp: int = ..., local: bool = ...) -> float: + """ + Returns the sum of component 'comp' over the MultiFab -- no ghost cells are included. + """ + def sum_unique( + self, comp: int = ..., local: bool = ..., period: Periodicity = ... + ) -> float: + """ + Same as sum with local=false, but for non-cell-centered data, thisskips non-unique points that are owned by multiple boxes. + """ + def weighted_sync(self, arg0: MultiFab, arg1: Periodicity) -> None: ... + +class PIdx: + class IntValues: + """ + Members: + """ + + __members__: typing.ClassVar[dict] = {} + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + + class RealValues: + """ + Members: + + w + + vx + + vy + + vz + + Ex + + Ey + + Ez + """ + + Ex: typing.ClassVar[PIdx.RealValues] # value = + Ey: typing.ClassVar[PIdx.RealValues] # value = + Ez: typing.ClassVar[PIdx.RealValues] # value = + __members__: typing.ClassVar[ + dict[str, PIdx.RealValues] + ] # value = {'w': , 'vx': , 'vy': , 'vz': , 'Ex': , 'Ey': , 'Ez': } + vx: typing.ClassVar[PIdx.RealValues] # value = + vy: typing.ClassVar[PIdx.RealValues] # value = + vz: typing.ClassVar[PIdx.RealValues] # value = + w: typing.ClassVar[PIdx.RealValues] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class PODVector_int_arena: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_pinned: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_std: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_arena: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_pinned: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_std: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ParConstIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_default: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_default: ... + def __next__(self) -> ParIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_default: ... + def __next__(self) -> ParIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_default: ... + def __next__(self) -> ParIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParmParse: + @staticmethod + def addfile(arg0: str) -> None: ... + def __init__(self, prefix: str = ...) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def add(self, arg0: str, arg1: bool) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: str) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: IntVect) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: Box) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[str]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[IntVect]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[Box]) -> None: ... + def get_bool(self, name: str, ival: int = ...) -> bool: + """ + parses input values + """ + def get_int(self, name: str, ival: int = ...) -> int: + """ + parses input values + """ + def get_real(self, name: str, ival: int = ...) -> float: + """ + parses input values + """ + def query_int(self, name: str, ival: int = ...) -> tuple[bool, int]: + """ + queries input values + """ + def remove(self, arg0: str) -> int: ... + +class ParticleContainer_0_0_4_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_arena: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_default: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_pinned: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_arena: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_default: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_pinned: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleInitType_0_0_4_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[4]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_0_0_5_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[5]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_1_1_2_1: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[1]] + int_struct_data: list[int[1]] + real_array_data: list[float[2]] + real_struct_data: list[float[1]] + def __init__(self) -> None: ... + +class ParticleTileData_0_0_37_1: + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_37_1: ... + def setSuperParticle(self, arg0: Particle_37_1, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_4_0: + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_4_0: ... + def setSuperParticle(self, arg0: Particle_4_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_5_0: + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_5_0: ... + def setSuperParticle(self, arg0: Particle_5_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_8_2: + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_8_2: ... + def setSuperParticle(self, arg0: Particle_8_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_1_1_2_1: + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_3_2: ... + def setSuperParticle(self, arg0: Particle_3_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTile_0_0_37_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_arena) -> None: ... + +class ParticleTile_0_0_37_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_default) -> None: ... + +class ParticleTile_0_0_37_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_pinned) -> None: ... + +class ParticleTile_0_0_4_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_arena) -> None: ... + +class ParticleTile_0_0_4_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_default) -> None: ... + +class ParticleTile_0_0_4_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_pinned) -> None: ... + +class ParticleTile_0_0_5_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_arena) -> None: ... + +class ParticleTile_0_0_5_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_default) -> None: ... + +class ParticleTile_0_0_5_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_pinned) -> None: ... + +class ParticleTile_0_0_8_2_arena: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_arena) -> None: ... + +class ParticleTile_0_0_8_2_default: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_default) -> None: ... + +class ParticleTile_0_0_8_2_pinned: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_pinned) -> None: ... + +class ParticleTile_1_1_2_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_arena) -> None: ... + +class ParticleTile_1_1_2_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_default: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_default) -> None: ... + +class ParticleTile_1_1_2_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_pinned) -> None: ... + +class Particle_0_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 0 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> None: ... + @typing.overload + def get_rdata(self) -> None: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[0]]) -> None: ... + +class Particle_1_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 1 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[1]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[1]]) -> None: ... + +class Particle_2_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 2 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[2]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[2]]) -> None: ... + +class Particle_37_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 37 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[37]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[37]]) -> None: ... + +class Particle_3_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 3 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[3]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[3]]) -> None: ... + +class Particle_4_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 4 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[4]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[4]]) -> None: ... + +class Particle_5_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 5 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[5]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[5]]) -> None: ... + +class Particle_7_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 7 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[7]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[7]]) -> None: ... + +class Particle_8_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 8 + x: float + y: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[8]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[8]]) -> None: ... + +class Periodicity: + __hash__: typing.ClassVar[None] = None + @staticmethod + def non_periodic() -> Periodicity: + """ + Return the Periodicity object that is not periodic in any direction + """ + def __eq__(self, arg0: Periodicity) -> bool: ... + def __getitem__(self, dir: int) -> bool: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + def __repr__(self) -> str: ... + def is_periodic(self, dir: int) -> bool: ... + @property + def domain(self) -> Box: + """ + Cell-centered domain Box "infinitely" long in non-periodic directions. + """ + @property + def is_all_periodic(self) -> bool: ... + @property + def is_any_periodic(self) -> bool: ... + @property + def shift_IntVect(self) -> list[IntVect]: ... + +class RealBox: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, x_lo: float, y_lo: float, x_hi: float, y_hi: float) -> None: ... + @typing.overload + def __init__(self, a_lo: list[float[2]], a_hi: list[float[2]]) -> None: ... + @typing.overload + def __init__(self, bx: Box, dx: list[float[2]], base: list[float[2]]) -> None: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + @typing.overload + def contains(self, rb: XDim3, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealVect, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealBox, eps: float = ...) -> bool: + """ + Determine if RealBox contains another RealBox, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: list[float], eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def hi(self, arg0: int) -> float: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def hi(self) -> list[float[2]]: + """ + Get all components of ``xhi`` + """ + def intersects(self, arg0: RealBox) -> bool: + """ + determine if box intersects with a box + """ + def length(self, arg0: int) -> float: ... + @typing.overload + def lo(self, arg0: int) -> float: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def lo(self) -> list[float[2]]: + """ + Get all components of ``xlo`` + """ + def ok(self) -> bool: + """ + Determine if RealBox satisfies ``xlo[i] None: + """ + Get all components of ``xlo`` + """ + @typing.overload + def setHi(self, arg0: int, arg1: float) -> None: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def setLo(self, arg0: list[float]) -> None: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def setLo(self, arg0: int, arg1: float) -> None: + """ + Get all components of ``xlo`` + """ + def volume(self) -> float: ... + @property + def xhi(self) -> list[float[2]]: ... + @property + def xlo(self) -> list[float[2]]: ... + +class RealVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def unit_vector() -> RealVect: ... + @staticmethod + def zero_vector() -> RealVect: ... + def BASISREALV(self) -> RealVect: + """ + return basis vector in given coordinate direction + """ + @typing.overload + def __add__(self, arg0: float) -> RealVect: ... + @typing.overload + def __add__(self, arg0: RealVect) -> RealVect: ... + def __eq__(self, arg0: RealVect) -> bool: ... + def __ge__(self, arg0: RealVect) -> bool: ... + def __getitem__(self, arg0: int) -> float: ... + def __gt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: float) -> RealVect: ... + @typing.overload + def __iadd__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: float) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + @typing.overload + def __init__(self, arg0: list[float]) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __isub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __isub__(self, arg0: RealVect) -> RealVect: ... + def __itruediv__(self, arg0: float) -> RealVect: ... + def __le__(self, arg0: RealVect) -> bool: ... + def __lt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __mul__(self, arg0: float) -> RealVect: ... + def __ne__(self, arg0: RealVect) -> bool: ... + def __neg__(self) -> RealVect: ... + def __pos__(self) -> RealVect: ... + def __radd__(self, arg0: float) -> RealVect: ... + def __repr__(self) -> str: ... + def __rmul__(self, arg0: float) -> RealVect: ... + def __rsub__(self, arg0: float) -> RealVect: ... + def __rtruediv__(self, arg0: float) -> RealVect: ... + def __setitem__(self, arg0: int, arg1: float) -> float: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __sub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: RealVect) -> RealVect: ... + def ceil(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::ceil of the vector components + """ + def dotProduct(self, arg0: RealVect) -> float: + """ + Return dot product of this vector with another + """ + def floor(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::floor of the vector components + """ + def max(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise maxima of this vector and another + """ + def maxDir(self, arg0: bool) -> int: + """ + direction or index of maximum value of this vector + """ + def min(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise minima of this vector and another + """ + def minDir(self, arg0: bool) -> int: + """ + direction or index of minimum value of this vector + """ + def round(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::round of the vector components + """ + def scale(self, arg0: float) -> RealVect: + """ + Multiplify each component of this vector by a scalar + """ + @property + def product(self) -> float: + """ + Product of entries of this vector + """ + @property + def radSquared(self) -> float: + """ + Length squared of this vector + """ + @property + def sum(self) -> float: + """ + Sum of the components of this vector + """ + @property + def vectorLength(self) -> float: + """ + Length or 2-Norm of this vector + """ + +class StructOfArrays_2_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class Vector_BoxArray: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: BoxArray) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_BoxArray: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_BoxArray) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + def append(self, x: BoxArray) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: BoxArray) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_BoxArray) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: BoxArray) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> BoxArray: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> BoxArray: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: BoxArray) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_DistributionMapping: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: DistributionMapping) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_DistributionMapping: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_DistributionMapping) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + def append(self, x: DistributionMapping) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: DistributionMapping) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_DistributionMapping) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: DistributionMapping) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> DistributionMapping: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> DistributionMapping: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: DistributionMapping) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Geometry: + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + @typing.overload + def __getitem__(self, s: slice) -> Vector_Geometry: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Geometry) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + def append(self, x: Geometry) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + @typing.overload + def extend(self, L: Vector_Geometry) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: Geometry) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> Geometry: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> Geometry: + """ + Remove and return the item at index ``i`` + """ + def size(self) -> int: ... + +class Vector_IntVect: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: IntVect) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_IntVect: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_IntVect) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + def append(self, x: IntVect) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: IntVect) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_IntVect) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: IntVect) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> IntVect: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> IntVect: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: IntVect) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Long: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Long: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Long) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Long) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_Real: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: float) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Real: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Real) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def append(self, x: float) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: float) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Real) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: float) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> float: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> float: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: float) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_int: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_int: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_int) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_int) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_string: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: str) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_string: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_string) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + def append(self, x: str) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: str) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_string) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: str) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> str: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> str: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: str) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class XDim3: + x: float + y: float + z: float + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + +def AlmostEqual(rb1: RealBox, rb2: RealBox, eps: float = ...) -> bool: + """ + Determine if two boxes are equal to within a tolerance + """ + +def The_Arena() -> Arena: ... +def The_Async_Arena() -> Arena: ... +def The_Cpu_Arena() -> Arena: ... +def The_Device_Arena() -> Arena: ... +def The_Managed_Arena() -> Arena: ... +def The_Pinned_Arena() -> Arena: ... +def begin(arg0: Box) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: IntVect) -> IntVect: ... +@typing.overload +def coarsen(arg0: Dim3, arg1: IntVect) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: int) -> IntVect: ... +def concatenate(root: str, num: int, mindigits: int = ...) -> str: + """ + Builds plotfile name + """ + +@typing.overload +def dtoh_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def dtoh_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def end(arg0: Box) -> Dim3: ... +@typing.overload +def finalize() -> None: ... +@typing.overload +def finalize(arg0: AMReX) -> None: ... +@typing.overload +def htod_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def htod_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def initialize(arg0: list) -> AMReX: + """ + Initialize AMReX library + """ + +def initialized() -> bool: + """ + Returns true if there are any currently-active and initialized AMReX instances (i.e. one for which amrex::Initialize has been called, and amrex::Finalize has not). Otherwise false. + """ + +@typing.overload +def lbound(arg0: Box) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong_const) -> Dim3: ... +@typing.overload +def length(arg0: Box) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong_const) -> Dim3: ... +def max(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def min(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def refine(arg0: Dim3, arg1: IntVect) -> Dim3: ... +def size() -> int: + """ + The amr stack size, the number of amr instances pushed. + """ + +@typing.overload +def ubound(arg0: Box) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong_const) -> Dim3: ... +def unpack_cpus(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def unpack_ids(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def write_single_level_plotfile( + plotfilename: str, + mf: MultiFab, + varnames: Vector_string, + geom: Geometry, + time: float, + level_step: int, + versionName: str = ..., + levelPrefix: str = ..., + mfPrefix: str = ..., + extra_dirs: Vector_string = ..., +) -> None: + """ + Writes single level plotfile + """ + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" diff --git a/src/amrex/space3d/__init__.pyi b/src/amrex/space3d/__init__.pyi new file mode 100644 index 00000000..17ea1466 --- /dev/null +++ b/src/amrex/space3d/__init__.pyi @@ -0,0 +1,474 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import os as os + +from amrex.space3d.amrex_3d_pybind import ( + AlmostEqual, + AMReX, + AmrInfo, + AmrMesh, + Arena, + Array4_double, + Array4_double_const, + Array4_float, + Array4_float_const, + Array4_int, + Array4_int_const, + Array4_long, + Array4_long_const, + Array4_longdouble, + Array4_longdouble_const, + Array4_longlong, + Array4_longlong_const, + Array4_short, + Array4_short_const, + Array4_uint, + Array4_uint_const, + Array4_ulong, + Array4_ulong_const, + Array4_ulonglong, + Array4_ulonglong_const, + Array4_ushort, + Array4_ushort_const, + ArrayOfStructs_0_0_arena, + ArrayOfStructs_0_0_default, + ArrayOfStructs_0_0_pinned, + ArrayOfStructs_1_1_arena, + ArrayOfStructs_1_1_default, + ArrayOfStructs_1_1_pinned, + ArrayOfStructs_2_1_arena, + ArrayOfStructs_2_1_default, + ArrayOfStructs_2_1_pinned, + BaseFab_Real, + Box, + BoxArray, + Config, + CoordSys, + Dim3, + Direction, + DistributionMapping, + FabArray_FArrayBox, + FabArrayBase, + FArrayBox, + Geometry, + GeometryData, + IndexType, + IntVect, + MFInfo, + MFIter, + MultiFab, + ParallelDescriptor, + ParConstIter_0_0_4_0_arena, + ParConstIter_0_0_4_0_default, + ParConstIter_0_0_4_0_pinned, + ParConstIter_0_0_5_0_arena, + ParConstIter_0_0_5_0_default, + ParConstIter_0_0_5_0_pinned, + ParConstIter_1_1_2_1_arena, + ParConstIter_1_1_2_1_default, + ParConstIter_1_1_2_1_pinned, + ParConstIter_pureSoA_8_2_arena, + ParConstIter_pureSoA_8_2_default, + ParConstIter_pureSoA_8_2_pinned, + ParConstIterBase_0_0_4_0_arena, + ParConstIterBase_0_0_4_0_default, + ParConstIterBase_0_0_4_0_pinned, + ParConstIterBase_0_0_5_0_arena, + ParConstIterBase_0_0_5_0_default, + ParConstIterBase_0_0_5_0_pinned, + ParConstIterBase_1_1_2_1_arena, + ParConstIterBase_1_1_2_1_default, + ParConstIterBase_1_1_2_1_pinned, + ParConstIterBase_pureSoA_8_2_arena, + ParConstIterBase_pureSoA_8_2_default, + ParConstIterBase_pureSoA_8_2_pinned, + ParIter_0_0_4_0_arena, + ParIter_0_0_4_0_default, + ParIter_0_0_4_0_pinned, + ParIter_0_0_5_0_arena, + ParIter_0_0_5_0_default, + ParIter_0_0_5_0_pinned, + ParIter_1_1_2_1_arena, + ParIter_1_1_2_1_default, + ParIter_1_1_2_1_pinned, + ParIter_pureSoA_8_2_arena, + ParIter_pureSoA_8_2_default, + ParIter_pureSoA_8_2_pinned, + ParIterBase_0_0_4_0_arena, + ParIterBase_0_0_4_0_default, + ParIterBase_0_0_4_0_pinned, + ParIterBase_0_0_5_0_arena, + ParIterBase_0_0_5_0_default, + ParIterBase_0_0_5_0_pinned, + ParIterBase_1_1_2_1_arena, + ParIterBase_1_1_2_1_default, + ParIterBase_1_1_2_1_pinned, + ParIterBase_pureSoA_8_2_arena, + ParIterBase_pureSoA_8_2_default, + ParIterBase_pureSoA_8_2_pinned, + ParmParse, + Particle_0_0, + Particle_1_1, + Particle_2_1, + Particle_3_2, + Particle_4_0, + Particle_5_0, + Particle_7_0, + Particle_8_2, + Particle_37_1, + ParticleContainer_0_0_4_0_arena, + ParticleContainer_0_0_4_0_default, + ParticleContainer_0_0_4_0_pinned, + ParticleContainer_0_0_5_0_arena, + ParticleContainer_0_0_5_0_default, + ParticleContainer_0_0_5_0_pinned, + ParticleContainer_1_1_2_1_arena, + ParticleContainer_1_1_2_1_default, + ParticleContainer_1_1_2_1_pinned, + ParticleContainer_pureSoA_8_2_arena, + ParticleContainer_pureSoA_8_2_default, + ParticleContainer_pureSoA_8_2_pinned, + ParticleInitType_0_0_4_0, + ParticleInitType_0_0_5_0, + ParticleInitType_1_1_2_1, + ParticleTile_0_0_4_0_arena, + ParticleTile_0_0_4_0_default, + ParticleTile_0_0_4_0_pinned, + ParticleTile_0_0_5_0_arena, + ParticleTile_0_0_5_0_default, + ParticleTile_0_0_5_0_pinned, + ParticleTile_0_0_8_2_arena, + ParticleTile_0_0_8_2_default, + ParticleTile_0_0_8_2_pinned, + ParticleTile_0_0_37_1_arena, + ParticleTile_0_0_37_1_default, + ParticleTile_0_0_37_1_pinned, + ParticleTile_1_1_2_1_arena, + ParticleTile_1_1_2_1_default, + ParticleTile_1_1_2_1_pinned, + ParticleTileData_0_0_4_0, + ParticleTileData_0_0_5_0, + ParticleTileData_0_0_8_2, + ParticleTileData_0_0_37_1, + ParticleTileData_1_1_2_1, + Periodicity, + PIdx, + PODVector_int_arena, + PODVector_int_pinned, + PODVector_int_std, + PODVector_real_arena, + PODVector_real_pinned, + PODVector_real_std, + RealBox, + RealVect, + StructOfArrays_2_1_arena, + StructOfArrays_2_1_default, + StructOfArrays_2_1_pinned, + StructOfArrays_4_0_arena, + StructOfArrays_4_0_default, + StructOfArrays_4_0_pinned, + StructOfArrays_5_0_arena, + StructOfArrays_5_0_default, + StructOfArrays_5_0_pinned, + StructOfArrays_8_2_arena, + StructOfArrays_8_2_default, + StructOfArrays_8_2_pinned, + StructOfArrays_37_1_arena, + StructOfArrays_37_1_default, + StructOfArrays_37_1_pinned, + The_Arena, + The_Async_Arena, + The_Cpu_Arena, + The_Device_Arena, + The_Managed_Arena, + The_Pinned_Arena, + Vector_BoxArray, + Vector_DistributionMapping, + Vector_Geometry, + Vector_int, + Vector_IntVect, + Vector_Long, + Vector_Real, + Vector_string, + XDim3, + begin, + coarsen, + concatenate, + dtoh_memcpy, + end, + finalize, + htod_memcpy, + initialize, + initialized, + lbound, + length, + max, + min, + refine, + size, + ubound, + unpack_cpus, + unpack_ids, + write_single_level_plotfile, +) + +from . import amrex_3d_pybind + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "Print", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "amrex_3d_pybind", + "begin", + "coarsen", + "concatenate", + "d_decl", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "os", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +def Print(*args, **kwargs): + """ + Wrap amrex::Print() - only the IO processor writes + """ + +def d_decl(x, y, z): ... + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" diff --git a/src/amrex/space3d/amrex_3d_pybind/ParallelDescriptor.pyi b/src/amrex/space3d/amrex_3d_pybind/ParallelDescriptor.pyi new file mode 100644 index 00000000..70fb4af4 --- /dev/null +++ b/src/amrex/space3d/amrex_3d_pybind/ParallelDescriptor.pyi @@ -0,0 +1,8 @@ +from __future__ import annotations + +__all__ = ["IOProcessor", "IOProcessorNumber", "MyProc", "NProcs"] + +def IOProcessor() -> bool: ... +def IOProcessorNumber() -> int: ... +def MyProc() -> int: ... +def NProcs() -> int: ... diff --git a/src/amrex/space3d/amrex_3d_pybind/__init__.pyi b/src/amrex/space3d/amrex_3d_pybind/__init__.pyi new file mode 100644 index 00000000..2aa9e15e --- /dev/null +++ b/src/amrex/space3d/amrex_3d_pybind/__init__.pyi @@ -0,0 +1,7808 @@ +""" + + amrex + ----- + .. currentmodule:: amrex + + .. autosummary:: + :toctree: _generate + AmrInfo + AmrMesh + Arena + ArrayOfStructs + Box + RealBox + BoxArray + Dim3 + FArrayBox + IntVect + IndexType + RealVect + MultiFab + ParallelDescriptor + Particle + ParmParse + ParticleTile + ParticleContainer + Periodicity + PlotFileUtil + PODVector + StructOfArrays + Utility + Vector + +""" +from __future__ import annotations + +import typing + +import numpy + +from . import ParallelDescriptor + +__all__ = [ + "AMReX", + "AlmostEqual", + "AmrInfo", + "AmrMesh", + "Arena", + "Array4_double", + "Array4_double_const", + "Array4_float", + "Array4_float_const", + "Array4_int", + "Array4_int_const", + "Array4_long", + "Array4_long_const", + "Array4_longdouble", + "Array4_longdouble_const", + "Array4_longlong", + "Array4_longlong_const", + "Array4_short", + "Array4_short_const", + "Array4_uint", + "Array4_uint_const", + "Array4_ulong", + "Array4_ulong_const", + "Array4_ulonglong", + "Array4_ulonglong_const", + "Array4_ushort", + "Array4_ushort_const", + "ArrayOfStructs_0_0_arena", + "ArrayOfStructs_0_0_default", + "ArrayOfStructs_0_0_pinned", + "ArrayOfStructs_1_1_arena", + "ArrayOfStructs_1_1_default", + "ArrayOfStructs_1_1_pinned", + "ArrayOfStructs_2_1_arena", + "ArrayOfStructs_2_1_default", + "ArrayOfStructs_2_1_pinned", + "BaseFab_Real", + "Box", + "BoxArray", + "Config", + "CoordSys", + "Dim3", + "Direction", + "DistributionMapping", + "FArrayBox", + "FabArrayBase", + "FabArray_FArrayBox", + "Geometry", + "GeometryData", + "IndexType", + "IntVect", + "MFInfo", + "MFIter", + "MultiFab", + "PIdx", + "PODVector_int_arena", + "PODVector_int_pinned", + "PODVector_int_std", + "PODVector_real_arena", + "PODVector_real_pinned", + "PODVector_real_std", + "ParConstIterBase_0_0_4_0_arena", + "ParConstIterBase_0_0_4_0_default", + "ParConstIterBase_0_0_4_0_pinned", + "ParConstIterBase_0_0_5_0_arena", + "ParConstIterBase_0_0_5_0_default", + "ParConstIterBase_0_0_5_0_pinned", + "ParConstIterBase_1_1_2_1_arena", + "ParConstIterBase_1_1_2_1_default", + "ParConstIterBase_1_1_2_1_pinned", + "ParConstIterBase_pureSoA_8_2_arena", + "ParConstIterBase_pureSoA_8_2_default", + "ParConstIterBase_pureSoA_8_2_pinned", + "ParConstIter_0_0_4_0_arena", + "ParConstIter_0_0_4_0_default", + "ParConstIter_0_0_4_0_pinned", + "ParConstIter_0_0_5_0_arena", + "ParConstIter_0_0_5_0_default", + "ParConstIter_0_0_5_0_pinned", + "ParConstIter_1_1_2_1_arena", + "ParConstIter_1_1_2_1_default", + "ParConstIter_1_1_2_1_pinned", + "ParConstIter_pureSoA_8_2_arena", + "ParConstIter_pureSoA_8_2_default", + "ParConstIter_pureSoA_8_2_pinned", + "ParIterBase_0_0_4_0_arena", + "ParIterBase_0_0_4_0_default", + "ParIterBase_0_0_4_0_pinned", + "ParIterBase_0_0_5_0_arena", + "ParIterBase_0_0_5_0_default", + "ParIterBase_0_0_5_0_pinned", + "ParIterBase_1_1_2_1_arena", + "ParIterBase_1_1_2_1_default", + "ParIterBase_1_1_2_1_pinned", + "ParIterBase_pureSoA_8_2_arena", + "ParIterBase_pureSoA_8_2_default", + "ParIterBase_pureSoA_8_2_pinned", + "ParIter_0_0_4_0_arena", + "ParIter_0_0_4_0_default", + "ParIter_0_0_4_0_pinned", + "ParIter_0_0_5_0_arena", + "ParIter_0_0_5_0_default", + "ParIter_0_0_5_0_pinned", + "ParIter_1_1_2_1_arena", + "ParIter_1_1_2_1_default", + "ParIter_1_1_2_1_pinned", + "ParIter_pureSoA_8_2_arena", + "ParIter_pureSoA_8_2_default", + "ParIter_pureSoA_8_2_pinned", + "ParallelDescriptor", + "ParmParse", + "ParticleContainer_0_0_4_0_arena", + "ParticleContainer_0_0_4_0_default", + "ParticleContainer_0_0_4_0_pinned", + "ParticleContainer_0_0_5_0_arena", + "ParticleContainer_0_0_5_0_default", + "ParticleContainer_0_0_5_0_pinned", + "ParticleContainer_1_1_2_1_arena", + "ParticleContainer_1_1_2_1_default", + "ParticleContainer_1_1_2_1_pinned", + "ParticleContainer_pureSoA_8_2_arena", + "ParticleContainer_pureSoA_8_2_default", + "ParticleContainer_pureSoA_8_2_pinned", + "ParticleInitType_0_0_4_0", + "ParticleInitType_0_0_5_0", + "ParticleInitType_1_1_2_1", + "ParticleTileData_0_0_37_1", + "ParticleTileData_0_0_4_0", + "ParticleTileData_0_0_5_0", + "ParticleTileData_0_0_8_2", + "ParticleTileData_1_1_2_1", + "ParticleTile_0_0_37_1_arena", + "ParticleTile_0_0_37_1_default", + "ParticleTile_0_0_37_1_pinned", + "ParticleTile_0_0_4_0_arena", + "ParticleTile_0_0_4_0_default", + "ParticleTile_0_0_4_0_pinned", + "ParticleTile_0_0_5_0_arena", + "ParticleTile_0_0_5_0_default", + "ParticleTile_0_0_5_0_pinned", + "ParticleTile_0_0_8_2_arena", + "ParticleTile_0_0_8_2_default", + "ParticleTile_0_0_8_2_pinned", + "ParticleTile_1_1_2_1_arena", + "ParticleTile_1_1_2_1_default", + "ParticleTile_1_1_2_1_pinned", + "Particle_0_0", + "Particle_1_1", + "Particle_2_1", + "Particle_37_1", + "Particle_3_2", + "Particle_4_0", + "Particle_5_0", + "Particle_7_0", + "Particle_8_2", + "Periodicity", + "RealBox", + "RealVect", + "StructOfArrays_2_1_arena", + "StructOfArrays_2_1_default", + "StructOfArrays_2_1_pinned", + "StructOfArrays_37_1_arena", + "StructOfArrays_37_1_default", + "StructOfArrays_37_1_pinned", + "StructOfArrays_4_0_arena", + "StructOfArrays_4_0_default", + "StructOfArrays_4_0_pinned", + "StructOfArrays_5_0_arena", + "StructOfArrays_5_0_default", + "StructOfArrays_5_0_pinned", + "StructOfArrays_8_2_arena", + "StructOfArrays_8_2_default", + "StructOfArrays_8_2_pinned", + "The_Arena", + "The_Async_Arena", + "The_Cpu_Arena", + "The_Device_Arena", + "The_Managed_Arena", + "The_Pinned_Arena", + "Vector_BoxArray", + "Vector_DistributionMapping", + "Vector_Geometry", + "Vector_IntVect", + "Vector_Long", + "Vector_Real", + "Vector_int", + "Vector_string", + "XDim3", + "begin", + "coarsen", + "concatenate", + "dtoh_memcpy", + "end", + "finalize", + "htod_memcpy", + "initialize", + "initialized", + "lbound", + "length", + "max", + "min", + "refine", + "size", + "ubound", + "unpack_cpus", + "unpack_ids", + "write_single_level_plotfile", +] + +class AMReX: + @staticmethod + def empty() -> bool: ... + @staticmethod + def erase(arg0: AMReX) -> None: ... + @staticmethod + def size() -> int: ... + @staticmethod + def top() -> AMReX: ... + +class AmrInfo: + check_input: bool + grid_eff: float + iterate_on_new_grids: bool + max_level: int + n_proper: int + refine_grid_layout: bool + refine_grid_layout_dims: IntVect + use_fixed_coarse_grids: bool + use_fixed_upto_level: int + use_new_chop: bool + verbose: int + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + def blocking_factor(self, arg0: int) -> IntVect: ... + def max_grid_size(self, arg0: int) -> IntVect: ... + def n_error_buf(self, arg0: int) -> IntVect: ... + def ref_ratio(self, arg0: int) -> IntVect: ... + +class AmrMesh: + def Verbose(self) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, + rb: RealBox, + max_level_in: int, + n_cell_in: Vector_int, + coord: int, + ref_ratios: Vector_IntVect, + is_per: list[int[3]], + ) -> None: ... + def __repr__(self) -> str: ... + def finest_level(self) -> int: ... + def max_level(self) -> int: ... + @typing.overload + def ref_ratio(self) -> Vector_IntVect: ... + @typing.overload + def ref_ratio(self, arg0: int) -> IntVect: ... + +class Arena: + pass + +class Array4_double: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_double_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_float_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_float_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.float32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_int_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_int_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_long_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_long_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: float) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longdouble_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> float: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longdouble_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.longdouble]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_longlong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_longlong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_short_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_short_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.int16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_uint_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_uint_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint32]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ulonglong_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ulonglong_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint64]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: IntVect, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[4]], arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: list[int[3]], arg1: int) -> None: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class Array4_ushort_const: + @typing.overload + def __getitem__(self, arg0: IntVect) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[4]]) -> int: ... + @typing.overload + def __getitem__(self, arg0: list[int[3]]) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_ushort_const, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: numpy.ndarray[numpy.uint16]) -> None: ... + def __repr__(self) -> str: ... + def contains(self, arg0: int, arg1: int, arg2: int) -> bool: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + @property + def nComp(self) -> int: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class ArrayOfStructs_0_0_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_0_0_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_0_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_0_0) -> None: ... + def back(self) -> Particle_0_0: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_0_0) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_1_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_1_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_1_1) -> None: ... + def back(self) -> Particle_1_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_1_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_arena: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_default: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ArrayOfStructs_2_1_pinned: + @staticmethod + def test_sizes() -> None: ... + def __getitem__(self, arg0: int) -> Particle_2_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_2_1) -> None: ... + def back(self) -> Particle_2_1: + """ + get back member. Problem!!!!! this is perfo + """ + @typing.overload + def empty(self) -> bool: ... + @typing.overload + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: Particle_2_1) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class BaseFab_Real: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + def big_end(self) -> IntVect: ... + def box(self) -> Box: ... + def clear(self) -> None: ... + def hi_vect(self) -> int: ... + def is_allocated(self) -> bool: ... + def length(self) -> IntVect: ... + def lo_vect(self) -> int: ... + @typing.overload + def n_bytes(self) -> int: ... + @typing.overload + def n_bytes(self, arg0: Box, arg1: int) -> int: ... + def n_bytes_owned(self) -> int: ... + def n_comp(self) -> int: ... + def num_pts(self) -> int: ... + def resize(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + def size(self) -> int: ... + def small_end(self) -> IntVect: ... + +class Box: + def __add__(self, arg0: IntVect) -> Box: ... + def __iadd__(self, arg0: IntVect) -> Box: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, typ: IntVect) -> None: ... + @typing.overload + def __init__(self, small: IntVect, big: IntVect, t: IndexType) -> None: ... + @typing.overload + def __init__(self, small: list[int[3]], big: list[int[3]]) -> None: ... + @typing.overload + def __init__( + self, small: list[int[3]], big: list[int[3]], t: IndexType + ) -> None: ... + def __isub__(self, arg0: IntVect) -> Box: ... + def __iter__(self) -> typing.Iterator: ... + def __repr__(self) -> str: ... + def __sub__(self, arg0: IntVect) -> Box: ... + def begin(self, arg0: Box) -> Dim3: ... + def contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def convert(self, arg0: IndexType) -> Box: ... + @typing.overload + def convert(self, arg0: IntVect) -> Box: ... + @typing.overload + def enclosed_cells(self) -> Box: ... + @typing.overload + def enclosed_cells(self, dir: int) -> Box: ... + @typing.overload + def enclosed_cells(self, d: Direction) -> Box: ... + def end(self, arg0: Box) -> Dim3: ... + @typing.overload + def grow(self, n_cell: int) -> Box: ... + @typing.overload + def grow(self, n_cells: IntVect) -> Box: ... + @typing.overload + def grow(self, idir: int, n_cell: int) -> Box: ... + @typing.overload + def grow(self, d: Direction, n_cell: int) -> Box: ... + def intersects(self, arg0: Box) -> bool: ... + def lbound(self, arg0: Box) -> Dim3: ... + @typing.overload + def length(self) -> IntVect: + """ + Return IntVect of lengths of the Box + """ + @typing.overload + def length(self, arg0: int) -> int: + """ + Return the length of the Box in given direction. + """ + def make_slab(self, direction: int, slab_index: int) -> Box: ... + def normalize(self) -> None: ... + def numPts(self) -> int: + """ + Return the number of points in the Box. + """ + def same_size(self, arg0: Box) -> bool: ... + def same_type(self, arg0: Box) -> bool: ... + def shift(self, arg0: IntVect) -> Box: ... + def strictly_contains(self, arg0: IntVect) -> bool: ... + @typing.overload + def surrounding_nodes(self) -> Box: ... + @typing.overload + def surrounding_nodes(self, dir: int) -> Box: ... + @typing.overload + def surrounding_nodes(self, d: Direction) -> Box: ... + def ubound(self, arg0: Box) -> Dim3: ... + @property + def big_end(self) -> IntVect: ... + @property + def cell_centered(self) -> bool: ... + @property + def d_num_pts(self) -> float: ... + @property + def hi_vect(self) -> IntVect: ... + @property + def is_empty(self) -> bool: ... + @property + def is_square(self) -> bool: ... + @property + def ix_type(self) -> IndexType: ... + @property + def lo_vect(self) -> IntVect: ... + @property + def num_pts(self) -> int: ... + @property + def ok(self) -> bool: ... + @property + def size(self) -> IntVect: ... + @property + def small_end(self) -> IntVect: ... + @property + def the_unit_box() -> Box: ... + @property + def type(self) -> IntVect: ... + @type.setter + def type(self, arg1: IndexType) -> Box: ... + @property + def volume(self) -> int: ... + +class BoxArray: + def __getitem__(self, arg0: int) -> Box: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Box) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int) -> None: ... + def __repr__(self) -> str: ... + def cell_equal(self, arg0: BoxArray) -> bool: ... + def clear(self) -> None: ... + @typing.overload + def coarsen(self, arg0: IntVect) -> BoxArray: ... + @typing.overload + def coarsen(self, arg0: int) -> BoxArray: ... + @typing.overload + def coarsenable(self, arg0: int, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: int) -> bool: ... + @typing.overload + def coarsenable(self, arg0: IntVect, arg1: IntVect) -> bool: ... + def define(self, arg0: Box) -> None: ... + def get(self, arg0: int) -> Box: ... + def ix_type(self) -> IndexType: ... + @typing.overload + def max_size(self, arg0: int) -> BoxArray: ... + @typing.overload + def max_size(self, arg0: IntVect) -> BoxArray: ... + def minimal_box(self) -> Box: ... + @typing.overload + def refine(self, arg0: int) -> BoxArray: ... + @typing.overload + def refine(self, arg0: IntVect) -> BoxArray: ... + def resize(self, arg0: int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def d_numPts(self) -> float: ... + @property + def empty(self) -> bool: ... + @property + def numPts(self) -> int: ... + @property + def size(self) -> int: ... + +class Config: + amrex_version: typing.ClassVar[str] = "23.08" + gpu_backend = None + have_gpu: typing.ClassVar[bool] # value = False + have_mpi: typing.ClassVar[bool] # value = True + have_omp: typing.ClassVar[bool] # value = False + spacedim: typing.ClassVar[int] = 3 + verbose: typing.ClassVar[int] = 1 + +class CoordSys: + class CoordType: + """ + Members: + + undef + + cartesian + + RZ + + SPHERICAL + """ + + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[ + CoordSys.CoordType + ] # value = + __members__: typing.ClassVar[ + dict[str, CoordSys.CoordType] + ] # value = {'undef': , 'cartesian': , 'RZ': , 'SPHERICAL': } + cartesian: typing.ClassVar[ + CoordSys.CoordType + ] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + RZ: typing.ClassVar[CoordSys.CoordType] # value = + SPHERICAL: typing.ClassVar[CoordSys.CoordType] # value = + cartesian: typing.ClassVar[CoordSys.CoordType] # value = + undef: typing.ClassVar[CoordSys.CoordType] # value = + def Coord(self) -> CoordSys.CoordType: ... + def CoordInt(self) -> int: ... + def IsCartesian(self) -> bool: ... + def IsRZ(self) -> bool: ... + def IsSPHERICAL(self) -> bool: ... + def SetCoord(self, arg0: CoordSys.CoordType) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: CoordSys) -> None: ... + def __repr__(self) -> str: ... + def ok(self) -> bool: ... + +class Dim3: + x: int + y: int + z: int + def __init__(self, arg0: int, arg1: int, arg2: int) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + +class Direction: + pass + +class DistributionMapping: + def ProcessorMap(self) -> Vector_int: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: DistributionMapping) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray) -> None: ... + @typing.overload + def __init__(self, boxes: BoxArray, nprocs: int) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def define(self, boxes: BoxArray) -> None: ... + @typing.overload + def define(self, boxes: BoxArray, nprocs: int) -> None: ... + @typing.overload + def define(self, arg0: Vector_int) -> None: ... + @property + def capacity(self) -> int: ... + @property + def empty(self) -> bool: ... + @property + def link_count(self) -> int: ... + @property + def size(self) -> int: ... + +class FArrayBox(BaseFab_Real): + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Arena) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: Arena) -> None: ... + @typing.overload + def __init__( + self, arg0: Box, arg1: int, arg2: bool, arg3: bool, arg4: Arena + ) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Box, arg1: int, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double, arg1: IndexType) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const) -> None: ... + @typing.overload + def __init__(self, arg0: Array4_double_const, arg1: IndexType) -> None: ... + def __repr__(self) -> str: ... + +class FabArrayBase: + def __iter__(self) -> MFIter: ... + def is_nodal(self, arg0: int) -> bool: ... + @property + def is_all_cell_centered(self) -> bool: ... + @property + def is_all_nodal(self) -> bool: ... + @property + def nComp(self) -> int: ... + @property + def nGrowVect(self) -> IntVect: ... + @property + def num_comp(self) -> int: ... + @property + def size(self) -> int: ... + +class FabArray_FArrayBox(FabArrayBase): + @staticmethod + def lin_comb( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: float, + arg5: FabArray_FArrayBox, + arg6: int, + arg7: int, + arg8: int, + arg9: IntVect, + ) -> None: ... + @staticmethod + def saxpy( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + @staticmethod + def xpay( + arg0: FabArray_FArrayBox, + arg1: float, + arg2: FabArray_FArrayBox, + arg3: int, + arg4: int, + arg5: int, + arg6: IntVect, + ) -> None: ... + def array(self, arg0: MFIter) -> Array4_double: ... + def const_array(self, arg0: MFIter) -> Array4_double_const: ... + @typing.overload + def fill_boundary(self, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary(self, period: Periodicity, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, nghost: IntVect, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary(self, scomp: int, ncomp: int, cross: bool = ...) -> None: ... + @typing.overload + def fill_boundary( + self, scomp: int, ncomp: int, period: Periodicity, cross: bool = ... + ) -> None: ... + @typing.overload + def fill_boundary( + self, + scomp: int, + ncomp: int, + nghost: IntVect, + period: Periodicity, + cross: bool = ..., + ) -> None: ... + def override_sync(self, arg0: Periodicity) -> None: ... + def sum(self, arg0: int, arg1: IntVect, arg2: bool) -> float: ... + @typing.overload + def sum_boundary(self, arg0: Periodicity) -> None: ... + @typing.overload + def sum_boundary(self, arg0: int, arg1: int, arg2: Periodicity) -> None: ... + @typing.overload + def sum_boundary( + self, arg0: int, arg1: int, arg2: IntVect, arg3: Periodicity + ) -> None: ... + +class Geometry(CoordSys): + @typing.overload + def Domain(self) -> Box: + """ + Return rectangular domain + """ + @typing.overload + def Domain(self, arg0: Box) -> None: ... + @typing.overload + def ProbDomain(self) -> RealBox: + """ + Return problem domain + """ + @typing.overload + def ProbDomain(self, arg0: RealBox) -> None: ... + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Get the hi end of the problem domain in specified direction + """ + @typing.overload + def ProbHi(self) -> list[float[3]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbLength(self, arg0: int) -> float: + """ + length of problem domain in specified dimension + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Get the lo end of the problem domain in specified direction + """ + @typing.overload + def ProbLo(self) -> list[float[3]]: + """ + Get the list of lo ends of the problem domain + """ + def ProbSize(self) -> float: + """ + the overall size of the domain + """ + def ResetDefaultCoord(self) -> None: + """ + Reset default coord of Geometry class with an Array of `int` + """ + def ResetDefaultPeriodicity(self) -> None: + """ + Reset default periodicity of Geometry class with an Array of `int` + """ + def ResetDefaultProbDomain(self) -> None: + """ + Reset default problem domain of Geometry class with a `RealBox` + """ + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, dom: Box, rb: RealBox, coord: int, is_per: list[int[3]] + ) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def coarsen(self, arg0: IntVect) -> None: ... + def data(self) -> GeometryData: + """ + Returns non-static copy of geometry's stored data + """ + def define(self, arg0: Box, arg1: RealBox, arg2: int, arg3: list[int[3]]) -> None: + """ + Set geometry + """ + @typing.overload + def growNonPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growNonPeriodicDomain(self, arg0: int) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: IntVect) -> Box: ... + @typing.overload + def growPeriodicDomain(self, arg0: int) -> Box: ... + def insideRoundOffDomain(self, arg0: float, arg1: float, arg2: float) -> bool: + """ + Returns true if a point is inside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def isAllPeriodic(self) -> bool: + """ + Is domain periodic in all directions? + """ + def isAnyPeriodic(self) -> bool: + """ + Is domain periodic in any direction? + """ + @typing.overload + def isPeriodic(self, arg0: int) -> bool: + """ + Is the domain periodic in the specified direction? + """ + @typing.overload + def isPeriodic(self) -> list[int[3]]: + """ + Return list indicating whether domain is periodic in each direction + """ + def outsideRoundOffDomain(self, arg0: float, arg1: float, arg2: float) -> bool: + """ + Returns true if a point is outside the roundoff domain. All particles with positions inside the roundoff domain are sure to be mapped to cells inside the Domain() box. Note that the same need not be true for all points inside ProbDomain() + """ + def period(self, arg0: int) -> int: + """ + Return the period in the specified direction + """ + @typing.overload + def periodicity(self) -> Periodicity: ... + @typing.overload + def periodicity(self, arg0: Box) -> Periodicity: + """ + Return Periodicity object with lengths determined by input Box + """ + def refine(self, arg0: IntVect) -> None: ... + def setPeriodicity(self, arg0: list[int[3]]) -> list[int[3]]: ... + +class GeometryData: + @typing.overload + def CellSize(self) -> list[float[3]]: + """ + Returns the cellsize for each coordinate direction. + """ + @typing.overload + def CellSize(self, arg0: int) -> float: + """ + Returns the cellsize for specified coordinate direction. + """ + def Coord(self) -> int: + """ + return integer coordinate type + """ + def Domain(self) -> Box: + """ + Returns our rectangular domain + """ + @typing.overload + def ProbHi(self) -> list[float[3]]: + """ + Returns the hi end for each coordinate direction. + """ + @typing.overload + def ProbHi(self, arg0: int) -> float: + """ + Returns the hi end of the problem domain in specified dimension. + """ + @typing.overload + def ProbLo(self) -> list[float[3]]: + """ + Returns the lo end for each coordinate direction. + """ + @typing.overload + def ProbLo(self, arg0: int) -> float: + """ + Returns the lo end of the problem domain in specified dimension. + """ + def __init__(self) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def isPeriodic(self) -> list[int[3]]: + """ + Returns whether the domain is periodic in each direction. + """ + @typing.overload + def isPeriodic(self, arg0: int) -> int: + """ + Returns whether the domain is periodic in the given direction. + """ + @property + def coord(self) -> int: ... + @property + def domain(self) -> Box: ... + @property + def dx(self) -> list[float[3]]: ... + @property + def is_periodic(self) -> list[int[3]]: ... + @property + def prob_domain(self) -> RealBox: ... + +class IndexType: + class CellIndex: + """ + Members: + + CELL + + NODE + """ + + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __members__: typing.ClassVar[ + dict[str, IndexType.CellIndex] + ] # value = {'CELL': , 'NODE': } + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + CELL: typing.ClassVar[IndexType.CellIndex] # value = + NODE: typing.ClassVar[IndexType.CellIndex] # value = + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_type() -> IndexType: ... + @staticmethod + def node_type() -> IndexType: ... + def __eq__(self, arg0: IndexType) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IndexType) -> None: ... + @typing.overload + def __init__( + self, + arg0: IndexType.CellIndex, + arg1: IndexType.CellIndex, + arg2: IndexType.CellIndex, + ) -> None: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IndexType) -> bool: ... + def __ne__(self, arg0: IndexType) -> bool: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + def any(self) -> bool: ... + @typing.overload + def cell_centered(self) -> bool: ... + @typing.overload + def cell_centered(self, arg0: int) -> bool: ... + def clear(self) -> None: ... + def flip(self, arg0: int) -> None: ... + @typing.overload + def ix_type(self) -> IntVect: ... + @typing.overload + def ix_type(self, arg0: int) -> IndexType.CellIndex: ... + @typing.overload + def node_centered(self) -> bool: ... + @typing.overload + def node_centered(self, arg0: int) -> bool: ... + def ok(self) -> bool: ... + def set(self, arg0: int) -> None: ... + def set_type(self, arg0: int, arg1: IndexType.CellIndex) -> None: ... + def setall(self) -> None: ... + def test(self, arg0: int) -> bool: ... + def to_IntVect(self) -> IntVect: ... + def unset(self, arg0: int) -> None: ... + +class IntVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def cell_vector() -> IntVect: ... + @staticmethod + def max_vector() -> IntVect: ... + @staticmethod + def min_vector() -> IntVect: ... + @staticmethod + def node_vector() -> IntVect: ... + @staticmethod + def unit_vector() -> IntVect: ... + @staticmethod + def zero_vector() -> IntVect: ... + @typing.overload + def __add__(self, arg0: int) -> IntVect: ... + @typing.overload + def __add__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __eq__(self, arg0: int) -> bool: ... + @typing.overload + def __eq__(self, arg0: IntVect) -> bool: ... + def __ge__(self, arg0: IntVect) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + def __gt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: int) -> IntVect: ... + @typing.overload + def __iadd__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __imul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def __init__(self, arg0: int) -> None: ... + @typing.overload + def __init__(self, arg0: list[int[3]]) -> None: ... + @typing.overload + def __isub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __isub__(self, arg0: IntVect) -> IntVect: ... + def __iter__(self) -> typing.Iterator: ... + @typing.overload + def __itruediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __itruediv__(self, arg0: IntVect) -> IntVect: ... + def __le__(self, arg0: IntVect) -> bool: ... + def __len__(self) -> int: ... + def __lt__(self, arg0: IntVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: int) -> IntVect: ... + @typing.overload + def __mul__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __ne__(self, arg0: int) -> bool: ... + @typing.overload + def __ne__(self, arg0: IntVect) -> bool: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> int: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: int) -> IntVect: ... + @typing.overload + def __sub__(self, arg0: IntVect) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: int) -> IntVect: ... + @typing.overload + def __truediv__(self, arg0: IntVect) -> IntVect: ... + def dim3(self) -> Dim3: ... + def numpy(self) -> numpy.ndarray: ... + @property + def max(self) -> int: ... + @property + def min(self) -> int: ... + @property + def sum(self) -> int: ... + +class MFInfo: + alloc: bool + arena: Arena + tags: Vector_string + def __init__(self) -> None: ... + def set_alloc(self, arg0: bool) -> MFInfo: ... + def set_arena(self, arg0: Arena) -> MFInfo: ... + def set_tag(self, arg0: str) -> None: ... + +class MFIter: + @typing.overload + def __init__(self, arg0: FabArrayBase) -> None: ... + @typing.overload + def __init__(self, arg0: MultiFab) -> None: ... + def __next__(self) -> MFIter: ... + def __repr__(self) -> str: ... + def fabbox(self) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int = ..., ng: int = ...) -> Box: ... + @typing.overload + def grownnodaltilebox(self, int: int, ng: IntVect) -> Box: ... + def growntilebox(self, ng: IntVect = ...) -> Box: ... + def nodaltilebox(self, dir: int = ...) -> Box: ... + @typing.overload + def tilebox(self) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect) -> Box: ... + @typing.overload + def tilebox(self, arg0: IntVect, arg1: IntVect) -> Box: ... + def validbox(self) -> Box: ... + @property + def index(self) -> int: ... + @property + def is_valid(self) -> bool: ... + @property + def length(self) -> int: ... + +class MultiFab(FabArray_FArrayBox): + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def add( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: int, + ) -> None: ... + @staticmethod + @typing.overload + def add_product( + arg0: MultiFab, + arg1: MultiFab, + arg2: int, + arg3: MultiFab, + arg4: int, + arg5: int, + arg6: int, + arg7: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: int, + ) -> None: ... + @staticmethod + @typing.overload + def copy( + dst: MultiFab, + src: MultiFab, + srccomp: int, + dstcomp: int, + numcomp: int, + nghost: IntVect, + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def divide( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def dot( + arg0: MultiFab, + arg1: int, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: bool, + ) -> float: ... + @staticmethod + @typing.overload + def dot(arg0: MultiFab, arg1: int, arg2: int, arg3: int, arg4: bool) -> float: ... + @staticmethod + def finalize() -> None: ... + @staticmethod + def initialize() -> None: ... + @staticmethod + def lin_comb( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: float, + arg5: MultiFab, + arg6: int, + arg7: int, + arg8: int, + arg9: int, + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def multiply( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def saxpy( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def subtract( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: int + ) -> None: ... + @staticmethod + @typing.overload + def swap( + arg0: MultiFab, arg1: MultiFab, arg2: int, arg3: int, arg4: int, arg5: IntVect + ) -> None: ... + @staticmethod + def xpay( + arg0: MultiFab, + arg1: float, + arg2: MultiFab, + arg3: int, + arg4: int, + arg5: int, + arg6: int, + ) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: int + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: int, + arg4: MFInfo, + ) -> None: ... + @typing.overload + def __init__( + self, arg0: BoxArray, arg1: DistributionMapping, arg2: int, arg3: IntVect + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: BoxArray, + arg1: DistributionMapping, + arg2: int, + arg3: IntVect, + arg4: MFInfo, + ) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def abs(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def abs(self, arg0: int, arg1: int, arg2: int) -> None: ... + def average_sync(self, arg0: Periodicity) -> None: ... + def box_array(self) -> BoxArray: ... + @typing.overload + def contains_inf(self, arg0: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_inf(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: int, arg3: bool) -> bool: ... + @typing.overload + def contains_nan(self, arg0: int, arg1: int, arg2: IntVect, arg3: bool) -> bool: ... + def divi(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + def dm(self) -> DistributionMapping: ... + @typing.overload + def invert(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def invert(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def invert( + self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int + ) -> None: ... + @typing.overload + def max(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab. + """ + @typing.overload + def max( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the maximum value of the specfied component of the MultiFab over the region. + """ + def maxIndex(self, arg0: int, arg1: int) -> IntVect: ... + @typing.overload + def min(self, comp: int = ..., nghost: int = ..., local: bool = ...) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab. + """ + @typing.overload + def min( + self, region: Box, comp: int = ..., nghost: int = ..., local: bool = ... + ) -> float: + """ + Returns the minimum value of the specfied component of the MultiFab over the region. + """ + def minIndex(self, arg0: int, arg1: int) -> IntVect: ... + def minus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def mult(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + def n_comp(self) -> int: ... + def n_grow_vect(self) -> IntVect: ... + @typing.overload + def negate(self, arg0: int) -> None: ... + @typing.overload + def negate(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int) -> None: ... + @typing.overload + def negate(self, arg0: Box, arg1: int, arg2: int, arg3: int) -> None: ... + def norm0(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: Periodicity, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: int, arg1: int, arg2: bool) -> float: ... + @typing.overload + def norm1(self, arg0: Vector_int, arg1: int, arg2: bool) -> Vector_Real: ... + @typing.overload + def norm2(self, arg0: int) -> float: ... + @typing.overload + def norm2(self, arg0: int, arg1: Periodicity) -> float: ... + @typing.overload + def norm2(self, arg0: Vector_int) -> Vector_Real: ... + def norminf(self, arg0: int, arg1: int, arg2: bool, arg3: bool) -> float: ... + @typing.overload + def plus(self, arg0: float, arg1: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int) -> None: ... + @typing.overload + def plus(self, arg0: float, arg1: Box, arg2: int, arg3: int, arg4: int) -> None: ... + @typing.overload + def plus(self, arg0: MultiFab, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: int) -> None: ... + @typing.overload + def set_val(self, arg0: float, arg1: int, arg2: int, arg3: IntVect) -> None: ... + def sum(self, comp: int = ..., local: bool = ...) -> float: + """ + Returns the sum of component 'comp' over the MultiFab -- no ghost cells are included. + """ + def sum_unique( + self, comp: int = ..., local: bool = ..., period: Periodicity = ... + ) -> float: + """ + Same as sum with local=false, but for non-cell-centered data, thisskips non-unique points that are owned by multiple boxes. + """ + def weighted_sync(self, arg0: MultiFab, arg1: Periodicity) -> None: ... + +class PIdx: + class IntValues: + """ + Members: + """ + + __members__: typing.ClassVar[dict] = {} + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + + class RealValues: + """ + Members: + + w + + vx + + vy + + vz + + Ex + + Ey + + Ez + """ + + Ex: typing.ClassVar[PIdx.RealValues] # value = + Ey: typing.ClassVar[PIdx.RealValues] # value = + Ez: typing.ClassVar[PIdx.RealValues] # value = + __members__: typing.ClassVar[ + dict[str, PIdx.RealValues] + ] # value = {'w': , 'vx': , 'vy': , 'vz': , 'Ex': , 'Ey': , 'Ez': } + vx: typing.ClassVar[PIdx.RealValues] # value = + vy: typing.ClassVar[PIdx.RealValues] # value = + vz: typing.ClassVar[PIdx.RealValues] # value = + w: typing.ClassVar[PIdx.RealValues] # value = + def __eq__(self, other: typing.Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: typing.Any) -> bool: ... + def __repr__(self) -> str: ... + def __setstate__(self, state: int) -> None: ... + def __str__(self) -> str: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class PODVector_int_arena: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_pinned: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_int_std: + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_int_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_arena: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_arena) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_pinned: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_pinned) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class PODVector_real_std: + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, size: int) -> None: ... + @typing.overload + def __init__(self, other: PODVector_real_std) -> None: ... + def __len__(self) -> int: ... + def __repr__(self) -> str: ... + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def empty(self) -> bool: ... + def pop_back(self) -> None: ... + def push_back(self, arg0: float) -> None: ... + def reserve(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int) -> None: ... + @typing.overload + def resize(self, arg0: int, arg1: float) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class ParConstIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_default: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParConstIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_default: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParConstIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParConstIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIterBase_0_0_4_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_arena: ... + def __next__(self) -> ParIterBase_0_0_4_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_arena: ... + def soa(self) -> StructOfArrays_4_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_default: ... + def __next__(self) -> ParIterBase_0_0_4_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_default: ... + def soa(self) -> StructOfArrays_4_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_4_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_4_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_4_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_4_0_pinned: ... + def soa(self) -> StructOfArrays_4_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_arena: ... + def __next__(self) -> ParIterBase_0_0_5_0_arena: ... + def aos(self) -> ArrayOfStructs_0_0_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_arena: ... + def soa(self) -> StructOfArrays_5_0_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_default: ... + def __next__(self) -> ParIterBase_0_0_5_0_default: ... + def aos(self) -> ArrayOfStructs_0_0_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_default: ... + def soa(self) -> StructOfArrays_5_0_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_0_0_5_0_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_0_0_5_0_pinned: ... + def __next__(self) -> ParIterBase_0_0_5_0_pinned: ... + def aos(self) -> ArrayOfStructs_0_0_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_5_0_pinned: ... + def soa(self) -> StructOfArrays_5_0_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_arena: ... + def __next__(self) -> ParIterBase_1_1_2_1_arena: ... + def aos(self) -> ArrayOfStructs_1_1_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_arena: ... + def soa(self) -> StructOfArrays_2_1_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_default: ... + def __next__(self) -> ParIterBase_1_1_2_1_default: ... + def aos(self) -> ArrayOfStructs_1_1_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_default: ... + def soa(self) -> StructOfArrays_2_1_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_1_1_2_1_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_1_1_2_1_pinned: ... + def __next__(self) -> ParIterBase_1_1_2_1_pinned: ... + def aos(self) -> ArrayOfStructs_1_1_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_1_1_2_1_pinned: ... + def soa(self) -> StructOfArrays_2_1_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_arena(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_arena: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_arena: ... + def soa(self) -> StructOfArrays_8_2_arena: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_default(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_default: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_default: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_default: ... + def soa(self) -> StructOfArrays_8_2_default: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIterBase_pureSoA_8_2_pinned(MFIter): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __iter__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def __next__(self) -> ParIterBase_pureSoA_8_2_pinned: ... + def geom(self, level: int) -> Geometry: ... + def particle_tile(self) -> ParticleTile_0_0_8_2_pinned: ... + def soa(self) -> StructOfArrays_8_2_pinned: ... + @property + def level(self) -> int: ... + @property + def num_neighbor_particles(self) -> int: ... + @property + def num_particles(self) -> int: ... + @property + def num_real_particles(self) -> int: ... + @property + def pair_index(self) -> tuple[int, int]: ... + +class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): + is_soa_particle: typing.ClassVar[bool] # value = False + def __init__( + self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): + is_soa_particle: typing.ClassVar[bool] # value = True + def __init__( + self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int + ) -> None: ... + def __repr__(self) -> str: ... + +class ParmParse: + @staticmethod + def addfile(arg0: str) -> None: ... + def __init__(self, prefix: str = ...) -> None: ... + def __repr__(self) -> str: ... + @typing.overload + def add(self, arg0: str, arg1: bool) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: int) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: float) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: str) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: IntVect) -> None: ... + @typing.overload + def add(self, arg0: str, arg1: Box) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[int]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[float]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[str]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[IntVect]) -> None: ... + @typing.overload + def addarr(self, arg0: str, arg1: list[Box]) -> None: ... + def get_bool(self, name: str, ival: int = ...) -> bool: + """ + parses input values + """ + def get_int(self, name: str, ival: int = ...) -> int: + """ + parses input values + """ + def get_real(self, name: str, ival: int = ...) -> float: + """ + parses input values + """ + def query_int(self, name: str, ival: int = ...) -> tuple[bool, int]: + """ + queries input values + """ + def remove(self, arg0: str) -> int: ... + +class ParticleContainer_0_0_4_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_4_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 4 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_4_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_4_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_4_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_4_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_arena: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_default: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_0_0_5_0_pinned: + NArrayInt: typing.ClassVar[int] = 0 + NArrayReal: typing.ClassVar[int] = 5 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_5_0_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_0_0_5_0 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_0_0_5_0, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_0_0_5_0 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_arena: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_default: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_1_1_2_1_pinned: + NArrayInt: typing.ClassVar[int] = 1 + NArrayReal: typing.ClassVar[int] = 2 + NStructInt: typing.ClassVar[int] = 1 + NStructReal: typing.ClassVar[int] = 1 + is_soa_particle: typing.ClassVar[bool] # value = False + def AddParticlesAtLevel( + self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_1_1_2_1_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def InitOnePerCell( + self, arg0: float, arg1: float, arg2: float, arg3: ParticleInitType_1_1_2_1 + ) -> None: ... + def InitRandom( + self, + arg0: int, + arg1: int, + arg2: ParticleInitType_1_1_2_1, + arg3: bool, + arg4: RealBox, + ) -> None: ... + def InitRandomPerBox( + self, arg0: int, arg1: int, arg2: ParticleInitType_1_1_2_1 + ) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_arena: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_arena]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_default: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_default]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleContainer_pureSoA_8_2_pinned: + NArrayInt: typing.ClassVar[int] = 2 + NArrayReal: typing.ClassVar[int] = 8 + NStructInt: typing.ClassVar[int] = 0 + NStructReal: typing.ClassVar[int] = 0 + is_soa_particle: typing.ClassVar[bool] # value = True + def AddParticlesAtLevel( + self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... + ) -> None: ... + def ByteSpread(self) -> list[int[3]]: ... + @typing.overload + def Define( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def Define( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def GetParticles( + self, level: int + ) -> dict[tuple[int, int], ParticleTile_0_0_8_2_pinned]: ... + def Increment(self, arg0: MultiFab, arg1: int) -> None: ... + def NumberOfParticlesAtLevel( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + def NumberOfParticlesInGrid( + self, level: int, only_valid: bool = ..., only_local: bool = ... + ) -> Vector_Long: ... + def OK(self, lev_min: int = ..., lev_max: int = ..., nGrow: int = ...) -> bool: ... + def PrintCapacity(self) -> list[int[3]]: ... + def Redistribute( + self, + lev_min: int = ..., + lev_max: int = ..., + nGrow: int = ..., + local: int = ..., + remove_negative: bool = ..., + ) -> None: ... + def RemoveParticlesAtLevel(self, arg0: int) -> None: ... + def RemoveParticlesNotAtFinestLevel(self) -> None: ... + def ShrinkToFit(self) -> None: ... + def SortParticlesByBin(self, arg0: IntVect) -> None: ... + def SortParticlesByCell(self) -> None: ... + def TotalNumberOfParticles( + self, only_valid: bool = ..., only_local: bool = ... + ) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, arg0: Geometry, arg1: DistributionMapping, arg2: BoxArray + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_int, + ) -> None: ... + @typing.overload + def __init__( + self, + arg0: Vector_Geometry, + arg1: Vector_DistributionMapping, + arg2: Vector_BoxArray, + arg3: Vector_IntVect, + ) -> None: ... + def clearParticles(self) -> None: ... + def numLocalTilesAtLevel(self, arg0: int) -> int: ... + def reserveData(self) -> None: ... + def resizeData(self) -> None: ... + @property + def finest_level(self) -> int: ... + +class ParticleInitType_0_0_4_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[4]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_0_0_5_0: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[0]] + int_struct_data: list[int[0]] + real_array_data: list[float[5]] + real_struct_data: list[float[0]] + def __init__(self) -> None: ... + +class ParticleInitType_1_1_2_1: + is_soa_particle: typing.ClassVar[bool] # value = False + int_array_data: list[int[1]] + int_struct_data: list[int[1]] + real_array_data: list[float[2]] + real_struct_data: list[float[1]] + def __init__(self) -> None: ... + +class ParticleTileData_0_0_37_1: + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_37_1: ... + def setSuperParticle(self, arg0: Particle_37_1, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_4_0: + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_4_0: ... + def setSuperParticle(self, arg0: Particle_4_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_5_0: + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_5_0: ... + def setSuperParticle(self, arg0: Particle_5_0, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_0_0_8_2: + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_8_2: ... + def setSuperParticle(self, arg0: Particle_8_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTileData_1_1_2_1: + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def getSuperParticle(self, arg0: int) -> Particle_3_2: ... + def setSuperParticle(self, arg0: Particle_3_2, arg1: int) -> None: ... + @property + def m_num_runtime_int(self) -> int: ... + @property + def m_num_runtime_real(self) -> int: ... + @property + def m_size(self) -> int: ... + +class ParticleTile_0_0_37_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_arena) -> None: ... + +class ParticleTile_0_0_37_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_default) -> None: ... + +class ParticleTile_0_0_37_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 37 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_37_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_37_1: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_37_1) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_37_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_37_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[37]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_37_1_pinned) -> None: ... + +class ParticleTile_0_0_4_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_arena) -> None: ... + +class ParticleTile_0_0_4_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_default) -> None: ... + +class ParticleTile_0_0_4_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 4 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_4_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_4_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_4_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_4_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_4_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[4]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_4_0_pinned) -> None: ... + +class ParticleTile_0_0_5_0_arena: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_arena) -> None: ... + +class ParticleTile_0_0_5_0_default: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_default: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_default) -> None: ... + +class ParticleTile_0_0_5_0_pinned: + NAI: typing.ClassVar[int] = 0 + NAR: typing.ClassVar[int] = 5 + def GetArrayOfStructs(self) -> ArrayOfStructs_0_0_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_5_0_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_5_0: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_5_0) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_5_0: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_0_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_5_0) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[5]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_5_0_pinned) -> None: ... + +class ParticleTile_0_0_8_2_arena: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_arena) -> None: ... + +class ParticleTile_0_0_8_2_default: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_default) -> None: ... + +class ParticleTile_0_0_8_2_pinned: + NAI: typing.ClassVar[int] = 2 + NAR: typing.ClassVar[int] = 8 + def GetStructOfArrays(self) -> StructOfArrays_8_2_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_8_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_8_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_0_0_8_2: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def push_back(self, arg0: Particle_8_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[8]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_0_0_8_2_pinned) -> None: ... + +class ParticleTile_1_1_2_1_arena: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_arena: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_arena: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_arena) -> None: ... + +class ParticleTile_1_1_2_1_default: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_default: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_default: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_default) -> None: ... + +class ParticleTile_1_1_2_1_pinned: + NAI: typing.ClassVar[int] = 1 + NAR: typing.ClassVar[int] = 2 + def GetArrayOfStructs(self) -> ArrayOfStructs_1_1_pinned: ... + def GetStructOfArrays(self) -> StructOfArrays_2_1_pinned: ... + def NumIntComps(self) -> int: ... + def NumRealComps(self) -> int: ... + def NumRuntimeIntComps(self) -> int: ... + def NumRuntimeRealComps(self) -> int: ... + def __getitem__(self, arg0: int) -> Particle_3_2: ... + def __init__(self) -> None: ... + def __setitem__(self, arg0: int, arg1: Particle_3_2) -> None: ... + def capacity(self) -> int: ... + def define(self, arg0: int, arg1: int) -> None: ... + def empty(self) -> bool: ... + def getNumNeighbors(self) -> int: ... + def getParticleTileData(self) -> ParticleTileData_1_1_2_1: ... + def numNeighborParticles(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + @typing.overload + def push_back(self, arg0: Particle_1_1) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back(self, arg0: Particle_3_2) -> None: + """ + Add one particle to this tile. + """ + @typing.overload + def push_back_int(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def push_back_int(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def push_back_int(self, arg0: int, arg1: int, arg2: int) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def push_back_real(self, arg0: list[float[2]]) -> None: ... + @typing.overload + def push_back_real(self, arg0: int, arg1: int, arg2: float) -> None: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def shrink_to_fit(self) -> None: ... + def size(self) -> int: ... + def swap(self, arg0: ParticleTile_1_1_2_1_pinned) -> None: ... + +class Particle_0_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 0 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> None: ... + @typing.overload + def get_rdata(self) -> None: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[0]]) -> None: ... + +class Particle_1_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 1 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[1]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[1]]) -> None: ... + +class Particle_2_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 2 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[2]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[2]]) -> None: ... + +class Particle_37_1: + NInt: typing.ClassVar[int] = 1 + NReal: typing.ClassVar[int] = 37 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[1]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[37]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[1]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[37]]) -> None: ... + +class Particle_3_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 3 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[3]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[3]]) -> None: ... + +class Particle_4_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 4 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[4]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[4]]) -> None: ... + +class Particle_5_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 5 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[5]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[5]]) -> None: ... + +class Particle_7_0: + NInt: typing.ClassVar[int] = 0 + NReal: typing.ClassVar[int] = 7 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> None: ... + @typing.overload + def get_idata(self) -> None: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[7]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[0]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[7]]) -> None: ... + +class Particle_8_2: + NInt: typing.ClassVar[int] = 2 + NReal: typing.ClassVar[int] = 8 + x: float + y: float + z: float + @typing.overload + def NextID(self) -> int: ... + @typing.overload + def NextID(self, arg0: int) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, *args) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float, **kwargs) -> None: ... + @typing.overload + def __init__(self, **kwargs) -> None: ... + def __repr__(self) -> str: ... + def __str__(self) -> str: ... + def cpu(self) -> int: ... + @typing.overload + def get_idata(self, arg0: int) -> int: ... + @typing.overload + def get_idata(self) -> list[int[2]]: ... + @typing.overload + def get_rdata(self, arg0: int) -> float: ... + @typing.overload + def get_rdata(self) -> list[float[8]]: ... + def id(self) -> int: ... + @typing.overload + def pos(self, arg0: int) -> float: ... + @typing.overload + def pos(self) -> RealVect: ... + @typing.overload + def setPos(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def setPos(self, arg0: RealVect) -> None: ... + @typing.overload + def setPos(self, arg0: list[float[3]]) -> None: ... + @typing.overload + def set_idata(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def set_idata(self, arg0: IntVect) -> None: ... + @typing.overload + def set_idata(self, arg0: list[int[2]]) -> None: ... + @typing.overload + def set_rdata(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def set_rdata(self, arg0: RealVect) -> None: ... + @typing.overload + def set_rdata(self, arg0: list[float[8]]) -> None: ... + +class Periodicity: + __hash__: typing.ClassVar[None] = None + @staticmethod + def non_periodic() -> Periodicity: + """ + Return the Periodicity object that is not periodic in any direction + """ + def __eq__(self, arg0: Periodicity) -> bool: ... + def __getitem__(self, dir: int) -> bool: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + def __repr__(self) -> str: ... + def is_periodic(self, dir: int) -> bool: ... + @property + def domain(self) -> Box: + """ + Cell-centered domain Box "infinitely" long in non-periodic directions. + """ + @property + def is_all_periodic(self) -> bool: ... + @property + def is_any_periodic(self) -> bool: ... + @property + def shift_IntVect(self) -> list[IntVect]: ... + +class RealBox: + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__( + self, + x_lo: float, + y_lo: float, + z_lo: float, + x_hi: float, + y_hi: float, + z_hi: float, + ) -> None: ... + @typing.overload + def __init__(self, a_lo: list[float[3]], a_hi: list[float[3]]) -> None: ... + @typing.overload + def __init__(self, bx: Box, dx: list[float[3]], base: list[float[3]]) -> None: ... + def __repr__(self) -> str: ... + def __str(self) -> str: ... + @typing.overload + def contains(self, rb: XDim3, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealVect, eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: RealBox, eps: float = ...) -> bool: + """ + Determine if RealBox contains another RealBox, within tolerance ``eps`` + """ + @typing.overload + def contains(self, rb: list[float], eps: float = ...) -> bool: + """ + Determine if RealBox contains ``pt``, within tolerance ``eps`` + """ + @typing.overload + def hi(self, arg0: int) -> float: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def hi(self) -> list[float[3]]: + """ + Get all components of ``xhi`` + """ + def intersects(self, arg0: RealBox) -> bool: + """ + determine if box intersects with a box + """ + def length(self, arg0: int) -> float: ... + @typing.overload + def lo(self, arg0: int) -> float: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def lo(self) -> list[float[3]]: + """ + Get all components of ``xlo`` + """ + def ok(self) -> bool: + """ + Determine if RealBox satisfies ``xlo[i] None: + """ + Get all components of ``xlo`` + """ + @typing.overload + def setHi(self, arg0: int, arg1: float) -> None: + """ + Get ith component of ``xhi`` + """ + @typing.overload + def setLo(self, arg0: list[float]) -> None: + """ + Get ith component of ``xlo`` + """ + @typing.overload + def setLo(self, arg0: int, arg1: float) -> None: + """ + Get all components of ``xlo`` + """ + def volume(self) -> float: ... + @property + def xhi(self) -> list[float[3]]: ... + @property + def xlo(self) -> list[float[3]]: ... + +class RealVect: + __hash__: typing.ClassVar[None] = None + @staticmethod + def unit_vector() -> RealVect: ... + @staticmethod + def zero_vector() -> RealVect: ... + def BASISREALV(self) -> RealVect: + """ + return basis vector in given coordinate direction + """ + @typing.overload + def __add__(self, arg0: float) -> RealVect: ... + @typing.overload + def __add__(self, arg0: RealVect) -> RealVect: ... + def __eq__(self, arg0: RealVect) -> bool: ... + def __ge__(self, arg0: RealVect) -> bool: ... + def __getitem__(self, arg0: int) -> float: ... + def __gt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __iadd__(self, arg0: float) -> RealVect: ... + @typing.overload + def __iadd__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: float) -> RealVect: ... + @typing.overload + def __imul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + @typing.overload + def __init__(self, arg0: IntVect) -> None: ... + @typing.overload + def __init__(self, arg0: list[float]) -> None: ... + @typing.overload + def __init__(self, arg0: float) -> None: ... + @typing.overload + def __isub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __isub__(self, arg0: RealVect) -> RealVect: ... + def __itruediv__(self, arg0: float) -> RealVect: ... + def __le__(self, arg0: RealVect) -> bool: ... + def __lt__(self, arg0: RealVect) -> bool: ... + @typing.overload + def __mul__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __mul__(self, arg0: float) -> RealVect: ... + def __ne__(self, arg0: RealVect) -> bool: ... + def __neg__(self) -> RealVect: ... + def __pos__(self) -> RealVect: ... + def __radd__(self, arg0: float) -> RealVect: ... + def __repr__(self) -> str: ... + def __rmul__(self, arg0: float) -> RealVect: ... + def __rsub__(self, arg0: float) -> RealVect: ... + def __rtruediv__(self, arg0: float) -> RealVect: ... + def __setitem__(self, arg0: int, arg1: float) -> float: ... + def __str(self) -> str: ... + @typing.overload + def __sub__(self, arg0: RealVect) -> RealVect: ... + @typing.overload + def __sub__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: float) -> RealVect: ... + @typing.overload + def __truediv__(self, arg0: RealVect) -> RealVect: ... + def ceil(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::ceil of the vector components + """ + def crossProduct(self, arg0: RealVect) -> RealVect: + """ + Return cross product of this vector with another + """ + def dotProduct(self, arg0: RealVect) -> float: + """ + Return dot product of this vector with another + """ + def floor(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::floor of the vector components + """ + def max(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise maxima of this vector and another + """ + def maxDir(self, arg0: bool) -> int: + """ + direction or index of maximum value of this vector + """ + def min(self, arg0: RealVect) -> RealVect: + """ + Replace vector with the component-wise minima of this vector and another + """ + def minDir(self, arg0: bool) -> int: + """ + direction or index of minimum value of this vector + """ + def round(self) -> IntVect: + """ + Return an ``IntVect`` whose components are the std::round of the vector components + """ + def scale(self, arg0: float) -> RealVect: + """ + Multiplify each component of this vector by a scalar + """ + @property + def product(self) -> float: + """ + Product of entries of this vector + """ + @property + def radSquared(self) -> float: + """ + Length squared of this vector + """ + @property + def sum(self) -> float: + """ + Sum of the components of this vector + """ + @property + def vectorLength(self) -> float: + """ + Length or 2-Norm of this vector + """ + +class StructOfArrays_2_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_2_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[2]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_37_1_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[1]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[37]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_4_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[4]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_5_0_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[0]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[5]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_arena: + @typing.overload + def GetIntData(self) -> list[PODVector_int_arena[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_arena[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_arena: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_default: + @typing.overload + def GetIntData(self) -> list[PODVector_int_std[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_std[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_std: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class StructOfArrays_8_2_pinned: + @typing.overload + def GetIntData(self) -> list[PODVector_int_pinned[2]]: + """ + Get access to the particle Int Arrays (only compile-time components) + """ + @typing.overload + def GetIntData(self, index: int) -> PODVector_int_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + @typing.overload + def GetRealData(self) -> list[PODVector_real_pinned[8]]: + """ + Get access to the particle Real Arrays (only compile-time components) + """ + @typing.overload + def GetRealData(self, index: int) -> PODVector_real_pinned: + """ + Get access to a particle Real component Array (compile-time and runtime component) + """ + def NumIntComps(self) -> int: + """ + Get the number of compile-time + runtime Int components + """ + def NumRealComps(self) -> int: + """ + Get the number of compile-time + runtime Real components + """ + def __init__(self) -> None: ... + def __len__(self) -> int: + """ + Get the number of particles + """ + def define(self, arg0: int, arg1: int) -> None: ... + def getNumNeighbors(self) -> int: ... + def numParticles(self) -> int: ... + def numRealParticles(self) -> int: ... + def numTotalParticles(self) -> int: ... + def resize(self, arg0: int) -> None: ... + def setNumNeighbors(self, arg0: int) -> None: ... + def size(self) -> int: + """ + Get the number of particles + """ + +class Vector_BoxArray: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: BoxArray) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_BoxArray: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __getitem__(self, arg0: int) -> BoxArray: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_BoxArray) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_BoxArray) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_BoxArray) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: BoxArray) -> None: ... + def append(self, x: BoxArray) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: BoxArray) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_BoxArray) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: BoxArray) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> BoxArray: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> BoxArray: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: BoxArray) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_DistributionMapping: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: DistributionMapping) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_DistributionMapping: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __getitem__(self, arg0: int) -> DistributionMapping: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_DistributionMapping) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_DistributionMapping) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_DistributionMapping) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: DistributionMapping) -> None: ... + def append(self, x: DistributionMapping) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: DistributionMapping) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_DistributionMapping) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: DistributionMapping) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> DistributionMapping: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> DistributionMapping: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: DistributionMapping) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Geometry: + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + @typing.overload + def __getitem__(self, s: slice) -> Vector_Geometry: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __getitem__(self, arg0: int) -> Geometry: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Geometry) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Geometry) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: Geometry) -> None: ... + def append(self, x: Geometry) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + @typing.overload + def extend(self, L: Vector_Geometry) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: Geometry) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> Geometry: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> Geometry: + """ + Remove and return the item at index ``i`` + """ + def size(self) -> int: ... + +class Vector_IntVect: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: IntVect) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_IntVect: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __getitem__(self, arg0: int) -> IntVect: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_IntVect) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_IntVect) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_IntVect) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: IntVect) -> None: ... + def append(self, x: IntVect) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: IntVect) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_IntVect) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: IntVect) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> IntVect: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> IntVect: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: IntVect) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class Vector_Long: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Long: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Long) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Long) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Long) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Long) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_Real: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: float) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_Real: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __getitem__(self, arg0: int) -> float: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_Real) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_Real) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_Real) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: float) -> None: ... + def append(self, x: float) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: float) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_Real) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: float) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> float: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> float: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: float) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_int: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: int) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_int: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __getitem__(self, arg0: int) -> int: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_int) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_int) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_int) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: int) -> None: ... + def append(self, x: int) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: int) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_int) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: int) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> int: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> int: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: int) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + @property + def __array_interface__(self) -> dict: ... + @property + def __cuda_array_interface__(self) -> dict: ... + +class Vector_string: + __hash__: typing.ClassVar[None] = None + def __bool__(self) -> bool: + """ + Check whether the list is nonempty + """ + def __contains__(self, x: str) -> bool: + """ + Return true the container contains ``x`` + """ + @typing.overload + def __delitem__(self, arg0: int) -> None: + """ + Delete the list elements at index ``i`` + """ + @typing.overload + def __delitem__(self, arg0: slice) -> None: + """ + Delete list elements using a slice object + """ + def __eq__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __getitem__(self, s: slice) -> Vector_string: + """ + Retrieve list elements using a slice object + """ + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __getitem__(self, arg0: int) -> str: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: + """ + Copy constructor + """ + @typing.overload + def __init__(self, arg0: typing.Iterable) -> None: ... + @typing.overload + def __init__(self) -> None: ... + @typing.overload + def __init__(self, arg0: Vector_string) -> None: ... + def __iter__(self) -> typing.Iterator: ... + def __len__(self) -> int: ... + def __ne__(self, arg0: Vector_string) -> bool: ... + @typing.overload + def __repr__(self) -> str: + """ + Return the canonical string representation of this list. + """ + @typing.overload + def __repr__(self) -> str: ... + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + @typing.overload + def __setitem__(self, arg0: slice, arg1: Vector_string) -> None: + """ + Assign list elements using a slice object + """ + @typing.overload + def __setitem__(self, arg0: int, arg1: str) -> None: ... + def append(self, x: str) -> None: + """ + Add an item to the end of the list + """ + def clear(self) -> None: + """ + Clear the contents + """ + def count(self, x: str) -> int: + """ + Return the number of times ``x`` appears in the list + """ + @typing.overload + def extend(self, L: Vector_string) -> None: + """ + Extend the list by appending all the items in the given list + """ + @typing.overload + def extend(self, L: typing.Iterable) -> None: + """ + Extend the list by appending all the items in the given list + """ + def insert(self, i: int, x: str) -> None: + """ + Insert an item at a given position. + """ + @typing.overload + def pop(self) -> str: + """ + Remove and return the last item + """ + @typing.overload + def pop(self, i: int) -> str: + """ + Remove and return the item at index ``i`` + """ + def remove(self, x: str) -> None: + """ + Remove the first item from the list whose value is x. It is an error if there is no such item. + """ + def size(self) -> int: ... + +class XDim3: + x: float + y: float + z: float + def __init__(self, arg0: float, arg1: float, arg2: float) -> None: ... + +def AlmostEqual(rb1: RealBox, rb2: RealBox, eps: float = ...) -> bool: + """ + Determine if two boxes are equal to within a tolerance + """ + +def The_Arena() -> Arena: ... +def The_Async_Arena() -> Arena: ... +def The_Cpu_Arena() -> Arena: ... +def The_Device_Arena() -> Arena: ... +def The_Managed_Arena() -> Arena: ... +def The_Pinned_Arena() -> Arena: ... +def begin(arg0: Box) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: IntVect) -> IntVect: ... +@typing.overload +def coarsen(arg0: Dim3, arg1: IntVect) -> Dim3: ... +@typing.overload +def coarsen(arg0: IntVect, arg1: int) -> IntVect: ... +def concatenate(root: str, num: int, mindigits: int = ...) -> str: + """ + Builds plotfile name + """ + +@typing.overload +def dtoh_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def dtoh_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def end(arg0: Box) -> Dim3: ... +@typing.overload +def finalize() -> None: ... +@typing.overload +def finalize(arg0: AMReX) -> None: ... +@typing.overload +def htod_memcpy(dest: FabArray_FArrayBox, src: FabArray_FArrayBox) -> None: ... +@typing.overload +def htod_memcpy( + dest: FabArray_FArrayBox, + src: FabArray_FArrayBox, + scomp: int, + dcomp: int, + ncomp: int, +) -> None: ... +def initialize(arg0: list) -> AMReX: + """ + Initialize AMReX library + """ + +def initialized() -> bool: + """ + Returns true if there are any currently-active and initialized AMReX instances (i.e. one for which amrex::Initialize has been called, and amrex::Finalize has not). Otherwise false. + """ + +@typing.overload +def lbound(arg0: Box) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def lbound(arg0: Array4_ulonglong_const) -> Dim3: ... +@typing.overload +def length(arg0: Box) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def length(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def length(arg0: Array4_ulonglong_const) -> Dim3: ... +def max(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def min(arg0: RealVect, arg1: RealVect) -> RealVect: ... +def refine(arg0: Dim3, arg1: IntVect) -> Dim3: ... +def size() -> int: + """ + The amr stack size, the number of amr instances pushed. + """ + +@typing.overload +def ubound(arg0: Box) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_float_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_double_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longdouble_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_short_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_int_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_long_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_longlong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ushort_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_uint_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulong_const) -> Dim3: ... +@typing.overload +def ubound(arg0: Array4_ulonglong_const) -> Dim3: ... +def unpack_cpus(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def unpack_ids(arg0: numpy.ndarray[numpy.uint64]) -> typing.Any: ... +def write_single_level_plotfile( + plotfilename: str, + mf: MultiFab, + varnames: Vector_string, + geom: Geometry, + time: float, + level_step: int, + versionName: str = ..., + levelPrefix: str = ..., + mfPrefix: str = ..., + extra_dirs: Vector_string = ..., +) -> None: + """ + Writes single level plotfile + """ + +__author__: str = "Axel Huebl, Ryan T. Sandberg, Shreyas Ananthan, David P. Grote, Revathi Jambunathan, Edoardo Zoni, Remi Lehe, Andrew Myers, Weiqun Zhang" +__license__: str = "BSD-3-Clause-LBNL" +__version__: str = "23.08" From ea0328edb2a5405a75ad413f76d31a4d14a18905 Mon Sep 17 00:00:00 2001 From: Axel Huebl Date: Fri, 1 Sep 2023 01:44:00 -0700 Subject: [PATCH 4/6] CI: Stub-Update Last Since bot pushes to not trigger CI reruns for GH Actions. --- .github/workflows/ci.yml | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 37a1485e..0ecbcdd6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -9,26 +9,27 @@ concurrency: cancel-in-progress: true jobs: - stubs: - name: 🔄 Update Stub Files - uses: ./.github/workflows/stubs.yml ubuntu: name: 🐧 Ubuntu - needs: stubs uses: ./.github/workflows/ubuntu.yml + intel: name: 🐧 Intel - needs: stubs uses: ./.github/workflows/intel.yml + hip: name: 🐧 HIP - needs: stubs uses: ./.github/workflows/hip.yml + macos: name: 🍏 macOS - needs: stubs uses: ./.github/workflows/macos.yml + windows: name: 🪟 Windows - needs: stubs uses: ./.github/workflows/windows.yml + + stubs: + name: 🔄 Update Stub Files + needs: [ubuntu, intel, hip, macos, windows] + uses: ./.github/workflows/stubs.yml From acf47b67b2c2584381927b70182cd058a63b8dad Mon Sep 17 00:00:00 2001 From: Axel Huebl Date: Fri, 1 Sep 2023 09:31:49 -0700 Subject: [PATCH 5/6] Fix using in headers --- src/Base/Vector.H | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Base/Vector.H b/src/Base/Vector.H index 043b433b..85539237 100644 --- a/src/Base/Vector.H +++ b/src/Base/Vector.H @@ -9,6 +9,7 @@ #include +#include #include #include #include @@ -18,15 +19,13 @@ namespace { - using namespace amrex; - /** CPU: __array_interface__ v3 * * https://numpy.org/doc/stable/reference/arrays.interface.html */ template > py::dict - array_interface(Vector const & vector) + array_interface(amrex::Vector const & vector) { auto d = py::dict(); bool const read_only = false; From 88bd6a56d6da9412694be7ea6b5c5a1b16f3c617 Mon Sep 17 00:00:00 2001 From: ax3l Date: Fri, 1 Sep 2023 18:06:20 +0000 Subject: [PATCH 6/6] Update Stub Files --- .../space1d/amrex_1d_pybind/__init__.pyi | 132 +++++++++--------- .../space2d/amrex_2d_pybind/__init__.pyi | 132 +++++++++--------- .../space3d/amrex_3d_pybind/__init__.pyi | 132 +++++++++--------- 3 files changed, 198 insertions(+), 198 deletions(-) diff --git a/src/amrex/space1d/amrex_1d_pybind/__init__.pyi b/src/amrex/space1d/amrex_1d_pybind/__init__.pyi index 9a2f1363..8a2ebf48 100644 --- a/src/amrex/space1d/amrex_1d_pybind/__init__.pyi +++ b/src/amrex/space1d/amrex_1d_pybind/__init__.pyi @@ -1470,9 +1470,9 @@ class BoxArray: class Config: amrex_version: typing.ClassVar[str] = "23.08" gpu_backend = None - have_gpu: typing.ClassVar[bool] # value = False - have_mpi: typing.ClassVar[bool] # value = True - have_omp: typing.ClassVar[bool] # value = False + have_gpu: typing.ClassVar[bool] = False + have_mpi: typing.ClassVar[bool] = True + have_omp: typing.ClassVar[bool] = False spacedim: typing.ClassVar[int] = 1 verbose: typing.ClassVar[int] = 1 @@ -2586,7 +2586,7 @@ class PODVector_real_std: def __cuda_array_interface__(self) -> dict: ... class ParConstIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2608,7 +2608,7 @@ class ParConstIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2630,7 +2630,7 @@ class ParConstIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -2652,7 +2652,7 @@ class ParConstIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -2674,7 +2674,7 @@ class ParConstIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -2696,7 +2696,7 @@ class ParConstIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -2718,7 +2718,7 @@ class ParConstIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -2740,7 +2740,7 @@ class ParConstIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -2762,7 +2762,7 @@ class ParConstIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -2784,7 +2784,7 @@ class ParConstIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -2805,7 +2805,7 @@ class ParConstIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -2826,7 +2826,7 @@ class ParConstIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -2847,91 +2847,91 @@ class ParConstIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2953,7 +2953,7 @@ class ParIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2975,7 +2975,7 @@ class ParIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -2997,7 +2997,7 @@ class ParIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -3019,7 +3019,7 @@ class ParIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -3041,7 +3041,7 @@ class ParIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -3063,7 +3063,7 @@ class ParIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -3085,7 +3085,7 @@ class ParIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -3107,7 +3107,7 @@ class ParIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -3129,7 +3129,7 @@ class ParIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -3150,7 +3150,7 @@ class ParIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -3171,7 +3171,7 @@ class ParIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3192,84 +3192,84 @@ class ParIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3337,7 +3337,7 @@ class ParticleContainer_0_0_4_0_arena: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3438,7 +3438,7 @@ class ParticleContainer_0_0_4_0_default: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3539,7 +3539,7 @@ class ParticleContainer_0_0_4_0_pinned: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3640,7 +3640,7 @@ class ParticleContainer_0_0_5_0_arena: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3741,7 +3741,7 @@ class ParticleContainer_0_0_5_0_default: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3842,7 +3842,7 @@ class ParticleContainer_0_0_5_0_pinned: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3943,7 +3943,7 @@ class ParticleContainer_1_1_2_1_arena: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4044,7 +4044,7 @@ class ParticleContainer_1_1_2_1_default: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... ) -> None: ... @@ -4145,7 +4145,7 @@ class ParticleContainer_1_1_2_1_pinned: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4246,7 +4246,7 @@ class ParticleContainer_pureSoA_8_2_arena: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4333,7 +4333,7 @@ class ParticleContainer_pureSoA_8_2_default: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... ) -> None: ... @@ -4420,7 +4420,7 @@ class ParticleContainer_pureSoA_8_2_pinned: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4503,7 +4503,7 @@ class ParticleContainer_pureSoA_8_2_pinned: def finest_level(self) -> int: ... class ParticleInitType_0_0_4_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[4]] @@ -4511,7 +4511,7 @@ class ParticleInitType_0_0_4_0: def __init__(self) -> None: ... class ParticleInitType_0_0_5_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[5]] @@ -4519,7 +4519,7 @@ class ParticleInitType_0_0_5_0: def __init__(self) -> None: ... class ParticleInitType_1_1_2_1: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[1]] int_struct_data: list[int[1]] real_array_data: list[float[2]] diff --git a/src/amrex/space2d/amrex_2d_pybind/__init__.pyi b/src/amrex/space2d/amrex_2d_pybind/__init__.pyi index ce738715..40d7f7f4 100644 --- a/src/amrex/space2d/amrex_2d_pybind/__init__.pyi +++ b/src/amrex/space2d/amrex_2d_pybind/__init__.pyi @@ -1470,9 +1470,9 @@ class BoxArray: class Config: amrex_version: typing.ClassVar[str] = "23.08" gpu_backend = None - have_gpu: typing.ClassVar[bool] # value = False - have_mpi: typing.ClassVar[bool] # value = True - have_omp: typing.ClassVar[bool] # value = False + have_gpu: typing.ClassVar[bool] = False + have_mpi: typing.ClassVar[bool] = True + have_omp: typing.ClassVar[bool] = False spacedim: typing.ClassVar[int] = 2 verbose: typing.ClassVar[int] = 1 @@ -2592,7 +2592,7 @@ class PODVector_real_std: def __cuda_array_interface__(self) -> dict: ... class ParConstIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2614,7 +2614,7 @@ class ParConstIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2636,7 +2636,7 @@ class ParConstIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -2658,7 +2658,7 @@ class ParConstIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -2680,7 +2680,7 @@ class ParConstIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -2702,7 +2702,7 @@ class ParConstIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -2724,7 +2724,7 @@ class ParConstIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -2746,7 +2746,7 @@ class ParConstIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -2768,7 +2768,7 @@ class ParConstIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -2790,7 +2790,7 @@ class ParConstIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -2811,7 +2811,7 @@ class ParConstIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -2832,7 +2832,7 @@ class ParConstIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -2853,91 +2853,91 @@ class ParConstIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2959,7 +2959,7 @@ class ParIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2981,7 +2981,7 @@ class ParIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -3003,7 +3003,7 @@ class ParIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -3025,7 +3025,7 @@ class ParIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -3047,7 +3047,7 @@ class ParIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -3069,7 +3069,7 @@ class ParIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -3091,7 +3091,7 @@ class ParIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -3113,7 +3113,7 @@ class ParIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -3135,7 +3135,7 @@ class ParIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -3156,7 +3156,7 @@ class ParIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -3177,7 +3177,7 @@ class ParIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3198,84 +3198,84 @@ class ParIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3343,7 +3343,7 @@ class ParticleContainer_0_0_4_0_arena: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3444,7 +3444,7 @@ class ParticleContainer_0_0_4_0_default: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3545,7 +3545,7 @@ class ParticleContainer_0_0_4_0_pinned: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3646,7 +3646,7 @@ class ParticleContainer_0_0_5_0_arena: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3747,7 +3747,7 @@ class ParticleContainer_0_0_5_0_default: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3848,7 +3848,7 @@ class ParticleContainer_0_0_5_0_pinned: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3949,7 +3949,7 @@ class ParticleContainer_1_1_2_1_arena: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4050,7 +4050,7 @@ class ParticleContainer_1_1_2_1_default: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... ) -> None: ... @@ -4151,7 +4151,7 @@ class ParticleContainer_1_1_2_1_pinned: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4252,7 +4252,7 @@ class ParticleContainer_pureSoA_8_2_arena: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4339,7 +4339,7 @@ class ParticleContainer_pureSoA_8_2_default: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... ) -> None: ... @@ -4426,7 +4426,7 @@ class ParticleContainer_pureSoA_8_2_pinned: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4509,7 +4509,7 @@ class ParticleContainer_pureSoA_8_2_pinned: def finest_level(self) -> int: ... class ParticleInitType_0_0_4_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[4]] @@ -4517,7 +4517,7 @@ class ParticleInitType_0_0_4_0: def __init__(self) -> None: ... class ParticleInitType_0_0_5_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[5]] @@ -4525,7 +4525,7 @@ class ParticleInitType_0_0_5_0: def __init__(self) -> None: ... class ParticleInitType_1_1_2_1: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[1]] int_struct_data: list[int[1]] real_array_data: list[float[2]] diff --git a/src/amrex/space3d/amrex_3d_pybind/__init__.pyi b/src/amrex/space3d/amrex_3d_pybind/__init__.pyi index 2aa9e15e..4504471d 100644 --- a/src/amrex/space3d/amrex_3d_pybind/__init__.pyi +++ b/src/amrex/space3d/amrex_3d_pybind/__init__.pyi @@ -1470,9 +1470,9 @@ class BoxArray: class Config: amrex_version: typing.ClassVar[str] = "23.08" gpu_backend = None - have_gpu: typing.ClassVar[bool] # value = False - have_mpi: typing.ClassVar[bool] # value = True - have_omp: typing.ClassVar[bool] # value = False + have_gpu: typing.ClassVar[bool] = False + have_mpi: typing.ClassVar[bool] = True + have_omp: typing.ClassVar[bool] = False spacedim: typing.ClassVar[int] = 3 verbose: typing.ClassVar[int] = 1 @@ -2595,7 +2595,7 @@ class PODVector_real_std: def __cuda_array_interface__(self) -> dict: ... class ParConstIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2617,7 +2617,7 @@ class ParConstIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2639,7 +2639,7 @@ class ParConstIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -2661,7 +2661,7 @@ class ParConstIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -2683,7 +2683,7 @@ class ParConstIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -2705,7 +2705,7 @@ class ParConstIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -2727,7 +2727,7 @@ class ParConstIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -2749,7 +2749,7 @@ class ParConstIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -2771,7 +2771,7 @@ class ParConstIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -2793,7 +2793,7 @@ class ParConstIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -2814,7 +2814,7 @@ class ParConstIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -2835,7 +2835,7 @@ class ParConstIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -2856,91 +2856,91 @@ class ParConstIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParConstIter_0_0_4_0_arena(ParConstIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_default(ParConstIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_4_0_pinned(ParConstIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_arena(ParConstIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_default(ParConstIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_0_0_5_0_pinned(ParConstIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_arena(ParConstIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_default(ParConstIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_1_1_2_1_pinned(ParConstIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_arena(ParConstIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_default(ParConstIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParConstIter_pureSoA_8_2_pinned(ParConstIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIterBase_0_0_4_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... @@ -2962,7 +2962,7 @@ class ParIterBase_0_0_4_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... @@ -2984,7 +2984,7 @@ class ParIterBase_0_0_4_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_4_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... @@ -3006,7 +3006,7 @@ class ParIterBase_0_0_4_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... @@ -3028,7 +3028,7 @@ class ParIterBase_0_0_5_0_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... @@ -3050,7 +3050,7 @@ class ParIterBase_0_0_5_0_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_0_0_5_0_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... @@ -3072,7 +3072,7 @@ class ParIterBase_0_0_5_0_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... @@ -3094,7 +3094,7 @@ class ParIterBase_1_1_2_1_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... @@ -3116,7 +3116,7 @@ class ParIterBase_1_1_2_1_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_1_1_2_1_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... @@ -3138,7 +3138,7 @@ class ParIterBase_1_1_2_1_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_arena(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... @@ -3159,7 +3159,7 @@ class ParIterBase_pureSoA_8_2_arena(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_default(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... @@ -3180,7 +3180,7 @@ class ParIterBase_pureSoA_8_2_default(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIterBase_pureSoA_8_2_pinned(MFIter): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3201,84 +3201,84 @@ class ParIterBase_pureSoA_8_2_pinned(MFIter): def pair_index(self) -> tuple[int, int]: ... class ParIter_0_0_4_0_arena(ParIterBase_0_0_4_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_default(ParIterBase_0_0_4_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_4_0_pinned(ParIterBase_0_0_4_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_4_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_arena(ParIterBase_0_0_5_0_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_default(ParIterBase_0_0_5_0_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_0_0_5_0_pinned(ParIterBase_0_0_5_0_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_0_0_5_0_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_arena(ParIterBase_1_1_2_1_arena): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_default(ParIterBase_1_1_2_1_default): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_1_1_2_1_pinned(ParIterBase_1_1_2_1_pinned): - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def __init__( self, particle_container: ParticleContainer_1_1_2_1_pinned, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_arena(ParIterBase_pureSoA_8_2_arena): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_arena, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_default(ParIterBase_pureSoA_8_2_default): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_default, level: int ) -> None: ... def __repr__(self) -> str: ... class ParIter_pureSoA_8_2_pinned(ParIterBase_pureSoA_8_2_pinned): - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def __init__( self, particle_container: ParticleContainer_pureSoA_8_2_pinned, level: int ) -> None: ... @@ -3346,7 +3346,7 @@ class ParticleContainer_0_0_4_0_arena: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3447,7 +3447,7 @@ class ParticleContainer_0_0_4_0_default: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3548,7 +3548,7 @@ class ParticleContainer_0_0_4_0_pinned: NArrayReal: typing.ClassVar[int] = 4 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_4_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3649,7 +3649,7 @@ class ParticleContainer_0_0_5_0_arena: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_arena, level: int, ngrow: int = ... ) -> None: ... @@ -3750,7 +3750,7 @@ class ParticleContainer_0_0_5_0_default: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_default, level: int, ngrow: int = ... ) -> None: ... @@ -3851,7 +3851,7 @@ class ParticleContainer_0_0_5_0_pinned: NArrayReal: typing.ClassVar[int] = 5 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_0_0_5_0_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -3952,7 +3952,7 @@ class ParticleContainer_1_1_2_1_arena: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4053,7 +4053,7 @@ class ParticleContainer_1_1_2_1_default: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_default, level: int, ngrow: int = ... ) -> None: ... @@ -4154,7 +4154,7 @@ class ParticleContainer_1_1_2_1_pinned: NArrayReal: typing.ClassVar[int] = 2 NStructInt: typing.ClassVar[int] = 1 NStructReal: typing.ClassVar[int] = 1 - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False def AddParticlesAtLevel( self, particles: ParticleTile_1_1_2_1_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4255,7 +4255,7 @@ class ParticleContainer_pureSoA_8_2_arena: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_arena, level: int, ngrow: int = ... ) -> None: ... @@ -4342,7 +4342,7 @@ class ParticleContainer_pureSoA_8_2_default: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_default, level: int, ngrow: int = ... ) -> None: ... @@ -4429,7 +4429,7 @@ class ParticleContainer_pureSoA_8_2_pinned: NArrayReal: typing.ClassVar[int] = 8 NStructInt: typing.ClassVar[int] = 0 NStructReal: typing.ClassVar[int] = 0 - is_soa_particle: typing.ClassVar[bool] # value = True + is_soa_particle: typing.ClassVar[bool] = True def AddParticlesAtLevel( self, particles: ParticleTile_0_0_8_2_pinned, level: int, ngrow: int = ... ) -> None: ... @@ -4512,7 +4512,7 @@ class ParticleContainer_pureSoA_8_2_pinned: def finest_level(self) -> int: ... class ParticleInitType_0_0_4_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[4]] @@ -4520,7 +4520,7 @@ class ParticleInitType_0_0_4_0: def __init__(self) -> None: ... class ParticleInitType_0_0_5_0: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[0]] int_struct_data: list[int[0]] real_array_data: list[float[5]] @@ -4528,7 +4528,7 @@ class ParticleInitType_0_0_5_0: def __init__(self) -> None: ... class ParticleInitType_1_1_2_1: - is_soa_particle: typing.ClassVar[bool] # value = False + is_soa_particle: typing.ClassVar[bool] = False int_array_data: list[int[1]] int_struct_data: list[int[1]] real_array_data: list[float[2]]