AnyType MatrixUpWind0::operator()(Stack stack) const
{
Matrice_Creuse<R> * sparce_mat =GetAny<Matrice_Creuse<R>* >((*emat)(stack));
MatriceMorse<R> * amorse =0;
MeshPoint *mp(MeshPointStack(stack)) , mps=*mp;
Mesh * pTh = GetAny<pmesh>((*expTh)(stack));
ffassert(pTh);
Mesh & Th (*pTh);
{
map< pair<int,int>, R> Aij;
KN<double> cc(Th.nv);
double infini=DBL_MAX;
cc=infini;
for (int it=0;it<Th.nt;it++)
for (int iv=0;iv<3;iv++)
{
int i=Th(it,iv);
if ( cc[i]==infini) { // if nuset the set
mp->setP(&Th,it,iv);
cc[i]=GetAny<double>((*expc)(stack));
}
}
for (int k=0;k<Th.nt;k++)
{
const Triangle & K(Th[k]);
const Vertex & A(K[0]), &B(K[1]),&C(K[2]);
R2 Pt(1./3.,1./3.);
R u[2];
MeshPointStack(stack)->set(Th,K(Pt),Pt,K,K.lab);
u[0] = GetAny< R>( (*expu1)(stack) ) ;
u[1] = GetAny< R>( (*expu2)(stack) ) ;
int ii[3] ={ Th(A), Th(B),Th(C)};
double q[3][2]= { { A.x,A.y} ,{B.x,B.y},{C.x,C.y} } ; // coordinates of 3 vertices (input)
double c[3]={cc[ii[0]],cc[ii[1]],cc[ii[2]]};
double a[3][3];
if (gladys(q,u,c,a) )
{
for (int i=0;i<3;i++)
for (int j=0;j<3;j++)
if (fabs(a[i][j]) >= 1e-30)
Aij[make_pair(ii[i],ii[j])]+=a[i][j];
}
}
amorse= new MatriceMorse<R>(Th.nv,Th.nv,Aij,false);
}
sparce_mat->Uh=UniqueffId();
sparce_mat->Vh=UniqueffId();
sparce_mat->A.master(amorse);
sparce_mat->typemat=(amorse->n == amorse->m) ? TypeSolveMat(TypeSolveMat::GMRES) : TypeSolveMat(TypeSolveMat::NONESQUARE); // none square matrice (morse)
*mp=mps;
if(verbosity>3) { cout << " End Build MatrixUpWind : " << endl;}
return sparce_mat;
}
ZLE_INT_T
vigetkey(void)
{
Keymap mn = openkeymap("main");
char m[3], *str;
Thingy cmd;
if (getbyte(0L, NULL) == EOF)
return ZLEEOF;
m[0] = lastchar;
metafy(m, 1, META_NOALLOC);
if(mn)
cmd = keybind(mn, m, &str);
else
cmd = t_undefinedkey;
if (!cmd || cmd == Th(z_sendbreak)) {
return ZLEEOF;
} else if (cmd == Th(z_quotedinsert)) {
if (getfullchar(0) == ZLEEOF)
return ZLEEOF;
} else if(cmd == Th(z_viquotedinsert)) {
ZLE_CHAR_T sav = zleline[zlecs];
zleline[zlecs] = '^';
zrefresh();
getfullchar(0);
zleline[zlecs] = sav;
if(LASTFULLCHAR == ZLEEOF)
return ZLEEOF;
} else if (cmd == Th(z_vicmdmode)) {
return ZLEEOF;
}
#ifdef MULTIBYTE_SUPPORT
if (!lastchar_wide_valid)
{
getrestchar(lastchar);
}
#endif
return LASTFULLCHAR;
}
AnyType MatrixUpWind3::operator()(Stack stack) const
{
Matrice_Creuse<R> * sparce_mat =GetAny<Matrice_Creuse<R>* >((*emat)(stack));
MatriceMorse<R> * amorse =0;
MeshPoint *mp(MeshPointStack(stack)) , mps=*mp;
Mesh3 * pTh = GetAny<pmesh3>((*expTh)(stack));
ffassert(pTh);
Mesh3 & Th (*pTh);
{
map< pair<int,int>, R> Aij;
KN<double> cc(Th.nv);
double infini=DBL_MAX;
cc=infini;
for (int it=0;it<Th.nt;it++)
for (int iv=0;iv<4;iv++)
{
int i=Th(it,iv);
if ( cc[i]==infini) { // if nuset the set
mp->setP(&Th,it,iv);
cc[i]=GetAny<double>((*expc)(stack));
}
}
for (int k=0;k<Th.nt;k++)
{
const Mesh3::Element & K(Th[k]);
const Mesh3::Vertex & A(K[0]), &B(K[1]),&C(K[2]),&D(K[3]);
R3 Pt(1./4.,1./4.,1./4.);
R3 U;
MeshPointStack(stack)->set(Th,K(Pt),Pt,K,K.lab);
U.x = GetAny< R>( (*expu1)(stack) ) ;
U.y = GetAny< R>( (*expu2)(stack) ) ;
U.z = GetAny< R>( (*expu3)(stack) ) ;
int ii[4] ={ Th(A), Th(B),Th(C),Th(D)};// number of 4 vertex
double c[4]={cc[ii[0]],cc[ii[1]],cc[ii[2]],cc[ii[3]]};
double a[4][4];
if (Marco(K,U,c,a) )
{
for (int i=0;i<4;i++)
for (int j=0;j<4;j++)
if (fabs(a[i][j]) >= 1e-30)
Aij[make_pair(ii[i],ii[j])]+=a[i][j];
}
}
amorse= new MatriceMorse<R>(Th.nv,Th.nv,Aij,false);
}
sparce_mat->Uh=UniqueffId();
sparce_mat->Vh=UniqueffId();
sparce_mat->A.master(amorse);
sparce_mat->typemat=(amorse->n == amorse->m) ? TypeSolveMat(TypeSolveMat::GMRES) : TypeSolveMat(TypeSolveMat::NONESQUARE); // none square matrice (morse)
*mp=mps;
if(verbosity>3) { cout << " End Build MatrixUpWind : " << endl;}
return sparce_mat;
}
/***********************************************************
start script in a new thread
***********************************************************/
void LuaHandlerBase::StartScript(const std::string & FunctionName, long ActorId, bool inlinefunction,
ScriptEnvironmentBase* env, int &ThreadReference)
{
ThreadReference = -1;
//try
//{
// luabind::call_function<void>(m_LuaState, FunctionName.c_str(), 1, env);
//}
//catch(const std::exception &error)
//{
// LogHandler::getInstance()->LogToFile(std::string("Exception calling lua function ") + FunctionName + std::string(" : ") + error.what() + std::string(" : ") + lua_tostring(m_LuaState, -1), 0);
//}
boost::shared_ptr<LuaThreadHandler> Th(new LuaThreadHandler(m_LuaState, ActorId, FunctionName,
inlinefunction, env, ThreadReference, m_creatingthread));
if(Th->IsStarted())
m_RunningThreads[ThreadReference] = Th;
else
ThreadReference = -1;
m_creatingthread = -1;
}
Thingy
executenamedcommand(char *prmt)
{
Thingy cmd, retval = NULL;
int l, len, feep = 0, listed = 0, curlist = 0;
int ols = (listshown && validlist), olll = lastlistlen;
char *cmdbuf, *ptr;
char *okeymap = ztrdup(curkeymapname);
clearlist = 1;
/* prmt may be constant */
prmt = ztrdup(prmt);
l = strlen(prmt);
cmdbuf = (char *)zhalloc(l + NAMLEN + 2
#ifdef MULTIBYTE_SUPPORT
+ 2 * MB_CUR_MAX
#endif
);
strcpy(cmdbuf, prmt);
zsfree(prmt);
statusline = cmdbuf;
selectlocalmap(command_keymap);
selectkeymap("main", 1);
ptr = cmdbuf += l;
len = 0;
for (;;) {
*ptr = '_';
ptr[1] = '\0';
zrefresh();
if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) {
statusline = NULL;
selectkeymap(okeymap, 1);
zsfree(okeymap);
if ((listshown = ols)) {
showinglist = -2;
lastlistlen = olll;
} else if (listed)
clearlist = listshown = 1;
retval = NULL;
goto done;
}
if(cmd == Th(z_clearscreen)) {
clearscreen(zlenoargs);
if (curlist) {
int zmultsav = zmult;
zmult = 1;
listlist(namedcmdll);
showinglist = 0;
zmult = zmultsav;
}
} else if(cmd == Th(z_redisplay)) {
redisplay(zlenoargs);
if (curlist) {
int zmultsav = zmult;
zmult = 1;
listlist(namedcmdll);
showinglist = 0;
zmult = zmultsav;
}
} else if(cmd == Th(z_viquotedinsert)) {
*ptr = '^';
zrefresh();
getfullchar(0);
if(LASTFULLCHAR == ZLEEOF || !LASTFULLCHAR || len >= NAMLEN)
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
curlist = 0;
}
} else if(cmd == Th(z_quotedinsert)) {
if(getfullchar(0) == ZLEEOF ||
!LASTFULLCHAR || len == NAMLEN)
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
curlist = 0;
}
} else if(cmd == Th(z_backwarddeletechar) ||
cmd == Th(z_vibackwarddeletechar)) {
if (len) {
ptr = backwardmetafiedchar(cmdbuf, ptr, NULL);
len = ptr - cmdbuf;
curlist = 0;
}
} else if(cmd == Th(z_killregion) || cmd == Th(z_backwardkillword) ||
cmd == Th(z_vibackwardkillword)) {
if (len)
curlist = 0;
while (len) {
convchar_t cc;
ptr = backwardmetafiedchar(cmdbuf, ptr, &cc);
len = ptr - cmdbuf;
if (cc == ZWC('-'))
break;
}
} else if(cmd == Th(z_killwholeline) || cmd == Th(z_vikillline) ||
cmd == Th(z_backwardkillline)) {
len = 0;
ptr = cmdbuf;
if (listed)
clearlist = listshown = 1;
curlist = 0;
} else if (cmd == Th(z_bracketedpaste)) {
char *insert = bracketedstring();
size_t inslen = strlen(insert);
if (len + inslen > NAMLEN)
feep = 1;
else {
strcpy(ptr, insert);
len += inslen;
ptr += inslen;
if (listed) {
clearlist = listshown = 1;
listed = 0;
} else
curlist = 0;
}
free(insert);
} else {
if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) {
Thingy r;
unambiguous:
*ptr = 0;
r = rthingy(cmdbuf);
if (!(r->flags & DISABLED)) {
unrefthingy(r);
statusline = NULL;
selectkeymap(okeymap, 1);
zsfree(okeymap);
if ((listshown = ols)) {
showinglist = -2;
lastlistlen = olll;
} else if (listed)
clearlist = listshown = 1;
retval = r;
goto done;
}
unrefthingy(r);
}
if(cmd == Th(z_selfinsertunmeta)) {
fixunmeta();
cmd = Th(z_selfinsert);
}
if (cmd == Th(z_listchoices) || cmd == Th(z_deletecharorlist) ||
cmd == Th(z_expandorcomplete) || cmd == Th(z_completeword) ||
cmd == Th(z_expandorcompleteprefix) || cmd == Th(z_vicmdmode) ||
cmd == Th(z_acceptline) || lastchar == ' ' || lastchar == '\t') {
namedcmdambig = 100;
namedcmdll = newlinklist();
*ptr = '\0';
namedcmdstr = cmdbuf;
scanhashtable(thingytab, 1, 0, DISABLED, scancompcmd, 0);
namedcmdstr = NULL;
if (empty(namedcmdll)) {
feep = 1;
if (listed)
clearlist = listshown = 1;
curlist = 0;
} else if (cmd == Th(z_listchoices) ||
cmd == Th(z_deletecharorlist)) {
int zmultsav = zmult;
*ptr = '_';
ptr[1] = '\0';
zmult = 1;
listlist(namedcmdll);
listed = curlist = 1;
showinglist = 0;
zmult = zmultsav;
} else if (!nextnode(firstnode(namedcmdll))) {
strcpy(ptr = cmdbuf, peekfirst(namedcmdll));
len = strlen(ptr);
ptr += len;
if (cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode))
goto unambiguous;
} else {
strcpy(cmdbuf, peekfirst(namedcmdll));
ptr = cmdbuf + namedcmdambig;
*ptr = '_';
ptr[1] = '\0';
if (isset(AUTOLIST) &&
!(isset(LISTAMBIGUOUS) && namedcmdambig > len)) {
int zmultsav = zmult;
if (isset(LISTBEEP))
feep = 1;
zmult = 1;
listlist(namedcmdll);
listed = curlist = 1;
showinglist = 0;
zmult = zmultsav;
}
len = namedcmdambig;
}
} else {
if (len == NAMLEN || cmd != Th(z_selfinsert))
feep = 1;
else {
#ifdef MULTIBYTE_SUPPORT
if (!lastchar_wide_valid)
getrestchar(lastchar, NULL, NULL);
if (lastchar_wide == WEOF)
feep = 1;
else
#endif
if (ZC_icntrl(LASTFULLCHAR))
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
if (listed) {
clearlist = listshown = 1;
listed = 0;
} else
curlist = 0;
}
}
}
}
if (feep)
handlefeep(zlenoargs);
feep = 0;
}
done:
selectlocalmap(NULL);
return retval;
}
int main(int argc, char **argv)
{
Real8 cutoffradian = 30.0*Pi/180.0;
char * fin=0,*fout=0,*fgeom=0;
verbosity = 2;
int ok=0,i=0;
if (argc >= 3)
{
fin=argv[1];
fout=argv[2];
ok= !access(fin,R_OK) && (access(fout,F_OK) || !access(fout,W_OK)) ;
}
for (i=3;i<argc && ok ;i+=2)
if (!strcmp(argv[i],"-g"))
{
fgeom=argv[i+1];
ok= ok && (access(fgeom,F_OK) || !access(fgeom,W_OK) );
}
else if (!strcmp(argv[i],"-thetamax"))
cutoffradian = atof(argv[i+1])*Pi/180.0;
else if (!strcmp(argv[i],"-v"))
verbosity = atoi(argv[i+1]);
else
ok=0;
if (!ok)
{
cout << "2D mesh convertisor of type .am_fmt .amdba .am .nopo .msh .ftq + bd mesh\n";
cout << " in type .am_fmt .amdba .am .nopo .msh .ftq + bd mesh\n";
cout << endl;
cout << " usage: cnmsh2 InMesh OutMesh \n";
cout << " or : cnmsh2 Inmeshfile OutBdmeshfile [-g OutGeomfile ] [ -thetamax theta ] [-v level]\n";
cout << endl;
cout << " where theta is the angular limit for smooth curve in degre \n";
cout << " level is level of verbosity in [0..99] 0 => no message, 99 to much \n";
cout << endl;
cout << " remark: ";
cout << " the type of OutMesh is defined with the suffix\n";
cout << " si the suffixe is not in .am_fmt .amdba .am .nopo .msh .ftq, then \n";
cout << " the mesh is a bd mesh (cf .mesh)" << endl;
return 1;
}
MeshIstreamErrorHandler = MeshErrorIO;
set_new_handler( &NewHandler);
#ifdef DRAWING
initgraphique();
initgraph=1;
#endif
// cout << "open file in " << fin<< endl;
Triangles Th(fin,cutoffradian);
if (!fgeom)
Th.Write(fout);
else
{
// cout << " geom " << fgeom << endl;
Th.Gh.Write(fgeom);
Th.Write(fout,Triangles::BDMesh);
}
return 0;
}
static int
getvirange(int wf)
{
int pos = zlecs, ret = 0;
int mult1 = zmult, hist1 = histline;
Thingy k2;
virangeflag = 1;
wordflag = wf;
/* Now we need to execute the movement command, to see where it *
* actually goes. virangeflag here indicates to the movement *
* function that it should place the cursor at the end of the *
* range, rather than where the cursor would actually go if it *
* were executed normally. This makes a difference to some *
* commands, but not all. For example, if searching forward *
* for a character, under normal circumstances the cursor lands *
* on the character. For a range, the range must include the *
* character, so the cursor gets placed after the character if *
* virangeflag is set. vi-match-bracket needs to change the *
* value of virangeflag under some circumstances, meaning that *
* we need to change the *starting* position. */
zmod.flags &= ~MOD_TMULT;
do {
vilinerange = 0;
prefixflag = 0;
if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) ||
k2 == Th(z_sendbreak)) {
wordflag = 0;
virangeflag = 0;
return -1;
}
/*
* With k2 == bindk, the command key is repeated:
* a number of lines is used. If the function used
* returns 1, we fail.
*/
if ((k2 == bindk) ? dovilinerange() : execzlefunc(k2, zlenoargs, 1))
ret = -1;
if(vichgrepeat)
zmult = mult1;
else
zmult = mult1 * zmod.tmult;
} while(prefixflag && !ret);
wordflag = 0;
virangeflag = 0;
/* It is an error to use a non-movement command to delimit the *
* range. We here reject the case where the command modified *
* the line, or selected a different history line. */
if (histline != hist1 || zlell != lastll || memcmp(zleline, lastline, zlell)) {
histline = hist1;
ZS_memcpy(zleline, lastline, zlell = lastll);
zlecs = pos;
return -1;
}
/* Can't handle an empty file. Also, if the movement command *
* failed, or didn't move, it is an error. */
if (!zlell || (zlecs == pos && virangeflag != 2) || ret == -1)
return -1;
/* vi-match-bracket changes the value of virangeflag when *
* moving to the opening bracket, meaning that we need to *
* change the *starting* position. */
if(virangeflag == -1)
{
int origcs = zlecs;
zlecs = pos;
INCCS();
pos = zlecs;
zlecs = origcs;
}
/* Get the range the right way round. zlecs is placed at the *
* start of the range, and pos (the return value of this *
* function) is the end. */
if (zlecs > pos) {
int tmp = zlecs;
zlecs = pos;
pos = tmp;
}
/* Was it a line-oriented move? If so, the command will have set *
* the vilinerange flag. In this case, entire lines are taken, *
* rather than just the sequence of characters delimited by pos *
* and zlecs. The terminating newline is left out of the range, *
* which the real command must deal with appropriately. At this *
* point we just need to make the range encompass entire lines. */
if(vilinerange) {
int newcs = findbol();
zlecs = pos;
pos = findeol();
zlecs = newcs;
}
return pos;
}
REAL age_z(REAL x){
REAL res;
REAL abr;
int_su1p(x,tz,&res,&abr);
return res*Th();
}
REAL Tl(REAL x){
REAL res;
REAL abr;
int_l1p(0.0,x,tz,&res,&abr);
return res*Th();
}
static int
getvirange(int wf)
{
int pos = zlecs, mpos = mark, ret = 0;
int visual = region_active; /* movement command might set it */
int mult1 = zmult, hist1 = histline;
Thingy k2;
if (visual) {
if (!zlell)
return -1;
pos = mark;
vilinerange = (visual == 2);
region_active = 0;
} else {
virangeflag = 1;
wordflag = wf;
mark = -1;
/* use operator-pending keymap if one exists */
Keymap km = openkeymap("viopp");
if (km)
selectlocalmap(km);
/* Now we need to execute the movement command, to see where it *
* actually goes. virangeflag here indicates to the movement *
* function that it should place the cursor at the end of the *
* range, rather than where the cursor would actually go if it *
* were executed normally. This makes a difference to some *
* commands, but not all. For example, if searching forward *
* for a character, under normal circumstances the cursor lands *
* on the character. For a range, the range must include the *
* character, so the cursor gets placed after the character if *
* virangeflag is set. */
zmod.flags &= ~MOD_TMULT;
do {
vilinerange = 0;
prefixflag = 0;
if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) ||
k2 == Th(z_sendbreak)) {
wordflag = 0;
virangeflag = 0;
mark = mpos;
return -1;
}
/*
* With k2 == bindk, the command key is repeated:
* a number of lines is used. If the function used
* returns 1, we fail.
*/
if ((k2 == bindk) ? dovilinerange() : execzlefunc(k2, zlenoargs, 1))
ret = -1;
if(vichgrepeat)
zmult = mult1;
else
zmult = mult1 * zmod.tmult;
} while(prefixflag && !ret);
wordflag = 0;
selectlocalmap(NULL);
/* It is an error to use a non-movement command to delimit the *
* range. We here reject the case where the command modified *
* the line, or selected a different history line. */
if (histline != hist1 || zlell != lastll || memcmp(zleline, lastline, zlell)) {
histline = hist1;
ZS_memcpy(zleline, lastline, zlell = lastll);
zlecs = pos;
mark = mpos;
virangeflag = 0;
return -1;
}
/* Can't handle an empty file. Also, if the movement command *
* failed, or didn't move, it is an error. */
if (!zlell || (zlecs == pos && (mark == -1 || mark == zlecs) &&
virangeflag != 2) || ret == -1) {
mark = mpos;
virangeflag = 0;
return -1;
}
virangeflag = 0;
/* if the mark has moved, ignore the original cursor position *
* and use the mark. */
if (mark != -1)
pos = mark;
}
mark = mpos;
/* Get the range the right way round. zlecs is placed at the *
* start of the range, and pos (the return value of this *
* function) is the end. */
if (zlecs > pos) {
int tmp = zlecs;
zlecs = pos;
pos = tmp;
}
/* visual selection mode needs to include additional position */
if (visual == 1 && pos < zlell && invicmdmode())
INCPOS(pos);
/* Was it a line-oriented move? If so, the command will have set *
* the vilinerange flag. In this case, entire lines are taken, *
* rather than just the sequence of characters delimited by pos *
* and zlecs. The terminating newline is left out of the range, *
* which the real command must deal with appropriately. At this *
* point we just need to make the range encompass entire lines. */
vilinerange = (zmod.flags & MOD_LINE) ||
(vilinerange && !(zmod.flags & MOD_CHAR));
if (vilinerange) {
int newcs = findbol();
lastcol = zlecs - newcs;
zlecs = pos;
pos = findeol();
zlecs = newcs;
} else if (!visual) {
/* for a character-wise move don't include a newline at the *
* end of the range */
int prev = pos;
DECPOS(prev);
if (zleline[prev] == ZWC('\n'))
pos = prev;
}
return pos;
}
