static int
SparseMatrix_init(SparseMatrix *self, PyObject *args, PyObject *kwds)
{
int i,nr,nc,nnz;
PyObject *nzval,*colind,*rowptr;
if(!PyArg_ParseTuple(args,
"iiiOOO",
&nr,
&nc,
&nnz,
&nzval,
&colind,
&rowptr))
return -1;
self->dim[0]=nr;
self->dim[1]=nc;
self->A.nnz = nnz;
self->A.nzval = DDATA(nzval);
self->A.colind = (int_t*)malloc(nnz*sizeof(int_t));
for (i=0;i<nnz;i++)
self->A.colind[i] = IDATA(colind)[i];
self->A.rowptr = (int_t*)malloc((nr+1)*sizeof(int_t));
for (i=0;i<nr+1;i++)
self->A.rowptr[i] = IDATA(rowptr)[i];
SuperMatrix Aprint;
Aprint.Stype = SLU_NC;
Aprint.Dtype = SLU_D;
Aprint.Mtype = SLU_GE;
Aprint.nrow = nr;
Aprint.ncol = nc;
Aprint.Store = &self->A;
return 0;
}
static PyObject* ctracking_setNodeOnBoundaryArray(PyObject* self,
PyObject* args)
{
PyObject *exteriorElementBoundariesArray,
*elementBoundaryNodesArray,
*nodeOnBoundaryArray;
if (!PyArg_ParseTuple(args,
"OOO",
&exteriorElementBoundariesArray,
&elementBoundaryNodesArray,
&nodeOnBoundaryArray))
return NULL;
setNodeOnBoundaryArray(SHAPE(exteriorElementBoundariesArray)[0],
SHAPE(elementBoundaryNodesArray)[1],
IDATA(exteriorElementBoundariesArray),
IDATA(elementBoundaryNodesArray),
IDATA(nodeOnBoundaryArray));
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
lapack_lite_dgelsd(PyObject *NPY_UNUSED(self), PyObject *args)
{
int lapack_lite_status;
int m;
int n;
int nrhs;
PyObject *a;
int lda;
PyObject *b;
int ldb;
PyObject *s;
double rcond;
int rank;
PyObject *work;
PyObject *iwork;
int lwork;
int info;
TRY(PyArg_ParseTuple(args,"iiiOiOiOdiOiOi",
&m,&n,&nrhs,&a,&lda,&b,&ldb,&s,&rcond,
&rank,&work,&lwork,&iwork,&info));
TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgelsd"));
TRY(check_object(b,NPY_DOUBLE,"b","NPY_DOUBLE","dgelsd"));
TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","dgelsd"));
TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dgelsd"));
TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","dgelsd"));
lapack_lite_status =
FNAME(dgelsd)(&m,&n,&nrhs,DDATA(a),&lda,DDATA(b),&ldb,
DDATA(s),&rcond,&rank,DDATA(work),&lwork,
IDATA(iwork),&info);
if (PyErr_Occurred()) {
return NULL;
}
return Py_BuildValue("{s:i,s:i,s:i,s:i,s:i,s:i,s:d,s:i,s:i,s:i}","dgelsd_",
lapack_lite_status,"m",m,"n",n,"nrhs",nrhs,
"lda",lda,"ldb",ldb,"rcond",rcond,"rank",rank,
"lwork",lwork,"info",info);
}
static PyObject *calc_grid_values( PyObject *self, PyObject *args )
{
int i, ok, num_tri, num_vert, ncol, nrow, num_norms, num_grid_val;
long *volumes;
double nodata_val;
double cell_size;
double *x, *y;
double *norms;
double *result;
double *grid_val;
PyObject *pyobj_x;
PyObject *pyobj_y;
PyObject *pyobj_norms;
PyObject *pyobj_volumes;
PyObject *pyobj_result;
PyObject *pyobj_grid_val;
ok = PyArg_ParseTuple( args, "iiddOOOOOO",
&nrow,
&ncol,
&cell_size,
&nodata_val,
&pyobj_x,
&pyobj_y,
&pyobj_norms,
&pyobj_volumes,
&pyobj_result,
&pyobj_grid_val );
if( !ok ){
fprintf( stderr, "calc_grid_values: argument parsing error\n" );
exit(1);
}
// get data from python objects
x = DDATA( pyobj_x );
y = DDATA( pyobj_y );
norms = DDATA( pyobj_norms );
result = DDATA( pyobj_result );
grid_val = DDATA( pyobj_grid_val );
volumes = IDATA( pyobj_volumes );
num_tri = ((PyArrayObject*)pyobj_volumes)->dimensions[0];
num_vert = ((PyArrayObject*)pyobj_x)->dimensions[0];
num_norms = ((PyArrayObject*)pyobj_norms)->dimensions[0];
num_grid_val = ((PyArrayObject*)pyobj_grid_val)->dimensions[0];
//printf("==== %d %d %d %d %d \n",num_norms,num_tri,num_vert,nrow,ncol);
// init triangle array
init_norms( x,y, norms, volumes, num_tri );
//printf("+++ %d\n",nrow*ncol);
// evaluate grid
for ( i = 0 ; i < nrow*ncol; i++ )
grid_val[i] = nodata_val;
_calc_grid_values( x,y, norms, num_vert, volumes, num_tri, \
cell_size, nrow, ncol, \
result, grid_val );
return Py_BuildValue("");
}
static PyObject* ctracking_trackPointsC0P1Velocity1d(PyObject* self,
PyObject* args)
{
int nElements_global,
nNodes_global,
nNodes_element,
nElementBoundaries_element,
nPointsToTrack;
double dir,
zeroTolForTracking;
PyObject *nodeArray,
*elementNodesArray,
*elementNeighborsArray,
*cvelocity_l2g,
*cvelocity_dof,
*x_depart_times,
*x_arrive_times,
*x_in,
*x_element,
*x_out,
*flag;
if (!PyArg_ParseTuple(args,
"iiiiOOOOOdOOidOOOO",
&nElements_global,
&nNodes_global,
&nNodes_element,
&nElementBoundaries_element,
&nodeArray,
&elementNodesArray,
&elementNeighborsArray,
&cvelocity_l2g,
&cvelocity_dof,
&dir,
&x_depart_times,
&x_arrive_times,
&nPointsToTrack,
&zeroTolForTracking,
&x_in,
&x_element,
&x_out,
&flag))
return NULL;
trackPointsC0P1Velocity1d(nElements_global, //mesh representation
nNodes_global,
nNodes_element,
nElementBoundaries_element,
DDATA(nodeArray),
IDATA(elementNodesArray),
IDATA(elementNeighborsArray), //local boundary id is associated with node across from boundary
IDATA(cvelocity_l2g),
DDATA(cvelocity_dof), //characteristic speed (velocity) representation
dir, //direction in time
DDATA(x_depart_times), //in -- time of departure for each point
DDATA(x_arrive_times), //desired stopping time
//out -- stopping time for each point
nPointsToTrack, //number of points to track
zeroTolForTracking, //ignore point if |u| < eps or |v| < eps
DDATA(x_in), //points for tracking (always 3d)
IDATA(x_element), //in -- element where point i is located at tIn
//out -- element where point i is located at tOut
DDATA(x_out), //stopping location for point i at tOut
IDATA(flag)); //in: > -2 -- track point
//in: -3 -- skip point
//out: -1 -- point in interior at tOut
//out: -2 -- point exited domain somewhere in (tIn,tOut)
//out: -3 -- did not track (e.g., or u = 0)
Py_INCREF(Py_None);
return Py_None;
}
static PyObject* ctracking_trackPointsRT0Velocity2dWithTrajectories(PyObject* self,
PyObject* args)
{
int localVelocityRepresentationFlag,
nElements_global,
nNodes_global,
nNodes_element,
nElementBoundaries_element,
nPointsToTrack,
debugLevel;
double dir,
zeroTolForTracking;
PyObject *nodeArray,
*elementNodesArray,
*elementNeighborsArray,
*elementBoundariesArray,
*elementBoundaryBarycentersArray,
*elementLocalBoundaryOuterNormalsArray,
*cvelocity_l2g,
*cvelocity_dof,
*x_depart_times,
*x_arrive_times,
*x_in,
*x_element,
*x_out,
*flag;
//try to build arrays for trajectories and return
int n_traj,n_tracked;
double * x_traj = 0, * t_traj = 0;
int * e_traj = 0, * offsets_traj = 0;
debugLevel = 0;
if (!PyArg_ParseTuple(args,
"iiiiiOOOOOOOOdOOidOOOO|i",
&localVelocityRepresentationFlag,
&nElements_global,
&nNodes_global,
&nNodes_element,
&nElementBoundaries_element,
&nodeArray,
&elementNodesArray,
&elementNeighborsArray,
&elementBoundariesArray,
&elementBoundaryBarycentersArray,
&elementLocalBoundaryOuterNormalsArray,
&cvelocity_l2g,
&cvelocity_dof,
&dir,
&x_depart_times,
&x_arrive_times,
&nPointsToTrack,
&zeroTolForTracking,
&x_in,
&x_element,
&x_out,
&flag,
&debugLevel))
return NULL;
trackPointsRT0Velocity2dWithTrajectories(debugLevel,
localVelocityRepresentationFlag,
nElements_global,
nNodes_global,
nNodes_element,
nElementBoundaries_element,
DDATA(nodeArray),
IDATA(elementNodesArray),
IDATA(elementNeighborsArray),
IDATA(elementBoundariesArray),
DDATA(elementBoundaryBarycentersArray),
DDATA(elementLocalBoundaryOuterNormalsArray),
IDATA(cvelocity_l2g),
DDATA(cvelocity_dof),
dir,
DDATA(x_depart_times),
DDATA(x_arrive_times),
nPointsToTrack,
zeroTolForTracking,
DDATA(x_in),
IDATA(x_element),
DDATA(x_out),
IDATA(flag),
n_traj,
n_tracked,
offsets_traj,
x_traj,
t_traj,
e_traj);
npy_intp dim[1],dim2[2];
dim[0] = n_traj;
PyArrayObject *t_traj_py = (PyArrayObject *)PyArray_SimpleNew(1,dim,PyArray_DOUBLE);
double* t_ptr = DDATA(t_traj_py);
dim2[0] = n_traj; dim2[1] = 3;
PyArrayObject *x_traj_py = (PyArrayObject *)PyArray_SimpleNew(2,dim2,PyArray_DOUBLE);
double* x_ptr = DDATA(x_traj_py);
dim[0] = n_traj;
PyArrayObject *e_traj_py = (PyArrayObject *)PyArray_SimpleNew(1,dim,PyArray_INT);
int* e_ptr = IDATA(e_traj_py);
dim[0] = n_tracked+1;
PyArrayObject *o_traj_py = (PyArrayObject *)PyArray_SimpleNew(1,dim,PyArray_INT);
int* o_ptr = IDATA(o_traj_py);
for (int i=0; i < n_traj; i++)
{
t_ptr[i] = t_traj[i]; e_ptr[i] = e_traj[i];
for (int j=0; j < 3; j++)
x_ptr[i*3+j] = x_traj[i*3+j];
}
for (int i=0; i < n_tracked+1; i++)
{
o_ptr[i] = offsets_traj[i];
}
return Py_BuildValue("(O,O,O,O)",PyArray_Return(x_traj_py),PyArray_Return(t_traj_py),PyArray_Return(e_traj_py),PyArray_Return(o_traj_py));
}
static PyObject* ctracking_trackPointsRT0Velocity2d(PyObject* self,
PyObject* args)
{
int localVelocityRepresentationFlag,
nElements_global,
nNodes_global,
nNodes_element,
nElementBoundaries_element,
nPointsToTrack,
debugLevel;
double dir,
zeroTolForTracking;
PyObject *nodeArray,
*elementNodesArray,
*elementNeighborsArray,
*elementBoundariesArray,
*elementBoundaryBarycentersArray,
*elementLocalBoundaryOuterNormalsArray,
*cvelocity_l2g,
*cvelocity_dof,
*x_depart_times,
*x_arrive_times,
*x_in,
*x_element,
*x_out,
*flag;
debugLevel = 0;
if (!PyArg_ParseTuple(args,
"iiiiiOOOOOOOOdOOidOOOO|i",
&localVelocityRepresentationFlag,
&nElements_global,
&nNodes_global,
&nNodes_element,
&nElementBoundaries_element,
&nodeArray,
&elementNodesArray,
&elementNeighborsArray,
&elementBoundariesArray,
&elementBoundaryBarycentersArray,
&elementLocalBoundaryOuterNormalsArray,
&cvelocity_l2g,
&cvelocity_dof,
&dir,
&x_depart_times,
&x_arrive_times,
&nPointsToTrack,
&zeroTolForTracking,
&x_in,
&x_element,
&x_out,
&flag,
&debugLevel))
return NULL;
trackPointsRT0Velocity2d(debugLevel,
localVelocityRepresentationFlag,
nElements_global,
nNodes_global,
nNodes_element,
nElementBoundaries_element,
DDATA(nodeArray),
IDATA(elementNodesArray),
IDATA(elementNeighborsArray),
IDATA(elementBoundariesArray),
DDATA(elementBoundaryBarycentersArray),
DDATA(elementLocalBoundaryOuterNormalsArray),
IDATA(cvelocity_l2g),
DDATA(cvelocity_dof),
dir,
DDATA(x_depart_times),
DDATA(x_arrive_times),
nPointsToTrack,
zeroTolForTracking,
DDATA(x_in),
IDATA(x_element),
DDATA(x_out),
IDATA(flag));
Py_INCREF(Py_None);
return Py_None;
}
TEXT(T_UP, "< Go up stairs");
TEXT(T_DOWN, "> Go down stairs");
TEXT(T_CT, "^T Teleport");
TEXT(T_WAIT, ". Wait a moment");
TEXT(T_E, "E Engrave msg on floor");
#define IFLAGS ITEMENABLED|ITEMTEXT|HIGHCOMP
#define IDATA(cmd,str,off) 0,off,WDT,9,IFLAGS,0,(APTR)&str,NULL,cmd,0L,0
/* Commands */
#undef WDT
#define WDT 184
static struct MenuItem cmdsub[] = {
{ &cmdsub[1], IDATA('?', T_HELP, 0) }, /* Display help */
{ &cmdsub[2], IDATA('&', T_amp, 10) }, /* Explain a command */
{ &cmdsub[3], IDATA('O', T_O, 20) }, /* Set options */
{ &cmdsub[4], IDATA('!', T_SHELL, 30) }, /* AmigaDos commands */
{ &cmdsub[5], IDATA('v', T_v, 40) }, /* Version number */
{ &cmdsub[6], IDATA(022, T_CR, 50) }, /*R Redraw screen */
{ &cmdsub[7], IDATA(020 ,T_CP, 60) }, /*P Repeat last message */
{ &cmdsub[8], IDATA('Q', T_Q, 70) }, /* Quit game */
{ NULL, IDATA('S', T_S, 80) }, /* Save the game */
};
/* Inventory */
#undef WDT
#define WDT 184
