diff --git a/bindings/pyfiction/include/pyfiction/algorithms/physical_design/design_sidb_gates.hpp b/bindings/pyfiction/include/pyfiction/algorithms/physical_design/design_sidb_gates.hpp index 67fc69de8..46da8d289 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/physical_design/design_sidb_gates.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/physical_design/design_sidb_gates.hpp @@ -23,27 +23,18 @@ namespace detail template void design_sidb_gates(pybind11::module& m) -{ - using namespace pybind11::literals; - - m.def("design_sidb_gates", &fiction::design_sidb_gates, "skeleton"_a, "spec"_a, - "params"_a = fiction::design_sidb_gates_params{}, DOC(fiction_design_sidb_gates)); -} - -} // namespace detail - -inline void design_sidb_gates(pybind11::module& m) { namespace py = pybind11; + using namespace py::literals; /** * Design approach selector type. */ - pybind11::enum_( + pybind11::enum_::design_sidb_gates_mode>( m, "design_sidb_gates_mode", DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode)) - .value("EXHAUSTIVE", fiction::design_sidb_gates_params::design_sidb_gates_mode::EXHAUSTIVE, + .value("EXHAUSTIVE", fiction::design_sidb_gates_params::design_sidb_gates_mode::EXHAUSTIVE, DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_EXHAUSTIVE)) - .value("RANDOM", fiction::design_sidb_gates_params::design_sidb_gates_mode::RANDOM, + .value("RANDOM", fiction::design_sidb_gates_params::design_sidb_gates_mode::RANDOM, DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_RANDOM)) ; @@ -51,22 +42,31 @@ inline void design_sidb_gates(pybind11::module& m) /** * Parameters. */ - py::class_(m, "design_sidb_gates_params", DOC(fiction_design_sidb_gates_params)) + py::class_>(m, "design_sidb_gates_params", + DOC(fiction_design_sidb_gates_params)) .def(py::init<>()) - .def_readwrite("phys_params", &fiction::design_sidb_gates_params::phys_params, + .def_readwrite("phys_params", &fiction::design_sidb_gates_params::phys_params, DOC(fiction_design_sidb_gates_params_phys_params)) - .def_readwrite("design_mode", &fiction::design_sidb_gates_params::design_mode, + .def_readwrite("design_mode", &fiction::design_sidb_gates_params::design_mode, DOC(fiction_design_sidb_gates_params_design_mode)) - .def_readwrite("canvas", &fiction::design_sidb_gates_params::canvas, + .def_readwrite("canvas", &fiction::design_sidb_gates_params::canvas, DOC(fiction_design_sidb_gates_params_canvas)) - .def_readwrite("number_of_sidbs", &fiction::design_sidb_gates_params::number_of_sidbs, + .def_readwrite("number_of_sidbs", &fiction::design_sidb_gates_params::number_of_sidbs, DOC(fiction_design_sidb_gates_params_number_of_sidbs)) - .def_readwrite("sim_engine", &fiction::design_sidb_gates_params::sim_engine, + .def_readwrite("sim_engine", &fiction::design_sidb_gates_params::sim_engine, DOC(fiction_design_sidb_gates_params_sim_engine)) ; - detail::design_sidb_gates(m); + m.def("design_sidb_gates", &fiction::design_sidb_gates, "skeleton"_a, "spec"_a, + "params"_a = fiction::design_sidb_gates_params{}, DOC(fiction_design_sidb_gates)); +} + +} // namespace detail + +inline void design_sidb_gates(pybind11::module& m) +{ + detail::design_sidb_gates(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp index 850a7625a..41e0306ac 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp @@ -84,7 +84,7 @@ inline void assess_physical_population_stability(pybind11::module& m) // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::assess_physical_population_stability(m); + detail::assess_physical_population_stability(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp index 94af25c3b..39f2b4266 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp @@ -24,12 +24,8 @@ void exhaustive_ground_state_simulation(pybind11::module& m) { using namespace pybind11::literals; - m.def( - "exhaustive_ground_state_simulation", - [](const Lyt& lyt, - const fiction::sidb_simulation_parameters& params) -> fiction::sidb_simulation_result - { return fiction::exhaustive_ground_state_simulation(lyt, params); }, - "lyt"_a, "params"_a = fiction::sidb_simulation_parameters{}, DOC(fiction_exhaustive_ground_state_simulation)); + m.def("exhaustive_ground_state_simulation", &fiction::exhaustive_ground_state_simulation, "lyt"_a, + "params"_a = fiction::sidb_simulation_parameters{}, DOC(fiction_exhaustive_ground_state_simulation)); } } // namespace detail @@ -38,7 +34,7 @@ inline void exhaustive_ground_state_simulation(pybind11::module& m) { // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::exhaustive_ground_state_simulation(m); + detail::exhaustive_ground_state_simulation(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quickexact.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quickexact.hpp index ebd9f1e25..3f3987ee2 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quickexact.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quickexact.hpp @@ -50,21 +50,8 @@ void quickexact(pybind11::module& m) ; - m.def( - "quickexact", - [](const Lyt& lyt, - const typename fiction::quickexact_params& params) -> fiction::sidb_simulation_result - { - fiction::quickexact_params converted_params{ - params.physical_parameters, - params.base_number_detection == fiction::quickexact_params::automatic_base_number_detection::ON ? - fiction::quickexact_params::automatic_base_number_detection::ON : - fiction::quickexact_params::automatic_base_number_detection::OFF, - params.local_external_potential, params.global_potential}; - - return fiction::quickexact(lyt, converted_params); - }, - "lyt"_a, "params"_a = fiction::quickexact_params{}, DOC(fiction_quickexact)); + m.def("quickexact", &fiction::quickexact, "lyt"_a, "params"_a = fiction::quickexact_params{}, + DOC(fiction_quickexact)); } } // namespace detail @@ -73,7 +60,7 @@ inline void quickexact(pybind11::module& m) { // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::quickexact(m); + detail::quickexact(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quicksim.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quicksim.hpp index dbcd8e73a..014809296 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quicksim.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/quicksim.hpp @@ -24,11 +24,7 @@ void quicksim(pybind11::module& m) { using namespace pybind11::literals; - m.def( - "quicksim", - [](const Lyt& lyt, const fiction::quicksim_params& params) -> fiction::sidb_simulation_result - { return fiction::quicksim(lyt, params); }, - "lyt"_a, "params"_a = fiction::quicksim_params{}, DOC(fiction_quicksim)); + m.def("quicksim", &fiction::quicksim, "lyt"_a, "params"_a = fiction::quicksim_params{}, DOC(fiction_quicksim)); } } // namespace detail @@ -53,7 +49,7 @@ inline void quicksim(pybind11::module& m) // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::quicksim(m); + detail::quicksim(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp index d4ea6b208..3758ff8ca 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp @@ -71,7 +71,7 @@ inline void random_sidb_layout_generator(pybind11::module& m) { // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::random_sidb_layout_generator(m); + detail::random_sidb_layout_generator(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/sidb_simulation_result.hpp b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/sidb_simulation_result.hpp index f8fc378ef..bf235b5a4 100644 --- a/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/sidb_simulation_result.hpp +++ b/bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/sidb_simulation_result.hpp @@ -49,7 +49,7 @@ inline void sidb_simulation_result(pybind11::module& m) { // NOTE be careful with the order of the following calls! Python will resolve the first matching overload! - detail::sidb_simulation_result(m); + detail::sidb_simulation_result(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/inout/write_location_and_ground_state.hpp b/bindings/pyfiction/include/pyfiction/inout/write_location_and_ground_state.hpp index 6a7f9b395..2c1474e14 100644 --- a/bindings/pyfiction/include/pyfiction/inout/write_location_and_ground_state.hpp +++ b/bindings/pyfiction/include/pyfiction/inout/write_location_and_ground_state.hpp @@ -9,10 +9,12 @@ #include "pyfiction/types.hpp" #include +#include #include #include +#include namespace pyfiction { @@ -27,16 +29,16 @@ void write_location_and_ground_state(pybind11::module& m) m.def( "write_location_and_ground_state", - [](const fiction::sidb_simulation_result& lyt, const std::string_view& filename) - { fiction::write_location_and_ground_state(lyt, filename); }, - "layout"_a, "filename"_a, DOC(fiction_write_location_and_ground_state)); + [](const fiction::sidb_simulation_result& sim_result, const std::string_view& filename) + { fiction::write_location_and_ground_state(sim_result, filename); }, + "sim_result"_a, "filename"_a, DOC(fiction_write_location_and_ground_state)); } } // namespace detail inline void write_location_and_ground_state(pybind11::module& m) { - detail::write_location_and_ground_state(m); + detail::write_location_and_ground_state(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/inout/write_sqd_sim_result.hpp b/bindings/pyfiction/include/pyfiction/inout/write_sqd_sim_result.hpp index 65eb9e090..d95f4f272 100644 --- a/bindings/pyfiction/include/pyfiction/inout/write_sqd_sim_result.hpp +++ b/bindings/pyfiction/include/pyfiction/inout/write_sqd_sim_result.hpp @@ -36,7 +36,7 @@ void write_sqd_sim_result(pybind11::module& m) inline void write_sqd_sim_result(pybind11::module& m) { - detail::write_sqd_sim_result(m); + detail::write_sqd_sim_result(m); } } // namespace pyfiction diff --git a/bindings/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp b/bindings/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp index bbb4646ef..36bd109e1 100644 --- a/bindings/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp +++ b/bindings/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp @@ -65,96 +65,18 @@ inline void charge_distribution_surface(pybind11::module& m) /** * Charge distribution surface. - * - * @note The charge_distribution_type in pyfiction must be viewed as a stand-alone type. It does not inherit from - * any other existing pyfiction types. Therefore, it does not implement functions of lower level layout types. */ - py::class_(m, "charge_distribution_surface", - DOC(fiction_charge_distribution_surface)) + py::class_(m, "charge_distribution_surface", + DOC(fiction_charge_distribution_surface)) .def(py::init(), "params"_a = fiction::sidb_simulation_parameters{}, "cs"_a = fiction::sidb_charge_state::NEGATIVE) - .def(py::init(), "lyt"_a, "params"_a = fiction::sidb_simulation_parameters{}, "cs"_a = fiction::sidb_charge_state::NEGATIVE) .def(py::init(), "lyt"_a) - .def(py::init( - [](const py_sidb_layout& layout, - const fiction::sidb_simulation_parameters& params = fiction::sidb_simulation_parameters{}, - const fiction::sidb_charge_state& cs = fiction::sidb_charge_state::NEGATIVE) - { - auto converted_layout = fiction::convert_to_siqad_coordinates(layout); - return fiction::charge_distribution_surface(converted_layout, params, cs); - }), - "layout"_a, "params"_a = fiction::sidb_simulation_parameters{}, - "cs"_a = fiction::sidb_charge_state::NEGATIVE) - - .def( - "x", [](const py_charge_distribution_surface& lyt) { return lyt.x(); }, DOC(fiction_cartesian_layout_x)) - .def( - "y", [](const py_charge_distribution_surface& lyt) { return lyt.y(); }, DOC(fiction_cartesian_layout_y)) - .def( - "z", [](const py_charge_distribution_surface& lyt) { return lyt.z(); }, DOC(fiction_cartesian_layout_z)) - .def( - "area", [](const py_charge_distribution_surface& lyt) { return lyt.area(); }, - DOC(fiction_cartesian_layout_area)) - .def( - "resize", - [](py_charge_distribution_surface& lyt, const py_siqad_coordinate& dimension) { lyt.resize(dimension); }, - "dimension"_a, DOC(fiction_cartesian_layout_resize)) - - .def( - "get_cell_type", - [](const py_charge_distribution_surface& lyt, const fiction::cell& c) - { return lyt.get_cell_type(c); }, - "c"_a, DOC(fiction_cell_level_layout_get_cell_type)) - .def( - "is_empty_cell", - [](const py_charge_distribution_surface& lyt, const fiction::cell& c) - { return lyt.is_empty_cell(c); }, - "c"_a, DOC(fiction_cell_level_layout_is_empty_cell)) - .def( - "assign_cell_name", - [](py_charge_distribution_surface& lyt, const fiction::cell& c, - const std::string& n) { lyt.assign_cell_name(c, n); }, - "c"_a, "n"_a, DOC(fiction_cell_level_layout_assign_cell_name)) - .def( - "get_cell_name", - [](const py_charge_distribution_surface& lyt, const fiction::cell& c) - { return lyt.get_cell_name(c); }, - "c"_a, DOC(fiction_cell_level_layout_get_cell_name)) - .def( - "set_layout_name", - [](py_charge_distribution_surface& lyt, const std::string& name) { lyt.set_layout_name(name); }, "name"_a, - DOC(fiction_cell_level_layout_set_layout_name)) - .def( - "get_layout_name", [](const py_charge_distribution_surface& lyt) { return lyt.get_layout_name(); }, - DOC(fiction_cell_level_layout_get_layout_name)) - .def( - "num_cells", [](const py_charge_distribution_surface& lyt) { return lyt.num_cells(); }, - DOC(fiction_cell_level_layout_num_cells)) - .def( - "is_empty", [](const py_charge_distribution_surface& lyt) { return lyt.is_empty(); }, - DOC(fiction_cell_level_layout_is_empty)) - .def( - "num_pis", [](const py_charge_distribution_surface& lyt) { return lyt.num_pis(); }, - DOC(fiction_cell_level_layout_num_pis)) - .def( - "num_pos", [](const py_charge_distribution_surface& lyt) { return lyt.num_pos(); }, - DOC(fiction_cell_level_layout_num_pos)) - .def( - "is_pi", - [](const py_charge_distribution_surface& lyt, const fiction::cell& c) - { return lyt.is_pi(c); }, - "c"_a, DOC(fiction_cell_level_layout_is_pi)) - .def( - "is_po", - [](const py_charge_distribution_surface& lyt, const fiction::cell& c) - { return lyt.is_po(c); }, - "c"_a, DOC(fiction_cell_level_layout_is_po)) - .def("get_all_sidb_locations_in_nm", &py_charge_distribution_surface::get_all_sidb_locations_in_nm) .def("assign_cell_type", &py_charge_distribution_surface::assign_cell_type, "c"_a, "ct"_a) .def("assign_physical_parameters", &py_charge_distribution_surface::assign_physical_parameters, "params"_a) @@ -290,7 +212,7 @@ inline void charge_distribution_surface(pybind11::module& m) .def( "is_within_bounds", - [](const py_charge_distribution_surface& lyt, const py_siqad_coordinate& c) + [](const py_charge_distribution_surface& lyt, const fiction::coordinate& c) { return lyt.is_within_bounds(c); }, "c"_a, DOC(fiction_cartesian_layout_is_within_bounds)) @@ -307,7 +229,7 @@ inline void charge_distribution_surface(pybind11::module& m) [](const py_charge_distribution_surface& lyt) { std::stringstream ss; - print_layout(lyt, ss); + print_layout(fiction::convert_to_siqad_coordinates(lyt), ss); return ss.str(); }) diff --git a/bindings/pyfiction/include/pyfiction/types.hpp b/bindings/pyfiction/include/pyfiction/types.hpp index 90f188367..890760343 100644 --- a/bindings/pyfiction/include/pyfiction/types.hpp +++ b/bindings/pyfiction/include/pyfiction/types.hpp @@ -107,18 +107,9 @@ using py_inml_layout = py_cartesian_cell_layout; using py_sidb_layout = py_cartesian_cell_layout; /** * Charge distribution surface. This is a special SiDB cell-level layout that is used for the SiDB simulation - * algorithms. It is based on SiQAD coordinates. + * algorithms. */ -using py_charge_distribution_surface = fiction::charge_distribution_surface>>>; -/** - * The base type of py_charge_distribution_surface to prevent double inference of charge_distribution_surface in the - * template parameter of many functions, which would yield a type not registered in pyfiction. This type is not - * explicitly exposed. Don't use it on its own elsewhere unless you know what you are doing. - */ -using py_cds_base = - fiction::cell_level_layout>>; +using py_charge_distribution_surface = fiction::charge_distribution_surface; } // namespace pyfiction diff --git a/bindings/pyfiction/pyfiction.cpp b/bindings/pyfiction/pyfiction.cpp index 2cfd82a55..82f66b436 100644 --- a/bindings/pyfiction/pyfiction.cpp +++ b/bindings/pyfiction/pyfiction.cpp @@ -12,7 +12,7 @@ #include "pyfiction/algorithms/path_finding/k_shortest_paths.hpp" #include "pyfiction/algorithms/physical_design/apply_gate_library.hpp" #include "pyfiction/algorithms/physical_design/color_routing.hpp" -// #include "pyfiction/algorithms/physical_design/design_sidb_gates.hpp" +#include "pyfiction/algorithms/physical_design/design_sidb_gates.hpp" #include "pyfiction/algorithms/physical_design/exact.hpp" #include "pyfiction/algorithms/physical_design/hexagonalization.hpp" #include "pyfiction/algorithms/physical_design/orthogonal.hpp" @@ -21,25 +21,25 @@ #include "pyfiction/algorithms/simulation/logic_simulation.hpp" #include "pyfiction/algorithms/simulation/sidb/calculate_energy_and_state_type.hpp" #include "pyfiction/algorithms/simulation/sidb/can_positive_charges_occur.hpp" -#include "pyfiction/algorithms/simulation/sidb/critical_temperature.hpp" +// #include "pyfiction/algorithms/simulation/sidb/critical_temperature.hpp" #include "pyfiction/algorithms/simulation/sidb/detect_bdl_pairs.hpp" #include "pyfiction/algorithms/simulation/sidb/energy_distribution.hpp" #include "pyfiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp" #include "pyfiction/algorithms/simulation/sidb/is_ground_state.hpp" #include "pyfiction/algorithms/simulation/sidb/is_operational.hpp" // #include "pyfiction/algorithms/simulation/sidb/maximum_defect_influence_position_and_distance.hpp" +#include "pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp" +#include "pyfiction/algorithms/simulation/sidb/convert_potential_to_distance.hpp" #include "pyfiction/algorithms/simulation/sidb/minimum_energy.hpp" #include "pyfiction/algorithms/simulation/sidb/occupation_probability_of_excited_states.hpp" #include "pyfiction/algorithms/simulation/sidb/operational_domain.hpp" #include "pyfiction/algorithms/simulation/sidb/quickexact.hpp" #include "pyfiction/algorithms/simulation/sidb/quicksim.hpp" -// #include "pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp" -// #include "pyfiction/algorithms/simulation/sidb/assess_physical_population_stability.hpp" -#include "pyfiction/algorithms/simulation/sidb/convert_potential_to_distance.hpp" +#include "pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp" #include "pyfiction/algorithms/simulation/sidb/sidb_simulation_engine.hpp" #include "pyfiction/algorithms/simulation/sidb/sidb_simulation_parameters.hpp" #include "pyfiction/algorithms/simulation/sidb/sidb_simulation_result.hpp" -#include "pyfiction/algorithms/simulation/sidb/time_to_solution.hpp" +// #include "pyfiction/algorithms/simulation/sidb/time_to_solution.hpp" #include "pyfiction/algorithms/verification/design_rule_violations.hpp" #include "pyfiction/algorithms/verification/equivalence_checking.hpp" #include "pyfiction/inout/read_fgl_layout.hpp" @@ -48,7 +48,7 @@ #include "pyfiction/inout/write_dot_layout.hpp" #include "pyfiction/inout/write_fgl_layout.hpp" #include "pyfiction/inout/write_fqca_layout.hpp" -#include "pyfiction/inout/write_location_and_ground_state.hpp" +// #include "pyfiction/inout/write_location_and_ground_state.hpp" #include "pyfiction/inout/write_operational_domain.hpp" #include "pyfiction/inout/write_qca_layout.hpp" #include "pyfiction/inout/write_qcc_layout.hpp" @@ -110,7 +110,7 @@ PYBIND11_MODULE(pyfiction, m) pyfiction::sidb_simulation_parameters(m); pyfiction::sidb_simulation_result(m); pyfiction::can_positive_charges_occur(m); - // pyfiction::assess_physical_population_stability(m); + pyfiction::assess_physical_population_stability(m); pyfiction::convert_potential_to_distance(m); pyfiction::detect_bdl_pairs(m); pyfiction::is_operational(m); @@ -124,9 +124,9 @@ PYBIND11_MODULE(pyfiction, m) pyfiction::energy_distribution(m); pyfiction::calculate_energy_and_state_type(m); pyfiction::occupation_probability_of_excited_states(m); - pyfiction::critical_temperature(m); - // pyfiction::random_sidb_layout_generator(m); - pyfiction::time_to_solution(m); + // pyfiction::critical_temperature(m); + pyfiction::random_sidb_layout_generator(m); + // pyfiction::time_to_solution(m); /** * Logic Networks */ @@ -153,7 +153,7 @@ PYBIND11_MODULE(pyfiction, m) pyfiction::color_routing(m); pyfiction::hexagonalization(m); pyfiction::post_layout_optimization(m); - // pyfiction::design_sidb_gates(m); + pyfiction::design_sidb_gates(m); /** * Algorithms: Properties */ @@ -183,7 +183,7 @@ PYBIND11_MODULE(pyfiction, m) pyfiction::write_qll_layout(m); pyfiction::write_fqca_layout(m); pyfiction::write_sqd_sim_result(m); - pyfiction::write_location_and_ground_state(m); + // pyfiction::write_location_and_ground_state(m); pyfiction::write_operational_domain(m); pyfiction::read_fgl_layout(m); pyfiction::read_fqca_layout(m); diff --git a/bindings/pyfiction/test/algorithms/simulation/sidb/test_critical_temperature.py b/bindings/pyfiction/test/algorithms/simulation/sidb/test_critical_temperature.py index 821cb202d..652f64b2f 100644 --- a/bindings/pyfiction/test/algorithms/simulation/sidb/test_critical_temperature.py +++ b/bindings/pyfiction/test/algorithms/simulation/sidb/test_critical_temperature.py @@ -5,43 +5,43 @@ dir_path = os.path.dirname(os.path.realpath(__file__)) -class TestCriticalTemperature(unittest.TestCase): - - def test_perturber_and_DB_pair(self): - layout = sidb_layout((10, 10)) - layout.assign_cell_type((0, 1), sidb_technology.cell_type.NORMAL) - layout.assign_cell_type((4, 1), sidb_technology.cell_type.NORMAL) - layout.assign_cell_type((6, 1), sidb_technology.cell_type.NORMAL) - - params = critical_temperature_params() - params.engine = simulation_engine.EXACT - - stats = critical_temperature_stats() - - cds = charge_distribution_surface(layout) - - critical_temperature_non_gate_based(cds, params, stats) - - self.assertEqual(stats.algorithm_name, "QuickExact") - self.assertEqual(stats.critical_temperature, 400) - self.assertEqual(stats.num_valid_lyt, 1) - - def test_bestagon_inv(self): - layout = read_sqd_layout(dir_path + "/../../../resources/hex_inv_diag_0.sqd", "inverter_input_0") - - params = critical_temperature_params() - params.engine = simulation_engine.APPROXIMATE - - stats = critical_temperature_stats() - - cds = charge_distribution_surface(layout) - spec = [create_not_tt()] - - critical_temperature_gate_based(cds, spec, params, stats) - - self.assertEqual(stats.algorithm_name, "QuickSim") - self.assertLessEqual(stats.critical_temperature, 400) - self.assertGreater(stats.num_valid_lyt, 1) +# class TestCriticalTemperature(unittest.TestCase): +# +# def test_perturber_and_DB_pair(self): +# layout = sidb_layout((10, 10)) +# layout.assign_cell_type((0, 1), sidb_technology.cell_type.NORMAL) +# layout.assign_cell_type((4, 1), sidb_technology.cell_type.NORMAL) +# layout.assign_cell_type((6, 1), sidb_technology.cell_type.NORMAL) +# +# params = critical_temperature_params() +# params.engine = simulation_engine.EXACT +# +# stats = critical_temperature_stats() +# +# cds = charge_distribution_surface(layout) +# +# critical_temperature_non_gate_based(cds, params, stats) +# +# self.assertEqual(stats.algorithm_name, "QuickExact") +# self.assertEqual(stats.critical_temperature, 400) +# self.assertEqual(stats.num_valid_lyt, 1) +# +# def test_bestagon_inv(self): +# layout = read_sqd_layout(dir_path + "/../../../resources/hex_inv_diag_0.sqd", "inverter_input_0") +# +# params = critical_temperature_params() +# params.engine = simulation_engine.APPROXIMATE +# +# stats = critical_temperature_stats() +# +# cds = charge_distribution_surface(layout) +# spec = [create_not_tt()] +# +# critical_temperature_gate_based(cds, spec, params, stats) +# +# self.assertEqual(stats.algorithm_name, "QuickSim") +# self.assertLessEqual(stats.critical_temperature, 400) +# self.assertGreater(stats.num_valid_lyt, 1) if __name__ == '__main__': diff --git a/bindings/pyfiction/test/algorithms/simulation/sidb/test_exhaustive_ground_state_simulation.py b/bindings/pyfiction/test/algorithms/simulation/sidb/test_exhaustive_ground_state_simulation.py index 65eb6079f..3e39ba1be 100644 --- a/bindings/pyfiction/test/algorithms/simulation/sidb/test_exhaustive_ground_state_simulation.py +++ b/bindings/pyfiction/test/algorithms/simulation/sidb/test_exhaustive_ground_state_simulation.py @@ -22,9 +22,9 @@ def test_perturber_and_DB_pair(self): groundstate = result.charge_distributions[0] - self.assertEqual(groundstate.get_charge_state((0, 0, 1)), sidb_charge_state.NEGATIVE) - self.assertEqual(groundstate.get_charge_state((4, 0, 1)), sidb_charge_state.NEUTRAL) - self.assertEqual(groundstate.get_charge_state((6, 0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(groundstate.get_charge_state((0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(groundstate.get_charge_state((4, 1)), sidb_charge_state.NEUTRAL) + self.assertEqual(groundstate.get_charge_state((6, 1)), sidb_charge_state.NEGATIVE) if __name__ == '__main__': diff --git a/bindings/pyfiction/test/algorithms/simulation/sidb/test_quicksim.py b/bindings/pyfiction/test/algorithms/simulation/sidb/test_quicksim.py index ca229d674..71713f0a1 100644 --- a/bindings/pyfiction/test/algorithms/simulation/sidb/test_quicksim.py +++ b/bindings/pyfiction/test/algorithms/simulation/sidb/test_quicksim.py @@ -35,9 +35,9 @@ def test_perturber_and_DB_pair(self): groundstate = result.charge_distributions[0] - self.assertEqual(groundstate.get_charge_state((0, 0, 1)), sidb_charge_state.NEGATIVE) - self.assertEqual(groundstate.get_charge_state((4, 0, 1)), sidb_charge_state.NEUTRAL) - self.assertEqual(groundstate.get_charge_state((6, 0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(groundstate.get_charge_state((0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(groundstate.get_charge_state((4, 1)), sidb_charge_state.NEUTRAL) + self.assertEqual(groundstate.get_charge_state((6, 1)), sidb_charge_state.NEGATIVE) if __name__ == '__main__': diff --git a/bindings/pyfiction/test/technology/test_charge_distribution_surface.py b/bindings/pyfiction/test/technology/test_charge_distribution_surface.py index 1725899b8..bdaca458a 100644 --- a/bindings/pyfiction/test/technology/test_charge_distribution_surface.py +++ b/bindings/pyfiction/test/technology/test_charge_distribution_surface.py @@ -13,22 +13,22 @@ def test_initialization(self): charge_lyt = charge_distribution_surface(layout_one) - self.assertEqual(charge_lyt.get_charge_state((0, 0, 1)), sidb_charge_state.NEGATIVE) - self.assertEqual(charge_lyt.get_charge_state((4, 0, 1)), sidb_charge_state.NEGATIVE) - self.assertEqual(charge_lyt.get_charge_state((6, 0, 1)), sidb_charge_state.NEGATIVE) - - charge_lyt.assign_charge_state((0, 0, 1), sidb_charge_state.NEUTRAL) - charge_lyt.assign_charge_state((4, 0, 1), sidb_charge_state.NEGATIVE) - charge_lyt.assign_charge_state((6, 0, 1), sidb_charge_state.NEGATIVE) - self.assertEqual(charge_lyt.get_charge_state((0, 0, 1)), sidb_charge_state.NEUTRAL) - self.assertEqual(charge_lyt.get_charge_state((4, 0, 1)), sidb_charge_state.NEGATIVE) - self.assertEqual(charge_lyt.get_charge_state((6, 0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(charge_lyt.get_charge_state((0, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(charge_lyt.get_charge_state((4, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(charge_lyt.get_charge_state((6, 1)), sidb_charge_state.NEGATIVE) + + charge_lyt.assign_charge_state((0, 1), sidb_charge_state.NEUTRAL) + charge_lyt.assign_charge_state((4, 1), sidb_charge_state.NEGATIVE) + charge_lyt.assign_charge_state((6, 1), sidb_charge_state.NEGATIVE) + self.assertEqual(charge_lyt.get_charge_state((0, 1)), sidb_charge_state.NEUTRAL) + self.assertEqual(charge_lyt.get_charge_state((4, 1)), sidb_charge_state.NEGATIVE) + self.assertEqual(charge_lyt.get_charge_state((6, 1)), sidb_charge_state.NEGATIVE) charge_lyt.update_after_charge_change() self.assertFalse(charge_lyt.is_physically_valid()) - charge_lyt.assign_charge_state((0, 0, 1), sidb_charge_state.NEGATIVE) - charge_lyt.assign_charge_state((4, 0, 1), sidb_charge_state.NEUTRAL) - charge_lyt.assign_charge_state((6, 0, 1), sidb_charge_state.NEGATIVE) + charge_lyt.assign_charge_state((0, 1), sidb_charge_state.NEGATIVE) + charge_lyt.assign_charge_state((4, 1), sidb_charge_state.NEUTRAL) + charge_lyt.assign_charge_state((6, 1), sidb_charge_state.NEGATIVE) charge_lyt.update_after_charge_change() self.assertTrue(charge_lyt.is_physically_valid())