Geant4 Visualization : Qt Driver

Developments for Geant4.9.4

Geant4 Workshop

Laurent Garnier

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Viewer and UI integration

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Rotations

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Meta Keys

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Speed improvments in OpenGL drivers

Loose time when moving a component is in visualization part. Thank to Shark (mac OSX), I identify two bootle neck : glBegin (47% of OGL time) and glFlush (44%). After some code optimisations :

Mac OSX 10.5 : Immediate Mode

	First draw time (sec)	Mem (Mo)	Rotation (fps)
Geant 4.9.3	5	45	0,46
Geant 4.9.4	6	48	0,53

Mac OSX 10.6 : Immediate Mode


Geant 4.9.3	5	40	0,6
Geant 4.9.4	6	40(=)	0,6

Mac OSX 10.5 : Stored Mode

Geant 4.9.3	94	270	1,2
Geant 4.9.4	72 (x1,3)	270 (=)	2,66 (x2,2)

Mac OSX 10.6 : Stored Mode

Geant 4.9.3	13	227	3,73
Geant 4.9.4	11 (x1,2)	210 (-5%)	5,3 (x1,43)

Speed improvments in OpenGL drivers

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Make posters

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Developpement on all platforms

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Qt configuration problems

Viewer and UI integration
Rotations
Meta Keys
Speed improvments in OpenGL drivers
Make posters
Developpement on all platforms
Qt configuration problems
Make an Geant4 application on mac

Make an Geant4 application on mac

Organisation

La librarie STL est organisée en plusieurs parties. Il existe principalement 3 types d'éléments

Les conteneurs
Permettent de contenir des données
Les itérateurs
Permettent aux algorithmes de manipuler les conteneurs : récupérer une donnée et passer à la suivante
Les algorithmes
Permettent de manipuler les données d'un conteneur en accédant aux données via les itérateurs

On ajoute

Les strings
Qui définissent les chaines de caractères comme type normal (copie, assignation, comparaison,...)

Conteneurs

Il s'agit de structures algorithmiques permettant :
- d'organiser un ensemble de données de même type en séquence,
- puis de parcourir ces données
Exemples :
- les listes (std::list)
- les tableaux (std::vector)
- les listes triées (std::set)
- les listes d'associations (std::map)
La définition d'un conteneur est indépendante du type des objets contenus
On spécifie ce qu'il contient lors de la déclaration de la variable
Allocation dynamique et automatique de la mémoire

Conteneurs ...

Ordonnés (position indépendante de la valeur)

List : liste doublement chaînée
Vector : tableau à 1 dimension

Triés (position dépendante de la valeur)

Set/Multiset : ensemble
Map/Multimap : tableau associatif

List

Utilisation des listes

 #include <iostream>
 #include <list>

 int main()
 {
   std::list<int> l;
 
   l.push_front(3);
   l.push_front(2);
   l.push_back(4);
 
   l.pop_front();
   l.pop_back();
 
   std::cout << l.front() << std::endl;
   std::cout << l.back()  << std::endl;
 
   return 0;
 }

List

Comme pour tous les composants STL, il faut toujours se placer dans l'espace de nommage std::

 #include <iostream>
 #include <list>

 int main()
 {
   std::list<int> l;
 
   l.push_front(3);
   l.push_front(2);
   l.push_back(4);
 
   l.pop_front();
   l.pop_back();
 
   std::cout << l.front() << std::endl;
   std::cout << l.back()  << std::endl;
 
   return 0;
 }

List

Insère un élément dans la liste

 #include <iostream>
 #include <list>

 int main()
 {
   std::list<int> l;
 
   l.push_front(3);
   l.push_front(2);
   l.push_back(4);
 
   l.pop_front();
   l.pop_back();
 
   std::cout << l.front() << std::endl;
   std::cout << l.back()  << std::endl;
 
   return 0;
 }

List

Retire un élément de la liste

 #include <iostream>
 #include <list>

 int main()
 {
   std::list<int> l;
 
   l.push_front(3);
   l.push_front(2);
   l.push_back(4);
 
   l.pop_front();
   l.pop_back();
 
   std::cout << l.front() << std::endl;
   std::cout << l.back()  << std::endl;
 
   return 0;
 }

List

Accède à un élément de la liste

 #include <iostream>
 #include <list>

 int main()
 {
   std::list<int> l;
 
   l.push_front(3);
   l.push_front(2);
   l.push_back(4);
 
   l.pop_front();
   l.pop_back();
 
   std::cout << l.front() << std::endl;
   std::cout << l.back()  << std::endl;
 
   return 0;
 }

Vector

Utilisation des vecteurs

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Vector

Insère un élément dans le vecteur

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Vector

Accède au 1er élément

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Vector

Modifie le 2è élément

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Vector

Accède au dernier élément du vecteur

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Vector

Supprime tous les éléments

 #include <iostream>
 #include <vector>
 
 int main()
 {
   std::vector<int> v;
 
   v.push_back(3);
   v.push_back(4);
 
   std::cout << v[0] << std::endl;
 
   v.at( 1 ) = 5;
   std::cout << v.back() << std::endl;
  
   v.clear();
   return 0;
 }

Quelques méthodes communes

Vider le conteneur :
- void clear();
  appelle le destructeur pour chaque objet dans le conteneur
  désalloue la mémoire utilisée
Retourner le nombre d'éléments :
- int size();
Tester si le conteneur est vide :
- bool empty();

Itérateurs

C'est une généralisation de la notion de pointeur.
Il permet de parcourir en séquence les éléments d'un conteneur sans avoir à se préoccuper du type du conteneur.

 #include <vector>
 {
   std::vector<int> v;
   // 
  std::vector<int>::iterator it1 = v.begin();
  std::vector<int>::iterator it2 = v.end();
 }

Itérateurs

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);    
   }  
 
   std::list<int>::iterator it;  
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;      
    std::cout << "i = " << i << std::endl;    
   }
   return (0);
 }

Itérateurs

Déclaration

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);
   }
 
   std::list<int>::iterator it;
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;
    std::cout << "i = " << i << std::endl;
   }
   return (0);
 }

Itérateurs

1er élément

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);    
   }  
 
   std::list<int>::iterator it;  
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;      
    std::cout << "i = " << i << std::endl;    
   }
   return (0);
 }

Itérateurs

Pointe après le dernier élément

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);    
   }  
 
   std::list<int>::iterator it;  
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;      
    std::cout << "i = " << i << std::endl;    
   }
   return (0);
 }

Itérateurs

On incrémente l'itérateur

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);    
   }  
 
   std::list<int>::iterator it;  
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;      
    std::cout << "i = " << i << std::endl;    
   }
   return (0);
 }

Itérateurs

On accède à l'élément par déréférencement

 #include <iostream>
 #include <list>
 
 int main()
 {
   std::list<int> liste;
 
   for (unsigned int i = 0; i < 10; i++) {
     liste.push_back(i);    
   }  
 
   std::list<int>::iterator it;  
   for (it = liste.begin(); it != liste.end(); ++it) {
    int i = *it;      
    std::cout << "i = " << i << std::endl;    
   }
   return (0);
 }

Choisir un conteneur

List :
- si on a besoin d'insérer ou de supprimer au milieu
- insertion en temps constant
- accès au n-ième élément en itérant depuis le 1er
Vector :
- si on a besoin d'accéder au n-ième élément
- insertion et suppression peuvent être coûteuses
- très efficace lorsqu'on a à parcourir le conteneur
Map :
- listes associatives
- listes maintenues triées lors de l'insertion de nouveaux éléments

Questions ?