Computer Assisted Medical Intervention Tool Kit  version 5.1
 
Loading...
Searching...
No Matches
PhysicalModel.h
Go to the documentation of this file.
1/*****************************************************************************
2 * $CAMITK_LICENCE_BEGIN$
3 *
4 * CamiTK - Computer Assisted Medical Intervention ToolKit
5 * (c) 2001-2023 Univ. Grenoble Alpes, CNRS, Grenoble INP, TIMC, 38000 Grenoble, France
6 *
7 * Visit http://camitk.imag.fr for more information
8 *
9 * This file is part of CamiTK.
10 *
11 * CamiTK is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * CamiTK is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * version 3 along with CamiTK. If not, see <http://www.gnu.org/licenses/>.
22 *
23 * $CAMITK_LICENCE_END$
24 ****************************************************************************/
25
26#ifndef PHYSICALMODEL_H
27#define PHYSICALMODEL_H
28
29//pmlschema forward declaration
30namespace physicalModel {
31class PhysicalModel;
32class Atoms;
33class ExclusiveComponent;
34class InformativeComponent;
35class MultiComponent;
36}
37
38#include "PhysicalModelIO.h"
39#include <string>
40#include <memory>
41#include <algorithm>
42#include "PMLAbortException.h"
43#include "StructuralComponent.h" // so we can put the optimized getAtom method inline
44#include "Atom.h" // so we can put the optimized getAtom method inline
45#include "Cell.h" // so we can put the optimized getCell method inline
46
47
48class MultiComponent;
49class Component;
50class Cell;
51class Structure;
52
53
54// Hide warning for Exception + declspec(nothrow)
55#if defined(_WIN32) && !defined(__MINGW32__) // MSVC only
56#pragma warning( disable : 4290 )
57#endif // MSVC only
58
60using PtrToSetProgressFunction = void (*)(const float donePercentage);
61
62namespace std {
66using GlobalIndexStructurePair = std::pair<unsigned int, Structure*>;
71using GlobalIndexStructureMap = std::map <unsigned int, Structure*>;
73using GlobalIndexStructureMapIterator = std::map <unsigned int, Structure*> ::iterator;
74}
75
76
87
88public:
95 PhysicalModel() noexcept;
96
104 PhysicalModel(const char* fileName, PtrToSetProgressFunction pspf = nullptr);
105
107 virtual ~PhysicalModel();
109 static const char* VERSION;
111
116 const std::string getName() const;
118 void setName(const std::string);
125 bool isModified();
129 void setModified();
131
145 void xmlPrint(std::ostream& o, bool opt = false);
146
154 void exportPatran(std::string filename);
155
163 void exportAnsysMesh(std::string filename);
165
170 unsigned int getNumberOfExclusiveComponents() const;
171
173 unsigned int getNumberOfInformativeComponents() const;
174
176 unsigned int getNumberOfAtoms() const;
177
179 unsigned int getNumberOfCells() const;
180
182 Component* getExclusiveComponent(const unsigned int) const;
183
186
189
192
195
197 Component* getInformativeComponent(const unsigned int) const;
198
201
207 void setAtoms(StructuralComponent*, bool deleteOld = true);
208
214 bool addAtom(Atom*);
215
228 Atom* getAtom(const unsigned int id);
229
235
241
246 Cell* getCell(const unsigned int id);
247
249 Structure* getStructureByName(const std::string n);
250
255 Component* getComponentByName(const std::string n);
256
261 virtual void setProgress(const float donePercentage);
262
265 virtual void setAtomPosition(Atom* atom, const double pos[3]);
266
271 double* getPositionPointer() const;
272
274 double* getPositionPointer(const unsigned int index) const;
275
277 double* getPositionPointer(const Atom* a) const;
279
280
281private:
286 void xmlRead(const char* n);
287
289 bool parseTree(std::unique_ptr<physicalModel::PhysicalModel> root, std::string defaultName);
291 bool parseAtoms(physicalModel::Atoms atomsRoot);
293 bool parseComponents(physicalModel::MultiComponent mcFather, Component* father, bool isExclusive);
294
296 Properties* properties;
297
299 bool isModifiedFlag;
300
306 MultiComponent* exclusiveComponents;
307
313 MultiComponent* informativeComponents;
314
318 StructuralComponent* atoms;
319
321 void clear();
322
325
327 std::vector <Cell*> optimizedCellList;
328
330 bool cellIndexOptimized;
331
334 void optimizeIndexes();
335
337 void optimizeIndexes(MultiComponent*, unsigned int*);
338
341
343 void init();
344
346 PtrToSetProgressFunction setProgressFunction;
347
349 double* positionPtr;
350};
351
352
353// ------------------ simple inline functions ------------------
355 return properties;
356}
357
358inline const std::string PhysicalModel::getName() const {
359 return properties->getName();
360}
361
362inline void PhysicalModel::setName(const std::string n) {
363 properties->setName(n);
364}
365
367 return isModifiedFlag;
368}
369
371 isModifiedFlag = true;
372}
373
375 return exclusiveComponents;
376}
378 return informativeComponents;
379}
381 return atoms;
382}
383
384// ------------------ getAtom ------------------
385inline Atom* PhysicalModel::getAtom(const unsigned int id) {
386
387 // optimization: first check if the order is the structure is not the same
388 // as the atom index (which is the case very often)
389 Atom* quickAccessed = dynamic_cast<Atom*>(atoms->getStructure(id));
390
391 if (quickAccessed && quickAccessed->getIndex() == id) {
392 return quickAccessed;
393 }
394 else {
395 // if not then check if it could be found in the map
396 std::GlobalIndexStructureMapIterator mapIt; // a representation map iterator
397 mapIt = atomMap.find(id);
398
399 // search in the map, and return the correct result
400 return ((mapIt == atomMap.end()) ? nullptr : (Atom*) mapIt->second);
401 }
402}
403
404// ------------------ getCell ------------------
405inline Cell* PhysicalModel::getCell(const unsigned int cellIndex) {
406 if (cellIndexOptimized) {
407 return optimizedCellList[cellIndex];
408 }
409 else {
410 std::GlobalIndexStructureMapIterator mapIt; // a representation map iterator
411
412 // check if it was find in the list
413 mapIt = cellMap.find(cellIndex);
414
415 // search in the map, and return the correct result
416 return ((mapIt == cellMap.end()) ? nullptr : (Cell*) mapIt->second);
417 }
418}
419
420// ------------------ getStructureByName ------------------
421inline Structure* PhysicalModel::getStructureByName(const std::string n) {
422 // look for structures into the global maps
423
424 // look for a cell with this name
425 auto mapIt = cellMap.begin();
426
427 while (mapIt != cellMap.end() && mapIt->second->getName() != n) {
428 mapIt++;
429 }
430
431 // if found returns it
432 if (mapIt != cellMap.end()) {
433 return mapIt->second;
434 }
435
436 // look now in the atoms
437 mapIt = atomMap.begin();
438
439 while (mapIt != atomMap.end() && mapIt->second->getName() != n) {
440 mapIt++;
441 }
442
443 // if found returns it
444 if (mapIt != atomMap.end()) {
445 return mapIt->second;
446 }
447
448 return nullptr;
449}
450
451#endif
#define a
void(*)(const float donePercentage) PtrToSetProgressFunction
Definition of a function/method that could be called by the setProgress method.
Definition PhysicalModel.h:60
An atom has an unique index in the physical model object, a 3D position, and different basic properti...
Definition Atom.h:49
A cell has an unique index in the physical model object, is composed by atoms, and different basic pr...
Definition Cell.h:46
A component is something that composed something and could also be a part of something.
Definition modeling/libraries/pml/Component.h:48
A multi-component stores other components, hence providing a way to have an tree representation of co...
Definition MultiComponent.h:44
This is the main class of this project.
Definition PhysicalModel.h:86
void setModified()
tell the physical model something has changed (for example: a property was modified/added).
Definition PhysicalModel.h:370
virtual ~PhysicalModel()
destructor
Definition PhysicalModel.cpp:67
unsigned int getNumberOfAtoms() const
get the number of atoms
Definition PhysicalModel.cpp:716
Properties * getProperties()
get all properties (beware of what you do with them!): please consider calling setModified().
Definition PhysicalModel.h:354
bool isModified()
check if something have changed
Definition PhysicalModel.h:366
void exportPatran(std::string filename)
Save the geometry (atoms/cells) of this PhysicalModel in the Patran format.
Definition PhysicalModel.cpp:896
double * getPositionPointer() const
get the pointer to the memory space allocated for the atom's position.
Definition PhysicalModel.cpp:145
Cell * getCell(const unsigned int id)
get the cell that has the global index given in parameters.
Definition PhysicalModel.h:405
unsigned int getNumberOfCells() const
get the total nr of cell in the physical model (exclusive as well as informative)
Definition PhysicalModel.cpp:130
Component * getInformativeComponent(const unsigned int) const
get an informative component by its index in the list
Definition PhysicalModel.cpp:736
PhysicalModel() noexcept
Default constructor : this one just initialize everything.
Definition PhysicalModel.cpp:54
Structure * getStructureByName(const std::string n)
get a cell using its name
Definition PhysicalModel.h:421
void setName(const std::string)
set the name of the physical model
Definition PhysicalModel.h:362
bool addGlobalIndexAtomPair(std::GlobalIndexStructurePair)
add or update a pair to the atom map.
Definition PhysicalModel.cpp:605
Atom * getAtom(const unsigned int id)
Get the atom that has the global index given in parameters.
Definition PhysicalModel.h:385
virtual void setProgress(const float donePercentage)
this method is called during a long process everytime a little bit of the process is finished.
Definition PhysicalModel.cpp:84
virtual void setAtomPosition(Atom *atom, const double pos[3])
Set the new position of an atom.
Definition PhysicalModel.cpp:671
MultiComponent * getExclusiveComponents() const
get all the exclusive components
Definition PhysicalModel.h:374
unsigned int getNumberOfInformativeComponents() const
get the total number of informative components
Definition PhysicalModel.cpp:706
bool addAtom(Atom *)
Add a new atom to the atoms' structural component.
Definition PhysicalModel.cpp:592
Component * getComponentByName(const std::string n)
get a structural or multi component by its name.
Definition PhysicalModel.cpp:553
void xmlPrint(std::ostream &o, bool opt=false)
print the physical model to an output stream in a XML format (see physicalmodel.xsd for detail about ...
Definition PhysicalModel.cpp:258
const std::string getName() const
Return the name of the physical model.
Definition PhysicalModel.h:358
unsigned int getNumberOfExclusiveComponents() const
get the total number of exclusive components
Definition PhysicalModel.cpp:696
Component * getExclusiveComponent(const unsigned int) const
get an exclusive component by its index in the list
Definition PhysicalModel.cpp:726
void setExclusiveComponents(MultiComponent *)
set the exclusive multi component. Becareful: the physical model takes control of this MultiComponent
Definition PhysicalModel.cpp:676
StructuralComponent * getAtoms() const
get all the atoms
Definition PhysicalModel.h:380
bool addGlobalIndexCellPair(std::GlobalIndexStructurePair)
add or update a pair to the cell map.
Definition PhysicalModel.cpp:633
void setAtoms(StructuralComponent *, bool deleteOld=true)
set the atom structural component.
Definition PhysicalModel.cpp:572
void setInformativeComponents(MultiComponent *)
set the exclusive multi component. Becareful: the physical model takes control of this MultiComponent
Definition PhysicalModel.cpp:686
static const char * VERSION
Current PML library version.
Definition PhysicalModel.h:109
MultiComponent * getInformativeComponents() const
get all the informative components
Definition PhysicalModel.h:377
void exportAnsysMesh(std::string filename)
Save the mesh (atoms/cells) of this PhysicalModel in the Ansys format.
Definition PhysicalModel.cpp:747
Describes the properties common to all structures and components.
Definition Properties.h:59
std::string getName() const
get the name (be careful, this method DOES NOT return a copy, so you got the direct ptr to the name!...
Definition Properties.h:250
void setName(std::string)
set the name (use the string = operator)
Definition Properties.h:254
A structural component is composed either by cell or by atoms.
Definition StructuralComponent.h:52
Structure * getStructure(const unsigned int) const
get a structure by its index (fisrt structure is at index 0)
Definition StructuralComponent.h:220
Pure virtual class that represent an element of the structure.
Definition Structure.h:43
unsigned int getIndex() const
get the structure unique index (stored in its property)
Definition Structure.cpp:30
Definition Atom.h:36
STL namespace.
std::map< unsigned int, Structure * > ::iterator GlobalIndexStructureMapIterator
the iterator corresponding to GlobalIndexStructureMap
Definition PhysicalModel.h:73
std::pair< unsigned int, Structure * > GlobalIndexStructurePair
definition of a couple (=STL pair) (int , Structure *) this associates a global cell/atom index to th...
Definition PhysicalModel.h:66
std::map< unsigned int, Structure * > GlobalIndexStructureMap
definition of the association set (=map in STL) globalIndexStructureMap.
Definition PhysicalModel.h:71