PhysicalModel.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2021 Univ. Grenoble Alpes, CNRS, Grenoble INP, TIMC, 38000 Grenoble, France
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/
 
#ifndef PHYSICALMODEL_H
#define PHYSICALMODEL_H
 
//pmlschema forward declaration
namespace physicalModel {
class PhysicalModel;
class Atoms;
class ExclusiveComponent;
class InformativeComponent;
class MultiComponent;
}
 
#include "PhysicalModelIO.h"
#include <string>
#include <memory>
#include <algorithm>
#include "PMLAbortException.h"
#include "StructuralComponent.h" // so we can put the optimized getAtom method inline
#include "Atom.h" // so we can put the optimized getAtom method inline
#include "Cell.h" // so we can put the optimized getCell method inline
 
 
class MultiComponent;
class Component;
class Cell;
class Structure;
 
 
// Hide warning for Exception + declspec(nothrow)
#if defined(_WIN32) && !defined(__MINGW32__) // MSVC only
#pragma warning( disable : 4290 )
#endif // MSVC only
 
using PtrToSetProgressFunction = void (*)(const float donePercentage);
 
namespace std {
using GlobalIndexStructurePair = std::pair<unsigned int, Structure*>;
using GlobalIndexStructureMap = std::map <unsigned int, Structure*>;
using GlobalIndexStructureMapIterator = std::map <unsigned int, Structure*> ::iterator;
}
 
 
class PhysicalModel {
 
public:
    PhysicalModel() noexcept;
 
    PhysicalModel(const char* fileName, PtrToSetProgressFunction pspf = nullptr);
 
    virtual ~PhysicalModel();
    static const char* VERSION;
 
    const std::string getName() const;
    void setName(const std::string);
    Properties* getProperties();
    bool isModified();
    void setModified();
 
    void xmlPrint(std::ostream& o, bool opt = false);
 
    void exportPatran(std::string filename);
 
    void exportAnsysMesh(std::string filename);
 
    unsigned int getNumberOfExclusiveComponents() const;
 
    unsigned int getNumberOfInformativeComponents() const;
 
    unsigned int getNumberOfAtoms() const;
 
    unsigned int getNumberOfCells() const;
 
    Component* getExclusiveComponent(const unsigned int) const;
 
    void setExclusiveComponents(MultiComponent*);
 
    MultiComponent* getExclusiveComponents() const;
 
    MultiComponent* getInformativeComponents() const;
 
    StructuralComponent* getAtoms() const;
 
    Component* getInformativeComponent(const unsigned int) const;
 
    void setInformativeComponents(MultiComponent*);
 
    void setAtoms(StructuralComponent*, bool deleteOld = true);
 
    bool addAtom(Atom*);
 
    Atom* getAtom(const unsigned int id);
 
    bool addGlobalIndexAtomPair(std::GlobalIndexStructurePair);
 
    bool addGlobalIndexCellPair(std::GlobalIndexStructurePair);
 
    Cell* getCell(const unsigned int id);
 
    Structure* getStructureByName(const std::string n);
 
    Component* getComponentByName(const std::string n);
 
    virtual void setProgress(const float donePercentage);
 
    virtual void setAtomPosition(Atom* atom, const double pos[3]);
 
    double* getPositionPointer() const;
 
    double* getPositionPointer(const unsigned int index) const;
 
    double* getPositionPointer(const Atom* a) const;
 
 
private:
    void xmlRead(const char* n);
 
    bool parseTree(std::unique_ptr<physicalModel::PhysicalModel> root, std::string defaultName);
    bool parseAtoms(physicalModel::Atoms atomsRoot);
    bool parseComponents(physicalModel::MultiComponent mcFather, Component* father, bool isExclusive);
 
    Properties* properties;
 
    bool isModifiedFlag;
 
    MultiComponent* exclusiveComponents;
 
    MultiComponent* informativeComponents;
 
    StructuralComponent* atoms;
 
    void clear();
 
    std::GlobalIndexStructureMap cellMap;
 
    std::vector <Cell*> optimizedCellList;
 
    bool cellIndexOptimized;
 
    void optimizeIndexes();
 
    void optimizeIndexes(MultiComponent*, unsigned int*);
 
    std::GlobalIndexStructureMap atomMap;
 
    void init();
 
    PtrToSetProgressFunction setProgressFunction;
 
    double* positionPtr;
};
 
 
// ------------------ simple inline functions ------------------
inline Properties* PhysicalModel::getProperties() {
    return properties;
}
 
inline const std::string PhysicalModel::getName() const {
    return properties->getName();
}
 
inline void PhysicalModel::setName(const std::string n) {
    properties->setName(n);
}
 
inline bool PhysicalModel::isModified() {
    return isModifiedFlag;
}
 
inline void PhysicalModel::setModified() {
    isModifiedFlag = true;
}
 
inline MultiComponent* PhysicalModel::getExclusiveComponents() const {
    return exclusiveComponents;
}
inline MultiComponent* PhysicalModel::getInformativeComponents() const {
    return informativeComponents;
}
inline StructuralComponent* PhysicalModel::getAtoms() const {
    return atoms;
}
 
// ------------------ getAtom ------------------
inline Atom* PhysicalModel::getAtom(const unsigned int id) {
 
    // optimization: first check if the order is the structure is not the same
    // as the atom index (which is the case very often)
    Atom* quickAccessed = dynamic_cast<Atom*>(atoms->getStructure(id));
 
    if (quickAccessed && quickAccessed->getIndex() == id) {
        return quickAccessed;
    }
    else {
        // if not then check if it could be found in the map
        std::GlobalIndexStructureMapIterator mapIt; // a representation map iterator
        mapIt = atomMap.find(id);
 
        // search in the map, and return the correct result
        return ((mapIt == atomMap.end()) ? nullptr : (Atom*) mapIt->second);
    }
}
 
// ------------------ getCell ------------------
inline Cell* PhysicalModel::getCell(const unsigned int cellIndex) {
    if (cellIndexOptimized) {
        return optimizedCellList[cellIndex];
    }
    else {
        std::GlobalIndexStructureMapIterator mapIt; // a representation map iterator
 
        // check if it was find in the list
        mapIt = cellMap.find(cellIndex);
 
        // search in the map, and return the correct result
        return ((mapIt == cellMap.end()) ? nullptr : (Cell*) mapIt->second);
    }
}
 
// ------------------ getStructureByName ------------------
inline Structure* PhysicalModel::getStructureByName(const std::string n) {
    // look for structures into the global maps
 
    // look for a cell with this name
    auto mapIt = cellMap.begin();
 
    while (mapIt != cellMap.end() && mapIt->second->getName() != n) {
        mapIt++;
    }
 
    // if found returns it
    if (mapIt != cellMap.end()) {
        return mapIt->second;
    }
 
    // look now in the atoms
    mapIt = atomMap.begin();
 
    while (mapIt != atomMap.end() && mapIt->second->getName() != n) {
        mapIt++;
    }
 
    // if found returns it
    if (mapIt != atomMap.end()) {
        return mapIt->second;
    }
 
    return nullptr;
}
 
#endif