const TrackManager* OnboardComputer::getTrackManagerByName(const char* const name) const
{
const TrackManager* p = 0;
const Basic::Pair* pair = findByName(name);
if (pair != 0) {
p = dynamic_cast<const TrackManager*>( pair->object() );
}
return p;
}
//------------------------------------------------------------------------------
// getTrackManagerByName() -- return a track manager by name
//------------------------------------------------------------------------------
TrackManager* OnboardComputer::getTrackManagerByName(const char* const name)
{
TrackManager* p = nullptr;
base::Pair* pair = findByName(name);
if (pair != nullptr) {
p = dynamic_cast<TrackManager*>( pair->object() );
}
return p;
}
// Send an event message to component 'id'
bool Component::send(const char* const id, const int event)
{
bool val {};
Pair* p = findByName(id);
if (p != nullptr) {
const auto g = static_cast<Component*>(p->object());
val = g->event(event);
}
return val;
}
virtual ActivePet* load(std::wstring petname) {
ActivePet* r = findByName(petname);
if (!r) {
r = openPet(petname, m_password);
if (r) {
m_pets.push_back(r);
}
}
return r;
}
void TCompBoneTracker::onGroupCreated(const TMsgEntityGroupCreated& msg) {
h_entity = findByName(*msg.handles, entity_name);
CEntity* e = h_entity;
if (!e)
return;
TCompSkeleton* skel = e->get<TCompSkeleton>();
if (!skel)
return;
bone_id = skel->model->getSkeleton()->getCoreSkeleton()->getCoreBoneId(bone_name);
}
// Send an event message to component 'id'
bool Component::send(const char* const id, const int event)
{
bool val = false;
Pair* p = findByName(id);
if (p != 0) {
Component* g = (Component*) p->object();
val = g->event(event);
}
return val;
}
bool Rename( const FSString& oldName, const FSString& newName )
{
FSArchNode* n = findByName( newName );
if ( !n )
{
return false;
}
n->name = newName;
return true;
}
FSArchNode* FSArchNode::Add( const FSArchNode& fsArchNode )
{
if ( findByName( fsArchNode.name ) )
{
return nullptr;
}
content.push_back( fsArchNode );
FSArchNode* Dir = &content.back();
Dir->parentDir = this;
return Dir;
}
//------------------------------------------------------------------------------
// select() -- select one of our components, using String or Number
//------------------------------------------------------------------------------
bool Component::select(const String* const name)
{
bool ok {true};
selected = nullptr;
setSelectionName(nullptr);
if (name != nullptr) {
setSelectionName(name);
Pair* p = findByName(*name);
if (p != nullptr) selected = static_cast<Component*>(p->object());
else {
std::cerr << "Component::select: name not found!" << std::endl;
ok = false;
}
}
return ok;
}
//------------------------------------------------------------------------------
// select() -- select one of our components, using String or Number
//------------------------------------------------------------------------------
bool Component::select(const String* const name)
{
bool ok = true;
selected = 0;
setSelectionName(0);
if (name != 0) {
setSelectionName(name);
Pair* p = findByName(*name);
if (p != 0) selected = (Component*) p->object();
else {
std::cerr << "Component::select: name not found!" << std::endl;
ok = false;
}
}
return ok;
}
bool SplashScreenState::keyPressed(const OIS::KeyEvent &keyEventRef)
{
if (OgreFramework::getSingletonPtr()->m_pKeyboard->isKeyDown(OIS::KC_ESCAPE))
{
m_bQuit = true;
return true;
}
if (OgreFramework::getSingletonPtr()->m_pKeyboard->isKeyDown(OIS::KC_RETURN) ||
OgreFramework::getSingletonPtr()->m_pKeyboard->isKeyDown(OIS::KC_SPACE))
{
changeAppState(findByName("MenuState"));
}
OgreFramework::getSingletonPtr()->keyPressed(keyEventRef);
return true;
}
bool CDropTarget::EnterViewMsg(CEnterViewMsg *msg) {
if (!_itemName.empty()) {
CGameObject *obj = dynamic_cast<CGameObject *>(findByName(_itemName));
if (!obj) {
loadFrame(_dragFrame);
_cursorId = _dragCursorId;
} else if (_clipName.empty()) {
loadFrame(_dropFrame);
} else {
playClip(_clipName, _clipFlags);
}
_cursorId = _dropCursorId;
}
return true;
}
void Widget::serverDownloadStart()
{
QTreeWidgetItem * item = ftpFiles->invisibleRootItem();
QTreeWidgetItem * header = ftpFiles->headerItem();
QStringList lst;
Computer * comp;
for(int i = 1; i < ftpFiles->columnCount(); i++)
{
lst = rebuildPath(item, "", i);
comp = findByName(header->text(i));
foreach(QString str, lst)
{
comp->getSocket()->write(QByteArray("ADFL::" + str.toAscii()));
}
comp->getSocket()->write(QByteArray("DNLD::"));
}
/**
* @brief Translate color value to terrain type to random weather code
* @param[in] tdef The terrain definition to add
*/
bool TerrainDefs::add(const TerrainDef* tdef) {
/* check for duplicate color code */
if (findByColor(tdef->rgbRed, tdef->rgbGreen, tdef->rgbBlue))
return false;
/* check for duplicate name */
if (findByName(tdef->terrainName))
return false;
for (int i = 0; i < MAX_TERRAINDEFS - 1; i++) {
if (!terrainDefTable[i]) {
terrainDefTable[i] = tdef;
terrainDefTable[i + 1] = nullptr;
return true;
}
}
return false;
}
bool ReplSetImpl::shouldChangeSyncTarget(const HostAndPort& currentTarget) {
lock lk(this);
OpTime targetOpTime = findByName(currentTarget.toString())->hbinfo().opTime;
for (Member *m = _members.head(); m; m = m->next()) {
if (m->syncable() &&
targetOpTime.getSecs()+maxSyncSourceLagSecs < m->hbinfo().opTime.getSecs()) {
log() << "changing sync target because current sync target's most recent OpTime is "
<< targetOpTime.toStringPretty() << " which is more than "
<< maxSyncSourceLagSecs << " seconds behind member " << m->fullName()
<< " whose most recent OpTime is " << m->hbinfo().opTime.getSecs();
return true;
}
}
if (gotForceSync()) {
return true;
}
return false;
}
skelPoseAction * skelPoseActionList::addAction(string _name, int _id) {
skelPoseAction * result;
int i = findById(_id);
if(i > -1) {
result = actions[i];
} else {
i = findByName(_name);
if(i > -1) {
result = actions[i];
} else {
result = new skelPoseAction();
result->name = _name;
result->id = _id;
actions.push_back(result);
}
}
return result;
}
/**
* @brief Merge the contents of another Kernels object
*
* This method mergest the contents of another Kernels object into this one.
* Kernels that exist in both instances of the object are handled special.
* The status of this object's version of the file is updated to reflect
* conditions of the other objects kernels.
*
* When the file does not exist in this object, the kernel file structure is
* copied from the other Kernels object, its managed status is set to false
* (since it pre-exists in another object that must relinquish its management
* of it) and is added to this objects kernel list.
*
* When the file does exist in this object, its load status is checked in the
* other Kernels object. If it is loaded according to the other object, it is
* marked as loaded in this object and its managed state is set to unmanaged
* (since it contained in another object, no assumptions can be made as to
* whom and how it came about to be loaded.
*
* The following code fragment demonstrates how to ensure only one Kernels
* object retains complete control of the merged set of kernels:
*
* @code
*
* Kernels master, other;
*
* // ...
*
*
* // Both objects are assumed to contain kenels and some state.
* master.Merge(other);
* other.UnManage();
* master.Manage();
* master.UpdateLoadStatus();
* @endcode
*
* The UpdateLoadStatus() ensures the state of the managed kernel list in
* master is completely up to date.
*
* @param other Other Kenels object containing a separate list of NAIF
* kernels that will be merged with the contents of this object.
*
* @return int Number of kernels added to this object. It does not include
* the count of kernels that are common to both and may have had
* its status modified.
*/
int Kernels::Merge(const Kernels &other) {
int nAdded(0);
for (unsigned int i = 0 ; i < other._kernels.size() ; i++) {
KernelFile *kernel = findByName(other._kernels[i].fullpath);
if (kernel == 0) {
KernelFile kfile = other._kernels[i];
kfile.managed = false;
_kernels.push_back(kfile);
nAdded++;
}
else {
if (other._kernels[i].loaded) {
kernel->loaded = true;
kernel->managed = false;
}
}
}
return (nAdded);
}
FSArchNode* FSArchNode::findByFsPath( FSPath& fsPath, int fsPathLevel )
{
FSString* curName = fsPath.GetItem( fsPathLevel );
if ( parentDir == nullptr
&& fsPathLevel == fsPath.Count() - 1
&& ( curName == nullptr || curName->GetUnicode() == 0 || curName->GetUnicode()[0] == 0 ) )
{
// request to find root node, and we are root
return this;
}
if ( name.Cmp( *curName ) == 0 )
{
if ( fsPath.Count() <= fsPathLevel )
{
// exact match
return this;
}
FSString* childName = fsPath.GetItem( fsPathLevel + 1 );
FSArchNode* n = findByName( *childName );
if ( n == nullptr )
{
return nullptr;
}
if ( fsPath.Count() <= fsPathLevel + 2 )
{
// no further recursion
return n;
}
if ( n->IsDir() )
{
// recurse into subdir
return n->findByFsPath( fsPath, fsPathLevel + 1 );
}
}
return nullptr;
}
//! solve a node, finding it by name
//! @param[in] nameNode name of the node
void AOgraph::solveByName(string nameNode)
{
AOnode* solved = findByName(nameNode);
bool result = solved->setSolved();
updateNodeFeasibility();
printGraphInfo();
// report that the graph has been solved if the solved node is the head node
if (head->nSolved == true)
{
cout<<"[REPORT] The graph is solved (head node solved)." <<endl;
return;
}
// update the path information (cost) of all paths
if (result == true)
updatePaths(*solved);
cout<<endl <<"Updated paths: " <<endl;
for(int i=0; i< (int)pUpdate.size(); i++)
cout<<"Path index: " <<pIndices[i] <<" - Benefit: " <<pUpdate[i] <<endl;
}
bool CDropTarget::DropZoneLostObjectMsg(CDropZoneLostObjectMsg *msg) {
if (!_itemName.empty()) {
CGameObject *obj = dynamic_cast<CGameObject *>(findByName(_itemName));
if (obj) {
if (msg->_object) {
obj->detach();
obj->addUnder(msg->_object);
} else if (dynamic_cast<CCarry *>(obj)) {
obj->petAddToInventory();
}
setVisible(true);
CDropZoneLostObjectMsg lostMsg(this);
lostMsg.execute(obj);
}
loadFrame(_dragFrame);
_cursorId = _dragCursorId;
}
return true;
}
//------------------------------------------------------------------------------
// updateData() - update non time-critical stuff here
//------------------------------------------------------------------------------
void LandingGear::updateData(const double dt)
{
BaseClass::updateData(dt);
// this will store our last value, so we know which way we are going
double lastPos = gearPos;
gearPos = getInstValue();
if (gearPos == gearUV) {
gearState = 0;
inTransit = false;
}
else if (gearPos == gearDV) {
gearState = 1;
inTransit = false;
}
// if we aren't equal to either, we are in transit
else {
inTransit = true;
// we are going towards the gear up value
if (gearPos < lastPos) gearState = 0;
// we are going towards the down value
else if (gearPos > lastPos) gearState = 1;
// if we are equal, we do nothing
}
// now send our select down based on our transition flag and gear pos
int x = 0;
if (gearState == 0 && !inTransit) x = 1;
else if (gearState == 0 && inTransit) x = 2;
else if (gearState == 1 && inTransit) x = 3;
else if (gearState == 1 && !inTransit) x = 4;
send("gearpos", SELECT, x, gearSelSD);
// determine if we have a rotary
base::Pair* pair = (base::Pair*)findByName("gearpos");
if (pair != nullptr) haveRotary = true;
}
DomainPtr DomainCollectionBase::getDomain(const wxString& name)
{
DomainPtr domain = findByName(name);
if (!domain)
{
SubjectLocker lock(this);
DatabasePtr db = getDatabase();
MetadataLoader* loader = db->getMetadataLoader();
MetadataLoaderTransaction tr(loader);
wxMBConv* converter = db->getCharsetConverter();
IBPP::Statement& st1 = loader->getStatement(
Domain::getLoadStatement(false));
st1->Set(1, wx2std(name, converter));
st1->Execute();
if (st1->Fetch())
{
domain = insert(name);
domain->loadProperties(st1, converter);
}
}
return domain;
}
void SplashScreenState::buttonHit(OgreBites::Button *button)
{
if (button->getName() == "SplashBtn")
changeAppState(findByName("GameState"));
}
//Reimplement draw function so that we have control over the order of
//elements, and we can add object labels
//
//The order in which components are drawn naturally determines the
//z-ordering (the layering) of the components. Objects which
//should appear "behind" others should be drawn first.
void SkyMapComposite::draw( SkyPainter *skyp )
{
Q_UNUSED(skyp)
#ifndef KSTARS_LITE
SkyMap *map = SkyMap::Instance();
KStarsData *data = KStarsData::Instance();
// We delay one draw cycle before re-indexing
// we MUST ensure CLines do not get re-indexed while we use DRAW_BUF
// so we do it here.
m_CLines->reindex( &m_reindexNum );
// This queues re-indexing for the next draw cycle
m_reindexNum = KSNumbers( data->updateNum()->julianDay() );
// This ensures that the JIT updates are synchronized for the entire draw
// cycle so the sky moves as a single sheet. May not be needed.
data->syncUpdateIDs();
// prepare the aperture
// FIXME_FOV: We may want to rejigger this to allow
// wide-angle views --hdevalence
float radius = map->projector()->fov();
if ( radius > 180.0 )
radius = 180.0;
if ( m_skyMesh->inDraw() ) {
printf("Warning: aborting concurrent SkyMapComposite::draw()\n");
return;
}
m_skyMesh->inDraw( true );
SkyPoint* focus = map->focus();
m_skyMesh->aperture( focus, radius + 1.0, DRAW_BUF ); // divide by 2 for testing
// create the no-precess aperture if needed
if ( Options::showEquatorialGrid() || Options::showHorizontalGrid() || Options::showCBounds() || Options::showEquator() ) {
m_skyMesh->index( focus, radius + 1.0, NO_PRECESS_BUF );
}
// clear marks from old labels and prep fonts
m_skyLabeler->reset( map );
m_skyLabeler->useStdFont();
// info boxes have highest label priority
// FIXME: REGRESSION. Labeler now know nothing about infoboxes
// map->infoBoxes()->reserveBoxes( psky );
// JM 2016-12-01: Why is this done this way?!! It's too inefficient
if( KStars::Instance() )
{
auto& obsList = KStarsData::Instance()->observingList()->sessionList();
if( Options::obsListText() )
foreach( QSharedPointer<SkyObject> obj_clone, obsList ) {
// Find the "original" obj
SkyObject *o = findByName( obj_clone->name() ); // FIXME: This is sloww.... and can also fail!!!
if ( !o )
continue;
SkyLabeler::AddLabel( o, SkyLabeler::RUDE_LABEL );
}
}
bool SymbolTable::isDefined(StringRef sym) {
if (const Atom *atom = findByName(sym))
return atom->definition() != Atom::definitionUndefined;
return false;
}
bool SymbolTable::addByName(const Atom &newAtom) {
StringRef name = newAtom.name();
assert(!name.empty());
const Atom *existing = findByName(name);
if (existing == nullptr) {
// Name is not in symbol table yet, add it associate with this atom.
_nameTable[name] = &newAtom;
return true;
}
// Do nothing if the same object is added more than once.
if (existing == &newAtom)
return false;
// Name is already in symbol table and associated with another atom.
bool useNew = true;
switch (collide(existing->definition(), newAtom.definition())) {
case NCR_First:
useNew = false;
break;
case NCR_Second:
useNew = true;
break;
case NCR_DupDef:
assert(existing->definition() == Atom::definitionRegular);
assert(newAtom.definition() == Atom::definitionRegular);
switch (mergeSelect(((DefinedAtom*)existing)->merge(),
((DefinedAtom*)&newAtom)->merge())) {
case MCR_First:
useNew = false;
break;
case MCR_Second:
useNew = true;
break;
case MCR_Largest: {
uint64_t existingSize = sectionSize((DefinedAtom*)existing);
uint64_t newSize = sectionSize((DefinedAtom*)&newAtom);
useNew = (newSize >= existingSize);
break;
}
case MCR_SameSize: {
uint64_t existingSize = sectionSize((DefinedAtom*)existing);
uint64_t newSize = sectionSize((DefinedAtom*)&newAtom);
if (existingSize == newSize) {
useNew = true;
break;
}
llvm::errs() << "Size mismatch: "
<< existing->name() << " (" << existingSize << ") "
<< newAtom.name() << " (" << newSize << ")\n";
// fallthrough
}
case MCR_Error:
if (!_context.getAllowDuplicates()) {
llvm::errs() << "Duplicate symbols: "
<< existing->name()
<< ":"
<< existing->file().path()
<< " and "
<< newAtom.name()
<< ":"
<< newAtom.file().path()
<< "\n";
llvm::report_fatal_error("duplicate symbol error");
}
useNew = false;
break;
}
break;
case NCR_DupUndef: {
const UndefinedAtom* existingUndef = cast<UndefinedAtom>(existing);
const UndefinedAtom* newUndef = cast<UndefinedAtom>(&newAtom);
bool sameCanBeNull = (existingUndef->canBeNull() == newUndef->canBeNull());
if (!sameCanBeNull &&
_context.warnIfCoalesableAtomsHaveDifferentCanBeNull()) {
llvm::errs() << "lld warning: undefined symbol "
<< existingUndef->name()
<< " has different weakness in "
<< existingUndef->file().path()
<< " and in " << newUndef->file().path() << "\n";
}
const UndefinedAtom *existingFallback = existingUndef->fallback();
const UndefinedAtom *newFallback = newUndef->fallback();
bool hasDifferentFallback =
(existingFallback && newFallback &&
existingFallback->name() != newFallback->name());
if (hasDifferentFallback) {
llvm::errs() << "lld warning: undefined symbol "
<< existingUndef->name() << " has different fallback: "
<< existingFallback->name() << " in "
<< existingUndef->file().path() << " and "
<< newFallback->name() << " in "
<< newUndef->file().path() << "\n";
}
bool hasNewFallback = newUndef->fallback();
if (sameCanBeNull)
useNew = hasNewFallback;
else
useNew = (newUndef->canBeNull() < existingUndef->canBeNull());
break;
}
case NCR_DupShLib: {
const SharedLibraryAtom *curShLib = cast<SharedLibraryAtom>(existing);
const SharedLibraryAtom *newShLib = cast<SharedLibraryAtom>(&newAtom);
bool sameNullness =
(curShLib->canBeNullAtRuntime() == newShLib->canBeNullAtRuntime());
bool sameName = curShLib->loadName().equals(newShLib->loadName());
if (sameName && !sameNullness &&
_context.warnIfCoalesableAtomsHaveDifferentCanBeNull()) {
// FIXME: need diagonstics interface for writing warning messages
llvm::errs() << "lld warning: shared library symbol "
<< curShLib->name() << " has different weakness in "
<< curShLib->file().path() << " and in "
<< newShLib->file().path();
}
if (!sameName && _context.warnIfCoalesableAtomsHaveDifferentLoadName()) {
// FIXME: need diagonstics interface for writing warning messages
llvm::errs() << "lld warning: shared library symbol "
<< curShLib->name() << " has different load path in "
<< curShLib->file().path() << " and in "
<< newShLib->file().path();
}
useNew = false;
break;
}
case NCR_Error:
llvm::errs() << "SymbolTable: error while merging " << name << "\n";
llvm::report_fatal_error("duplicate symbol error");
break;
}
if (useNew) {
// Update name table to use new atom.
_nameTable[name] = &newAtom;
// Add existing atom to replacement table.
_replacedAtoms[existing] = &newAtom;
} else {
// New atom is not being used. Add it to replacement table.
_replacedAtoms[&newAtom] = existing;
}
return false;
}
// Given a notebook's name as a QString, we return the lid
qint32 LinkedNotebookTable::findByName(QString &name) {
string n = name.toStdString();
return findByName(n);
}
void SupernovaeComponent::loadData()
{
QString serialNo, hostGalaxy, date, type, offset, SNPosition, discoverers ;
dms ra, dec;
float magnitude;
qDebug()<<"Loading Supernovae data";
//m_ObjectList.clear();
latest.clear();
objectNames(SkyObject::SUPERNOVA).clear();
KStarsData *m_data = KStarsData::Instance(); // to convert equatorial coordinate to horizontal
//SN ,Host Galaxy ,Date , R.A. , Decl., Offset ,Mag., Disc. Ref. , SN Position , Posn. Ref. ,Typ, SN ,Discoverer(s)
QList< QPair<QString,KSParser::DataTypes> > sequence;
sequence.append(qMakePair(QString("serialNo"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("hostGalaxy"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("date"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("ra"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("dec"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("offset"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("magnitude"), KSParser::D_FLOAT));
sequence.append(qMakePair(QString("ignore1"), KSParser::D_SKIP));
sequence.append(qMakePair(QString("SNPosition"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("ignore2"), KSParser::D_SKIP));
sequence.append(qMakePair(QString("type"), KSParser::D_QSTRING));
sequence.append(qMakePair(QString("ignore3"), KSParser::D_SKIP));
sequence.append(qMakePair(QString("discoverers"), KSParser::D_QSTRING));
QString file_name = QStandardPaths::locate(QStandardPaths::DataLocation,
QString("supernovae.dat"));
KSParser snParser(file_name, '#', sequence);
QHash<QString, QVariant> row_content;
while (snParser.HasNextRow()){
Supernova *sup=0;
row_content = snParser.ReadNextRow();
if(row_content["serialNo"].toString() == "Null")
continue;
serialNo = row_content["serialNo"].toString().trimmed();
hostGalaxy = row_content["hostGalaxy"].toString();
date = row_content["date"].toString();
ra = dms(row_content["ra"].toString(), false);
dec = dms(row_content["dec"].toString());
offset = row_content["offset"].toString();
magnitude = row_content["magnitude"].toFloat();
SNPosition = row_content["SNPosition"].toString();
type = row_content["type"].toString();
discoverers = row_content["discoverers"].toString();
if (magnitude == KSParser::EBROKEN_FLOAT)
magnitude = 99.9;
sup=new Supernova(ra, dec, date, magnitude, serialNo, type, hostGalaxy, offset, discoverers);
sup->EquatorialToHorizontal(m_data->lst(),m_data->geo()->lat());
if (!m_ObjectList.empty())
{
if ( findByName(sup->name() ) == 0 )
{
//qDebug()<<"List of supernovae not empty. Found new supernova";
m_ObjectList.append(sup);
latest.append(sup);
}/*
else
m_ObjectList.append(sup);*/
}
else //if the list is empty
{
m_ObjectList.append(sup);
latest.append(sup);
//notifyNewSupernovae();
}
objectNames(SkyObject::SUPERNOVA).append(sup->name());
}
//notifyNewSupernovae();
}
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;
}
void AccountingSelector::insertDir(QDir d, QListViewItem *root) {
QListViewItem* tli = 0;
// sanity check
if(!d.exists() || !d.isReadable())
return;
// set up filter
d.setNameFilter("*.rst");
d.setFilter(QDir::Files);
d.setSorting(QDir::Name);
// read the list of files
const QFileInfoList_qt3 *list = d.entryInfoList_qt3();
QFileInfoListIterator it( *list );
QFileInfo *fi;
// traverse the list and insert into the widget
while((fi = it.current())) {
++it;
QString samename = fi->fileName();
QListViewItem *i = findByName(samename);
// skip this file if already in tree
if(i)
continue;
// check if this is the file we should mark
QString name = fileNameToName(fi->baseName(true));
if(root)
tli = new QListViewItem(root, name);
else
tli = new QListViewItem(tl, name);
tli->setPixmap(0, pmfile);
// check if this is the item we are searching for
// (only in "Edit"-mode, not in "New"-mode
if(!isnewaccount && !edit_s.isEmpty() &&
(edit_s == QString(fi->filePath()).right(edit_s.length()))) {
edit_item = tli;
}
}
// set up a filter for the directories
d.setFilter(QDir::Dirs);
d.setNameFilter("*");
const QFileInfoList_qt3 *dlist = d.entryInfoList_qt3();
QFileInfoListIterator dit(*dlist);
while((fi = dit.current())) {
// skip "." and ".." directories
if(fi->fileName().left(1) != ".") {
// convert to human-readable name
QString name = fileNameToName(fi->fileName());
// if the tree already has an item with this name,
// skip creation and use this one, otherwise
// create a new entry
QListViewItem *i = findByName(name);
if(!i) {
QListViewItem* item;
if(root)
item = new QListViewItem(root, name);
else
item = new QListViewItem(tl, name);
item->setPixmap(0, pmfolder);
insertDir(QDir(fi->filePath()), item);
} else
insertDir(QDir(fi->filePath()), i);
}
++dit;
}
}
