mirror of
https://github.com/NGSolve/netgen.git
synced 2024-12-25 13:30:34 +05:00
424 lines
9.5 KiB
C++
424 lines
9.5 KiB
C++
#define NGSOLVE
|
|
|
|
#ifdef PARALLEL
|
|
|
|
#include "dlfcn.h"
|
|
|
|
#ifdef OCCGEOMETRY
|
|
#include <occgeom.hpp>
|
|
#endif
|
|
|
|
// #include <mystdlib.h>
|
|
|
|
#include <meshing.hpp>
|
|
|
|
// #include "incvis.hpp"
|
|
#include <visual.hpp>
|
|
|
|
|
|
#ifdef PARALLELGL
|
|
|
|
#ifndef WIN32
|
|
|
|
#define GLX_GLXEXT_LEGACY
|
|
#define GLX_GLXEXT_PROTOTYPES
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
#include <X11/Xatom.h> /* for XA_RGB_DEFAULT_MAP atom */
|
|
#include <GL/glx.h>
|
|
#include <GL/glxext.h>
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
#include <geometry2d.hpp>
|
|
#include <stlgeom.hpp>
|
|
|
|
// #include <incvis.hpp>
|
|
// #include <visual.hpp>
|
|
// #include <mystdlib.h>
|
|
// #include <myadt.hpp>
|
|
// #include <linalg.hpp>
|
|
// #include <csg.hpp>
|
|
|
|
|
|
|
|
#include <meshing.hpp>
|
|
|
|
// #include "parallel.hpp"
|
|
#include "parallelfunc.hpp"
|
|
|
|
|
|
// extern "C" void NGS_ParallelRun (const string & message);
|
|
void (*NGS_ParallelRun) (const string & message) = NULL;
|
|
|
|
|
|
// extern void NGS_ParallelRun ( const string & message );
|
|
|
|
namespace netgen
|
|
{
|
|
#include "../interface/writeuser.hpp"
|
|
extern string ngdir;
|
|
|
|
#ifdef OPENGL
|
|
extern VisualSceneMesh vsmesh;
|
|
#endif
|
|
}
|
|
|
|
void Parallel_Exit();
|
|
|
|
|
|
namespace netgen {
|
|
extern AutoPtr<Mesh> mesh;
|
|
extern VisualSceneMesh vsmesh;
|
|
}
|
|
|
|
using namespace netgen;
|
|
using netgen::RegisterUserFormats;
|
|
|
|
|
|
|
|
#ifdef PARALLEL
|
|
void Ng_Exit ()
|
|
{
|
|
// Parallel_Exit();
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void ParallelRun()
|
|
{
|
|
string message;
|
|
MPI_Status status;
|
|
|
|
|
|
MPI_Comm_size(MPI_COMM_WORLD, &ntasks);
|
|
MPI_Comm_rank(MPI_COMM_WORLD, &id);
|
|
|
|
|
|
|
|
bool test = true;
|
|
|
|
// testout = new ostream(0);
|
|
testout = new ofstream (string("testout_proc") + id );
|
|
|
|
while ( test )
|
|
{
|
|
#ifdef SCALASCA
|
|
#pragma pomp inst begin (message)
|
|
#endif
|
|
|
|
// MyMPI_Recv ( message, 0, MPI_TAG_CMD );
|
|
message = MyMPI_RecvCmd();
|
|
|
|
#ifdef SCALASCA
|
|
#pragma pomp inst end (message)
|
|
#endif
|
|
|
|
|
|
if ( message.compare(0, 3, "ngs") == 0 )
|
|
{
|
|
// PrintMessage ( 1, "Starting NgSolve routine ", message ) ;
|
|
|
|
if (NGS_ParallelRun == NULL)
|
|
{
|
|
void * handle = dlopen ("libngsolve.so", RTLD_NOW | RTLD_GLOBAL);
|
|
if (!handle)
|
|
{
|
|
cerr << "cannot load shared library libngsolve.so" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
NGS_ParallelRun = (void (*) (const string & message)) dlsym (handle, "NGS_ParallelRun");
|
|
|
|
if (!NGS_ParallelRun)
|
|
{
|
|
cerr << "cannot bind function NGS_ParallelRun" << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
(*NGS_ParallelRun) (message);
|
|
}
|
|
else
|
|
|
|
if ( message == "mesh" )
|
|
{
|
|
VT_USER_START ("Mesh::ReceiveParallelMesh");
|
|
mesh.Reset( new netgen::Mesh);
|
|
// mesh->ReceiveParallelMesh();
|
|
mesh->SendRecvMesh();
|
|
VT_USER_END ("Mesh::ReceiveParallelMesh");
|
|
}
|
|
|
|
else if ( message == "overlap++" )
|
|
{
|
|
PrintMessage (1, "overlap++++++");
|
|
mesh -> UpdateOverlap();
|
|
}
|
|
|
|
else if ( message == "visualize" )
|
|
{
|
|
cout << "p" << id << ": ACHTUNG - alles wieder zumachen, sonst geht nix mehr :)" << endl;
|
|
cout << "Tcl-disabled" << endl;
|
|
/*
|
|
|
|
// initialize application
|
|
Tcl_Interp * myinterp = Tcl_CreateInterp ();
|
|
if (Tcl_AppInit (myinterp) == TCL_ERROR)
|
|
{
|
|
cerr << "Exit Netgen due to initialization problem" << endl;
|
|
exit (1);
|
|
}
|
|
|
|
string startfile = ngdir + "/libsrc/parallel/ng_parallel.tcl";
|
|
|
|
if (verbose)
|
|
cout << "Load Tcl-script from " << startfile << endl;
|
|
|
|
int errcode = Tcl_EvalFile (myinterp, (char*)startfile.c_str());
|
|
|
|
if (errcode)
|
|
{
|
|
cout << "Error in Tcl-Script:" << endl;
|
|
cout << "result = " << myinterp->result << endl;
|
|
cout << "in line " << myinterp->errorLine << endl;
|
|
|
|
if (myinterp->errorLine == 1)
|
|
cout << "\nMake sure to set environment variable NETGENDIR" << endl;
|
|
|
|
exit (1);
|
|
}
|
|
|
|
// lookup user file formats and insert into format list:
|
|
ARRAY<const char*> userformats;
|
|
RegisterUserFormats (userformats);
|
|
|
|
ostringstream fstr;
|
|
for (int i = 1; i <= userformats.Size(); i++)
|
|
fstr << ".ngmenu.file.filetype add radio -label \""
|
|
<< userformats.Get(i) << "\" -variable exportfiletype\n";
|
|
|
|
|
|
Tcl_Eval (myinterp, (char*)fstr.str().c_str());
|
|
Tcl_SetVar (myinterp, "exportfiletype", "Neutral Format", 0);
|
|
|
|
|
|
|
|
Tk_MainLoop();
|
|
|
|
|
|
Tcl_DeleteInterp (myinterp);
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
#ifdef PARALLELGL
|
|
|
|
else if ( message == "redraw" )
|
|
{
|
|
// draw into the same GLX - drawing context
|
|
// works on parallel machine, but
|
|
// did not manage to get glXImportContextEXT working on Laptop (JS)
|
|
|
|
string redraw_cmd;
|
|
// MyMPI_Recv (redraw_cmd, 0, MPI_TAG_VIS);
|
|
redraw_cmd = MyMPI_RecvCmd();
|
|
|
|
// PrintMessage (1, "Redraw - ", redraw_cmd);
|
|
|
|
static string displname;
|
|
static int curDrawable, contextid;
|
|
|
|
static Display * display = NULL;
|
|
static GLXContext context;
|
|
static XVisualInfo * visinfo = 0;
|
|
|
|
// if (!display)
|
|
if (redraw_cmd == "init")
|
|
{
|
|
MyMPI_Recv (displname, 0, MPI_TAG_VIS);
|
|
MyMPI_Recv (curDrawable, 0, MPI_TAG_VIS);
|
|
MyMPI_Recv (contextid, 0, MPI_TAG_VIS);
|
|
|
|
|
|
display = XOpenDisplay (displname.c_str());
|
|
|
|
/*
|
|
PrintMessage (3, "displ - name = ", displname);
|
|
PrintMessage (3, "display = ", display,
|
|
" display props: ",
|
|
" screen w = ", XDisplayWidth (display, 0),
|
|
" , h = ", XDisplayHeight (display, 0));
|
|
*/
|
|
|
|
Window win;
|
|
int wx, wy;
|
|
unsigned int ww, wh, bw, depth;
|
|
// cout << "got drawable: " << curDrawable << endl;
|
|
|
|
XGetGeometry(display, curDrawable, &win,
|
|
&wx, &wy, &ww, &wh,
|
|
&bw, &depth);
|
|
|
|
/*
|
|
cout << "P" << id << ": window-props: x = " << wx << ", y = " << wy
|
|
<< ", w = " << ww << ", h = " << wh << ", depth = " << depth << endl;
|
|
*/
|
|
|
|
#define VISUAL
|
|
#ifdef VISUAL
|
|
|
|
// make a new GLXContext
|
|
// first, generate a visual (copied from togl)
|
|
|
|
int attrib_list[1000];
|
|
|
|
# define MAX_ATTEMPTS 12
|
|
static int ci_depths[MAX_ATTEMPTS] = {
|
|
8, 4, 2, 1, 12, 16, 8, 4, 2, 1, 12, 16
|
|
};
|
|
static int dbl_flags[MAX_ATTEMPTS] = {
|
|
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1
|
|
};
|
|
|
|
/* It may take a few tries to get a visual */
|
|
|
|
for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++)
|
|
{
|
|
int attrib_count = 0;
|
|
attrib_list[attrib_count++] = GLX_USE_GL;
|
|
|
|
|
|
/* RGB[A] mode */
|
|
attrib_list[attrib_count++] = GLX_RGBA;
|
|
attrib_list[attrib_count++] = GLX_RED_SIZE;
|
|
attrib_list[attrib_count++] = 1;
|
|
attrib_list[attrib_count++] = GLX_GREEN_SIZE;
|
|
attrib_list[attrib_count++] = 1;
|
|
attrib_list[attrib_count++] = GLX_BLUE_SIZE;
|
|
attrib_list[attrib_count++] = 1;
|
|
// attrib_list[attrib_count++] = GLX_ALPHA_SIZE;
|
|
// attrib_list[attrib_count++] = 1;
|
|
|
|
attrib_list[attrib_count++] = GLX_DEPTH_SIZE;
|
|
attrib_list[attrib_count++] = 1;
|
|
|
|
attrib_list[attrib_count++] = GLX_DOUBLEBUFFER;
|
|
|
|
attrib_list[attrib_count++] = None;
|
|
|
|
visinfo = glXChooseVisual(display, 0,
|
|
attrib_list);
|
|
if (visinfo) {
|
|
/* found a GLX visual! */
|
|
// cout << "found VISINFO !!!" << endl;
|
|
|
|
/*
|
|
int hi = 0;
|
|
std::cout << "attribs = ";
|
|
while (attrib_list[hi] != None)
|
|
std::cout << attrib_list[hi++] << " ";
|
|
std::cout << std::endl;
|
|
*/
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (!visinfo)
|
|
cerr << "no VISINFO found" << endl;
|
|
|
|
// context = glXCreateContext( display, visinfo, 0, /* curContext, */ False );
|
|
context = glXCreateContext( display, visinfo, glXImportContextEXT ( display, contextid ), False);
|
|
// cout << "context = " << context << endl;
|
|
|
|
glXMakeCurrent (display, curDrawable, context);
|
|
|
|
|
|
#else
|
|
// try to get GLXcontext from the master.
|
|
// this needs an indirect context (BUT DOES NOT WORK ????)
|
|
|
|
context = glXImportContextEXT ( display, contextid );
|
|
|
|
|
|
PrintMessage (1, "GLX-contextid = " , contextid,
|
|
" imported context ", context);
|
|
|
|
|
|
glXMakeCurrent (display, curDrawable, context);
|
|
#endif
|
|
|
|
// PrintMessage (1, "redraw - init complete");
|
|
}
|
|
|
|
if (redraw_cmd == "broadcast")
|
|
{
|
|
vsmesh.Broadcast ();
|
|
}
|
|
|
|
if (redraw_cmd == "linelist")
|
|
{
|
|
// glXMakeCurrent (display, curDrawable, context);
|
|
vsmesh.BuildLineList();
|
|
// glXMakeCurrent (display, None, NULL);
|
|
}
|
|
|
|
if (redraw_cmd == "filledlist")
|
|
{
|
|
vsmesh.BuildFilledList (false);
|
|
}
|
|
|
|
|
|
if (redraw_cmd == "solsurfellist")
|
|
{
|
|
vssolution.DrawSurfaceElements();
|
|
}
|
|
|
|
if (redraw_cmd == "clipplanetrigs")
|
|
{
|
|
vssolution.DrawClipPlaneTrigs();
|
|
}
|
|
|
|
if (redraw_cmd == "getminmax")
|
|
{
|
|
double hmin, hmax;
|
|
vssolution.GetMinMax (-1, -1, hmin, hmax);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
else if ( message == "end" )
|
|
{
|
|
// PrintMessage (1, "EXIT");
|
|
test = false;
|
|
// end netgen
|
|
Ng_Exit();
|
|
}
|
|
|
|
|
|
else
|
|
{
|
|
PrintMessage ( 1, "received unidentified message '" + message + "'\n");
|
|
|
|
test = false;
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|