Field.cpp File Reference

#include <FieldUtils/Field.hpp>
#include <FieldUtils/FieldConvertComm.hpp>
#include <LibUtilities/Python/BasicUtils/SharedArray.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions
void	NewPartition (FieldSharedPtr f, py::list &py_argv, int part)
FieldSharedPtr	Field_Init (py::list &argv, int nparts=0, int output_points=0, int output_points_hom_z=0, bool error=false, bool force_output=false, bool no_equispaced=false, int npz=0, std::string onlyshape="", int part_only=0, int part_only_overlapping=0, bool useSessionVariables=false, bool useSessionExpansion=false, bool verbose=false, std::string domain="")
const Array< OneD, const NekDouble >	Field_GetPts (FieldSharedPtr f, const int i)
void	Field_SetPts (FieldSharedPtr f, const int i, const Array< OneD, const NekDouble > &inarray)
void	export_Field (py::module &m)

Function Documentation

export_Field()

void export_Field

(

py::module &

m

)

Definition at line 196 of file Field.cpp.

{
    py::class_<Field, std::shared_ptr<Field>>(m, "Field")
        .def(py::init<>(&Field_Init), py::arg("argv") = py::list(),
             py::arg("nparts") = 0, py::arg("output_points") = 0,
             py::arg("output_points_hom_z") = 0, py::arg("error") = false,
             py::arg("force_output") = false, py::arg("no_equispaced") = false,
             py::arg("npz") = 0, py::arg("onlyshape") = "",
             py::arg("part_only") = 0, py::arg("part_only_overlapping") = 0,
             py::arg("use_session_variables") = false,
             py::arg("use_session_expansion") = false,
             py::arg("verbose") = false, py::arg("domain") = "")
 
        .def("GetPts", &Field_GetPts)
        .def("SetPts", &Field_SetPts)
        .def("ClearField", &Field::ClearField)
        .def("NewPartition", &NewPartition)
        .def("ReadFieldDefs", &Field::ReadFieldDefs)
 
        .def("SetupFromExpList", &Field::SetupFromExpList)
 
        .def_readwrite("graph", &Field::m_graph)
        .def_readwrite("session", &Field::m_session)
        .def_readwrite("verbose", &Field::m_verbose)
        .def_readwrite("comm", &Field::m_comm);
}

References Field_GetPts(), Field_Init(), Field_SetPts(), and NewPartition().

Referenced by PYBIND11_MODULE().

Field_GetPts()

const Array< OneD, const NekDouble > Field_GetPts	(	FieldSharedPtr	f,
		const int	i
	)

Definition at line 180 of file Field.cpp.

{
    return f->m_fieldPts->GetPts(i);
}

Referenced by export_Field().

Field_Init()

FieldSharedPtr Field_Init	(	py::list &	argv,
		int	nparts = 0,
		int	output_points = 0,
		int	output_points_hom_z = 0,
		bool	error = false,
		bool	force_output = false,
		bool	no_equispaced = false,
		int	npz = 0,
		std::string	onlyshape = "",
		int	part_only = 0,
		int	part_only_overlapping = 0,
		bool	useSessionVariables = false,
		bool	useSessionExpansion = false,
		bool	verbose = false,
		std::string	domain = ""
	)

Definition at line 64 of file Field.cpp.

{
    // Construct shared pointer to a Field object.
    std::shared_ptr<Field> f = MemoryManager<Field>::AllocateSharedPtr();
 
    if (py::len(argv) > 0)
    {
        // Get argc and argv from the Python command line.
        PyCppCommandLine cpp(argv);
 
        // Define the MPI Communicator.
        f->m_comm = LibUtilities::GetCommFactory().CreateInstance(
            "Serial", cpp.GetArgc(), cpp.GetArgv());
 
        if (nparts)
        {
            f->m_vm.insert(
                std::make_pair("nparts", po::variable_value(nparts, false)));
            if (nparts > 1)
            {
                f->m_nParts  = nparts;
                f->m_defComm = f->m_comm;
            }
        }
    }
 
    // Populate m_vm.
    if (output_points)
    {
        f->m_vm.insert(std::make_pair(
            "output-points", po::variable_value(output_points, false)));
    }
 
    if (output_points_hom_z)
    {
        f->m_vm.insert(
            std::make_pair("output-points-hom-z",
                           po::variable_value(output_points_hom_z, false)));
    }
 
    if (error)
    {
        f->m_vm.insert(std::make_pair("error", po::variable_value()));
    }
 
    if (force_output)
    {
        f->m_vm.insert(std::make_pair("force-output", po::variable_value()));
    }
 
    if (domain.size())
    {
        NEKERROR(ErrorUtil::efatal,
                 "The doamin option in field is deprecated. Please use "
                 "the xml option range=\"xmax,xmin,ymax,ymin\", \n\t i.e."
                 "InputModule.Create(\"xml\",  field, \"myfile.xml\", "
                 "range=\"-1,1,-1,1\").Run()");
    }
 
    if (no_equispaced)
    {
        f->m_vm.insert(std::make_pair("no-equispaced", po::variable_value()));
    }
 
    if (npz)
    {
        f->m_vm.insert(std::make_pair("npz", po::variable_value(npz, false)));
    }
 
    if (onlyshape.size())
    {
        f->m_vm.insert(
            std::make_pair("onlyshape", po::variable_value(onlyshape, false)));
    }
 
    if (part_only)
    {
        f->m_vm.insert(
            std::make_pair("part-only", po::variable_value(part_only, false)));
    }
 
    if (part_only_overlapping)
    {
        f->m_vm.insert(
            std::make_pair("part-only-overlapping",
                           po::variable_value(part_only_overlapping, false)));
    }
 
    if (useSessionVariables)
    {
        f->m_vm.insert(
            std::make_pair("use_session_variables", po::variable_value()));
    }
 
    if (useSessionExpansion)
    {
        f->m_vm.insert(
            std::make_pair("use_session_expansion", po::variable_value()));
    }
 
    if (verbose)
    {
        f->m_vm.insert(std::make_pair("verbose", po::variable_value()));
    }
 
    return f;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::ErrorUtil::efatal, Nektar::LibUtilities::CppCommandLine::GetArgc(), Nektar::LibUtilities::CppCommandLine::GetArgv(), Nektar::LibUtilities::GetCommFactory(), and NEKERROR.

Referenced by export_Field().

Field_SetPts()

void Field_SetPts	(	FieldSharedPtr	f,
		const int	i,
		const Array< OneD, const NekDouble > &	inarray
	)

Definition at line 190 of file Field.cpp.

{
    f->m_fieldPts->SetPts(i, inarray);
}

Referenced by export_Field().

NewPartition()

void NewPartition	(	FieldSharedPtr	f,
		py::list &	py_argv,
		int	part
	)

Definition at line 48 of file Field.cpp.

{
    std::cout << std::endl << "Processing partition: " << part << std::endl;
    f->ClearField();
 
    PyCppCommandLine cpp(py_argv);
 
    f->m_partComm = std::shared_ptr<FieldConvertComm>(
        new FieldConvertComm(cpp.GetArgc(), cpp.GetArgv(), f->m_nParts, part));
}

References Nektar::LibUtilities::CppCommandLine::GetArgc(), and Nektar::LibUtilities::CppCommandLine::GetArgv().

Referenced by export_Field().