// -*- C++ -*-
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//<LicenseText>
//
// CitcomS.py by Eh Tan, Eun-seo Choi, and Pururav Thoutireddy.
// Copyright (C) 2002-2005, California Institute of Technology.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//</LicenseText>
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#include "config.h"
#include <Python.h>
#include "mpi.h"
#include "mpi/pympi.h"
#include "inlets_outlets.h"
///////////////////////////////////////////////////////////////////////////////
#include "SVTInlet.h"
extern "C" void deleteSVTInlet(void*);
char PyCitcomSExchanger_SVTInlet_create__doc__[] = "";
char PyCitcomSExchanger_SVTInlet_create__name__[] = "SVTInlet_create";
PyObject * PyCitcomSExchanger_SVTInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3;
if (!PyArg_ParseTuple(args, "OOO:SVTInlet_create",
&obj1, &obj2, &obj3))
return NULL;
Boundary* b = static_cast<Boundary*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
SVTInlet* inlet = new SVTInlet(*b, *sink, E);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deleteSVTInlet);
return Py_BuildValue("O", cobj);
}
void deleteSVTInlet(void* p)
{
delete static_cast<SVTInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "BoundarySVTInlet.h"
extern "C" void deleteBoundarySVTInlet(void*);
char PyCitcomSExchanger_BoundarySVTInlet_create__doc__[] = "";
char PyCitcomSExchanger_BoundarySVTInlet_create__name__[] = "BoundarySVTInlet_create";
PyObject * PyCitcomSExchanger_BoundarySVTInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3, *obj4;
if (!PyArg_ParseTuple(args, "OOOO:BoundarySVTInlet_create",
&obj1, &obj2, &obj3, &obj4))
return NULL;
Boundary* b = static_cast<Boundary*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
PyMPICommObject* comm = (PyMPICommObject *)obj4;
MPI_Comm& cm = comm->comm;
BoundarySVTInlet* inlet = new BoundarySVTInlet(*b, *sink, E, cm);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deleteBoundarySVTInlet);
return Py_BuildValue("O", cobj);
}
void deleteBoundarySVTInlet(void* p)
{
delete static_cast<BoundarySVTInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "TInlet.h"
extern "C" void deleteTInlet(void*);
char PyCitcomSExchanger_TInlet_create__doc__[] = "";
char PyCitcomSExchanger_TInlet_create__name__[] = "TInlet_create";
PyObject * PyCitcomSExchanger_TInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3;
if (!PyArg_ParseTuple(args, "OOO:TInlet_create",
&obj1, &obj2, &obj3))
return NULL;
Exchanger::BoundedMesh* b = static_cast<Exchanger::BoundedMesh*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
TInlet* inlet = new TInlet(*b, *sink, E);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deleteTInlet);
return Py_BuildValue("O", cobj);
}
void deleteTInlet(void* p)
{
delete static_cast<TInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "PInlet.h"
extern "C" void deletePInlet(void*);
char PyCitcomSExchanger_PInlet_create__doc__[] = "";
char PyCitcomSExchanger_PInlet_create__name__[] = "PInlet_create";
PyObject * PyCitcomSExchanger_PInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3;
if (!PyArg_ParseTuple(args, "OOO:PInlet_create",
&obj1, &obj2, &obj3))
return NULL;
Exchanger::BoundedMesh* b = static_cast<Exchanger::BoundedMesh*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
PInlet* inlet = new PInlet(*b, *sink, E);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deletePInlet);
return Py_BuildValue("O", cobj);
}
void deletePInlet(void* p)
{
delete static_cast<PInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "SInlet.h"
extern "C" void deleteSInlet(void*);
char PyCitcomSExchanger_SInlet_create__doc__[] = "";
char PyCitcomSExchanger_SInlet_create__name__[] = "SInlet_create";
PyObject * PyCitcomSExchanger_SInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3;
if (!PyArg_ParseTuple(args, "OOO:SInlet_create",
&obj1, &obj2, &obj3))
return NULL;
Boundary* b = static_cast<Boundary*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
SInlet* inlet = new SInlet(*b, *sink, E);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deleteSInlet);
return Py_BuildValue("O", cobj);
}
void deleteSInlet(void* p)
{
delete static_cast<SInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "VTInlet.h"
extern "C" void deleteVTInlet(void*);
char PyCitcomSExchanger_VTInlet_create__doc__[] = "";
char PyCitcomSExchanger_VTInlet_create__name__[] = "VTInlet_create";
PyObject * PyCitcomSExchanger_VTInlet_create(PyObject *self, PyObject *args)
{
PyObject *obj1, *obj2, *obj3;
if (!PyArg_ParseTuple(args, "OOO:VTInlet_create",
&obj1, &obj2, &obj3))
return NULL;
Exchanger::BoundedMesh* b = static_cast<Exchanger::BoundedMesh*>(PyCObject_AsVoidPtr(obj1));
Exchanger::Sink* sink = static_cast<Exchanger::Sink*>(PyCObject_AsVoidPtr(obj2));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj3));
VTInlet* inlet = new VTInlet(*b, *sink, E);
PyObject *cobj = PyCObject_FromVoidPtr(inlet, deleteVTInlet);
return Py_BuildValue("O", cobj);
}
void deleteVTInlet(void* p)
{
delete static_cast<VTInlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "SVTOutlet.h"
extern "C" void deleteSVTOutlet(void*);
char PyCitcomSExchanger_SVTOutlet_create__doc__[] = "";
char PyCitcomSExchanger_SVTOutlet_create__name__[] = "SVTOutlet_create";
PyObject * PyCitcomSExchanger_SVTOutlet_create(PyObject *self, PyObject *args)
{
PyObject *obj0, *obj1;
if (!PyArg_ParseTuple(args, "OO:SVTOutlet_create",
&obj0, &obj1))
return NULL;
CitcomSource* source = static_cast<CitcomSource*>(PyCObject_AsVoidPtr(obj0));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj1));
SVTOutlet* outlet = new SVTOutlet(*source, E);
PyObject *cobj = PyCObject_FromVoidPtr(outlet, deleteSVTOutlet);
return Py_BuildValue("O", cobj);
}
void deleteSVTOutlet(void* p)
{
delete static_cast<SVTOutlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "TOutlet.h"
extern "C" void deleteTOutlet(void*);
char PyCitcomSExchanger_TOutlet_create__doc__[] = "";
char PyCitcomSExchanger_TOutlet_create__name__[] = "TOutlet_create";
PyObject * PyCitcomSExchanger_TOutlet_create(PyObject *self, PyObject *args)
{
PyObject *obj0, *obj1;
if (!PyArg_ParseTuple(args, "OO:TOutlet_create",
&obj0, &obj1))
return NULL;
CitcomSource* source = static_cast<CitcomSource*>(PyCObject_AsVoidPtr(obj0));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj1));
TOutlet* outlet = new TOutlet(*source, E);
PyObject *cobj = PyCObject_FromVoidPtr(outlet, deleteTOutlet);
return Py_BuildValue("O", cobj);
}
void deleteTOutlet(void* p)
{
delete static_cast<TOutlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "POutlet.h"
extern "C" void deletePOutlet(void*);
char PyCitcomSExchanger_POutlet_create__doc__[] = "";
char PyCitcomSExchanger_POutlet_create__name__[] = "POutlet_create";
PyObject * PyCitcomSExchanger_POutlet_create(PyObject *self, PyObject *args)
{
PyObject *obj0, *obj1;
if (!PyArg_ParseTuple(args, "OO:POutlet_create",
&obj0, &obj1))
return NULL;
CitcomSource* source = static_cast<CitcomSource*>(PyCObject_AsVoidPtr(obj0));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj1));
POutlet* outlet = new POutlet(*source, E);
PyObject *cobj = PyCObject_FromVoidPtr(outlet, deletePOutlet);
return Py_BuildValue("O", cobj);
}
void deletePOutlet(void* p)
{
delete static_cast<POutlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "VOutlet.h"
extern "C" void deleteVOutlet(void*);
char PyCitcomSExchanger_VOutlet_create__doc__[] = "";
char PyCitcomSExchanger_VOutlet_create__name__[] = "VOutlet_create";
PyObject * PyCitcomSExchanger_VOutlet_create(PyObject *self, PyObject *args)
{
PyObject *obj0, *obj1;
if (!PyArg_ParseTuple(args, "OO:VOutlet_create",
&obj0, &obj1))
return NULL;
CitcomSource* source = static_cast<CitcomSource*>(PyCObject_AsVoidPtr(obj0));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj1));
VOutlet* outlet = new VOutlet(*source, E);
PyObject *cobj = PyCObject_FromVoidPtr(outlet, deleteVOutlet);
return Py_BuildValue("O", cobj);
}
void deleteVOutlet(void* p)
{
delete static_cast<VOutlet*>(p);
}
///////////////////////////////////////////////////////////////////////////////
#include "VTOutlet.h"
extern "C" void deleteVTOutlet(void*);
char PyCitcomSExchanger_VTOutlet_create__doc__[] = "";
char PyCitcomSExchanger_VTOutlet_create__name__[] = "VTOutlet_create";
PyObject * PyCitcomSExchanger_VTOutlet_create(PyObject *self, PyObject *args)
{
PyObject *obj0, *obj1;
if (!PyArg_ParseTuple(args, "OO:VTOutlet_create",
&obj0, &obj1))
return NULL;
CitcomSource* source = static_cast<CitcomSource*>(PyCObject_AsVoidPtr(obj0));
All_variables* E = static_cast<All_variables*>(PyCObject_AsVoidPtr(obj1));
VTOutlet* outlet = new VTOutlet(*source, E);
PyObject *cobj = PyCObject_FromVoidPtr(outlet, deleteVTOutlet);
return Py_BuildValue("O", cobj);
}
void deleteVTOutlet(void* p)
{
delete static_cast<VTOutlet*>(p);
}
// version
// $Id$
// End of file