void tex::math_ac ()
{
if (cur_cmd == ACCENT) {
print_err("Please use ");
print_esc("mathaccent");
print(" for accents in math mode");
help_math_accent();
error();
}
tail_append(new_node(ACCENT_NOAD_SIZE));
type(tail) = ACCENT_NOAD;
subtype(tail) = NORMAL;
mzero(nucleus(tail));
mzero(subscr(tail));
mzero(supscr(tail));
math_type(accent_chr(tail)) = MATH_CHAR;
scan_fifteen_bit_int();
character(accent_chr(tail)) = cur_val % 256;
if (cur_val >= VAR_CODE && fam_in_range()) {
fam(accent_chr(tail)) = cur_fam;
} else {
fam(accent_chr(tail)) = cur_val / 256 % 16;
}
scan_math(nucleus(tail));
}
void tex::set_math_char(int c)
{
ptr p;
if (c >= 0100000) {
cur_cs = active_base[cur_chr];
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
x_token();
back_input();
} else {
p = new_noad();
math_type(nucleus(p)) = MATH_CHAR;
character(nucleus(p)) = c % 256;
fam(nucleus(p)) = c / 256 % 16;
if (c >= VAR_CODE) {
if (fam_in_range())
fam(nucleus(p)) = cur_fam;
type(p) = ORD_NOAD;
} else {
type(p) = ORD_NOAD + c / 010000;
}
tail_append(p);
}
}
void tex::scan_math(ptr p)
{
int c;
restart:
get_nbrx_token();
reswitch:
switch (cur_cmd)
{
case LETTER:
case OTHER_CHAR:
case CHAR_GIVEN:
c = math_code(cur_chr);
if (c == 0100000) {
cur_cs = active_base[cur_chr];
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
x_token();
back_input();
goto restart;
}
break;
case CHAR_NUM:
scan_char_num();
cur_chr = cur_val;
cur_cmd = CHAR_GIVEN;
goto reswitch;
case MATH_CHAR_NUM:
scan_fifteen_bit_int();
c = cur_val;
break;
case MATH_GIVEN:
c = cur_chr;
break;
case DELIM_NUM:
scan_twenty_seven_bit_int();
c = cur_val / 010000;
break;
default:
back_input();
scan_left_brace();
saved(0) = p;
incr(save_ptr);
push_math(MATH_GROUP);
return;
}
math_type(p) = MATH_CHAR;
character(p) = c % 256;
if (c >= VAR_CODE && fam_in_range()) {
fam(p) = cur_fam;
} else {
fam(p) = c / 256 % 16;
}
}
void lfmxsp(smpar *sp, mxArray *mcell, int d)
{ double *alpha;
char str[16];
alpha = mxGetPr(mxGetField(mcell,0,"alpha"));
nn(sp) = alpha[0];
fixh(sp)= alpha[1];
pen(sp) = alpha[2];
mxGetString(mxGetField(mcell,0,"adaptive_criterion"),str,16);
acri(sp) = lfacri(str);
deg(sp) = mxGetPr(mxGetField(mcell,0,"degree"))[0];
deg0(sp) = -1;
mxGetString(mxGetField(mcell,0,"family"),str,16);
fam(sp) = lffamily(str);
mxGetString(mxGetField(mcell,0,"link"),str,16);
link(sp) = lflink(str);
setfamily(sp);
mxGetString(mxGetField(mcell,0,"kernel"),str,16);
ker(sp) = lfkernel(str);
mxGetString(mxGetField(mcell,0,"kernel_type"),str,16);
kt(sp) = lfketype(str);
npar(sp) = calcp(sp,d);
de_renorm = (int)(mxGetPr(mxGetField(mcell,0,"deren"))[0]);
mxGetString(mxGetField(mcell,0,"deit"),str,16);
de_itype = deitype(str);
de_mint = (int)(mxGetPr(mxGetField(mcell,0,"demint"))[0]);
lf_debug = (int)(mxGetPr(mxGetField(mcell,0,"debug"))[0]);
}
void RecTestCase::TestFamily()
{
idt id;
recFamily record1;
record1.f_id = 0;
record1.f_husb_id = 3;
record1.f_wife_id = 4;
// f_id = 0 so create new record and set f_id to new value.
record1.Save();
id = record1.f_id;
// Database is created with initial default family, so this is 2.
CPPUNIT_ASSERT( id == 2 );
recFamily record2;
record2.f_id = record1.f_id;
record2.Read();
CPPUNIT_ASSERT( record1 == record2 );
record1.f_husb_id = 16;
record1.f_wife_id = 15;
// f_id = 1 which exists, so amend record leaving f_id to old value.
record1.Save();
CPPUNIT_ASSERT( record1.f_id == id );
record2.Read();
CPPUNIT_ASSERT( record1 == record2 );
record1.f_id = 999;
record1.f_husb_id = 8888;
// f_id = 999 which doesn't exists, so create new record with no change to f_id.
record1.Save();
CPPUNIT_ASSERT( record1.f_id == 999 );
record2.f_id = record1.f_id;
record2.Read();
CPPUNIT_ASSERT( record1 == record2 );
record1.f_id = 0;
record1.f_husb_id = 7777;
record1.Save();
CPPUNIT_ASSERT( record1.f_id != 0 );
CPPUNIT_ASSERT( record1.Exists() == true );
record1.Delete();
CPPUNIT_ASSERT( record1.Exists() == false );
CPPUNIT_ASSERT( recFamily::Exists( 999 ) == true );
recFamily::Delete( 999 );
CPPUNIT_ASSERT( recFamily::Exists( 999 ) == false );
// Create some records for later testing
recFamily fam(0);
fam.FSetID( 5 );
fam.Save();
fam.FSetID( 11 );
fam.Save();
}
static bool ProcessFamiliesFromFontList(wxFontEnumerator *This,
char **fonts,
int nFonts)
{
#if wxUSE_REGEX
wxRegEx re(wxT("^(-[^-]*){14}$"), wxRE_NOSUB);
#endif // wxUSE_REGEX
// extract the list of (unique) font families
wxSortedArrayString families;
for ( int n = 0; n < nFonts; n++ )
{
char *font = fonts[n];
#if wxUSE_REGEX
if ( !re.Matches(font) )
#else // !wxUSE_REGEX
if ( !wxString(font).Matches(wxT("-*-*-*-*-*-*-*-*-*-*-*-*-*-*")) )
#endif // wxUSE_REGEX/!wxUSE_REGEX
{
// it's not a full font name (probably an alias)
continue;
}
// coverity[returned_null]
char *dash = strchr(font + 1, '-');
char *family = dash + 1;
dash = strchr(family, '-');
*dash = '\0'; // !NULL because Matches() above succeeded
wxString fam(family);
if ( families.Index(fam) == wxNOT_FOUND )
{
if ( !This->OnFacename(fam) )
{
// stop enumerating
return false;
}
families.Add(fam);
}
//else: already seen
}
return true;
}
int GModel::readMED(const std::string &name)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0) {
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
med_int v[3], vf[3];
MEDversionDonner(&v[0], &v[1], &v[2]);
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
Msg::Info("Reading MED file V%d.%d.%d using MED library V%d.%d.%d",
vf[0], vf[1], vf[2], v[0], v[1], v[2]);
if(vf[0] < 2 || (vf[0] == 2 && vf[1] < 2)){
Msg::Error("Cannot read MED file older than V2.2");
return 0;
}
std::vector<std::string> meshNames;
for(int i = 0; i < MEDnMaa(fid); i++){
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim, nStep;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, i + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, i + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
meshNames.push_back(meshName);
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
int ret = 1;
for(unsigned int i = 0; i < meshNames.size(); i++){
// we use the filename as a kind of "partition" indicator, allowing to
// complete a model part by part (used e.g. in DDM, since MED does not store
// a partition index)
GModel *m = findByName(meshNames[i], name);
if(!m) m = new GModel(meshNames[i]);
ret = m->readMED(name, i);
if(!ret) return 0;
}
return ret;
}
int GModel::readMED(const std::string &name, int meshIndex)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
int numMeshes = MEDnMaa(fid);
if(meshIndex >= numMeshes){
Msg::Info("Could not find mesh %d in MED file", meshIndex);
return 0;
}
checkPointMaxNumbers();
GModel::setCurrent(this); // make sure we increment max nums in this model
// read mesh info
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim, nStep = 1;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
// FIXME: we should support multi-step MED3 meshes (probably by
// storing each mesh as a separate model, with a naming convention
// e.g. meshName_step%d). This way we could also handle multi-mesh
// time sequences in MED3.
if(nStep > 1)
Msg::Warning("Discarding %d last meshes in multi-step MED mesh", nStep - 1);
setName(meshName);
setFileName(name);
if(meshType == MED_NON_STRUCTURE){
Msg::Info("Reading %d-D unstructured mesh <<%s>>", spaceDim, meshName);
}
else{
Msg::Error("Reading structured MED meshes is not supported");
return 0;
}
med_int vf[3];
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
// read nodes
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord, geoTransform;
med_int numNodes = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, MED_COORDINATE, MED_NO_CMODE,
&changeOfCoord, &geoTransform);
#else
med_int numNodes = MEDnEntMaa(fid, meshName, MED_COOR, MED_NOEUD, MED_NONE,
MED_NOD);
#endif
if(numNodes < 0){
Msg::Error("Could not read number of MED nodes");
return 0;
}
if(numNodes == 0){
Msg::Error("No nodes in MED mesh");
return 0;
}
std::vector<MVertex*> verts(numNodes);
std::vector<med_float> coord(spaceDim * numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeCoordinateRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
&coord[0]) < 0){
#else
std::vector<char> coordName(spaceDim * MED_TAILLE_PNOM + 1);
std::vector<char> coordUnit(spaceDim * MED_TAILLE_PNOM + 1);
med_repere rep;
if(MEDcoordLire(fid, meshName, spaceDim, &coord[0], MED_FULL_INTERLACE,
MED_ALL, 0, 0, &rep, &coordName[0], &coordUnit[0]) < 0){
#endif
Msg::Error("Could not read MED node coordinates");
return 0;
}
std::vector<med_int> nodeTags(numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, &nodeTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &nodeTags[0], numNodes, MED_NOEUD, MED_NONE) < 0)
#endif
nodeTags.clear();
for(int i = 0; i < numNodes; i++)
verts[i] = new MVertex(coord[spaceDim * i],
(spaceDim > 1) ? coord[spaceDim * i + 1] : 0.,
(spaceDim > 2) ? coord[spaceDim * i + 2] : 0.,
0, nodeTags.empty() ? 0 : nodeTags[i]);
// read elements (loop over all possible MSH element types)
for(int mshType = 0; mshType < MSH_NUM_TYPE; mshType++){
med_geometrie_element type = msh2medElementType(mshType);
if(type == MED_NONE) continue;
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord;
med_bool geoTransform;
med_int numEle = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_CONNECTIVITY, MED_NODAL, &changeOfCoord,
&geoTransform);
#else
med_int numEle = MEDnEntMaa(fid, meshName, MED_CONN, MED_MAILLE, type, MED_NOD);
#endif
if(numEle <= 0) continue;
int numNodPerEle = type % 100;
std::vector<med_int> conn(numEle * numNodPerEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementConnectivityRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_NODAL, MED_FULL_INTERLACE, &conn[0]) < 0){
#else
if(MEDconnLire(fid, meshName, spaceDim, &conn[0], MED_FULL_INTERLACE, 0, MED_ALL,
MED_MAILLE, type, MED_NOD) < 0){
#endif
Msg::Error("Could not read MED elements");
return 0;
}
std::vector<med_int> fam(numEle, 0);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityFamilyNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &fam[0]) < 0){
#else
if(MEDfamLire(fid, meshName, &fam[0], numEle, MED_MAILLE, type) < 0){
#endif
Msg::Info("No family number for elements: using 0 as default family number");
}
std::vector<med_int> eleTags(numEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &eleTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &eleTags[0], numEle, MED_MAILLE, type) < 0)
#endif
eleTags.clear();
std::map<int, std::vector<MElement*> > elements;
MElementFactory factory;
for(int j = 0; j < numEle; j++){
std::vector<MVertex*> v(numNodPerEle);
for(int k = 0; k < numNodPerEle; k++)
v[k] = verts[conn[numNodPerEle * j + med2mshNodeIndex(type, k)] - 1];
MElement *e = factory.create(mshType, v, eleTags.empty() ? 0 : eleTags[j]);
if(e) elements[-fam[j]].push_back(e);
}
_storeElementsInEntities(elements);
}
_associateEntityWithMeshVertices();
_storeVerticesInEntities(verts);
// read family info
med_int numFamilies = MEDnFam(fid, meshName);
if(numFamilies < 0){
Msg::Error("Could not read MED families");
return 0;
}
for(int i = 0; i < numFamilies; i++){
#if (MED_MAJOR_NUM == 3)
med_int numAttrib = (vf[0] == 2) ? MEDnFamily23Attribute(fid, meshName, i + 1) : 0;
med_int numGroups = MEDnFamilyGroup(fid, meshName, i + 1);
#else
med_int numAttrib = MEDnAttribut(fid, meshName, i + 1);
med_int numGroups = MEDnGroupe(fid, meshName, i + 1);
#endif
if(numAttrib < 0 || numGroups < 0){
Msg::Error("Could not read MED groups or attributes");
return 0;
}
std::vector<med_int> attribId(numAttrib + 1);
std::vector<med_int> attribVal(numAttrib + 1);
std::vector<char> attribDes(MED_TAILLE_DESC * numAttrib + 1);
std::vector<char> groupNames(MED_TAILLE_LNOM * numGroups + 1);
char familyName[MED_TAILLE_NOM + 1];
med_int familyNum;
#if (MED_MAJOR_NUM == 3)
if(vf[0] == 2){ // MED2 file
if(MEDfamily23Info(fid, meshName, i + 1, familyName, &attribId[0],
&attribVal[0], &attribDes[0], &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED2 family %d", i + 1);
continue;
}
}
else{
if(MEDfamilyInfo(fid, meshName, i + 1, familyName, &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED3 family %d", i + 1);
continue;
}
}
#else
if(MEDfamInfo(fid, meshName, i + 1, familyName, &familyNum, &attribId[0],
&attribVal[0], &attribDes[0], &numAttrib, &groupNames[0],
&numGroups) < 0){
Msg::Error("Could not read info for MED family %d", i + 1);
continue;
}
#endif
// family tags are unique (for all dimensions)
GEntity *ge;
if((ge = getRegionByTag(-familyNum))){}
else if((ge = getFaceByTag(-familyNum))){}
else if((ge = getEdgeByTag(-familyNum))){}
else ge = getVertexByTag(-familyNum);
if(ge){
elementaryNames[std::pair<int, int>(ge->dim(), -familyNum)] = familyName;
if(numGroups > 0){
for(int j = 0; j < numGroups; j++){
char tmp[MED_TAILLE_LNOM + 1];
strncpy(tmp, &groupNames[j * MED_TAILLE_LNOM], MED_TAILLE_LNOM);
tmp[MED_TAILLE_LNOM] = '\0';
// don't use same physical number across dimensions, as e.g. getdp
// does not support this
int pnum = setPhysicalName(tmp, ge->dim(), getMaxPhysicalNumber(-1) + 1);
if(std::find(ge->physicals.begin(), ge->physicals.end(), pnum) ==
ge->physicals.end())
ge->physicals.push_back(pnum);
}
}
}
}
// check if we need to read some post-processing data later
#if (MED_MAJOR_NUM == 3)
bool postpro = (MEDnField(fid) > 0) ? true : false;
#else
bool postpro = (MEDnChamp(fid, 0) > 0) ? true : false;
#endif
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return postpro ? 2 : 1;
}
template<class T>
static void fillElementsMED(med_int family, std::vector<T*> &elements,
std::vector<med_int> &conn, std::vector<med_int> &fam,
med_geometrie_element &type)
{
if(elements.empty()) return;
type = msh2medElementType(elements[0]->getTypeForMSH());
if(type == MED_NONE){
Msg::Warning("Unsupported element type in MED format");
return;
}
for(unsigned int i = 0; i < elements.size(); i++){
elements[i]->setVolumePositive();
for(int j = 0; j < elements[i]->getNumVertices(); j++)
conn.push_back(elements[i]->getVertex(med2mshNodeIndex(type, j))->getIndex());
fam.push_back(family);
}
}
static void writeElementsMED(med_idt &fid, char *meshName, std::vector<med_int> &conn,
std::vector<med_int> &fam, med_geometrie_element type)
{
if(fam.empty()) return;
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_CELL, type,
MED_NODAL, MED_FULL_INTERLACE, (med_int)fam.size(),
&conn[0], MED_FALSE, 0, MED_FALSE, 0, MED_TRUE, &fam[0]) < 0)
#else
if(MEDelementsEcr(fid, meshName, (med_int)3, &conn[0], MED_FULL_INTERLACE,
0, MED_FAUX, 0, MED_FAUX, &fam[0], (med_int)fam.size(),
MED_MAILLE, type, MED_NOD) < 0)
#endif
Msg::Error("Could not write MED elements");
}
int GModel::writeMED(const std::string &name, bool saveAll, double scalingFactor)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_CREATION);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
// write header
if(MEDfichDesEcr(fid, (char*)"MED file generated by Gmsh") < 0){
Msg::Error("Unable to write MED descriptor");
return 0;
}
char *meshName = (char*)getName().c_str();
// Gmsh always writes 3D unstructured meshes
#if (MED_MAJOR_NUM == 3)
char dtUnit[MED_SNAME_SIZE + 1] = "";
char axisName[3 * MED_SNAME_SIZE + 1] = "";
char axisUnit[3 * MED_SNAME_SIZE + 1] = "";
if(MEDmeshCr(fid, meshName, 3, 3, MED_UNSTRUCTURED_MESH, "Mesh created with Gmsh",
dtUnit, MED_SORT_DTIT, MED_CARTESIAN, axisName, axisUnit) < 0){
#else
if(MEDmaaCr(fid, meshName, 3, MED_NON_STRUCTURE,
(char*)"Mesh created with Gmsh") < 0){
#endif
Msg::Error("Could not create MED mesh");
return 0;
}
// if there are no physicals we save all the elements
if(noPhysicalGroups()) saveAll = true;
// index the vertices we save in a continuous sequence (MED
// connectivity is given in terms of vertex indices)
indexMeshVertices(saveAll);
// get a vector containing all the geometrical entities in the
// model (the ordering of the entities must be the same as the one
// used during the indexing of the vertices)
std::vector<GEntity*> entities;
getEntities(entities);
std::map<GEntity*, int> families;
// write the families
{
// always create a "0" family, with no groups or attributes
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, "F_0", 0, 0, "") < 0)
#else
if(MEDfamCr(fid, meshName, (char*)"F_0", 0, 0, 0, 0, 0, 0, 0) < 0)
#endif
Msg::Error("Could not create MED family 0");
// create one family per elementary entity, with one group per
// physical entity and no attributes
for(unsigned int i = 0; i < entities.size(); i++){
if(saveAll || entities[i]->physicals.size()){
int num = - ((int)families.size() + 1);
families[entities[i]] = num;
std::ostringstream fs;
fs << entities[i]->dim() << "D_" << entities[i]->tag();
std::string familyName = "F_" + fs.str();
std::string groupName;
for(unsigned j = 0; j < entities[i]->physicals.size(); j++){
std::string tmp = getPhysicalName
(entities[i]->dim(), entities[i]->physicals[j]);
if(tmp.empty()){ // create unique name
std::ostringstream gs;
gs << entities[i]->dim() << "D_" << entities[i]->physicals[j];
groupName += "G_" + gs.str();
}
else
groupName += tmp;
groupName.resize((j + 1) * MED_TAILLE_LNOM, ' ');
}
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, familyName.c_str(),
(med_int)num, (med_int)entities[i]->physicals.size(),
groupName.c_str()) < 0)
#else
if(MEDfamCr(fid, meshName, (char*)familyName.c_str(),
(med_int)num, 0, 0, 0, 0, (char*)groupName.c_str(),
(med_int)entities[i]->physicals.size()) < 0)
#endif
Msg::Error("Could not create MED family %d", num);
}
}
}
// write the nodes
{
std::vector<med_float> coord;
std::vector<med_int> fam;
for(unsigned int i = 0; i < entities.size(); i++){
for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++){
MVertex *v = entities[i]->mesh_vertices[j];
if(v->getIndex() >= 0){
coord.push_back(v->x() * scalingFactor);
coord.push_back(v->y() * scalingFactor);
coord.push_back(v->z() * scalingFactor);
fam.push_back(0); // we never create node families
}
}
}
if(fam.empty()){
Msg::Error("No nodes to write in MED mesh");
return 0;
}
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_FULL_INTERLACE,
(med_int)fam.size(), &coord[0], MED_FALSE, "", MED_FALSE, 0,
MED_TRUE, &fam[0]) < 0)
#else
char coordName[3 * MED_TAILLE_PNOM + 1] =
"x y z ";
char coordUnit[3 * MED_TAILLE_PNOM + 1] =
"unknown unknown unknown ";
if(MEDnoeudsEcr(fid, meshName, (med_int)3, &coord[0], MED_FULL_INTERLACE,
MED_CART, coordName, coordUnit, 0, MED_FAUX, 0, MED_FAUX,
&fam[0], (med_int)fam.size()) < 0)
#endif
Msg::Error("Could not write nodes");
}
// write the elements
{
{ // points
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(viter it = firstVertex(); it != lastVertex(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->points, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // lines
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(eiter it = firstEdge(); it != lastEdge(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->lines, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // triangles
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->triangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // quads
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->quadrangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // tets
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->tetrahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // hexas
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->hexahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // prisms
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->prisms, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // pyramids
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->pyramids, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return 1;
}
#else
int GModel::readMED(const std::string &name)
{
Msg::Error("Gmsh must be compiled with MED support to read '%s'",
name.c_str());
return 0;
}
/*
* Runs the command object cmdobj on the db with name dbname and puts result in result.
* @param dbname, name of db
* @param cmdobj, object that contains entire command
* @param options
* @param errmsg, reference to error message
* @param result, reference to builder for result
* @param fromRepl
* @return true if successful, false otherwise
*/
bool FTSCommand::_run(const string& dbname,
BSONObj& cmdObj,
int cmdOptions,
const string& ns,
const string& searchString,
string language, // "" for not-set
int limit,
BSONObj& filter,
BSONObj& projection,
string& errmsg,
BSONObjBuilder& result ) {
Timer comm;
scoped_ptr<Projection> pr;
if ( !projection.isEmpty() ) {
pr.reset( new Projection() );
pr->init( projection );
}
// priority queue for results
Results results;
Database* db = cc().database();
Collection* collection = db->getCollection( ns );
if ( !collection ) {
errmsg = "can't find ns";
return false;
}
vector<int> idxMatches;
collection->details()->findIndexByType( INDEX_NAME, idxMatches );
if ( idxMatches.size() == 0 ) {
errmsg = str::stream() << "no text index for: " << ns;
return false;
}
if ( idxMatches.size() > 1 ) {
errmsg = str::stream() << "too many text indexes for: " << ns;
return false;
}
BSONObj indexPrefix;
IndexDescriptor* descriptor = collection->getIndexCatalog()->getDescriptor(idxMatches[0]);
auto_ptr<FTSAccessMethod> fam(new FTSAccessMethod(descriptor));
if ( language == "" ) {
language = fam->getSpec().defaultLanguage().str();
}
Status s = fam->getSpec().getIndexPrefix( filter, &indexPrefix );
if ( !s.isOK() ) {
errmsg = s.toString();
return false;
}
FTSQuery query;
if ( !query.parse( searchString, language ).isOK() ) {
errmsg = "can't parse search";
return false;
}
result.append( "queryDebugString", query.debugString() );
result.append( "language", language );
FTSSearch search(descriptor, fam->getSpec(), indexPrefix, query, filter );
search.go( &results, limit );
// grab underlying container inside priority queue
vector<ScoredLocation> r( results.dangerous() );
// sort results by score (not always in correct order, especially w.r.t. multiterm)
sort( r.begin(), r.end() );
// build the results bson array shown to user
BSONArrayBuilder a( result.subarrayStart( "results" ) );
int tempSize = 1024 * 1024; // leave a mb for other things
long long numReturned = 0;
for ( unsigned n = 0; n < r.size(); n++ ) {
BSONObj obj = BSONObj::make(r[n].rec);
BSONObj toSendBack = obj;
if ( pr ) {
toSendBack = pr->transform(obj);
}
if ( ( tempSize + toSendBack.objsize() ) >= BSONObjMaxUserSize ) {
break;
}
BSONObjBuilder x( a.subobjStart() );
x.append( "score" , r[n].score );
x.append( "obj", toSendBack );
BSONObj xobj = x.done();
tempSize += xobj.objsize();
numReturned++;
}
a.done();
// returns some stats to the user
BSONObjBuilder bb( result.subobjStart( "stats" ) );
bb.appendNumber( "nscanned" , search.getKeysLookedAt() );
bb.appendNumber( "nscannedObjects" , search.getObjLookedAt() );
bb.appendNumber( "n" , numReturned );
bb.appendNumber( "nfound" , r.size() );
bb.append( "timeMicros", (int)comm.micros() );
bb.done();
return true;
}
PlanStage* buildStages(const string& ns, const QuerySolutionNode* root, WorkingSet* ws) {
if (STAGE_COLLSCAN == root->getType()) {
const CollectionScanNode* csn = static_cast<const CollectionScanNode*>(root);
CollectionScanParams params;
params.ns = csn->name;
params.tailable = csn->tailable;
params.direction = (csn->direction == 1) ? CollectionScanParams::FORWARD
: CollectionScanParams::BACKWARD;
return new CollectionScan(params, ws, csn->filter.get());
}
else if (STAGE_IXSCAN == root->getType()) {
const IndexScanNode* ixn = static_cast<const IndexScanNode*>(root);
//
// XXX XXX
// Given that this grabs data from the catalog, we must do this inside of a lock.
// We should change this to take a (ns, index key pattern) pair so that the params
// don't involve any on-disk data, just descriptions thereof.
// XXX XXX
//
Database* db = cc().database();
Collection* collection = db ? db->getCollection( ns ) : NULL;
if (NULL == collection) {
warning() << "Can't ixscan null ns " << ns << endl;
return NULL;
}
NamespaceDetails* nsd = collection->details();
int idxNo = nsd->findIndexByKeyPattern(ixn->indexKeyPattern);
if (-1 == idxNo) {
warning() << "Can't find idx " << ixn->indexKeyPattern.toString()
<< "in ns " << ns << endl;
return NULL;
}
IndexScanParams params;
params.descriptor = collection->getIndexCatalog()->getDescriptor( idxNo );
params.bounds = ixn->bounds;
params.direction = ixn->direction;
params.limit = ixn->limit;
return new IndexScan(params, ws, ixn->filter.get());
}
else if (STAGE_FETCH == root->getType()) {
const FetchNode* fn = static_cast<const FetchNode*>(root);
PlanStage* childStage = buildStages(ns, fn->children[0], ws);
if (NULL == childStage) { return NULL; }
return new FetchStage(ws, childStage, fn->filter.get());
}
else if (STAGE_SORT == root->getType()) {
const SortNode* sn = static_cast<const SortNode*>(root);
PlanStage* childStage = buildStages(ns, sn->children[0], ws);
if (NULL == childStage) { return NULL; }
SortStageParams params;
params.pattern = sn->pattern;
params.query = sn->query;
return new SortStage(params, ws, childStage);
}
else if (STAGE_PROJECTION == root->getType()) {
const ProjectionNode* pn = static_cast<const ProjectionNode*>(root);
PlanStage* childStage = buildStages(ns, pn->children[0], ws);
if (NULL == childStage) { return NULL; }
return new ProjectionStage(pn->projection, pn->fullExpression, ws, childStage);
}
else if (STAGE_LIMIT == root->getType()) {
const LimitNode* ln = static_cast<const LimitNode*>(root);
PlanStage* childStage = buildStages(ns, ln->children[0], ws);
if (NULL == childStage) { return NULL; }
return new LimitStage(ln->limit, ws, childStage);
}
else if (STAGE_SKIP == root->getType()) {
const SkipNode* sn = static_cast<const SkipNode*>(root);
PlanStage* childStage = buildStages(ns, sn->children[0], ws);
if (NULL == childStage) { return NULL; }
return new SkipStage(sn->skip, ws, childStage);
}
else if (STAGE_AND_HASH == root->getType()) {
const AndHashNode* ahn = static_cast<const AndHashNode*>(root);
auto_ptr<AndHashStage> ret(new AndHashStage(ws, ahn->filter.get()));
for (size_t i = 0; i < ahn->children.size(); ++i) {
PlanStage* childStage = buildStages(ns, ahn->children[i], ws);
if (NULL == childStage) { return NULL; }
ret->addChild(childStage);
}
return ret.release();
}
else if (STAGE_OR == root->getType()) {
const OrNode * orn = static_cast<const OrNode*>(root);
auto_ptr<OrStage> ret(new OrStage(ws, orn->dedup, orn->filter.get()));
for (size_t i = 0; i < orn->children.size(); ++i) {
PlanStage* childStage = buildStages(ns, orn->children[i], ws);
if (NULL == childStage) { return NULL; }
ret->addChild(childStage);
}
return ret.release();
}
else if (STAGE_AND_SORTED == root->getType()) {
const AndSortedNode* asn = static_cast<const AndSortedNode*>(root);
auto_ptr<AndSortedStage> ret(new AndSortedStage(ws, asn->filter.get()));
for (size_t i = 0; i < asn->children.size(); ++i) {
PlanStage* childStage = buildStages(ns, asn->children[i], ws);
if (NULL == childStage) { return NULL; }
ret->addChild(childStage);
}
return ret.release();
}
else if (STAGE_SORT_MERGE == root->getType()) {
const MergeSortNode* msn = static_cast<const MergeSortNode*>(root);
MergeSortStageParams params;
params.dedup = msn->dedup;
params.pattern = msn->sort;
auto_ptr<MergeSortStage> ret(new MergeSortStage(params, ws));
for (size_t i = 0; i < msn->children.size(); ++i) {
PlanStage* childStage = buildStages(ns, msn->children[i], ws);
if (NULL == childStage) { return NULL; }
ret->addChild(childStage);
}
return ret.release();
}
else if (STAGE_GEO_2D == root->getType()) {
const Geo2DNode* node = static_cast<const Geo2DNode*>(root);
TwoDParams params;
params.gq = node->gq;
params.filter = node->filter.get();
params.indexKeyPattern = node->indexKeyPattern;
params.ns = ns;
return new TwoD(params, ws);
}
else if (STAGE_GEO_NEAR_2D == root->getType()) {
const GeoNear2DNode* node = static_cast<const GeoNear2DNode*>(root);
TwoDNearParams params;
params.nearQuery = node->nq;
params.ns = ns;
params.indexKeyPattern = node->indexKeyPattern;
params.filter = node->filter.get();
params.numWanted = node->numWanted;
// XXX XXX where do we grab this from?? the near query...modify geo parser... :(
params.uniqueDocs = false;
// XXX XXX where do we grab this from?? the near query...modify geo parser... :(
return new TwoDNear(params, ws);
}
else if (STAGE_GEO_NEAR_2DSPHERE == root->getType()) {
const GeoNear2DSphereNode* node = static_cast<const GeoNear2DSphereNode*>(root);
return new S2NearStage(ns, node->indexKeyPattern, node->nq, node->baseBounds,
node->filter.get(), ws);
}
else if (STAGE_TEXT == root->getType()) {
const TextNode* node = static_cast<const TextNode*>(root);
Database* db = cc().database();
Collection* collection = db ? db->getCollection( ns ) : NULL;
if (NULL == collection) { return NULL; }
vector<int> idxMatches;
collection->details()->findIndexByType("text", idxMatches);
if (1 != idxMatches.size()) { return NULL; }
IndexDescriptor* index = collection->getIndexCatalog()->getDescriptor(idxMatches[0]);
auto_ptr<FTSAccessMethod> fam(new FTSAccessMethod(index));
TextStageParams params(fam->getSpec());
params.ns = ns;
params.index = index;
params.spec = fam->getSpec();
params.limit = node->_numWanted;
Status s = fam->getSpec().getIndexPrefix(BSONObj(), ¶ms.indexPrefix);
if (!s.isOK()) { return NULL; }
string language = ("" == node->_language
? fam->getSpec().defaultLanguage().str()
: node->_language);
FTSQuery ftsq;
Status parseStatus = ftsq.parse(node->_query, language);
if (!parseStatus.isOK()) { return NULL; }
params.query = ftsq;
return new TextStage(params, ws, node->filter.get());
}
else if (STAGE_SHARDING_FILTER == root->getType()) {
const ShardingFilterNode* fn = static_cast<const ShardingFilterNode*>(root);
PlanStage* childStage = buildStages(ns, fn->children[0], ws);
if (NULL == childStage) { return NULL; }
return new ShardFilterStage(ns, ws, childStage);
}
else {
stringstream ss;
root->appendToString(&ss, 0);
warning() << "Could not build exec tree for node " << ss.str() << endl;
return NULL;
}
}